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 (ffofmt(s->oformat)->priv_data_size > 0) {
122  s->priv_data = av_mallocz(ffofmt(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 FFOutputFormat *of = ffofmt(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->p.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->p.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->p.codec_tag) {
285  if ( par->codec_tag
286  && par->codec_id == AV_CODEC_ID_RAWVIDEO
287  && ( av_codec_get_tag(of->p.codec_tag, par->codec_id) == 0
288  || av_codec_get_tag(of->p.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->p.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->p.priv_class) {
323  *(const AVClass **)s->priv_data = of->p.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 (of->init) {
347  if ((ret = of->init(s)) < 0) {
348  if (of->deinit)
349  of->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  const FFOutputFormat *const of = ffofmt(s->oformat);
424  if (of && of->deinit && si->initialized)
425  of->deinit(s);
426  si->initialized =
427  si->streams_initialized = 0;
428 }
429 
431 {
432  FFFormatContext *const si = ffformatcontext(s);
433  int ret = 0;
434 
435  if ((ret = init_muxer(s, options)) < 0)
436  return ret;
437 
438  si->initialized = 1;
439  si->streams_initialized = ret;
440 
441  if (ffofmt(s->oformat)->init && ret) {
442  if ((ret = init_pts(s)) < 0)
443  return ret;
444 
446  }
447 
449 }
450 
452 {
453  FFFormatContext *const si = ffformatcontext(s);
454  int already_initialized = si->initialized;
455  int streams_already_initialized = si->streams_initialized;
456  int ret = 0;
457 
458  if (!already_initialized)
459  if ((ret = avformat_init_output(s, options)) < 0)
460  return ret;
461 
462  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
464  if (ffofmt(s->oformat)->write_header) {
465  ret = ffofmt(s->oformat)->write_header(s);
466  if (ret >= 0 && s->pb && s->pb->error < 0)
467  ret = s->pb->error;
468  if (ret < 0)
469  goto fail;
471  }
472  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
474 
475  if (!si->streams_initialized) {
476  if ((ret = init_pts(s)) < 0)
477  goto fail;
478  }
479 
480  return streams_already_initialized;
481 
482 fail:
483  deinit_muxer(s);
484  return ret;
485 }
486 
487 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
488 
489 
490 #if FF_API_COMPUTE_PKT_FIELDS2
492 //FIXME merge with compute_pkt_fields
494 {
495  FFFormatContext *const si = ffformatcontext(s);
496  FFStream *const sti = ffstream(st);
497  int delay = st->codecpar->video_delay;
498  int frame_size;
499 
500  if (!si->missing_ts_warning &&
501  !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
503  (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
505  "Timestamps are unset in a packet for stream %d. "
506  "This is deprecated and will stop working in the future. "
507  "Fix your code to set the timestamps properly\n", st->index);
508  si->missing_ts_warning = 1;
509  }
510 
511  if (s->debug & FF_FDEBUG_TS)
512  av_log(s, AV_LOG_DEBUG, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
514 
515  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
516  pkt->pts = pkt->dts;
517 
518  //XXX/FIXME this is a temporary hack until all encoders output pts
519  if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
520  static int warned;
521  if (!warned) {
522  av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
523  warned = 1;
524  }
525  pkt->dts =
526 // pkt->pts= st->cur_dts;
527  pkt->pts = sti->priv_pts->val;
528  }
529 
530  //calculate dts from pts
531  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
532  sti->pts_buffer[0] = pkt->pts;
533  for (int i = 1; i < delay + 1 && sti->pts_buffer[i] == AV_NOPTS_VALUE; i++)
534  sti->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
535  for (int i = 0; i<delay && sti->pts_buffer[i] > sti->pts_buffer[i + 1]; i++)
536  FFSWAP(int64_t, sti->pts_buffer[i], sti->pts_buffer[i + 1]);
537 
538  pkt->dts = sti->pts_buffer[0];
539  }
540 
541  if (sti->cur_dts && sti->cur_dts != AV_NOPTS_VALUE &&
542  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
545  sti->cur_dts >= pkt->dts) || sti->cur_dts > pkt->dts)) {
547  "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
548  st->index, av_ts2str(sti->cur_dts), av_ts2str(pkt->dts));
549  return AVERROR(EINVAL);
550  }
551  if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
553  "pts (%s) < dts (%s) in stream %d\n",
555  st->index);
556  return AVERROR(EINVAL);
557  }
558 
559  if (s->debug & FF_FDEBUG_TS)
560  av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n",
562 
563  sti->cur_dts = pkt->dts;
564  sti->priv_pts->val = pkt->dts;
565 
566  /* update pts */
567  switch (st->codecpar->codec_type) {
568  case AVMEDIA_TYPE_AUDIO:
570  (*(AVFrame **)pkt->data)->nb_samples :
572 
573  /* HACK/FIXME, we skip the initial 0 size packets as they are most
574  * likely equal to the encoder delay, but it would be better if we
575  * had the real timestamps from the encoder */
576  if (frame_size >= 0 && (pkt->size || sti->priv_pts->num != sti->priv_pts->den >> 1 || sti->priv_pts->val)) {
577  frac_add(sti->priv_pts, (int64_t)st->time_base.den * frame_size);
578  }
579  break;
580  case AVMEDIA_TYPE_VIDEO:
581  frac_add(sti->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
582  break;
583  }
584  return 0;
585 }
587 #endif
588 
590 {
591  if (pkt->duration < 0 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
592  av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
594  pkt->duration = 0;
595  }
596 
597  if (pkt->duration)
598  return;
599 
600  switch (st->codecpar->codec_type) {
601  case AVMEDIA_TYPE_VIDEO:
602  if (st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0) {
604  st->time_base);
605  } else if (st->time_base.num * 1000LL > st->time_base.den)
606  pkt->duration = 1;
607  break;
608  case AVMEDIA_TYPE_AUDIO: {
610  if (frame_size && st->codecpar->sample_rate) {
612  (AVRational){1, st->codecpar->sample_rate},
613  st->time_base);
614  }
615  break;
616  }
617  }
618 }
619 
621  AVPacket *pkt)
622 {
623  AVFormatContext *const s = &si->pub;
624  int64_t offset;
625 
627  return;
628 
629  if (si->avoid_negative_ts_status == AVOID_NEGATIVE_TS_UNKNOWN) {
630  int use_pts = si->avoid_negative_ts_use_pts;
631  int64_t ts = use_pts ? pkt->pts : pkt->dts;
632  AVRational tb = sti->pub.time_base;
633 
634  if (ts == AV_NOPTS_VALUE)
635  return;
636 
637  ts -= sti->lowest_ts_allowed;
638 
639  /* Peek into the muxing queue to improve our estimate
640  * of the lowest timestamp if av_interleaved_write_frame() is used. */
641  for (const PacketListEntry *pktl = si->packet_buffer.head;
642  pktl; pktl = pktl->next) {
643  AVRational cmp_tb = s->streams[pktl->pkt.stream_index]->time_base;
644  int64_t cmp_ts = use_pts ? pktl->pkt.pts : pktl->pkt.dts;
645  if (cmp_ts == AV_NOPTS_VALUE)
646  continue;
647  cmp_ts -= ffstream(s->streams[pktl->pkt.stream_index])->lowest_ts_allowed;
648  if (s->output_ts_offset)
649  cmp_ts += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, cmp_tb);
650  if (av_compare_ts(cmp_ts, cmp_tb, ts, tb) < 0) {
651  ts = cmp_ts;
652  tb = cmp_tb;
653  }
654  }
655 
656  if (ts < 0 ||
657  ts > 0 && s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) {
658  for (unsigned i = 0; i < s->nb_streams; i++) {
659  AVStream *const st2 = s->streams[i];
660  FFStream *const sti2 = ffstream(st2);
661  sti2->mux_ts_offset = av_rescale_q_rnd(-ts, tb,
662  st2->time_base,
663  AV_ROUND_UP);
664  }
665  }
666  si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_KNOWN;
667  }
668 
669  offset = sti->mux_ts_offset;
670 
671  if (pkt->dts != AV_NOPTS_VALUE)
672  pkt->dts += offset;
673  if (pkt->pts != AV_NOPTS_VALUE)
674  pkt->pts += offset;
675 
676  if (si->avoid_negative_ts_use_pts) {
677  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < sti->lowest_ts_allowed) {
678  av_log(s, AV_LOG_WARNING, "failed to avoid negative "
679  "pts %s in stream %d.\n"
680  "Try -avoid_negative_ts 1 as a possible workaround.\n",
681  av_ts2str(pkt->pts),
683  );
684  }
685  } else {
686  if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < sti->lowest_ts_allowed) {
688  "Packets poorly interleaved, failed to avoid negative "
689  "timestamp %s in stream %d.\n"
690  "Try -max_interleave_delta 0 as a possible workaround.\n",
691  av_ts2str(pkt->dts),
693  );
694  }
695  }
696 }
697 
698 /**
699  * Shift timestamps and call muxer; the original pts/dts are not kept.
700  *
701  * FIXME: this function should NEVER get undefined pts/dts beside when the
702  * AVFMT_NOTIMESTAMPS is set.
703  * Those additional safety checks should be dropped once the correct checks
704  * are set in the callers.
705  */
707 {
708  FFFormatContext *const si = ffformatcontext(s);
709  AVStream *const st = s->streams[pkt->stream_index];
710  FFStream *const sti = ffstream(st);
711  int ret;
712 
713  // If the timestamp offsetting below is adjusted, adjust
714  // ff_interleaved_peek similarly.
715  if (s->output_ts_offset) {
716  int64_t offset = av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
717 
718  if (pkt->dts != AV_NOPTS_VALUE)
719  pkt->dts += offset;
720  if (pkt->pts != AV_NOPTS_VALUE)
721  pkt->pts += offset;
722  }
723  handle_avoid_negative_ts(si, sti, pkt);
724 
726  AVFrame **frame = (AVFrame **)pkt->data;
727  av_assert0(pkt->size == sizeof(*frame));
728  ret = ffofmt(s->oformat)->write_uncoded_frame(s, pkt->stream_index, frame, 0);
729  } else {
730  ret = ffofmt(s->oformat)->write_packet(s, pkt);
731  }
732 
733  if (s->pb && ret >= 0) {
735  if (s->pb->error < 0)
736  ret = s->pb->error;
737  }
738 
739  if (ret >= 0)
740  st->nb_frames++;
741 
742  return ret;
743 }
744 
746 {
747  if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
748  av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
749  pkt->stream_index);
750  return AVERROR(EINVAL);
751  }
752 
753  if (s->streams[pkt->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
754  av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
755  return AVERROR(EINVAL);
756  }
757 
758  return 0;
759 }
760 
762 {
763  FFStream *const sti = ffstream(st);
764 #if !FF_API_COMPUTE_PKT_FIELDS2
765  /* sanitize the timestamps */
766  if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
767 
768  /* when there is no reordering (so dts is equal to pts), but
769  * only one of them is set, set the other as well */
770  if (!sti->reorder) {
771  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)
772  pkt->pts = pkt->dts;
773  if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
774  pkt->dts = pkt->pts;
775  }
776 
777  /* check that the timestamps are set */
778  if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {
780  "Timestamps are unset in a packet for stream %d\n", st->index);
781  return AVERROR(EINVAL);
782  }
783 
784  /* check that the dts are increasing (or at least non-decreasing,
785  * if the format allows it */
786  if (sti->cur_dts != AV_NOPTS_VALUE &&
787  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && sti->cur_dts >= pkt->dts) ||
788  sti->cur_dts > pkt->dts)) {
790  "Application provided invalid, non monotonically increasing "
791  "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
792  st->index, sti->cur_dts, pkt->dts);
793  return AVERROR(EINVAL);
794  }
795 
796  if (pkt->pts < pkt->dts) {
797  av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
798  pkt->pts, pkt->dts, st->index);
799  return AVERROR(EINVAL);
800  }
801  }
802 #endif
803  /* update flags */
804  if (sti->is_intra_only)
806 
807  if (!pkt->data && !pkt->side_data_elems) {
808  /* Such empty packets signal EOS for the BSF API; so sanitize
809  * the packet by allocating data of size 0 (+ padding). */
812  }
813 
814  return 0;
815 }
816 
817 #define CHUNK_START 0x1000
818 
820  int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
821 {
822  int ret;
823  FFFormatContext *const si = ffformatcontext(s);
824  PacketListEntry **next_point, *this_pktl;
825  AVStream *st = s->streams[pkt->stream_index];
826  FFStream *const sti = ffstream(st);
827  int chunked = s->max_chunk_size || s->max_chunk_duration;
828 
829  this_pktl = av_malloc(sizeof(*this_pktl));
830  if (!this_pktl) {
832  return AVERROR(ENOMEM);
833  }
834  if ((ret = av_packet_make_refcounted(pkt)) < 0) {
835  av_free(this_pktl);
837  return ret;
838  }
839 
840  av_packet_move_ref(&this_pktl->pkt, pkt);
841  pkt = &this_pktl->pkt;
842 
843  if (sti->last_in_packet_buffer) {
844  next_point = &(sti->last_in_packet_buffer->next);
845  } else {
846  next_point = &si->packet_buffer.head;
847  }
848 
849  if (chunked) {
850  uint64_t max= av_rescale_q_rnd(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base, AV_ROUND_UP);
853  if ( (s->max_chunk_size && sti->interleaver_chunk_size > s->max_chunk_size)
854  || (max && sti->interleaver_chunk_duration > max)) {
855  sti->interleaver_chunk_size = 0;
856  pkt->flags |= CHUNK_START;
857  if (max && sti->interleaver_chunk_duration > max) {
858  int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
859  int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
860 
861  sti->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
862  } else
864  }
865  }
866  if (*next_point) {
867  if (chunked && !(pkt->flags & CHUNK_START))
868  goto next_non_null;
869 
870  if (compare(s, &si->packet_buffer.tail->pkt, pkt)) {
871  while ( *next_point
872  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
873  || !compare(s, &(*next_point)->pkt, pkt)))
874  next_point = &(*next_point)->next;
875  if (*next_point)
876  goto next_non_null;
877  } else {
878  next_point = &(si->packet_buffer.tail->next);
879  }
880  }
881  av_assert1(!*next_point);
882 
883  si->packet_buffer.tail = this_pktl;
884 next_non_null:
885 
886  this_pktl->next = *next_point;
887 
888  sti->last_in_packet_buffer = *next_point = this_pktl;
889 
890  return 0;
891 }
892 
894  const AVPacket *pkt)
895 {
896  AVStream *st = s->streams[pkt->stream_index];
897  AVStream *st2 = s->streams[next->stream_index];
898  int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
899  st->time_base);
900  if (s->audio_preload) {
901  int preload = st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
902  int preload2 = st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
903  if (preload != preload2) {
904  int64_t ts, ts2;
905  preload *= s->audio_preload;
906  preload2 *= s->audio_preload;
907  ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - preload;
908  ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - preload2;
909  if (ts == ts2) {
910  ts = ((uint64_t)pkt ->dts*st ->time_base.num*AV_TIME_BASE - (uint64_t)preload *st ->time_base.den)*st2->time_base.den
911  - ((uint64_t)next->dts*st2->time_base.num*AV_TIME_BASE - (uint64_t)preload2*st2->time_base.den)*st ->time_base.den;
912  ts2 = 0;
913  }
914  comp = (ts2 > ts) - (ts2 < ts);
915  }
916  }
917 
918  if (comp == 0)
919  return pkt->stream_index < next->stream_index;
920  return comp > 0;
921 }
922 
924  int flush, int has_packet)
925 {
926  FFFormatContext *const si = ffformatcontext(s);
927  int stream_count = 0;
928  int noninterleaved_count = 0;
929  int ret;
930  int eof = flush;
931 
932  if (has_packet) {
934  return ret;
935  }
936 
937  for (unsigned i = 0; i < s->nb_streams; i++) {
938  const AVStream *const st = s->streams[i];
939  const FFStream *const sti = cffstream(st);
940  const AVCodecParameters *const par = st->codecpar;
941  if (sti->last_in_packet_buffer) {
942  ++stream_count;
943  } else if (par->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
944  par->codec_id != AV_CODEC_ID_VP8 &&
945  par->codec_id != AV_CODEC_ID_VP9) {
946  ++noninterleaved_count;
947  }
948  }
949 
950  if (si->nb_interleaved_streams == stream_count)
951  flush = 1;
952 
953  if (s->max_interleave_delta > 0 &&
954  si->packet_buffer.head &&
956  !flush &&
957  si->nb_interleaved_streams == stream_count+noninterleaved_count
958  ) {
959  AVPacket *const top_pkt = &si->packet_buffer.head->pkt;
960  int64_t delta_dts = INT64_MIN;
961  int64_t top_dts = av_rescale_q(top_pkt->dts,
962  s->streams[top_pkt->stream_index]->time_base,
964 
965  for (unsigned i = 0; i < s->nb_streams; i++) {
966  const AVStream *const st = s->streams[i];
967  const FFStream *const sti = cffstream(st);
968  const PacketListEntry *const last = sti->last_in_packet_buffer;
969  int64_t last_dts;
970 
971  if (!last)
972  continue;
973 
974  last_dts = av_rescale_q(last->pkt.dts,
975  st->time_base,
977  delta_dts = FFMAX(delta_dts, last_dts - top_dts);
978  }
979 
980  if (delta_dts > s->max_interleave_delta) {
982  "Delay between the first packet and last packet in the "
983  "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
984  delta_dts, s->max_interleave_delta);
985  flush = 1;
986  }
987  }
988 
989  if (si->packet_buffer.head &&
990  eof &&
991  (s->flags & AVFMT_FLAG_SHORTEST) &&
992  si->shortest_end == AV_NOPTS_VALUE) {
993  AVPacket *const top_pkt = &si->packet_buffer.head->pkt;
994 
995  si->shortest_end = av_rescale_q(top_pkt->dts,
996  s->streams[top_pkt->stream_index]->time_base,
998  }
999 
1000  if (si->shortest_end != AV_NOPTS_VALUE) {
1001  while (si->packet_buffer.head) {
1002  PacketListEntry *pktl = si->packet_buffer.head;
1003  AVPacket *const top_pkt = &pktl->pkt;
1004  AVStream *const st = s->streams[top_pkt->stream_index];
1005  FFStream *const sti = ffstream(st);
1006  int64_t top_dts = av_rescale_q(top_pkt->dts, st->time_base,
1007  AV_TIME_BASE_Q);
1008 
1009  if (si->shortest_end + 1 >= top_dts)
1010  break;
1011 
1012  si->packet_buffer.head = pktl->next;
1013  if (!si->packet_buffer.head)
1014  si->packet_buffer.tail = NULL;
1015 
1016  if (sti->last_in_packet_buffer == pktl)
1017  sti->last_in_packet_buffer = NULL;
1018 
1019  av_packet_unref(&pktl->pkt);
1020  av_freep(&pktl);
1021  flush = 0;
1022  }
1023  }
1024 
1025  if (stream_count && flush) {
1026  PacketListEntry *pktl = si->packet_buffer.head;
1027  AVStream *const st = s->streams[pktl->pkt.stream_index];
1028  FFStream *const sti = ffstream(st);
1029 
1030  if (sti->last_in_packet_buffer == pktl)
1031  sti->last_in_packet_buffer = NULL;
1033 
1034  return 1;
1035  } else {
1036  return 0;
1037  }
1038 }
1039 
1041  int flush, int has_packet)
1042 {
1043  return has_packet;
1044 }
1045 
1046 int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
1047 {
1048  AVStream *st;
1049 
1050  if (stream_index < 0 || stream_index >= s->nb_streams)
1051  return AVERROR(EINVAL);
1052 
1053  st = s->streams[stream_index];
1054  *offset = ffstream(st)->mux_ts_offset;
1055 
1056  if (s->output_ts_offset)
1057  *offset += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
1058 
1059  return 0;
1060 }
1061 
1063 {
1064  FFFormatContext *const si = ffformatcontext(s);
1065  PacketListEntry *pktl = si->packet_buffer.head;
1066  while (pktl) {
1067  if (pktl->pkt.stream_index == stream) {
1068  return &pktl->pkt;
1069  }
1070  pktl = pktl->next;
1071  }
1072  return NULL;
1073 }
1074 
1076 {
1077  int ret;
1078 
1079  if (!(s->flags & AVFMT_FLAG_AUTO_BSF))
1080  return 1;
1081 
1082  if (ffofmt(s->oformat)->check_bitstream) {
1083  if (!sti->bitstream_checked) {
1084  if ((ret = ffofmt(s->oformat)->check_bitstream(s, &sti->pub, pkt)) < 0)
1085  return ret;
1086  else if (ret == 1)
1087  sti->bitstream_checked = 1;
1088  }
1089  }
1090 
1091  return 1;
1092 }
1093 
1095  int flush, int has_packet)
1096 {
1097  FFFormatContext *const si = ffformatcontext(s);
1098  for (;; ) {
1099  int ret = si->interleave_packet(s, pkt, flush, has_packet);
1100  if (ret <= 0)
1101  return ret;
1102 
1103  has_packet = 0;
1104 
1105  ret = write_packet(s, pkt);
1107  if (ret < 0)
1108  return ret;
1109  }
1110 }
1111 
1112 static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1113 {
1114  int ret;
1115 
1116  if (s->debug & FF_FDEBUG_TS)
1117  av_log(s, AV_LOG_DEBUG, "%s size:%d dts:%s pts:%s\n", __FUNCTION__,
1119 
1120  guess_pkt_duration(s, st, pkt);
1121 
1122 #if FF_API_COMPUTE_PKT_FIELDS2
1123  if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1124  return ret;
1125 #endif
1126 
1127  if (interleaved) {
1128  if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1129  return AVERROR(EINVAL);
1130  return interleaved_write_packet(s, pkt, 0, 1);
1131  } else {
1132  return write_packet(s, pkt);
1133  }
1134 }
1135 
1136 static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1137 {
1138  FFStream *const sti = ffstream(st);
1139  AVBSFContext *const bsfc = sti->bsfc;
1140  int ret;
1141 
1142  if ((ret = av_bsf_send_packet(bsfc, pkt)) < 0) {
1144  "Failed to send packet to filter %s for stream %d\n",
1145  bsfc->filter->name, st->index);
1146  return ret;
1147  }
1148 
1149  do {
1150  ret = av_bsf_receive_packet(bsfc, pkt);
1151  if (ret < 0) {
1152  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
1153  return 0;
1154  av_log(s, AV_LOG_ERROR, "Error applying bitstream filters to an output "
1155  "packet for stream #%d: %s\n", st->index, av_err2str(ret));
1156  if (!(s->error_recognition & AV_EF_EXPLODE) && ret != AVERROR(ENOMEM))
1157  continue;
1158  return ret;
1159  }
1161  ret = write_packet_common(s, st, pkt, interleaved);
1162  if (ret >= 0 && !interleaved) // a successful write_packet_common already unrefed pkt for interleaved
1164  } while (ret >= 0);
1165 
1166  return ret;
1167 }
1168 
1169 static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
1170 {
1171  AVStream *st;
1172  FFStream *sti;
1173  int ret = check_packet(s, pkt);
1174  if (ret < 0)
1175  return ret;
1176  st = s->streams[pkt->stream_index];
1177  sti = ffstream(st);
1178 
1179  ret = prepare_input_packet(s, st, pkt);
1180  if (ret < 0)
1181  return ret;
1182 
1183  ret = check_bitstream(s, sti, pkt);
1184  if (ret < 0)
1185  return ret;
1186 
1187  if (sti->bsfc) {
1188  return write_packets_from_bsfs(s, st, pkt, interleaved);
1189  } else {
1190  return write_packet_common(s, st, pkt, interleaved);
1191  }
1192 }
1193 
1195 {
1196  FFFormatContext *const si = ffformatcontext(s);
1197  AVPacket *pkt = si->parse_pkt;
1198  int ret;
1199 
1200  if (!in) {
1201  if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
1202  ret = ffofmt(s->oformat)->write_packet(s, NULL);
1203  flush_if_needed(s);
1204  if (ret >= 0 && s->pb && s->pb->error < 0)
1205  ret = s->pb->error;
1206  return ret;
1207  }
1208  return 1;
1209  }
1210 
1211  if (in->flags & AV_PKT_FLAG_UNCODED_FRAME) {
1212  pkt = in;
1213  } else {
1214  /* We don't own in, so we have to make sure not to modify it.
1215  * (ff_write_chained() relies on this fact.)
1216  * The following avoids copying in's data unnecessarily.
1217  * Copying side data is unavoidable as a bitstream filter
1218  * may change it, e.g. free it on errors. */
1219  pkt->data = in->data;
1220  pkt->size = in->size;
1221  ret = av_packet_copy_props(pkt, in);
1222  if (ret < 0)
1223  return ret;
1224  if (in->buf) {
1225  pkt->buf = av_buffer_ref(in->buf);
1226  if (!pkt->buf) {
1227  ret = AVERROR(ENOMEM);
1228  goto fail;
1229  }
1230  }
1231  }
1232 
1233  ret = write_packets_common(s, pkt, 0/*non-interleaved*/);
1234 
1235 fail:
1236  // Uncoded frames using the noninterleaved codepath are also freed here
1238  return ret;
1239 }
1240 
1242 {
1243  int ret;
1244 
1245  if (pkt) {
1246  ret = write_packets_common(s, pkt, 1/*interleaved*/);
1247  if (ret < 0)
1249  return ret;
1250  } else {
1251  av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");
1252  return interleaved_write_packet(s, ffformatcontext(s)->parse_pkt, 1/*flush*/, 0);
1253  }
1254 }
1255 
1257 {
1258  FFFormatContext *const si = ffformatcontext(s);
1259  AVPacket *const pkt = si->parse_pkt;
1260  int ret1, ret = 0;
1261 
1262  for (unsigned i = 0; i < s->nb_streams; i++) {
1263  AVStream *const st = s->streams[i];
1264  FFStream *const sti = ffstream(st);
1265  if (sti->bsfc) {
1266  ret1 = write_packets_from_bsfs(s, st, pkt, 1/*interleaved*/);
1267  if (ret1 < 0)
1269  if (ret >= 0)
1270  ret = ret1;
1271  }
1272  }
1273  ret1 = interleaved_write_packet(s, pkt, 1, 0);
1274  if (ret >= 0)
1275  ret = ret1;
1276 
1277  if (ffofmt(s->oformat)->write_trailer) {
1278  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1280  ret1 = ffofmt(s->oformat)->write_trailer(s);
1281  if (ret >= 0)
1282  ret = ret1;
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  const FFOutputFormat *const of = ffofmt(s->oformat);
1306  if (!of || !of->get_output_timestamp)
1307  return AVERROR(ENOSYS);
1308  of->get_output_timestamp(s, stream, dts, wall);
1309  return 0;
1310 }
1311 
1312 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
1313 {
1314  int ret;
1315  const AVBitStreamFilter *bsf;
1316  FFStream *const sti = ffstream(st);
1317  AVBSFContext *bsfc;
1318 
1319  av_assert0(!sti->bsfc);
1320 
1321  if (!(bsf = av_bsf_get_by_name(name))) {
1322  av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
1323  return AVERROR_BSF_NOT_FOUND;
1324  }
1325 
1326  if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
1327  return ret;
1328 
1329  bsfc->time_base_in = st->time_base;
1330  if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
1331  av_bsf_free(&bsfc);
1332  return ret;
1333  }
1334 
1335  if (args && bsfc->filter->priv_class) {
1336  if ((ret = av_set_options_string(bsfc->priv_data, args, "=", ":")) < 0) {
1337  av_bsf_free(&bsfc);
1338  return ret;
1339  }
1340  }
1341 
1342  if ((ret = av_bsf_init(bsfc)) < 0) {
1343  av_bsf_free(&bsfc);
1344  return ret;
1345  }
1346 
1347  sti->bsfc = bsfc;
1348 
1350  "Automatically inserted bitstream filter '%s'; args='%s'\n",
1351  name, args ? args : "");
1352  return 1;
1353 }
1354 
1355 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
1357 {
1358  int64_t pts = pkt->pts, dts = pkt->dts, duration = pkt->duration;
1359  int stream_index = pkt->stream_index;
1360  AVRational time_base = pkt->time_base;
1361  int ret;
1362 
1363  pkt->stream_index = dst_stream;
1364 
1366  src->streams[stream_index]->time_base,
1367  dst->streams[dst_stream]->time_base);
1368 
1369  if (!interleave) {
1370  ret = av_write_frame(dst, pkt);
1371  /* We only have to backup and restore the fields that
1372  * we changed ourselves, because av_write_frame() does not
1373  * modify the packet given to it. */
1374  pkt->pts = pts;
1375  pkt->dts = dts;
1376  pkt->duration = duration;
1377  pkt->stream_index = stream_index;
1378  pkt->time_base = time_base;
1379  } else
1381 
1382  return ret;
1383 }
1384 
1385 static void uncoded_frame_free(void *unused, uint8_t *data)
1386 {
1387  av_frame_free((AVFrame **)data);
1388  av_free(data);
1389 }
1390 
1391 static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
1392  AVFrame *frame, int interleaved)
1393 {
1394  FFFormatContext *const si = ffformatcontext(s);
1395  AVPacket *pkt = si->parse_pkt;
1396 
1397  av_assert0(s->oformat);
1398  if (!ffofmt(s->oformat)->write_uncoded_frame) {
1399  av_frame_free(&frame);
1400  return AVERROR(ENOSYS);
1401  }
1402 
1403  if (!frame) {
1404  pkt = NULL;
1405  } else {
1406  size_t bufsize = sizeof(frame) + AV_INPUT_BUFFER_PADDING_SIZE;
1407  AVFrame **framep = av_mallocz(bufsize);
1408 
1409  if (!framep)
1410  goto fail;
1411  pkt->buf = av_buffer_create((void *)framep, bufsize,
1412  uncoded_frame_free, NULL, 0);
1413  if (!pkt->buf) {
1414  av_free(framep);
1415  fail:
1416  av_frame_free(&frame);
1417  return AVERROR(ENOMEM);
1418  }
1419  *framep = frame;
1420 
1421  pkt->data = (void *)framep;
1422  pkt->size = sizeof(frame);
1423  pkt->pts =
1424  pkt->dts = frame->pts;
1425 #if FF_API_PKT_DURATION
1427  if (frame->pkt_duration)
1428  pkt->duration = frame->pkt_duration;
1429  else
1431 #endif
1432  pkt->duration = frame->duration;
1433  pkt->stream_index = stream_index;
1435  }
1436 
1437  return interleaved ? av_interleaved_write_frame(s, pkt) :
1438  av_write_frame(s, pkt);
1439 }
1440 
1442  AVFrame *frame)
1443 {
1444  return write_uncoded_frame_internal(s, stream_index, frame, 0);
1445 }
1446 
1448  AVFrame *frame)
1449 {
1450  return write_uncoded_frame_internal(s, stream_index, frame, 1);
1451 }
1452 
1454 {
1455  const FFOutputFormat *const of = ffofmt(s->oformat);
1456  av_assert0(of);
1457  if (!of->write_uncoded_frame)
1458  return AVERROR(ENOSYS);
1459  return of->write_uncoded_frame(s, stream_index, NULL,
1461 }
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:493
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:893
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:2199
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:483
FF_FDEBUG_TS
#define FF_FDEBUG_TS
Definition: avformat.h:1374
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:761
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:769
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:479
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:1075
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:99
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
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:1172
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:1441
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:927
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:1242
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:1453
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:430
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
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:34
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:482
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:771
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:1243
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:1437
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:774
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:923
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:579
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:706
AVCodecTag
Definition: internal.h:49
write_packet_common
static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1112
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:1094
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:487
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:2205
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:817
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ffofmt
static const FFOutputFormat * ffofmt(const AVOutputFormat *fmt)
Definition: mux.h:136
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:533
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:1447
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:1062
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:451
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:244
AVFormatContext
Format I/O context.
Definition: avformat.h:1104
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:861
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:1435
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:877
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:819
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
FFOutputFormat::write_packet
int(* write_packet)(AVFormatContext *, AVPacket *pkt)
Write a packet.
Definition: mux.h:53
FFOutputFormat::deinit
void(* deinit)(AVFormatContext *)
Deinitialize format.
Definition: mux.h:123
ff_get_muxer_ts_offset
int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
Definition: mux.c:1046
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
FFOutputFormat
Definition: mux.h:30
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:536
av_write_frame
int av_write_frame(AVFormatContext *s, AVPacket *in)
Write a packet to an output media file.
Definition: mux.c:1194
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:1355
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:899
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:1169
AVOutputFormat::flags
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:527
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
FFOutputFormat::write_uncoded_frame
int(* write_uncoded_frame)(AVFormatContext *, int stream_index, AVFrame **frame, unsigned flags)
Write an uncoded AVFrame.
Definition: mux.h:98
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
FFOutputFormat::check_bitstream
int(* check_bitstream)(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
Set up any necessary bitstream filtering and extract any extra data needed for the global header.
Definition: mux.h:132
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:488
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:833
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:468
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:916
AVFMT_NOSTREAMS
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:484
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
FFOutputFormat::interleave_packet
int(* interleave_packet)(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
A format-specific function for interleavement.
Definition: mux.h:71
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
FFOutputFormat::priv_data_size
int priv_data_size
size of private data so that it can be allocated in the wrapper
Definition: mux.h:38
FFOutputFormat::write_header
int(* write_header)(AVFormatContext *)
Definition: mux.h:45
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:1256
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:835
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:507
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:1436
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:254
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:492
MAX_REORDER_DELAY
@ MAX_REORDER_DELAY
Definition: vaapi_encode.h:45
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:489
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:907
FFOutputFormat::get_output_timestamp
void(* get_output_timestamp)(AVFormatContext *s, int stream, int64_t *dts, int64_t *wall)
Definition: mux.h:82
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:1239
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:838
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
check_packet
static int check_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:745
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:844
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:1391
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:1312
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:96
AV_WRITE_UNCODED_FRAME_QUERY
@ AV_WRITE_UNCODED_FRAME_QUERY
Query whether the feature is possible on this stream.
Definition: mux.h:208
guess_pkt_duration
static FF_ENABLE_DEPRECATION_WARNINGS void guess_pkt_duration(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:589
AVSTREAM_INIT_IN_INIT_OUTPUT
#define AVSTREAM_INIT_IN_INIT_OUTPUT
stream parameters initialized in avformat_init_output
Definition: avformat.h:2200
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:1040
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:270
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:367
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:1136
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:1241
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:1385
FFStream::cur_dts
int64_t cur_dts
Definition: internal.h:410
FFOutputFormat::write_trailer
int(* write_trailer)(AVFormatContext *)
Definition: mux.h:54
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:1232
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
FFOutputFormat::init
int(* init)(AVFormatContext *)
Initialize format.
Definition: mux.h:114
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3657
AVFMT_AVOID_NEG_TS_AUTO
#define AVFMT_AVOID_NEG_TS_AUTO
Enabled when required by target format.
Definition: avformat.h:1434
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
FFFormatContext::avoid_negative_ts_status
enum FFFormatContext::@282 avoid_negative_ts_status
Whether the timestamp shift offset has already been determined.
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:620
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:83
mux.h
FFFormatContext::avoid_negative_ts_use_pts
int avoid_negative_ts_use_pts
Definition: internal.h:153