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/internal.h"
26 #include "libavutil/opt.h"
27 #include "libavutil/dict.h"
28 #include "libavutil/pixdesc.h"
29 #include "libavutil/timestamp.h"
30 #include "libavutil/avassert.h"
31 #include "libavutil/avstring.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mathematics.h"
34 
35 /**
36  * @file
37  * muxing functions for use within libavformat
38  */
39 
40 /* fraction handling */
41 
42 /**
43  * f = val + (num / den) + 0.5.
44  *
45  * 'num' is normalized so that it is such as 0 <= num < den.
46  *
47  * @param f fractional number
48  * @param val integer value
49  * @param num must be >= 0
50  * @param den must be >= 1
51  */
52 static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
53 {
54  num += (den >> 1);
55  if (num >= den) {
56  val += num / den;
57  num = num % den;
58  }
59  f->val = val;
60  f->num = num;
61  f->den = den;
62 }
63 
64 /**
65  * Fractional addition to f: f = f + (incr / f->den).
66  *
67  * @param f fractional number
68  * @param incr increment, can be positive or negative
69  */
70 static void frac_add(FFFrac *f, int64_t incr)
71 {
72  int64_t num, den;
73 
74  num = f->num + incr;
75  den = f->den;
76  if (num < 0) {
77  f->val += num / den;
78  num = num % den;
79  if (num < 0) {
80  num += den;
81  f->val--;
82  }
83  } else if (num >= den) {
84  f->val += num / den;
85  num = num % den;
86  }
87  f->num = num;
88 }
89 
91 {
92  AVRational q;
93  int j;
94 
95  q = st->time_base;
96 
97  for (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  int n;
196  enum AVCodecID id = AV_CODEC_ID_NONE;
197  int64_t tag = -1;
198 
199  /**
200  * Check that tag + id is in the table
201  * If neither is in the table -> OK
202  * If tag is in the table with another id -> FAIL
203  * If id is in the table with another tag -> FAIL unless strict < normal
204  */
205  for (n = 0; s->oformat->codec_tag[n]; n++) {
206  avctag = s->oformat->codec_tag[n];
207  while (avctag->id != AV_CODEC_ID_NONE) {
208  if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codecpar->codec_tag)) {
209  id = avctag->id;
210  if (id == st->codecpar->codec_id)
211  return 1;
212  }
213  if (avctag->id == st->codecpar->codec_id)
214  tag = avctag->tag;
215  avctag++;
216  }
217  }
218  if (id != AV_CODEC_ID_NONE)
219  return 0;
220  if (tag >= 0 && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
221  return 0;
222  return 1;
223 }
224 
225 
227 {
228  int ret = 0, i;
229  AVStream *st;
230  AVDictionary *tmp = NULL;
231  AVCodecParameters *par = NULL;
232  const AVOutputFormat *of = s->oformat;
233  const AVCodecDescriptor *desc;
235 
236  if (options)
237  av_dict_copy(&tmp, *options, 0);
238 
239  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
240  goto fail;
241  if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
242  (ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
243  goto fail;
244 
245  if (!s->url && !(s->url = av_strdup(""))) {
246  ret = AVERROR(ENOMEM);
247  goto fail;
248  }
249 
250  // some sanity checks
251  if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) {
252  av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");
253  ret = AVERROR(EINVAL);
254  goto fail;
255  }
256 
257  for (i = 0; i < s->nb_streams; i++) {
258  st = s->streams[i];
259  par = st->codecpar;
260 
261  if (!st->time_base.num) {
262  /* fall back on the default timebase values */
263  if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)
264  avpriv_set_pts_info(st, 64, 1, par->sample_rate);
265  else
266  avpriv_set_pts_info(st, 33, 1, 90000);
267  }
268 
269  switch (par->codec_type) {
270  case AVMEDIA_TYPE_AUDIO:
271  if (par->sample_rate <= 0) {
272  av_log(s, AV_LOG_ERROR, "sample rate not set\n");
273  ret = AVERROR(EINVAL);
274  goto fail;
275  }
276  if (!par->block_align)
277  par->block_align = par->channels *
278  av_get_bits_per_sample(par->codec_id) >> 3;
279  break;
280  case AVMEDIA_TYPE_VIDEO:
281  if ((par->width <= 0 || par->height <= 0) &&
282  !(of->flags & AVFMT_NODIMENSIONS)) {
283  av_log(s, AV_LOG_ERROR, "dimensions not set\n");
284  ret = AVERROR(EINVAL);
285  goto fail;
286  }
289  ) {
290  if (st->sample_aspect_ratio.num != 0 &&
291  st->sample_aspect_ratio.den != 0 &&
292  par->sample_aspect_ratio.num != 0 &&
293  par->sample_aspect_ratio.den != 0) {
294  av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
295  "(%d/%d) and encoder layer (%d/%d)\n",
298  par->sample_aspect_ratio.den);
299  ret = AVERROR(EINVAL);
300  goto fail;
301  }
302  }
303  break;
304  }
305 
307  if (desc && desc->props & AV_CODEC_PROP_REORDER)
308  st->internal->reorder = 1;
309 
311 
312  if (of->codec_tag) {
313  if ( par->codec_tag
314  && par->codec_id == AV_CODEC_ID_RAWVIDEO
315  && ( av_codec_get_tag(of->codec_tag, par->codec_id) == 0
316  || av_codec_get_tag(of->codec_tag, par->codec_id) == MKTAG('r', 'a', 'w', ' '))
317  && !validate_codec_tag(s, st)) {
318  // the current rawvideo encoding system ends up setting
319  // the wrong codec_tag for avi/mov, we override it here
320  par->codec_tag = 0;
321  }
322  if (par->codec_tag) {
323  if (!validate_codec_tag(s, st)) {
324  const uint32_t otag = av_codec_get_tag(s->oformat->codec_tag, par->codec_id);
326  "Tag %s incompatible with output codec id '%d' (%s)\n",
327  av_fourcc2str(par->codec_tag), par->codec_id, av_fourcc2str(otag));
329  goto fail;
330  }
331  } else
332  par->codec_tag = av_codec_get_tag(of->codec_tag, par->codec_id);
333  }
334 
336  s->internal->nb_interleaved_streams++;
337  }
338 
339  if (!s->priv_data && of->priv_data_size > 0) {
340  s->priv_data = av_mallocz(of->priv_data_size);
341  if (!s->priv_data) {
342  ret = AVERROR(ENOMEM);
343  goto fail;
344  }
345  if (of->priv_class) {
346  *(const AVClass **)s->priv_data = of->priv_class;
347  av_opt_set_defaults(s->priv_data);
348  if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
349  goto fail;
350  }
351  }
352 
353  /* set muxer identification string */
354  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
355  av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
356  } else {
357  av_dict_set(&s->metadata, "encoder", NULL, 0);
358  }
359 
360  for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {
361  av_dict_set(&s->metadata, e->key, NULL, 0);
362  }
363 
364  if (options) {
366  *options = tmp;
367  }
368 
369  if (s->oformat->init) {
370  if ((ret = s->oformat->init(s)) < 0) {
371  if (s->oformat->deinit)
372  s->oformat->deinit(s);
373  return ret;
374  }
375  return ret == 0;
376  }
377 
378  return 0;
379 
380 fail:
381  av_dict_free(&tmp);
382  return ret;
383 }
384 
386 {
387  int i;
388  AVStream *st;
389 
390  /* init PTS generation */
391  for (i = 0; i < s->nb_streams; i++) {
392  int64_t den = AV_NOPTS_VALUE;
393  st = s->streams[i];
394 
395  switch (st->codecpar->codec_type) {
396  case AVMEDIA_TYPE_AUDIO:
397  den = (int64_t)st->time_base.num * st->codecpar->sample_rate;
398  break;
399  case AVMEDIA_TYPE_VIDEO:
400  den = (int64_t)st->time_base.num * st->time_base.den;
401  break;
402  default:
403  break;
404  }
405 
406  if (!st->internal->priv_pts)
407  st->internal->priv_pts = av_mallocz(sizeof(*st->internal->priv_pts));
408  if (!st->internal->priv_pts)
409  return AVERROR(ENOMEM);
410 
411  if (den != AV_NOPTS_VALUE) {
412  if (den <= 0)
413  return AVERROR_INVALIDDATA;
414 
415  frac_init(st->internal->priv_pts, 0, 0, den);
416  }
417  }
418 
419  if (s->avoid_negative_ts < 0) {
420  av_assert2(s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO);
421  if (s->oformat->flags & (AVFMT_TS_NEGATIVE | AVFMT_NOTIMESTAMPS)) {
422  s->avoid_negative_ts = 0;
423  } else
424  s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE;
425  }
426 
427  return 0;
428 }
429 
431 {
432  if (s->pb && s->pb->error >= 0) {
433  if (s->flush_packets == 1 || s->flags & AVFMT_FLAG_FLUSH_PACKETS)
434  avio_flush(s->pb);
435  else if (s->flush_packets && !(s->oformat->flags & AVFMT_NOFILE))
437  }
438 }
439 
441 {
442  if (s->oformat && s->oformat->deinit && s->internal->initialized)
443  s->oformat->deinit(s);
444  s->internal->initialized =
445  s->internal->streams_initialized = 0;
446 }
447 
449 {
450  int ret = 0;
451 
452  if ((ret = init_muxer(s, options)) < 0)
453  return ret;
454 
455  s->internal->initialized = 1;
456  s->internal->streams_initialized = ret;
457 
458  if (s->oformat->init && ret) {
459  if ((ret = init_pts(s)) < 0)
460  return ret;
461 
463  }
464 
466 }
467 
469 {
470  int ret = 0;
471  int already_initialized = s->internal->initialized;
472  int streams_already_initialized = s->internal->streams_initialized;
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 (!s->internal->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  int delay = FFMAX(st->codecpar->video_delay, st->internal->avctx->max_b_frames > 0);
512  int i;
513  int frame_size;
514 
515  if (!s->internal->missing_ts_warning &&
516  !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
518  (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
520  "Timestamps are unset in a packet for stream %d. "
521  "This is deprecated and will stop working in the future. "
522  "Fix your code to set the timestamps properly\n", st->index);
523  s->internal->missing_ts_warning = 1;
524  }
525 
526  if (s->debug & FF_FDEBUG_TS)
527  av_log(s, AV_LOG_DEBUG, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
529 
530  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
531  pkt->pts = pkt->dts;
532 
533  //XXX/FIXME this is a temporary hack until all encoders output pts
534  if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
535  static int warned;
536  if (!warned) {
537  av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
538  warned = 1;
539  }
540  pkt->dts =
541 // pkt->pts= st->cur_dts;
542  pkt->pts = st->internal->priv_pts->val;
543  }
544 
545  //calculate dts from pts
546  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
547  st->internal->pts_buffer[0] = pkt->pts;
548  for (i = 1; i < delay + 1 && st->internal->pts_buffer[i] == AV_NOPTS_VALUE; i++)
549  st->internal->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
550  for (i = 0; i<delay && st->internal->pts_buffer[i] > st->internal->pts_buffer[i + 1]; i++)
551  FFSWAP(int64_t, st->internal->pts_buffer[i], st->internal->pts_buffer[i + 1]);
552 
553  pkt->dts = st->internal->pts_buffer[0];
554  }
555 
556  if (st->cur_dts && st->cur_dts != AV_NOPTS_VALUE &&
557  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
560  st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
562  "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
563  st->index, av_ts2str(st->cur_dts), av_ts2str(pkt->dts));
564  return AVERROR(EINVAL);
565  }
566  if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
568  "pts (%s) < dts (%s) in stream %d\n",
570  st->index);
571  return AVERROR(EINVAL);
572  }
573 
574  if (s->debug & FF_FDEBUG_TS)
575  av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n",
577 
578  st->cur_dts = pkt->dts;
579  st->internal->priv_pts->val = pkt->dts;
580 
581  /* update pts */
582  switch (st->codecpar->codec_type) {
583  case AVMEDIA_TYPE_AUDIO:
585  (*(AVFrame **)pkt->data)->nb_samples :
587 
588  /* HACK/FIXME, we skip the initial 0 size packets as they are most
589  * likely equal to the encoder delay, but it would be better if we
590  * had the real timestamps from the encoder */
591  if (frame_size >= 0 && (pkt->size || st->internal->priv_pts->num != st->internal->priv_pts->den >> 1 || st->internal->priv_pts->val)) {
592  frac_add(st->internal->priv_pts, (int64_t)st->time_base.den * frame_size);
593  }
594  break;
595  case AVMEDIA_TYPE_VIDEO:
596  frac_add(st->internal->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
597  break;
598  }
599  return 0;
600 }
602 #endif
603 
605 {
606  if (pkt->duration < 0 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
607  av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
609  pkt->duration = 0;
610  }
611 
612  if (pkt->duration)
613  return;
614 
615  switch (st->codecpar->codec_type) {
616  case AVMEDIA_TYPE_VIDEO:
617  if (st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0) {
619  st->time_base);
620  } else if (st->time_base.num * 1000LL > st->time_base.den)
621  pkt->duration = 1;
622  break;
623  case AVMEDIA_TYPE_AUDIO: {
625  if (frame_size && st->codecpar->sample_rate) {
627  (AVRational){1, st->codecpar->sample_rate},
628  st->time_base);
629  }
630  break;
631  }
632  }
633 }
634 
635 /**
636  * Shift timestamps and call muxer; the original pts/dts are not kept.
637  *
638  * FIXME: this function should NEVER get undefined pts/dts beside when the
639  * AVFMT_NOTIMESTAMPS is set.
640  * Those additional safety checks should be dropped once the correct checks
641  * are set in the callers.
642  */
644 {
645  int ret;
646 
647  // If the timestamp offsetting below is adjusted, adjust
648  // ff_interleaved_peek similarly.
649  if (s->output_ts_offset) {
650  AVStream *st = s->streams[pkt->stream_index];
651  int64_t offset = av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
652 
653  if (pkt->dts != AV_NOPTS_VALUE)
654  pkt->dts += offset;
655  if (pkt->pts != AV_NOPTS_VALUE)
656  pkt->pts += offset;
657  }
658 
659  if (s->avoid_negative_ts > 0) {
660  AVStream *st = s->streams[pkt->stream_index];
661  int64_t offset = st->internal->mux_ts_offset;
662  int64_t ts = s->internal->avoid_negative_ts_use_pts ? pkt->pts : pkt->dts;
663 
664  if (s->internal->offset == AV_NOPTS_VALUE && ts != AV_NOPTS_VALUE &&
665  (ts < 0 || s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO)) {
666  s->internal->offset = -ts;
667  s->internal->offset_timebase = st->time_base;
668  }
669 
670  if (s->internal->offset != AV_NOPTS_VALUE && !offset) {
671  offset = st->internal->mux_ts_offset =
672  av_rescale_q_rnd(s->internal->offset,
673  s->internal->offset_timebase,
674  st->time_base,
675  AV_ROUND_UP);
676  }
677 
678  if (pkt->dts != AV_NOPTS_VALUE)
679  pkt->dts += offset;
680  if (pkt->pts != AV_NOPTS_VALUE)
681  pkt->pts += offset;
682 
683  if (s->internal->avoid_negative_ts_use_pts) {
684  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < 0) {
685  av_log(s, AV_LOG_WARNING, "failed to avoid negative "
686  "pts %s in stream %d.\n"
687  "Try -avoid_negative_ts 1 as a possible workaround.\n",
688  av_ts2str(pkt->pts),
690  );
691  }
692  } else {
693  av_assert2(pkt->dts == AV_NOPTS_VALUE || pkt->dts >= 0 || s->max_interleave_delta > 0);
694  if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < 0) {
696  "Packets poorly interleaved, failed to avoid negative "
697  "timestamp %s in stream %d.\n"
698  "Try -max_interleave_delta 0 as a possible workaround.\n",
699  av_ts2str(pkt->dts),
701  );
702  }
703  }
704  }
705 
707  AVFrame **frame = (AVFrame **)pkt->data;
708  av_assert0(pkt->size == sizeof(*frame));
709  ret = s->oformat->write_uncoded_frame(s, pkt->stream_index, frame, 0);
710  } else {
711  ret = s->oformat->write_packet(s, pkt);
712  }
713 
714  if (s->pb && ret >= 0) {
716  if (s->pb->error < 0)
717  ret = s->pb->error;
718  }
719 
720  if (ret >= 0)
721  s->streams[pkt->stream_index]->nb_frames++;
722 
723  return ret;
724 }
725 
727 {
728  if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
729  av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
730  pkt->stream_index);
731  return AVERROR(EINVAL);
732  }
733 
734  if (s->streams[pkt->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
735  av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
736  return AVERROR(EINVAL);
737  }
738 
739  return 0;
740 }
741 
743 {
744 #if !FF_API_COMPUTE_PKT_FIELDS2
745  /* sanitize the timestamps */
746  if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
747 
748  /* when there is no reordering (so dts is equal to pts), but
749  * only one of them is set, set the other as well */
750  if (!st->internal->reorder) {
751  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)
752  pkt->pts = pkt->dts;
753  if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
754  pkt->dts = pkt->pts;
755  }
756 
757  /* check that the timestamps are set */
758  if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {
760  "Timestamps are unset in a packet for stream %d\n", st->index);
761  return AVERROR(EINVAL);
762  }
763 
764  /* check that the dts are increasing (or at least non-decreasing,
765  * if the format allows it */
766  if (st->cur_dts != AV_NOPTS_VALUE &&
767  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && st->cur_dts >= pkt->dts) ||
768  st->cur_dts > pkt->dts)) {
770  "Application provided invalid, non monotonically increasing "
771  "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
772  st->index, st->cur_dts, pkt->dts);
773  return AVERROR(EINVAL);
774  }
775 
776  if (pkt->pts < pkt->dts) {
777  av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
778  pkt->pts, pkt->dts, st->index);
779  return AVERROR(EINVAL);
780  }
781  }
782 #endif
783  /* update flags */
784  if (st->internal->is_intra_only)
786 
787  return 0;
788 }
789 
790 #define CHUNK_START 0x1000
791 
793  int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
794 {
795  int ret;
796  PacketList **next_point, *this_pktl;
797  AVStream *st = s->streams[pkt->stream_index];
798  int chunked = s->max_chunk_size || s->max_chunk_duration;
799 
800  this_pktl = av_malloc(sizeof(PacketList));
801  if (!this_pktl) {
803  return AVERROR(ENOMEM);
804  }
805  if ((ret = av_packet_make_refcounted(pkt)) < 0) {
806  av_free(this_pktl);
808  return ret;
809  }
810 
811  av_packet_move_ref(&this_pktl->pkt, pkt);
812  pkt = &this_pktl->pkt;
813 
814  if (st->internal->last_in_packet_buffer) {
815  next_point = &(st->internal->last_in_packet_buffer->next);
816  } else {
817  next_point = &s->internal->packet_buffer;
818  }
819 
820  if (chunked) {
821  uint64_t max= av_rescale_q_rnd(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base, AV_ROUND_UP);
824  if ( (s->max_chunk_size && st->internal->interleaver_chunk_size > s->max_chunk_size)
825  || (max && st->internal->interleaver_chunk_duration > max)) {
827  pkt->flags |= CHUNK_START;
828  if (max && st->internal->interleaver_chunk_duration > max) {
829  int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
830  int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
831 
832  st->internal->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
833  } else
835  }
836  }
837  if (*next_point) {
838  if (chunked && !(pkt->flags & CHUNK_START))
839  goto next_non_null;
840 
841  if (compare(s, &s->internal->packet_buffer_end->pkt, pkt)) {
842  while ( *next_point
843  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
844  || !compare(s, &(*next_point)->pkt, pkt)))
845  next_point = &(*next_point)->next;
846  if (*next_point)
847  goto next_non_null;
848  } else {
849  next_point = &(s->internal->packet_buffer_end->next);
850  }
851  }
852  av_assert1(!*next_point);
853 
854  s->internal->packet_buffer_end = this_pktl;
855 next_non_null:
856 
857  this_pktl->next = *next_point;
858 
859  st->internal->last_in_packet_buffer = *next_point = this_pktl;
860 
861  return 0;
862 }
863 
865  const AVPacket *pkt)
866 {
867  AVStream *st = s->streams[pkt->stream_index];
868  AVStream *st2 = s->streams[next->stream_index];
869  int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
870  st->time_base);
871  if (s->audio_preload) {
872  int preload = st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
873  int preload2 = st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
874  if (preload != preload2) {
875  int64_t ts, ts2;
876  preload *= s->audio_preload;
877  preload2 *= s->audio_preload;
878  ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - preload;
879  ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - preload2;
880  if (ts == ts2) {
881  ts = ((uint64_t)pkt ->dts*st ->time_base.num*AV_TIME_BASE - (uint64_t)preload *st ->time_base.den)*st2->time_base.den
882  - ((uint64_t)next->dts*st2->time_base.num*AV_TIME_BASE - (uint64_t)preload2*st2->time_base.den)*st ->time_base.den;
883  ts2 = 0;
884  }
885  comp = (ts2 > ts) - (ts2 < ts);
886  }
887  }
888 
889  if (comp == 0)
890  return pkt->stream_index < next->stream_index;
891  return comp > 0;
892 }
893 
895  AVPacket *pkt, int flush)
896 {
897  PacketList *pktl;
898  int stream_count = 0;
899  int noninterleaved_count = 0;
900  int i, ret;
901  int eof = flush;
902 
903  if (pkt) {
905  return ret;
906  }
907 
908  for (i = 0; i < s->nb_streams; i++) {
909  if (s->streams[i]->internal->last_in_packet_buffer) {
910  ++stream_count;
911  } else if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
912  s->streams[i]->codecpar->codec_id != AV_CODEC_ID_VP8 &&
913  s->streams[i]->codecpar->codec_id != AV_CODEC_ID_VP9) {
914  ++noninterleaved_count;
915  }
916  }
917 
918  if (s->internal->nb_interleaved_streams == stream_count)
919  flush = 1;
920 
921  if (s->max_interleave_delta > 0 &&
922  s->internal->packet_buffer &&
923  !flush &&
924  s->internal->nb_interleaved_streams == stream_count+noninterleaved_count
925  ) {
926  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
927  int64_t delta_dts = INT64_MIN;
928  int64_t top_dts = av_rescale_q(top_pkt->dts,
929  s->streams[top_pkt->stream_index]->time_base,
931 
932  for (i = 0; i < s->nb_streams; i++) {
933  int64_t last_dts;
934  const PacketList *last = s->streams[i]->internal->last_in_packet_buffer;
935 
936  if (!last)
937  continue;
938 
939  last_dts = av_rescale_q(last->pkt.dts,
940  s->streams[i]->time_base,
942  delta_dts = FFMAX(delta_dts, last_dts - top_dts);
943  }
944 
945  if (delta_dts > s->max_interleave_delta) {
947  "Delay between the first packet and last packet in the "
948  "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
949  delta_dts, s->max_interleave_delta);
950  flush = 1;
951  }
952  }
953 
954  if (s->internal->packet_buffer &&
955  eof &&
956  (s->flags & AVFMT_FLAG_SHORTEST) &&
957  s->internal->shortest_end == AV_NOPTS_VALUE) {
958  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
959 
960  s->internal->shortest_end = av_rescale_q(top_pkt->dts,
961  s->streams[top_pkt->stream_index]->time_base,
963  }
964 
965  if (s->internal->shortest_end != AV_NOPTS_VALUE) {
966  while (s->internal->packet_buffer) {
967  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
968  AVStream *st;
969  int64_t top_dts = av_rescale_q(top_pkt->dts,
970  s->streams[top_pkt->stream_index]->time_base,
972 
973  if (s->internal->shortest_end + 1 >= top_dts)
974  break;
975 
976  pktl = s->internal->packet_buffer;
977  st = s->streams[pktl->pkt.stream_index];
978 
979  s->internal->packet_buffer = pktl->next;
980  if (!s->internal->packet_buffer)
981  s->internal->packet_buffer_end = NULL;
982 
983  if (st->internal->last_in_packet_buffer == pktl)
985 
986  av_packet_unref(&pktl->pkt);
987  av_freep(&pktl);
988  flush = 0;
989  }
990  }
991 
992  if (stream_count && flush) {
993  AVStream *st;
994  pktl = s->internal->packet_buffer;
995  *out = pktl->pkt;
996  st = s->streams[out->stream_index];
997 
998  s->internal->packet_buffer = pktl->next;
999  if (!s->internal->packet_buffer)
1000  s->internal->packet_buffer_end = NULL;
1001 
1002  if (st->internal->last_in_packet_buffer == pktl)
1004  av_freep(&pktl);
1005 
1006  return 1;
1007  } else {
1008  return 0;
1009  }
1010 }
1011 
1012 int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
1013 {
1014  AVStream *st;
1015 
1016  if (stream_index < 0 || stream_index >= s->nb_streams)
1017  return AVERROR(EINVAL);
1018 
1019  st = s->streams[stream_index];
1020  *offset = st->internal->mux_ts_offset;
1021 
1022  if (s->output_ts_offset)
1023  *offset += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
1024 
1025  return 0;
1026 }
1027 
1029 {
1030  PacketList *pktl = s->internal->packet_buffer;
1031  while (pktl) {
1032  if (pktl->pkt.stream_index == stream) {
1033  return &pktl->pkt;
1034  }
1035  pktl = pktl->next;
1036  }
1037  return NULL;
1038 }
1039 
1040 /**
1041  * Interleave an AVPacket correctly so it can be muxed.
1042  * @param out the interleaved packet will be output here
1043  * @param in the input packet; will always be blank on return if not NULL
1044  * @param flush 1 if no further packets are available as input and all
1045  * remaining packets should be output
1046  * @return 1 if a packet was output, 0 if no packet could be output,
1047  * < 0 if an error occurred
1048  */
1050 {
1051  if (s->oformat->interleave_packet) {
1052  return s->oformat->interleave_packet(s, out, in, flush);
1053  } else
1054  return ff_interleave_packet_per_dts(s, out, in, flush);
1055 }
1056 
1058 {
1059  int ret;
1060 
1061  if (!(s->flags & AVFMT_FLAG_AUTO_BSF))
1062  return 1;
1063 
1064  if (s->oformat->check_bitstream) {
1065  if (!st->internal->bitstream_checked) {
1066  if ((ret = s->oformat->check_bitstream(s, pkt)) < 0)
1067  return ret;
1068  else if (ret == 1)
1069  st->internal->bitstream_checked = 1;
1070  }
1071  }
1072 
1073  return 1;
1074 }
1075 
1077 {
1078  for (;; ) {
1079  AVPacket opkt;
1080  int ret = interleave_packet(s, &opkt, pkt, flush);
1081  if (ret <= 0)
1082  return ret;
1083 
1084  pkt = NULL;
1085 
1086  ret = write_packet(s, &opkt);
1087 
1088  av_packet_unref(&opkt);
1089 
1090  if (ret < 0)
1091  return ret;
1092  }
1093 }
1094 
1095 static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1096 {
1097  int ret;
1098 
1099  if (s->debug & FF_FDEBUG_TS)
1100  av_log(s, AV_LOG_DEBUG, "%s size:%d dts:%s pts:%s\n", __FUNCTION__,
1102 
1103  guess_pkt_duration(s, st, pkt);
1104 
1105 #if FF_API_COMPUTE_PKT_FIELDS2
1106  if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1107  return ret;
1108 #endif
1109 
1110  if (interleaved) {
1111  if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1112  return AVERROR(EINVAL);
1113  return interleaved_write_packet(s, pkt, 0);
1114  } else {
1115  return write_packet(s, pkt);
1116  }
1117 }
1118 
1119 static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1120 {
1121  AVBSFContext *bsfc = st->internal->bsfc;
1122  int ret;
1123 
1124  if ((ret = av_bsf_send_packet(bsfc, pkt)) < 0) {
1126  "Failed to send packet to filter %s for stream %d\n",
1127  bsfc->filter->name, st->index);
1128  return ret;
1129  }
1130 
1131  do {
1132  ret = av_bsf_receive_packet(bsfc, pkt);
1133  if (ret < 0) {
1134  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
1135  return 0;
1136  av_log(s, AV_LOG_ERROR, "Error applying bitstream filters to an output "
1137  "packet for stream #%d: %s\n", st->index, av_err2str(ret));
1138  if (!(s->error_recognition & AV_EF_EXPLODE) && ret != AVERROR(ENOMEM))
1139  continue;
1140  return ret;
1141  }
1143  ret = write_packet_common(s, st, pkt, interleaved);
1144  if (ret >= 0 && !interleaved) // a successful write_packet_common already unrefed pkt for interleaved
1146  } while (ret >= 0);
1147 
1148  return ret;
1149 }
1150 
1151 static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
1152 {
1153  AVStream *st;
1154  int ret = check_packet(s, pkt);
1155  if (ret < 0)
1156  return ret;
1157  st = s->streams[pkt->stream_index];
1158 
1159  ret = prepare_input_packet(s, st, pkt);
1160  if (ret < 0)
1161  return ret;
1162 
1163  ret = check_bitstream(s, st, pkt);
1164  if (ret < 0)
1165  return ret;
1166 
1167  if (st->internal->bsfc) {
1168  return write_packets_from_bsfs(s, st, pkt, interleaved);
1169  } else {
1170  return write_packet_common(s, st, pkt, interleaved);
1171  }
1172 }
1173 
1175 {
1176  AVPacket *pkt = s->internal->pkt;
1177  int ret;
1178 
1179  if (!in) {
1180  if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
1181  ret = s->oformat->write_packet(s, NULL);
1182  flush_if_needed(s);
1183  if (ret >= 0 && s->pb && s->pb->error < 0)
1184  ret = s->pb->error;
1185  return ret;
1186  }
1187  return 1;
1188  }
1189 
1190  if (in->flags & AV_PKT_FLAG_UNCODED_FRAME) {
1191  pkt = in;
1192  } else {
1193  /* We don't own in, so we have to make sure not to modify it.
1194  * The following avoids copying in's data unnecessarily.
1195  * Copying side data is unavoidable as a bitstream filter
1196  * may change it, e.g. free it on errors. */
1198  pkt->buf = NULL;
1199  pkt->data = in->data;
1200  pkt->size = in->size;
1201  ret = av_packet_copy_props(pkt, in);
1202  if (ret < 0)
1203  return ret;
1204  if (in->buf) {
1205  pkt->buf = av_buffer_ref(in->buf);
1206  if (!pkt->buf) {
1207  ret = AVERROR(ENOMEM);
1208  goto fail;
1209  }
1210  }
1211  }
1212 
1213  ret = write_packets_common(s, pkt, 0/*non-interleaved*/);
1214 
1215 fail:
1216  // Uncoded frames using the noninterleaved codepath are also freed here
1218  return ret;
1219 }
1220 
1222 {
1223  int ret;
1224 
1225  if (pkt) {
1226  ret = write_packets_common(s, pkt, 1/*interleaved*/);
1227  if (ret < 0)
1229  return ret;
1230  } else {
1231  av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");
1232  return interleaved_write_packet(s, NULL, 1/*flush*/);
1233  }
1234 }
1235 
1237 {
1238  int i, ret1, ret = 0;
1239  AVPacket *pkt = s->internal->pkt;
1240 
1242  for (i = 0; i < s->nb_streams; i++) {
1243  if (s->streams[i]->internal->bsfc) {
1244  ret1 = write_packets_from_bsfs(s, s->streams[i], pkt, 1/*interleaved*/);
1245  if (ret1 < 0)
1247  if (ret >= 0)
1248  ret = ret1;
1249  }
1250  }
1251  ret1 = interleaved_write_packet(s, NULL, 1);
1252  if (ret >= 0)
1253  ret = ret1;
1254 
1255  if (s->oformat->write_trailer) {
1256  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1258  if (ret >= 0) {
1259  ret = s->oformat->write_trailer(s);
1260  } else {
1261  s->oformat->write_trailer(s);
1262  }
1263  }
1264 
1265  deinit_muxer(s);
1266 
1267  if (s->pb)
1268  avio_flush(s->pb);
1269  if (ret == 0)
1270  ret = s->pb ? s->pb->error : 0;
1271  for (i = 0; i < s->nb_streams; i++) {
1272  av_freep(&s->streams[i]->priv_data);
1273  av_freep(&s->streams[i]->internal->index_entries);
1274  }
1275  if (s->oformat->priv_class)
1276  av_opt_free(s->priv_data);
1277  av_freep(&s->priv_data);
1278  return ret;
1279 }
1280 
1282  int64_t *dts, int64_t *wall)
1283 {
1284  if (!s->oformat || !s->oformat->get_output_timestamp)
1285  return AVERROR(ENOSYS);
1286  s->oformat->get_output_timestamp(s, stream, dts, wall);
1287  return 0;
1288 }
1289 
1290 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
1292 {
1293  AVPacket local_pkt;
1294  int ret;
1295 
1296  local_pkt = *pkt;
1297  local_pkt.stream_index = dst_stream;
1298 
1299  av_packet_rescale_ts(&local_pkt,
1300  src->streams[pkt->stream_index]->time_base,
1301  dst->streams[dst_stream]->time_base);
1302 
1303  if (interleave) ret = av_interleaved_write_frame(dst, &local_pkt);
1304  else ret = av_write_frame(dst, &local_pkt);
1305  pkt->buf = local_pkt.buf;
1306  pkt->side_data = local_pkt.side_data;
1307  pkt->side_data_elems = local_pkt.side_data_elems;
1308  return ret;
1309 }
1310 
1311 static void uncoded_frame_free(void *unused, uint8_t *data)
1312 {
1313  av_frame_free((AVFrame **)data);
1314  av_free(data);
1315 }
1316 
1317 static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
1318  AVFrame *frame, int interleaved)
1319 {
1320  AVPacket *pkt = s->internal->pkt;
1321 
1322  av_assert0(s->oformat);
1323  if (!s->oformat->write_uncoded_frame) {
1324  av_frame_free(&frame);
1325  return AVERROR(ENOSYS);
1326  }
1327 
1328  if (!frame) {
1329  pkt = NULL;
1330  } else {
1331  size_t bufsize = sizeof(frame) + AV_INPUT_BUFFER_PADDING_SIZE;
1332  AVFrame **framep = av_mallocz(bufsize);
1333 
1334  if (!framep)
1335  goto fail;
1337  pkt->buf = av_buffer_create((void *)framep, bufsize,
1338  uncoded_frame_free, NULL, 0);
1339  if (!pkt->buf) {
1340  av_free(framep);
1341  fail:
1342  av_frame_free(&frame);
1343  return AVERROR(ENOMEM);
1344  }
1345  *framep = frame;
1346 
1347  pkt->data = (void *)framep;
1348  pkt->size = sizeof(frame);
1349  pkt->pts =
1350  pkt->dts = frame->pts;
1351  pkt->duration = frame->pkt_duration;
1352  pkt->stream_index = stream_index;
1354  }
1355 
1356  return interleaved ? av_interleaved_write_frame(s, pkt) :
1357  av_write_frame(s, pkt);
1358 }
1359 
1361  AVFrame *frame)
1362 {
1363  return write_uncoded_frame_internal(s, stream_index, frame, 0);
1364 }
1365 
1367  AVFrame *frame)
1368 {
1369  return write_uncoded_frame_internal(s, stream_index, frame, 1);
1370 }
1371 
1373 {
1374  av_assert0(s->oformat);
1375  if (!s->oformat->write_uncoded_frame)
1376  return AVERROR(ENOSYS);
1377  return s->oformat->write_uncoded_frame(s, stream_index, NULL,
1379 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:30
AVStreamInternal::priv_pts
FFFrac * priv_pts
Definition: internal.h:215
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:403
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
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:187
interleave_compare_dts
static int interleave_compare_dts(AVFormatContext *s, const AVPacket *next, const AVPacket *pkt)
Definition: mux.c:864
LIBAVFORMAT_IDENT
#define LIBAVFORMAT_IDENT
Definition: version.h:46
AVStreamInternal::reorder
int reorder
Set to 1 if the codec allows reordering, so pts can be different from dts.
Definition: internal.h:175
AVSTREAM_INIT_IN_WRITE_HEADER
#define AVSTREAM_INIT_IN_WRITE_HEADER
stream parameters initialized in avformat_write_header
Definition: avformat.h:2166
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:147
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1358
AVFMT_NODIMENSIONS
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:466
FF_FDEBUG_TS
#define FF_FDEBUG_TS
Definition: avformat.h:1373
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:742
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:108
AVStreamInternal::avctx
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:192
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
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2541
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:478
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:800
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:462
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:43
AVBitStreamFilter::name
const char * name
Definition: bsf.h:99
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:62
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:27
pixdesc.h
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1174
avpriv_toupper4
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:859
AVStreamInternal::interleaver_chunk_size
int64_t interleaver_chunk_size
Definition: internal.h:255
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:1360
AVPacket::data
uint8_t * data
Definition: packet.h:365
AVStream::internal
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1008
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:899
PacketList
Definition: packet_internal.h:26
data
const char data[16]
Definition: mxf.c:142
AVStream::cur_dts
int64_t cur_dts
Definition: avformat.h:1002
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:70
AVFMT_FLAG_SHORTEST
#define AVFMT_FLAG_SHORTEST
Stop muxing when the shortest stream stops.
Definition: avformat.h:1247
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:383
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
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:1372
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:448
AVStreamInternal::bsfc
AVBSFContext * bsfc
bitstream filter to run on stream
Definition: internal.h:182
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:396
AVBSFContext
The bitstream filter state.
Definition: bsf.h:49
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
ff_is_intra_only
int ff_is_intra_only(enum AVCodecID id)
Definition: utils.c:955
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:469
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
fail
#define fail()
Definition: checkasm.h:134
AVFMT_FLAG_AUTO_BSF
#define AVFMT_FLAG_AUTO_BSF
Add bitstream filters as requested by the muxer.
Definition: avformat.h:1248
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:1435
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:1049
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:805
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:83
AVRational::num
int num
Numerator.
Definition: rational.h:59
avassert.h
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:207
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:181
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:643
AVCodecTag
Definition: internal.h:42
write_packet_common
static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1095
AVStreamInternal::mux_ts_offset
int64_t mux_ts_offset
Timestamp offset added to timestamps before muxing.
Definition: internal.h:309
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:82
frame_size
int frame_size
Definition: mxfenc.c:2206
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:217
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
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
CHUNK_START
#define CHUNK_START
Definition: mux.c:790
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:202
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:81
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:516
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:1366
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:1028
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:468
init_muxer
static int init_muxer(AVFormatContext *s, AVDictionary **options)
Definition: mux.c:226
if
if(ret)
Definition: filter_design.txt:179
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:235
AVFormatContext
Format I/O context.
Definition: avformat.h:1106
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:348
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:979
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
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:855
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:592
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:792
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:1012
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:70
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:519
av_write_frame
int av_write_frame(AVFormatContext *s, AVPacket *in)
Write a packet to an output media file.
Definition: mux.c:1174
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1441
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:459
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:1290
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:50
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
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
write_packets_common
static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
Definition: mux.c:1151
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:510
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
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:583
options
const OptionDef options[]
AVPacket::size
int size
Definition: packet.h:366
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:166
av_codec_get_tag
unsigned int av_codec_get_tag(const struct AVCodecTag *const *tags, enum AVCodecID id)
Get the codec tag for the given codec id id.
FFFrac::val
int64_t val
Definition: internal.h:60
flush_if_needed
static void flush_if_needed(AVFormatContext *s)
Definition: mux.c:430
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:119
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *s, 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:4799
AVStreamInternal::is_intra_only
int is_intra_only
Definition: internal.h:213
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:471
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:458
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:888
AVFMT_NOSTREAMS
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:467
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:560
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:364
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:465
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:371
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:506
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1389
AVStreamInternal::last_in_packet_buffer
struct PacketList * last_in_packet_buffer
last packet in packet_buffer for this stream when muxing.
Definition: internal.h:367
PacketList::pkt
AVPacket pkt
Definition: packet_internal.h:28
AVStreamInternal::pts_buffer
int64_t pts_buffer[MAX_REORDER_DELAY+1]
Definition: internal.h:341
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:595
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:56
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:1236
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:374
i
int i
Definition: input.c:407
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:224
AVOutputFormat
Definition: avformat.h:490
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:358
guess_pkt_duration
static void guess_pkt_duration(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:604
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:1281
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:1434
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:205
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:243
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
AVBSFContext::time_base_out
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: bsf.h:95
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:475
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:472
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:879
tag
uint32_t tag
Definition: movenc.c:1594
AVFMT_FLAG_BITEXACT
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1241
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:832
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
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:376
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:90
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:192
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:440
AVStreamInternal::interleaver_chunk_duration
int64_t interleaver_chunk_duration
Definition: internal.h:256
check_packet
static int check_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:726
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:833
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:1317
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:4301
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:810
AVSTREAM_INIT_IN_INIT_OUTPUT
#define AVSTREAM_INIT_IN_INIT_OUTPUT
stream parameters initialized in avformat_init_output
Definition: avformat.h:2167
AVPacket::stream_index
int stream_index
Definition: packet.h:367
av_buffer_ref
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
AVBSFContext::filter
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: bsf.h:58
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:259
desc
const char * desc
Definition: libsvtav1.c:79
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:60
AVCodecContext::max_b_frames
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:761
write_packets_from_bsfs
static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1119
packet_internal.h
MAX_REORDER_DELAY
@ MAX_REORDER_DELAY
Definition: vaapi_encode.h:44
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:894
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
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:70
init_pts
static int init_pts(AVFormatContext *s)
Definition: mux.c:385
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:81
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:52
AVPacket
This structure stores compressed data.
Definition: packet.h:342
AV_WRITE_UNCODED_FRAME_QUERY
@ AV_WRITE_UNCODED_FRAME_QUERY
Query whether the feature is possible on this stream.
Definition: internal.h:842
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:1221
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:1311
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:1076
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:189
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:59
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:1234
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3508
AVFMT_AVOID_NEG_TS_AUTO
#define AVFMT_AVOID_NEG_TS_AUTO
Enabled when required by target format.
Definition: avformat.h:1433
avstring.h
FFFrac
The exact value of the fractional number is: 'val + num / den'.
Definition: internal.h:59
FFFrac::den
int64_t den
Definition: internal.h:60
check_bitstream
static int check_bitstream(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:1057
AVCodecTag::tag
unsigned int tag
Definition: internal.h:44
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
av_rescale_q_rnd
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.
Definition: mathematics.c:134
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:90
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:377
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
AVStreamInternal::bitstream_checked
int bitstream_checked
Whether or not check_bitstream should still be run on each packet.
Definition: internal.h:187
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:531