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/mem.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/dict.h"
33 #include "libavutil/timestamp.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/frame.h"
36 #include "libavutil/internal.h"
37 #include "libavutil/mathematics.h"
38 
39 /**
40  * @file
41  * muxing functions for use within libavformat
42  */
43 
44 /* fraction handling */
45 
46 /**
47  * f = val + (num / den) + 0.5.
48  *
49  * 'num' is normalized so that it is such as 0 <= num < den.
50  *
51  * @param f fractional number
52  * @param val integer value
53  * @param num must be >= 0
54  * @param den must be >= 1
55  */
56 static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
57 {
58  num += (den >> 1);
59  if (num >= den) {
60  val += num / den;
61  num = num % den;
62  }
63  f->val = val;
64  f->num = num;
65  f->den = den;
66 }
67 
68 /**
69  * Fractional addition to f: f = f + (incr / f->den).
70  *
71  * @param f fractional number
72  * @param incr increment, can be positive or negative
73  */
74 static void frac_add(FFFrac *f, int64_t incr)
75 {
76  int64_t num, den;
77 
78  num = f->num + incr;
79  den = f->den;
80  if (num < 0) {
81  f->val += num / den;
82  num = num % den;
83  if (num < 0) {
84  num += den;
85  f->val--;
86  }
87  } else if (num >= den) {
88  f->val += num / den;
89  num = num % den;
90  }
91  f->num = num;
92 }
93 
95  const char *format, const char *filename)
96 {
98  int ret = 0;
99 
100  *avctx = NULL;
101  if (!s)
102  goto nomem;
103 
104  if (!oformat) {
105  if (format) {
106  oformat = av_guess_format(format, NULL, NULL);
107  if (!oformat) {
108  av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not known.\n", format);
109  ret = AVERROR(EINVAL);
110  goto error;
111  }
112  } else {
113  oformat = av_guess_format(NULL, filename, NULL);
114  if (!oformat) {
115  ret = AVERROR(EINVAL);
117  "Unable to choose an output format for '%s'; "
118  "use a standard extension for the filename or specify "
119  "the format manually.\n", filename);
120  goto error;
121  }
122  }
123  }
124 
125  s->oformat = oformat;
126  if (ffofmt(s->oformat)->priv_data_size > 0) {
127  s->priv_data = av_mallocz(ffofmt(s->oformat)->priv_data_size);
128  if (!s->priv_data)
129  goto nomem;
130  if (s->oformat->priv_class) {
131  *(const AVClass**)s->priv_data= s->oformat->priv_class;
132  av_opt_set_defaults(s->priv_data);
133  }
134  } else
135  s->priv_data = NULL;
136 
137  if (filename) {
138  if (!(s->url = av_strdup(filename)))
139  goto nomem;
140 
141  }
142  *avctx = s;
143  return 0;
144 nomem:
145  av_log(s, AV_LOG_ERROR, "Out of memory\n");
146  ret = AVERROR(ENOMEM);
147 error:
149  return ret;
150 }
151 
152 static int validate_codec_tag(const AVFormatContext *s, const AVStream *st)
153 {
154  const AVCodecTag *avctag;
155  enum AVCodecID id = AV_CODEC_ID_NONE;
156  unsigned uppercase_tag = ff_toupper4(st->codecpar->codec_tag);
157  int64_t tag = -1;
158 
159  /**
160  * Check that tag + id is in the table
161  * If neither is in the table -> OK
162  * If tag is in the table with another id -> FAIL
163  * If id is in the table with another tag -> FAIL unless strict < normal
164  */
165  for (int n = 0; s->oformat->codec_tag[n]; n++) {
166  avctag = s->oformat->codec_tag[n];
167  while (avctag->id != AV_CODEC_ID_NONE) {
168  if (ff_toupper4(avctag->tag) == uppercase_tag) {
169  id = avctag->id;
170  if (id == st->codecpar->codec_id)
171  return 1;
172  }
173  if (avctag->id == st->codecpar->codec_id)
174  tag = avctag->tag;
175  avctag++;
176  }
177  }
178  if (id != AV_CODEC_ID_NONE)
179  return 0;
180  if (tag >= 0 && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
181  return 0;
182  return 1;
183 }
184 
185 
187 {
188  FFFormatContext *const si = ffformatcontext(s);
189  AVDictionary *tmp = NULL;
190  const FFOutputFormat *of = ffofmt(s->oformat);
192  static const unsigned default_codec_offsets[] = {
193  [AVMEDIA_TYPE_VIDEO] = offsetof(AVOutputFormat, video_codec),
194  [AVMEDIA_TYPE_AUDIO] = offsetof(AVOutputFormat, audio_codec),
195  [AVMEDIA_TYPE_SUBTITLE] = offsetof(AVOutputFormat, subtitle_codec),
196  };
197  unsigned nb_type[FF_ARRAY_ELEMS(default_codec_offsets)] = { 0 };
198  int ret = 0;
199 
200  if (options)
201  av_dict_copy(&tmp, *options, 0);
202 
203  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
204  goto fail;
205  if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
206  (ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
207  goto fail;
208 
209  if (!s->url && !(s->url = av_strdup(""))) {
210  ret = AVERROR(ENOMEM);
211  goto fail;
212  }
213 
214  // some sanity checks
215  if (s->nb_streams == 0 && !(of->p.flags & AVFMT_NOSTREAMS)) {
216  av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");
217  ret = AVERROR(EINVAL);
218  goto fail;
219  }
220 
221  for (unsigned i = 0; i < s->nb_streams; i++) {
222  AVStream *const st = s->streams[i];
223  FFStream *const sti = ffstream(st);
224  AVCodecParameters *const par = st->codecpar;
225  const AVCodecDescriptor *desc;
226 
227  if (!st->time_base.num) {
228  /* fall back on the default timebase values */
229  if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)
230  avpriv_set_pts_info(st, 64, 1, par->sample_rate);
231  else
232  avpriv_set_pts_info(st, 33, 1, 90000);
233  }
234 
235  switch (par->codec_type) {
236  case AVMEDIA_TYPE_AUDIO:
237  if (par->sample_rate <= 0) {
238  av_log(s, AV_LOG_ERROR, "sample rate not set\n");
239  ret = AVERROR(EINVAL);
240  goto fail;
241  }
242 
243  if (!par->block_align)
244  par->block_align = par->ch_layout.nb_channels *
245  av_get_bits_per_sample(par->codec_id) >> 3;
246  break;
247  case AVMEDIA_TYPE_VIDEO:
248  if ((par->width <= 0 || par->height <= 0) &&
249  !(of->p.flags & AVFMT_NODIMENSIONS)) {
250  av_log(s, AV_LOG_ERROR, "dimensions not set\n");
251  ret = AVERROR(EINVAL);
252  goto fail;
253  }
256  ) {
257  if (st->sample_aspect_ratio.num != 0 &&
258  st->sample_aspect_ratio.den != 0 &&
259  par->sample_aspect_ratio.num != 0 &&
260  par->sample_aspect_ratio.den != 0) {
261  av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
262  "(%d/%d) and encoder layer (%d/%d)\n",
265  par->sample_aspect_ratio.den);
266  ret = AVERROR(EINVAL);
267  goto fail;
268  }
269  }
270  break;
271  }
273  enum AVCodecID default_codec_id = AV_CODEC_ID_NONE;
274  unsigned nb;
275  if ((unsigned)par->codec_type < FF_ARRAY_ELEMS(default_codec_offsets)) {
276  nb = ++nb_type[par->codec_type];
277  if (default_codec_offsets[par->codec_type])
278  default_codec_id = *(const enum AVCodecID*)((const char*)of + default_codec_offsets[par->codec_type]);
279  }
281  default_codec_id != AV_CODEC_ID_NONE && par->codec_id != default_codec_id) {
282  av_log(s, AV_LOG_ERROR, "%s muxer supports only codec %s for type %s\n",
283  of->p.name, avcodec_get_name(default_codec_id), av_get_media_type_string(par->codec_type));
284  ret = AVERROR(EINVAL);
285  goto fail;
286  } else if (default_codec_id == AV_CODEC_ID_NONE ||
287  (of->flags_internal & FF_OFMT_FLAG_MAX_ONE_OF_EACH && nb > 1)) {
288  const char *type = av_get_media_type_string(par->codec_type);
289  av_log(s, AV_LOG_ERROR, "%s muxer does not support %s stream of type %s\n",
290  of->p.name, default_codec_id == AV_CODEC_ID_NONE ? "any" : "more than one",
291  type ? type : "unknown");
292  ret = AVERROR(EINVAL);
293  goto fail;
294  }
295  }
296 
297 #if FF_API_AVSTREAM_SIDE_DATA
299  /* if the caller is using the deprecated AVStream side_data API,
300  * copy its contents to AVStream.codecpar, giving it priority
301  over existing side data in the latter */
302  for (int i = 0; i < st->nb_side_data; i++) {
303  const AVPacketSideData *sd_src = &st->side_data[i];
304  AVPacketSideData *sd_dst;
305 
308  sd_src->type, sd_src->size, 0);
309  if (!sd_dst) {
310  ret = AVERROR(ENOMEM);
311  goto fail;
312  }
313  memcpy(sd_dst->data, sd_src->data, sd_src->size);
314  }
316 #endif
317 
319  if (desc && desc->props & AV_CODEC_PROP_REORDER)
320  sti->reorder = 1;
321 
323 
324  if (of->p.codec_tag) {
325  if ( par->codec_tag
326  && par->codec_id == AV_CODEC_ID_RAWVIDEO
327  && ( av_codec_get_tag(of->p.codec_tag, par->codec_id) == 0
328  || av_codec_get_tag(of->p.codec_tag, par->codec_id) == MKTAG('r', 'a', 'w', ' '))
329  && !validate_codec_tag(s, st)) {
330  // the current rawvideo encoding system ends up setting
331  // the wrong codec_tag for avi/mov, we override it here
332  par->codec_tag = 0;
333  }
334  if (par->codec_tag) {
335  if (!validate_codec_tag(s, st)) {
336  const uint32_t otag = av_codec_get_tag(s->oformat->codec_tag, par->codec_id);
338  "Tag %s incompatible with output codec id '%d' (%s)\n",
339  av_fourcc2str(par->codec_tag), par->codec_id, av_fourcc2str(otag));
341  goto fail;
342  }
343  } else
344  par->codec_tag = av_codec_get_tag(of->p.codec_tag, par->codec_id);
345  }
346 
347  if (par->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
350  }
352  if (!si->interleave_packet)
356 
357  if (!s->priv_data && of->priv_data_size > 0) {
358  s->priv_data = av_mallocz(of->priv_data_size);
359  if (!s->priv_data) {
360  ret = AVERROR(ENOMEM);
361  goto fail;
362  }
363  if (of->p.priv_class) {
364  *(const AVClass **)s->priv_data = of->p.priv_class;
365  av_opt_set_defaults(s->priv_data);
366  if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
367  goto fail;
368  }
369  }
370 
371  /* set muxer identification string */
372  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
373  av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
374  } else {
375  av_dict_set(&s->metadata, "encoder", NULL, 0);
376  }
377 
378  for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {
379  av_dict_set(&s->metadata, e->key, NULL, 0);
380  }
381 
382  if (options) {
384  *options = tmp;
385  }
386 
387  if (of->init) {
388  if ((ret = of->init(s)) < 0) {
389  if (of->deinit)
390  of->deinit(s);
391  return ret;
392  }
393  return ret == 0;
394  }
395 
396  return 0;
397 
398 fail:
399  av_dict_free(&tmp);
400  return ret;
401 }
402 
404 {
405  FFFormatContext *const si = ffformatcontext(s);
406 
407  /* init PTS generation */
408  for (unsigned i = 0; i < s->nb_streams; i++) {
409  AVStream *const st = s->streams[i];
410  FFStream *const sti = ffstream(st);
411  int64_t den = AV_NOPTS_VALUE;
412 
413  switch (st->codecpar->codec_type) {
414  case AVMEDIA_TYPE_AUDIO:
415  den = (int64_t)st->time_base.num * st->codecpar->sample_rate;
416  break;
417  case AVMEDIA_TYPE_VIDEO:
418  den = (int64_t)st->time_base.num * st->time_base.den;
419  break;
420  default:
421  break;
422  }
423 
424  if (den != AV_NOPTS_VALUE) {
425  if (den <= 0)
426  return AVERROR_INVALIDDATA;
427 
428  frac_init(&sti->priv_pts, 0, 0, den);
429  }
430  }
431 
432  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_UNKNOWN;
433  if (s->avoid_negative_ts < 0) {
434  av_assert2(s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO);
435  if (s->oformat->flags & (AVFMT_TS_NEGATIVE | AVFMT_NOTIMESTAMPS)) {
436  s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_DISABLED;
437  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_DISABLED;
438  } else
439  s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE;
440  } else if (s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_DISABLED)
441  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_DISABLED;
442 
443  return 0;
444 }
445 
447 {
448  if (s->pb && s->pb->error >= 0) {
449  if (s->flush_packets == 1 || s->flags & AVFMT_FLAG_FLUSH_PACKETS)
450  avio_flush(s->pb);
451  else if (s->flush_packets && !(s->oformat->flags & AVFMT_NOFILE))
453  }
454 }
455 
457 {
458  FFFormatContext *const si = ffformatcontext(s);
459  const FFOutputFormat *const of = ffofmt(s->oformat);
460  if (of && of->deinit && si->initialized)
461  of->deinit(s);
462  si->initialized =
463  si->streams_initialized = 0;
464 }
465 
467 {
468  FFFormatContext *const si = ffformatcontext(s);
469  int ret = 0;
470 
471  if ((ret = init_muxer(s, options)) < 0)
472  return ret;
473 
474  si->initialized = 1;
475  si->streams_initialized = ret;
476 
477  if (ffofmt(s->oformat)->init && ret) {
478  if ((ret = init_pts(s)) < 0)
479  return ret;
480 
482  }
483 
485 }
486 
488 {
489  FFFormatContext *const si = ffformatcontext(s);
490  int already_initialized = si->initialized;
491  int streams_already_initialized = si->streams_initialized;
492  int ret = 0;
493 
494  if (!already_initialized)
495  if ((ret = avformat_init_output(s, options)) < 0)
496  return ret;
497 
498  if (ffofmt(s->oformat)->write_header) {
499  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
501  ret = ffofmt(s->oformat)->write_header(s);
502  if (ret >= 0 && s->pb && s->pb->error < 0)
503  ret = s->pb->error;
504  if (ret < 0)
505  goto fail;
507  }
508  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
510 
511  if (!si->streams_initialized) {
512  if ((ret = init_pts(s)) < 0)
513  goto fail;
514  }
515 
516  return streams_already_initialized;
517 
518 fail:
519  deinit_muxer(s);
520  return ret;
521 }
522 
523 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
524 
525 
526 #if FF_API_COMPUTE_PKT_FIELDS2
528 //FIXME merge with compute_pkt_fields
530 {
531  FFFormatContext *const si = ffformatcontext(s);
532  FFStream *const sti = ffstream(st);
533  int delay = st->codecpar->video_delay;
534  int frame_size;
535 
536  if (!si->missing_ts_warning &&
537  !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
539  (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
541  "Timestamps are unset in a packet for stream %d. "
542  "This is deprecated and will stop working in the future. "
543  "Fix your code to set the timestamps properly\n", st->index);
544  si->missing_ts_warning = 1;
545  }
546 
547  if (s->debug & FF_FDEBUG_TS)
548  av_log(s, AV_LOG_DEBUG, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
550 
551  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
552  pkt->pts = pkt->dts;
553 
554  //XXX/FIXME this is a temporary hack until all encoders output pts
555  if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
556  static int warned;
557  if (!warned) {
558  av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
559  warned = 1;
560  }
561  pkt->dts =
562 // pkt->pts= st->cur_dts;
563  pkt->pts = sti->priv_pts.val;
564  }
565 
566  //calculate dts from pts
567  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
568  sti->pts_buffer[0] = pkt->pts;
569  for (int i = 1; i < delay + 1 && sti->pts_buffer[i] == AV_NOPTS_VALUE; i++)
570  sti->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
571  for (int i = 0; i<delay && sti->pts_buffer[i] > sti->pts_buffer[i + 1]; i++)
572  FFSWAP(int64_t, sti->pts_buffer[i], sti->pts_buffer[i + 1]);
573 
574  pkt->dts = sti->pts_buffer[0];
575  }
576 
577  if (sti->cur_dts && sti->cur_dts != AV_NOPTS_VALUE &&
578  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
581  sti->cur_dts >= pkt->dts) || sti->cur_dts > pkt->dts)) {
583  "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
584  st->index, av_ts2str(sti->cur_dts), av_ts2str(pkt->dts));
585  return AVERROR(EINVAL);
586  }
587  if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
589  "pts (%s) < dts (%s) in stream %d\n",
591  st->index);
592  return AVERROR(EINVAL);
593  }
594 
595  if (s->debug & FF_FDEBUG_TS)
596  av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n",
598 
599  sti->cur_dts = pkt->dts;
600  sti->priv_pts.val = pkt->dts;
601 
602  /* update pts */
603  switch (st->codecpar->codec_type) {
604  case AVMEDIA_TYPE_AUDIO:
606  (*(AVFrame **)pkt->data)->nb_samples :
608 
609  /* HACK/FIXME, we skip the initial 0 size packets as they are most
610  * likely equal to the encoder delay, but it would be better if we
611  * had the real timestamps from the encoder */
612  if (frame_size >= 0 && (pkt->size || sti->priv_pts.num != sti->priv_pts.den >> 1 || sti->priv_pts.val)) {
613  frac_add(&sti->priv_pts, (int64_t)st->time_base.den * frame_size);
614  }
615  break;
616  case AVMEDIA_TYPE_VIDEO:
617  frac_add(&sti->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
618  break;
619  }
620  return 0;
621 }
623 #endif
624 
626 {
627  if (pkt->duration < 0 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
628  av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
630  pkt->duration = 0;
631  }
632 
633  if (pkt->duration)
634  return;
635 
636  switch (st->codecpar->codec_type) {
637  case AVMEDIA_TYPE_VIDEO:
638  if (st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0) {
640  st->time_base);
641  } else if (st->time_base.num * 1000LL > st->time_base.den)
642  pkt->duration = 1;
643  break;
644  case AVMEDIA_TYPE_AUDIO: {
646  if (frame_size && st->codecpar->sample_rate) {
648  (AVRational){1, st->codecpar->sample_rate},
649  st->time_base);
650  }
651  break;
652  }
653  }
654 }
655 
657  AVPacket *pkt)
658 {
659  AVFormatContext *const s = &si->pub;
660  int64_t offset;
661 
663  return;
664 
665  if (si->avoid_negative_ts_status == AVOID_NEGATIVE_TS_UNKNOWN) {
666  int use_pts = si->avoid_negative_ts_use_pts;
667  int64_t ts = use_pts ? pkt->pts : pkt->dts;
668  AVRational tb = sti->pub.time_base;
669 
670  if (ts == AV_NOPTS_VALUE)
671  return;
672 
673  ts -= sti->lowest_ts_allowed;
674 
675  /* Peek into the muxing queue to improve our estimate
676  * of the lowest timestamp if av_interleaved_write_frame() is used. */
677  for (const PacketListEntry *pktl = si->packet_buffer.head;
678  pktl; pktl = pktl->next) {
679  AVRational cmp_tb = s->streams[pktl->pkt.stream_index]->time_base;
680  int64_t cmp_ts = use_pts ? pktl->pkt.pts : pktl->pkt.dts;
681  if (cmp_ts == AV_NOPTS_VALUE)
682  continue;
683  cmp_ts -= ffstream(s->streams[pktl->pkt.stream_index])->lowest_ts_allowed;
684  if (s->output_ts_offset)
685  cmp_ts += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, cmp_tb);
686  if (av_compare_ts(cmp_ts, cmp_tb, ts, tb) < 0) {
687  ts = cmp_ts;
688  tb = cmp_tb;
689  }
690  }
691 
692  if (ts < 0 ||
693  ts > 0 && s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) {
694  for (unsigned i = 0; i < s->nb_streams; i++) {
695  AVStream *const st2 = s->streams[i];
696  FFStream *const sti2 = ffstream(st2);
697  sti2->mux_ts_offset = av_rescale_q_rnd(-ts, tb,
698  st2->time_base,
699  AV_ROUND_UP);
700  }
701  }
702  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_KNOWN;
703  }
704 
705  offset = sti->mux_ts_offset;
706 
707  if (pkt->dts != AV_NOPTS_VALUE)
708  pkt->dts += offset;
709  if (pkt->pts != AV_NOPTS_VALUE)
710  pkt->pts += offset;
711 
712  if (si->avoid_negative_ts_use_pts) {
713  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < sti->lowest_ts_allowed) {
714  av_log(s, AV_LOG_WARNING, "failed to avoid negative "
715  "pts %s in stream %d.\n"
716  "Try -avoid_negative_ts 1 as a possible workaround.\n",
717  av_ts2str(pkt->pts),
719  );
720  }
721  } else {
722  if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < sti->lowest_ts_allowed) {
724  "Packets poorly interleaved, failed to avoid negative "
725  "timestamp %s in stream %d.\n"
726  "Try -max_interleave_delta 0 as a possible workaround.\n",
727  av_ts2str(pkt->dts),
729  );
730  }
731  }
732 }
733 
734 /**
735  * Shift timestamps and call muxer; the original pts/dts are not kept.
736  *
737  * FIXME: this function should NEVER get undefined pts/dts beside when the
738  * AVFMT_NOTIMESTAMPS is set.
739  * Those additional safety checks should be dropped once the correct checks
740  * are set in the callers.
741  */
743 {
744  FFFormatContext *const si = ffformatcontext(s);
745  AVStream *const st = s->streams[pkt->stream_index];
746  FFStream *const sti = ffstream(st);
747  int ret;
748 
749  // If the timestamp offsetting below is adjusted, adjust
750  // ff_interleaved_peek similarly.
751  if (s->output_ts_offset) {
752  int64_t offset = av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
753 
754  if (pkt->dts != AV_NOPTS_VALUE)
755  pkt->dts += offset;
756  if (pkt->pts != AV_NOPTS_VALUE)
757  pkt->pts += offset;
758  }
759  handle_avoid_negative_ts(si, sti, pkt);
760 
762  AVFrame **frame = (AVFrame **)pkt->data;
763  av_assert0(pkt->size == sizeof(*frame));
764  ret = ffofmt(s->oformat)->write_uncoded_frame(s, pkt->stream_index, frame, 0);
765  } else {
766  ret = ffofmt(s->oformat)->write_packet(s, pkt);
767  }
768 
769  if (s->pb && ret >= 0) {
771  if (s->pb->error < 0)
772  ret = s->pb->error;
773  }
774 
775  if (ret >= 0)
776  st->nb_frames++;
777 
778  return ret;
779 }
780 
782 {
783  if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
784  av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
785  pkt->stream_index);
786  return AVERROR(EINVAL);
787  }
788 
789  if (s->streams[pkt->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
790  av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
791  return AVERROR(EINVAL);
792  }
793 
794  return 0;
795 }
796 
798 {
799  FFStream *const sti = ffstream(st);
800 #if !FF_API_COMPUTE_PKT_FIELDS2
801  /* sanitize the timestamps */
802  if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
803 
804  /* when there is no reordering (so dts is equal to pts), but
805  * only one of them is set, set the other as well */
806  if (!sti->reorder) {
807  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)
808  pkt->pts = pkt->dts;
809  if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
810  pkt->dts = pkt->pts;
811  }
812 
813  /* check that the timestamps are set */
814  if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {
816  "Timestamps are unset in a packet for stream %d\n", st->index);
817  return AVERROR(EINVAL);
818  }
819 
820  /* check that the dts are increasing (or at least non-decreasing,
821  * if the format allows it */
822  if (sti->cur_dts != AV_NOPTS_VALUE &&
823  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && sti->cur_dts >= pkt->dts) ||
824  sti->cur_dts > pkt->dts)) {
826  "Application provided invalid, non monotonically increasing "
827  "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
828  st->index, sti->cur_dts, pkt->dts);
829  return AVERROR(EINVAL);
830  }
831 
832  if (pkt->pts < pkt->dts) {
833  av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
834  pkt->pts, pkt->dts, st->index);
835  return AVERROR(EINVAL);
836  }
837  }
838 #endif
839  /* update flags */
840  if (sti->is_intra_only)
842 
843  if (!pkt->data && !pkt->side_data_elems) {
844  /* Such empty packets signal EOS for the BSF API; so sanitize
845  * the packet by allocating data of size 0 (+ padding). */
848  }
849 
850  return 0;
851 }
852 
853 #define CHUNK_START 0x1000
854 
856  int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
857 {
858  int ret;
859  FFFormatContext *const si = ffformatcontext(s);
860  PacketListEntry **next_point, *this_pktl;
861  AVStream *st = s->streams[pkt->stream_index];
862  FFStream *const sti = ffstream(st);
863  int chunked = s->max_chunk_size || s->max_chunk_duration;
864 
865  this_pktl = av_malloc(sizeof(*this_pktl));
866  if (!this_pktl) {
868  return AVERROR(ENOMEM);
869  }
870  if ((ret = av_packet_make_refcounted(pkt)) < 0) {
871  av_free(this_pktl);
873  return ret;
874  }
875 
876  av_packet_move_ref(&this_pktl->pkt, pkt);
877  pkt = &this_pktl->pkt;
878 
879  if (sti->last_in_packet_buffer) {
880  next_point = &(sti->last_in_packet_buffer->next);
881  } else {
882  next_point = &si->packet_buffer.head;
883  }
884 
885  if (chunked) {
886  uint64_t max= av_rescale_q_rnd(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base, AV_ROUND_UP);
889  if ( (s->max_chunk_size && sti->interleaver_chunk_size > s->max_chunk_size)
890  || (max && sti->interleaver_chunk_duration > max)) {
891  sti->interleaver_chunk_size = 0;
892  pkt->flags |= CHUNK_START;
893  if (max && sti->interleaver_chunk_duration > max) {
894  int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
895  int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
896 
897  sti->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
898  } else
900  }
901  }
902  if (*next_point) {
903  if (chunked && !(pkt->flags & CHUNK_START))
904  goto next_non_null;
905 
906  if (compare(s, &si->packet_buffer.tail->pkt, pkt)) {
907  while ( *next_point
908  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
909  || !compare(s, &(*next_point)->pkt, pkt)))
910  next_point = &(*next_point)->next;
911  if (*next_point)
912  goto next_non_null;
913  } else {
914  next_point = &(si->packet_buffer.tail->next);
915  }
916  }
917  av_assert1(!*next_point);
918 
919  si->packet_buffer.tail = this_pktl;
920 next_non_null:
921 
922  this_pktl->next = *next_point;
923 
924  sti->last_in_packet_buffer = *next_point = this_pktl;
925 
926  return 0;
927 }
928 
930  const AVPacket *pkt)
931 {
932  AVStream *st = s->streams[pkt->stream_index];
933  AVStream *st2 = s->streams[next->stream_index];
934  int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
935  st->time_base);
936  if (s->audio_preload) {
937  int preload = st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
938  int preload2 = st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
939  if (preload != preload2) {
940  int64_t ts, ts2;
941  preload *= s->audio_preload;
942  preload2 *= s->audio_preload;
943  ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - preload;
944  ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - preload2;
945  if (ts == ts2) {
946  ts = ((uint64_t)pkt ->dts*st ->time_base.num*AV_TIME_BASE - (uint64_t)preload *st ->time_base.den)*st2->time_base.den
947  - ((uint64_t)next->dts*st2->time_base.num*AV_TIME_BASE - (uint64_t)preload2*st2->time_base.den)*st ->time_base.den;
948  ts2 = 0;
949  }
950  comp = (ts2 > ts) - (ts2 < ts);
951  }
952  }
953 
954  if (comp == 0)
955  return pkt->stream_index < next->stream_index;
956  return comp > 0;
957 }
958 
960  int flush, int has_packet)
961 {
962  FFFormatContext *const si = ffformatcontext(s);
963  int stream_count = 0;
964  int noninterleaved_count = 0;
965  int ret;
966  int eof = flush;
967 
968  if (has_packet) {
970  return ret;
971  }
972 
973  for (unsigned i = 0; i < s->nb_streams; i++) {
974  const AVStream *const st = s->streams[i];
975  const FFStream *const sti = cffstream(st);
976  const AVCodecParameters *const par = st->codecpar;
977  if (sti->last_in_packet_buffer) {
978  ++stream_count;
979  } else if (par->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
980  par->codec_id != AV_CODEC_ID_VP8 &&
981  par->codec_id != AV_CODEC_ID_VP9 &&
983  ++noninterleaved_count;
984  }
985  }
986 
987  if (si->nb_interleaved_streams == stream_count)
988  flush = 1;
989 
990  if (s->max_interleave_delta > 0 &&
991  si->packet_buffer.head &&
993  !flush &&
994  si->nb_interleaved_streams == stream_count+noninterleaved_count
995  ) {
996  AVPacket *const top_pkt = &si->packet_buffer.head->pkt;
997  int64_t delta_dts = INT64_MIN;
998  int64_t top_dts = av_rescale_q(top_pkt->dts,
999  s->streams[top_pkt->stream_index]->time_base,
1000  AV_TIME_BASE_Q);
1001 
1002  for (unsigned i = 0; i < s->nb_streams; i++) {
1003  const AVStream *const st = s->streams[i];
1004  const FFStream *const sti = cffstream(st);
1005  const PacketListEntry *const last = sti->last_in_packet_buffer;
1006  int64_t last_dts;
1007 
1008  if (!last || st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
1009  continue;
1010 
1011  last_dts = av_rescale_q(last->pkt.dts,
1012  st->time_base,
1013  AV_TIME_BASE_Q);
1014  delta_dts = FFMAX(delta_dts, last_dts - top_dts);
1015  }
1016 
1017  if (delta_dts > s->max_interleave_delta) {
1019  "Delay between the first packet and last packet in the "
1020  "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
1021  delta_dts, s->max_interleave_delta);
1022  flush = 1;
1023  }
1024  }
1025 
1026 #if FF_API_LAVF_SHORTEST
1027  if (si->packet_buffer.head &&
1028  eof &&
1029  (s->flags & AVFMT_FLAG_SHORTEST) &&
1030  si->shortest_end == AV_NOPTS_VALUE) {
1031  AVPacket *const top_pkt = &si->packet_buffer.head->pkt;
1032 
1033  si->shortest_end = av_rescale_q(top_pkt->dts,
1034  s->streams[top_pkt->stream_index]->time_base,
1035  AV_TIME_BASE_Q);
1036  }
1037 
1038  if (si->shortest_end != AV_NOPTS_VALUE) {
1039  while (si->packet_buffer.head) {
1040  PacketListEntry *pktl = si->packet_buffer.head;
1041  AVPacket *const top_pkt = &pktl->pkt;
1042  AVStream *const st = s->streams[top_pkt->stream_index];
1043  FFStream *const sti = ffstream(st);
1044  int64_t top_dts = av_rescale_q(top_pkt->dts, st->time_base,
1045  AV_TIME_BASE_Q);
1046 
1047  if (si->shortest_end + 1 >= top_dts)
1048  break;
1049 
1050  si->packet_buffer.head = pktl->next;
1051  if (!si->packet_buffer.head)
1052  si->packet_buffer.tail = NULL;
1053 
1054  if (sti->last_in_packet_buffer == pktl)
1055  sti->last_in_packet_buffer = NULL;
1056 
1057  av_packet_unref(&pktl->pkt);
1058  av_freep(&pktl);
1059  flush = 0;
1060  }
1061  }
1062 #endif
1063 
1064  if (stream_count && flush) {
1065  PacketListEntry *pktl = si->packet_buffer.head;
1066  AVStream *const st = s->streams[pktl->pkt.stream_index];
1067  FFStream *const sti = ffstream(st);
1068 
1069  if (sti->last_in_packet_buffer == pktl)
1070  sti->last_in_packet_buffer = NULL;
1072 
1073  return 1;
1074  } else {
1075  return 0;
1076  }
1077 }
1078 
1080  int flush, int has_packet)
1081 {
1082  return has_packet;
1083 }
1084 
1085 int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
1086 {
1087  AVStream *st;
1088 
1089  if (stream_index < 0 || stream_index >= s->nb_streams)
1090  return AVERROR(EINVAL);
1091 
1092  st = s->streams[stream_index];
1093  *offset = ffstream(st)->mux_ts_offset;
1094 
1095  if (s->output_ts_offset)
1096  *offset += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
1097 
1098  return 0;
1099 }
1100 
1102 {
1103  FFFormatContext *const si = ffformatcontext(s);
1104  PacketListEntry *pktl = si->packet_buffer.head;
1105  while (pktl) {
1106  if (pktl->pkt.stream_index == stream) {
1107  return &pktl->pkt;
1108  }
1109  pktl = pktl->next;
1110  }
1111  return NULL;
1112 }
1113 
1115 {
1116  int ret;
1117 
1118  if (!(s->flags & AVFMT_FLAG_AUTO_BSF))
1119  return 1;
1120 
1121  if (ffofmt(s->oformat)->check_bitstream) {
1122  if (!sti->bitstream_checked) {
1123  if ((ret = ffofmt(s->oformat)->check_bitstream(s, &sti->pub, pkt)) < 0)
1124  return ret;
1125  else if (ret == 1)
1126  sti->bitstream_checked = 1;
1127  }
1128  }
1129 
1130  return 1;
1131 }
1132 
1134  int flush, int has_packet)
1135 {
1136  FFFormatContext *const si = ffformatcontext(s);
1137  for (;; ) {
1138  int ret = si->interleave_packet(s, pkt, flush, has_packet);
1139  if (ret <= 0)
1140  return ret;
1141 
1142  has_packet = 0;
1143 
1144  ret = write_packet(s, pkt);
1146  if (ret < 0)
1147  return ret;
1148  }
1149 }
1150 
1151 static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1152 {
1153  int ret;
1154 
1155  if (s->debug & FF_FDEBUG_TS)
1156  av_log(s, AV_LOG_DEBUG, "%s size:%d dts:%s pts:%s\n", __func__,
1158 
1159  guess_pkt_duration(s, st, pkt);
1160 
1161 #if FF_API_COMPUTE_PKT_FIELDS2
1162  if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1163  return ret;
1164 #endif
1165 
1166  if (interleaved) {
1167  if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1168  return AVERROR(EINVAL);
1169  return interleaved_write_packet(s, pkt, 0, 1);
1170  } else {
1171  return write_packet(s, pkt);
1172  }
1173 }
1174 
1175 static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1176 {
1177  FFStream *const sti = ffstream(st);
1178  AVBSFContext *const bsfc = sti->bsfc;
1179  int ret;
1180 
1181  if ((ret = av_bsf_send_packet(bsfc, pkt)) < 0) {
1183  "Failed to send packet to filter %s for stream %d\n",
1184  bsfc->filter->name, st->index);
1185  return ret;
1186  }
1187 
1188  do {
1189  ret = av_bsf_receive_packet(bsfc, pkt);
1190  if (ret < 0) {
1191  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
1192  return 0;
1193  av_log(s, AV_LOG_ERROR, "Error applying bitstream filters to an output "
1194  "packet for stream #%d: %s\n", st->index, av_err2str(ret));
1195  if (!(s->error_recognition & AV_EF_EXPLODE) && ret != AVERROR(ENOMEM))
1196  continue;
1197  return ret;
1198  }
1200  ret = write_packet_common(s, st, pkt, interleaved);
1201  if (ret >= 0 && !interleaved) // a successful write_packet_common already unrefed pkt for interleaved
1203  } while (ret >= 0);
1204 
1205  return ret;
1206 }
1207 
1208 static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
1209 {
1210  AVStream *st;
1211  FFStream *sti;
1212  int ret = check_packet(s, pkt);
1213  if (ret < 0)
1214  return ret;
1215  st = s->streams[pkt->stream_index];
1216  sti = ffstream(st);
1217 
1218  ret = prepare_input_packet(s, st, pkt);
1219  if (ret < 0)
1220  return ret;
1221 
1222  ret = check_bitstream(s, sti, pkt);
1223  if (ret < 0)
1224  return ret;
1225 
1226  if (sti->bsfc) {
1227  return write_packets_from_bsfs(s, st, pkt, interleaved);
1228  } else {
1229  return write_packet_common(s, st, pkt, interleaved);
1230  }
1231 }
1232 
1234 {
1235  FFFormatContext *const si = ffformatcontext(s);
1236  AVPacket *pkt = si->parse_pkt;
1237  int ret;
1238 
1239  if (!in) {
1240  if (ffofmt(s->oformat)->flags_internal & FF_OFMT_FLAG_ALLOW_FLUSH) {
1241  ret = ffofmt(s->oformat)->write_packet(s, NULL);
1242  flush_if_needed(s);
1243  if (ret >= 0 && s->pb && s->pb->error < 0)
1244  ret = s->pb->error;
1245  return ret;
1246  }
1247  return 1;
1248  }
1249 
1250  if (in->flags & AV_PKT_FLAG_UNCODED_FRAME) {
1251  pkt = in;
1252  } else {
1253  /* We don't own in, so we have to make sure not to modify it.
1254  * (ff_write_chained() relies on this fact.)
1255  * The following avoids copying in's data unnecessarily.
1256  * Copying side data is unavoidable as a bitstream filter
1257  * may change it, e.g. free it on errors. */
1258  pkt->data = in->data;
1259  pkt->size = in->size;
1261  if (ret < 0)
1262  return ret;
1263  if (in->buf) {
1264  pkt->buf = av_buffer_ref(in->buf);
1265  if (!pkt->buf) {
1266  ret = AVERROR(ENOMEM);
1267  goto fail;
1268  }
1269  }
1270  }
1271 
1272  ret = write_packets_common(s, pkt, 0/*non-interleaved*/);
1273 
1274 fail:
1275  // Uncoded frames using the noninterleaved codepath are also freed here
1277  return ret;
1278 }
1279 
1281 {
1282  int ret;
1283 
1284  if (pkt) {
1285  ret = write_packets_common(s, pkt, 1/*interleaved*/);
1286  if (ret < 0)
1288  return ret;
1289  } else {
1290  av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");
1291  return interleaved_write_packet(s, ffformatcontext(s)->parse_pkt, 1/*flush*/, 0);
1292  }
1293 }
1294 
1296 {
1297  FFFormatContext *const si = ffformatcontext(s);
1298  AVPacket *const pkt = si->parse_pkt;
1299  int ret1, ret = 0;
1300 
1301  for (unsigned i = 0; i < s->nb_streams; i++) {
1302  AVStream *const st = s->streams[i];
1303  FFStream *const sti = ffstream(st);
1304  if (sti->bsfc) {
1305  ret1 = write_packets_from_bsfs(s, st, pkt, 1/*interleaved*/);
1306  if (ret1 < 0)
1308  if (ret >= 0)
1309  ret = ret1;
1310  }
1311  }
1312  ret1 = interleaved_write_packet(s, pkt, 1, 0);
1313  if (ret >= 0)
1314  ret = ret1;
1315 
1316  if (ffofmt(s->oformat)->write_trailer) {
1317  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1319  ret1 = ffofmt(s->oformat)->write_trailer(s);
1320  if (ret >= 0)
1321  ret = ret1;
1322  }
1323 
1324  deinit_muxer(s);
1325 
1326  if (s->pb)
1327  avio_flush(s->pb);
1328  if (ret == 0)
1329  ret = s->pb ? s->pb->error : 0;
1330  for (unsigned i = 0; i < s->nb_streams; i++) {
1331  av_freep(&s->streams[i]->priv_data);
1332  av_freep(&ffstream(s->streams[i])->index_entries);
1333  }
1334  if (s->oformat->priv_class)
1335  av_opt_free(s->priv_data);
1336  av_freep(&s->priv_data);
1337  av_packet_unref(si->pkt);
1338  return ret;
1339 }
1340 
1342  int64_t *dts, int64_t *wall)
1343 {
1344  const FFOutputFormat *const of = ffofmt(s->oformat);
1345  if (!of || !of->get_output_timestamp)
1346  return AVERROR(ENOSYS);
1347  of->get_output_timestamp(s, stream, dts, wall);
1348  return 0;
1349 }
1350 
1351 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
1352 {
1353  int ret;
1354  const AVBitStreamFilter *bsf;
1355  FFStream *const sti = ffstream(st);
1356  AVBSFContext *bsfc;
1357 
1358  av_assert0(!sti->bsfc);
1359 
1360  if (!(bsf = av_bsf_get_by_name(name))) {
1361  av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
1362  return AVERROR_BSF_NOT_FOUND;
1363  }
1364 
1365  if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
1366  return ret;
1367 
1368  bsfc->time_base_in = st->time_base;
1369  if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
1370  av_bsf_free(&bsfc);
1371  return ret;
1372  }
1373 
1374  if (args && bsfc->filter->priv_class) {
1375  if ((ret = av_set_options_string(bsfc->priv_data, args, "=", ":")) < 0) {
1376  av_bsf_free(&bsfc);
1377  return ret;
1378  }
1379  }
1380 
1381  if ((ret = av_bsf_init(bsfc)) < 0) {
1382  av_bsf_free(&bsfc);
1383  return ret;
1384  }
1385 
1386  sti->bsfc = bsfc;
1387 
1389  "Automatically inserted bitstream filter '%s'; args='%s'\n",
1390  name, args ? args : "");
1391  return 1;
1392 }
1393 
1394 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
1396 {
1397  int64_t pts = pkt->pts, dts = pkt->dts, duration = pkt->duration;
1398  int stream_index = pkt->stream_index;
1399  AVRational time_base = pkt->time_base;
1400  int ret;
1401 
1402  pkt->stream_index = dst_stream;
1403 
1405  src->streams[stream_index]->time_base,
1406  dst->streams[dst_stream]->time_base);
1407 
1408  if (!interleave) {
1409  ret = av_write_frame(dst, pkt);
1410  /* We only have to backup and restore the fields that
1411  * we changed ourselves, because av_write_frame() does not
1412  * modify the packet given to it. */
1413  pkt->pts = pts;
1414  pkt->dts = dts;
1415  pkt->duration = duration;
1416  pkt->stream_index = stream_index;
1417  pkt->time_base = time_base;
1418  } else
1420 
1421  return ret;
1422 }
1423 
1424 static void uncoded_frame_free(void *unused, uint8_t *data)
1425 {
1426  av_frame_free((AVFrame **)data);
1427  av_free(data);
1428 }
1429 
1430 static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
1431  AVFrame *frame, int interleaved)
1432 {
1433  FFFormatContext *const si = ffformatcontext(s);
1434  AVPacket *pkt = si->parse_pkt;
1435 
1436  av_assert0(s->oformat);
1437  if (!ffofmt(s->oformat)->write_uncoded_frame) {
1438  av_frame_free(&frame);
1439  return AVERROR(ENOSYS);
1440  }
1441 
1442  if (!frame) {
1443  pkt = NULL;
1444  } else {
1445  size_t bufsize = sizeof(frame) + AV_INPUT_BUFFER_PADDING_SIZE;
1446  AVFrame **framep = av_mallocz(bufsize);
1447 
1448  if (!framep)
1449  goto fail;
1450  pkt->buf = av_buffer_create((void *)framep, bufsize,
1451  uncoded_frame_free, NULL, 0);
1452  if (!pkt->buf) {
1453  av_free(framep);
1454  fail:
1455  av_frame_free(&frame);
1456  return AVERROR(ENOMEM);
1457  }
1458  *framep = frame;
1459 
1460  pkt->data = (void *)framep;
1461  pkt->size = sizeof(frame);
1462  pkt->pts =
1463  pkt->dts = frame->pts;
1464  pkt->duration = frame->duration;
1465  pkt->stream_index = stream_index;
1467  }
1468 
1469  return interleaved ? av_interleaved_write_frame(s, pkt) :
1470  av_write_frame(s, pkt);
1471 }
1472 
1474  AVFrame *frame)
1475 {
1476  return write_uncoded_frame_internal(s, stream_index, frame, 0);
1477 }
1478 
1480  AVFrame *frame)
1481 {
1482  return write_uncoded_frame_internal(s, stream_index, frame, 1);
1483 }
1484 
1486 {
1487  const FFOutputFormat *const of = ffofmt(s->oformat);
1488  av_assert0(of);
1489  if (!of->write_uncoded_frame)
1490  return AVERROR(ENOSYS);
1491  return of->write_uncoded_frame(s, stream_index, NULL,
1493 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:533
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.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
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:1654
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:2455
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:959
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:94
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:81
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:1133
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:186
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:374
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:375
FFStream::interleaver_chunk_size
int64_t interleaver_chunk_size
Definition: internal.h:254
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:524
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
FFFormatContext::avoid_negative_ts_status
enum FFFormatContext::@345 avoid_negative_ts_status
Whether the timestamp shift offset has already been determined.
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:542
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:1485
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:466
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:579
ff_get_muxer_ts_offset
int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
Definition: mux.c:1085
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:461
FFStream::is_intra_only
int is_intra_only
Definition: internal.h:240
AVPacketSideData::size
size_t size
Definition: packet.h:377
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:456
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:417
fail
#define fail()
Definition: checkasm.h:183
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:1925
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: packet.c:580
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:644
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:60
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:65
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:2423
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
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:1793
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:376
write_packets_from_bsfs
static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1175
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:487
PacketList::tail
PacketListEntry * tail
Definition: packet_internal.h:34
init_pts
static int init_pts(AVFormatContext *s)
Definition: mux.c:403
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:223
compute_muxer_pkt_fields
static FF_DISABLE_DEPRECATION_WARNINGS int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:529
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:507
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:1473
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
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:625
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:378
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:368
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:1208
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:1233
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: packet.c:484
PacketListEntry::next
struct PacketListEntry * next
Definition: packet_internal.h:29
MAX_REORDER_DELAY
@ MAX_REORDER_DELAY
Definition: vaapi_encode.h:45
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:152
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:525
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:161
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:1424
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:122
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:523
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:1430
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:523
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:797
av_packet_make_refcounted
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: packet.c:490
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:530
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: packet.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:1295
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: packet.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:1101
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:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:517
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:1938
AV_CODEC_ID_SMPTE_2038
@ AV_CODEC_ID_SMPTE_2038
Definition: codec_id.h:591
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:853
check_bitstream
static int check_bitstream(AVFormatContext *s, FFStream *sti, AVPacket *pkt)
Definition: mux.c:1114
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:855
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:1341
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:742
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:256
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:1851
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:929
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: packet.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:56
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:1151
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:2456
AVPacket::stream_index
int stream_index
Definition: packet.h:526
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:446
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
desc
const char * desc
Definition: libsvtav1.c:79
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:79
FFFrac::num
int64_t num
Definition: internal.h:60
mem.h
packet_internal.h
handle_avoid_negative_ts
static void handle_avoid_negative_ts(FFFormatContext *si, FFStream *sti, AVPacket *pkt)
Definition: mux.c:656
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:781
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:1079
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:1479
AVPacket
This structure stores compressed data.
Definition: packet.h:501
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:1280
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:74
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:3735
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:1962
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:1351
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:568
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:536
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:1394
FFFormatContext::avoid_negative_ts_use_pts
int avoid_negative_ts_use_pts
Definition: internal.h:148