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  }
337 
338  if (!s->priv_data && of->priv_data_size > 0) {
339  s->priv_data = av_mallocz(of->priv_data_size);
340  if (!s->priv_data) {
341  ret = AVERROR(ENOMEM);
342  goto fail;
343  }
344  if (of->priv_class) {
345  *(const AVClass **)s->priv_data = of->priv_class;
346  av_opt_set_defaults(s->priv_data);
347  if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
348  goto fail;
349  }
350  }
351 
352  /* set muxer identification string */
353  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
354  av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
355  } else {
356  av_dict_set(&s->metadata, "encoder", NULL, 0);
357  }
358 
359  for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {
360  av_dict_set(&s->metadata, e->key, NULL, 0);
361  }
362 
363  if (options) {
365  *options = tmp;
366  }
367 
368  if (s->oformat->init) {
369  if ((ret = s->oformat->init(s)) < 0) {
370  if (s->oformat->deinit)
371  s->oformat->deinit(s);
372  return ret;
373  }
374  return ret == 0;
375  }
376 
377  return 0;
378 
379 fail:
380  av_dict_free(&tmp);
381  return ret;
382 }
383 
385 {
386  /* init PTS generation */
387  for (unsigned i = 0; i < s->nb_streams; i++) {
388  AVStream *const st = s->streams[i];
389  FFStream *const sti = ffstream(st);
390  int64_t den = AV_NOPTS_VALUE;
391 
392  switch (st->codecpar->codec_type) {
393  case AVMEDIA_TYPE_AUDIO:
394  den = (int64_t)st->time_base.num * st->codecpar->sample_rate;
395  break;
396  case AVMEDIA_TYPE_VIDEO:
397  den = (int64_t)st->time_base.num * st->time_base.den;
398  break;
399  default:
400  break;
401  }
402 
403  if (!sti->priv_pts)
404  sti->priv_pts = av_mallocz(sizeof(*sti->priv_pts));
405  if (!sti->priv_pts)
406  return AVERROR(ENOMEM);
407 
408  if (den != AV_NOPTS_VALUE) {
409  if (den <= 0)
410  return AVERROR_INVALIDDATA;
411 
412  frac_init(sti->priv_pts, 0, 0, den);
413  }
414  }
415 
416  if (s->avoid_negative_ts < 0) {
417  av_assert2(s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO);
418  if (s->oformat->flags & (AVFMT_TS_NEGATIVE | AVFMT_NOTIMESTAMPS)) {
419  s->avoid_negative_ts = 0;
420  } else
421  s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE;
422  }
423 
424  return 0;
425 }
426 
428 {
429  if (s->pb && s->pb->error >= 0) {
430  if (s->flush_packets == 1 || s->flags & AVFMT_FLAG_FLUSH_PACKETS)
431  avio_flush(s->pb);
432  else if (s->flush_packets && !(s->oformat->flags & AVFMT_NOFILE))
434  }
435 }
436 
438 {
439  FFFormatContext *const si = ffformatcontext(s);
440  if (s->oformat && s->oformat->deinit && si->initialized)
441  s->oformat->deinit(s);
442  si->initialized =
443  si->streams_initialized = 0;
444 }
445 
447 {
448  FFFormatContext *const si = ffformatcontext(s);
449  int ret = 0;
450 
451  if ((ret = init_muxer(s, options)) < 0)
452  return ret;
453 
454  si->initialized = 1;
455  si->streams_initialized = ret;
456 
457  if (s->oformat->init && ret) {
458  if ((ret = init_pts(s)) < 0)
459  return ret;
460 
462  }
463 
465 }
466 
468 {
469  FFFormatContext *const si = ffformatcontext(s);
470  int already_initialized = si->initialized;
471  int streams_already_initialized = si->streams_initialized;
472  int ret = 0;
473 
474  if (!already_initialized)
475  if ((ret = avformat_init_output(s, options)) < 0)
476  return ret;
477 
478  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
480  if (s->oformat->write_header) {
481  ret = s->oformat->write_header(s);
482  if (ret >= 0 && s->pb && s->pb->error < 0)
483  ret = s->pb->error;
484  if (ret < 0)
485  goto fail;
487  }
488  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
490 
491  if (!si->streams_initialized) {
492  if ((ret = init_pts(s)) < 0)
493  goto fail;
494  }
495 
496  return streams_already_initialized;
497 
498 fail:
499  deinit_muxer(s);
500  return ret;
501 }
502 
503 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
504 
505 
506 #if FF_API_COMPUTE_PKT_FIELDS2
508 //FIXME merge with compute_pkt_fields
509 static int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)
510 {
511  FFFormatContext *const si = ffformatcontext(s);
512  FFStream *const sti = ffstream(st);
513  int delay = st->codecpar->video_delay;
514  int frame_size;
515 
516  if (!si->missing_ts_warning &&
517  !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
519  (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
521  "Timestamps are unset in a packet for stream %d. "
522  "This is deprecated and will stop working in the future. "
523  "Fix your code to set the timestamps properly\n", st->index);
524  si->missing_ts_warning = 1;
525  }
526 
527  if (s->debug & FF_FDEBUG_TS)
528  av_log(s, AV_LOG_DEBUG, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
530 
531  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
532  pkt->pts = pkt->dts;
533 
534  //XXX/FIXME this is a temporary hack until all encoders output pts
535  if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
536  static int warned;
537  if (!warned) {
538  av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
539  warned = 1;
540  }
541  pkt->dts =
542 // pkt->pts= st->cur_dts;
543  pkt->pts = sti->priv_pts->val;
544  }
545 
546  //calculate dts from pts
547  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
548  sti->pts_buffer[0] = pkt->pts;
549  for (int i = 1; i < delay + 1 && sti->pts_buffer[i] == AV_NOPTS_VALUE; i++)
550  sti->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
551  for (int i = 0; i<delay && sti->pts_buffer[i] > sti->pts_buffer[i + 1]; i++)
552  FFSWAP(int64_t, sti->pts_buffer[i], sti->pts_buffer[i + 1]);
553 
554  pkt->dts = sti->pts_buffer[0];
555  }
556 
557  if (sti->cur_dts && sti->cur_dts != AV_NOPTS_VALUE &&
558  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
561  sti->cur_dts >= pkt->dts) || sti->cur_dts > pkt->dts)) {
563  "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
564  st->index, av_ts2str(sti->cur_dts), av_ts2str(pkt->dts));
565  return AVERROR(EINVAL);
566  }
567  if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
569  "pts (%s) < dts (%s) in stream %d\n",
571  st->index);
572  return AVERROR(EINVAL);
573  }
574 
575  if (s->debug & FF_FDEBUG_TS)
576  av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n",
578 
579  sti->cur_dts = pkt->dts;
580  sti->priv_pts->val = pkt->dts;
581 
582  /* update pts */
583  switch (st->codecpar->codec_type) {
584  case AVMEDIA_TYPE_AUDIO:
586  (*(AVFrame **)pkt->data)->nb_samples :
588 
589  /* HACK/FIXME, we skip the initial 0 size packets as they are most
590  * likely equal to the encoder delay, but it would be better if we
591  * had the real timestamps from the encoder */
592  if (frame_size >= 0 && (pkt->size || sti->priv_pts->num != sti->priv_pts->den >> 1 || sti->priv_pts->val)) {
593  frac_add(sti->priv_pts, (int64_t)st->time_base.den * frame_size);
594  }
595  break;
596  case AVMEDIA_TYPE_VIDEO:
597  frac_add(sti->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
598  break;
599  }
600  return 0;
601 }
603 #endif
604 
606 {
607  if (pkt->duration < 0 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
608  av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
610  pkt->duration = 0;
611  }
612 
613  if (pkt->duration)
614  return;
615 
616  switch (st->codecpar->codec_type) {
617  case AVMEDIA_TYPE_VIDEO:
618  if (st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0) {
620  st->time_base);
621  } else if (st->time_base.num * 1000LL > st->time_base.den)
622  pkt->duration = 1;
623  break;
624  case AVMEDIA_TYPE_AUDIO: {
626  if (frame_size && st->codecpar->sample_rate) {
628  (AVRational){1, st->codecpar->sample_rate},
629  st->time_base);
630  }
631  break;
632  }
633  }
634 }
635 
636 /**
637  * Shift timestamps and call muxer; the original pts/dts are not kept.
638  *
639  * FIXME: this function should NEVER get undefined pts/dts beside when the
640  * AVFMT_NOTIMESTAMPS is set.
641  * Those additional safety checks should be dropped once the correct checks
642  * are set in the callers.
643  */
645 {
646  FFFormatContext *const si = ffformatcontext(s);
647  AVStream *const st = s->streams[pkt->stream_index];
648  FFStream *const sti = ffstream(st);
649  int ret;
650 
651  // If the timestamp offsetting below is adjusted, adjust
652  // ff_interleaved_peek similarly.
653  if (s->output_ts_offset) {
654  int64_t offset = av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
655 
656  if (pkt->dts != AV_NOPTS_VALUE)
657  pkt->dts += offset;
658  if (pkt->pts != AV_NOPTS_VALUE)
659  pkt->pts += offset;
660  }
661 
662  if (s->avoid_negative_ts > 0) {
663  int64_t offset = sti->mux_ts_offset;
664  int64_t ts = si->avoid_negative_ts_use_pts ? pkt->pts : pkt->dts;
665 
666  if (si->offset == AV_NOPTS_VALUE && ts != AV_NOPTS_VALUE &&
667  (ts < 0 || s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO)) {
668  si->offset = -ts;
669  si->offset_timebase = st->time_base;
670  }
671 
672  if (si->offset != AV_NOPTS_VALUE && !offset) {
673  offset = sti->mux_ts_offset =
675  si->offset_timebase,
676  st->time_base,
677  AV_ROUND_UP);
678  }
679 
680  if (pkt->dts != AV_NOPTS_VALUE)
681  pkt->dts += offset;
682  if (pkt->pts != AV_NOPTS_VALUE)
683  pkt->pts += offset;
684 
685  if (si->avoid_negative_ts_use_pts) {
686  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < 0) {
687  av_log(s, AV_LOG_WARNING, "failed to avoid negative "
688  "pts %s in stream %d.\n"
689  "Try -avoid_negative_ts 1 as a possible workaround.\n",
690  av_ts2str(pkt->pts),
692  );
693  }
694  } else {
695  av_assert2(pkt->dts == AV_NOPTS_VALUE || pkt->dts >= 0 || s->max_interleave_delta > 0);
696  if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < 0) {
698  "Packets poorly interleaved, failed to avoid negative "
699  "timestamp %s in stream %d.\n"
700  "Try -max_interleave_delta 0 as a possible workaround.\n",
701  av_ts2str(pkt->dts),
703  );
704  }
705  }
706  }
707 
709  AVFrame **frame = (AVFrame **)pkt->data;
710  av_assert0(pkt->size == sizeof(*frame));
711  ret = s->oformat->write_uncoded_frame(s, pkt->stream_index, frame, 0);
712  } else {
713  ret = s->oformat->write_packet(s, pkt);
714  }
715 
716  if (s->pb && ret >= 0) {
718  if (s->pb->error < 0)
719  ret = s->pb->error;
720  }
721 
722  if (ret >= 0)
723  st->nb_frames++;
724 
725  return ret;
726 }
727 
729 {
730  if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
731  av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
732  pkt->stream_index);
733  return AVERROR(EINVAL);
734  }
735 
736  if (s->streams[pkt->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
737  av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
738  return AVERROR(EINVAL);
739  }
740 
741  return 0;
742 }
743 
745 {
746  FFStream *const sti = ffstream(st);
747 #if !FF_API_COMPUTE_PKT_FIELDS2
748  /* sanitize the timestamps */
749  if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
750 
751  /* when there is no reordering (so dts is equal to pts), but
752  * only one of them is set, set the other as well */
753  if (!sti->reorder) {
754  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)
755  pkt->pts = pkt->dts;
756  if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
757  pkt->dts = pkt->pts;
758  }
759 
760  /* check that the timestamps are set */
761  if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {
763  "Timestamps are unset in a packet for stream %d\n", st->index);
764  return AVERROR(EINVAL);
765  }
766 
767  /* check that the dts are increasing (or at least non-decreasing,
768  * if the format allows it */
769  if (sti->cur_dts != AV_NOPTS_VALUE &&
770  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && sti->cur_dts >= pkt->dts) ||
771  sti->cur_dts > pkt->dts)) {
773  "Application provided invalid, non monotonically increasing "
774  "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
775  st->index, sti->cur_dts, pkt->dts);
776  return AVERROR(EINVAL);
777  }
778 
779  if (pkt->pts < pkt->dts) {
780  av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
781  pkt->pts, pkt->dts, st->index);
782  return AVERROR(EINVAL);
783  }
784  }
785 #endif
786  /* update flags */
787  if (sti->is_intra_only)
789 
790  return 0;
791 }
792 
793 #define CHUNK_START 0x1000
794 
796  int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
797 {
798  int ret;
799  FFFormatContext *const si = ffformatcontext(s);
800  PacketList **next_point, *this_pktl;
801  AVStream *st = s->streams[pkt->stream_index];
802  FFStream *const sti = ffstream(st);
803  int chunked = s->max_chunk_size || s->max_chunk_duration;
804 
805  this_pktl = av_malloc(sizeof(PacketList));
806  if (!this_pktl) {
808  return AVERROR(ENOMEM);
809  }
810  if ((ret = av_packet_make_refcounted(pkt)) < 0) {
811  av_free(this_pktl);
813  return ret;
814  }
815 
816  av_packet_move_ref(&this_pktl->pkt, pkt);
817  pkt = &this_pktl->pkt;
818 
819  if (sti->last_in_packet_buffer) {
820  next_point = &(sti->last_in_packet_buffer->next);
821  } else {
822  next_point = &si->packet_buffer;
823  }
824 
825  if (chunked) {
826  uint64_t max= av_rescale_q_rnd(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base, AV_ROUND_UP);
829  if ( (s->max_chunk_size && sti->interleaver_chunk_size > s->max_chunk_size)
830  || (max && sti->interleaver_chunk_duration > max)) {
831  sti->interleaver_chunk_size = 0;
832  pkt->flags |= CHUNK_START;
833  if (max && sti->interleaver_chunk_duration > max) {
834  int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
835  int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
836 
837  sti->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
838  } else
840  }
841  }
842  if (*next_point) {
843  if (chunked && !(pkt->flags & CHUNK_START))
844  goto next_non_null;
845 
846  if (compare(s, &si->packet_buffer_end->pkt, pkt)) {
847  while ( *next_point
848  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
849  || !compare(s, &(*next_point)->pkt, pkt)))
850  next_point = &(*next_point)->next;
851  if (*next_point)
852  goto next_non_null;
853  } else {
854  next_point = &(si->packet_buffer_end->next);
855  }
856  }
857  av_assert1(!*next_point);
858 
859  si->packet_buffer_end = this_pktl;
860 next_non_null:
861 
862  this_pktl->next = *next_point;
863 
864  sti->last_in_packet_buffer = *next_point = this_pktl;
865 
866  return 0;
867 }
868 
870  const AVPacket *pkt)
871 {
872  AVStream *st = s->streams[pkt->stream_index];
873  AVStream *st2 = s->streams[next->stream_index];
874  int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
875  st->time_base);
876  if (s->audio_preload) {
877  int preload = st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
878  int preload2 = st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
879  if (preload != preload2) {
880  int64_t ts, ts2;
881  preload *= s->audio_preload;
882  preload2 *= s->audio_preload;
883  ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - preload;
884  ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - preload2;
885  if (ts == ts2) {
886  ts = ((uint64_t)pkt ->dts*st ->time_base.num*AV_TIME_BASE - (uint64_t)preload *st ->time_base.den)*st2->time_base.den
887  - ((uint64_t)next->dts*st2->time_base.num*AV_TIME_BASE - (uint64_t)preload2*st2->time_base.den)*st ->time_base.den;
888  ts2 = 0;
889  }
890  comp = (ts2 > ts) - (ts2 < ts);
891  }
892  }
893 
894  if (comp == 0)
895  return pkt->stream_index < next->stream_index;
896  return comp > 0;
897 }
898 
900  AVPacket *pkt, int flush)
901 {
902  FFFormatContext *const si = ffformatcontext(s);
903  int stream_count = 0;
904  int noninterleaved_count = 0;
905  int ret;
906  int eof = flush;
907 
908  if (pkt) {
910  return ret;
911  }
912 
913  for (unsigned i = 0; i < s->nb_streams; i++) {
914  const AVStream *const st = s->streams[i];
915  const FFStream *const sti = cffstream(st);
916  const AVCodecParameters *const par = st->codecpar;
917  if (sti->last_in_packet_buffer) {
918  ++stream_count;
919  } else if (par->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
920  par->codec_id != AV_CODEC_ID_VP8 &&
921  par->codec_id != AV_CODEC_ID_VP9) {
922  ++noninterleaved_count;
923  }
924  }
925 
926  if (si->nb_interleaved_streams == stream_count)
927  flush = 1;
928 
929  if (s->max_interleave_delta > 0 &&
930  si->packet_buffer &&
931  !flush &&
932  si->nb_interleaved_streams == stream_count+noninterleaved_count
933  ) {
934  AVPacket *const top_pkt = &si->packet_buffer->pkt;
935  int64_t delta_dts = INT64_MIN;
936  int64_t top_dts = av_rescale_q(top_pkt->dts,
937  s->streams[top_pkt->stream_index]->time_base,
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 PacketList *last = sti->last_in_packet_buffer;
944  int64_t last_dts;
945 
946  if (!last)
947  continue;
948 
949  last_dts = av_rescale_q(last->pkt.dts,
950  st->time_base,
952  delta_dts = FFMAX(delta_dts, last_dts - top_dts);
953  }
954 
955  if (delta_dts > s->max_interleave_delta) {
957  "Delay between the first packet and last packet in the "
958  "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
959  delta_dts, s->max_interleave_delta);
960  flush = 1;
961  }
962  }
963 
964  if (si->packet_buffer &&
965  eof &&
966  (s->flags & AVFMT_FLAG_SHORTEST) &&
967  si->shortest_end == AV_NOPTS_VALUE) {
968  AVPacket *const top_pkt = &si->packet_buffer->pkt;
969 
970  si->shortest_end = av_rescale_q(top_pkt->dts,
971  s->streams[top_pkt->stream_index]->time_base,
973  }
974 
975  if (si->shortest_end != AV_NOPTS_VALUE) {
976  while (si->packet_buffer) {
977  PacketList *pktl = si->packet_buffer;
978  AVPacket *const top_pkt = &pktl->pkt;
979  AVStream *const st = s->streams[top_pkt->stream_index];
980  FFStream *const sti = ffstream(st);
981  int64_t top_dts = av_rescale_q(top_pkt->dts, st->time_base,
983 
984  if (si->shortest_end + 1 >= top_dts)
985  break;
986 
987  si->packet_buffer = pktl->next;
988  if (!si->packet_buffer)
989  si->packet_buffer_end = NULL;
990 
991  if (sti->last_in_packet_buffer == pktl)
993 
994  av_packet_unref(&pktl->pkt);
995  av_freep(&pktl);
996  flush = 0;
997  }
998  }
999 
1000  if (stream_count && flush) {
1001  PacketList *pktl = si->packet_buffer;
1002  AVStream *const st = s->streams[pktl->pkt.stream_index];
1003  FFStream *const sti = ffstream(st);
1004 
1005  *out = pktl->pkt;
1006 
1007  si->packet_buffer = pktl->next;
1008  if (!si->packet_buffer)
1009  si->packet_buffer_end = NULL;
1010 
1011  if (sti->last_in_packet_buffer == pktl)
1012  sti->last_in_packet_buffer = NULL;
1013  av_freep(&pktl);
1014 
1015  return 1;
1016  } else {
1017  return 0;
1018  }
1019 }
1020 
1021 int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
1022 {
1023  AVStream *st;
1024 
1025  if (stream_index < 0 || stream_index >= s->nb_streams)
1026  return AVERROR(EINVAL);
1027 
1028  st = s->streams[stream_index];
1029  *offset = ffstream(st)->mux_ts_offset;
1030 
1031  if (s->output_ts_offset)
1032  *offset += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
1033 
1034  return 0;
1035 }
1036 
1038 {
1039  FFFormatContext *const si = ffformatcontext(s);
1040  PacketList *pktl = si->packet_buffer;
1041  while (pktl) {
1042  if (pktl->pkt.stream_index == stream) {
1043  return &pktl->pkt;
1044  }
1045  pktl = pktl->next;
1046  }
1047  return NULL;
1048 }
1049 
1050 /**
1051  * Interleave an AVPacket correctly so it can be muxed.
1052  * @param out the interleaved packet will be output here
1053  * @param in the input packet; will always be blank on return if not NULL
1054  * @param flush 1 if no further packets are available as input and all
1055  * remaining packets should be output
1056  * @return 1 if a packet was output, 0 if no packet could be output,
1057  * < 0 if an error occurred
1058  */
1060 {
1061  if (s->oformat->interleave_packet) {
1062  return s->oformat->interleave_packet(s, out, in, flush);
1063  } else
1064  return ff_interleave_packet_per_dts(s, out, in, flush);
1065 }
1066 
1068 {
1069  int ret;
1070 
1071  if (!(s->flags & AVFMT_FLAG_AUTO_BSF))
1072  return 1;
1073 
1074  if (s->oformat->check_bitstream) {
1075  if (!sti->bitstream_checked) {
1076  if ((ret = s->oformat->check_bitstream(s, pkt)) < 0)
1077  return ret;
1078  else if (ret == 1)
1079  sti->bitstream_checked = 1;
1080  }
1081  }
1082 
1083  return 1;
1084 }
1085 
1087 {
1088  for (;; ) {
1089  AVPacket opkt;
1090  int ret = interleave_packet(s, &opkt, pkt, flush);
1091  if (ret <= 0)
1092  return ret;
1093 
1094  pkt = NULL;
1095 
1096  ret = write_packet(s, &opkt);
1097 
1098  av_packet_unref(&opkt);
1099 
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);
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->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. */
1213  pkt->buf = NULL;
1214  pkt->data = in->data;
1215  pkt->size = in->size;
1216  ret = av_packet_copy_props(pkt, in);
1217  if (ret < 0)
1218  return ret;
1219  if (in->buf) {
1220  pkt->buf = av_buffer_ref(in->buf);
1221  if (!pkt->buf) {
1222  ret = AVERROR(ENOMEM);
1223  goto fail;
1224  }
1225  }
1226  }
1227 
1228  ret = write_packets_common(s, pkt, 0/*non-interleaved*/);
1229 
1230 fail:
1231  // Uncoded frames using the noninterleaved codepath are also freed here
1233  return ret;
1234 }
1235 
1237 {
1238  int ret;
1239 
1240  if (pkt) {
1241  ret = write_packets_common(s, pkt, 1/*interleaved*/);
1242  if (ret < 0)
1244  return ret;
1245  } else {
1246  av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");
1247  return interleaved_write_packet(s, NULL, 1/*flush*/);
1248  }
1249 }
1250 
1252 {
1253  FFFormatContext *const si = ffformatcontext(s);
1254  AVPacket *const pkt = si->pkt;
1255  int ret1, ret = 0;
1256 
1258  for (unsigned i = 0; i < s->nb_streams; i++) {
1259  if (ffstream(s->streams[i])->bsfc) {
1260  ret1 = write_packets_from_bsfs(s, s->streams[i], pkt, 1/*interleaved*/);
1261  if (ret1 < 0)
1263  if (ret >= 0)
1264  ret = ret1;
1265  }
1266  }
1267  ret1 = interleaved_write_packet(s, NULL, 1);
1268  if (ret >= 0)
1269  ret = ret1;
1270 
1271  if (s->oformat->write_trailer) {
1272  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1274  if (ret >= 0) {
1275  ret = s->oformat->write_trailer(s);
1276  } else {
1277  s->oformat->write_trailer(s);
1278  }
1279  }
1280 
1281  deinit_muxer(s);
1282 
1283  if (s->pb)
1284  avio_flush(s->pb);
1285  if (ret == 0)
1286  ret = s->pb ? s->pb->error : 0;
1287  for (unsigned i = 0; i < s->nb_streams; i++) {
1288  av_freep(&s->streams[i]->priv_data);
1289  av_freep(&ffstream(s->streams[i])->index_entries);
1290  }
1291  if (s->oformat->priv_class)
1292  av_opt_free(s->priv_data);
1293  av_freep(&s->priv_data);
1294  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->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;
1363  pkt->buf = av_buffer_create((void *)framep, bufsize,
1364  uncoded_frame_free, NULL, 0);
1365  if (!pkt->buf) {
1366  av_free(framep);
1367  fail:
1368  av_frame_free(&frame);
1369  return AVERROR(ENOMEM);
1370  }
1371  *framep = frame;
1372 
1373  pkt->data = (void *)framep;
1374  pkt->size = sizeof(frame);
1375  pkt->pts =
1376  pkt->dts = frame->pts;
1377  pkt->duration = frame->pkt_duration;
1378  pkt->stream_index = stream_index;
1380  }
1381 
1382  return interleaved ? av_interleaved_write_frame(s, pkt) :
1383  av_write_frame(s, pkt);
1384 }
1385 
1387  AVFrame *frame)
1388 {
1389  return write_uncoded_frame_internal(s, stream_index, frame, 0);
1390 }
1391 
1393  AVFrame *frame)
1394 {
1395  return write_uncoded_frame_internal(s, stream_index, frame, 1);
1396 }
1397 
1399 {
1400  av_assert0(s->oformat);
1401  if (!s->oformat->write_uncoded_frame)
1402  return AVERROR(ENOSYS);
1403  return s->oformat->write_uncoded_frame(s, stream_index, NULL,
1405 }
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:417
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:869
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:2161
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
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:1358
AVFMT_NODIMENSIONS
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:471
FF_FDEBUG_TS
#define FF_FDEBUG_TS
Definition: avformat.h:1370
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
out
FILE * out
Definition: movenc.c:54
prepare_input_packet
static int prepare_input_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:744
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:183
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2540
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:815
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:467
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:1067
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
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:1165
avpriv_toupper4
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:871
FFStream::interleaver_chunk_size
int64_t interleaver_chunk_size
Definition: internal.h:276
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:1386
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:912
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:160
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:68
AVFMT_FLAG_SHORTEST
#define AVFMT_FLAG_SHORTEST
Stop muxing when the shortest stream stops.
Definition: avformat.h:1238
FFStream::bsfc
AVBSFContext * bsfc
bitstream filter to run on stream
Definition: internal.h:205
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:93
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:1398
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:446
cffstream
static const av_always_inline FFStream * cffstream(const AVStream *st)
Definition: internal.h:431
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:155
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:821
ff_is_intra_only
int ff_is_intra_only(enum AVCodecID id)
Definition: utils.c:287
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:475
FFStream::is_intra_only
int is_intra_only
Definition: internal.h:234
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:426
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:1239
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:1432
interleave_packet
static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush)
Interleave an AVPacket correctly so it can be muxed.
Definition: mux.c:1059
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:820
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
FFStream::priv_pts
FFFrac * priv_pts
Definition: internal.h:236
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:585
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:644
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
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:1656
AV_PKT_FLAG_UNCODED_FRAME
#define AV_PKT_FLAG_UNCODED_FRAME
Definition: mux.c:503
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:2207
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:388
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
CHUNK_START
#define CHUNK_START
Definition: mux.c:793
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:521
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:1392
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:1037
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:467
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:238
AVFormatContext
Format I/O context.
Definition: avformat.h:1097
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:992
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:210
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:868
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:593
NULL
#define NULL
Definition: coverity.c:32
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:597
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:795
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:599
ff_get_muxer_ts_offset
int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
Definition: mux.c:1021
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:1611
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:524
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:1331
FFStream::interleaver_chunk_duration
int64_t interleaver_chunk_duration
Definition: internal.h:277
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:474
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:29
AVStream::nb_frames
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:890
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:515
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:114
FFFormatContext::packet_buffer_end
struct PacketList * packet_buffer_end
Definition: internal.h:90
options
const OptionDef options[]
AVPacket::size
int size
Definition: packet.h:374
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:427
FFStream
Definition: internal.h:188
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:476
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:463
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:596
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:901
AVFMT_NOSTREAMS
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:472
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:1631
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:480
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:521
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1279
PacketList::pkt
AVPacket pkt
Definition: packet_internal.h:28
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:595
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:1251
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:380
i
int i
Definition: input.c:406
FFStream::mux_ts_offset
int64_t mux_ts_offset
Timestamp offset added to timestamps before muxing.
Definition: internal.h:330
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:495
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:605
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:198
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:1431
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:362
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:261
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:480
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:477
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
AVStream::disposition
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:892
tag
uint32_t tag
Definition: movenc.c:1597
AVFMT_FLAG_BITEXACT
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1232
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:845
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:437
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:89
FFFormatContext::offset_timebase
AVRational offset_timebase
Timebase for the timestamp offset.
Definition: internal.h:142
check_packet
static int check_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:728
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:846
compare
static float compare(const AVFrame *haystack, const AVFrame *obj, int offx, int offy)
Definition: vf_find_rect.c:106
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:598
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:679
FFFormatContext::offset
int64_t offset
Offset to remap timestamps to be non-negative.
Definition: internal.h:137
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:1146
AVSTREAM_INIT_IN_INIT_OUTPUT
#define AVSTREAM_INIT_IN_INIT_OUTPUT
stream parameters initialized in avformat_init_output
Definition: avformat.h:2162
AVPacket::stream_index
int stream_index
Definition: packet.h:375
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:271
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:277
desc
const char * desc
Definition: libsvtav1.c:79
FFFormatContext::streams_initialized
int streams_initialized
Whether or not avformat_init_output fully initialized streams.
Definition: internal.h:165
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_guess_format
const AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)
Return the output format in the list of registered output formats which best matches the provided par...
Definition: format.c: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_interleave_packet_per_dts
int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
Interleave an AVPacket per dts so it can be muxed.
Definition: mux.c:899
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.
Definition: internal.h:125
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:384
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:873
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:1236
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:423
format
fg outputs[0] format
Definition: ffmpeg_filter.c:175
timestamp.h
interleaved_write_packet
static int interleaved_write_packet(AVFormatContext *s, AVPacket *pkt, int flush)
Definition: mux.c:1086
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:1225
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:3514
AVFMT_AVOID_NEG_TS_AUTO
#define AVFMT_AVOID_NEG_TS_AUTO
Enabled when required by target format.
Definition: avformat.h:1430
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
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:536
FFFormatContext::avoid_negative_ts_use_pts
int avoid_negative_ts_use_pts
Definition: internal.h:150