FFmpeg
mux.c
Go to the documentation of this file.
1 /*
2  * muxing functions for use within FFmpeg
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "avformat.h"
23 #include "internal.h"
24 #include "libavcodec/internal.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/dict.h"
27 #include "libavutil/pixdesc.h"
28 #include "libavutil/timestamp.h"
29 #include "libavutil/avassert.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/internal.h"
32 #include "libavutil/mathematics.h"
33 
34 /**
35  * @file
36  * muxing functions for use within libavformat
37  */
38 
39 /* fraction handling */
40 
41 /**
42  * f = val + (num / den) + 0.5.
43  *
44  * 'num' is normalized so that it is such as 0 <= num < den.
45  *
46  * @param f fractional number
47  * @param val integer value
48  * @param num must be >= 0
49  * @param den must be >= 1
50  */
51 static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
52 {
53  num += (den >> 1);
54  if (num >= den) {
55  val += num / den;
56  num = num % den;
57  }
58  f->val = val;
59  f->num = num;
60  f->den = den;
61 }
62 
63 /**
64  * Fractional addition to f: f = f + (incr / f->den).
65  *
66  * @param f fractional number
67  * @param incr increment, can be positive or negative
68  */
69 static void frac_add(FFFrac *f, int64_t incr)
70 {
71  int64_t num, den;
72 
73  num = f->num + incr;
74  den = f->den;
75  if (num < 0) {
76  f->val += num / den;
77  num = num % den;
78  if (num < 0) {
79  num += den;
80  f->val--;
81  }
82  } else if (num >= den) {
83  f->val += num / den;
84  num = num % den;
85  }
86  f->num = num;
87 }
88 
90 {
91  AVRational q;
92  int j;
93 
94  q = st->time_base;
95 
96  for (j=2; j<14; j+= 1+(j>2))
97  while (q.den / q.num < min_precision && q.num % j == 0)
98  q.num /= j;
99  while (q.den / q.num < min_precision && q.den < (1<<24))
100  q.den <<= 1;
101 
102  return q;
103 }
104 
106 {
107  AVCodecParameters *par = st->codecpar;
108  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(par->format);
109 
111  return par->chroma_location;
112 
113  if (pix_desc) {
114  if (pix_desc->log2_chroma_h == 0) {
115  return AVCHROMA_LOC_TOPLEFT;
116  } else if (pix_desc->log2_chroma_w == 1 && pix_desc->log2_chroma_h == 1) {
118  switch (par->codec_id) {
119  case AV_CODEC_ID_MJPEG:
121  }
122  }
124  switch (par->codec_id) {
126  }
127  }
128  }
129  }
130 
132 
133 }
134 
136  const char *format, const char *filename)
137 {
139  int ret = 0;
140 
141  *avctx = NULL;
142  if (!s)
143  goto nomem;
144 
145  if (!oformat) {
146  if (format) {
147  oformat = av_guess_format(format, NULL, NULL);
148  if (!oformat) {
149  av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
150  ret = AVERROR(EINVAL);
151  goto error;
152  }
153  } else {
154  oformat = av_guess_format(NULL, filename, NULL);
155  if (!oformat) {
156  ret = AVERROR(EINVAL);
157  av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
158  filename);
159  goto error;
160  }
161  }
162  }
163 
164  s->oformat = oformat;
165  if (s->oformat->priv_data_size > 0) {
167  if (!s->priv_data)
168  goto nomem;
169  if (s->oformat->priv_class) {
170  *(const AVClass**)s->priv_data= s->oformat->priv_class;
172  }
173  } else
174  s->priv_data = NULL;
175 
176  if (filename) {
177 #if FF_API_FORMAT_FILENAME
179  av_strlcpy(s->filename, filename, sizeof(s->filename));
181 #endif
182  if (!(s->url = av_strdup(filename)))
183  goto nomem;
184 
185  }
186  *avctx = s;
187  return 0;
188 nomem:
189  av_log(s, AV_LOG_ERROR, "Out of memory\n");
190  ret = AVERROR(ENOMEM);
191 error:
193  return ret;
194 }
195 
197 {
198  const AVCodecTag *avctag;
199  int n;
200  enum AVCodecID id = AV_CODEC_ID_NONE;
201  int64_t tag = -1;
202 
203  /**
204  * Check that tag + id is in the table
205  * If neither is in the table -> OK
206  * If tag is in the table with another id -> FAIL
207  * If id is in the table with another tag -> FAIL unless strict < normal
208  */
209  for (n = 0; s->oformat->codec_tag[n]; n++) {
210  avctag = s->oformat->codec_tag[n];
211  while (avctag->id != AV_CODEC_ID_NONE) {
212  if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codecpar->codec_tag)) {
213  id = avctag->id;
214  if (id == st->codecpar->codec_id)
215  return 1;
216  }
217  if (avctag->id == st->codecpar->codec_id)
218  tag = avctag->tag;
219  avctag++;
220  }
221  }
222  if (id != AV_CODEC_ID_NONE)
223  return 0;
224  if (tag >= 0 && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
225  return 0;
226  return 1;
227 }
228 
229 
231 {
232  int ret = 0, i;
233  AVStream *st;
234  AVDictionary *tmp = NULL;
235  AVCodecParameters *par = NULL;
236  const AVOutputFormat *of = s->oformat;
237  const AVCodecDescriptor *desc;
239 
240  if (options)
241  av_dict_copy(&tmp, *options, 0);
242 
243  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
244  goto fail;
245  if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
246  (ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
247  goto fail;
248 
249 #if FF_API_FORMAT_FILENAME
251  if (!s->url && !(s->url = av_strdup(s->filename))) {
253 #else
254  if (!s->url && !(s->url = av_strdup(""))) {
255 #endif
256  ret = AVERROR(ENOMEM);
257  goto fail;
258  }
259 
260 #if FF_API_LAVF_AVCTX
262  if (s->nb_streams && s->streams[0]->codec->flags & AV_CODEC_FLAG_BITEXACT) {
263  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
265  "The AVFormatContext is not in set to bitexact mode, only "
266  "the AVCodecContext. If this is not intended, set "
267  "AVFormatContext.flags |= AVFMT_FLAG_BITEXACT.\n");
268  }
269  }
271 #endif
272 
273  // some sanity checks
274  if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) {
275  av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");
276  ret = AVERROR(EINVAL);
277  goto fail;
278  }
279 
280  for (i = 0; i < s->nb_streams; i++) {
281  st = s->streams[i];
282  par = st->codecpar;
283 
284 #if FF_API_LAVF_AVCTX
287  st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN) {
288  av_log(s, AV_LOG_WARNING, "Using AVStream.codec to pass codec "
289  "parameters to muxers is deprecated, use AVStream.codecpar "
290  "instead.\n");
291  ret = avcodec_parameters_from_context(st->codecpar, st->codec);
292  if (ret < 0)
293  goto fail;
294  }
296 #endif
297 
298  if (!st->time_base.num) {
299  /* fall back on the default timebase values */
300  if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)
301  avpriv_set_pts_info(st, 64, 1, par->sample_rate);
302  else
303  avpriv_set_pts_info(st, 33, 1, 90000);
304  }
305 
306  switch (par->codec_type) {
307  case AVMEDIA_TYPE_AUDIO:
308  if (par->sample_rate <= 0) {
309  av_log(s, AV_LOG_ERROR, "sample rate not set\n");
310  ret = AVERROR(EINVAL);
311  goto fail;
312  }
313  if (!par->block_align)
314  par->block_align = par->channels *
315  av_get_bits_per_sample(par->codec_id) >> 3;
316  break;
317  case AVMEDIA_TYPE_VIDEO:
318  if ((par->width <= 0 || par->height <= 0) &&
319  !(of->flags & AVFMT_NODIMENSIONS)) {
320  av_log(s, AV_LOG_ERROR, "dimensions not set\n");
321  ret = AVERROR(EINVAL);
322  goto fail;
323  }
326  ) {
327  if (st->sample_aspect_ratio.num != 0 &&
328  st->sample_aspect_ratio.den != 0 &&
329  par->sample_aspect_ratio.num != 0 &&
330  par->sample_aspect_ratio.den != 0) {
331  av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
332  "(%d/%d) and encoder layer (%d/%d)\n",
335  par->sample_aspect_ratio.den);
336  ret = AVERROR(EINVAL);
337  goto fail;
338  }
339  }
340  break;
341  }
342 
343  desc = avcodec_descriptor_get(par->codec_id);
344  if (desc && desc->props & AV_CODEC_PROP_REORDER)
345  st->internal->reorder = 1;
346 
348 
349  if (of->codec_tag) {
350  if ( par->codec_tag
351  && par->codec_id == AV_CODEC_ID_RAWVIDEO
352  && ( av_codec_get_tag(of->codec_tag, par->codec_id) == 0
353  || av_codec_get_tag(of->codec_tag, par->codec_id) == MKTAG('r', 'a', 'w', ' '))
354  && !validate_codec_tag(s, st)) {
355  // the current rawvideo encoding system ends up setting
356  // the wrong codec_tag for avi/mov, we override it here
357  par->codec_tag = 0;
358  }
359  if (par->codec_tag) {
360  if (!validate_codec_tag(s, st)) {
361  const uint32_t otag = av_codec_get_tag(s->oformat->codec_tag, par->codec_id);
362  av_log(s, AV_LOG_ERROR,
363  "Tag %s incompatible with output codec id '%d' (%s)\n",
364  av_fourcc2str(par->codec_tag), par->codec_id, av_fourcc2str(otag));
365  ret = AVERROR_INVALIDDATA;
366  goto fail;
367  }
368  } else
369  par->codec_tag = av_codec_get_tag(of->codec_tag, par->codec_id);
370  }
371 
374  }
375 
376  if (!s->priv_data && of->priv_data_size > 0) {
378  if (!s->priv_data) {
379  ret = AVERROR(ENOMEM);
380  goto fail;
381  }
382  if (of->priv_class) {
383  *(const AVClass **)s->priv_data = of->priv_class;
385  if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
386  goto fail;
387  }
388  }
389 
390  /* set muxer identification string */
391  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
392  av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
393  } else {
394  av_dict_set(&s->metadata, "encoder", NULL, 0);
395  }
396 
397  for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {
398  av_dict_set(&s->metadata, e->key, NULL, 0);
399  }
400 
401  if (options) {
402  av_dict_free(options);
403  *options = tmp;
404  }
405 
406  if (s->oformat->init) {
407  if ((ret = s->oformat->init(s)) < 0) {
408  if (s->oformat->deinit)
409  s->oformat->deinit(s);
410  return ret;
411  }
412  return ret == 0;
413  }
414 
415  return 0;
416 
417 fail:
418  av_dict_free(&tmp);
419  return ret;
420 }
421 
422 static int init_pts(AVFormatContext *s)
423 {
424  int i;
425  AVStream *st;
426 
427  /* init PTS generation */
428  for (i = 0; i < s->nb_streams; i++) {
429  int64_t den = AV_NOPTS_VALUE;
430  st = s->streams[i];
431 
432  switch (st->codecpar->codec_type) {
433  case AVMEDIA_TYPE_AUDIO:
434  den = (int64_t)st->time_base.num * st->codecpar->sample_rate;
435  break;
436  case AVMEDIA_TYPE_VIDEO:
437  den = (int64_t)st->time_base.num * st->time_base.den;
438  break;
439  default:
440  break;
441  }
442 
443  if (!st->internal->priv_pts)
444  st->internal->priv_pts = av_mallocz(sizeof(*st->internal->priv_pts));
445  if (!st->internal->priv_pts)
446  return AVERROR(ENOMEM);
447 
448  if (den != AV_NOPTS_VALUE) {
449  if (den <= 0)
450  return AVERROR_INVALIDDATA;
451 
452  frac_init(st->internal->priv_pts, 0, 0, den);
453  }
454  }
455 
456  if (s->avoid_negative_ts < 0) {
459  s->avoid_negative_ts = 0;
460  } else
462  }
463 
464  return 0;
465 }
466 
468 {
469  if (s->pb && s->pb->error >= 0) {
470  if (s->flush_packets == 1 || s->flags & AVFMT_FLAG_FLUSH_PACKETS)
471  avio_flush(s->pb);
472  else if (s->flush_packets && !(s->oformat->flags & AVFMT_NOFILE))
474  }
475 }
476 
478 {
479  if (s->oformat && s->oformat->deinit && s->internal->initialized)
480  s->oformat->deinit(s);
481  s->internal->initialized =
483 }
484 
486 {
487  int ret = 0;
488 
489  if ((ret = init_muxer(s, options)) < 0)
490  return ret;
491 
492  s->internal->initialized = 1;
494 
495  if (s->oformat->init && ret) {
496  if ((ret = init_pts(s)) < 0)
497  return ret;
498 
500  }
501 
503 }
504 
506 {
507  int ret = 0;
508  int already_initialized = s->internal->initialized;
509  int streams_already_initialized = s->internal->streams_initialized;
510 
511  if (!already_initialized)
512  if ((ret = avformat_init_output(s, options)) < 0)
513  return ret;
514 
515  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
517  if (s->oformat->write_header) {
518  ret = s->oformat->write_header(s);
519  if (ret >= 0 && s->pb && s->pb->error < 0)
520  ret = s->pb->error;
521  if (ret < 0)
522  goto fail;
523  flush_if_needed(s);
524  }
525  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
527 
528  if (!s->internal->streams_initialized) {
529  if ((ret = init_pts(s)) < 0)
530  goto fail;
531  }
532 
533  return streams_already_initialized;
534 
535 fail:
536  deinit_muxer(s);
537  return ret;
538 }
539 
540 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
541 
542 
543 #if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
545 //FIXME merge with compute_pkt_fields
546 static int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)
547 {
548  int delay = FFMAX(st->codecpar->video_delay, st->internal->avctx->max_b_frames > 0);
549  int i;
550  int frame_size;
551 
552  if (!s->internal->missing_ts_warning &&
553  !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
555  (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
557  "Timestamps are unset in a packet for stream %d. "
558  "This is deprecated and will stop working in the future. "
559  "Fix your code to set the timestamps properly\n", st->index);
560  s->internal->missing_ts_warning = 1;
561  }
562 
563  if (s->debug & FF_FDEBUG_TS)
564  av_log(s, AV_LOG_DEBUG, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
565  av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), delay, pkt->size, pkt->stream_index);
566 
567  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
568  pkt->pts = pkt->dts;
569 
570  //XXX/FIXME this is a temporary hack until all encoders output pts
571  if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
572  static int warned;
573  if (!warned) {
574  av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
575  warned = 1;
576  }
577  pkt->dts =
578 // pkt->pts= st->cur_dts;
579  pkt->pts = st->internal->priv_pts->val;
580  }
581 
582  //calculate dts from pts
583  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
584  st->internal->pts_buffer[0] = pkt->pts;
585  for (i = 1; i < delay + 1 && st->internal->pts_buffer[i] == AV_NOPTS_VALUE; i++)
586  st->internal->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
587  for (i = 0; i<delay && st->internal->pts_buffer[i] > st->internal->pts_buffer[i + 1]; i++)
588  FFSWAP(int64_t, st->internal->pts_buffer[i], st->internal->pts_buffer[i + 1]);
589 
590  pkt->dts = st->internal->pts_buffer[0];
591  }
592 
593  if (st->cur_dts && st->cur_dts != AV_NOPTS_VALUE &&
594  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
597  st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
598  av_log(s, AV_LOG_ERROR,
599  "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
600  st->index, av_ts2str(st->cur_dts), av_ts2str(pkt->dts));
601  return AVERROR(EINVAL);
602  }
603  if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
604  av_log(s, AV_LOG_ERROR,
605  "pts (%s) < dts (%s) in stream %d\n",
606  av_ts2str(pkt->pts), av_ts2str(pkt->dts),
607  st->index);
608  return AVERROR(EINVAL);
609  }
610 
611  if (s->debug & FF_FDEBUG_TS)
612  av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n",
613  av_ts2str(pkt->pts), av_ts2str(pkt->dts));
614 
615  st->cur_dts = pkt->dts;
616  st->internal->priv_pts->val = pkt->dts;
617 
618  /* update pts */
619  switch (st->codecpar->codec_type) {
620  case AVMEDIA_TYPE_AUDIO:
621  frame_size = (pkt->flags & AV_PKT_FLAG_UNCODED_FRAME) ?
622  (*(AVFrame **)pkt->data)->nb_samples :
623  av_get_audio_frame_duration(st->codec, pkt->size);
624 
625  /* HACK/FIXME, we skip the initial 0 size packets as they are most
626  * likely equal to the encoder delay, but it would be better if we
627  * had the real timestamps from the encoder */
628  if (frame_size >= 0 && (pkt->size || st->internal->priv_pts->num != st->internal->priv_pts->den >> 1 || st->internal->priv_pts->val)) {
629  frac_add(st->internal->priv_pts, (int64_t)st->time_base.den * frame_size);
630  }
631  break;
632  case AVMEDIA_TYPE_VIDEO:
633  frac_add(st->internal->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
634  break;
635  }
636  return 0;
637 }
639 #endif
640 
642 {
643  if (pkt->duration < 0 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
644  av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
645  pkt->duration, pkt->stream_index);
646  pkt->duration = 0;
647  }
648 
649  if (pkt->duration)
650  return;
651 
652  switch (st->codecpar->codec_type) {
653  case AVMEDIA_TYPE_VIDEO:
654  if (st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0) {
656  st->time_base);
657  } else if (st->time_base.num * 1000LL > st->time_base.den)
658  pkt->duration = 1;
659  break;
660  case AVMEDIA_TYPE_AUDIO: {
662  if (frame_size && st->codecpar->sample_rate) {
663  pkt->duration = av_rescale_q(frame_size,
664  (AVRational){1, st->codecpar->sample_rate},
665  st->time_base);
666  }
667  break;
668  }
669  }
670 }
671 
672 /**
673  * Shift timestamps and call muxer; the original pts/dts are not kept.
674  *
675  * FIXME: this function should NEVER get undefined pts/dts beside when the
676  * AVFMT_NOTIMESTAMPS is set.
677  * Those additional safety checks should be dropped once the correct checks
678  * are set in the callers.
679  */
681 {
682  int ret;
683 
684  // If the timestamp offsetting below is adjusted, adjust
685  // ff_interleaved_peek similarly.
686  if (s->output_ts_offset) {
687  AVStream *st = s->streams[pkt->stream_index];
689 
690  if (pkt->dts != AV_NOPTS_VALUE)
691  pkt->dts += offset;
692  if (pkt->pts != AV_NOPTS_VALUE)
693  pkt->pts += offset;
694  }
695 
696  if (s->avoid_negative_ts > 0) {
697  AVStream *st = s->streams[pkt->stream_index];
698  int64_t offset = st->internal->mux_ts_offset;
699  int64_t ts = s->internal->avoid_negative_ts_use_pts ? pkt->pts : pkt->dts;
700 
701  if (s->internal->offset == AV_NOPTS_VALUE && ts != AV_NOPTS_VALUE &&
702  (ts < 0 || s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO)) {
703  s->internal->offset = -ts;
705  }
706 
707  if (s->internal->offset != AV_NOPTS_VALUE && !offset) {
708  offset = st->internal->mux_ts_offset =
711  st->time_base,
712  AV_ROUND_UP);
713  }
714 
715  if (pkt->dts != AV_NOPTS_VALUE)
716  pkt->dts += offset;
717  if (pkt->pts != AV_NOPTS_VALUE)
718  pkt->pts += offset;
719 
721  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < 0) {
722  av_log(s, AV_LOG_WARNING, "failed to avoid negative "
723  "pts %s in stream %d.\n"
724  "Try -avoid_negative_ts 1 as a possible workaround.\n",
725  av_ts2str(pkt->pts),
726  pkt->stream_index
727  );
728  }
729  } else {
730  av_assert2(pkt->dts == AV_NOPTS_VALUE || pkt->dts >= 0 || s->max_interleave_delta > 0);
731  if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < 0) {
733  "Packets poorly interleaved, failed to avoid negative "
734  "timestamp %s in stream %d.\n"
735  "Try -max_interleave_delta 0 as a possible workaround.\n",
736  av_ts2str(pkt->dts),
737  pkt->stream_index
738  );
739  }
740  }
741  }
742 
743  if ((pkt->flags & AV_PKT_FLAG_UNCODED_FRAME)) {
744  AVFrame **frame = (AVFrame **)pkt->data;
745  av_assert0(pkt->size == sizeof(*frame));
746  ret = s->oformat->write_uncoded_frame(s, pkt->stream_index, frame, 0);
747  } else {
748  ret = s->oformat->write_packet(s, pkt);
749  }
750 
751  if (s->pb && ret >= 0) {
752  flush_if_needed(s);
753  if (s->pb->error < 0)
754  ret = s->pb->error;
755  }
756 
757  if (ret >= 0)
758  s->streams[pkt->stream_index]->nb_frames++;
759 
760  return ret;
761 }
762 
764 {
765  if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
766  av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
767  pkt->stream_index);
768  return AVERROR(EINVAL);
769  }
770 
772  av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
773  return AVERROR(EINVAL);
774  }
775 
776  return 0;
777 }
778 
780 {
781 #if !FF_API_COMPUTE_PKT_FIELDS2 || !FF_API_LAVF_AVCTX
782  /* sanitize the timestamps */
783  if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
784 
785  /* when there is no reordering (so dts is equal to pts), but
786  * only one of them is set, set the other as well */
787  if (!st->internal->reorder) {
788  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)
789  pkt->pts = pkt->dts;
790  if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
791  pkt->dts = pkt->pts;
792  }
793 
794  /* check that the timestamps are set */
795  if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {
796  av_log(s, AV_LOG_ERROR,
797  "Timestamps are unset in a packet for stream %d\n", st->index);
798  return AVERROR(EINVAL);
799  }
800 
801  /* check that the dts are increasing (or at least non-decreasing,
802  * if the format allows it */
803  if (st->cur_dts != AV_NOPTS_VALUE &&
804  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && st->cur_dts >= pkt->dts) ||
805  st->cur_dts > pkt->dts)) {
806  av_log(s, AV_LOG_ERROR,
807  "Application provided invalid, non monotonically increasing "
808  "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
809  st->index, st->cur_dts, pkt->dts);
810  return AVERROR(EINVAL);
811  }
812 
813  if (pkt->pts < pkt->dts) {
814  av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
815  pkt->pts, pkt->dts, st->index);
816  return AVERROR(EINVAL);
817  }
818  }
819 #endif
820  /* update flags */
821  if (st->internal->is_intra_only)
822  pkt->flags |= AV_PKT_FLAG_KEY;
823 
824  return 0;
825 }
826 
827 #define CHUNK_START 0x1000
828 
830  int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
831 {
832  int ret;
833  AVPacketList **next_point, *this_pktl;
834  AVStream *st = s->streams[pkt->stream_index];
835  int chunked = s->max_chunk_size || s->max_chunk_duration;
836 
837  this_pktl = av_malloc(sizeof(AVPacketList));
838  if (!this_pktl) {
839  av_packet_unref(pkt);
840  return AVERROR(ENOMEM);
841  }
842  if ((ret = av_packet_make_refcounted(pkt)) < 0) {
843  av_free(this_pktl);
844  av_packet_unref(pkt);
845  return ret;
846  }
847 
848  av_packet_move_ref(&this_pktl->pkt, pkt);
849  pkt = &this_pktl->pkt;
850 
851  if (st->internal->last_in_packet_buffer) {
852  next_point = &(st->internal->last_in_packet_buffer->next);
853  } else {
854  next_point = &s->internal->packet_buffer;
855  }
856 
857  if (chunked) {
859  st->internal->interleaver_chunk_size += pkt->size;
862  || (max && st->internal->interleaver_chunk_duration > max)) {
864  pkt->flags |= CHUNK_START;
865  if (max && st->internal->interleaver_chunk_duration > max) {
866  int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
867  int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
868 
869  st->internal->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
870  } else
872  }
873  }
874  if (*next_point) {
875  if (chunked && !(pkt->flags & CHUNK_START))
876  goto next_non_null;
877 
878  if (compare(s, &s->internal->packet_buffer_end->pkt, pkt)) {
879  while ( *next_point
880  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
881  || !compare(s, &(*next_point)->pkt, pkt)))
882  next_point = &(*next_point)->next;
883  if (*next_point)
884  goto next_non_null;
885  } else {
886  next_point = &(s->internal->packet_buffer_end->next);
887  }
888  }
889  av_assert1(!*next_point);
890 
891  s->internal->packet_buffer_end = this_pktl;
892 next_non_null:
893 
894  this_pktl->next = *next_point;
895 
896  st->internal->last_in_packet_buffer = *next_point = this_pktl;
897 
898  return 0;
899 }
900 
902  const AVPacket *pkt)
903 {
904  AVStream *st = s->streams[pkt->stream_index];
905  AVStream *st2 = s->streams[next->stream_index];
906  int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
907  st->time_base);
908  if (s->audio_preload) {
909  int preload = st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
910  int preload2 = st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
911  if (preload != preload2) {
912  int64_t ts, ts2;
913  preload *= s->audio_preload;
914  preload2 *= s->audio_preload;
915  ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - preload;
916  ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - preload2;
917  if (ts == ts2) {
918  ts = ((uint64_t)pkt ->dts*st ->time_base.num*AV_TIME_BASE - (uint64_t)preload *st ->time_base.den)*st2->time_base.den
919  - ((uint64_t)next->dts*st2->time_base.num*AV_TIME_BASE - (uint64_t)preload2*st2->time_base.den)*st ->time_base.den;
920  ts2 = 0;
921  }
922  comp = (ts2 > ts) - (ts2 < ts);
923  }
924  }
925 
926  if (comp == 0)
927  return pkt->stream_index < next->stream_index;
928  return comp > 0;
929 }
930 
932  AVPacket *pkt, int flush)
933 {
934  AVPacketList *pktl;
935  int stream_count = 0;
936  int noninterleaved_count = 0;
937  int i, ret;
938  int eof = flush;
939 
940  if (pkt) {
941  if ((ret = ff_interleave_add_packet(s, pkt, interleave_compare_dts)) < 0)
942  return ret;
943  }
944 
945  for (i = 0; i < s->nb_streams; i++) {
946  if (s->streams[i]->internal->last_in_packet_buffer) {
947  ++stream_count;
948  } else if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
951  ++noninterleaved_count;
952  }
953  }
954 
955  if (s->internal->nb_interleaved_streams == stream_count)
956  flush = 1;
957 
958  if (s->max_interleave_delta > 0 &&
959  s->internal->packet_buffer &&
960  !flush &&
961  s->internal->nb_interleaved_streams == stream_count+noninterleaved_count
962  ) {
963  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
964  int64_t delta_dts = INT64_MIN;
965  int64_t top_dts = av_rescale_q(top_pkt->dts,
966  s->streams[top_pkt->stream_index]->time_base,
968 
969  for (i = 0; i < s->nb_streams; i++) {
970  int64_t last_dts;
972 
973  if (!last)
974  continue;
975 
976  last_dts = av_rescale_q(last->pkt.dts,
977  s->streams[i]->time_base,
979  delta_dts = FFMAX(delta_dts, last_dts - top_dts);
980  }
981 
982  if (delta_dts > s->max_interleave_delta) {
983  av_log(s, AV_LOG_DEBUG,
984  "Delay between the first packet and last packet in the "
985  "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
986  delta_dts, s->max_interleave_delta);
987  flush = 1;
988  }
989  }
990 
991  if (s->internal->packet_buffer &&
992  eof &&
993  (s->flags & AVFMT_FLAG_SHORTEST) &&
995  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
996 
997  s->internal->shortest_end = av_rescale_q(top_pkt->dts,
998  s->streams[top_pkt->stream_index]->time_base,
1000  }
1001 
1002  if (s->internal->shortest_end != AV_NOPTS_VALUE) {
1003  while (s->internal->packet_buffer) {
1004  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
1005  AVStream *st;
1006  int64_t top_dts = av_rescale_q(top_pkt->dts,
1007  s->streams[top_pkt->stream_index]->time_base,
1008  AV_TIME_BASE_Q);
1009 
1010  if (s->internal->shortest_end + 1 >= top_dts)
1011  break;
1012 
1013  pktl = s->internal->packet_buffer;
1014  st = s->streams[pktl->pkt.stream_index];
1015 
1016  s->internal->packet_buffer = pktl->next;
1017  if (!s->internal->packet_buffer)
1019 
1020  if (st->internal->last_in_packet_buffer == pktl)
1022 
1023  av_packet_unref(&pktl->pkt);
1024  av_freep(&pktl);
1025  flush = 0;
1026  }
1027  }
1028 
1029  if (stream_count && flush) {
1030  AVStream *st;
1031  pktl = s->internal->packet_buffer;
1032  *out = pktl->pkt;
1033  st = s->streams[out->stream_index];
1034 
1035  s->internal->packet_buffer = pktl->next;
1036  if (!s->internal->packet_buffer)
1038 
1039  if (st->internal->last_in_packet_buffer == pktl)
1041  av_freep(&pktl);
1042 
1043  return 1;
1044  } else {
1045  return 0;
1046  }
1047 }
1048 
1049 int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
1050 {
1051  AVStream *st;
1052 
1053  if (stream_index < 0 || stream_index >= s->nb_streams)
1054  return AVERROR(EINVAL);
1055 
1056  st = s->streams[stream_index];
1057  *offset = st->internal->mux_ts_offset;
1058 
1059  if (s->output_ts_offset)
1061 
1062  return 0;
1063 }
1064 
1066 {
1067  AVPacketList *pktl = s->internal->packet_buffer;
1068  while (pktl) {
1069  if (pktl->pkt.stream_index == stream) {
1070  return &pktl->pkt;
1071  }
1072  pktl = pktl->next;
1073  }
1074  return NULL;
1075 }
1076 
1077 /**
1078  * Interleave an AVPacket correctly so it can be muxed.
1079  * @param out the interleaved packet will be output here
1080  * @param in the input packet; will always be blank on return if not NULL
1081  * @param flush 1 if no further packets are available as input and all
1082  * remaining packets should be output
1083  * @return 1 if a packet was output, 0 if no packet could be output,
1084  * < 0 if an error occurred
1085  */
1087 {
1088  if (s->oformat->interleave_packet) {
1089  return s->oformat->interleave_packet(s, out, in, flush);
1090  } else
1091  return ff_interleave_packet_per_dts(s, out, in, flush);
1092 }
1093 
1095 {
1096  int ret;
1097 
1098  if (!(s->flags & AVFMT_FLAG_AUTO_BSF))
1099  return 1;
1100 
1101  if (s->oformat->check_bitstream) {
1102  if (!st->internal->bitstream_checked) {
1103  if ((ret = s->oformat->check_bitstream(s, pkt)) < 0)
1104  return ret;
1105  else if (ret == 1)
1106  st->internal->bitstream_checked = 1;
1107  }
1108  }
1109 
1110  return 1;
1111 }
1112 
1114 {
1115  for (;; ) {
1116  AVPacket opkt;
1117  int ret = interleave_packet(s, &opkt, pkt, flush);
1118  if (ret <= 0)
1119  return ret;
1120 
1121  pkt = NULL;
1122 
1123  ret = write_packet(s, &opkt);
1124 
1125  av_packet_unref(&opkt);
1126 
1127  if (ret < 0)
1128  return ret;
1129  }
1130 }
1131 
1132 static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1133 {
1134  int ret;
1135 
1136  if (s->debug & FF_FDEBUG_TS)
1137  av_log(s, AV_LOG_DEBUG, "%s size:%d dts:%s pts:%s\n", __FUNCTION__,
1138  pkt->size, av_ts2str(pkt->dts), av_ts2str(pkt->pts));
1139 
1140  guess_pkt_duration(s, st, pkt);
1141 
1142 #if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
1143  if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1144  return ret;
1145 #endif
1146 
1147  if (interleaved) {
1148  if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1149  return AVERROR(EINVAL);
1150  return interleaved_write_packet(s, pkt, 0);
1151  } else {
1152  return write_packet(s, pkt);
1153  }
1154 }
1155 
1156 static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1157 {
1158  AVBSFContext *bsfc = st->internal->bsfc;
1159  int ret;
1160 
1161  if ((ret = av_bsf_send_packet(bsfc, pkt)) < 0) {
1162  av_log(s, AV_LOG_ERROR,
1163  "Failed to send packet to filter %s for stream %d\n",
1164  bsfc->filter->name, st->index);
1165  return ret;
1166  }
1167 
1168  do {
1169  ret = av_bsf_receive_packet(bsfc, pkt);
1170  if (ret < 0) {
1171  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
1172  return 0;
1173  av_log(s, AV_LOG_ERROR, "Error applying bitstream filters to an output "
1174  "packet for stream #%d: %s\n", st->index, av_err2str(ret));
1175  if (!(s->error_recognition & AV_EF_EXPLODE) && ret != AVERROR(ENOMEM))
1176  continue;
1177  return ret;
1178  }
1179  av_packet_rescale_ts(pkt, bsfc->time_base_out, st->time_base);
1180  ret = write_packet_common(s, st, pkt, interleaved);
1181  if (ret >= 0 && !interleaved) // a successful write_packet_common already unrefed pkt for interleaved
1182  av_packet_unref(pkt);
1183  } while (ret >= 0);
1184 
1185  return ret;
1186 }
1187 
1188 static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
1189 {
1190  AVStream *st;
1191  int ret = check_packet(s, pkt);
1192  if (ret < 0)
1193  return ret;
1194  st = s->streams[pkt->stream_index];
1195 
1196  ret = prepare_input_packet(s, st, pkt);
1197  if (ret < 0)
1198  return ret;
1199 
1200  ret = check_bitstream(s, st, pkt);
1201  if (ret < 0)
1202  return ret;
1203 
1204  if (st->internal->bsfc) {
1205  return write_packets_from_bsfs(s, st, pkt, interleaved);
1206  } else {
1207  return write_packet_common(s, st, pkt, interleaved);
1208  }
1209 }
1210 
1212 {
1213  AVPacket local_pkt, *pkt = &local_pkt;
1214  int ret;
1215 
1216  if (!in) {
1217  if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
1218  ret = s->oformat->write_packet(s, NULL);
1219  flush_if_needed(s);
1220  if (ret >= 0 && s->pb && s->pb->error < 0)
1221  ret = s->pb->error;
1222  return ret;
1223  }
1224  return 1;
1225  }
1226 
1227  if (in->flags & AV_PKT_FLAG_UNCODED_FRAME) {
1228  pkt = in;
1229  } else {
1230  /* We don't own in, so we have to make sure not to modify it.
1231  * The following avoids copying in's data unnecessarily.
1232  * Copying side data is unavoidable as a bitstream filter
1233  * may change it, e.g. free it on errors. */
1234  pkt->buf = NULL;
1235  pkt->data = in->data;
1236  pkt->size = in->size;
1237  ret = av_packet_copy_props(pkt, in);
1238  if (ret < 0)
1239  return ret;
1240  if (in->buf) {
1241  pkt->buf = av_buffer_ref(in->buf);
1242  if (!pkt->buf) {
1243  ret = AVERROR(ENOMEM);
1244  goto fail;
1245  }
1246  }
1247  }
1248 
1249  ret = write_packets_common(s, pkt, 0/*non-interleaved*/);
1250 
1251 fail:
1252  // Uncoded frames using the noninterleaved codepath are also freed here
1253  av_packet_unref(pkt);
1254  return ret;
1255 }
1256 
1258 {
1259  int ret;
1260 
1261  if (pkt) {
1262  ret = write_packets_common(s, pkt, 1/*interleaved*/);
1263  if (ret < 0)
1264  av_packet_unref(pkt);
1265  return ret;
1266  } else {
1267  av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");
1268  return interleaved_write_packet(s, NULL, 1/*flush*/);
1269  }
1270 }
1271 
1273 {
1274  int i, ret1, ret = 0;
1275  AVPacket pkt = {0};
1276  av_init_packet(&pkt);
1277 
1278  for (i = 0; i < s->nb_streams; i++) {
1279  if (s->streams[i]->internal->bsfc) {
1280  ret1 = write_packets_from_bsfs(s, s->streams[i], &pkt, 1/*interleaved*/);
1281  if (ret1 < 0)
1282  av_packet_unref(&pkt);
1283  if (ret >= 0)
1284  ret = ret1;
1285  }
1286  }
1287  ret1 = interleaved_write_packet(s, NULL, 1);
1288  if (ret >= 0)
1289  ret = ret1;
1290 
1291  if (s->oformat->write_trailer) {
1292  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1294  if (ret >= 0) {
1295  ret = s->oformat->write_trailer(s);
1296  } else {
1297  s->oformat->write_trailer(s);
1298  }
1299  }
1300 
1301  deinit_muxer(s);
1302 
1303  if (s->pb)
1304  avio_flush(s->pb);
1305  if (ret == 0)
1306  ret = s->pb ? s->pb->error : 0;
1307  for (i = 0; i < s->nb_streams; i++) {
1308  av_freep(&s->streams[i]->priv_data);
1310  }
1311  if (s->oformat->priv_class)
1312  av_opt_free(s->priv_data);
1313  av_freep(&s->priv_data);
1314  return ret;
1315 }
1316 
1317 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
1318  int64_t *dts, int64_t *wall)
1319 {
1320  if (!s->oformat || !s->oformat->get_output_timestamp)
1321  return AVERROR(ENOSYS);
1322  s->oformat->get_output_timestamp(s, stream, dts, wall);
1323  return 0;
1324 }
1325 
1326 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
1328 {
1329  AVPacket local_pkt;
1330  int ret;
1331 
1332  local_pkt = *pkt;
1333  local_pkt.stream_index = dst_stream;
1334 
1335  av_packet_rescale_ts(&local_pkt,
1336  src->streams[pkt->stream_index]->time_base,
1337  dst->streams[dst_stream]->time_base);
1338 
1339  if (interleave) ret = av_interleaved_write_frame(dst, &local_pkt);
1340  else ret = av_write_frame(dst, &local_pkt);
1341  pkt->buf = local_pkt.buf;
1342  pkt->side_data = local_pkt.side_data;
1343  pkt->side_data_elems = local_pkt.side_data_elems;
1344  return ret;
1345 }
1346 
1347 static void uncoded_frame_free(void *unused, uint8_t *data)
1348 {
1349  av_frame_free((AVFrame **)data);
1350  av_free(data);
1351 }
1352 
1353 static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
1354  AVFrame *frame, int interleaved)
1355 {
1356  AVPacket pkt, *pktp;
1357 
1358  av_assert0(s->oformat);
1359  if (!s->oformat->write_uncoded_frame) {
1360  av_frame_free(&frame);
1361  return AVERROR(ENOSYS);
1362  }
1363 
1364  if (!frame) {
1365  pktp = NULL;
1366  } else {
1367  size_t bufsize = sizeof(frame) + AV_INPUT_BUFFER_PADDING_SIZE;
1368  AVFrame **framep = av_mallocz(bufsize);
1369 
1370  if (!framep)
1371  goto fail;
1372  pktp = &pkt;
1373  av_init_packet(&pkt);
1374  pkt.buf = av_buffer_create((void *)framep, bufsize,
1375  uncoded_frame_free, NULL, 0);
1376  if (!pkt.buf) {
1377  av_free(framep);
1378  fail:
1379  av_frame_free(&frame);
1380  return AVERROR(ENOMEM);
1381  }
1382  *framep = frame;
1383 
1384  pkt.data = (void *)framep;
1385  pkt.size = sizeof(frame);
1386  pkt.pts =
1387  pkt.dts = frame->pts;
1388  pkt.duration = frame->pkt_duration;
1389  pkt.stream_index = stream_index;
1391  }
1392 
1393  return interleaved ? av_interleaved_write_frame(s, pktp) :
1394  av_write_frame(s, pktp);
1395 }
1396 
1397 int av_write_uncoded_frame(AVFormatContext *s, int stream_index,
1398  AVFrame *frame)
1399 {
1400  return write_uncoded_frame_internal(s, stream_index, frame, 0);
1401 }
1402 
1404  AVFrame *frame)
1405 {
1406  return write_uncoded_frame_internal(s, stream_index, frame, 1);
1407 }
1408 
1410 {
1411  av_assert0(s->oformat);
1412  if (!s->oformat->write_uncoded_frame)
1413  return AVERROR(ENOSYS);
1414  return s->oformat->write_uncoded_frame(s, stream_index, NULL,
1416 }
int avformat_alloc_output_context2(AVFormatContext **avctx, ff_const59 AVOutputFormat *oformat, const char *format, const char *filename)
Allocate an AVFormatContext for an output format.
Definition: mux.c:135
#define AV_CODEC_PROP_REORDER
Codec supports frame reordering.
Definition: codec_desc.h:92
static float compare(const AVFrame *haystack, const AVFrame *obj, int offx, int offy)
Definition: vf_find_rect.c:104
enum AVChromaLocation chroma_location
Definition: codec_par.h:150
#define NULL
Definition: coverity.c:32
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
AVBSFContext * bsfc
bitstream filter to run on stream
Definition: internal.h:164
int audio_preload
Audio preload in microseconds.
Definition: avformat.h:1603
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int check_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:763
enum AVCodecID id
Definition: internal.h:43
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:607
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file ensuring correct interleaving.
Definition: mux.c:1257
int bitstream_checked
Whether or not check_bitstream should still be run on each packet.
Definition: internal.h:169
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
FFFrac * priv_pts
Definition: internal.h:198
static void flush(AVCodecContext *avctx)
static void uncoded_frame_free(void *unused, uint8_t *data)
Definition: mux.c:1347
int flush_packets
Flush the I/O context after each packet.
Definition: avformat.h:1670
int av_write_frame(AVFormatContext *s, AVPacket *in)
Write a packet to an output media file.
Definition: mux.c:1211
const char * desc
Definition: libsvtav1.c:79
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
int reorder
Set to 1 if the codec allows reordering, so pts can be different from dts.
Definition: internal.h:157
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4905
int(* init)(struct AVFormatContext *)
Initialize format.
Definition: avformat.h:624
#define AVSTREAM_INIT_IN_INIT_OUTPUT
stream parameters initialized in avformat_init_output
Definition: avformat.h:2422
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:791
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:136
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1358
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: bsf.h:58
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:946
int num
Numerator.
Definition: rational.h:59
The bitstream filter state.
Definition: bsf.h:49
int index
stream index in AVFormatContext
Definition: avformat.h:885
static int prepare_input_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:779
int size
Definition: packet.h:364
int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
Interleave an AVPacket per dts so it can be muxed.
Definition: mux.c:931
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1708
static void deinit_muxer(AVFormatContext *s)
Definition: mux.c:477
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
int av_get_output_timestamp(struct AVFormatContext *s, int stream, int64_t *dts, int64_t *wall)
Get timing information for the data currently output.
Definition: mux.c:1317
static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index, AVFrame *frame, int interleaved)
Definition: mux.c:1353
int64_t offset
Offset to remap timestamps to be non-negative.
Definition: internal.h:106
int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
Definition: mux.c:1049
void * priv_data
Definition: avformat.h:899
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
int avoid_negative_ts_use_pts
Definition: internal.h:119
static AVPacket pkt
int av_write_uncoded_frame_query(AVFormatContext *s, int stream_index)
Test whether a muxer supports uncoded frame.
Definition: mux.c:1409
static void error(const char *err)
int64_t interleaver_chunk_size
Definition: internal.h:238
#define AVFMT_ALLOW_FLUSH
Format allows flushing.
Definition: avformat.h:471
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate.The lists are not just lists
int strict_std_compliance
Allow non-standard and experimental extension.
Definition: avformat.h:1551
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:472
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt, AVFormatContext *src, int interleave)
Write a packet to another muxer than the one the user originally intended.
Definition: mux.c:1326
static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
Definition: mux.c:1188
int(* interleave_packet)(struct AVFormatContext *, AVPacket *out, AVPacket *in, int flush)
A format-specific function for interleavement.
Definition: avformat.h:568
Trailer data, which doesn&#39;t contain actual content, but only for finalizing the output file...
Definition: avio.h:140
Format I/O context.
Definition: avformat.h:1243
int64_t output_ts_offset
Output timestamp offset, in microseconds.
Definition: avformat.h:1772
int64_t cur_dts
Definition: avformat.h:1077
static void interleave(uint8_t *dst, uint8_t *src, int w, int h, int dst_linesize, int src_linesize, enum FilterMode mode, int swap)
Definition: vf_il.c:114
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define CHUNK_START
Definition: mux.c:827
Public dictionary API.
static void flush_if_needed(AVFormatContext *s)
Definition: mux.c:467
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT, AVFMT_TS_NEGATIVE
Definition: avformat.h:519
uint8_t
Round toward +infinity.
Definition: mathematics.h:83
#define av_malloc(s)
Opaque data information usually continuous.
Definition: avutil.h:203
int width
Video only.
Definition: codec_par.h:126
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
AVOptions.
A point in the output bytestream where the underlying AVIOContext might flush the buffer depending on...
Definition: avio.h:146
timestamp utils, mostly useful for debugging/logging purposes
Query whether the feature is possible on this stream.
Definition: internal.h:775
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
AVPacket pkt
Definition: packet.h:397
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
#define f(width, name)
Definition: cbs_vp9.c:255
int priv_data_size
size of private data so that it can be allocated in the wrapper
Definition: avformat.h:552
The exact value of the fractional number is: &#39;val + num / den&#39;.
Definition: internal.h:59
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:381
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:407
struct AVPacketList * last_in_packet_buffer
last packet in packet_buffer for this stream when muxing.
Definition: internal.h:350
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:483
int64_t mux_ts_offset
Timestamp offset added to timestamps before muxing.
Definition: internal.h:292
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1311
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:211
const char * name
Definition: bsf.h:99
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1374
uint8_t * data
Definition: packet.h:363
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
int64_t max_interleave_delta
Maximum buffering duration for interleaving.
Definition: avformat.h:1545
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:664
uint32_t tag
Definition: movenc.c:1597
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define max(a, b)
Definition: cuda_runtime.h:33
struct AVPacketList * packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:76
#define AVSTREAM_INIT_IN_WRITE_HEADER
stream parameters initialized in avformat_write_header
Definition: avformat.h:2421
static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush)
Interleave an AVPacket correctly so it can be muxed.
Definition: mux.c:1086
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1391
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
static int interleave_compare_dts(AVFormatContext *s, const AVPacket *next, const AVPacket *pkt)
Definition: mux.c:901
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
#define src
Definition: vp8dsp.c:255
#define ff_const59
The ff_const59 define is not part of the public API and will be removed without further warning...
Definition: avformat.h:544
#define AVFMT_FLAG_FLUSH_PACKETS
Flush the AVIOContext every packet.
Definition: avformat.h:1384
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1483
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1611
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
void av_packet_rescale_ts(AVPacket *pkt, AVRational src_tb, AVRational dst_tb)
Convert valid timing fields (timestamps / durations) in a packet from one timebase to another...
Definition: avpacket.c:713
static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1132
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
Definition: mux.c:196
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
#define AV_PKT_FLAG_UNCODED_FRAME
Definition: mux.c:540
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
int(* check_bitstream)(struct AVFormatContext *, const AVPacket *pkt)
Set up any necessary bitstream filtering and extract any extra data needed for the global header...
Definition: avformat.h:639
char * url
input or output URL.
Definition: avformat.h:1339
int video_delay
Video only.
Definition: codec_par.h:155
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:346
simple assert() macros that are a bit more flexible than ISO C assert().
int side_data_elems
Definition: packet.h:375
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:29
int ff_is_intra_only(enum AVCodecID id)
Definition: utils.c:986
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:957
#define FFMAX(a, b)
Definition: common.h:103
int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)
This function is the same as av_get_audio_frame_duration(), except it works with AVCodecParameters in...
Definition: utils.c:1833
int64_t val
Definition: internal.h:60
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
#define fail()
Definition: checkasm.h:133
static void guess_pkt_duration(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:641
const AVPacket * ff_interleaved_peek(AVFormatContext *s, int stream)
Find the next packet in the interleaving queue for the given stream.
Definition: mux.c:1065
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
Definition: mathematics.c:147
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
static int write_packet(AVFormatContext *s, AVPacket *pkt)
Shift timestamps and call muxer; the original pts/dts are not kept.
Definition: mux.c:680
int streams_initialized
Whether or not avformat_init_output fully initialized streams.
Definition: internal.h:134
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:233
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1299
#define LIBAVFORMAT_IDENT
Definition: version.h:46
int block_align
Audio only.
Definition: codec_par.h:177
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:572
This is any, unlabelled data.
Definition: avio.h:135
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
int(* write_header)(struct AVFormatContext *)
Definition: avformat.h:554
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
int64_t shortest_end
Timestamp of the end of the shortest stream.
Definition: internal.h:124
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
int avformat_write_header(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and write the stream header to an output media file.
Definition: mux.c:505
int(* write_uncoded_frame)(struct AVFormatContext *, int stream_index, AVFrame **frame, unsigned flags)
Write an uncoded AVFrame.
Definition: avformat.h:595
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:560
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: bsf.h:95
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:672
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:609
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
int avoid_negative_ts
Avoid negative timestamps during muxing.
Definition: avformat.h:1586
static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
f = val + (num / den) + 0.5.
Definition: mux.c:51
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1651
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
static int init_muxer(AVFormatContext *s, AVDictionary **options)
Definition: mux.c:230
Opaque data information usually sparse.
Definition: avutil.h:205
int64_t num
Definition: internal.h:60
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:528
int avformat_init_output(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and initialize the codec, but do not write the header.
Definition: mux.c:485
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
Definition: opt.c:1631
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:852
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1262
if(ret)
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:85
Stream structure.
Definition: avformat.h:884
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:462
#define FF_FDEBUG_TS
Definition: avformat.h:1527
int frame_size
Definition: mxfenc.c:2205
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:200
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1156
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1123
int64_t pkt_duration
duration of the corresponding packet, expressed in AVStream->time_base units, 0 if unknown...
Definition: frame.h:593
int debug
Flags to enable debugging.
Definition: avformat.h:1526
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1656
AVIOContext * pb
I/O context.
Definition: avformat.h:1285
const struct AVCodecTag *const * codec_tag
List of supported codec_id-codec_tag pairs, ordered by "better choice first".
Definition: avformat.h:525
int64_t den
Definition: internal.h:60
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:606
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:226
int(* write_trailer)(struct AVFormatContext *)
Definition: avformat.h:563
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
int nb_interleaved_streams
Number of streams relevant for interleaving.
Definition: internal.h:69
Describe the class of an AVClass context structure.
Definition: log.h:67
int initialized
Whether or not avformat_init_output has already been called.
Definition: internal.h:129
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1599
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:1900
ff_const59 AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)
Return the output format in the list of registered output formats which best matches the provided par...
Definition: format.c:51
int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt, int(*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
Add packet to an AVFormatContext&#39;s packet_buffer list, determining its interleaved position using com...
Definition: mux.c:829
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define AV_DISPOSITION_TIMED_THUMBNAILS
The stream is sparse, and contains thumbnail images, often corresponding to chapter markers...
Definition: avformat.h:857
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: utils.c:2127
void(* get_output_timestamp)(struct AVFormatContext *s, int stream, int64_t *dts, int64_t *wall)
Definition: avformat.h:579
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:245
enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:105
AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:89
#define AVFMT_AVOID_NEG_TS_AUTO
Enabled when required by target format.
Definition: avformat.h:1587
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4410
#define AVFMT_FLAG_AUTO_BSF
Add bitstream filters as requested by the muxer.
Definition: avformat.h:1402
int error
contains the error code or 0 if no error happened
Definition: avio.h:245
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:1824
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: codec_desc.h:38
unsigned int tag
Definition: internal.h:44
AVRational offset_timebase
Timebase for the timestamp offset.
Definition: internal.h:111
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
int sample_rate
Audio only.
Definition: codec_par.h:170
#define AVFMT_AVOID_NEG_TS_MAKE_ZERO
Shift timestamps so that they start at 0.
Definition: avformat.h:1589
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
Main libavformat public API header.
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:374
int64_t pts_buffer[MAX_REORDER_DELAY+1]
Definition: internal.h:324
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1611
const OptionDef options[]
Definition: ffmpeg_opt.c:3424
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
int av_interleaved_write_uncoded_frame(AVFormatContext *s, int stream_index, AVFrame *frame)
Write an uncoded frame to an output media file.
Definition: mux.c:1403
common internal api header.
struct AVPacketList * next
Definition: packet.h:398
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:458
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:467
int max_chunk_size
Max chunk size in bytes Note, not all formats support this and unpredictable things may happen if it ...
Definition: avformat.h:1619
int error_recognition
Error recognition; higher values will detect more errors but may misdetect some more or less valid pa...
Definition: avformat.h:1510
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:937
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
static void frac_add(FFFrac *f, int64_t incr)
Fractional addition to f: f = f + (incr / f->den).
Definition: mux.c:69
static int init_pts(AVFormatContext *s)
Definition: mux.c:422
int64_t interleaver_chunk_duration
Definition: internal.h:239
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:935
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
int av_write_uncoded_frame(AVFormatContext *s, int stream_index, AVFrame *frame)
Write an uncoded frame to an output media file.
Definition: mux.c:1397
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
static int interleaved_write_packet(AVFormatContext *s, AVPacket *pkt, int flush)
Definition: mux.c:1113
#define AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE
Shift timestamps so they are non negative.
Definition: avformat.h:1588
struct AVPacketList * packet_buffer_end
Definition: internal.h:77
#define av_free(p)
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
int max_chunk_duration
Max chunk time in microseconds.
Definition: avformat.h:1611
void * priv_data
Format private data.
Definition: avformat.h:1271
void(* deinit)(struct AVFormatContext *)
Deinitialize format.
Definition: avformat.h:633
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:466
static int check_bitstream(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:1094
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3501
int(* write_packet)(struct AVFormatContext *, AVPacket *pkt)
Write a packet.
Definition: avformat.h:562
int channels
Audio only.
Definition: codec_par.h:166
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:174
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:362
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
Definition: mux.c:1272
FILE * out
Definition: movenc.c:54
#define av_freep(p)
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:605
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:608
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1049
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.
Definition: mathematics.c:134
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
#define FFSWAP(type, a, b)
Definition: common.h:108
int stream_index
Definition: packet.h:365
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:913
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define MKTAG(a, b, c, d)
Definition: common.h:478
unsigned int av_codec_get_tag(const struct AVCodecTag *const *tags, enum AVCodecID id)
Get the codec tag for the given codec id id.
#define AVFMT_TS_NEGATIVE
Format allows muxing negative timestamps.
Definition: avformat.h:477
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:340
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
Header data; this needs to be present for the stream to be decodeable.
Definition: avio.h:115
int i
Definition: input.c:407
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define AVFMT_FLAG_SHORTEST
Stop muxing when the shortest stream stops.
Definition: avformat.h:1401
static uint8_t tmp[11]
Definition: aes_ctr.c:27