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