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