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 (ff_toupper4(avctag->tag) == ff_toupper4(st->codecpar->codec_tag)) {
208  id = avctag->id;
209  if (id == st->codecpar->codec_id)
210  return 1;
211  }
212  if (avctag->id == st->codecpar->codec_id)
213  tag = avctag->tag;
214  avctag++;
215  }
216  }
217  if (id != AV_CODEC_ID_NONE)
218  return 0;
219  if (tag >= 0 && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
220  return 0;
221  return 1;
222 }
223 
224 
226 {
227  FFFormatContext *const si = ffformatcontext(s);
228  AVDictionary *tmp = NULL;
229  const AVOutputFormat *of = s->oformat;
231  int ret = 0;
232 
233  if (options)
234  av_dict_copy(&tmp, *options, 0);
235 
236  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
237  goto fail;
238  if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
239  (ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
240  goto fail;
241 
242  if (!s->url && !(s->url = av_strdup(""))) {
243  ret = AVERROR(ENOMEM);
244  goto fail;
245  }
246 
247  // some sanity checks
248  if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) {
249  av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");
250  ret = AVERROR(EINVAL);
251  goto fail;
252  }
253 
254  for (unsigned i = 0; i < s->nb_streams; i++) {
255  AVStream *const st = s->streams[i];
256  FFStream *const sti = ffstream(st);
257  AVCodecParameters *const par = st->codecpar;
258  const AVCodecDescriptor *desc;
259 
260  if (!st->time_base.num) {
261  /* fall back on the default timebase values */
262  if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)
263  avpriv_set_pts_info(st, 64, 1, par->sample_rate);
264  else
265  avpriv_set_pts_info(st, 33, 1, 90000);
266  }
267 
268  switch (par->codec_type) {
269  case AVMEDIA_TYPE_AUDIO:
270  if (par->sample_rate <= 0) {
271  av_log(s, AV_LOG_ERROR, "sample rate not set\n");
272  ret = AVERROR(EINVAL);
273  goto fail;
274  }
275  if (!par->block_align)
276  par->block_align = par->channels *
277  av_get_bits_per_sample(par->codec_id) >> 3;
278  break;
279  case AVMEDIA_TYPE_VIDEO:
280  if ((par->width <= 0 || par->height <= 0) &&
281  !(of->flags & AVFMT_NODIMENSIONS)) {
282  av_log(s, AV_LOG_ERROR, "dimensions not set\n");
283  ret = AVERROR(EINVAL);
284  goto fail;
285  }
288  ) {
289  if (st->sample_aspect_ratio.num != 0 &&
290  st->sample_aspect_ratio.den != 0 &&
291  par->sample_aspect_ratio.num != 0 &&
292  par->sample_aspect_ratio.den != 0) {
293  av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
294  "(%d/%d) and encoder layer (%d/%d)\n",
297  par->sample_aspect_ratio.den);
298  ret = AVERROR(EINVAL);
299  goto fail;
300  }
301  }
302  break;
303  }
304 
306  if (desc && desc->props & AV_CODEC_PROP_REORDER)
307  sti->reorder = 1;
308 
310 
311  if (of->codec_tag) {
312  if ( par->codec_tag
313  && par->codec_id == AV_CODEC_ID_RAWVIDEO
314  && ( av_codec_get_tag(of->codec_tag, par->codec_id) == 0
315  || av_codec_get_tag(of->codec_tag, par->codec_id) == MKTAG('r', 'a', 'w', ' '))
316  && !validate_codec_tag(s, st)) {
317  // the current rawvideo encoding system ends up setting
318  // the wrong codec_tag for avi/mov, we override it here
319  par->codec_tag = 0;
320  }
321  if (par->codec_tag) {
322  if (!validate_codec_tag(s, st)) {
323  const uint32_t otag = av_codec_get_tag(s->oformat->codec_tag, par->codec_id);
325  "Tag %s incompatible with output codec id '%d' (%s)\n",
326  av_fourcc2str(par->codec_tag), par->codec_id, av_fourcc2str(otag));
328  goto fail;
329  }
330  } else
331  par->codec_tag = av_codec_get_tag(of->codec_tag, par->codec_id);
332  }
333 
336  }
338  if (!si->interleave_packet)
342 
343  if (!s->priv_data && of->priv_data_size > 0) {
344  s->priv_data = av_mallocz(of->priv_data_size);
345  if (!s->priv_data) {
346  ret = AVERROR(ENOMEM);
347  goto fail;
348  }
349  if (of->priv_class) {
350  *(const AVClass **)s->priv_data = of->priv_class;
351  av_opt_set_defaults(s->priv_data);
352  if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
353  goto fail;
354  }
355  }
356 
357  /* set muxer identification string */
358  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
359  av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
360  } else {
361  av_dict_set(&s->metadata, "encoder", NULL, 0);
362  }
363 
364  for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {
365  av_dict_set(&s->metadata, e->key, NULL, 0);
366  }
367 
368  if (options) {
370  *options = tmp;
371  }
372 
373  if (s->oformat->init) {
374  if ((ret = s->oformat->init(s)) < 0) {
375  if (s->oformat->deinit)
376  s->oformat->deinit(s);
377  return ret;
378  }
379  return ret == 0;
380  }
381 
382  return 0;
383 
384 fail:
385  av_dict_free(&tmp);
386  return ret;
387 }
388 
390 {
391  FFFormatContext *const si = ffformatcontext(s);
392 
393  /* init PTS generation */
394  for (unsigned i = 0; i < s->nb_streams; i++) {
395  AVStream *const st = s->streams[i];
396  FFStream *const sti = ffstream(st);
397  int64_t den = AV_NOPTS_VALUE;
398 
399  switch (st->codecpar->codec_type) {
400  case AVMEDIA_TYPE_AUDIO:
401  den = (int64_t)st->time_base.num * st->codecpar->sample_rate;
402  break;
403  case AVMEDIA_TYPE_VIDEO:
404  den = (int64_t)st->time_base.num * st->time_base.den;
405  break;
406  default:
407  break;
408  }
409 
410  if (!sti->priv_pts)
411  sti->priv_pts = av_mallocz(sizeof(*sti->priv_pts));
412  if (!sti->priv_pts)
413  return AVERROR(ENOMEM);
414 
415  if (den != AV_NOPTS_VALUE) {
416  if (den <= 0)
417  return AVERROR_INVALIDDATA;
418 
419  frac_init(sti->priv_pts, 0, 0, den);
420  }
421  }
422 
423  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_UNKNOWN;
424  if (s->avoid_negative_ts < 0) {
425  av_assert2(s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO);
426  if (s->oformat->flags & (AVFMT_TS_NEGATIVE | AVFMT_NOTIMESTAMPS)) {
427  s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_DISABLED;
428  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_DISABLED;
429  } else
430  s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE;
431  } else if (s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_DISABLED)
432  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_DISABLED;
433 
434  return 0;
435 }
436 
438 {
439  if (s->pb && s->pb->error >= 0) {
440  if (s->flush_packets == 1 || s->flags & AVFMT_FLAG_FLUSH_PACKETS)
441  avio_flush(s->pb);
442  else if (s->flush_packets && !(s->oformat->flags & AVFMT_NOFILE))
444  }
445 }
446 
448 {
449  FFFormatContext *const si = ffformatcontext(s);
450  if (s->oformat && s->oformat->deinit && si->initialized)
451  s->oformat->deinit(s);
452  si->initialized =
453  si->streams_initialized = 0;
454 }
455 
457 {
458  FFFormatContext *const si = ffformatcontext(s);
459  int ret = 0;
460 
461  if ((ret = init_muxer(s, options)) < 0)
462  return ret;
463 
464  si->initialized = 1;
465  si->streams_initialized = ret;
466 
467  if (s->oformat->init && ret) {
468  if ((ret = init_pts(s)) < 0)
469  return ret;
470 
472  }
473 
475 }
476 
478 {
479  FFFormatContext *const si = ffformatcontext(s);
480  int already_initialized = si->initialized;
481  int streams_already_initialized = si->streams_initialized;
482  int ret = 0;
483 
484  if (!already_initialized)
485  if ((ret = avformat_init_output(s, options)) < 0)
486  return ret;
487 
488  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
490  if (s->oformat->write_header) {
491  ret = s->oformat->write_header(s);
492  if (ret >= 0 && s->pb && s->pb->error < 0)
493  ret = s->pb->error;
494  if (ret < 0)
495  goto fail;
497  }
498  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
500 
501  if (!si->streams_initialized) {
502  if ((ret = init_pts(s)) < 0)
503  goto fail;
504  }
505 
506  return streams_already_initialized;
507 
508 fail:
509  deinit_muxer(s);
510  return ret;
511 }
512 
513 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
514 
515 
516 #if FF_API_COMPUTE_PKT_FIELDS2
518 //FIXME merge with compute_pkt_fields
519 static int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)
520 {
521  FFFormatContext *const si = ffformatcontext(s);
522  FFStream *const sti = ffstream(st);
523  int delay = st->codecpar->video_delay;
524  int frame_size;
525 
526  if (!si->missing_ts_warning &&
527  !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
529  (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
531  "Timestamps are unset in a packet for stream %d. "
532  "This is deprecated and will stop working in the future. "
533  "Fix your code to set the timestamps properly\n", st->index);
534  si->missing_ts_warning = 1;
535  }
536 
537  if (s->debug & FF_FDEBUG_TS)
538  av_log(s, AV_LOG_DEBUG, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
540 
541  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
542  pkt->pts = pkt->dts;
543 
544  //XXX/FIXME this is a temporary hack until all encoders output pts
545  if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
546  static int warned;
547  if (!warned) {
548  av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
549  warned = 1;
550  }
551  pkt->dts =
552 // pkt->pts= st->cur_dts;
553  pkt->pts = sti->priv_pts->val;
554  }
555 
556  //calculate dts from pts
557  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
558  sti->pts_buffer[0] = pkt->pts;
559  for (int i = 1; i < delay + 1 && sti->pts_buffer[i] == AV_NOPTS_VALUE; i++)
560  sti->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
561  for (int i = 0; i<delay && sti->pts_buffer[i] > sti->pts_buffer[i + 1]; i++)
562  FFSWAP(int64_t, sti->pts_buffer[i], sti->pts_buffer[i + 1]);
563 
564  pkt->dts = sti->pts_buffer[0];
565  }
566 
567  if (sti->cur_dts && sti->cur_dts != AV_NOPTS_VALUE &&
568  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
571  sti->cur_dts >= pkt->dts) || sti->cur_dts > pkt->dts)) {
573  "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
574  st->index, av_ts2str(sti->cur_dts), av_ts2str(pkt->dts));
575  return AVERROR(EINVAL);
576  }
577  if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
579  "pts (%s) < dts (%s) in stream %d\n",
581  st->index);
582  return AVERROR(EINVAL);
583  }
584 
585  if (s->debug & FF_FDEBUG_TS)
586  av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n",
588 
589  sti->cur_dts = pkt->dts;
590  sti->priv_pts->val = pkt->dts;
591 
592  /* update pts */
593  switch (st->codecpar->codec_type) {
594  case AVMEDIA_TYPE_AUDIO:
596  (*(AVFrame **)pkt->data)->nb_samples :
598 
599  /* HACK/FIXME, we skip the initial 0 size packets as they are most
600  * likely equal to the encoder delay, but it would be better if we
601  * had the real timestamps from the encoder */
602  if (frame_size >= 0 && (pkt->size || sti->priv_pts->num != sti->priv_pts->den >> 1 || sti->priv_pts->val)) {
603  frac_add(sti->priv_pts, (int64_t)st->time_base.den * frame_size);
604  }
605  break;
606  case AVMEDIA_TYPE_VIDEO:
607  frac_add(sti->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
608  break;
609  }
610  return 0;
611 }
613 #endif
614 
616 {
617  if (pkt->duration < 0 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
618  av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
620  pkt->duration = 0;
621  }
622 
623  if (pkt->duration)
624  return;
625 
626  switch (st->codecpar->codec_type) {
627  case AVMEDIA_TYPE_VIDEO:
628  if (st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0) {
630  st->time_base);
631  } else if (st->time_base.num * 1000LL > st->time_base.den)
632  pkt->duration = 1;
633  break;
634  case AVMEDIA_TYPE_AUDIO: {
636  if (frame_size && st->codecpar->sample_rate) {
638  (AVRational){1, st->codecpar->sample_rate},
639  st->time_base);
640  }
641  break;
642  }
643  }
644 }
645 
647  AVPacket *pkt)
648 {
649  AVFormatContext *const s = &si->pub;
650  int64_t offset;
651 
653  return;
654 
655  if (si->avoid_negative_ts_status == AVOID_NEGATIVE_TS_UNKNOWN) {
656  int use_pts = si->avoid_negative_ts_use_pts;
657  int64_t ts = use_pts ? pkt->pts : pkt->dts;
658  AVRational tb = sti->pub.time_base;
659 
660  if (ts == AV_NOPTS_VALUE)
661  return;
662 
663  /* Peek into the muxing queue to improve our estimate
664  * of the lowest timestamp if av_interleaved_write_frame() is used. */
665  for (const PacketListEntry *pktl = si->packet_buffer.head;
666  pktl; pktl = pktl->next) {
667  AVRational cmp_tb = s->streams[pktl->pkt.stream_index]->time_base;
668  int64_t cmp_ts = use_pts ? pktl->pkt.pts : pktl->pkt.dts;
669  if (cmp_ts == AV_NOPTS_VALUE)
670  continue;
671  if (s->output_ts_offset)
672  cmp_ts += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, cmp_tb);
673  if (av_compare_ts(cmp_ts, cmp_tb, ts, tb) < 0) {
674  ts = cmp_ts;
675  tb = cmp_tb;
676  }
677  }
678 
679  if (ts < 0 ||
680  ts > 0 && s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) {
681  for (unsigned i = 0; i < s->nb_streams; i++) {
682  AVStream *const st2 = s->streams[i];
683  FFStream *const sti2 = ffstream(st2);
684  sti2->mux_ts_offset = av_rescale_q_rnd(-ts, tb,
685  st2->time_base,
686  AV_ROUND_UP);
687  }
688  }
689  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_KNOWN;
690  }
691 
692  offset = sti->mux_ts_offset;
693 
694  if (pkt->dts != AV_NOPTS_VALUE)
695  pkt->dts += offset;
696  if (pkt->pts != AV_NOPTS_VALUE)
697  pkt->pts += offset;
698 
699  if (si->avoid_negative_ts_use_pts) {
700  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < 0) {
701  av_log(s, AV_LOG_WARNING, "failed to avoid negative "
702  "pts %s in stream %d.\n"
703  "Try -avoid_negative_ts 1 as a possible workaround.\n",
704  av_ts2str(pkt->pts),
706  );
707  }
708  } else {
709  if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < 0) {
711  "Packets poorly interleaved, failed to avoid negative "
712  "timestamp %s in stream %d.\n"
713  "Try -max_interleave_delta 0 as a possible workaround.\n",
714  av_ts2str(pkt->dts),
716  );
717  }
718  }
719 }
720 
721 /**
722  * Shift timestamps and call muxer; the original pts/dts are not kept.
723  *
724  * FIXME: this function should NEVER get undefined pts/dts beside when the
725  * AVFMT_NOTIMESTAMPS is set.
726  * Those additional safety checks should be dropped once the correct checks
727  * are set in the callers.
728  */
730 {
731  FFFormatContext *const si = ffformatcontext(s);
732  AVStream *const st = s->streams[pkt->stream_index];
733  FFStream *const sti = ffstream(st);
734  int ret;
735 
736  // If the timestamp offsetting below is adjusted, adjust
737  // ff_interleaved_peek similarly.
738  if (s->output_ts_offset) {
739  int64_t offset = av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
740 
741  if (pkt->dts != AV_NOPTS_VALUE)
742  pkt->dts += offset;
743  if (pkt->pts != AV_NOPTS_VALUE)
744  pkt->pts += offset;
745  }
746  handle_avoid_negative_ts(si, sti, pkt);
747 
749  AVFrame **frame = (AVFrame **)pkt->data;
750  av_assert0(pkt->size == sizeof(*frame));
751  ret = s->oformat->write_uncoded_frame(s, pkt->stream_index, frame, 0);
752  } else {
753  ret = s->oformat->write_packet(s, pkt);
754  }
755 
756  if (s->pb && ret >= 0) {
758  if (s->pb->error < 0)
759  ret = s->pb->error;
760  }
761 
762  if (ret >= 0)
763  st->nb_frames++;
764 
765  return ret;
766 }
767 
769 {
770  if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
771  av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
772  pkt->stream_index);
773  return AVERROR(EINVAL);
774  }
775 
776  if (s->streams[pkt->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
777  av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
778  return AVERROR(EINVAL);
779  }
780 
781  return 0;
782 }
783 
785 {
786  FFStream *const sti = ffstream(st);
787 #if !FF_API_COMPUTE_PKT_FIELDS2
788  /* sanitize the timestamps */
789  if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
790 
791  /* when there is no reordering (so dts is equal to pts), but
792  * only one of them is set, set the other as well */
793  if (!sti->reorder) {
794  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)
795  pkt->pts = pkt->dts;
796  if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
797  pkt->dts = pkt->pts;
798  }
799 
800  /* check that the timestamps are set */
801  if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {
803  "Timestamps are unset in a packet for stream %d\n", st->index);
804  return AVERROR(EINVAL);
805  }
806 
807  /* check that the dts are increasing (or at least non-decreasing,
808  * if the format allows it */
809  if (sti->cur_dts != AV_NOPTS_VALUE &&
810  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && sti->cur_dts >= pkt->dts) ||
811  sti->cur_dts > pkt->dts)) {
813  "Application provided invalid, non monotonically increasing "
814  "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
815  st->index, sti->cur_dts, pkt->dts);
816  return AVERROR(EINVAL);
817  }
818 
819  if (pkt->pts < pkt->dts) {
820  av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
821  pkt->pts, pkt->dts, st->index);
822  return AVERROR(EINVAL);
823  }
824  }
825 #endif
826  /* update flags */
827  if (sti->is_intra_only)
829 
830  if (!pkt->data && !pkt->side_data_elems) {
831  /* Such empty packets signal EOS for the BSF API; so sanitize
832  * the packet by allocating data of size 0 (+ padding). */
835  }
836 
837  return 0;
838 }
839 
840 #define CHUNK_START 0x1000
841 
843  int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
844 {
845  int ret;
846  FFFormatContext *const si = ffformatcontext(s);
847  PacketListEntry **next_point, *this_pktl;
848  AVStream *st = s->streams[pkt->stream_index];
849  FFStream *const sti = ffstream(st);
850  int chunked = s->max_chunk_size || s->max_chunk_duration;
851 
852  this_pktl = av_malloc(sizeof(*this_pktl));
853  if (!this_pktl) {
855  return AVERROR(ENOMEM);
856  }
857  if ((ret = av_packet_make_refcounted(pkt)) < 0) {
858  av_free(this_pktl);
860  return ret;
861  }
862 
863  av_packet_move_ref(&this_pktl->pkt, pkt);
864  pkt = &this_pktl->pkt;
865 
866  if (sti->last_in_packet_buffer) {
867  next_point = &(sti->last_in_packet_buffer->next);
868  } else {
869  next_point = &si->packet_buffer.head;
870  }
871 
872  if (chunked) {
873  uint64_t max= av_rescale_q_rnd(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base, AV_ROUND_UP);
876  if ( (s->max_chunk_size && sti->interleaver_chunk_size > s->max_chunk_size)
877  || (max && sti->interleaver_chunk_duration > max)) {
878  sti->interleaver_chunk_size = 0;
879  pkt->flags |= CHUNK_START;
880  if (max && sti->interleaver_chunk_duration > max) {
881  int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
882  int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
883 
884  sti->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
885  } else
887  }
888  }
889  if (*next_point) {
890  if (chunked && !(pkt->flags & CHUNK_START))
891  goto next_non_null;
892 
893  if (compare(s, &si->packet_buffer.tail->pkt, pkt)) {
894  while ( *next_point
895  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
896  || !compare(s, &(*next_point)->pkt, pkt)))
897  next_point = &(*next_point)->next;
898  if (*next_point)
899  goto next_non_null;
900  } else {
901  next_point = &(si->packet_buffer.tail->next);
902  }
903  }
904  av_assert1(!*next_point);
905 
906  si->packet_buffer.tail = this_pktl;
907 next_non_null:
908 
909  this_pktl->next = *next_point;
910 
911  sti->last_in_packet_buffer = *next_point = this_pktl;
912 
913  return 0;
914 }
915 
917  const AVPacket *pkt)
918 {
919  AVStream *st = s->streams[pkt->stream_index];
920  AVStream *st2 = s->streams[next->stream_index];
921  int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
922  st->time_base);
923  if (s->audio_preload) {
924  int preload = st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
925  int preload2 = st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
926  if (preload != preload2) {
927  int64_t ts, ts2;
928  preload *= s->audio_preload;
929  preload2 *= s->audio_preload;
930  ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - preload;
931  ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - preload2;
932  if (ts == ts2) {
933  ts = ((uint64_t)pkt ->dts*st ->time_base.num*AV_TIME_BASE - (uint64_t)preload *st ->time_base.den)*st2->time_base.den
934  - ((uint64_t)next->dts*st2->time_base.num*AV_TIME_BASE - (uint64_t)preload2*st2->time_base.den)*st ->time_base.den;
935  ts2 = 0;
936  }
937  comp = (ts2 > ts) - (ts2 < ts);
938  }
939  }
940 
941  if (comp == 0)
942  return pkt->stream_index < next->stream_index;
943  return comp > 0;
944 }
945 
947  int flush, int has_packet)
948 {
949  FFFormatContext *const si = ffformatcontext(s);
950  int stream_count = 0;
951  int noninterleaved_count = 0;
952  int ret;
953  int eof = flush;
954 
955  if (has_packet) {
957  return ret;
958  }
959 
960  for (unsigned i = 0; i < s->nb_streams; i++) {
961  const AVStream *const st = s->streams[i];
962  const FFStream *const sti = cffstream(st);
963  const AVCodecParameters *const par = st->codecpar;
964  if (sti->last_in_packet_buffer) {
965  ++stream_count;
966  } else if (par->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
967  par->codec_id != AV_CODEC_ID_VP8 &&
968  par->codec_id != AV_CODEC_ID_VP9) {
969  ++noninterleaved_count;
970  }
971  }
972 
973  if (si->nb_interleaved_streams == stream_count)
974  flush = 1;
975 
976  if (s->max_interleave_delta > 0 &&
977  si->packet_buffer.head &&
978  !flush &&
979  si->nb_interleaved_streams == stream_count+noninterleaved_count
980  ) {
981  AVPacket *const top_pkt = &si->packet_buffer.head->pkt;
982  int64_t delta_dts = INT64_MIN;
983  int64_t top_dts = av_rescale_q(top_pkt->dts,
984  s->streams[top_pkt->stream_index]->time_base,
986 
987  for (unsigned i = 0; i < s->nb_streams; i++) {
988  const AVStream *const st = s->streams[i];
989  const FFStream *const sti = cffstream(st);
990  const PacketListEntry *const last = sti->last_in_packet_buffer;
991  int64_t last_dts;
992 
993  if (!last)
994  continue;
995 
996  last_dts = av_rescale_q(last->pkt.dts,
997  st->time_base,
999  delta_dts = FFMAX(delta_dts, last_dts - top_dts);
1000  }
1001 
1002  if (delta_dts > s->max_interleave_delta) {
1004  "Delay between the first packet and last packet in the "
1005  "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
1006  delta_dts, s->max_interleave_delta);
1007  flush = 1;
1008  }
1009  }
1010 
1011  if (si->packet_buffer.head &&
1012  eof &&
1013  (s->flags & AVFMT_FLAG_SHORTEST) &&
1014  si->shortest_end == AV_NOPTS_VALUE) {
1015  AVPacket *const top_pkt = &si->packet_buffer.head->pkt;
1016 
1017  si->shortest_end = av_rescale_q(top_pkt->dts,
1018  s->streams[top_pkt->stream_index]->time_base,
1019  AV_TIME_BASE_Q);
1020  }
1021 
1022  if (si->shortest_end != AV_NOPTS_VALUE) {
1023  while (si->packet_buffer.head) {
1024  PacketListEntry *pktl = si->packet_buffer.head;
1025  AVPacket *const top_pkt = &pktl->pkt;
1026  AVStream *const st = s->streams[top_pkt->stream_index];
1027  FFStream *const sti = ffstream(st);
1028  int64_t top_dts = av_rescale_q(top_pkt->dts, st->time_base,
1029  AV_TIME_BASE_Q);
1030 
1031  if (si->shortest_end + 1 >= top_dts)
1032  break;
1033 
1034  si->packet_buffer.head = pktl->next;
1035  if (!si->packet_buffer.head)
1036  si->packet_buffer.tail = NULL;
1037 
1038  if (sti->last_in_packet_buffer == pktl)
1039  sti->last_in_packet_buffer = NULL;
1040 
1041  av_packet_unref(&pktl->pkt);
1042  av_freep(&pktl);
1043  flush = 0;
1044  }
1045  }
1046 
1047  if (stream_count && flush) {
1048  PacketListEntry *pktl = si->packet_buffer.head;
1049  AVStream *const st = s->streams[pktl->pkt.stream_index];
1050  FFStream *const sti = ffstream(st);
1051 
1052  if (sti->last_in_packet_buffer == pktl)
1053  sti->last_in_packet_buffer = NULL;
1055 
1056  return 1;
1057  } else {
1058  return 0;
1059  }
1060 }
1061 
1063  int flush, int has_packet)
1064 {
1065  return has_packet;
1066 }
1067 
1068 int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
1069 {
1070  AVStream *st;
1071 
1072  if (stream_index < 0 || stream_index >= s->nb_streams)
1073  return AVERROR(EINVAL);
1074 
1075  st = s->streams[stream_index];
1076  *offset = ffstream(st)->mux_ts_offset;
1077 
1078  if (s->output_ts_offset)
1079  *offset += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
1080 
1081  return 0;
1082 }
1083 
1085 {
1086  FFFormatContext *const si = ffformatcontext(s);
1087  PacketListEntry *pktl = si->packet_buffer.head;
1088  while (pktl) {
1089  if (pktl->pkt.stream_index == stream) {
1090  return &pktl->pkt;
1091  }
1092  pktl = pktl->next;
1093  }
1094  return NULL;
1095 }
1096 
1098 {
1099  int ret;
1100 
1101  if (!(s->flags & AVFMT_FLAG_AUTO_BSF))
1102  return 1;
1103 
1104  if (s->oformat->check_bitstream) {
1105  if (!sti->bitstream_checked) {
1106  if ((ret = s->oformat->check_bitstream(s, &sti->pub, pkt)) < 0)
1107  return ret;
1108  else if (ret == 1)
1109  sti->bitstream_checked = 1;
1110  }
1111  }
1112 
1113  return 1;
1114 }
1115 
1117  int flush, int has_packet)
1118 {
1119  FFFormatContext *const si = ffformatcontext(s);
1120  for (;; ) {
1121  int ret = si->interleave_packet(s, pkt, flush, has_packet);
1122  if (ret <= 0)
1123  return ret;
1124 
1125  has_packet = 0;
1126 
1127  ret = write_packet(s, pkt);
1129  if (ret < 0)
1130  return ret;
1131  }
1132 }
1133 
1134 static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1135 {
1136  int ret;
1137 
1138  if (s->debug & FF_FDEBUG_TS)
1139  av_log(s, AV_LOG_DEBUG, "%s size:%d dts:%s pts:%s\n", __FUNCTION__,
1141 
1142  guess_pkt_duration(s, st, pkt);
1143 
1144 #if FF_API_COMPUTE_PKT_FIELDS2
1145  if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1146  return ret;
1147 #endif
1148 
1149  if (interleaved) {
1150  if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1151  return AVERROR(EINVAL);
1152  return interleaved_write_packet(s, pkt, 0, 1);
1153  } else {
1154  return write_packet(s, pkt);
1155  }
1156 }
1157 
1158 static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1159 {
1160  FFStream *const sti = ffstream(st);
1161  AVBSFContext *const bsfc = sti->bsfc;
1162  int ret;
1163 
1164  if ((ret = av_bsf_send_packet(bsfc, pkt)) < 0) {
1166  "Failed to send packet to filter %s for stream %d\n",
1167  bsfc->filter->name, st->index);
1168  return ret;
1169  }
1170 
1171  do {
1172  ret = av_bsf_receive_packet(bsfc, pkt);
1173  if (ret < 0) {
1174  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
1175  return 0;
1176  av_log(s, AV_LOG_ERROR, "Error applying bitstream filters to an output "
1177  "packet for stream #%d: %s\n", st->index, av_err2str(ret));
1178  if (!(s->error_recognition & AV_EF_EXPLODE) && ret != AVERROR(ENOMEM))
1179  continue;
1180  return ret;
1181  }
1183  ret = write_packet_common(s, st, pkt, interleaved);
1184  if (ret >= 0 && !interleaved) // a successful write_packet_common already unrefed pkt for interleaved
1186  } while (ret >= 0);
1187 
1188  return ret;
1189 }
1190 
1191 static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
1192 {
1193  AVStream *st;
1194  FFStream *sti;
1195  int ret = check_packet(s, pkt);
1196  if (ret < 0)
1197  return ret;
1198  st = s->streams[pkt->stream_index];
1199  sti = ffstream(st);
1200 
1201  ret = prepare_input_packet(s, st, pkt);
1202  if (ret < 0)
1203  return ret;
1204 
1205  ret = check_bitstream(s, sti, pkt);
1206  if (ret < 0)
1207  return ret;
1208 
1209  if (sti->bsfc) {
1210  return write_packets_from_bsfs(s, st, pkt, interleaved);
1211  } else {
1212  return write_packet_common(s, st, pkt, interleaved);
1213  }
1214 }
1215 
1217 {
1218  FFFormatContext *const si = ffformatcontext(s);
1219  AVPacket *pkt = si->parse_pkt;
1220  int ret;
1221 
1222  if (!in) {
1223  if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
1224  ret = s->oformat->write_packet(s, NULL);
1225  flush_if_needed(s);
1226  if (ret >= 0 && s->pb && s->pb->error < 0)
1227  ret = s->pb->error;
1228  return ret;
1229  }
1230  return 1;
1231  }
1232 
1233  if (in->flags & AV_PKT_FLAG_UNCODED_FRAME) {
1234  pkt = in;
1235  } else {
1236  /* We don't own in, so we have to make sure not to modify it.
1237  * (ff_write_chained() relies on this fact.)
1238  * The following avoids copying in's data unnecessarily.
1239  * Copying side data is unavoidable as a bitstream filter
1240  * may change it, e.g. free it on errors. */
1241  pkt->data = in->data;
1242  pkt->size = in->size;
1243  ret = av_packet_copy_props(pkt, in);
1244  if (ret < 0)
1245  return ret;
1246  if (in->buf) {
1247  pkt->buf = av_buffer_ref(in->buf);
1248  if (!pkt->buf) {
1249  ret = AVERROR(ENOMEM);
1250  goto fail;
1251  }
1252  }
1253  }
1254 
1255  ret = write_packets_common(s, pkt, 0/*non-interleaved*/);
1256 
1257 fail:
1258  // Uncoded frames using the noninterleaved codepath are also freed here
1260  return ret;
1261 }
1262 
1264 {
1265  int ret;
1266 
1267  if (pkt) {
1268  ret = write_packets_common(s, pkt, 1/*interleaved*/);
1269  if (ret < 0)
1271  return ret;
1272  } else {
1273  av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");
1274  return interleaved_write_packet(s, ffformatcontext(s)->parse_pkt, 1/*flush*/, 0);
1275  }
1276 }
1277 
1279 {
1280  FFFormatContext *const si = ffformatcontext(s);
1281  AVPacket *const pkt = si->parse_pkt;
1282  int ret1, ret = 0;
1283 
1284  for (unsigned i = 0; i < s->nb_streams; i++) {
1285  AVStream *const st = s->streams[i];
1286  FFStream *const sti = ffstream(st);
1287  if (sti->bsfc) {
1288  ret1 = write_packets_from_bsfs(s, st, pkt, 1/*interleaved*/);
1289  if (ret1 < 0)
1291  if (ret >= 0)
1292  ret = ret1;
1293  }
1294  }
1295  ret1 = interleaved_write_packet(s, pkt, 1, 0);
1296  if (ret >= 0)
1297  ret = ret1;
1298 
1299  if (s->oformat->write_trailer) {
1300  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1302  if (ret >= 0) {
1303  ret = s->oformat->write_trailer(s);
1304  } else {
1305  s->oformat->write_trailer(s);
1306  }
1307  }
1308 
1309  deinit_muxer(s);
1310 
1311  if (s->pb)
1312  avio_flush(s->pb);
1313  if (ret == 0)
1314  ret = s->pb ? s->pb->error : 0;
1315  for (unsigned i = 0; i < s->nb_streams; i++) {
1316  av_freep(&s->streams[i]->priv_data);
1317  av_freep(&ffstream(s->streams[i])->index_entries);
1318  }
1319  if (s->oformat->priv_class)
1320  av_opt_free(s->priv_data);
1321  av_freep(&s->priv_data);
1322  av_packet_unref(si->pkt);
1323  return ret;
1324 }
1325 
1327  int64_t *dts, int64_t *wall)
1328 {
1329  if (!s->oformat || !s->oformat->get_output_timestamp)
1330  return AVERROR(ENOSYS);
1331  s->oformat->get_output_timestamp(s, stream, dts, wall);
1332  return 0;
1333 }
1334 
1335 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
1337 {
1338  int64_t pts = pkt->pts, dts = pkt->dts, duration = pkt->duration;
1339  int stream_index = pkt->stream_index;
1340  AVRational time_base = pkt->time_base;
1341  int ret;
1342 
1343  pkt->stream_index = dst_stream;
1344 
1346  src->streams[stream_index]->time_base,
1347  dst->streams[dst_stream]->time_base);
1348 
1349  if (!interleave) {
1350  ret = av_write_frame(dst, pkt);
1351  /* We only have to backup and restore the fields that
1352  * we changed ourselves, because av_write_frame() does not
1353  * modify the packet given to it. */
1354  pkt->pts = pts;
1355  pkt->dts = dts;
1356  pkt->duration = duration;
1357  pkt->stream_index = stream_index;
1358  pkt->time_base = time_base;
1359  } else
1361 
1362  return ret;
1363 }
1364 
1365 static void uncoded_frame_free(void *unused, uint8_t *data)
1366 {
1367  av_frame_free((AVFrame **)data);
1368  av_free(data);
1369 }
1370 
1371 static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
1372  AVFrame *frame, int interleaved)
1373 {
1374  FFFormatContext *const si = ffformatcontext(s);
1375  AVPacket *pkt = si->parse_pkt;
1376 
1377  av_assert0(s->oformat);
1378  if (!s->oformat->write_uncoded_frame) {
1379  av_frame_free(&frame);
1380  return AVERROR(ENOSYS);
1381  }
1382 
1383  if (!frame) {
1384  pkt = NULL;
1385  } else {
1386  size_t bufsize = sizeof(frame) + AV_INPUT_BUFFER_PADDING_SIZE;
1387  AVFrame **framep = av_mallocz(bufsize);
1388 
1389  if (!framep)
1390  goto fail;
1391  pkt->buf = av_buffer_create((void *)framep, bufsize,
1392  uncoded_frame_free, NULL, 0);
1393  if (!pkt->buf) {
1394  av_free(framep);
1395  fail:
1396  av_frame_free(&frame);
1397  return AVERROR(ENOMEM);
1398  }
1399  *framep = frame;
1400 
1401  pkt->data = (void *)framep;
1402  pkt->size = sizeof(frame);
1403  pkt->pts =
1404  pkt->dts = frame->pts;
1405  pkt->duration = frame->pkt_duration;
1406  pkt->stream_index = stream_index;
1408  }
1409 
1410  return interleaved ? av_interleaved_write_frame(s, pkt) :
1411  av_write_frame(s, pkt);
1412 }
1413 
1415  AVFrame *frame)
1416 {
1417  return write_uncoded_frame_internal(s, stream_index, frame, 0);
1418 }
1419 
1421  AVFrame *frame)
1422 {
1423  return write_uncoded_frame_internal(s, stream_index, frame, 1);
1424 }
1425 
1427 {
1428  av_assert0(s->oformat);
1429  if (!s->oformat->write_uncoded_frame)
1430  return AVERROR(ENOSYS);
1431  return s->oformat->write_uncoded_frame(s, stream_index, NULL,
1433 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:424
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
interleave_compare_dts
static int interleave_compare_dts(AVFormatContext *s, const AVPacket *next, const AVPacket *pkt)
Definition: mux.c:916
LIBAVFORMAT_IDENT
#define LIBAVFORMAT_IDENT
Definition: version.h:46
PacketList::head
PacketListEntry * head
Definition: packet_internal.h:32
avpriv_packet_list_get
int avpriv_packet_list_get(PacketList *pkt_buffer, AVPacket *pkt)
Remove the oldest AVPacket in the list and return it.
Definition: avpacket.c:577
AVSTREAM_INIT_IN_WRITE_HEADER
#define AVSTREAM_INIT_IN_WRITE_HEADER
stream parameters initialized in avformat_write_header
Definition: avformat.h:2286
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
FFFormatContext::interleave_packet
int(* interleave_packet)(struct AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
The interleavement function in use.
Definition: internal.h:99
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
av_compare_ts
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
Definition: mathematics.c:146
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1364
AVFMT_NODIMENSIONS
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:479
FF_FDEBUG_TS
#define FF_FDEBUG_TS
Definition: avformat.h:1473
avformat_alloc_output_context2
int avformat_alloc_output_context2(AVFormatContext **avctx, const AVOutputFormat *oformat, const char *format, const char *filename)
Allocate an AVFormatContext for an output format.
Definition: mux.c:136
prepare_input_packet
static int prepare_input_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:784
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:188
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2660
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AV_DISPOSITION_ATTACHED_PIC
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:873
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:475
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:52
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:1097
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:109
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
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:1268
FFStream::interleaver_chunk_size
int64_t interleaver_chunk_size
Definition: internal.h:281
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:1414
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:1015
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:165
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:1341
ff_toupper4
unsigned int ff_toupper4(unsigned int x)
Definition: to_upper4.h:29
FFStream::bsfc
AVBSFContext * bsfc
bitstream filter to run on stream
Definition: internal.h:210
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:391
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
max
#define max(a, b)
Definition: cuda_runtime.h:33
mathematics.h
AVDictionary
Definition: dict.c:30
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
av_write_uncoded_frame_query
int av_write_uncoded_frame_query(AVFormatContext *s, int stream_index)
Test whether a muxer supports uncoded frame.
Definition: mux.c:1426
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:456
cffstream
static const av_always_inline FFStream * cffstream(const AVStream *st)
Definition: internal.h:436
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:428
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:160
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:816
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:490
FFStream::is_intra_only
int is_intra_only
Definition: internal.h:239
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:431
fail
#define fail()
Definition: checkasm.h:128
AVFMT_FLAG_AUTO_BSF
#define AVFMT_FLAG_AUTO_BSF
Add bitstream filters as requested by the muxer.
Definition: avformat.h:1342
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:1536
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:878
pts
static int64_t pts
Definition: transcode_aac.c:653
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:83
AVRational::num
int num
Numerator.
Definition: rational.h:59
ff_interleave_packet_per_dts
int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
Interleave an AVPacket per dts so it can be muxed.
Definition: mux.c:946
FFStream::priv_pts
FFFrac * priv_pts
Definition: internal.h:241
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:580
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:729
AVCodecTag
Definition: internal.h:51
write_packet_common
static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1134
duration
int64_t duration
Definition: movenc.c:64
interleaved_write_packet
static int interleaved_write_packet(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
Definition: mux.c:1116
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
av_opt_set_dict
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1661
AV_PKT_FLAG_UNCODED_FRAME
#define AV_PKT_FLAG_UNCODED_FRAME
Definition: mux.c:513
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
FFFormatContext::packet_buffer
PacketList packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:107
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:2199
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
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
CHUNK_START
#define CHUNK_START
Definition: mux.c:840
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:529
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:1420
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:1084
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:477
init_muxer
static int init_muxer(AVFormatContext *s, AVDictionary **options)
Definition: mux.c:225
PacketList::tail
PacketListEntry * tail
Definition: packet_internal.h:32
if
if(ret)
Definition: filter_design.txt:179
FFFormatContext
Definition: internal.h:73
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:252
AVFormatContext
Format I/O context.
Definition: avformat.h:1200
FFStream::pub
AVStream pub
The public context.
Definition: internal.h:197
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:1095
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AVFMT_AVOID_NEG_TS_DISABLED
#define AVFMT_AVOID_NEG_TS_DISABLED
Do not shift timestamps even when they are negative.
Definition: avformat.h:1534
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:215
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:965
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:593
NULL
#define NULL
Definition: coverity.c:32
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:618
AVIO_DATA_MARKER_TRAILER
@ AVIO_DATA_MARKER_TRAILER
Trailer data, which doesn't contain actual content, but only for finalizing the output file.
Definition: avio.h:140
ff_interleave_add_packet
int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt, int(*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
Add packet to an AVFormatContext's packet_buffer list, determining its interleaved position using com...
Definition: mux.c:842
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:620
ff_get_muxer_ts_offset
int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
Definition: mux.c:1068
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1617
frac_add
static void frac_add(FFFrac *f, int64_t incr)
Fractional addition to f: f = f + (incr / f->den).
Definition: mux.c:71
AVOutputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:532
av_write_frame
int av_write_frame(AVFormatContext *s, AVPacket *in)
Write a packet to an output media file.
Definition: mux.c:1216
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1335
FFStream::interleaver_chunk_duration
int64_t interleaver_chunk_duration
Definition: internal.h:282
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:481
PacketListEntry::next
struct PacketListEntry * next
Definition: packet_internal.h:27
FFFormatContext::avoid_negative_ts_status
enum FFFormatContext::@259 avoid_negative_ts_status
Whether the timestamp shift offset has already been determined.
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:1335
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:51
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
AVStream::nb_frames
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:987
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:1191
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:523
AVOID_NEGATIVE_TS_ENABLED
#define AVOID_NEGATIVE_TS_ENABLED(status)
Definition: internal.h:94
interleave
static void interleave(uint8_t *dst, uint8_t *src, int w, int h, int dst_linesize, int src_linesize, enum FilterMode mode, int swap)
Definition: vf_il.c:108
options
const OptionDef options[]
AVPacket::size
int size
Definition: packet.h:374
FFFormatContext::parse_pkt
AVPacket * parse_pkt
The generic code uses this as a temporary packet to parse packets or for muxing, especially flushing.
Definition: internal.h:136
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:69
flush_if_needed
static void flush_if_needed(AVFormatContext *s)
Definition: mux.c:437
FFStream
Definition: internal.h:193
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:484
PacketListEntry::pkt
AVPacket pkt
Definition: packet_internal.h:28
format
ofilter format
Definition: ffmpeg_filter.c:172
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:464
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:617
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:1004
AVFMT_NOSTREAMS
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:480
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:559
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
av_opt_set_dict2
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
Definition: opt.c:1637
av_packet_make_refcounted
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:487
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:203
av_packet_rescale_ts
void av_packet_rescale_ts(AVPacket *pkt, AVRational src_tb, AVRational dst_tb)
Convert valid timing fields (timestamps / durations) in a packet from one timebase to another.
Definition: avpacket.c:528
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1283
AVOutputFormat::interleave_packet
int(* interleave_packet)(struct AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
A format-specific function for interleavement.
Definition: avformat.h:577
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:616
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:57
MAX_REORDER_DELAY
@ MAX_REORDER_DELAY
Definition: vaapi_encode.h:44
av_write_trailer
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
Definition: mux.c:1278
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
av_packet_copy_props
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:387
PacketListEntry
Definition: packet_internal.h:26
FFStream::mux_ts_offset
int64_t mux_ts_offset
Timestamp offset added to timestamps before muxing.
Definition: internal.h:335
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:503
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
guess_pkt_duration
static void guess_pkt_duration(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:615
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:1326
FFStream::reorder
int reorder
Set to 1 if the codec allows reordering, so pts can be different from dts.
Definition: internal.h:203
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:1535
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:367
tb
#define tb
Definition: regdef.h:68
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:263
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:128
AVBSFContext::time_base_out
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: bsf.h:87
FFStream::last_in_packet_buffer
PacketListEntry * last_in_packet_buffer
last packet in packet_buffer for this stream when muxing.
Definition: internal.h:393
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:488
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:485
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:995
tag
uint32_t tag
Definition: movenc.c:1596
AVFMT_FLAG_BITEXACT
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1335
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:935
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:447
check_packet
static int check_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:768
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:943
compare
static float compare(const AVFrame *haystack, const AVFrame *obj, int offx, int offy)
Definition: vf_find_rect.c:95
write_uncoded_frame_internal
static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index, AVFrame *frame, int interleaved)
Definition: mux.c:1371
AVCHROMA_LOC_CENTER
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:619
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVIO_DATA_MARKER_HEADER
@ AVIO_DATA_MARKER_HEADER
Header data; this needs to be present for the stream to be decodeable.
Definition: avio.h:115
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:688
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:1195
AVSTREAM_INIT_IN_INIT_OUTPUT
#define AVSTREAM_INIT_IN_INIT_OUTPUT
stream parameters initialized in avformat_init_output
Definition: avformat.h:2287
AVPacket::stream_index
int stream_index
Definition: packet.h:375
ff_interleave_packet_passthrough
int ff_interleave_packet_passthrough(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
Interleave packets directly in the order in which they arrive without any sort of buffering.
Definition: mux.c:1062
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:276
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
AVBSFContext::filter
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: bsf.h:56
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:279
desc
const char * desc
Definition: libsvtav1.c:79
FFFormatContext::streams_initialized
int streams_initialized
Whether or not avformat_init_output fully initialized streams.
Definition: internal.h:170
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:69
write_packets_from_bsfs
static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1158
packet_internal.h
ff_choose_chroma_location
enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:106
AVCodecParameters::video_delay
int video_delay
Video only.
Definition: codec_par.h:155
FFFormatContext::pkt
AVPacket * pkt
Used to hold temporary packets for the generic demuxing code.
Definition: internal.h:143
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: codec_par.h:38
AVCodecParameters::format
int format
Definition: codec_par.h:84
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
init_pts
static int init_pts(AVFormatContext *s)
Definition: mux.c:389
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:79
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
frac_init
static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
f = val + (num / den) + 0.5.
Definition: mux.c:53
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AV_WRITE_UNCODED_FRAME_QUERY
@ AV_WRITE_UNCODED_FRAME_QUERY
Query whether the feature is possible on this stream.
Definition: internal.h:898
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:1263
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
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
uncoded_frame_free
static void uncoded_frame_free(void *unused, uint8_t *data)
Definition: mux.c:1365
FFStream::cur_dts
int64_t cur_dts
Definition: internal.h:428
timestamp.h
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:190
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
AVFMT_FLAG_FLUSH_PACKETS
#define AVFMT_FLAG_FLUSH_PACKETS
Flush the AVIOContext every packet.
Definition: avformat.h:1328
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3521
AVFMT_AVOID_NEG_TS_AUTO
#define AVFMT_AVOID_NEG_TS_AUTO
Enabled when required by target format.
Definition: avformat.h:1533
avstring.h
FFFrac
The exact value of the fractional number is: 'val + num / den'.
Definition: internal.h:68
FFFrac::den
int64_t den
Definition: internal.h:69
AVCodecTag::tag
unsigned int tag
Definition: internal.h:53
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:52
FFFormatContext::pub
AVFormatContext pub
The public context.
Definition: internal.h:77
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:417
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:385
handle_avoid_negative_ts
static void handle_avoid_negative_ts(FFFormatContext *si, FFStream *sti, AVPacket *pkt)
Definition: mux.c:646
FFFormatContext::nb_interleaved_streams
int nb_interleaved_streams
Number of streams relevant for interleaving.
Definition: internal.h:83
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:544
FFFormatContext::avoid_negative_ts_use_pts
int avoid_negative_ts_use_pts
Definition: internal.h:155