FFmpeg
mux.c
Go to the documentation of this file.
1 /*
2  * muxing functions for use within FFmpeg
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "avformat.h"
23 #include "internal.h"
24 #include "mux.h"
25 #include "version.h"
26 #include "libavcodec/bsf.h"
27 #include "libavcodec/internal.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/dict.h"
31 #include "libavutil/timestamp.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/internal.h"
34 #include "libavutil/mathematics.h"
35 
36 /**
37  * @file
38  * muxing functions for use within libavformat
39  */
40 
41 /* fraction handling */
42 
43 /**
44  * f = val + (num / den) + 0.5.
45  *
46  * 'num' is normalized so that it is such as 0 <= num < den.
47  *
48  * @param f fractional number
49  * @param val integer value
50  * @param num must be >= 0
51  * @param den must be >= 1
52  */
53 static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
54 {
55  num += (den >> 1);
56  if (num >= den) {
57  val += num / den;
58  num = num % den;
59  }
60  f->val = val;
61  f->num = num;
62  f->den = den;
63 }
64 
65 /**
66  * Fractional addition to f: f = f + (incr / f->den).
67  *
68  * @param f fractional number
69  * @param incr increment, can be positive or negative
70  */
71 static void frac_add(FFFrac *f, int64_t incr)
72 {
73  int64_t num, den;
74 
75  num = f->num + incr;
76  den = f->den;
77  if (num < 0) {
78  f->val += num / den;
79  num = num % den;
80  if (num < 0) {
81  num += den;
82  f->val--;
83  }
84  } else if (num >= den) {
85  f->val += num / den;
86  num = num % den;
87  }
88  f->num = num;
89 }
90 
92  const char *format, const char *filename)
93 {
95  int ret = 0;
96 
97  *avctx = NULL;
98  if (!s)
99  goto nomem;
100 
101  if (!oformat) {
102  if (format) {
103  oformat = av_guess_format(format, NULL, NULL);
104  if (!oformat) {
105  av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
106  ret = AVERROR(EINVAL);
107  goto error;
108  }
109  } else {
110  oformat = av_guess_format(NULL, filename, NULL);
111  if (!oformat) {
112  ret = AVERROR(EINVAL);
113  av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
114  filename);
115  goto error;
116  }
117  }
118  }
119 
120  s->oformat = oformat;
121  if (s->oformat->priv_data_size > 0) {
122  s->priv_data = av_mallocz(s->oformat->priv_data_size);
123  if (!s->priv_data)
124  goto nomem;
125  if (s->oformat->priv_class) {
126  *(const AVClass**)s->priv_data= s->oformat->priv_class;
127  av_opt_set_defaults(s->priv_data);
128  }
129  } else
130  s->priv_data = NULL;
131 
132  if (filename) {
133  if (!(s->url = av_strdup(filename)))
134  goto nomem;
135 
136  }
137  *avctx = s;
138  return 0;
139 nomem:
140  av_log(s, AV_LOG_ERROR, "Out of memory\n");
141  ret = AVERROR(ENOMEM);
142 error:
144  return ret;
145 }
146 
147 static int validate_codec_tag(const AVFormatContext *s, const AVStream *st)
148 {
149  const AVCodecTag *avctag;
150  enum AVCodecID id = AV_CODEC_ID_NONE;
151  unsigned uppercase_tag = ff_toupper4(st->codecpar->codec_tag);
152  int64_t tag = -1;
153 
154  /**
155  * Check that tag + id is in the table
156  * If neither is in the table -> OK
157  * If tag is in the table with another id -> FAIL
158  * If id is in the table with another tag -> FAIL unless strict < normal
159  */
160  for (int n = 0; s->oformat->codec_tag[n]; n++) {
161  avctag = s->oformat->codec_tag[n];
162  while (avctag->id != AV_CODEC_ID_NONE) {
163  if (ff_toupper4(avctag->tag) == uppercase_tag) {
164  id = avctag->id;
165  if (id == st->codecpar->codec_id)
166  return 1;
167  }
168  if (avctag->id == st->codecpar->codec_id)
169  tag = avctag->tag;
170  avctag++;
171  }
172  }
173  if (id != AV_CODEC_ID_NONE)
174  return 0;
175  if (tag >= 0 && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
176  return 0;
177  return 1;
178 }
179 
180 
182 {
183  FFFormatContext *const si = ffformatcontext(s);
184  AVDictionary *tmp = NULL;
185  const AVOutputFormat *of = s->oformat;
187  int ret = 0;
188 
189  if (options)
190  av_dict_copy(&tmp, *options, 0);
191 
192  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
193  goto fail;
194  if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
195  (ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
196  goto fail;
197 
198  if (!s->url && !(s->url = av_strdup(""))) {
199  ret = AVERROR(ENOMEM);
200  goto fail;
201  }
202 
203  // some sanity checks
204  if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) {
205  av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");
206  ret = AVERROR(EINVAL);
207  goto fail;
208  }
209 
210  for (unsigned i = 0; i < s->nb_streams; i++) {
211  AVStream *const st = s->streams[i];
212  FFStream *const sti = ffstream(st);
213  AVCodecParameters *const par = st->codecpar;
214  const AVCodecDescriptor *desc;
215 
216  if (!st->time_base.num) {
217  /* fall back on the default timebase values */
218  if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)
219  avpriv_set_pts_info(st, 64, 1, par->sample_rate);
220  else
221  avpriv_set_pts_info(st, 33, 1, 90000);
222  }
223 
224  switch (par->codec_type) {
225  case AVMEDIA_TYPE_AUDIO:
226  if (par->sample_rate <= 0) {
227  av_log(s, AV_LOG_ERROR, "sample rate not set\n");
228  ret = AVERROR(EINVAL);
229  goto fail;
230  }
231 
232 #if FF_API_OLD_CHANNEL_LAYOUT
234  /* if the caller is using the deprecated channel layout API,
235  * convert it to the new style */
236  if (!par->ch_layout.nb_channels &&
237  par->channels) {
238  if (par->channel_layout) {
239  av_channel_layout_from_mask(&par->ch_layout, par->channel_layout);
240  } else {
242  par->ch_layout.nb_channels = par->channels;
243  }
244  }
246 #endif
247 
248  if (!par->block_align)
249  par->block_align = par->ch_layout.nb_channels *
250  av_get_bits_per_sample(par->codec_id) >> 3;
251  break;
252  case AVMEDIA_TYPE_VIDEO:
253  if ((par->width <= 0 || par->height <= 0) &&
254  !(of->flags & AVFMT_NODIMENSIONS)) {
255  av_log(s, AV_LOG_ERROR, "dimensions not set\n");
256  ret = AVERROR(EINVAL);
257  goto fail;
258  }
261  ) {
262  if (st->sample_aspect_ratio.num != 0 &&
263  st->sample_aspect_ratio.den != 0 &&
264  par->sample_aspect_ratio.num != 0 &&
265  par->sample_aspect_ratio.den != 0) {
266  av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
267  "(%d/%d) and encoder layer (%d/%d)\n",
270  par->sample_aspect_ratio.den);
271  ret = AVERROR(EINVAL);
272  goto fail;
273  }
274  }
275  break;
276  }
277 
279  if (desc && desc->props & AV_CODEC_PROP_REORDER)
280  sti->reorder = 1;
281 
283 
284  if (of->codec_tag) {
285  if ( par->codec_tag
286  && par->codec_id == AV_CODEC_ID_RAWVIDEO
287  && ( av_codec_get_tag(of->codec_tag, par->codec_id) == 0
288  || av_codec_get_tag(of->codec_tag, par->codec_id) == MKTAG('r', 'a', 'w', ' '))
289  && !validate_codec_tag(s, st)) {
290  // the current rawvideo encoding system ends up setting
291  // the wrong codec_tag for avi/mov, we override it here
292  par->codec_tag = 0;
293  }
294  if (par->codec_tag) {
295  if (!validate_codec_tag(s, st)) {
296  const uint32_t otag = av_codec_get_tag(s->oformat->codec_tag, par->codec_id);
298  "Tag %s incompatible with output codec id '%d' (%s)\n",
299  av_fourcc2str(par->codec_tag), par->codec_id, av_fourcc2str(otag));
301  goto fail;
302  }
303  } else
304  par->codec_tag = av_codec_get_tag(of->codec_tag, par->codec_id);
305  }
306 
309  }
311  if (!si->interleave_packet)
315 
316  if (!s->priv_data && of->priv_data_size > 0) {
317  s->priv_data = av_mallocz(of->priv_data_size);
318  if (!s->priv_data) {
319  ret = AVERROR(ENOMEM);
320  goto fail;
321  }
322  if (of->priv_class) {
323  *(const AVClass **)s->priv_data = of->priv_class;
324  av_opt_set_defaults(s->priv_data);
325  if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
326  goto fail;
327  }
328  }
329 
330  /* set muxer identification string */
331  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
332  av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
333  } else {
334  av_dict_set(&s->metadata, "encoder", NULL, 0);
335  }
336 
337  for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {
338  av_dict_set(&s->metadata, e->key, NULL, 0);
339  }
340 
341  if (options) {
343  *options = tmp;
344  }
345 
346  if (s->oformat->init) {
347  if ((ret = s->oformat->init(s)) < 0) {
348  if (s->oformat->deinit)
349  s->oformat->deinit(s);
350  return ret;
351  }
352  return ret == 0;
353  }
354 
355  return 0;
356 
357 fail:
358  av_dict_free(&tmp);
359  return ret;
360 }
361 
363 {
364  FFFormatContext *const si = ffformatcontext(s);
365 
366  /* init PTS generation */
367  for (unsigned i = 0; i < s->nb_streams; i++) {
368  AVStream *const st = s->streams[i];
369  FFStream *const sti = ffstream(st);
370  int64_t den = AV_NOPTS_VALUE;
371 
372  switch (st->codecpar->codec_type) {
373  case AVMEDIA_TYPE_AUDIO:
374  den = (int64_t)st->time_base.num * st->codecpar->sample_rate;
375  break;
376  case AVMEDIA_TYPE_VIDEO:
377  den = (int64_t)st->time_base.num * st->time_base.den;
378  break;
379  default:
380  break;
381  }
382 
383  if (!sti->priv_pts)
384  sti->priv_pts = av_mallocz(sizeof(*sti->priv_pts));
385  if (!sti->priv_pts)
386  return AVERROR(ENOMEM);
387 
388  if (den != AV_NOPTS_VALUE) {
389  if (den <= 0)
390  return AVERROR_INVALIDDATA;
391 
392  frac_init(sti->priv_pts, 0, 0, den);
393  }
394  }
395 
396  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_UNKNOWN;
397  if (s->avoid_negative_ts < 0) {
398  av_assert2(s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO);
399  if (s->oformat->flags & (AVFMT_TS_NEGATIVE | AVFMT_NOTIMESTAMPS)) {
400  s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_DISABLED;
401  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_DISABLED;
402  } else
403  s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE;
404  } else if (s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_DISABLED)
405  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_DISABLED;
406 
407  return 0;
408 }
409 
411 {
412  if (s->pb && s->pb->error >= 0) {
413  if (s->flush_packets == 1 || s->flags & AVFMT_FLAG_FLUSH_PACKETS)
414  avio_flush(s->pb);
415  else if (s->flush_packets && !(s->oformat->flags & AVFMT_NOFILE))
417  }
418 }
419 
421 {
422  FFFormatContext *const si = ffformatcontext(s);
423  if (s->oformat && s->oformat->deinit && si->initialized)
424  s->oformat->deinit(s);
425  si->initialized =
426  si->streams_initialized = 0;
427 }
428 
430 {
431  FFFormatContext *const si = ffformatcontext(s);
432  int ret = 0;
433 
434  if ((ret = init_muxer(s, options)) < 0)
435  return ret;
436 
437  si->initialized = 1;
438  si->streams_initialized = ret;
439 
440  if (s->oformat->init && ret) {
441  if ((ret = init_pts(s)) < 0)
442  return ret;
443 
445  }
446 
448 }
449 
451 {
452  FFFormatContext *const si = ffformatcontext(s);
453  int already_initialized = si->initialized;
454  int streams_already_initialized = si->streams_initialized;
455  int ret = 0;
456 
457  if (!already_initialized)
458  if ((ret = avformat_init_output(s, options)) < 0)
459  return ret;
460 
461  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
463  if (s->oformat->write_header) {
464  ret = s->oformat->write_header(s);
465  if (ret >= 0 && s->pb && s->pb->error < 0)
466  ret = s->pb->error;
467  if (ret < 0)
468  goto fail;
470  }
471  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
473 
474  if (!si->streams_initialized) {
475  if ((ret = init_pts(s)) < 0)
476  goto fail;
477  }
478 
479  return streams_already_initialized;
480 
481 fail:
482  deinit_muxer(s);
483  return ret;
484 }
485 
486 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
487 
488 
489 #if FF_API_COMPUTE_PKT_FIELDS2
491 //FIXME merge with compute_pkt_fields
493 {
494  FFFormatContext *const si = ffformatcontext(s);
495  FFStream *const sti = ffstream(st);
496  int delay = st->codecpar->video_delay;
497  int frame_size;
498 
499  if (!si->missing_ts_warning &&
500  !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
502  (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
504  "Timestamps are unset in a packet for stream %d. "
505  "This is deprecated and will stop working in the future. "
506  "Fix your code to set the timestamps properly\n", st->index);
507  si->missing_ts_warning = 1;
508  }
509 
510  if (s->debug & FF_FDEBUG_TS)
511  av_log(s, AV_LOG_DEBUG, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
513 
514  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
515  pkt->pts = pkt->dts;
516 
517  //XXX/FIXME this is a temporary hack until all encoders output pts
518  if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
519  static int warned;
520  if (!warned) {
521  av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
522  warned = 1;
523  }
524  pkt->dts =
525 // pkt->pts= st->cur_dts;
526  pkt->pts = sti->priv_pts->val;
527  }
528 
529  //calculate dts from pts
530  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
531  sti->pts_buffer[0] = pkt->pts;
532  for (int i = 1; i < delay + 1 && sti->pts_buffer[i] == AV_NOPTS_VALUE; i++)
533  sti->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
534  for (int i = 0; i<delay && sti->pts_buffer[i] > sti->pts_buffer[i + 1]; i++)
535  FFSWAP(int64_t, sti->pts_buffer[i], sti->pts_buffer[i + 1]);
536 
537  pkt->dts = sti->pts_buffer[0];
538  }
539 
540  if (sti->cur_dts && sti->cur_dts != AV_NOPTS_VALUE &&
541  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
544  sti->cur_dts >= pkt->dts) || sti->cur_dts > pkt->dts)) {
546  "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
547  st->index, av_ts2str(sti->cur_dts), av_ts2str(pkt->dts));
548  return AVERROR(EINVAL);
549  }
550  if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
552  "pts (%s) < dts (%s) in stream %d\n",
554  st->index);
555  return AVERROR(EINVAL);
556  }
557 
558  if (s->debug & FF_FDEBUG_TS)
559  av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n",
561 
562  sti->cur_dts = pkt->dts;
563  sti->priv_pts->val = pkt->dts;
564 
565  /* update pts */
566  switch (st->codecpar->codec_type) {
567  case AVMEDIA_TYPE_AUDIO:
569  (*(AVFrame **)pkt->data)->nb_samples :
571 
572  /* HACK/FIXME, we skip the initial 0 size packets as they are most
573  * likely equal to the encoder delay, but it would be better if we
574  * had the real timestamps from the encoder */
575  if (frame_size >= 0 && (pkt->size || sti->priv_pts->num != sti->priv_pts->den >> 1 || sti->priv_pts->val)) {
576  frac_add(sti->priv_pts, (int64_t)st->time_base.den * frame_size);
577  }
578  break;
579  case AVMEDIA_TYPE_VIDEO:
580  frac_add(sti->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
581  break;
582  }
583  return 0;
584 }
586 #endif
587 
589 {
590  if (pkt->duration < 0 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
591  av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
593  pkt->duration = 0;
594  }
595 
596  if (pkt->duration)
597  return;
598 
599  switch (st->codecpar->codec_type) {
600  case AVMEDIA_TYPE_VIDEO:
601  if (st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0) {
603  st->time_base);
604  } else if (st->time_base.num * 1000LL > st->time_base.den)
605  pkt->duration = 1;
606  break;
607  case AVMEDIA_TYPE_AUDIO: {
609  if (frame_size && st->codecpar->sample_rate) {
611  (AVRational){1, st->codecpar->sample_rate},
612  st->time_base);
613  }
614  break;
615  }
616  }
617 }
618 
620  AVPacket *pkt)
621 {
622  AVFormatContext *const s = &si->pub;
623  int64_t offset;
624 
626  return;
627 
628  if (si->avoid_negative_ts_status == AVOID_NEGATIVE_TS_UNKNOWN) {
629  int use_pts = si->avoid_negative_ts_use_pts;
630  int64_t ts = use_pts ? pkt->pts : pkt->dts;
631  AVRational tb = sti->pub.time_base;
632 
633  if (ts == AV_NOPTS_VALUE)
634  return;
635 
636  ts -= sti->lowest_ts_allowed;
637 
638  /* Peek into the muxing queue to improve our estimate
639  * of the lowest timestamp if av_interleaved_write_frame() is used. */
640  for (const PacketListEntry *pktl = si->packet_buffer.head;
641  pktl; pktl = pktl->next) {
642  AVRational cmp_tb = s->streams[pktl->pkt.stream_index]->time_base;
643  int64_t cmp_ts = use_pts ? pktl->pkt.pts : pktl->pkt.dts;
644  if (cmp_ts == AV_NOPTS_VALUE)
645  continue;
646  cmp_ts -= ffstream(s->streams[pktl->pkt.stream_index])->lowest_ts_allowed;
647  if (s->output_ts_offset)
648  cmp_ts += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, cmp_tb);
649  if (av_compare_ts(cmp_ts, cmp_tb, ts, tb) < 0) {
650  ts = cmp_ts;
651  tb = cmp_tb;
652  }
653  }
654 
655  if (ts < 0 ||
656  ts > 0 && s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) {
657  for (unsigned i = 0; i < s->nb_streams; i++) {
658  AVStream *const st2 = s->streams[i];
659  FFStream *const sti2 = ffstream(st2);
660  sti2->mux_ts_offset = av_rescale_q_rnd(-ts, tb,
661  st2->time_base,
662  AV_ROUND_UP);
663  }
664  }
665  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_KNOWN;
666  }
667 
668  offset = sti->mux_ts_offset;
669 
670  if (pkt->dts != AV_NOPTS_VALUE)
671  pkt->dts += offset;
672  if (pkt->pts != AV_NOPTS_VALUE)
673  pkt->pts += offset;
674 
675  if (si->avoid_negative_ts_use_pts) {
676  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < sti->lowest_ts_allowed) {
677  av_log(s, AV_LOG_WARNING, "failed to avoid negative "
678  "pts %s in stream %d.\n"
679  "Try -avoid_negative_ts 1 as a possible workaround.\n",
680  av_ts2str(pkt->pts),
682  );
683  }
684  } else {
685  if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < sti->lowest_ts_allowed) {
687  "Packets poorly interleaved, failed to avoid negative "
688  "timestamp %s in stream %d.\n"
689  "Try -max_interleave_delta 0 as a possible workaround.\n",
690  av_ts2str(pkt->dts),
692  );
693  }
694  }
695 }
696 
697 /**
698  * Shift timestamps and call muxer; the original pts/dts are not kept.
699  *
700  * FIXME: this function should NEVER get undefined pts/dts beside when the
701  * AVFMT_NOTIMESTAMPS is set.
702  * Those additional safety checks should be dropped once the correct checks
703  * are set in the callers.
704  */
706 {
707  FFFormatContext *const si = ffformatcontext(s);
708  AVStream *const st = s->streams[pkt->stream_index];
709  FFStream *const sti = ffstream(st);
710  int ret;
711 
712  // If the timestamp offsetting below is adjusted, adjust
713  // ff_interleaved_peek similarly.
714  if (s->output_ts_offset) {
715  int64_t offset = av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
716 
717  if (pkt->dts != AV_NOPTS_VALUE)
718  pkt->dts += offset;
719  if (pkt->pts != AV_NOPTS_VALUE)
720  pkt->pts += offset;
721  }
722  handle_avoid_negative_ts(si, sti, pkt);
723 
725  AVFrame **frame = (AVFrame **)pkt->data;
726  av_assert0(pkt->size == sizeof(*frame));
727  ret = s->oformat->write_uncoded_frame(s, pkt->stream_index, frame, 0);
728  } else {
729  ret = s->oformat->write_packet(s, pkt);
730  }
731 
732  if (s->pb && ret >= 0) {
734  if (s->pb->error < 0)
735  ret = s->pb->error;
736  }
737 
738  if (ret >= 0)
739  st->nb_frames++;
740 
741  return ret;
742 }
743 
745 {
746  if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
747  av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
748  pkt->stream_index);
749  return AVERROR(EINVAL);
750  }
751 
752  if (s->streams[pkt->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
753  av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
754  return AVERROR(EINVAL);
755  }
756 
757  return 0;
758 }
759 
761 {
762  FFStream *const sti = ffstream(st);
763 #if !FF_API_COMPUTE_PKT_FIELDS2
764  /* sanitize the timestamps */
765  if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
766 
767  /* when there is no reordering (so dts is equal to pts), but
768  * only one of them is set, set the other as well */
769  if (!sti->reorder) {
770  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)
771  pkt->pts = pkt->dts;
772  if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
773  pkt->dts = pkt->pts;
774  }
775 
776  /* check that the timestamps are set */
777  if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {
779  "Timestamps are unset in a packet for stream %d\n", st->index);
780  return AVERROR(EINVAL);
781  }
782 
783  /* check that the dts are increasing (or at least non-decreasing,
784  * if the format allows it */
785  if (sti->cur_dts != AV_NOPTS_VALUE &&
786  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && sti->cur_dts >= pkt->dts) ||
787  sti->cur_dts > pkt->dts)) {
789  "Application provided invalid, non monotonically increasing "
790  "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
791  st->index, sti->cur_dts, pkt->dts);
792  return AVERROR(EINVAL);
793  }
794 
795  if (pkt->pts < pkt->dts) {
796  av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
797  pkt->pts, pkt->dts, st->index);
798  return AVERROR(EINVAL);
799  }
800  }
801 #endif
802  /* update flags */
803  if (sti->is_intra_only)
805 
806  if (!pkt->data && !pkt->side_data_elems) {
807  /* Such empty packets signal EOS for the BSF API; so sanitize
808  * the packet by allocating data of size 0 (+ padding). */
811  }
812 
813  return 0;
814 }
815 
816 #define CHUNK_START 0x1000
817 
819  int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
820 {
821  int ret;
822  FFFormatContext *const si = ffformatcontext(s);
823  PacketListEntry **next_point, *this_pktl;
824  AVStream *st = s->streams[pkt->stream_index];
825  FFStream *const sti = ffstream(st);
826  int chunked = s->max_chunk_size || s->max_chunk_duration;
827 
828  this_pktl = av_malloc(sizeof(*this_pktl));
829  if (!this_pktl) {
831  return AVERROR(ENOMEM);
832  }
833  if ((ret = av_packet_make_refcounted(pkt)) < 0) {
834  av_free(this_pktl);
836  return ret;
837  }
838 
839  av_packet_move_ref(&this_pktl->pkt, pkt);
840  pkt = &this_pktl->pkt;
841 
842  if (sti->last_in_packet_buffer) {
843  next_point = &(sti->last_in_packet_buffer->next);
844  } else {
845  next_point = &si->packet_buffer.head;
846  }
847 
848  if (chunked) {
849  uint64_t max= av_rescale_q_rnd(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base, AV_ROUND_UP);
852  if ( (s->max_chunk_size && sti->interleaver_chunk_size > s->max_chunk_size)
853  || (max && sti->interleaver_chunk_duration > max)) {
854  sti->interleaver_chunk_size = 0;
855  pkt->flags |= CHUNK_START;
856  if (max && sti->interleaver_chunk_duration > max) {
857  int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
858  int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
859 
860  sti->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
861  } else
863  }
864  }
865  if (*next_point) {
866  if (chunked && !(pkt->flags & CHUNK_START))
867  goto next_non_null;
868 
869  if (compare(s, &si->packet_buffer.tail->pkt, pkt)) {
870  while ( *next_point
871  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
872  || !compare(s, &(*next_point)->pkt, pkt)))
873  next_point = &(*next_point)->next;
874  if (*next_point)
875  goto next_non_null;
876  } else {
877  next_point = &(si->packet_buffer.tail->next);
878  }
879  }
880  av_assert1(!*next_point);
881 
882  si->packet_buffer.tail = this_pktl;
883 next_non_null:
884 
885  this_pktl->next = *next_point;
886 
887  sti->last_in_packet_buffer = *next_point = this_pktl;
888 
889  return 0;
890 }
891 
893  const AVPacket *pkt)
894 {
895  AVStream *st = s->streams[pkt->stream_index];
896  AVStream *st2 = s->streams[next->stream_index];
897  int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
898  st->time_base);
899  if (s->audio_preload) {
900  int preload = st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
901  int preload2 = st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
902  if (preload != preload2) {
903  int64_t ts, ts2;
904  preload *= s->audio_preload;
905  preload2 *= s->audio_preload;
906  ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - preload;
907  ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - preload2;
908  if (ts == ts2) {
909  ts = ((uint64_t)pkt ->dts*st ->time_base.num*AV_TIME_BASE - (uint64_t)preload *st ->time_base.den)*st2->time_base.den
910  - ((uint64_t)next->dts*st2->time_base.num*AV_TIME_BASE - (uint64_t)preload2*st2->time_base.den)*st ->time_base.den;
911  ts2 = 0;
912  }
913  comp = (ts2 > ts) - (ts2 < ts);
914  }
915  }
916 
917  if (comp == 0)
918  return pkt->stream_index < next->stream_index;
919  return comp > 0;
920 }
921 
923  int flush, int has_packet)
924 {
925  FFFormatContext *const si = ffformatcontext(s);
926  int stream_count = 0;
927  int noninterleaved_count = 0;
928  int ret;
929  int eof = flush;
930 
931  if (has_packet) {
933  return ret;
934  }
935 
936  for (unsigned i = 0; i < s->nb_streams; i++) {
937  const AVStream *const st = s->streams[i];
938  const FFStream *const sti = cffstream(st);
939  const AVCodecParameters *const par = st->codecpar;
940  if (sti->last_in_packet_buffer) {
941  ++stream_count;
942  } else if (par->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
943  par->codec_id != AV_CODEC_ID_VP8 &&
944  par->codec_id != AV_CODEC_ID_VP9) {
945  ++noninterleaved_count;
946  }
947  }
948 
949  if (si->nb_interleaved_streams == stream_count)
950  flush = 1;
951 
952  if (s->max_interleave_delta > 0 &&
953  si->packet_buffer.head &&
954  !flush &&
955  si->nb_interleaved_streams == stream_count+noninterleaved_count
956  ) {
957  AVPacket *const top_pkt = &si->packet_buffer.head->pkt;
958  int64_t delta_dts = INT64_MIN;
959  int64_t top_dts = av_rescale_q(top_pkt->dts,
960  s->streams[top_pkt->stream_index]->time_base,
962 
963  for (unsigned i = 0; i < s->nb_streams; i++) {
964  const AVStream *const st = s->streams[i];
965  const FFStream *const sti = cffstream(st);
966  const PacketListEntry *const last = sti->last_in_packet_buffer;
967  int64_t last_dts;
968 
969  if (!last)
970  continue;
971 
972  last_dts = av_rescale_q(last->pkt.dts,
973  st->time_base,
975  delta_dts = FFMAX(delta_dts, last_dts - top_dts);
976  }
977 
978  if (delta_dts > s->max_interleave_delta) {
980  "Delay between the first packet and last packet in the "
981  "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
982  delta_dts, s->max_interleave_delta);
983  flush = 1;
984  }
985  }
986 
987  if (si->packet_buffer.head &&
988  eof &&
989  (s->flags & AVFMT_FLAG_SHORTEST) &&
990  si->shortest_end == AV_NOPTS_VALUE) {
991  AVPacket *const top_pkt = &si->packet_buffer.head->pkt;
992 
993  si->shortest_end = av_rescale_q(top_pkt->dts,
994  s->streams[top_pkt->stream_index]->time_base,
996  }
997 
998  if (si->shortest_end != AV_NOPTS_VALUE) {
999  while (si->packet_buffer.head) {
1000  PacketListEntry *pktl = si->packet_buffer.head;
1001  AVPacket *const top_pkt = &pktl->pkt;
1002  AVStream *const st = s->streams[top_pkt->stream_index];
1003  FFStream *const sti = ffstream(st);
1004  int64_t top_dts = av_rescale_q(top_pkt->dts, st->time_base,
1005  AV_TIME_BASE_Q);
1006 
1007  if (si->shortest_end + 1 >= top_dts)
1008  break;
1009 
1010  si->packet_buffer.head = pktl->next;
1011  if (!si->packet_buffer.head)
1012  si->packet_buffer.tail = NULL;
1013 
1014  if (sti->last_in_packet_buffer == pktl)
1015  sti->last_in_packet_buffer = NULL;
1016 
1017  av_packet_unref(&pktl->pkt);
1018  av_freep(&pktl);
1019  flush = 0;
1020  }
1021  }
1022 
1023  if (stream_count && flush) {
1024  PacketListEntry *pktl = si->packet_buffer.head;
1025  AVStream *const st = s->streams[pktl->pkt.stream_index];
1026  FFStream *const sti = ffstream(st);
1027 
1028  if (sti->last_in_packet_buffer == pktl)
1029  sti->last_in_packet_buffer = NULL;
1031 
1032  return 1;
1033  } else {
1034  return 0;
1035  }
1036 }
1037 
1039  int flush, int has_packet)
1040 {
1041  return has_packet;
1042 }
1043 
1044 int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
1045 {
1046  AVStream *st;
1047 
1048  if (stream_index < 0 || stream_index >= s->nb_streams)
1049  return AVERROR(EINVAL);
1050 
1051  st = s->streams[stream_index];
1052  *offset = ffstream(st)->mux_ts_offset;
1053 
1054  if (s->output_ts_offset)
1055  *offset += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
1056 
1057  return 0;
1058 }
1059 
1061 {
1062  FFFormatContext *const si = ffformatcontext(s);
1063  PacketListEntry *pktl = si->packet_buffer.head;
1064  while (pktl) {
1065  if (pktl->pkt.stream_index == stream) {
1066  return &pktl->pkt;
1067  }
1068  pktl = pktl->next;
1069  }
1070  return NULL;
1071 }
1072 
1074 {
1075  int ret;
1076 
1077  if (!(s->flags & AVFMT_FLAG_AUTO_BSF))
1078  return 1;
1079 
1080  if (s->oformat->check_bitstream) {
1081  if (!sti->bitstream_checked) {
1082  if ((ret = s->oformat->check_bitstream(s, &sti->pub, pkt)) < 0)
1083  return ret;
1084  else if (ret == 1)
1085  sti->bitstream_checked = 1;
1086  }
1087  }
1088 
1089  return 1;
1090 }
1091 
1093  int flush, int has_packet)
1094 {
1095  FFFormatContext *const si = ffformatcontext(s);
1096  for (;; ) {
1097  int ret = si->interleave_packet(s, pkt, flush, has_packet);
1098  if (ret <= 0)
1099  return ret;
1100 
1101  has_packet = 0;
1102 
1103  ret = write_packet(s, pkt);
1105  if (ret < 0)
1106  return ret;
1107  }
1108 }
1109 
1110 static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1111 {
1112  int ret;
1113 
1114  if (s->debug & FF_FDEBUG_TS)
1115  av_log(s, AV_LOG_DEBUG, "%s size:%d dts:%s pts:%s\n", __FUNCTION__,
1117 
1118  guess_pkt_duration(s, st, pkt);
1119 
1120 #if FF_API_COMPUTE_PKT_FIELDS2
1121  if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1122  return ret;
1123 #endif
1124 
1125  if (interleaved) {
1126  if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1127  return AVERROR(EINVAL);
1128  return interleaved_write_packet(s, pkt, 0, 1);
1129  } else {
1130  return write_packet(s, pkt);
1131  }
1132 }
1133 
1134 static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1135 {
1136  FFStream *const sti = ffstream(st);
1137  AVBSFContext *const bsfc = sti->bsfc;
1138  int ret;
1139 
1140  if ((ret = av_bsf_send_packet(bsfc, pkt)) < 0) {
1142  "Failed to send packet to filter %s for stream %d\n",
1143  bsfc->filter->name, st->index);
1144  return ret;
1145  }
1146 
1147  do {
1148  ret = av_bsf_receive_packet(bsfc, pkt);
1149  if (ret < 0) {
1150  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
1151  return 0;
1152  av_log(s, AV_LOG_ERROR, "Error applying bitstream filters to an output "
1153  "packet for stream #%d: %s\n", st->index, av_err2str(ret));
1154  if (!(s->error_recognition & AV_EF_EXPLODE) && ret != AVERROR(ENOMEM))
1155  continue;
1156  return ret;
1157  }
1159  ret = write_packet_common(s, st, pkt, interleaved);
1160  if (ret >= 0 && !interleaved) // a successful write_packet_common already unrefed pkt for interleaved
1162  } while (ret >= 0);
1163 
1164  return ret;
1165 }
1166 
1167 static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
1168 {
1169  AVStream *st;
1170  FFStream *sti;
1171  int ret = check_packet(s, pkt);
1172  if (ret < 0)
1173  return ret;
1174  st = s->streams[pkt->stream_index];
1175  sti = ffstream(st);
1176 
1177  ret = prepare_input_packet(s, st, pkt);
1178  if (ret < 0)
1179  return ret;
1180 
1181  ret = check_bitstream(s, sti, pkt);
1182  if (ret < 0)
1183  return ret;
1184 
1185  if (sti->bsfc) {
1186  return write_packets_from_bsfs(s, st, pkt, interleaved);
1187  } else {
1188  return write_packet_common(s, st, pkt, interleaved);
1189  }
1190 }
1191 
1193 {
1194  FFFormatContext *const si = ffformatcontext(s);
1195  AVPacket *pkt = si->parse_pkt;
1196  int ret;
1197 
1198  if (!in) {
1199  if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
1200  ret = s->oformat->write_packet(s, NULL);
1201  flush_if_needed(s);
1202  if (ret >= 0 && s->pb && s->pb->error < 0)
1203  ret = s->pb->error;
1204  return ret;
1205  }
1206  return 1;
1207  }
1208 
1209  if (in->flags & AV_PKT_FLAG_UNCODED_FRAME) {
1210  pkt = in;
1211  } else {
1212  /* We don't own in, so we have to make sure not to modify it.
1213  * (ff_write_chained() relies on this fact.)
1214  * The following avoids copying in's data unnecessarily.
1215  * Copying side data is unavoidable as a bitstream filter
1216  * may change it, e.g. free it on errors. */
1217  pkt->data = in->data;
1218  pkt->size = in->size;
1219  ret = av_packet_copy_props(pkt, in);
1220  if (ret < 0)
1221  return ret;
1222  if (in->buf) {
1223  pkt->buf = av_buffer_ref(in->buf);
1224  if (!pkt->buf) {
1225  ret = AVERROR(ENOMEM);
1226  goto fail;
1227  }
1228  }
1229  }
1230 
1231  ret = write_packets_common(s, pkt, 0/*non-interleaved*/);
1232 
1233 fail:
1234  // Uncoded frames using the noninterleaved codepath are also freed here
1236  return ret;
1237 }
1238 
1240 {
1241  int ret;
1242 
1243  if (pkt) {
1244  ret = write_packets_common(s, pkt, 1/*interleaved*/);
1245  if (ret < 0)
1247  return ret;
1248  } else {
1249  av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");
1250  return interleaved_write_packet(s, ffformatcontext(s)->parse_pkt, 1/*flush*/, 0);
1251  }
1252 }
1253 
1255 {
1256  FFFormatContext *const si = ffformatcontext(s);
1257  AVPacket *const pkt = si->parse_pkt;
1258  int ret1, ret = 0;
1259 
1260  for (unsigned i = 0; i < s->nb_streams; i++) {
1261  AVStream *const st = s->streams[i];
1262  FFStream *const sti = ffstream(st);
1263  if (sti->bsfc) {
1264  ret1 = write_packets_from_bsfs(s, st, pkt, 1/*interleaved*/);
1265  if (ret1 < 0)
1267  if (ret >= 0)
1268  ret = ret1;
1269  }
1270  }
1271  ret1 = interleaved_write_packet(s, pkt, 1, 0);
1272  if (ret >= 0)
1273  ret = ret1;
1274 
1275  if (s->oformat->write_trailer) {
1276  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1278  if (ret >= 0) {
1279  ret = s->oformat->write_trailer(s);
1280  } else {
1281  s->oformat->write_trailer(s);
1282  }
1283  }
1284 
1285  deinit_muxer(s);
1286 
1287  if (s->pb)
1288  avio_flush(s->pb);
1289  if (ret == 0)
1290  ret = s->pb ? s->pb->error : 0;
1291  for (unsigned i = 0; i < s->nb_streams; i++) {
1292  av_freep(&s->streams[i]->priv_data);
1293  av_freep(&ffstream(s->streams[i])->index_entries);
1294  }
1295  if (s->oformat->priv_class)
1296  av_opt_free(s->priv_data);
1297  av_freep(&s->priv_data);
1298  av_packet_unref(si->pkt);
1299  return ret;
1300 }
1301 
1303  int64_t *dts, int64_t *wall)
1304 {
1305  if (!s->oformat || !s->oformat->get_output_timestamp)
1306  return AVERROR(ENOSYS);
1307  s->oformat->get_output_timestamp(s, stream, dts, wall);
1308  return 0;
1309 }
1310 
1311 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
1312 {
1313  int ret;
1314  const AVBitStreamFilter *bsf;
1315  FFStream *const sti = ffstream(st);
1316  AVBSFContext *bsfc;
1317 
1318  av_assert0(!sti->bsfc);
1319 
1320  if (!(bsf = av_bsf_get_by_name(name))) {
1321  av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
1322  return AVERROR_BSF_NOT_FOUND;
1323  }
1324 
1325  if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
1326  return ret;
1327 
1328  bsfc->time_base_in = st->time_base;
1329  if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
1330  av_bsf_free(&bsfc);
1331  return ret;
1332  }
1333 
1334  if (args && bsfc->filter->priv_class) {
1335  if ((ret = av_set_options_string(bsfc->priv_data, args, "=", ":")) < 0) {
1336  av_bsf_free(&bsfc);
1337  return ret;
1338  }
1339  }
1340 
1341  if ((ret = av_bsf_init(bsfc)) < 0) {
1342  av_bsf_free(&bsfc);
1343  return ret;
1344  }
1345 
1346  sti->bsfc = bsfc;
1347 
1349  "Automatically inserted bitstream filter '%s'; args='%s'\n",
1350  name, args ? args : "");
1351  return 1;
1352 }
1353 
1354 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
1356 {
1357  int64_t pts = pkt->pts, dts = pkt->dts, duration = pkt->duration;
1358  int stream_index = pkt->stream_index;
1359  AVRational time_base = pkt->time_base;
1360  int ret;
1361 
1362  pkt->stream_index = dst_stream;
1363 
1365  src->streams[stream_index]->time_base,
1366  dst->streams[dst_stream]->time_base);
1367 
1368  if (!interleave) {
1369  ret = av_write_frame(dst, pkt);
1370  /* We only have to backup and restore the fields that
1371  * we changed ourselves, because av_write_frame() does not
1372  * modify the packet given to it. */
1373  pkt->pts = pts;
1374  pkt->dts = dts;
1375  pkt->duration = duration;
1376  pkt->stream_index = stream_index;
1377  pkt->time_base = time_base;
1378  } else
1380 
1381  return ret;
1382 }
1383 
1384 static void uncoded_frame_free(void *unused, uint8_t *data)
1385 {
1386  av_frame_free((AVFrame **)data);
1387  av_free(data);
1388 }
1389 
1390 static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
1391  AVFrame *frame, int interleaved)
1392 {
1393  FFFormatContext *const si = ffformatcontext(s);
1394  AVPacket *pkt = si->parse_pkt;
1395 
1396  av_assert0(s->oformat);
1397  if (!s->oformat->write_uncoded_frame) {
1398  av_frame_free(&frame);
1399  return AVERROR(ENOSYS);
1400  }
1401 
1402  if (!frame) {
1403  pkt = NULL;
1404  } else {
1405  size_t bufsize = sizeof(frame) + AV_INPUT_BUFFER_PADDING_SIZE;
1406  AVFrame **framep = av_mallocz(bufsize);
1407 
1408  if (!framep)
1409  goto fail;
1410  pkt->buf = av_buffer_create((void *)framep, bufsize,
1411  uncoded_frame_free, NULL, 0);
1412  if (!pkt->buf) {
1413  av_free(framep);
1414  fail:
1415  av_frame_free(&frame);
1416  return AVERROR(ENOMEM);
1417  }
1418  *framep = frame;
1419 
1420  pkt->data = (void *)framep;
1421  pkt->size = sizeof(frame);
1422  pkt->pts =
1423  pkt->dts = frame->pts;
1424 #if FF_API_PKT_DURATION
1426  if (frame->pkt_duration)
1427  pkt->duration = frame->pkt_duration;
1428  else
1430 #endif
1431  pkt->duration = frame->duration;
1432  pkt->stream_index = stream_index;
1434  }
1435 
1436  return interleaved ? av_interleaved_write_frame(s, pkt) :
1437  av_write_frame(s, pkt);
1438 }
1439 
1441  AVFrame *frame)
1442 {
1443  return write_uncoded_frame_internal(s, stream_index, frame, 0);
1444 }
1445 
1447  AVFrame *frame)
1448 {
1449  return write_uncoded_frame_internal(s, stream_index, frame, 1);
1450 }
1451 
1453 {
1454  av_assert0(s->oformat);
1455  if (!s->oformat->write_uncoded_frame)
1456  return AVERROR(ENOSYS);
1457  return s->oformat->write_uncoded_frame(s, stream_index, NULL,
1459 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
compute_muxer_pkt_fields
static FF_DISABLE_DEPRECATION_WARNINGS int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:492
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:422
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AVBSFContext::par_in
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:90
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
interleave_compare_dts
static int interleave_compare_dts(AVFormatContext *s, const AVPacket *next, const AVPacket *pkt)
Definition: mux.c:892
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
LIBAVFORMAT_IDENT
#define LIBAVFORMAT_IDENT
Definition: version.h:45
PacketList::head
PacketListEntry * head
Definition: packet_internal.h:32
avpriv_packet_list_get
int avpriv_packet_list_get(PacketList *pkt_buffer, AVPacket *pkt)
Remove the oldest AVPacket in the list and return it.
Definition: avpacket.c:575
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
AVSTREAM_INIT_IN_WRITE_HEADER
#define AVSTREAM_INIT_IN_WRITE_HEADER
stream parameters initialized in avformat_write_header
Definition: avformat.h:2314
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:97
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:58
av_compare_ts
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
Definition: mathematics.c:147
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1459
AVFMT_NODIMENSIONS
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:485
FF_FDEBUG_TS
#define FF_FDEBUG_TS
Definition: avformat.h:1489
avformat_alloc_output_context2
int avformat_alloc_output_context2(AVFormatContext **avctx, const AVOutputFormat *oformat, const char *format, const char *filename)
Allocate an AVFormatContext for an output format.
Definition: mux.c:91
FFStream::bsfc
struct AVBSFContext * bsfc
bitstream filter to run on stream
Definition: internal.h:213
prepare_input_packet
static int prepare_input_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:760
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:80
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:54
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:191
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:879
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:481
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:50
AVBitStreamFilter::name
const char * name
Definition: bsf.h:112
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
check_bitstream
static int check_bitstream(AVFormatContext *s, FFStream *sti, AVPacket *pkt)
Definition: mux.c:1073
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1284
FFStream::interleaver_chunk_size
int64_t interleaver_chunk_size
Definition: internal.h:256
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:1440
AVPacket::data
uint8_t * data
Definition: packet.h:374
validate_codec_tag
static int validate_codec_tag(const AVFormatContext *s, const AVStream *st)
Definition: mux.c:147
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:1028
data
const char data[16]
Definition: mxf.c:146
FFFormatContext::initialized
int initialized
Whether or not avformat_init_output has already been called.
Definition: internal.h:163
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:75
AVFMT_FLAG_SHORTEST
#define AVFMT_FLAG_SHORTEST
Stop muxing when the shortest stream stops.
Definition: avformat.h:1357
ff_toupper4
unsigned int ff_toupper4(unsigned int x)
Definition: to_upper4.h:29
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:66
max
#define max(a, b)
Definition: cuda_runtime.h:33
mathematics.h
AVDictionary
Definition: dict.c:32
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:306
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
av_write_uncoded_frame_query
int av_write_uncoded_frame_query(AVFormatContext *s, int stream_index)
Test whether a muxer supports uncoded frame.
Definition: mux.c:1452
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:429
cffstream
static const av_always_inline FFStream * cffstream(const AVStream *st)
Definition: internal.h:418
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:311
av_bsf_free
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
Definition: bsf.c:53
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
AVBSFContext
The bitstream filter state.
Definition: bsf.h:68
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
FFFormatContext::shortest_end
int64_t shortest_end
Timestamp of the end of the shortest stream.
Definition: internal.h:158
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:492
av_set_options_string
int av_set_options_string(void *ctx, const char *opts, const char *key_val_sep, const char *pairs_sep)
Parse the key/value pairs list in opts.
Definition: opt.c:1587
FFStream::is_intra_only
int is_intra_only
Definition: internal.h:242
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:763
bsf.h
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:413
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:1358
val
static double val(void *priv, double ch)
Definition: aeval.c:77
AVFMT_AVOID_NEG_TS_MAKE_ZERO
#define AVFMT_AVOID_NEG_TS_MAKE_ZERO
Shift timestamps so that they start at 0.
Definition: avformat.h:1552
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:884
pts
static int64_t pts
Definition: transcode_aac.c:654
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:922
FFStream::priv_pts
FFFrac * priv_pts
Definition: internal.h:244
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:575
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:705
AVCodecTag
Definition: internal.h:49
write_packet_common
static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1110
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:1092
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:60
av_opt_set_dict
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1767
AV_PKT_FLAG_UNCODED_FRAME
#define AV_PKT_FLAG_UNCODED_FRAME
Definition: mux.c:486
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
s
#define s(width, name)
Definition: cbs_vp9.c:256
FFFormatContext::packet_buffer
PacketList packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:105
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:138
AVDictionaryEntry::key
char * key
Definition: dict.h:90
frame_size
int frame_size
Definition: mxfenc.c:2202
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:220
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:128
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:112
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
av_channel_layout_from_mask
FF_ENABLE_DEPRECATION_WARNINGS int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
Definition: channel_layout.c:391
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
CHUNK_START
#define CHUNK_START
Definition: mux.c:816
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AVBSFContext::time_base_in
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: bsf.h:102
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
av_bsf_alloc
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:105
AVOutputFormat::codec_tag
const struct AVCodecTag *const * codec_tag
List of supported codec_id-codec_tag pairs, ordered by "better choice first".
Definition: avformat.h:535
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:1446
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:1060
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
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:450
init_muxer
static int init_muxer(AVFormatContext *s, AVDictionary **options)
Definition: mux.c:181
PacketList::tail
PacketListEntry * tail
Definition: packet_internal.h:32
if
if(ret)
Definition: filter_design.txt:179
FFFormatContext
Definition: internal.h:71
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:254
AVFormatContext
Format I/O context.
Definition: avformat.h:1216
FFStream::pub
AVStream pub
The public context.
Definition: internal.h:200
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:357
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
av_bsf_init
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:150
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AVFMT_AVOID_NEG_TS_DISABLED
#define AVFMT_AVOID_NEG_TS_DISABLED
Do not shift timestamps even when they are negative.
Definition: avformat.h:1550
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
FFStream::bitstream_checked
int bitstream_checked
Whether or not check_bitstream should still be run on each packet.
Definition: internal.h:218
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:978
NULL
#define NULL
Definition: coverity.c:32
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:231
AVIO_DATA_MARKER_TRAILER
@ AVIO_DATA_MARKER_TRAILER
Trailer data, which doesn't contain actual content, but only for finalizing the output file.
Definition: avio.h:145
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:818
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ff_get_muxer_ts_offset
int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
Definition: mux.c:1044
AVERROR_BSF_NOT_FOUND
#define AVERROR_BSF_NOT_FOUND
Bitstream filter not found.
Definition: error.h:51
AVBitStreamFilter::priv_class
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions.
Definition: bsf.h:130
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1719
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:538
av_write_frame
int av_write_frame(AVFormatContext *s, AVPacket *in)
Write a packet to an output media file.
Definition: mux.c:1192
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:213
FFStream::interleaver_chunk_duration
int64_t interleaver_chunk_duration
Definition: internal.h:257
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:479
PacketListEntry::next
struct PacketListEntry * next
Definition: packet_internal.h:27
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:1354
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:178
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
AVStream::nb_frames
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:1000
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
write_packets_common
static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
Definition: mux.c:1167
AVOutputFormat::flags
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:529
AVOID_NEGATIVE_TS_ENABLED
#define AVOID_NEGATIVE_TS_ENABLED(status)
Definition: internal.h:92
interleave
static void interleave(uint8_t *dst, uint8_t *src, int w, int h, int dst_linesize, int src_linesize, enum FilterMode mode, int swap)
Definition: vf_il.c:108
options
const OptionDef options[]
f
f
Definition: af_crystalizer.c:122
AVPacket::size
int size
Definition: packet.h:375
FFFormatContext::parse_pkt
AVPacket * parse_pkt
The generic code uses this as a temporary packet to parse packets or for muxing, especially flushing.
Definition: internal.h:134
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:164
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:67
flush_if_needed
static void flush_if_needed(AVFormatContext *s)
Definition: mux.c:410
FFStream
Definition: internal.h:196
AV_CODEC_PROP_REORDER
#define AV_CODEC_PROP_REORDER
Codec supports frame reordering.
Definition: codec_desc.h:92
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:203
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
MAX_REORDER_DELAY
@ MAX_REORDER_DELAY
Definition: vaapi_encode.h:45
AVFMT_ALLOW_FLUSH
#define AVFMT_ALLOW_FLUSH
Format allows flushing.
Definition: avformat.h:490
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:826
PacketListEntry::pkt
AVPacket pkt
Definition: packet_internal.h:28
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:470
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:1017
AVFMT_NOSTREAMS
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:486
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:563
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: defs.h:60
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:1743
av_packet_make_refcounted
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:485
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
av_packet_rescale_ts
void av_packet_rescale_ts(AVPacket *pkt, AVRational src_tb, AVRational dst_tb)
Convert valid timing fields (timestamps / durations) in a packet from one timebase to another.
Definition: avpacket.c:526
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:583
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:1254
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
av_packet_copy_props
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:385
ff_is_intra_only
int ff_is_intra_only(enum AVCodecID id)
Definition: avformat.c:827
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:310
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
AVOutputFormat
Definition: avformat.h:509
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
internal.h
AVCodecParameters::height
int height
Definition: codec_par.h:129
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:185
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:1302
FFStream::reorder
int reorder
Set to 1 if the codec allows reordering, so pts can be different from dts.
Definition: internal.h:206
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE
#define AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE
Shift timestamps so they are non negative.
Definition: avformat.h:1551
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:349
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:264
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
AVBSFContext::time_base_out
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: bsf.h:108
FFStream::last_in_packet_buffer
PacketListEntry * last_in_packet_buffer
last packet in packet_buffer for this stream when muxing.
Definition: internal.h:375
AVIO_DATA_MARKER_UNKNOWN
@ AVIO_DATA_MARKER_UNKNOWN
This is any, unlabelled data.
Definition: avio.h:140
AVFMT_TS_NEGATIVE
#define AVFMT_TS_NEGATIVE
Format allows muxing negative timestamps.
Definition: avformat.h:494
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:491
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
version.h
AVBSFContext::priv_data
void * priv_data
Opaque filter-specific private data.
Definition: bsf.h:83
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:1008
tag
uint32_t tag
Definition: movenc.c:1647
AVFMT_FLAG_BITEXACT
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1351
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:948
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
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
deinit_muxer
static void deinit_muxer(AVFormatContext *s)
Definition: mux.c:420
FFFormatContext::avoid_negative_ts_status
enum FFFormatContext::@280 avoid_negative_ts_status
Whether the timestamp shift offset has already been determined.
check_packet
static int check_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:744
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:956
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:1390
ff_stream_add_bitstream_filter
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: mux.c:1311
AVBitStreamFilter
Definition: bsf.h:111
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:120
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:95
AV_WRITE_UNCODED_FRAME_QUERY
@ AV_WRITE_UNCODED_FRAME_QUERY
Query whether the feature is possible on this stream.
Definition: mux.h:95
guess_pkt_duration
static FF_ENABLE_DEPRECATION_WARNINGS void guess_pkt_duration(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:588
AVSTREAM_INIT_IN_INIT_OUTPUT
#define AVSTREAM_INIT_IN_INIT_OUTPUT
stream parameters initialized in avformat_init_output
Definition: avformat.h:2315
AVPacket::stream_index
int stream_index
Definition: packet.h:376
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:1038
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:251
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
AVBSFContext::filter
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: bsf.h:77
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:280
desc
const char * desc
Definition: libsvtav1.c:83
FFFormatContext::streams_initialized
int streams_initialized
Whether or not avformat_init_output fully initialized streams.
Definition: internal.h:168
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:53
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
FFFrac::num
int64_t num
Definition: internal.h:67
write_packets_from_bsfs
static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1134
packet_internal.h
AVCodecParameters::video_delay
int video_delay
Video only.
Definition: codec_par.h:157
FFFormatContext::pkt
AVPacket * pkt
Used to hold temporary packets for the generic demuxing code.
Definition: internal.h:141
init_pts
static int init_pts(AVFormatContext *s)
Definition: mux.c:362
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:62
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:351
av_interleaved_write_frame
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file ensuring correct interleaving.
Definition: mux.c:1239
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:86
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:237
uncoded_frame_free
static void uncoded_frame_free(void *unused, uint8_t *data)
Definition: mux.c:1384
FFStream::cur_dts
int64_t cur_dts
Definition: internal.h:410
timestamp.h
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:192
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
AVFMT_FLAG_FLUSH_PACKETS
#define AVFMT_FLAG_FLUSH_PACKETS
Flush the AVIOContext every packet.
Definition: avformat.h:1344
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:3617
AVFMT_AVOID_NEG_TS_AUTO
#define AVFMT_AVOID_NEG_TS_AUTO
Enabled when required by target format.
Definition: avformat.h:1549
FFFrac
The exact value of the fractional number is: 'val + num / den'.
Definition: internal.h:66
FFFrac::den
int64_t den
Definition: internal.h:67
AVCodecTag::tag
unsigned int tag
Definition: internal.h:51
FFFormatContext::pub
AVFormatContext pub
The public context.
Definition: internal.h:75
FFStream::lowest_ts_allowed
int64_t lowest_ts_allowed
This is the lowest ts allowed in this track; it may be set by the muxer during init or write_header a...
Definition: internal.h:317
av_rescale_q_rnd
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.
Definition: mathematics.c:134
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:74
AVPacket::time_base
AVRational time_base
Time base of the packet's timestamps.
Definition: packet.h:418
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:386
handle_avoid_negative_ts
static void handle_avoid_negative_ts(FFFormatContext *si, FFStream *sti, AVPacket *pkt)
Definition: mux.c:619
FFFormatContext::nb_interleaved_streams
int nb_interleaved_streams
Number of streams relevant for interleaving.
Definition: internal.h:81
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:354
AVIO_DATA_MARKER_FLUSH_POINT
@ AVIO_DATA_MARKER_FLUSH_POINT
A point in the output bytestream where the underlying AVIOContext might flush the buffer depending on...
Definition: avio.h:151
av_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:82
mux.h
AVOutputFormat::priv_data_size
int priv_data_size
size of private data so that it can be allocated in the wrapper
Definition: avformat.h:550
FFFormatContext::avoid_negative_ts_use_pts
int avoid_negative_ts_use_pts
Definition: internal.h:153