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 "mux.h"
25 #include "version.h"
26 #include "libavcodec/bsf.h"
27 #include "libavcodec/codec_desc.h"
28 #include "libavcodec/internal.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/dict.h"
32 #include "libavutil/timestamp.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/frame.h"
35 #include "libavutil/internal.h"
36 #include "libavutil/mathematics.h"
37 
38 /**
39  * @file
40  * muxing functions for use within libavformat
41  */
42 
43 /* fraction handling */
44 
45 /**
46  * f = val + (num / den) + 0.5.
47  *
48  * 'num' is normalized so that it is such as 0 <= num < den.
49  *
50  * @param f fractional number
51  * @param val integer value
52  * @param num must be >= 0
53  * @param den must be >= 1
54  */
55 static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
56 {
57  num += (den >> 1);
58  if (num >= den) {
59  val += num / den;
60  num = num % den;
61  }
62  f->val = val;
63  f->num = num;
64  f->den = den;
65 }
66 
67 /**
68  * Fractional addition to f: f = f + (incr / f->den).
69  *
70  * @param f fractional number
71  * @param incr increment, can be positive or negative
72  */
73 static void frac_add(FFFrac *f, int64_t incr)
74 {
75  int64_t num, den;
76 
77  num = f->num + incr;
78  den = f->den;
79  if (num < 0) {
80  f->val += num / den;
81  num = num % den;
82  if (num < 0) {
83  num += den;
84  f->val--;
85  }
86  } else if (num >= den) {
87  f->val += num / den;
88  num = num % den;
89  }
90  f->num = num;
91 }
92 
94  const char *format, const char *filename)
95 {
97  int ret = 0;
98 
99  *avctx = NULL;
100  if (!s)
101  goto nomem;
102 
103  if (!oformat) {
104  if (format) {
105  oformat = av_guess_format(format, NULL, NULL);
106  if (!oformat) {
107  av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not known.\n", format);
108  ret = AVERROR(EINVAL);
109  goto error;
110  }
111  } else {
112  oformat = av_guess_format(NULL, filename, NULL);
113  if (!oformat) {
114  ret = AVERROR(EINVAL);
116  "Unable to choose an output format for '%s'; "
117  "use a standard extension for the filename or specify "
118  "the format manually.\n", filename);
119  goto error;
120  }
121  }
122  }
123 
124  s->oformat = oformat;
125  if (ffofmt(s->oformat)->priv_data_size > 0) {
126  s->priv_data = av_mallocz(ffofmt(s->oformat)->priv_data_size);
127  if (!s->priv_data)
128  goto nomem;
129  if (s->oformat->priv_class) {
130  *(const AVClass**)s->priv_data= s->oformat->priv_class;
131  av_opt_set_defaults(s->priv_data);
132  }
133  } else
134  s->priv_data = NULL;
135 
136  if (filename) {
137  if (!(s->url = av_strdup(filename)))
138  goto nomem;
139 
140  }
141  *avctx = s;
142  return 0;
143 nomem:
144  av_log(s, AV_LOG_ERROR, "Out of memory\n");
145  ret = AVERROR(ENOMEM);
146 error:
148  return ret;
149 }
150 
151 static int validate_codec_tag(const AVFormatContext *s, const AVStream *st)
152 {
153  const AVCodecTag *avctag;
154  enum AVCodecID id = AV_CODEC_ID_NONE;
155  unsigned uppercase_tag = ff_toupper4(st->codecpar->codec_tag);
156  int64_t tag = -1;
157 
158  /**
159  * Check that tag + id is in the table
160  * If neither is in the table -> OK
161  * If tag is in the table with another id -> FAIL
162  * If id is in the table with another tag -> FAIL unless strict < normal
163  */
164  for (int n = 0; s->oformat->codec_tag[n]; n++) {
165  avctag = s->oformat->codec_tag[n];
166  while (avctag->id != AV_CODEC_ID_NONE) {
167  if (ff_toupper4(avctag->tag) == uppercase_tag) {
168  id = avctag->id;
169  if (id == st->codecpar->codec_id)
170  return 1;
171  }
172  if (avctag->id == st->codecpar->codec_id)
173  tag = avctag->tag;
174  avctag++;
175  }
176  }
177  if (id != AV_CODEC_ID_NONE)
178  return 0;
179  if (tag >= 0 && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
180  return 0;
181  return 1;
182 }
183 
184 
186 {
187  FFFormatContext *const si = ffformatcontext(s);
188  AVDictionary *tmp = NULL;
189  const FFOutputFormat *of = ffofmt(s->oformat);
191  static const unsigned default_codec_offsets[] = {
192  [AVMEDIA_TYPE_VIDEO] = offsetof(AVOutputFormat, video_codec),
193  [AVMEDIA_TYPE_AUDIO] = offsetof(AVOutputFormat, audio_codec),
194  [AVMEDIA_TYPE_SUBTITLE] = offsetof(AVOutputFormat, subtitle_codec),
195  };
196  unsigned nb_type[FF_ARRAY_ELEMS(default_codec_offsets)] = { 0 };
197  int ret = 0;
198 
199  if (options)
200  av_dict_copy(&tmp, *options, 0);
201 
202  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
203  goto fail;
204  if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
205  (ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
206  goto fail;
207 
208  if (!s->url && !(s->url = av_strdup(""))) {
209  ret = AVERROR(ENOMEM);
210  goto fail;
211  }
212 
213  // some sanity checks
214  if (s->nb_streams == 0 && !(of->p.flags & AVFMT_NOSTREAMS)) {
215  av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");
216  ret = AVERROR(EINVAL);
217  goto fail;
218  }
219 
220  for (unsigned i = 0; i < s->nb_streams; i++) {
221  AVStream *const st = s->streams[i];
222  FFStream *const sti = ffstream(st);
223  AVCodecParameters *const par = st->codecpar;
224  const AVCodecDescriptor *desc;
225 
226  if (!st->time_base.num) {
227  /* fall back on the default timebase values */
228  if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)
229  avpriv_set_pts_info(st, 64, 1, par->sample_rate);
230  else
231  avpriv_set_pts_info(st, 33, 1, 90000);
232  }
233 
234  switch (par->codec_type) {
235  case AVMEDIA_TYPE_AUDIO:
236  if (par->sample_rate <= 0) {
237  av_log(s, AV_LOG_ERROR, "sample rate not set\n");
238  ret = AVERROR(EINVAL);
239  goto fail;
240  }
241 
242  if (!par->block_align)
243  par->block_align = par->ch_layout.nb_channels *
244  av_get_bits_per_sample(par->codec_id) >> 3;
245  break;
246  case AVMEDIA_TYPE_VIDEO:
247  if ((par->width <= 0 || par->height <= 0) &&
248  !(of->p.flags & AVFMT_NODIMENSIONS)) {
249  av_log(s, AV_LOG_ERROR, "dimensions not set\n");
250  ret = AVERROR(EINVAL);
251  goto fail;
252  }
255  ) {
256  if (st->sample_aspect_ratio.num != 0 &&
257  st->sample_aspect_ratio.den != 0 &&
258  par->sample_aspect_ratio.num != 0 &&
259  par->sample_aspect_ratio.den != 0) {
260  av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
261  "(%d/%d) and encoder layer (%d/%d)\n",
264  par->sample_aspect_ratio.den);
265  ret = AVERROR(EINVAL);
266  goto fail;
267  }
268  }
269  break;
270  }
272  enum AVCodecID default_codec_id = AV_CODEC_ID_NONE;
273  unsigned nb;
274  if ((unsigned)par->codec_type < FF_ARRAY_ELEMS(default_codec_offsets)) {
275  nb = ++nb_type[par->codec_type];
276  if (default_codec_offsets[par->codec_type])
277  default_codec_id = *(const enum AVCodecID*)((const char*)of + default_codec_offsets[par->codec_type]);
278  }
280  default_codec_id != AV_CODEC_ID_NONE && par->codec_id != default_codec_id) {
281  av_log(s, AV_LOG_ERROR, "%s muxer supports only codec %s for type %s\n",
282  of->p.name, avcodec_get_name(default_codec_id), av_get_media_type_string(par->codec_type));
283  ret = AVERROR(EINVAL);
284  goto fail;
285  } else if (default_codec_id == AV_CODEC_ID_NONE ||
286  (of->flags_internal & FF_OFMT_FLAG_MAX_ONE_OF_EACH && nb > 1)) {
287  const char *type = av_get_media_type_string(par->codec_type);
288  av_log(s, AV_LOG_ERROR, "%s muxer does not support %s stream of type %s\n",
289  of->p.name, default_codec_id == AV_CODEC_ID_NONE ? "any" : "more than one",
290  type ? type : "unknown");
291  ret = AVERROR(EINVAL);
292  goto fail;
293  }
294  }
295 
296 #if FF_API_AVSTREAM_SIDE_DATA
298  /* if the caller is using the deprecated AVStream side_data API,
299  * copy its contents to AVStream.codecpar, giving it priority
300  over existing side data in the latter */
301  for (int i = 0; i < st->nb_side_data; i++) {
302  const AVPacketSideData *sd_src = &st->side_data[i];
303  AVPacketSideData *sd_dst;
304 
307  sd_src->type, sd_src->size, 0);
308  if (!sd_dst) {
309  ret = AVERROR(ENOMEM);
310  goto fail;
311  }
312  memcpy(sd_dst->data, sd_src->data, sd_src->size);
313  }
315 #endif
316 
318  if (desc && desc->props & AV_CODEC_PROP_REORDER)
319  sti->reorder = 1;
320 
322 
323  if (of->p.codec_tag) {
324  if ( par->codec_tag
325  && par->codec_id == AV_CODEC_ID_RAWVIDEO
326  && ( av_codec_get_tag(of->p.codec_tag, par->codec_id) == 0
327  || av_codec_get_tag(of->p.codec_tag, par->codec_id) == MKTAG('r', 'a', 'w', ' '))
328  && !validate_codec_tag(s, st)) {
329  // the current rawvideo encoding system ends up setting
330  // the wrong codec_tag for avi/mov, we override it here
331  par->codec_tag = 0;
332  }
333  if (par->codec_tag) {
334  if (!validate_codec_tag(s, st)) {
335  const uint32_t otag = av_codec_get_tag(s->oformat->codec_tag, par->codec_id);
337  "Tag %s incompatible with output codec id '%d' (%s)\n",
338  av_fourcc2str(par->codec_tag), par->codec_id, av_fourcc2str(otag));
340  goto fail;
341  }
342  } else
343  par->codec_tag = av_codec_get_tag(of->p.codec_tag, par->codec_id);
344  }
345 
346  if (par->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
349  }
351  if (!si->interleave_packet)
355 
356  if (!s->priv_data && of->priv_data_size > 0) {
357  s->priv_data = av_mallocz(of->priv_data_size);
358  if (!s->priv_data) {
359  ret = AVERROR(ENOMEM);
360  goto fail;
361  }
362  if (of->p.priv_class) {
363  *(const AVClass **)s->priv_data = of->p.priv_class;
364  av_opt_set_defaults(s->priv_data);
365  if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
366  goto fail;
367  }
368  }
369 
370  /* set muxer identification string */
371  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
372  av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
373  } else {
374  av_dict_set(&s->metadata, "encoder", NULL, 0);
375  }
376 
377  for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {
378  av_dict_set(&s->metadata, e->key, NULL, 0);
379  }
380 
381  if (options) {
383  *options = tmp;
384  }
385 
386  if (of->init) {
387  if ((ret = of->init(s)) < 0) {
388  if (of->deinit)
389  of->deinit(s);
390  return ret;
391  }
392  return ret == 0;
393  }
394 
395  return 0;
396 
397 fail:
398  av_dict_free(&tmp);
399  return ret;
400 }
401 
403 {
404  FFFormatContext *const si = ffformatcontext(s);
405 
406  /* init PTS generation */
407  for (unsigned i = 0; i < s->nb_streams; i++) {
408  AVStream *const st = s->streams[i];
409  FFStream *const sti = ffstream(st);
410  int64_t den = AV_NOPTS_VALUE;
411 
412  switch (st->codecpar->codec_type) {
413  case AVMEDIA_TYPE_AUDIO:
414  den = (int64_t)st->time_base.num * st->codecpar->sample_rate;
415  break;
416  case AVMEDIA_TYPE_VIDEO:
417  den = (int64_t)st->time_base.num * st->time_base.den;
418  break;
419  default:
420  break;
421  }
422 
423  if (den != AV_NOPTS_VALUE) {
424  if (den <= 0)
425  return AVERROR_INVALIDDATA;
426 
427  frac_init(&sti->priv_pts, 0, 0, den);
428  }
429  }
430 
431  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_UNKNOWN;
432  if (s->avoid_negative_ts < 0) {
433  av_assert2(s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO);
434  if (s->oformat->flags & (AVFMT_TS_NEGATIVE | AVFMT_NOTIMESTAMPS)) {
435  s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_DISABLED;
436  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_DISABLED;
437  } else
438  s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE;
439  } else if (s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_DISABLED)
440  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_DISABLED;
441 
442  return 0;
443 }
444 
446 {
447  if (s->pb && s->pb->error >= 0) {
448  if (s->flush_packets == 1 || s->flags & AVFMT_FLAG_FLUSH_PACKETS)
449  avio_flush(s->pb);
450  else if (s->flush_packets && !(s->oformat->flags & AVFMT_NOFILE))
452  }
453 }
454 
456 {
457  FFFormatContext *const si = ffformatcontext(s);
458  const FFOutputFormat *const of = ffofmt(s->oformat);
459  if (of && of->deinit && si->initialized)
460  of->deinit(s);
461  si->initialized =
462  si->streams_initialized = 0;
463 }
464 
466 {
467  FFFormatContext *const si = ffformatcontext(s);
468  int ret = 0;
469 
470  if ((ret = init_muxer(s, options)) < 0)
471  return ret;
472 
473  si->initialized = 1;
474  si->streams_initialized = ret;
475 
476  if (ffofmt(s->oformat)->init && ret) {
477  if ((ret = init_pts(s)) < 0)
478  return ret;
479 
481  }
482 
484 }
485 
487 {
488  FFFormatContext *const si = ffformatcontext(s);
489  int already_initialized = si->initialized;
490  int streams_already_initialized = si->streams_initialized;
491  int ret = 0;
492 
493  if (!already_initialized)
494  if ((ret = avformat_init_output(s, options)) < 0)
495  return ret;
496 
497  if (ffofmt(s->oformat)->write_header) {
498  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
500  ret = ffofmt(s->oformat)->write_header(s);
501  if (ret >= 0 && s->pb && s->pb->error < 0)
502  ret = s->pb->error;
503  if (ret < 0)
504  goto fail;
506  }
507  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
509 
510  if (!si->streams_initialized) {
511  if ((ret = init_pts(s)) < 0)
512  goto fail;
513  }
514 
515  return streams_already_initialized;
516 
517 fail:
518  deinit_muxer(s);
519  return ret;
520 }
521 
522 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
523 
524 
525 #if FF_API_COMPUTE_PKT_FIELDS2
527 //FIXME merge with compute_pkt_fields
529 {
530  FFFormatContext *const si = ffformatcontext(s);
531  FFStream *const sti = ffstream(st);
532  int delay = st->codecpar->video_delay;
533  int frame_size;
534 
535  if (!si->missing_ts_warning &&
536  !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
538  (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
540  "Timestamps are unset in a packet for stream %d. "
541  "This is deprecated and will stop working in the future. "
542  "Fix your code to set the timestamps properly\n", st->index);
543  si->missing_ts_warning = 1;
544  }
545 
546  if (s->debug & FF_FDEBUG_TS)
547  av_log(s, AV_LOG_DEBUG, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
549 
550  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
551  pkt->pts = pkt->dts;
552 
553  //XXX/FIXME this is a temporary hack until all encoders output pts
554  if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
555  static int warned;
556  if (!warned) {
557  av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
558  warned = 1;
559  }
560  pkt->dts =
561 // pkt->pts= st->cur_dts;
562  pkt->pts = sti->priv_pts.val;
563  }
564 
565  //calculate dts from pts
566  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
567  sti->pts_buffer[0] = pkt->pts;
568  for (int i = 1; i < delay + 1 && sti->pts_buffer[i] == AV_NOPTS_VALUE; i++)
569  sti->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
570  for (int i = 0; i<delay && sti->pts_buffer[i] > sti->pts_buffer[i + 1]; i++)
571  FFSWAP(int64_t, sti->pts_buffer[i], sti->pts_buffer[i + 1]);
572 
573  pkt->dts = sti->pts_buffer[0];
574  }
575 
576  if (sti->cur_dts && sti->cur_dts != AV_NOPTS_VALUE &&
577  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
580  sti->cur_dts >= pkt->dts) || sti->cur_dts > pkt->dts)) {
582  "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
583  st->index, av_ts2str(sti->cur_dts), av_ts2str(pkt->dts));
584  return AVERROR(EINVAL);
585  }
586  if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
588  "pts (%s) < dts (%s) in stream %d\n",
590  st->index);
591  return AVERROR(EINVAL);
592  }
593 
594  if (s->debug & FF_FDEBUG_TS)
595  av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n",
597 
598  sti->cur_dts = pkt->dts;
599  sti->priv_pts.val = pkt->dts;
600 
601  /* update pts */
602  switch (st->codecpar->codec_type) {
603  case AVMEDIA_TYPE_AUDIO:
605  (*(AVFrame **)pkt->data)->nb_samples :
607 
608  /* HACK/FIXME, we skip the initial 0 size packets as they are most
609  * likely equal to the encoder delay, but it would be better if we
610  * had the real timestamps from the encoder */
611  if (frame_size >= 0 && (pkt->size || sti->priv_pts.num != sti->priv_pts.den >> 1 || sti->priv_pts.val)) {
612  frac_add(&sti->priv_pts, (int64_t)st->time_base.den * frame_size);
613  }
614  break;
615  case AVMEDIA_TYPE_VIDEO:
616  frac_add(&sti->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
617  break;
618  }
619  return 0;
620 }
622 #endif
623 
625 {
626  if (pkt->duration < 0 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
627  av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
629  pkt->duration = 0;
630  }
631 
632  if (pkt->duration)
633  return;
634 
635  switch (st->codecpar->codec_type) {
636  case AVMEDIA_TYPE_VIDEO:
637  if (st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0) {
639  st->time_base);
640  } else if (st->time_base.num * 1000LL > st->time_base.den)
641  pkt->duration = 1;
642  break;
643  case AVMEDIA_TYPE_AUDIO: {
645  if (frame_size && st->codecpar->sample_rate) {
647  (AVRational){1, st->codecpar->sample_rate},
648  st->time_base);
649  }
650  break;
651  }
652  }
653 }
654 
656  AVPacket *pkt)
657 {
658  AVFormatContext *const s = &si->pub;
659  int64_t offset;
660 
662  return;
663 
664  if (si->avoid_negative_ts_status == AVOID_NEGATIVE_TS_UNKNOWN) {
665  int use_pts = si->avoid_negative_ts_use_pts;
666  int64_t ts = use_pts ? pkt->pts : pkt->dts;
667  AVRational tb = sti->pub.time_base;
668 
669  if (ts == AV_NOPTS_VALUE)
670  return;
671 
672  ts -= sti->lowest_ts_allowed;
673 
674  /* Peek into the muxing queue to improve our estimate
675  * of the lowest timestamp if av_interleaved_write_frame() is used. */
676  for (const PacketListEntry *pktl = si->packet_buffer.head;
677  pktl; pktl = pktl->next) {
678  AVRational cmp_tb = s->streams[pktl->pkt.stream_index]->time_base;
679  int64_t cmp_ts = use_pts ? pktl->pkt.pts : pktl->pkt.dts;
680  if (cmp_ts == AV_NOPTS_VALUE)
681  continue;
682  cmp_ts -= ffstream(s->streams[pktl->pkt.stream_index])->lowest_ts_allowed;
683  if (s->output_ts_offset)
684  cmp_ts += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, cmp_tb);
685  if (av_compare_ts(cmp_ts, cmp_tb, ts, tb) < 0) {
686  ts = cmp_ts;
687  tb = cmp_tb;
688  }
689  }
690 
691  if (ts < 0 ||
692  ts > 0 && s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) {
693  for (unsigned i = 0; i < s->nb_streams; i++) {
694  AVStream *const st2 = s->streams[i];
695  FFStream *const sti2 = ffstream(st2);
696  sti2->mux_ts_offset = av_rescale_q_rnd(-ts, tb,
697  st2->time_base,
698  AV_ROUND_UP);
699  }
700  }
701  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_KNOWN;
702  }
703 
704  offset = sti->mux_ts_offset;
705 
706  if (pkt->dts != AV_NOPTS_VALUE)
707  pkt->dts += offset;
708  if (pkt->pts != AV_NOPTS_VALUE)
709  pkt->pts += offset;
710 
711  if (si->avoid_negative_ts_use_pts) {
712  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < sti->lowest_ts_allowed) {
713  av_log(s, AV_LOG_WARNING, "failed to avoid negative "
714  "pts %s in stream %d.\n"
715  "Try -avoid_negative_ts 1 as a possible workaround.\n",
716  av_ts2str(pkt->pts),
718  );
719  }
720  } else {
721  if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < sti->lowest_ts_allowed) {
723  "Packets poorly interleaved, failed to avoid negative "
724  "timestamp %s in stream %d.\n"
725  "Try -max_interleave_delta 0 as a possible workaround.\n",
726  av_ts2str(pkt->dts),
728  );
729  }
730  }
731 }
732 
733 /**
734  * Shift timestamps and call muxer; the original pts/dts are not kept.
735  *
736  * FIXME: this function should NEVER get undefined pts/dts beside when the
737  * AVFMT_NOTIMESTAMPS is set.
738  * Those additional safety checks should be dropped once the correct checks
739  * are set in the callers.
740  */
742 {
743  FFFormatContext *const si = ffformatcontext(s);
744  AVStream *const st = s->streams[pkt->stream_index];
745  FFStream *const sti = ffstream(st);
746  int ret;
747 
748  // If the timestamp offsetting below is adjusted, adjust
749  // ff_interleaved_peek similarly.
750  if (s->output_ts_offset) {
751  int64_t offset = av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
752 
753  if (pkt->dts != AV_NOPTS_VALUE)
754  pkt->dts += offset;
755  if (pkt->pts != AV_NOPTS_VALUE)
756  pkt->pts += offset;
757  }
758  handle_avoid_negative_ts(si, sti, pkt);
759 
761  AVFrame **frame = (AVFrame **)pkt->data;
762  av_assert0(pkt->size == sizeof(*frame));
763  ret = ffofmt(s->oformat)->write_uncoded_frame(s, pkt->stream_index, frame, 0);
764  } else {
765  ret = ffofmt(s->oformat)->write_packet(s, pkt);
766  }
767 
768  if (s->pb && ret >= 0) {
770  if (s->pb->error < 0)
771  ret = s->pb->error;
772  }
773 
774  if (ret >= 0)
775  st->nb_frames++;
776 
777  return ret;
778 }
779 
781 {
782  if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
783  av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
784  pkt->stream_index);
785  return AVERROR(EINVAL);
786  }
787 
788  if (s->streams[pkt->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
789  av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
790  return AVERROR(EINVAL);
791  }
792 
793  return 0;
794 }
795 
797 {
798  FFStream *const sti = ffstream(st);
799 #if !FF_API_COMPUTE_PKT_FIELDS2
800  /* sanitize the timestamps */
801  if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
802 
803  /* when there is no reordering (so dts is equal to pts), but
804  * only one of them is set, set the other as well */
805  if (!sti->reorder) {
806  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)
807  pkt->pts = pkt->dts;
808  if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
809  pkt->dts = pkt->pts;
810  }
811 
812  /* check that the timestamps are set */
813  if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {
815  "Timestamps are unset in a packet for stream %d\n", st->index);
816  return AVERROR(EINVAL);
817  }
818 
819  /* check that the dts are increasing (or at least non-decreasing,
820  * if the format allows it */
821  if (sti->cur_dts != AV_NOPTS_VALUE &&
822  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && sti->cur_dts >= pkt->dts) ||
823  sti->cur_dts > pkt->dts)) {
825  "Application provided invalid, non monotonically increasing "
826  "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
827  st->index, sti->cur_dts, pkt->dts);
828  return AVERROR(EINVAL);
829  }
830 
831  if (pkt->pts < pkt->dts) {
832  av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
833  pkt->pts, pkt->dts, st->index);
834  return AVERROR(EINVAL);
835  }
836  }
837 #endif
838  /* update flags */
839  if (sti->is_intra_only)
841 
842  if (!pkt->data && !pkt->side_data_elems) {
843  /* Such empty packets signal EOS for the BSF API; so sanitize
844  * the packet by allocating data of size 0 (+ padding). */
847  }
848 
849  return 0;
850 }
851 
852 #define CHUNK_START 0x1000
853 
855  int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
856 {
857  int ret;
858  FFFormatContext *const si = ffformatcontext(s);
859  PacketListEntry **next_point, *this_pktl;
860  AVStream *st = s->streams[pkt->stream_index];
861  FFStream *const sti = ffstream(st);
862  int chunked = s->max_chunk_size || s->max_chunk_duration;
863 
864  this_pktl = av_malloc(sizeof(*this_pktl));
865  if (!this_pktl) {
867  return AVERROR(ENOMEM);
868  }
869  if ((ret = av_packet_make_refcounted(pkt)) < 0) {
870  av_free(this_pktl);
872  return ret;
873  }
874 
875  av_packet_move_ref(&this_pktl->pkt, pkt);
876  pkt = &this_pktl->pkt;
877 
878  if (sti->last_in_packet_buffer) {
879  next_point = &(sti->last_in_packet_buffer->next);
880  } else {
881  next_point = &si->packet_buffer.head;
882  }
883 
884  if (chunked) {
885  uint64_t max= av_rescale_q_rnd(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base, AV_ROUND_UP);
888  if ( (s->max_chunk_size && sti->interleaver_chunk_size > s->max_chunk_size)
889  || (max && sti->interleaver_chunk_duration > max)) {
890  sti->interleaver_chunk_size = 0;
891  pkt->flags |= CHUNK_START;
892  if (max && sti->interleaver_chunk_duration > max) {
893  int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
894  int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
895 
896  sti->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
897  } else
899  }
900  }
901  if (*next_point) {
902  if (chunked && !(pkt->flags & CHUNK_START))
903  goto next_non_null;
904 
905  if (compare(s, &si->packet_buffer.tail->pkt, pkt)) {
906  while ( *next_point
907  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
908  || !compare(s, &(*next_point)->pkt, pkt)))
909  next_point = &(*next_point)->next;
910  if (*next_point)
911  goto next_non_null;
912  } else {
913  next_point = &(si->packet_buffer.tail->next);
914  }
915  }
916  av_assert1(!*next_point);
917 
918  si->packet_buffer.tail = this_pktl;
919 next_non_null:
920 
921  this_pktl->next = *next_point;
922 
923  sti->last_in_packet_buffer = *next_point = this_pktl;
924 
925  return 0;
926 }
927 
929  const AVPacket *pkt)
930 {
931  AVStream *st = s->streams[pkt->stream_index];
932  AVStream *st2 = s->streams[next->stream_index];
933  int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
934  st->time_base);
935  if (s->audio_preload) {
936  int preload = st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
937  int preload2 = st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
938  if (preload != preload2) {
939  int64_t ts, ts2;
940  preload *= s->audio_preload;
941  preload2 *= s->audio_preload;
942  ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - preload;
943  ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - preload2;
944  if (ts == ts2) {
945  ts = ((uint64_t)pkt ->dts*st ->time_base.num*AV_TIME_BASE - (uint64_t)preload *st ->time_base.den)*st2->time_base.den
946  - ((uint64_t)next->dts*st2->time_base.num*AV_TIME_BASE - (uint64_t)preload2*st2->time_base.den)*st ->time_base.den;
947  ts2 = 0;
948  }
949  comp = (ts2 > ts) - (ts2 < ts);
950  }
951  }
952 
953  if (comp == 0)
954  return pkt->stream_index < next->stream_index;
955  return comp > 0;
956 }
957 
959  int flush, int has_packet)
960 {
961  FFFormatContext *const si = ffformatcontext(s);
962  int stream_count = 0;
963  int noninterleaved_count = 0;
964  int ret;
965  int eof = flush;
966 
967  if (has_packet) {
969  return ret;
970  }
971 
972  for (unsigned i = 0; i < s->nb_streams; i++) {
973  const AVStream *const st = s->streams[i];
974  const FFStream *const sti = cffstream(st);
975  const AVCodecParameters *const par = st->codecpar;
976  if (sti->last_in_packet_buffer) {
977  ++stream_count;
978  } else if (par->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
979  par->codec_id != AV_CODEC_ID_VP8 &&
980  par->codec_id != AV_CODEC_ID_VP9 &&
982  ++noninterleaved_count;
983  }
984  }
985 
986  if (si->nb_interleaved_streams == stream_count)
987  flush = 1;
988 
989  if (s->max_interleave_delta > 0 &&
990  si->packet_buffer.head &&
992  !flush &&
993  si->nb_interleaved_streams == stream_count+noninterleaved_count
994  ) {
995  AVPacket *const top_pkt = &si->packet_buffer.head->pkt;
996  int64_t delta_dts = INT64_MIN;
997  int64_t top_dts = av_rescale_q(top_pkt->dts,
998  s->streams[top_pkt->stream_index]->time_base,
1000 
1001  for (unsigned i = 0; i < s->nb_streams; i++) {
1002  const AVStream *const st = s->streams[i];
1003  const FFStream *const sti = cffstream(st);
1004  const PacketListEntry *const last = sti->last_in_packet_buffer;
1005  int64_t last_dts;
1006 
1007  if (!last || st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
1008  continue;
1009 
1010  last_dts = av_rescale_q(last->pkt.dts,
1011  st->time_base,
1012  AV_TIME_BASE_Q);
1013  delta_dts = FFMAX(delta_dts, last_dts - top_dts);
1014  }
1015 
1016  if (delta_dts > s->max_interleave_delta) {
1018  "Delay between the first packet and last packet in the "
1019  "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
1020  delta_dts, s->max_interleave_delta);
1021  flush = 1;
1022  }
1023  }
1024 
1025 #if FF_API_LAVF_SHORTEST
1026  if (si->packet_buffer.head &&
1027  eof &&
1028  (s->flags & AVFMT_FLAG_SHORTEST) &&
1029  si->shortest_end == AV_NOPTS_VALUE) {
1030  AVPacket *const top_pkt = &si->packet_buffer.head->pkt;
1031 
1032  si->shortest_end = av_rescale_q(top_pkt->dts,
1033  s->streams[top_pkt->stream_index]->time_base,
1034  AV_TIME_BASE_Q);
1035  }
1036 
1037  if (si->shortest_end != AV_NOPTS_VALUE) {
1038  while (si->packet_buffer.head) {
1039  PacketListEntry *pktl = si->packet_buffer.head;
1040  AVPacket *const top_pkt = &pktl->pkt;
1041  AVStream *const st = s->streams[top_pkt->stream_index];
1042  FFStream *const sti = ffstream(st);
1043  int64_t top_dts = av_rescale_q(top_pkt->dts, st->time_base,
1044  AV_TIME_BASE_Q);
1045 
1046  if (si->shortest_end + 1 >= top_dts)
1047  break;
1048 
1049  si->packet_buffer.head = pktl->next;
1050  if (!si->packet_buffer.head)
1051  si->packet_buffer.tail = NULL;
1052 
1053  if (sti->last_in_packet_buffer == pktl)
1054  sti->last_in_packet_buffer = NULL;
1055 
1056  av_packet_unref(&pktl->pkt);
1057  av_freep(&pktl);
1058  flush = 0;
1059  }
1060  }
1061 #endif
1062 
1063  if (stream_count && flush) {
1064  PacketListEntry *pktl = si->packet_buffer.head;
1065  AVStream *const st = s->streams[pktl->pkt.stream_index];
1066  FFStream *const sti = ffstream(st);
1067 
1068  if (sti->last_in_packet_buffer == pktl)
1069  sti->last_in_packet_buffer = NULL;
1071 
1072  return 1;
1073  } else {
1074  return 0;
1075  }
1076 }
1077 
1079  int flush, int has_packet)
1080 {
1081  return has_packet;
1082 }
1083 
1084 int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
1085 {
1086  AVStream *st;
1087 
1088  if (stream_index < 0 || stream_index >= s->nb_streams)
1089  return AVERROR(EINVAL);
1090 
1091  st = s->streams[stream_index];
1092  *offset = ffstream(st)->mux_ts_offset;
1093 
1094  if (s->output_ts_offset)
1095  *offset += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
1096 
1097  return 0;
1098 }
1099 
1101 {
1102  FFFormatContext *const si = ffformatcontext(s);
1103  PacketListEntry *pktl = si->packet_buffer.head;
1104  while (pktl) {
1105  if (pktl->pkt.stream_index == stream) {
1106  return &pktl->pkt;
1107  }
1108  pktl = pktl->next;
1109  }
1110  return NULL;
1111 }
1112 
1114 {
1115  int ret;
1116 
1117  if (!(s->flags & AVFMT_FLAG_AUTO_BSF))
1118  return 1;
1119 
1120  if (ffofmt(s->oformat)->check_bitstream) {
1121  if (!sti->bitstream_checked) {
1122  if ((ret = ffofmt(s->oformat)->check_bitstream(s, &sti->pub, pkt)) < 0)
1123  return ret;
1124  else if (ret == 1)
1125  sti->bitstream_checked = 1;
1126  }
1127  }
1128 
1129  return 1;
1130 }
1131 
1133  int flush, int has_packet)
1134 {
1135  FFFormatContext *const si = ffformatcontext(s);
1136  for (;; ) {
1137  int ret = si->interleave_packet(s, pkt, flush, has_packet);
1138  if (ret <= 0)
1139  return ret;
1140 
1141  has_packet = 0;
1142 
1143  ret = write_packet(s, pkt);
1145  if (ret < 0)
1146  return ret;
1147  }
1148 }
1149 
1150 static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1151 {
1152  int ret;
1153 
1154  if (s->debug & FF_FDEBUG_TS)
1155  av_log(s, AV_LOG_DEBUG, "%s size:%d dts:%s pts:%s\n", __func__,
1157 
1158  guess_pkt_duration(s, st, pkt);
1159 
1160 #if FF_API_COMPUTE_PKT_FIELDS2
1161  if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1162  return ret;
1163 #endif
1164 
1165  if (interleaved) {
1166  if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1167  return AVERROR(EINVAL);
1168  return interleaved_write_packet(s, pkt, 0, 1);
1169  } else {
1170  return write_packet(s, pkt);
1171  }
1172 }
1173 
1174 static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1175 {
1176  FFStream *const sti = ffstream(st);
1177  AVBSFContext *const bsfc = sti->bsfc;
1178  int ret;
1179 
1180  if ((ret = av_bsf_send_packet(bsfc, pkt)) < 0) {
1182  "Failed to send packet to filter %s for stream %d\n",
1183  bsfc->filter->name, st->index);
1184  return ret;
1185  }
1186 
1187  do {
1188  ret = av_bsf_receive_packet(bsfc, pkt);
1189  if (ret < 0) {
1190  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
1191  return 0;
1192  av_log(s, AV_LOG_ERROR, "Error applying bitstream filters to an output "
1193  "packet for stream #%d: %s\n", st->index, av_err2str(ret));
1194  if (!(s->error_recognition & AV_EF_EXPLODE) && ret != AVERROR(ENOMEM))
1195  continue;
1196  return ret;
1197  }
1199  ret = write_packet_common(s, st, pkt, interleaved);
1200  if (ret >= 0 && !interleaved) // a successful write_packet_common already unrefed pkt for interleaved
1202  } while (ret >= 0);
1203 
1204  return ret;
1205 }
1206 
1207 static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
1208 {
1209  AVStream *st;
1210  FFStream *sti;
1211  int ret = check_packet(s, pkt);
1212  if (ret < 0)
1213  return ret;
1214  st = s->streams[pkt->stream_index];
1215  sti = ffstream(st);
1216 
1217  ret = prepare_input_packet(s, st, pkt);
1218  if (ret < 0)
1219  return ret;
1220 
1221  ret = check_bitstream(s, sti, pkt);
1222  if (ret < 0)
1223  return ret;
1224 
1225  if (sti->bsfc) {
1226  return write_packets_from_bsfs(s, st, pkt, interleaved);
1227  } else {
1228  return write_packet_common(s, st, pkt, interleaved);
1229  }
1230 }
1231 
1233 {
1234  FFFormatContext *const si = ffformatcontext(s);
1235  AVPacket *pkt = si->parse_pkt;
1236  int ret;
1237 
1238  if (!in) {
1239  if (ffofmt(s->oformat)->flags_internal & FF_OFMT_FLAG_ALLOW_FLUSH) {
1240  ret = ffofmt(s->oformat)->write_packet(s, NULL);
1241  flush_if_needed(s);
1242  if (ret >= 0 && s->pb && s->pb->error < 0)
1243  ret = s->pb->error;
1244  return ret;
1245  }
1246  return 1;
1247  }
1248 
1249  if (in->flags & AV_PKT_FLAG_UNCODED_FRAME) {
1250  pkt = in;
1251  } else {
1252  /* We don't own in, so we have to make sure not to modify it.
1253  * (ff_write_chained() relies on this fact.)
1254  * The following avoids copying in's data unnecessarily.
1255  * Copying side data is unavoidable as a bitstream filter
1256  * may change it, e.g. free it on errors. */
1257  pkt->data = in->data;
1258  pkt->size = in->size;
1260  if (ret < 0)
1261  return ret;
1262  if (in->buf) {
1263  pkt->buf = av_buffer_ref(in->buf);
1264  if (!pkt->buf) {
1265  ret = AVERROR(ENOMEM);
1266  goto fail;
1267  }
1268  }
1269  }
1270 
1271  ret = write_packets_common(s, pkt, 0/*non-interleaved*/);
1272 
1273 fail:
1274  // Uncoded frames using the noninterleaved codepath are also freed here
1276  return ret;
1277 }
1278 
1280 {
1281  int ret;
1282 
1283  if (pkt) {
1284  ret = write_packets_common(s, pkt, 1/*interleaved*/);
1285  if (ret < 0)
1287  return ret;
1288  } else {
1289  av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");
1290  return interleaved_write_packet(s, ffformatcontext(s)->parse_pkt, 1/*flush*/, 0);
1291  }
1292 }
1293 
1295 {
1296  FFFormatContext *const si = ffformatcontext(s);
1297  AVPacket *const pkt = si->parse_pkt;
1298  int ret1, ret = 0;
1299 
1300  for (unsigned i = 0; i < s->nb_streams; i++) {
1301  AVStream *const st = s->streams[i];
1302  FFStream *const sti = ffstream(st);
1303  if (sti->bsfc) {
1304  ret1 = write_packets_from_bsfs(s, st, pkt, 1/*interleaved*/);
1305  if (ret1 < 0)
1307  if (ret >= 0)
1308  ret = ret1;
1309  }
1310  }
1311  ret1 = interleaved_write_packet(s, pkt, 1, 0);
1312  if (ret >= 0)
1313  ret = ret1;
1314 
1315  if (ffofmt(s->oformat)->write_trailer) {
1316  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1318  ret1 = ffofmt(s->oformat)->write_trailer(s);
1319  if (ret >= 0)
1320  ret = ret1;
1321  }
1322 
1323  deinit_muxer(s);
1324 
1325  if (s->pb)
1326  avio_flush(s->pb);
1327  if (ret == 0)
1328  ret = s->pb ? s->pb->error : 0;
1329  for (unsigned i = 0; i < s->nb_streams; i++) {
1330  av_freep(&s->streams[i]->priv_data);
1331  av_freep(&ffstream(s->streams[i])->index_entries);
1332  }
1333  if (s->oformat->priv_class)
1334  av_opt_free(s->priv_data);
1335  av_freep(&s->priv_data);
1336  av_packet_unref(si->pkt);
1337  return ret;
1338 }
1339 
1341  int64_t *dts, int64_t *wall)
1342 {
1343  const FFOutputFormat *const of = ffofmt(s->oformat);
1344  if (!of || !of->get_output_timestamp)
1345  return AVERROR(ENOSYS);
1346  of->get_output_timestamp(s, stream, dts, wall);
1347  return 0;
1348 }
1349 
1350 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
1351 {
1352  int ret;
1353  const AVBitStreamFilter *bsf;
1354  FFStream *const sti = ffstream(st);
1355  AVBSFContext *bsfc;
1356 
1357  av_assert0(!sti->bsfc);
1358 
1359  if (!(bsf = av_bsf_get_by_name(name))) {
1360  av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
1361  return AVERROR_BSF_NOT_FOUND;
1362  }
1363 
1364  if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
1365  return ret;
1366 
1367  bsfc->time_base_in = st->time_base;
1368  if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
1369  av_bsf_free(&bsfc);
1370  return ret;
1371  }
1372 
1373  if (args && bsfc->filter->priv_class) {
1374  if ((ret = av_set_options_string(bsfc->priv_data, args, "=", ":")) < 0) {
1375  av_bsf_free(&bsfc);
1376  return ret;
1377  }
1378  }
1379 
1380  if ((ret = av_bsf_init(bsfc)) < 0) {
1381  av_bsf_free(&bsfc);
1382  return ret;
1383  }
1384 
1385  sti->bsfc = bsfc;
1386 
1388  "Automatically inserted bitstream filter '%s'; args='%s'\n",
1389  name, args ? args : "");
1390  return 1;
1391 }
1392 
1393 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
1395 {
1396  int64_t pts = pkt->pts, dts = pkt->dts, duration = pkt->duration;
1397  int stream_index = pkt->stream_index;
1398  AVRational time_base = pkt->time_base;
1399  int ret;
1400 
1401  pkt->stream_index = dst_stream;
1402 
1404  src->streams[stream_index]->time_base,
1405  dst->streams[dst_stream]->time_base);
1406 
1407  if (!interleave) {
1408  ret = av_write_frame(dst, pkt);
1409  /* We only have to backup and restore the fields that
1410  * we changed ourselves, because av_write_frame() does not
1411  * modify the packet given to it. */
1412  pkt->pts = pts;
1413  pkt->dts = dts;
1414  pkt->duration = duration;
1415  pkt->stream_index = stream_index;
1416  pkt->time_base = time_base;
1417  } else
1419 
1420  return ret;
1421 }
1422 
1423 static void uncoded_frame_free(void *unused, uint8_t *data)
1424 {
1425  av_frame_free((AVFrame **)data);
1426  av_free(data);
1427 }
1428 
1429 static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
1430  AVFrame *frame, int interleaved)
1431 {
1432  FFFormatContext *const si = ffformatcontext(s);
1433  AVPacket *pkt = si->parse_pkt;
1434 
1435  av_assert0(s->oformat);
1436  if (!ffofmt(s->oformat)->write_uncoded_frame) {
1437  av_frame_free(&frame);
1438  return AVERROR(ENOSYS);
1439  }
1440 
1441  if (!frame) {
1442  pkt = NULL;
1443  } else {
1444  size_t bufsize = sizeof(frame) + AV_INPUT_BUFFER_PADDING_SIZE;
1445  AVFrame **framep = av_mallocz(bufsize);
1446 
1447  if (!framep)
1448  goto fail;
1449  pkt->buf = av_buffer_create((void *)framep, bufsize,
1450  uncoded_frame_free, NULL, 0);
1451  if (!pkt->buf) {
1452  av_free(framep);
1453  fail:
1454  av_frame_free(&frame);
1455  return AVERROR(ENOMEM);
1456  }
1457  *framep = frame;
1458 
1459  pkt->data = (void *)framep;
1460  pkt->size = sizeof(frame);
1461  pkt->pts =
1462  pkt->dts = frame->pts;
1463  pkt->duration = frame->duration;
1464  pkt->stream_index = stream_index;
1466  }
1467 
1468  return interleaved ? av_interleaved_write_frame(s, pkt) :
1469  av_write_frame(s, pkt);
1470 }
1471 
1473  AVFrame *frame)
1474 {
1475  return write_uncoded_frame_internal(s, stream_index, frame, 0);
1476 }
1477 
1479  AVFrame *frame)
1480 {
1481  return write_uncoded_frame_internal(s, stream_index, frame, 1);
1482 }
1483 
1485 {
1486  const FFOutputFormat *const of = ffofmt(s->oformat);
1487  av_assert0(of);
1488  if (!of->write_uncoded_frame)
1489  return AVERROR(ENOSYS);
1490  return of->write_uncoded_frame(s, stream_index, NULL,
1492 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:522
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:427
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AVBSFContext::par_in
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:90
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
name
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 default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
LIBAVFORMAT_IDENT
#define LIBAVFORMAT_IDENT
Definition: version.h:45
PacketList::head
PacketListEntry * head
Definition: packet_internal.h:34
avpriv_packet_list_get
int avpriv_packet_list_get(PacketList *pkt_buffer, AVPacket *pkt)
Remove the oldest AVPacket in the list and return it.
Definition: avpacket.c:580
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1640
AVOutputFormat::name
const char * name
Definition: avformat.h:510
AVSTREAM_INIT_IN_WRITE_HEADER
#define AVSTREAM_INIT_IN_WRITE_HEADER
stream parameters initialized in avformat_write_header
Definition: avformat.h:2443
AVERROR
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
opt.h
FFFormatContext::interleave_packet
int(* interleave_packet)(struct AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
The interleavement function in use.
Definition: internal.h:90
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
av_compare_ts
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
AVFMT_NODIMENSIONS
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:483
FF_FDEBUG_TS
#define FF_FDEBUG_TS
Definition: avformat.h:1534
FFStream::bsfc
struct AVBSFContext * bsfc
bitstream filter to run on stream
Definition: internal.h:211
ff_interleave_packet_per_dts
int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
Interleave an AVPacket per dts so it can be muxed.
Definition: mux.c:958
avformat_alloc_output_context2
int avformat_alloc_output_context2(AVFormatContext **avctx, const AVOutputFormat *oformat, const char *format, const char *filename)
Allocate an AVFormatContext for an output format.
Definition: mux.c:93
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:80
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:188
interleaved_write_packet
static int interleaved_write_packet(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
Definition: mux.c:1132
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AV_DISPOSITION_ATTACHED_PIC
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:674
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:479
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
AVCodecTag::id
enum AVCodecID id
Definition: internal.h:43
AVBitStreamFilter::name
const char * name
Definition: bsf.h:112
init_muxer
static int init_muxer(AVFormatContext *s, AVDictionary **options)
Definition: mux.c:185
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1323
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:373
FFStream::interleaver_chunk_size
int64_t interleaver_chunk_size
Definition: internal.h:254
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:522
FFOutputFormat::flags_internal
int flags_internal
Internal flags.
Definition: mux.h:74
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:832
data
const char data[16]
Definition: mxf.c:148
FFFormatContext::initialized
int initialized
Whether or not avformat_init_output has already been called.
Definition: internal.h:160
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:75
ff_toupper4
unsigned int ff_toupper4(unsigned int x)
Definition: to_upper4.h:29
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:540
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
max
#define max(a, b)
Definition: cuda_runtime.h:33
mathematics.h
AVDictionary
Definition: dict.c:34
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS
#define FF_OFMT_FLAG_ONLY_DEFAULT_CODECS
If this flag is set, then the only permitted audio/video/subtitle codec ids are AVOutputFormat....
Definition: mux.h:59
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
av_write_uncoded_frame_query
int av_write_uncoded_frame_query(AVFormatContext *s, int stream_index)
Test whether a muxer supports uncoded frame.
Definition: mux.c:1484
avformat_init_output
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:465
cffstream
static const av_always_inline FFStream * cffstream(const AVStream *st)
Definition: internal.h:422
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
av_bsf_free
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
Definition: bsf.c:52
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:577
ff_get_muxer_ts_offset
int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
Definition: mux.c:1084
AVBSFContext
The bitstream filter state.
Definition: bsf.h:68
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:65
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
avio_write_marker
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:460
FFStream::is_intra_only
int is_intra_only
Definition: internal.h:240
AVPacketSideData::size
size_t size
Definition: packet.h:375
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:853
bsf.h
deinit_muxer
static void deinit_muxer(AVFormatContext *s)
Definition: mux.c:455
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:417
fail
#define fail()
Definition: checkasm.h:179
AVFMT_FLAG_AUTO_BSF
#define AVFMT_FLAG_AUTO_BSF
Add bitstream filters as requested by the muxer.
Definition: avformat.h:1429
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1910
val
static double val(void *priv, double ch)
Definition: aeval.c:78
AVFMT_AVOID_NEG_TS_MAKE_ZERO
#define AVFMT_AVOID_NEG_TS_MAKE_ZERO
Shift timestamps so that they start at 0.
Definition: avformat.h:1646
type
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 type
Definition: writing_filters.txt:86
AV_DISPOSITION_TIMED_THUMBNAILS
#define AV_DISPOSITION_TIMED_THUMBNAILS
The stream is sparse, and contains thumbnail images, often corresponding to chapter markers.
Definition: avformat.h:679
pts
static int64_t pts
Definition: transcode_aac.c:643
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:134
AVRational::num
int num
Numerator.
Definition: rational.h:59
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:547
avassert.h
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVCodecTag
Definition: internal.h:42
duration
int64_t duration
Definition: movenc.c:64
av_dict_get
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:62
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
s
#define s(width, name)
Definition: cbs_vp9.c:198
FFFormatContext::packet_buffer
PacketList packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:98
format
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
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:144
AVDictionaryEntry::key
char * key
Definition: dict.h:90
frame_size
int frame_size
Definition: mxfenc.c:2422
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:220
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
MAX_REORDER_DELAY
@ MAX_REORDER_DELAY
Definition: vaapi_encode.h:45
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
av_set_options_string
int av_set_options_string(void *ctx, const char *opts, const char *key_val_sep, const char *pairs_sep)
Parse the key/value pairs list in opts.
Definition: opt.c:1778
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AVPacketSideData::data
uint8_t * data
Definition: packet.h:374
write_packets_from_bsfs
static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1174
ffofmt
static const FFOutputFormat * ffofmt(const AVOutputFormat *fmt)
Definition: mux.h:167
AVBSFContext::time_base_in
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: bsf.h:102
av_rescale_q
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
av_bsf_alloc
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:104
AVOutputFormat::codec_tag
const struct AVCodecTag *const * codec_tag
List of supported codec_id-codec_tag pairs, ordered by "better choice first".
Definition: avformat.h:535
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:86
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
AudioData::data
uint8_t * data
samples buffer
Definition: swresample_internal.h:47
avformat_write_header
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:486
PacketList::tail
PacketListEntry * tail
Definition: packet_internal.h:34
init_pts
static int init_pts(AVFormatContext *s)
Definition: mux.c:402
if
if(ret)
Definition: filter_design.txt:179
FFFormatContext
Definition: internal.h:64
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:222
compute_muxer_pkt_fields
static FF_DISABLE_DEPRECATION_WARNINGS int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:528
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
FFStream::pub
AVStream pub
The public context.
Definition: internal.h:197
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:505
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
av_bsf_init
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:149
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AVFMT_AVOID_NEG_TS_DISABLED
#define AVFMT_AVOID_NEG_TS_DISABLED
Do not shift timestamps even when they are negative.
Definition: avformat.h:1644
av_write_uncoded_frame
int av_write_uncoded_frame(AVFormatContext *s, int stream_index, AVFrame *frame)
Write an uncoded frame to an output media file.
Definition: mux.c:1472
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
FFStream::bitstream_checked
int bitstream_checked
Whether or not check_bitstream should still be run on each packet.
Definition: internal.h:216
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:782
NULL
#define NULL
Definition: coverity.c:32
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:230
FFFormatContext::avoid_negative_ts_status
enum FFFormatContext::@316 avoid_negative_ts_status
Whether the timestamp shift offset has already been determined.
AVIO_DATA_MARKER_TRAILER
@ AVIO_DATA_MARKER_TRAILER
Trailer data, which doesn't contain actual content, but only for finalizing the output file.
Definition: avio.h:139
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
FFOutputFormat::write_packet
int(* write_packet)(AVFormatContext *, AVPacket *pkt)
Write a packet.
Definition: mux.h:84
guess_pkt_duration
static FF_ENABLE_DEPRECATION_WARNINGS void guess_pkt_duration(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:624
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:376
FFOutputFormat::deinit
void(* deinit)(AVFormatContext *)
Deinitialize format.
Definition: mux.h:154
AVERROR_BSF_NOT_FOUND
#define AVERROR_BSF_NOT_FOUND
Bitstream filter not found.
Definition: error.h:51
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:367
AVBitStreamFilter::priv_class
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions.
Definition: bsf.h:130
write_packets_common
static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
Definition: mux.c:1207
FFOutputFormat
Definition: mux.h:61
AVOutputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:538
av_write_frame
int av_write_frame(AVFormatContext *s, AVPacket *in)
Write a packet to an output media file.
Definition: mux.c:1232
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
FFStream::interleaver_chunk_duration
int64_t interleaver_chunk_duration
Definition: internal.h:255
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:484
PacketListEntry::next
struct PacketListEntry * next
Definition: packet_internal.h:29
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
AVStream::nb_frames
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:804
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
validate_codec_tag
static int validate_codec_tag(const AVFormatContext *s, const AVStream *st)
Definition: mux.c:151
AVOutputFormat::flags
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:529
AVOID_NEGATIVE_TS_ENABLED
#define AVOID_NEGATIVE_TS_ENABLED(status)
Definition: internal.h:85
interleave
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:110
options
const OptionDef options[]
f
f
Definition: af_crystalizer.c:121
AVPacket::size
int size
Definition: packet.h:523
FFFormatContext::parse_pkt
AVPacket * parse_pkt
The generic code uses this as a temporary packet to parse packets or for muxing, especially flushing.
Definition: internal.h:127
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:160
av_codec_get_tag
unsigned int av_codec_get_tag(const struct AVCodecTag *const *tags, enum AVCodecID id)
Get the codec tag for the given codec id id.
FF_OFMT_FLAG_ALLOW_FLUSH
#define FF_OFMT_FLAG_ALLOW_FLUSH
This flag indicates that the muxer stores data internally and supports flushing it.
Definition: mux.h:38
FFFrac::val
int64_t val
Definition: internal.h:60
FFStream
Definition: internal.h:193
AV_CODEC_PROP_REORDER
#define AV_CODEC_PROP_REORDER
Codec supports frame reordering.
Definition: codec_desc.h:92
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:202
uncoded_frame_free
static void uncoded_frame_free(void *unused, uint8_t *data)
Definition: mux.c:1423
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:121
FFOutputFormat::check_bitstream
int(* check_bitstream)(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
Set up any necessary bitstream filtering and extract any extra data needed for the global header.
Definition: mux.h:163
AV_PKT_FLAG_UNCODED_FRAME
#define AV_PKT_FLAG_UNCODED_FRAME
Definition: mux.c:522
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
av_get_audio_frame_duration2
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:796
PacketListEntry::pkt
AVPacket pkt
Definition: packet_internal.h:30
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
write_uncoded_frame_internal
static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index, AVFrame *frame, int interleaved)
Definition: mux.c:1429
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:821
frame.h
AVFMT_NOSTREAMS
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:484
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:521
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: defs.h:60
FFOutputFormat::interleave_packet
int(* interleave_packet)(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
A format-specific function for interleavement.
Definition: mux.h:102
offset
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
Definition: writing_filters.txt:86
prepare_input_packet
static int prepare_input_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:796
av_packet_make_refcounted
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:490
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:528
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
av_packet_rescale_ts
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:531
FFOutputFormat::priv_data_size
int priv_data_size
size of private data so that it can be allocated in the wrapper
Definition: mux.h:69
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:406
FFOutputFormat::write_header
int(* write_header)(AVFormatContext *)
Definition: mux.h:76
av_write_trailer
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
Definition: mux.c:1294
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
av_packet_copy_props
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:390
ff_is_intra_only
int ff_is_intra_only(enum AVCodecID id)
Definition: avformat.c:926
ff_interleaved_peek
const AVPacket * ff_interleaved_peek(AVFormatContext *s, int stream)
Find the next packet in the interleaving queue for the given stream.
Definition: mux.c:1100
PacketListEntry
Definition: packet_internal.h:28
FFStream::mux_ts_offset
int64_t mux_ts_offset
Timestamp offset added to timestamps before muxing.
Definition: internal.h:308
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
AVOutputFormat
Definition: avformat.h:509
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
av_opt_set_dict2
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:1923
AV_CODEC_ID_SMPTE_2038
@ AV_CODEC_ID_SMPTE_2038
Definition: codec_id.h:590
internal.h
FFStream::priv_pts
FFFrac priv_pts
Definition: internal.h:242
AVCodecParameters::height
int height
Definition: codec_par.h:135
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:191
CHUNK_START
#define CHUNK_START
Definition: mux.c:852
check_bitstream
static int check_bitstream(AVFormatContext *s, FFStream *sti, AVPacket *pkt)
Definition: mux.c:1113
ff_interleave_add_packet
int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt, int(*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
Add packet to an AVFormatContext's packet_buffer list, determining its interleaved position using com...
Definition: mux.c:854
av_get_output_timestamp
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:1340
FF_OFMT_FLAG_MAX_ONE_OF_EACH
#define FF_OFMT_FLAG_MAX_ONE_OF_EACH
If this flag is set, it indicates that for each codec type whose corresponding default codec (i....
Definition: mux.h:50
FFStream::reorder
int reorder
Set to 1 if the codec allows reordering, so pts can be different from dts.
Definition: internal.h:204
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE
#define AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE
Shift timestamps so they are non negative.
Definition: avformat.h:1645
write_packet
static int write_packet(AVFormatContext *s, AVPacket *pkt)
Shift timestamps and call muxer; the original pts/dts are not kept.
Definition: mux.c:741
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:205
FFStream::pts_buffer
int64_t pts_buffer[MAX_REORDER_DELAY+1]
Definition: internal.h:347
tb
#define tb
Definition: regdef.h:68
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
av_rescale
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
AVBSFContext::time_base_out
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: bsf.h:108
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition: codec_par.h:81
FFStream::last_in_packet_buffer
PacketListEntry * last_in_packet_buffer
last packet in packet_buffer for this stream when muxing.
Definition: internal.h:375
AVIO_DATA_MARKER_UNKNOWN
@ AVIO_DATA_MARKER_UNKNOWN
This is any, unlabelled data.
Definition: avio.h:134
AVFMT_TS_NEGATIVE
#define AVFMT_TS_NEGATIVE
Format allows muxing negative timestamps.
Definition: avformat.h:494
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:491
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
version.h
AVBSFContext::priv_data
void * priv_data
Opaque filter-specific private data.
Definition: bsf.h:83
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:812
FFOutputFormat::get_output_timestamp
void(* get_output_timestamp)(AVFormatContext *s, int stream, int64_t *dts, int64_t *wall)
Definition: mux.h:113
tag
uint32_t tag
Definition: movenc.c:1786
AVFMT_FLAG_BITEXACT
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1423
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
frame
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
Definition: filter_design.txt:264
interleave_compare_dts
static int interleave_compare_dts(AVFormatContext *s, const AVPacket *next, const AVPacket *pkt)
Definition: mux.c:928
avformat.h
dict.h
av_packet_side_data_new
AVPacketSideData * av_packet_side_data_new(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, size_t size, int flags)
Allocate a new packet side data.
Definition: avpacket.c:704
frac_init
static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
f = val + (num / den) + 0.5.
Definition: mux.c:55
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:28
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:749
compare
static float compare(const AVFrame *haystack, const AVFrame *obj, int offx, int offy)
Definition: vf_find_rect.c:96
AVBitStreamFilter
Definition: bsf.h:111
AVRational::den
int den
Denominator.
Definition: rational.h:60
write_packet_common
static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1150
AVIO_DATA_MARKER_HEADER
@ AVIO_DATA_MARKER_HEADER
Header data; this needs to be present for the stream to be decodeable.
Definition: avio.h:114
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:141
AV_WRITE_UNCODED_FRAME_QUERY
@ AV_WRITE_UNCODED_FRAME_QUERY
Query whether the feature is possible on this stream.
Definition: mux.h:239
AVSTREAM_INIT_IN_INIT_OUTPUT
#define AVSTREAM_INIT_IN_INIT_OUTPUT
stream parameters initialized in avformat_init_output
Definition: avformat.h:2444
AVPacket::stream_index
int stream_index
Definition: packet.h:524
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:249
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AVBSFContext::filter
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: bsf.h:77
flush_if_needed
static void flush_if_needed(AVFormatContext *s)
Definition: mux.c:445
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
desc
const char * desc
Definition: libsvtav1.c:75
FFFormatContext::streams_initialized
int streams_initialized
Whether or not avformat_init_output fully initialized streams.
Definition: internal.h:165
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_guess_format
const 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:80
FFFrac::num
int64_t num
Definition: internal.h:60
packet_internal.h
handle_avoid_negative_ts
static void handle_avoid_negative_ts(FFFormatContext *si, FFStream *sti, AVPacket *pkt)
Definition: mux.c:655
AVCodecParameters::video_delay
int video_delay
Video only.
Definition: codec_par.h:175
FFFormatContext::pkt
AVPacket * pkt
Used to hold temporary packets for the generic demuxing code.
Definition: internal.h:134
check_packet
static int check_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:780
ff_interleave_packet_passthrough
int ff_interleave_packet_passthrough(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
Interleave packets directly in the order in which they arrive without any sort of buffering.
Definition: mux.c:1078
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
SwrContext::in
AudioData in
input audio data
Definition: swresample_internal.h:146
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
av_interleaved_write_uncoded_frame
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:1478
AVPacket
This structure stores compressed data.
Definition: packet.h:499
av_interleaved_write_frame
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file ensuring correct interleaving.
Definition: mux.c:1279
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
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:88
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:237
FFStream::cur_dts
int64_t cur_dts
Definition: internal.h:410
FFOutputFormat::write_trailer
int(* write_trailer)(AVFormatContext *)
Definition: mux.h:85
frac_add
static void frac_add(FFFrac *f, int64_t incr)
Fractional addition to f: f = f + (incr / f->den).
Definition: mux.c:73
timestamp.h
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:192
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
AVFMT_FLAG_FLUSH_PACKETS
#define AVFMT_FLAG_FLUSH_PACKETS
Flush the AVIOContext every packet.
Definition: avformat.h:1416
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
FFOutputFormat::init
int(* init)(AVFormatContext *)
Initialize format.
Definition: mux.h:145
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3727
AVFMT_AVOID_NEG_TS_AUTO
#define AVFMT_AVOID_NEG_TS_AUTO
Enabled when required by target format.
Definition: avformat.h:1643
av_opt_set_dict
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1947
FFFrac
The exact value of the fractional number is: 'val + num / den'.
Definition: internal.h:59
FFFrac::den
int64_t den
Definition: internal.h:60
AVCodecTag::tag
unsigned int tag
Definition: internal.h:44
codec_desc.h
FFFormatContext::pub
AVFormatContext pub
The public context.
Definition: internal.h:68
ff_stream_add_bitstream_filter
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: mux.c:1350
FFStream::lowest_ts_allowed
int64_t lowest_ts_allowed
This is the lowest ts allowed in this track; it may be set by the muxer during init or write_header a...
Definition: internal.h:315
av_rescale_q_rnd
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
FFOutputFormat::write_uncoded_frame
int(* write_uncoded_frame)(AVFormatContext *, int stream_index, struct AVFrame **frame, unsigned flags)
Write an uncoded AVFrame.
Definition: mux.h:129
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:106
AVPacket::time_base
AVRational time_base
Time base of the packet's timestamps.
Definition: packet.h:566
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:534
FFFormatContext::nb_interleaved_streams
int nb_interleaved_streams
Number of streams relevant for interleaving.
Definition: internal.h:74
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:345
AVIO_DATA_MARKER_FLUSH_POINT
@ AVIO_DATA_MARKER_FLUSH_POINT
A point in the output bytestream where the underlying AVIOContext might flush the buffer depending on...
Definition: avio.h:145
av_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:86
mux.h
ff_write_chained
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:1393
FFFormatContext::avoid_negative_ts_use_pts
int avoid_negative_ts_use_pts
Definition: internal.h:148