FFmpeg
mux.c
Go to the documentation of this file.
1 /*
2  * muxing functions for use within FFmpeg
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "avformat.h"
23 #include "internal.h"
24 #include "libavcodec/bsf.h"
25 #include "libavcodec/internal.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/pixdesc.h"
30 #include "libavutil/timestamp.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/avstring.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 {
93  AVRational q;
94 
95  q = st->time_base;
96 
97  for (int j = 2; j < 14; j += 1 + (j > 2))
98  while (q.den / q.num < min_precision && q.num % j == 0)
99  q.num /= j;
100  while (q.den / q.num < min_precision && q.den < (1<<24))
101  q.den <<= 1;
102 
103  return q;
104 }
105 
107 {
108  AVCodecParameters *par = st->codecpar;
109  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(par->format);
110 
112  return par->chroma_location;
113 
114  if (pix_desc) {
115  if (pix_desc->log2_chroma_h == 0) {
116  return AVCHROMA_LOC_TOPLEFT;
117  } else if (pix_desc->log2_chroma_w == 1 && pix_desc->log2_chroma_h == 1) {
119  switch (par->codec_id) {
120  case AV_CODEC_ID_MJPEG:
122  }
123  }
125  switch (par->codec_id) {
127  }
128  }
129  }
130  }
131 
133 
134 }
135 
137  const char *format, const char *filename)
138 {
140  int ret = 0;
141 
142  *avctx = NULL;
143  if (!s)
144  goto nomem;
145 
146  if (!oformat) {
147  if (format) {
148  oformat = av_guess_format(format, NULL, NULL);
149  if (!oformat) {
150  av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
151  ret = AVERROR(EINVAL);
152  goto error;
153  }
154  } else {
155  oformat = av_guess_format(NULL, filename, NULL);
156  if (!oformat) {
157  ret = AVERROR(EINVAL);
158  av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
159  filename);
160  goto error;
161  }
162  }
163  }
164 
165  s->oformat = oformat;
166  if (s->oformat->priv_data_size > 0) {
167  s->priv_data = av_mallocz(s->oformat->priv_data_size);
168  if (!s->priv_data)
169  goto nomem;
170  if (s->oformat->priv_class) {
171  *(const AVClass**)s->priv_data= s->oformat->priv_class;
172  av_opt_set_defaults(s->priv_data);
173  }
174  } else
175  s->priv_data = NULL;
176 
177  if (filename) {
178  if (!(s->url = av_strdup(filename)))
179  goto nomem;
180 
181  }
182  *avctx = s;
183  return 0;
184 nomem:
185  av_log(s, AV_LOG_ERROR, "Out of memory\n");
186  ret = AVERROR(ENOMEM);
187 error:
189  return ret;
190 }
191 
193 {
194  const AVCodecTag *avctag;
195  enum AVCodecID id = AV_CODEC_ID_NONE;
196  int64_t tag = -1;
197 
198  /**
199  * Check that tag + id is in the table
200  * If neither is in the table -> OK
201  * If tag is in the table with another id -> FAIL
202  * If id is in the table with another tag -> FAIL unless strict < normal
203  */
204  for (int n = 0; s->oformat->codec_tag[n]; n++) {
205  avctag = s->oformat->codec_tag[n];
206  while (avctag->id != AV_CODEC_ID_NONE) {
207  if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codecpar->codec_tag)) {
208  id = avctag->id;
209  if (id == st->codecpar->codec_id)
210  return 1;
211  }
212  if (avctag->id == st->codecpar->codec_id)
213  tag = avctag->tag;
214  avctag++;
215  }
216  }
217  if (id != AV_CODEC_ID_NONE)
218  return 0;
219  if (tag >= 0 && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
220  return 0;
221  return 1;
222 }
223 
224 
226 {
227  FFFormatContext *const si = ffformatcontext(s);
228  AVDictionary *tmp = NULL;
229  const AVOutputFormat *of = s->oformat;
231  int ret = 0;
232 
233  if (options)
234  av_dict_copy(&tmp, *options, 0);
235 
236  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
237  goto fail;
238  if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
239  (ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
240  goto fail;
241 
242  if (!s->url && !(s->url = av_strdup(""))) {
243  ret = AVERROR(ENOMEM);
244  goto fail;
245  }
246 
247  // some sanity checks
248  if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) {
249  av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");
250  ret = AVERROR(EINVAL);
251  goto fail;
252  }
253 
254  for (unsigned i = 0; i < s->nb_streams; i++) {
255  AVStream *const st = s->streams[i];
256  FFStream *const sti = ffstream(st);
257  AVCodecParameters *const par = st->codecpar;
258  const AVCodecDescriptor *desc;
259 
260  if (!st->time_base.num) {
261  /* fall back on the default timebase values */
262  if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)
263  avpriv_set_pts_info(st, 64, 1, par->sample_rate);
264  else
265  avpriv_set_pts_info(st, 33, 1, 90000);
266  }
267 
268  switch (par->codec_type) {
269  case AVMEDIA_TYPE_AUDIO:
270  if (par->sample_rate <= 0) {
271  av_log(s, AV_LOG_ERROR, "sample rate not set\n");
272  ret = AVERROR(EINVAL);
273  goto fail;
274  }
275  if (!par->block_align)
276  par->block_align = par->channels *
277  av_get_bits_per_sample(par->codec_id) >> 3;
278  break;
279  case AVMEDIA_TYPE_VIDEO:
280  if ((par->width <= 0 || par->height <= 0) &&
281  !(of->flags & AVFMT_NODIMENSIONS)) {
282  av_log(s, AV_LOG_ERROR, "dimensions not set\n");
283  ret = AVERROR(EINVAL);
284  goto fail;
285  }
288  ) {
289  if (st->sample_aspect_ratio.num != 0 &&
290  st->sample_aspect_ratio.den != 0 &&
291  par->sample_aspect_ratio.num != 0 &&
292  par->sample_aspect_ratio.den != 0) {
293  av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
294  "(%d/%d) and encoder layer (%d/%d)\n",
297  par->sample_aspect_ratio.den);
298  ret = AVERROR(EINVAL);
299  goto fail;
300  }
301  }
302  break;
303  }
304 
306  if (desc && desc->props & AV_CODEC_PROP_REORDER)
307  sti->reorder = 1;
308 
310 
311  if (of->codec_tag) {
312  if ( par->codec_tag
313  && par->codec_id == AV_CODEC_ID_RAWVIDEO
314  && ( av_codec_get_tag(of->codec_tag, par->codec_id) == 0
315  || av_codec_get_tag(of->codec_tag, par->codec_id) == MKTAG('r', 'a', 'w', ' '))
316  && !validate_codec_tag(s, st)) {
317  // the current rawvideo encoding system ends up setting
318  // the wrong codec_tag for avi/mov, we override it here
319  par->codec_tag = 0;
320  }
321  if (par->codec_tag) {
322  if (!validate_codec_tag(s, st)) {
323  const uint32_t otag = av_codec_get_tag(s->oformat->codec_tag, par->codec_id);
325  "Tag %s incompatible with output codec id '%d' (%s)\n",
326  av_fourcc2str(par->codec_tag), par->codec_id, av_fourcc2str(otag));
328  goto fail;
329  }
330  } else
331  par->codec_tag = av_codec_get_tag(of->codec_tag, par->codec_id);
332  }
333 
336  }
338  if (!si->interleave_packet)
342 
343  if (!s->priv_data && of->priv_data_size > 0) {
344  s->priv_data = av_mallocz(of->priv_data_size);
345  if (!s->priv_data) {
346  ret = AVERROR(ENOMEM);
347  goto fail;
348  }
349  if (of->priv_class) {
350  *(const AVClass **)s->priv_data = of->priv_class;
351  av_opt_set_defaults(s->priv_data);
352  if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
353  goto fail;
354  }
355  }
356 
357  /* set muxer identification string */
358  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
359  av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
360  } else {
361  av_dict_set(&s->metadata, "encoder", NULL, 0);
362  }
363 
364  for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {
365  av_dict_set(&s->metadata, e->key, NULL, 0);
366  }
367 
368  if (options) {
370  *options = tmp;
371  }
372 
373  if (s->oformat->init) {
374  if ((ret = s->oformat->init(s)) < 0) {
375  if (s->oformat->deinit)
376  s->oformat->deinit(s);
377  return ret;
378  }
379  return ret == 0;
380  }
381 
382  return 0;
383 
384 fail:
385  av_dict_free(&tmp);
386  return ret;
387 }
388 
390 {
391  /* init PTS generation */
392  for (unsigned i = 0; i < s->nb_streams; i++) {
393  AVStream *const st = s->streams[i];
394  FFStream *const sti = ffstream(st);
395  int64_t den = AV_NOPTS_VALUE;
396 
397  switch (st->codecpar->codec_type) {
398  case AVMEDIA_TYPE_AUDIO:
399  den = (int64_t)st->time_base.num * st->codecpar->sample_rate;
400  break;
401  case AVMEDIA_TYPE_VIDEO:
402  den = (int64_t)st->time_base.num * st->time_base.den;
403  break;
404  default:
405  break;
406  }
407 
408  if (!sti->priv_pts)
409  sti->priv_pts = av_mallocz(sizeof(*sti->priv_pts));
410  if (!sti->priv_pts)
411  return AVERROR(ENOMEM);
412 
413  if (den != AV_NOPTS_VALUE) {
414  if (den <= 0)
415  return AVERROR_INVALIDDATA;
416 
417  frac_init(sti->priv_pts, 0, 0, den);
418  }
419  }
420 
421  if (s->avoid_negative_ts < 0) {
422  av_assert2(s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO);
423  if (s->oformat->flags & (AVFMT_TS_NEGATIVE | AVFMT_NOTIMESTAMPS)) {
424  s->avoid_negative_ts = 0;
425  } else
426  s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE;
427  }
428 
429  return 0;
430 }
431 
433 {
434  if (s->pb && s->pb->error >= 0) {
435  if (s->flush_packets == 1 || s->flags & AVFMT_FLAG_FLUSH_PACKETS)
436  avio_flush(s->pb);
437  else if (s->flush_packets && !(s->oformat->flags & AVFMT_NOFILE))
439  }
440 }
441 
443 {
444  FFFormatContext *const si = ffformatcontext(s);
445  if (s->oformat && s->oformat->deinit && si->initialized)
446  s->oformat->deinit(s);
447  si->initialized =
448  si->streams_initialized = 0;
449 }
450 
452 {
453  FFFormatContext *const si = ffformatcontext(s);
454  int ret = 0;
455 
456  if ((ret = init_muxer(s, options)) < 0)
457  return ret;
458 
459  si->initialized = 1;
460  si->streams_initialized = ret;
461 
462  if (s->oformat->init && ret) {
463  if ((ret = init_pts(s)) < 0)
464  return ret;
465 
467  }
468 
470 }
471 
473 {
474  FFFormatContext *const si = ffformatcontext(s);
475  int already_initialized = si->initialized;
476  int streams_already_initialized = si->streams_initialized;
477  int ret = 0;
478 
479  if (!already_initialized)
480  if ((ret = avformat_init_output(s, options)) < 0)
481  return ret;
482 
483  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
485  if (s->oformat->write_header) {
486  ret = s->oformat->write_header(s);
487  if (ret >= 0 && s->pb && s->pb->error < 0)
488  ret = s->pb->error;
489  if (ret < 0)
490  goto fail;
492  }
493  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
495 
496  if (!si->streams_initialized) {
497  if ((ret = init_pts(s)) < 0)
498  goto fail;
499  }
500 
501  return streams_already_initialized;
502 
503 fail:
504  deinit_muxer(s);
505  return ret;
506 }
507 
508 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
509 
510 
511 #if FF_API_COMPUTE_PKT_FIELDS2
513 //FIXME merge with compute_pkt_fields
514 static int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)
515 {
516  FFFormatContext *const si = ffformatcontext(s);
517  FFStream *const sti = ffstream(st);
518  int delay = st->codecpar->video_delay;
519  int frame_size;
520 
521  if (!si->missing_ts_warning &&
522  !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
524  (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
526  "Timestamps are unset in a packet for stream %d. "
527  "This is deprecated and will stop working in the future. "
528  "Fix your code to set the timestamps properly\n", st->index);
529  si->missing_ts_warning = 1;
530  }
531 
532  if (s->debug & FF_FDEBUG_TS)
533  av_log(s, AV_LOG_DEBUG, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
535 
536  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
537  pkt->pts = pkt->dts;
538 
539  //XXX/FIXME this is a temporary hack until all encoders output pts
540  if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
541  static int warned;
542  if (!warned) {
543  av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
544  warned = 1;
545  }
546  pkt->dts =
547 // pkt->pts= st->cur_dts;
548  pkt->pts = sti->priv_pts->val;
549  }
550 
551  //calculate dts from pts
552  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
553  sti->pts_buffer[0] = pkt->pts;
554  for (int i = 1; i < delay + 1 && sti->pts_buffer[i] == AV_NOPTS_VALUE; i++)
555  sti->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
556  for (int i = 0; i<delay && sti->pts_buffer[i] > sti->pts_buffer[i + 1]; i++)
557  FFSWAP(int64_t, sti->pts_buffer[i], sti->pts_buffer[i + 1]);
558 
559  pkt->dts = sti->pts_buffer[0];
560  }
561 
562  if (sti->cur_dts && sti->cur_dts != AV_NOPTS_VALUE &&
563  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
566  sti->cur_dts >= pkt->dts) || sti->cur_dts > pkt->dts)) {
568  "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
569  st->index, av_ts2str(sti->cur_dts), av_ts2str(pkt->dts));
570  return AVERROR(EINVAL);
571  }
572  if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
574  "pts (%s) < dts (%s) in stream %d\n",
576  st->index);
577  return AVERROR(EINVAL);
578  }
579 
580  if (s->debug & FF_FDEBUG_TS)
581  av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n",
583 
584  sti->cur_dts = pkt->dts;
585  sti->priv_pts->val = pkt->dts;
586 
587  /* update pts */
588  switch (st->codecpar->codec_type) {
589  case AVMEDIA_TYPE_AUDIO:
591  (*(AVFrame **)pkt->data)->nb_samples :
593 
594  /* HACK/FIXME, we skip the initial 0 size packets as they are most
595  * likely equal to the encoder delay, but it would be better if we
596  * had the real timestamps from the encoder */
597  if (frame_size >= 0 && (pkt->size || sti->priv_pts->num != sti->priv_pts->den >> 1 || sti->priv_pts->val)) {
598  frac_add(sti->priv_pts, (int64_t)st->time_base.den * frame_size);
599  }
600  break;
601  case AVMEDIA_TYPE_VIDEO:
602  frac_add(sti->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
603  break;
604  }
605  return 0;
606 }
608 #endif
609 
611 {
612  if (pkt->duration < 0 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
613  av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
615  pkt->duration = 0;
616  }
617 
618  if (pkt->duration)
619  return;
620 
621  switch (st->codecpar->codec_type) {
622  case AVMEDIA_TYPE_VIDEO:
623  if (st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0) {
625  st->time_base);
626  } else if (st->time_base.num * 1000LL > st->time_base.den)
627  pkt->duration = 1;
628  break;
629  case AVMEDIA_TYPE_AUDIO: {
631  if (frame_size && st->codecpar->sample_rate) {
633  (AVRational){1, st->codecpar->sample_rate},
634  st->time_base);
635  }
636  break;
637  }
638  }
639 }
640 
641 /**
642  * Shift timestamps and call muxer; the original pts/dts are not kept.
643  *
644  * FIXME: this function should NEVER get undefined pts/dts beside when the
645  * AVFMT_NOTIMESTAMPS is set.
646  * Those additional safety checks should be dropped once the correct checks
647  * are set in the callers.
648  */
650 {
651  FFFormatContext *const si = ffformatcontext(s);
652  AVStream *const st = s->streams[pkt->stream_index];
653  FFStream *const sti = ffstream(st);
654  int ret;
655 
656  // If the timestamp offsetting below is adjusted, adjust
657  // ff_interleaved_peek similarly.
658  if (s->output_ts_offset) {
659  int64_t offset = av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
660 
661  if (pkt->dts != AV_NOPTS_VALUE)
662  pkt->dts += offset;
663  if (pkt->pts != AV_NOPTS_VALUE)
664  pkt->pts += offset;
665  }
666 
667  if (s->avoid_negative_ts > 0) {
668  int64_t offset = sti->mux_ts_offset;
669  int64_t ts = si->avoid_negative_ts_use_pts ? pkt->pts : pkt->dts;
670 
671  if (si->offset == AV_NOPTS_VALUE && ts != AV_NOPTS_VALUE &&
672  (ts < 0 || s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO)) {
673  si->offset = -ts;
674  si->offset_timebase = st->time_base;
675  }
676 
677  if (si->offset != AV_NOPTS_VALUE && !offset) {
678  offset = sti->mux_ts_offset =
680  si->offset_timebase,
681  st->time_base,
682  AV_ROUND_UP);
683  }
684 
685  if (pkt->dts != AV_NOPTS_VALUE)
686  pkt->dts += offset;
687  if (pkt->pts != AV_NOPTS_VALUE)
688  pkt->pts += offset;
689 
690  if (si->avoid_negative_ts_use_pts) {
691  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < 0) {
692  av_log(s, AV_LOG_WARNING, "failed to avoid negative "
693  "pts %s in stream %d.\n"
694  "Try -avoid_negative_ts 1 as a possible workaround.\n",
695  av_ts2str(pkt->pts),
697  );
698  }
699  } else {
700  av_assert2(pkt->dts == AV_NOPTS_VALUE || pkt->dts >= 0 || s->max_interleave_delta > 0);
701  if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < 0) {
703  "Packets poorly interleaved, failed to avoid negative "
704  "timestamp %s in stream %d.\n"
705  "Try -max_interleave_delta 0 as a possible workaround.\n",
706  av_ts2str(pkt->dts),
708  );
709  }
710  }
711  }
712 
714  AVFrame **frame = (AVFrame **)pkt->data;
715  av_assert0(pkt->size == sizeof(*frame));
716  ret = s->oformat->write_uncoded_frame(s, pkt->stream_index, frame, 0);
717  } else {
718  ret = s->oformat->write_packet(s, pkt);
719  }
720 
721  if (s->pb && ret >= 0) {
723  if (s->pb->error < 0)
724  ret = s->pb->error;
725  }
726 
727  if (ret >= 0)
728  st->nb_frames++;
729 
730  return ret;
731 }
732 
734 {
735  if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
736  av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
737  pkt->stream_index);
738  return AVERROR(EINVAL);
739  }
740 
741  if (s->streams[pkt->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
742  av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
743  return AVERROR(EINVAL);
744  }
745 
746  return 0;
747 }
748 
750 {
751  FFStream *const sti = ffstream(st);
752 #if !FF_API_COMPUTE_PKT_FIELDS2
753  /* sanitize the timestamps */
754  if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
755 
756  /* when there is no reordering (so dts is equal to pts), but
757  * only one of them is set, set the other as well */
758  if (!sti->reorder) {
759  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)
760  pkt->pts = pkt->dts;
761  if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
762  pkt->dts = pkt->pts;
763  }
764 
765  /* check that the timestamps are set */
766  if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {
768  "Timestamps are unset in a packet for stream %d\n", st->index);
769  return AVERROR(EINVAL);
770  }
771 
772  /* check that the dts are increasing (or at least non-decreasing,
773  * if the format allows it */
774  if (sti->cur_dts != AV_NOPTS_VALUE &&
775  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && sti->cur_dts >= pkt->dts) ||
776  sti->cur_dts > pkt->dts)) {
778  "Application provided invalid, non monotonically increasing "
779  "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
780  st->index, sti->cur_dts, pkt->dts);
781  return AVERROR(EINVAL);
782  }
783 
784  if (pkt->pts < pkt->dts) {
785  av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
786  pkt->pts, pkt->dts, st->index);
787  return AVERROR(EINVAL);
788  }
789  }
790 #endif
791  /* update flags */
792  if (sti->is_intra_only)
794 
795  if (!pkt->data && !pkt->side_data_elems) {
796  /* Such empty packets signal EOS for the BSF API; so sanitize
797  * the packet by allocating data of size 0 (+ padding). */
800  }
801 
802  return 0;
803 }
804 
805 #define CHUNK_START 0x1000
806 
808  int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
809 {
810  int ret;
811  FFFormatContext *const si = ffformatcontext(s);
812  PacketList **next_point, *this_pktl;
813  AVStream *st = s->streams[pkt->stream_index];
814  FFStream *const sti = ffstream(st);
815  int chunked = s->max_chunk_size || s->max_chunk_duration;
816 
817  this_pktl = av_malloc(sizeof(PacketList));
818  if (!this_pktl) {
820  return AVERROR(ENOMEM);
821  }
822  if ((ret = av_packet_make_refcounted(pkt)) < 0) {
823  av_free(this_pktl);
825  return ret;
826  }
827 
828  av_packet_move_ref(&this_pktl->pkt, pkt);
829  pkt = &this_pktl->pkt;
830 
831  if (sti->last_in_packet_buffer) {
832  next_point = &(sti->last_in_packet_buffer->next);
833  } else {
834  next_point = &si->packet_buffer;
835  }
836 
837  if (chunked) {
838  uint64_t max= av_rescale_q_rnd(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base, AV_ROUND_UP);
841  if ( (s->max_chunk_size && sti->interleaver_chunk_size > s->max_chunk_size)
842  || (max && sti->interleaver_chunk_duration > max)) {
843  sti->interleaver_chunk_size = 0;
844  pkt->flags |= CHUNK_START;
845  if (max && sti->interleaver_chunk_duration > max) {
846  int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
847  int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
848 
849  sti->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
850  } else
852  }
853  }
854  if (*next_point) {
855  if (chunked && !(pkt->flags & CHUNK_START))
856  goto next_non_null;
857 
858  if (compare(s, &si->packet_buffer_end->pkt, pkt)) {
859  while ( *next_point
860  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
861  || !compare(s, &(*next_point)->pkt, pkt)))
862  next_point = &(*next_point)->next;
863  if (*next_point)
864  goto next_non_null;
865  } else {
866  next_point = &(si->packet_buffer_end->next);
867  }
868  }
869  av_assert1(!*next_point);
870 
871  si->packet_buffer_end = this_pktl;
872 next_non_null:
873 
874  this_pktl->next = *next_point;
875 
876  sti->last_in_packet_buffer = *next_point = this_pktl;
877 
878  return 0;
879 }
880 
882  const AVPacket *pkt)
883 {
884  AVStream *st = s->streams[pkt->stream_index];
885  AVStream *st2 = s->streams[next->stream_index];
886  int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
887  st->time_base);
888  if (s->audio_preload) {
889  int preload = st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
890  int preload2 = st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
891  if (preload != preload2) {
892  int64_t ts, ts2;
893  preload *= s->audio_preload;
894  preload2 *= s->audio_preload;
895  ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - preload;
896  ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - preload2;
897  if (ts == ts2) {
898  ts = ((uint64_t)pkt ->dts*st ->time_base.num*AV_TIME_BASE - (uint64_t)preload *st ->time_base.den)*st2->time_base.den
899  - ((uint64_t)next->dts*st2->time_base.num*AV_TIME_BASE - (uint64_t)preload2*st2->time_base.den)*st ->time_base.den;
900  ts2 = 0;
901  }
902  comp = (ts2 > ts) - (ts2 < ts);
903  }
904  }
905 
906  if (comp == 0)
907  return pkt->stream_index < next->stream_index;
908  return comp > 0;
909 }
910 
912  int flush, int has_packet)
913 {
914  FFFormatContext *const si = ffformatcontext(s);
915  int stream_count = 0;
916  int noninterleaved_count = 0;
917  int ret;
918  int eof = flush;
919 
920  if (has_packet) {
922  return ret;
923  }
924 
925  for (unsigned i = 0; i < s->nb_streams; i++) {
926  const AVStream *const st = s->streams[i];
927  const FFStream *const sti = cffstream(st);
928  const AVCodecParameters *const par = st->codecpar;
929  if (sti->last_in_packet_buffer) {
930  ++stream_count;
931  } else if (par->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
932  par->codec_id != AV_CODEC_ID_VP8 &&
933  par->codec_id != AV_CODEC_ID_VP9) {
934  ++noninterleaved_count;
935  }
936  }
937 
938  if (si->nb_interleaved_streams == stream_count)
939  flush = 1;
940 
941  if (s->max_interleave_delta > 0 &&
942  si->packet_buffer &&
943  !flush &&
944  si->nb_interleaved_streams == stream_count+noninterleaved_count
945  ) {
946  AVPacket *const top_pkt = &si->packet_buffer->pkt;
947  int64_t delta_dts = INT64_MIN;
948  int64_t top_dts = av_rescale_q(top_pkt->dts,
949  s->streams[top_pkt->stream_index]->time_base,
951 
952  for (unsigned i = 0; i < s->nb_streams; i++) {
953  const AVStream *const st = s->streams[i];
954  const FFStream *const sti = cffstream(st);
955  const PacketList *last = sti->last_in_packet_buffer;
956  int64_t last_dts;
957 
958  if (!last)
959  continue;
960 
961  last_dts = av_rescale_q(last->pkt.dts,
962  st->time_base,
964  delta_dts = FFMAX(delta_dts, last_dts - top_dts);
965  }
966 
967  if (delta_dts > s->max_interleave_delta) {
969  "Delay between the first packet and last packet in the "
970  "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
971  delta_dts, s->max_interleave_delta);
972  flush = 1;
973  }
974  }
975 
976  if (si->packet_buffer &&
977  eof &&
978  (s->flags & AVFMT_FLAG_SHORTEST) &&
979  si->shortest_end == AV_NOPTS_VALUE) {
980  AVPacket *const top_pkt = &si->packet_buffer->pkt;
981 
982  si->shortest_end = av_rescale_q(top_pkt->dts,
983  s->streams[top_pkt->stream_index]->time_base,
985  }
986 
987  if (si->shortest_end != AV_NOPTS_VALUE) {
988  while (si->packet_buffer) {
989  PacketList *pktl = si->packet_buffer;
990  AVPacket *const top_pkt = &pktl->pkt;
991  AVStream *const st = s->streams[top_pkt->stream_index];
992  FFStream *const sti = ffstream(st);
993  int64_t top_dts = av_rescale_q(top_pkt->dts, st->time_base,
995 
996  if (si->shortest_end + 1 >= top_dts)
997  break;
998 
999  si->packet_buffer = pktl->next;
1000  if (!si->packet_buffer)
1001  si->packet_buffer_end = NULL;
1002 
1003  if (sti->last_in_packet_buffer == pktl)
1004  sti->last_in_packet_buffer = NULL;
1005 
1006  av_packet_unref(&pktl->pkt);
1007  av_freep(&pktl);
1008  flush = 0;
1009  }
1010  }
1011 
1012  if (stream_count && flush) {
1013  PacketList *pktl = si->packet_buffer;
1014  AVStream *const st = s->streams[pktl->pkt.stream_index];
1015  FFStream *const sti = ffstream(st);
1016 
1017  *pkt = pktl->pkt;
1018 
1019  si->packet_buffer = pktl->next;
1020  if (!si->packet_buffer)
1021  si->packet_buffer_end = NULL;
1022 
1023  if (sti->last_in_packet_buffer == pktl)
1024  sti->last_in_packet_buffer = NULL;
1025  av_freep(&pktl);
1026 
1027  return 1;
1028  } else {
1029  return 0;
1030  }
1031 }
1032 
1034  int flush, int has_packet)
1035 {
1036  return has_packet;
1037 }
1038 
1039 int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
1040 {
1041  AVStream *st;
1042 
1043  if (stream_index < 0 || stream_index >= s->nb_streams)
1044  return AVERROR(EINVAL);
1045 
1046  st = s->streams[stream_index];
1047  *offset = ffstream(st)->mux_ts_offset;
1048 
1049  if (s->output_ts_offset)
1050  *offset += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
1051 
1052  return 0;
1053 }
1054 
1056 {
1057  FFFormatContext *const si = ffformatcontext(s);
1058  PacketList *pktl = si->packet_buffer;
1059  while (pktl) {
1060  if (pktl->pkt.stream_index == stream) {
1061  return &pktl->pkt;
1062  }
1063  pktl = pktl->next;
1064  }
1065  return NULL;
1066 }
1067 
1069 {
1070  int ret;
1071 
1072  if (!(s->flags & AVFMT_FLAG_AUTO_BSF))
1073  return 1;
1074 
1075  if (s->oformat->check_bitstream) {
1076  if (!sti->bitstream_checked) {
1077  if ((ret = s->oformat->check_bitstream(s, &sti->pub, pkt)) < 0)
1078  return ret;
1079  else if (ret == 1)
1080  sti->bitstream_checked = 1;
1081  }
1082  }
1083 
1084  return 1;
1085 }
1086 
1088  int flush, int has_packet)
1089 {
1090  FFFormatContext *const si = ffformatcontext(s);
1091  for (;; ) {
1092  int ret = si->interleave_packet(s, pkt, flush, has_packet);
1093  if (ret <= 0)
1094  return ret;
1095 
1096  has_packet = 0;
1097 
1098  ret = write_packet(s, pkt);
1100  if (ret < 0)
1101  return ret;
1102  }
1103 }
1104 
1105 static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1106 {
1107  int ret;
1108 
1109  if (s->debug & FF_FDEBUG_TS)
1110  av_log(s, AV_LOG_DEBUG, "%s size:%d dts:%s pts:%s\n", __FUNCTION__,
1112 
1113  guess_pkt_duration(s, st, pkt);
1114 
1115 #if FF_API_COMPUTE_PKT_FIELDS2
1116  if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1117  return ret;
1118 #endif
1119 
1120  if (interleaved) {
1121  if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1122  return AVERROR(EINVAL);
1123  return interleaved_write_packet(s, pkt, 0, 1);
1124  } else {
1125  return write_packet(s, pkt);
1126  }
1127 }
1128 
1129 static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1130 {
1131  FFStream *const sti = ffstream(st);
1132  AVBSFContext *const bsfc = sti->bsfc;
1133  int ret;
1134 
1135  if ((ret = av_bsf_send_packet(bsfc, pkt)) < 0) {
1137  "Failed to send packet to filter %s for stream %d\n",
1138  bsfc->filter->name, st->index);
1139  return ret;
1140  }
1141 
1142  do {
1143  ret = av_bsf_receive_packet(bsfc, pkt);
1144  if (ret < 0) {
1145  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
1146  return 0;
1147  av_log(s, AV_LOG_ERROR, "Error applying bitstream filters to an output "
1148  "packet for stream #%d: %s\n", st->index, av_err2str(ret));
1149  if (!(s->error_recognition & AV_EF_EXPLODE) && ret != AVERROR(ENOMEM))
1150  continue;
1151  return ret;
1152  }
1154  ret = write_packet_common(s, st, pkt, interleaved);
1155  if (ret >= 0 && !interleaved) // a successful write_packet_common already unrefed pkt for interleaved
1157  } while (ret >= 0);
1158 
1159  return ret;
1160 }
1161 
1162 static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
1163 {
1164  AVStream *st;
1165  FFStream *sti;
1166  int ret = check_packet(s, pkt);
1167  if (ret < 0)
1168  return ret;
1169  st = s->streams[pkt->stream_index];
1170  sti = ffstream(st);
1171 
1172  ret = prepare_input_packet(s, st, pkt);
1173  if (ret < 0)
1174  return ret;
1175 
1176  ret = check_bitstream(s, sti, pkt);
1177  if (ret < 0)
1178  return ret;
1179 
1180  if (sti->bsfc) {
1181  return write_packets_from_bsfs(s, st, pkt, interleaved);
1182  } else {
1183  return write_packet_common(s, st, pkt, interleaved);
1184  }
1185 }
1186 
1188 {
1189  FFFormatContext *const si = ffformatcontext(s);
1190  AVPacket *pkt = si->parse_pkt;
1191  int ret;
1192 
1193  if (!in) {
1194  if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
1195  ret = s->oformat->write_packet(s, NULL);
1196  flush_if_needed(s);
1197  if (ret >= 0 && s->pb && s->pb->error < 0)
1198  ret = s->pb->error;
1199  return ret;
1200  }
1201  return 1;
1202  }
1203 
1204  if (in->flags & AV_PKT_FLAG_UNCODED_FRAME) {
1205  pkt = in;
1206  } else {
1207  /* We don't own in, so we have to make sure not to modify it.
1208  * (ff_write_chained() relies on this fact.)
1209  * The following avoids copying in's data unnecessarily.
1210  * Copying side data is unavoidable as a bitstream filter
1211  * may change it, e.g. free it on errors. */
1212  pkt->data = in->data;
1213  pkt->size = in->size;
1214  ret = av_packet_copy_props(pkt, in);
1215  if (ret < 0)
1216  return ret;
1217  if (in->buf) {
1218  pkt->buf = av_buffer_ref(in->buf);
1219  if (!pkt->buf) {
1220  ret = AVERROR(ENOMEM);
1221  goto fail;
1222  }
1223  }
1224  }
1225 
1226  ret = write_packets_common(s, pkt, 0/*non-interleaved*/);
1227 
1228 fail:
1229  // Uncoded frames using the noninterleaved codepath are also freed here
1231  return ret;
1232 }
1233 
1235 {
1236  int ret;
1237 
1238  if (pkt) {
1239  ret = write_packets_common(s, pkt, 1/*interleaved*/);
1240  if (ret < 0)
1242  return ret;
1243  } else {
1244  av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");
1245  return interleaved_write_packet(s, ffformatcontext(s)->parse_pkt, 1/*flush*/, 0);
1246  }
1247 }
1248 
1250 {
1251  FFFormatContext *const si = ffformatcontext(s);
1252  AVPacket *const pkt = si->parse_pkt;
1253  int ret1, ret = 0;
1254 
1255  for (unsigned i = 0; i < s->nb_streams; i++) {
1256  AVStream *const st = s->streams[i];
1257  FFStream *const sti = ffstream(st);
1258  if (sti->bsfc) {
1259  ret1 = write_packets_from_bsfs(s, st, pkt, 1/*interleaved*/);
1260  if (ret1 < 0)
1262  if (ret >= 0)
1263  ret = ret1;
1264  }
1265  }
1266  ret1 = interleaved_write_packet(s, pkt, 1, 0);
1267  if (ret >= 0)
1268  ret = ret1;
1269 
1270  if (s->oformat->write_trailer) {
1271  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1273  if (ret >= 0) {
1274  ret = s->oformat->write_trailer(s);
1275  } else {
1276  s->oformat->write_trailer(s);
1277  }
1278  }
1279 
1280  deinit_muxer(s);
1281 
1282  if (s->pb)
1283  avio_flush(s->pb);
1284  if (ret == 0)
1285  ret = s->pb ? s->pb->error : 0;
1286  for (unsigned i = 0; i < s->nb_streams; i++) {
1287  av_freep(&s->streams[i]->priv_data);
1288  av_freep(&ffstream(s->streams[i])->index_entries);
1289  }
1290  if (s->oformat->priv_class)
1291  av_opt_free(s->priv_data);
1292  av_freep(&s->priv_data);
1293  av_packet_unref(si->pkt);
1294  return ret;
1295 }
1296 
1298  int64_t *dts, int64_t *wall)
1299 {
1300  if (!s->oformat || !s->oformat->get_output_timestamp)
1301  return AVERROR(ENOSYS);
1302  s->oformat->get_output_timestamp(s, stream, dts, wall);
1303  return 0;
1304 }
1305 
1306 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
1308 {
1309  int64_t pts = pkt->pts, dts = pkt->dts, duration = pkt->duration;
1310  int stream_index = pkt->stream_index;
1311  AVRational time_base = pkt->time_base;
1312  int ret;
1313 
1314  pkt->stream_index = dst_stream;
1315 
1317  src->streams[stream_index]->time_base,
1318  dst->streams[dst_stream]->time_base);
1319 
1320  if (!interleave) {
1321  ret = av_write_frame(dst, pkt);
1322  /* We only have to backup and restore the fields that
1323  * we changed ourselves, because av_write_frame() does not
1324  * modify the packet given to it. */
1325  pkt->pts = pts;
1326  pkt->dts = dts;
1327  pkt->duration = duration;
1328  pkt->stream_index = stream_index;
1329  pkt->time_base = time_base;
1330  } else
1332 
1333  return ret;
1334 }
1335 
1336 static void uncoded_frame_free(void *unused, uint8_t *data)
1337 {
1338  av_frame_free((AVFrame **)data);
1339  av_free(data);
1340 }
1341 
1342 static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
1343  AVFrame *frame, int interleaved)
1344 {
1345  FFFormatContext *const si = ffformatcontext(s);
1346  AVPacket *pkt = si->parse_pkt;
1347 
1348  av_assert0(s->oformat);
1349  if (!s->oformat->write_uncoded_frame) {
1350  av_frame_free(&frame);
1351  return AVERROR(ENOSYS);
1352  }
1353 
1354  if (!frame) {
1355  pkt = NULL;
1356  } else {
1357  size_t bufsize = sizeof(frame) + AV_INPUT_BUFFER_PADDING_SIZE;
1358  AVFrame **framep = av_mallocz(bufsize);
1359 
1360  if (!framep)
1361  goto fail;
1362  pkt->buf = av_buffer_create((void *)framep, bufsize,
1363  uncoded_frame_free, NULL, 0);
1364  if (!pkt->buf) {
1365  av_free(framep);
1366  fail:
1367  av_frame_free(&frame);
1368  return AVERROR(ENOMEM);
1369  }
1370  *framep = frame;
1371 
1372  pkt->data = (void *)framep;
1373  pkt->size = sizeof(frame);
1374  pkt->pts =
1375  pkt->dts = frame->pts;
1376  pkt->duration = frame->pkt_duration;
1377  pkt->stream_index = stream_index;
1379  }
1380 
1381  return interleaved ? av_interleaved_write_frame(s, pkt) :
1382  av_write_frame(s, pkt);
1383 }
1384 
1386  AVFrame *frame)
1387 {
1388  return write_uncoded_frame_internal(s, stream_index, frame, 0);
1389 }
1390 
1392  AVFrame *frame)
1393 {
1394  return write_uncoded_frame_internal(s, stream_index, frame, 1);
1395 }
1396 
1398 {
1399  av_assert0(s->oformat);
1400  if (!s->oformat->write_uncoded_frame)
1401  return AVERROR(ENOSYS);
1402  return s->oformat->write_uncoded_frame(s, stream_index, NULL,
1404 }
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:424
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
interleave_compare_dts
static int interleave_compare_dts(AVFormatContext *s, const AVPacket *next, const AVPacket *pkt)
Definition: mux.c:881
LIBAVFORMAT_IDENT
#define LIBAVFORMAT_IDENT
Definition: version.h:46
AVSTREAM_INIT_IN_WRITE_HEADER
#define AVSTREAM_INIT_IN_WRITE_HEADER
stream parameters initialized in avformat_write_header
Definition: avformat.h:2265
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:87
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
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:146
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:1364
AVFMT_NODIMENSIONS
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:472
FF_FDEBUG_TS
#define FF_FDEBUG_TS
Definition: avformat.h:1466
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:136
prepare_input_packet
static int prepare_input_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:749
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:85
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:191
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2660
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:866
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:468
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:91
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:1068
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:109
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:310
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
pixdesc.h
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1261
avpriv_toupper4
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:877
FFStream::interleaver_chunk_size
int64_t interleaver_chunk_size
Definition: internal.h:284
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:1385
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:1008
PacketList
Definition: packet_internal.h:26
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:168
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:1334
FFStream::bsfc
AVBSFContext * bsfc
bitstream filter to run on stream
Definition: internal.h:213
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:391
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
max
#define max(a, b)
Definition: cuda_runtime.h:33
mathematics.h
AVDictionary
Definition: dict.c:30
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:1397
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:451
cffstream
static const av_always_inline FFStream * cffstream(const AVStream *st)
Definition: internal.h:439
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:425
AVBSFContext
The bitstream filter state.
Definition: bsf.h:47
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
FFFormatContext::shortest_end
int64_t shortest_end
Timestamp of the end of the shortest stream.
Definition: internal.h:163
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:827
ff_is_intra_only
int ff_is_intra_only(enum AVCodecID id)
Definition: utils.c:288
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
FFStream::is_intra_only
int is_intra_only
Definition: internal.h:242
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
bsf.h
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:434
fail
#define fail()
Definition: checkasm.h:127
AVFMT_FLAG_AUTO_BSF
#define AVFMT_FLAG_AUTO_BSF
Add bitstream filters as requested by the muxer.
Definition: avformat.h:1335
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AVFMT_AVOID_NEG_TS_MAKE_ZERO
#define AVFMT_AVOID_NEG_TS_MAKE_ZERO
Shift timestamps so that they start at 0.
Definition: avformat.h:1528
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:871
pts
static int64_t pts
Definition: transcode_aac.c:653
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:911
FFStream::priv_pts
FFFrac * priv_pts
Definition: internal.h:244
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:591
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:649
AVCodecTag
Definition: internal.h:50
write_packet_common
static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1105
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:1087
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:1661
AV_PKT_FLAG_UNCODED_FRAME
#define AV_PKT_FLAG_UNCODED_FRAME
Definition: mux.c:508
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:257
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:136
AVDictionaryEntry::key
char * key
Definition: dict.h:80
frame_size
int frame_size
Definition: mxfenc.c:2198
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:126
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
FFStream::last_in_packet_buffer
struct PacketList * last_in_packet_buffer
last packet in packet_buffer for this stream when muxing.
Definition: internal.h:396
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
CHUNK_START
#define CHUNK_START
Definition: mux.c:805
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition: codec_par.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
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:141
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
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:522
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:1391
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:1055
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
f
#define f(width, name)
Definition: cbs_vp9.c:255
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:472
init_muxer
static int init_muxer(AVFormatContext *s, AVDictionary **options)
Definition: mux.c:225
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:1193
FFStream::pub
AVStream pub
The public context.
Definition: internal.h:200
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:356
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1088
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
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:218
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:958
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:593
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
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:618
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:140
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:807
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:620
ff_get_muxer_ts_offset
int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
Definition: mux.c:1039
src
#define src
Definition: vp8dsp.c:255
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1617
frac_add
static void frac_add(FFFrac *f, int64_t incr)
Fractional addition to f: f = f + (incr / f->den).
Definition: mux.c:71
PacketList::next
struct PacketList * next
Definition: packet_internal.h:27
AVOutputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:525
av_write_frame
int av_write_frame(AVFormatContext *s, AVPacket *in)
Write a packet to an output media file.
Definition: mux.c:1187
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1335
FFStream::interleaver_chunk_duration
int64_t interleaver_chunk_duration
Definition: internal.h:285
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:481
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:1306
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:51
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:980
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:1162
validate_codec_tag
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
Definition: mux.c:192
AVOutputFormat::flags
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:516
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
FFFormatContext::packet_buffer_end
struct PacketList * packet_buffer_end
Definition: internal.h:96
options
const OptionDef options[]
AVPacket::size
int size
Definition: packet.h:374
FFFormatContext::parse_pkt
AVPacket * parse_pkt
The generic code uses this as a temporary packet to parse packets or for muxing, especially flushing.
Definition: internal.h:127
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:154
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:432
FFStream
Definition: internal.h:196
AV_CODEC_PROP_REORDER
#define AV_CODEC_PROP_REORDER
Codec supports frame reordering.
Definition: codec_desc.h:92
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:477
format
ofilter format
Definition: ffmpeg_filter.c:172
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:464
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:617
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:997
AVFMT_NOSTREAMS
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:473
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:559
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
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:1637
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:487
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
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:528
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1283
PacketList::pkt
AVPacket pkt
Definition: packet_internal.h:28
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:570
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:616
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:57
MAX_REORDER_DELAY
@ MAX_REORDER_DELAY
Definition: vaapi_encode.h:44
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:1249
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:387
FFStream::mux_ts_offset
int64_t mux_ts_offset
Timestamp offset added to timestamps before muxing.
Definition: internal.h:338
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:226
AVOutputFormat
Definition: avformat.h:496
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
guess_pkt_duration
static void guess_pkt_duration(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:610
internal.h
AVCodecParameters::height
int height
Definition: codec_par.h:127
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:177
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:1297
FFStream::reorder
int reorder
Set to 1 if the codec allows reordering, so pts can be different from dts.
Definition: internal.h:206
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:1527
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:370
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:263
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:128
AVBSFContext::time_base_out
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: bsf.h:87
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
AVIO_DATA_MARKER_UNKNOWN
@ AVIO_DATA_MARKER_UNKNOWN
This is any, unlabelled data.
Definition: avio.h:135
AVFMT_TS_NEGATIVE
#define AVFMT_TS_NEGATIVE
Format allows muxing negative timestamps.
Definition: avformat.h:481
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:478
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:988
tag
uint32_t tag
Definition: movenc.c:1595
AVFMT_FLAG_BITEXACT
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1328
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:928
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
ff_choose_timebase
AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:91
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:198
AVCodecParameters::chroma_location
enum AVChromaLocation chroma_location
Definition: codec_par.h:150
deinit_muxer
static void deinit_muxer(AVFormatContext *s)
Definition: mux.c:442
FFFormatContext::packet_buffer
struct PacketList * packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:95
FFFormatContext::offset_timebase
AVRational offset_timebase
Timebase for the timestamp offset.
Definition: internal.h:150
check_packet
static int check_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:733
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:936
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:1342
AVCHROMA_LOC_CENTER
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:619
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:115
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:680
FFFormatContext::offset
int64_t offset
Offset to remap timestamps to be non-negative.
Definition: internal.h:145
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: utils.c:1186
AVSTREAM_INIT_IN_INIT_OUTPUT
#define AVSTREAM_INIT_IN_INIT_OUTPUT
stream parameters initialized in avformat_init_output
Definition: avformat.h:2266
AVPacket::stream_index
int stream_index
Definition: packet.h:375
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:1033
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:279
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:56
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:279
desc
const char * desc
Definition: libsvtav1.c:79
FFFormatContext::streams_initialized
int streams_initialized
Whether or not avformat_init_output fully initialized streams.
Definition: internal.h:173
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:51
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:1129
packet_internal.h
ff_choose_chroma_location
enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:106
AVCodecParameters::video_delay
int video_delay
Video only.
Definition: codec_par.h:155
FFFormatContext::pkt
AVPacket * pkt
Used to hold temporary packets for the generic demuxing code.
Definition: internal.h:134
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: codec_par.h:38
AVCodecParameters::format
int format
Definition: codec_par.h:84
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
init_pts
static int init_pts(AVFormatContext *s)
Definition: mux.c:389
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
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:60
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:350
AV_WRITE_UNCODED_FRAME_QUERY
@ AV_WRITE_UNCODED_FRAME_QUERY
Query whether the feature is possible on this stream.
Definition: internal.h:880
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:1234
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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
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:1336
FFStream::cur_dts
int64_t cur_dts
Definition: internal.h:431
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:28
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:1321
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:3521
AVFMT_AVOID_NEG_TS_AUTO
#define AVFMT_AVOID_NEG_TS_AUTO
Enabled when required by target format.
Definition: avformat.h:1526
avstring.h
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
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:52
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:133
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:89
AVPacket::time_base
AVRational time_base
Time base of the packet's timestamps.
Definition: packet.h:414
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:385
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:348
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:146
AVOutputFormat::priv_data_size
int priv_data_size
size of private data so that it can be allocated in the wrapper
Definition: avformat.h:537
FFFormatContext::avoid_negative_ts_use_pts
int avoid_negative_ts_use_pts
Definition: internal.h:158