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 "avio_internal.h"
24 #include "internal.h"
25 #include "libavcodec/internal.h"
26 #include "libavcodec/bytestream.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/pixdesc.h"
30 #include "libavutil/timestamp.h"
31 #include "metadata.h"
32 #include "id3v2.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/internal.h"
36 #include "libavutil/mathematics.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/time.h"
39 #include "riff.h"
40 #include "audiointerleave.h"
41 #include "url.h"
42 #include <stdarg.h>
43 #if CONFIG_NETWORK
44 #include "network.h"
45 #endif
46 
47 /**
48  * @file
49  * muxing functions for use within libavformat
50  */
51 
52 /* fraction handling */
53 
54 /**
55  * f = val + (num / den) + 0.5.
56  *
57  * 'num' is normalized so that it is such as 0 <= num < den.
58  *
59  * @param f fractional number
60  * @param val integer value
61  * @param num must be >= 0
62  * @param den must be >= 1
63  */
64 static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
65 {
66  num += (den >> 1);
67  if (num >= den) {
68  val += num / den;
69  num = num % den;
70  }
71  f->val = val;
72  f->num = num;
73  f->den = den;
74 }
75 
76 /**
77  * Fractional addition to f: f = f + (incr / f->den).
78  *
79  * @param f fractional number
80  * @param incr increment, can be positive or negative
81  */
82 static void frac_add(FFFrac *f, int64_t incr)
83 {
84  int64_t num, den;
85 
86  num = f->num + incr;
87  den = f->den;
88  if (num < 0) {
89  f->val += num / den;
90  num = num % den;
91  if (num < 0) {
92  num += den;
93  f->val--;
94  }
95  } else if (num >= den) {
96  f->val += num / den;
97  num = num % den;
98  }
99  f->num = num;
100 }
101 
103 {
104  AVRational q;
105  int j;
106 
107  q = st->time_base;
108 
109  for (j=2; j<14; j+= 1+(j>2))
110  while (q.den / q.num < min_precision && q.num % j == 0)
111  q.num /= j;
112  while (q.den / q.num < min_precision && q.den < (1<<24))
113  q.den <<= 1;
114 
115  return q;
116 }
117 
119 {
120  AVCodecParameters *par = st->codecpar;
121  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(par->format);
122 
124  return par->chroma_location;
125 
126  if (pix_desc) {
127  if (pix_desc->log2_chroma_h == 0) {
128  return AVCHROMA_LOC_TOPLEFT;
129  } else if (pix_desc->log2_chroma_w == 1 && pix_desc->log2_chroma_h == 1) {
131  switch (par->codec_id) {
132  case AV_CODEC_ID_MJPEG:
134  }
135  }
137  switch (par->codec_id) {
139  }
140  }
141  }
142  }
143 
145 
146 }
147 
149  const char *format, const char *filename)
150 {
152  int ret = 0;
153 
154  *avctx = NULL;
155  if (!s)
156  goto nomem;
157 
158  if (!oformat) {
159  if (format) {
160  oformat = av_guess_format(format, NULL, NULL);
161  if (!oformat) {
162  av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
163  ret = AVERROR(EINVAL);
164  goto error;
165  }
166  } else {
167  oformat = av_guess_format(NULL, filename, NULL);
168  if (!oformat) {
169  ret = AVERROR(EINVAL);
170  av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
171  filename);
172  goto error;
173  }
174  }
175  }
176 
177  s->oformat = oformat;
178  if (s->oformat->priv_data_size > 0) {
180  if (!s->priv_data)
181  goto nomem;
182  if (s->oformat->priv_class) {
183  *(const AVClass**)s->priv_data= s->oformat->priv_class;
185  }
186  } else
187  s->priv_data = NULL;
188 
189  if (filename) {
190 #if FF_API_FORMAT_FILENAME
192  av_strlcpy(s->filename, filename, sizeof(s->filename));
194 #endif
195  if (!(s->url = av_strdup(filename)))
196  goto nomem;
197 
198  }
199  *avctx = s;
200  return 0;
201 nomem:
202  av_log(s, AV_LOG_ERROR, "Out of memory\n");
203  ret = AVERROR(ENOMEM);
204 error:
206  return ret;
207 }
208 
210 {
211  const AVCodecTag *avctag;
212  int n;
213  enum AVCodecID id = AV_CODEC_ID_NONE;
214  int64_t tag = -1;
215 
216  /**
217  * Check that tag + id is in the table
218  * If neither is in the table -> OK
219  * If tag is in the table with another id -> FAIL
220  * If id is in the table with another tag -> FAIL unless strict < normal
221  */
222  for (n = 0; s->oformat->codec_tag[n]; n++) {
223  avctag = s->oformat->codec_tag[n];
224  while (avctag->id != AV_CODEC_ID_NONE) {
225  if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codecpar->codec_tag)) {
226  id = avctag->id;
227  if (id == st->codecpar->codec_id)
228  return 1;
229  }
230  if (avctag->id == st->codecpar->codec_id)
231  tag = avctag->tag;
232  avctag++;
233  }
234  }
235  if (id != AV_CODEC_ID_NONE)
236  return 0;
237  if (tag >= 0 && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
238  return 0;
239  return 1;
240 }
241 
242 
244 {
245  int ret = 0, i;
246  AVStream *st;
247  AVDictionary *tmp = NULL;
248  AVCodecParameters *par = NULL;
249  const AVOutputFormat *of = s->oformat;
250  const AVCodecDescriptor *desc;
252 
253  if (options)
254  av_dict_copy(&tmp, *options, 0);
255 
256  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
257  goto fail;
258  if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
259  (ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
260  goto fail;
261 
262 #if FF_API_FORMAT_FILENAME
264  if (!s->url && !(s->url = av_strdup(s->filename))) {
266 #else
267  if (!s->url && !(s->url = av_strdup(""))) {
268 #endif
269  ret = AVERROR(ENOMEM);
270  goto fail;
271  }
272 
273 #if FF_API_LAVF_AVCTX
275  if (s->nb_streams && s->streams[0]->codec->flags & AV_CODEC_FLAG_BITEXACT) {
276  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
278  "The AVFormatContext is not in set to bitexact mode, only "
279  "the AVCodecContext. If this is not intended, set "
280  "AVFormatContext.flags |= AVFMT_FLAG_BITEXACT.\n");
281  }
282  }
284 #endif
285 
286  // some sanity checks
287  if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) {
288  av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");
289  ret = AVERROR(EINVAL);
290  goto fail;
291  }
292 
293  for (i = 0; i < s->nb_streams; i++) {
294  st = s->streams[i];
295  par = st->codecpar;
296 
297 #if FF_API_LAVF_AVCTX
300  st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN) {
301  av_log(s, AV_LOG_WARNING, "Using AVStream.codec to pass codec "
302  "parameters to muxers is deprecated, use AVStream.codecpar "
303  "instead.\n");
304  ret = avcodec_parameters_from_context(st->codecpar, st->codec);
305  if (ret < 0)
306  goto fail;
307  }
309 #endif
310 
311  if (!st->time_base.num) {
312  /* fall back on the default timebase values */
313  if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)
314  avpriv_set_pts_info(st, 64, 1, par->sample_rate);
315  else
316  avpriv_set_pts_info(st, 33, 1, 90000);
317  }
318 
319  switch (par->codec_type) {
320  case AVMEDIA_TYPE_AUDIO:
321  if (par->sample_rate <= 0) {
322  av_log(s, AV_LOG_ERROR, "sample rate not set\n");
323  ret = AVERROR(EINVAL);
324  goto fail;
325  }
326  if (!par->block_align)
327  par->block_align = par->channels *
328  av_get_bits_per_sample(par->codec_id) >> 3;
329  break;
330  case AVMEDIA_TYPE_VIDEO:
331  if ((par->width <= 0 || par->height <= 0) &&
332  !(of->flags & AVFMT_NODIMENSIONS)) {
333  av_log(s, AV_LOG_ERROR, "dimensions not set\n");
334  ret = AVERROR(EINVAL);
335  goto fail;
336  }
339  ) {
340  if (st->sample_aspect_ratio.num != 0 &&
341  st->sample_aspect_ratio.den != 0 &&
342  par->sample_aspect_ratio.num != 0 &&
343  par->sample_aspect_ratio.den != 0) {
344  av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
345  "(%d/%d) and encoder layer (%d/%d)\n",
348  par->sample_aspect_ratio.den);
349  ret = AVERROR(EINVAL);
350  goto fail;
351  }
352  }
353  break;
354  }
355 
356  desc = avcodec_descriptor_get(par->codec_id);
357  if (desc && desc->props & AV_CODEC_PROP_REORDER)
358  st->internal->reorder = 1;
359 
360  if (of->codec_tag) {
361  if ( par->codec_tag
362  && par->codec_id == AV_CODEC_ID_RAWVIDEO
363  && ( av_codec_get_tag(of->codec_tag, par->codec_id) == 0
364  || av_codec_get_tag(of->codec_tag, par->codec_id) == MKTAG('r', 'a', 'w', ' '))
365  && !validate_codec_tag(s, st)) {
366  // the current rawvideo encoding system ends up setting
367  // the wrong codec_tag for avi/mov, we override it here
368  par->codec_tag = 0;
369  }
370  if (par->codec_tag) {
371  if (!validate_codec_tag(s, st)) {
372  const uint32_t otag = av_codec_get_tag(s->oformat->codec_tag, par->codec_id);
373  av_log(s, AV_LOG_ERROR,
374  "Tag %s incompatible with output codec id '%d' (%s)\n",
375  av_fourcc2str(par->codec_tag), par->codec_id, av_fourcc2str(otag));
376  ret = AVERROR_INVALIDDATA;
377  goto fail;
378  }
379  } else
380  par->codec_tag = av_codec_get_tag(of->codec_tag, par->codec_id);
381  }
382 
385  }
386 
387  if (!s->priv_data && of->priv_data_size > 0) {
389  if (!s->priv_data) {
390  ret = AVERROR(ENOMEM);
391  goto fail;
392  }
393  if (of->priv_class) {
394  *(const AVClass **)s->priv_data = of->priv_class;
396  if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
397  goto fail;
398  }
399  }
400 
401  /* set muxer identification string */
402  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
403  av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
404  } else {
405  av_dict_set(&s->metadata, "encoder", NULL, 0);
406  }
407 
408  for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {
409  av_dict_set(&s->metadata, e->key, NULL, 0);
410  }
411 
412  if (options) {
413  av_dict_free(options);
414  *options = tmp;
415  }
416 
417  if (s->oformat->init) {
418  if ((ret = s->oformat->init(s)) < 0) {
419  if (s->oformat->deinit)
420  s->oformat->deinit(s);
421  return ret;
422  }
423  return ret == 0;
424  }
425 
426  return 0;
427 
428 fail:
429  av_dict_free(&tmp);
430  return ret;
431 }
432 
433 static int init_pts(AVFormatContext *s)
434 {
435  int i;
436  AVStream *st;
437 
438  /* init PTS generation */
439  for (i = 0; i < s->nb_streams; i++) {
440  int64_t den = AV_NOPTS_VALUE;
441  st = s->streams[i];
442 
443  switch (st->codecpar->codec_type) {
444  case AVMEDIA_TYPE_AUDIO:
445  den = (int64_t)st->time_base.num * st->codecpar->sample_rate;
446  break;
447  case AVMEDIA_TYPE_VIDEO:
448  den = (int64_t)st->time_base.num * st->time_base.den;
449  break;
450  default:
451  break;
452  }
453 
454  if (!st->internal->priv_pts)
455  st->internal->priv_pts = av_mallocz(sizeof(*st->internal->priv_pts));
456  if (!st->internal->priv_pts)
457  return AVERROR(ENOMEM);
458 
459  if (den != AV_NOPTS_VALUE) {
460  if (den <= 0)
461  return AVERROR_INVALIDDATA;
462 
463  frac_init(st->internal->priv_pts, 0, 0, den);
464  }
465  }
466 
467  if (s->avoid_negative_ts < 0) {
470  s->avoid_negative_ts = 0;
471  } else
473  }
474 
475  return 0;
476 }
477 
479 {
480  if (s->pb && s->pb->error >= 0) {
481  if (s->flush_packets == 1 || s->flags & AVFMT_FLAG_FLUSH_PACKETS)
482  avio_flush(s->pb);
483  else if (s->flush_packets && !(s->oformat->flags & AVFMT_NOFILE))
485  }
486 }
487 
489 {
490  if (s->oformat && s->oformat->deinit && s->internal->initialized)
491  s->oformat->deinit(s);
492  s->internal->initialized =
494 }
495 
497 {
498  int ret = 0;
499 
500  if ((ret = init_muxer(s, options)) < 0)
501  return ret;
502 
503  s->internal->initialized = 1;
505 
506  if (s->oformat->init && ret) {
507  if ((ret = init_pts(s)) < 0)
508  return ret;
509 
511  }
512 
514 }
515 
517 {
518  int ret = 0;
519  int already_initialized = s->internal->initialized;
520  int streams_already_initialized = s->internal->streams_initialized;
521 
522  if (!already_initialized)
523  if ((ret = avformat_init_output(s, options)) < 0)
524  return ret;
525 
526  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
528  if (s->oformat->write_header) {
529  ret = s->oformat->write_header(s);
530  if (ret >= 0 && s->pb && s->pb->error < 0)
531  ret = s->pb->error;
532  if (ret < 0)
533  goto fail;
534  flush_if_needed(s);
535  }
536  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
538 
539  if (!s->internal->streams_initialized) {
540  if ((ret = init_pts(s)) < 0)
541  goto fail;
542  }
543 
544  return streams_already_initialized;
545 
546 fail:
547  deinit_muxer(s);
548  return ret;
549 }
550 
551 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
552 
553 /* Note: using sizeof(AVFrame) from outside lavu is unsafe in general, but
554  it is only being used internally to this file as a consistency check.
555  The value is chosen to be very unlikely to appear on its own and to cause
556  immediate failure if used anywhere as a real size. */
557 #define UNCODED_FRAME_PACKET_SIZE (INT_MIN / 3 * 2 + (int)sizeof(AVFrame))
558 
559 
560 #if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
562 //FIXME merge with compute_pkt_fields
563 static int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)
564 {
565  int delay = FFMAX(st->codecpar->video_delay, st->internal->avctx->max_b_frames > 0);
566  int num, den, i;
567  int frame_size;
568 
569  if (!s->internal->missing_ts_warning &&
570  !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
572  (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
574  "Timestamps are unset in a packet for stream %d. "
575  "This is deprecated and will stop working in the future. "
576  "Fix your code to set the timestamps properly\n", st->index);
577  s->internal->missing_ts_warning = 1;
578  }
579 
580  if (s->debug & FF_FDEBUG_TS)
581  av_log(s, AV_LOG_DEBUG, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
582  av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), delay, pkt->size, pkt->stream_index);
583 
584  if (pkt->duration < 0 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
585  av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
586  pkt->duration, pkt->stream_index);
587  pkt->duration = 0;
588  }
589 
590  /* duration field */
591  if (pkt->duration == 0) {
592  ff_compute_frame_duration(s, &num, &den, st, NULL, pkt);
593  if (den && num) {
594  pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
595  }
596  }
597 
598  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
599  pkt->pts = pkt->dts;
600 
601  //XXX/FIXME this is a temporary hack until all encoders output pts
602  if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
603  static int warned;
604  if (!warned) {
605  av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
606  warned = 1;
607  }
608  pkt->dts =
609 // pkt->pts= st->cur_dts;
610  pkt->pts = st->internal->priv_pts->val;
611  }
612 
613  //calculate dts from pts
614  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
615  st->pts_buffer[0] = pkt->pts;
616  for (i = 1; i < delay + 1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
617  st->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
618  for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
619  FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
620 
621  pkt->dts = st->pts_buffer[0];
622  }
623 
624  if (st->cur_dts && st->cur_dts != AV_NOPTS_VALUE &&
625  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
628  st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
629  av_log(s, AV_LOG_ERROR,
630  "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
631  st->index, av_ts2str(st->cur_dts), av_ts2str(pkt->dts));
632  return AVERROR(EINVAL);
633  }
634  if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
635  av_log(s, AV_LOG_ERROR,
636  "pts (%s) < dts (%s) in stream %d\n",
637  av_ts2str(pkt->pts), av_ts2str(pkt->dts),
638  st->index);
639  return AVERROR(EINVAL);
640  }
641 
642  if (s->debug & FF_FDEBUG_TS)
643  av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n",
644  av_ts2str(pkt->pts), av_ts2str(pkt->dts));
645 
646  st->cur_dts = pkt->dts;
647  st->internal->priv_pts->val = pkt->dts;
648 
649  /* update pts */
650  switch (st->codecpar->codec_type) {
651  case AVMEDIA_TYPE_AUDIO:
652  frame_size = (pkt->flags & AV_PKT_FLAG_UNCODED_FRAME) ?
653  ((AVFrame *)pkt->data)->nb_samples :
654  av_get_audio_frame_duration(st->codec, pkt->size);
655 
656  /* HACK/FIXME, we skip the initial 0 size packets as they are most
657  * likely equal to the encoder delay, but it would be better if we
658  * had the real timestamps from the encoder */
659  if (frame_size >= 0 && (pkt->size || st->internal->priv_pts->num != st->internal->priv_pts->den >> 1 || st->internal->priv_pts->val)) {
660  frac_add(st->internal->priv_pts, (int64_t)st->time_base.den * frame_size);
661  }
662  break;
663  case AVMEDIA_TYPE_VIDEO:
664  frac_add(st->internal->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
665  break;
666  }
667  return 0;
668 }
670 #endif
671 
672 /**
673  * Make timestamps non negative, move side data from payload to internal struct, call muxer, and restore
674  * sidedata.
675  *
676  * FIXME: this function should NEVER get undefined pts/dts beside when the
677  * AVFMT_NOTIMESTAMPS is set.
678  * Those additional safety checks should be dropped once the correct checks
679  * are set in the callers.
680  */
682 {
683  int ret;
684  int64_t pts_backup, dts_backup;
685 
686  pts_backup = pkt->pts;
687  dts_backup = pkt->dts;
688 
689  // If the timestamp offsetting below is adjusted, adjust
690  // ff_interleaved_peek similarly.
691  if (s->output_ts_offset) {
692  AVStream *st = s->streams[pkt->stream_index];
694 
695  if (pkt->dts != AV_NOPTS_VALUE)
696  pkt->dts += offset;
697  if (pkt->pts != AV_NOPTS_VALUE)
698  pkt->pts += offset;
699  }
700 
701  if (s->avoid_negative_ts > 0) {
702  AVStream *st = s->streams[pkt->stream_index];
703  int64_t offset = st->mux_ts_offset;
704  int64_t ts = s->internal->avoid_negative_ts_use_pts ? pkt->pts : pkt->dts;
705 
706  if (s->internal->offset == AV_NOPTS_VALUE && ts != AV_NOPTS_VALUE &&
707  (ts < 0 || s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO)) {
708  s->internal->offset = -ts;
710  }
711 
712  if (s->internal->offset != AV_NOPTS_VALUE && !offset) {
713  offset = st->mux_ts_offset =
716  st->time_base,
717  AV_ROUND_UP);
718  }
719 
720  if (pkt->dts != AV_NOPTS_VALUE)
721  pkt->dts += offset;
722  if (pkt->pts != AV_NOPTS_VALUE)
723  pkt->pts += offset;
724 
726  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < 0) {
727  av_log(s, AV_LOG_WARNING, "failed to avoid negative "
728  "pts %s in stream %d.\n"
729  "Try -avoid_negative_ts 1 as a possible workaround.\n",
730  av_ts2str(pkt->pts),
731  pkt->stream_index
732  );
733  }
734  } else {
735  av_assert2(pkt->dts == AV_NOPTS_VALUE || pkt->dts >= 0 || s->max_interleave_delta > 0);
736  if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < 0) {
738  "Packets poorly interleaved, failed to avoid negative "
739  "timestamp %s in stream %d.\n"
740  "Try -max_interleave_delta 0 as a possible workaround.\n",
741  av_ts2str(pkt->dts),
742  pkt->stream_index
743  );
744  }
745  }
746  }
747 
748  if ((pkt->flags & AV_PKT_FLAG_UNCODED_FRAME)) {
749  AVFrame *frame = (AVFrame *)pkt->data;
751  ret = s->oformat->write_uncoded_frame(s, pkt->stream_index, &frame, 0);
752  av_frame_free(&frame);
753  } else {
754  ret = s->oformat->write_packet(s, pkt);
755  }
756 
757  if (s->pb && ret >= 0) {
758  flush_if_needed(s);
759  if (s->pb->error < 0)
760  ret = s->pb->error;
761  }
762 
763  if (ret < 0) {
764  pkt->pts = pts_backup;
765  pkt->dts = dts_backup;
766  }
767 
768  return ret;
769 }
770 
772 {
773  if (!pkt)
774  return 0;
775 
776  if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
777  av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
778  pkt->stream_index);
779  return AVERROR(EINVAL);
780  }
781 
783  av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
784  return AVERROR(EINVAL);
785  }
786 
787  return 0;
788 }
789 
791 {
792  int ret;
793 
794  ret = check_packet(s, pkt);
795  if (ret < 0)
796  return ret;
797 
798 #if !FF_API_COMPUTE_PKT_FIELDS2 || !FF_API_LAVF_AVCTX
799  /* sanitize the timestamps */
800  if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
801  AVStream *st = s->streams[pkt->stream_index];
802 
803  /* when there is no reordering (so dts is equal to pts), but
804  * only one of them is set, set the other as well */
805  if (!st->internal->reorder) {
806  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)
807  pkt->pts = pkt->dts;
808  if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
809  pkt->dts = pkt->pts;
810  }
811 
812  /* check that the timestamps are set */
813  if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {
814  av_log(s, AV_LOG_ERROR,
815  "Timestamps are unset in a packet for stream %d\n", st->index);
816  return AVERROR(EINVAL);
817  }
818 
819  /* check that the dts are increasing (or at least non-decreasing,
820  * if the format allows it */
821  if (st->cur_dts != AV_NOPTS_VALUE &&
822  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && st->cur_dts >= pkt->dts) ||
823  st->cur_dts > pkt->dts)) {
824  av_log(s, AV_LOG_ERROR,
825  "Application provided invalid, non monotonically increasing "
826  "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
827  st->index, st->cur_dts, pkt->dts);
828  return AVERROR(EINVAL);
829  }
830 
831  if (pkt->pts < pkt->dts) {
832  av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
833  pkt->pts, pkt->dts, st->index);
834  return AVERROR(EINVAL);
835  }
836  }
837 #endif
838 
839  return 0;
840 }
841 
843  AVStream *st = s->streams[pkt->stream_index];
844  int i, ret;
845 
846  if (!(s->flags & AVFMT_FLAG_AUTO_BSF))
847  return 1;
848 
849  if (s->oformat->check_bitstream) {
850  if (!st->internal->bitstream_checked) {
851  if ((ret = s->oformat->check_bitstream(s, pkt)) < 0)
852  return ret;
853  else if (ret == 1)
854  st->internal->bitstream_checked = 1;
855  }
856  }
857 
858  for (i = 0; i < st->internal->nb_bsfcs; i++) {
859  AVBSFContext *ctx = st->internal->bsfcs[i];
860  // TODO: when any bitstream filter requires flushing at EOF, we'll need to
861  // flush each stream's BSF chain on write_trailer.
862  if ((ret = av_bsf_send_packet(ctx, pkt)) < 0) {
863  av_log(ctx, AV_LOG_ERROR,
864  "Failed to send packet to filter %s for stream %d\n",
865  ctx->filter->name, pkt->stream_index);
866  return ret;
867  }
868  // TODO: when any automatically-added bitstream filter is generating multiple
869  // output packets for a single input one, we'll need to call this in a loop
870  // and write each output packet.
871  if ((ret = av_bsf_receive_packet(ctx, pkt)) < 0) {
872  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
873  return 0;
874  av_log(ctx, AV_LOG_ERROR,
875  "Failed to receive packet from filter %s for stream %d\n",
876  ctx->filter->name, pkt->stream_index);
878  return ret;
879  return 0;
880  }
881  }
882  return 1;
883 }
884 
886 {
887  int ret;
888 
889  ret = prepare_input_packet(s, pkt);
890  if (ret < 0)
891  return ret;
892 
893  if (!pkt) {
894  if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
895  ret = s->oformat->write_packet(s, NULL);
896  flush_if_needed(s);
897  if (ret >= 0 && s->pb && s->pb->error < 0)
898  ret = s->pb->error;
899  return ret;
900  }
901  return 1;
902  }
903 
904  ret = do_packet_auto_bsf(s, pkt);
905  if (ret <= 0)
906  return ret;
907 
908 #if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
909  ret = compute_muxer_pkt_fields(s, s->streams[pkt->stream_index], pkt);
910 
911  if (ret < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
912  return ret;
913 #endif
914 
915  ret = write_packet(s, pkt);
916  if (ret >= 0 && s->pb && s->pb->error < 0)
917  ret = s->pb->error;
918 
919  if (ret >= 0)
920  s->streams[pkt->stream_index]->nb_frames++;
921  return ret;
922 }
923 
924 #define CHUNK_START 0x1000
925 
927  int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
928 {
929  int ret;
930  AVPacketList **next_point, *this_pktl;
931  AVStream *st = s->streams[pkt->stream_index];
932  int chunked = s->max_chunk_size || s->max_chunk_duration;
933 
934  this_pktl = av_malloc(sizeof(AVPacketList));
935  if (!this_pktl)
936  return AVERROR(ENOMEM);
937  if ((pkt->flags & AV_PKT_FLAG_UNCODED_FRAME)) {
939  av_assert0(((AVFrame *)pkt->data)->buf);
940  } else {
941  if ((ret = av_packet_make_refcounted(pkt)) < 0) {
942  av_free(this_pktl);
943  return ret;
944  }
945  }
946 
947  av_packet_move_ref(&this_pktl->pkt, pkt);
948  pkt = &this_pktl->pkt;
949 
951  next_point = &(st->last_in_packet_buffer->next);
952  } else {
953  next_point = &s->internal->packet_buffer;
954  }
955 
956  if (chunked) {
958  st->interleaver_chunk_size += pkt->size;
961  || (max && st->interleaver_chunk_duration > max)) {
962  st->interleaver_chunk_size = 0;
963  this_pktl->pkt.flags |= CHUNK_START;
964  if (max && st->interleaver_chunk_duration > max) {
965  int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
966  int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
967 
968  st->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
969  } else
971  }
972  }
973  if (*next_point) {
974  if (chunked && !(this_pktl->pkt.flags & CHUNK_START))
975  goto next_non_null;
976 
977  if (compare(s, &s->internal->packet_buffer_end->pkt, pkt)) {
978  while ( *next_point
979  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
980  || !compare(s, &(*next_point)->pkt, pkt)))
981  next_point = &(*next_point)->next;
982  if (*next_point)
983  goto next_non_null;
984  } else {
985  next_point = &(s->internal->packet_buffer_end->next);
986  }
987  }
988  av_assert1(!*next_point);
989 
990  s->internal->packet_buffer_end = this_pktl;
991 next_non_null:
992 
993  this_pktl->next = *next_point;
994 
996  *next_point = this_pktl;
997 
998  return 0;
999 }
1000 
1002  const AVPacket *pkt)
1003 {
1004  AVStream *st = s->streams[pkt->stream_index];
1005  AVStream *st2 = s->streams[next->stream_index];
1006  int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
1007  st->time_base);
1008  if (s->audio_preload) {
1009  int preload = st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
1010  int preload2 = st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
1011  if (preload != preload2) {
1012  int64_t ts, ts2;
1013  preload *= s->audio_preload;
1014  preload2 *= s->audio_preload;
1015  ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - preload;
1016  ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - preload2;
1017  if (ts == ts2) {
1018  ts = ((uint64_t)pkt ->dts*st ->time_base.num*AV_TIME_BASE - (uint64_t)preload *st ->time_base.den)*st2->time_base.den
1019  - ((uint64_t)next->dts*st2->time_base.num*AV_TIME_BASE - (uint64_t)preload2*st2->time_base.den)*st ->time_base.den;
1020  ts2 = 0;
1021  }
1022  comp = (ts2 > ts) - (ts2 < ts);
1023  }
1024  }
1025 
1026  if (comp == 0)
1027  return pkt->stream_index < next->stream_index;
1028  return comp > 0;
1029 }
1030 
1032  AVPacket *pkt, int flush)
1033 {
1034  AVPacketList *pktl;
1035  int stream_count = 0;
1036  int noninterleaved_count = 0;
1037  int i, ret;
1038  int eof = flush;
1039 
1040  if (pkt) {
1041  if ((ret = ff_interleave_add_packet(s, pkt, interleave_compare_dts)) < 0)
1042  return ret;
1043  }
1044 
1045  for (i = 0; i < s->nb_streams; i++) {
1046  if (s->streams[i]->last_in_packet_buffer) {
1047  ++stream_count;
1048  } else if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
1051  ++noninterleaved_count;
1052  }
1053  }
1054 
1055  if (s->internal->nb_interleaved_streams == stream_count)
1056  flush = 1;
1057 
1058  if (s->max_interleave_delta > 0 &&
1059  s->internal->packet_buffer &&
1060  !flush &&
1061  s->internal->nb_interleaved_streams == stream_count+noninterleaved_count
1062  ) {
1063  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
1064  int64_t delta_dts = INT64_MIN;
1065  int64_t top_dts = av_rescale_q(top_pkt->dts,
1066  s->streams[top_pkt->stream_index]->time_base,
1067  AV_TIME_BASE_Q);
1068 
1069  for (i = 0; i < s->nb_streams; i++) {
1070  int64_t last_dts;
1071  const AVPacketList *last = s->streams[i]->last_in_packet_buffer;
1072 
1073  if (!last)
1074  continue;
1075 
1076  last_dts = av_rescale_q(last->pkt.dts,
1077  s->streams[i]->time_base,
1078  AV_TIME_BASE_Q);
1079  delta_dts = FFMAX(delta_dts, last_dts - top_dts);
1080  }
1081 
1082  if (delta_dts > s->max_interleave_delta) {
1083  av_log(s, AV_LOG_DEBUG,
1084  "Delay between the first packet and last packet in the "
1085  "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
1086  delta_dts, s->max_interleave_delta);
1087  flush = 1;
1088  }
1089  }
1090 
1091  if (s->internal->packet_buffer &&
1092  eof &&
1093  (s->flags & AVFMT_FLAG_SHORTEST) &&
1095  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
1096 
1097  s->internal->shortest_end = av_rescale_q(top_pkt->dts,
1098  s->streams[top_pkt->stream_index]->time_base,
1099  AV_TIME_BASE_Q);
1100  }
1101 
1102  if (s->internal->shortest_end != AV_NOPTS_VALUE) {
1103  while (s->internal->packet_buffer) {
1104  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
1105  AVStream *st;
1106  int64_t top_dts = av_rescale_q(top_pkt->dts,
1107  s->streams[top_pkt->stream_index]->time_base,
1108  AV_TIME_BASE_Q);
1109 
1110  if (s->internal->shortest_end + 1 >= top_dts)
1111  break;
1112 
1113  pktl = s->internal->packet_buffer;
1114  st = s->streams[pktl->pkt.stream_index];
1115 
1116  s->internal->packet_buffer = pktl->next;
1117  if (!s->internal->packet_buffer)
1119 
1120  if (st->last_in_packet_buffer == pktl)
1122 
1123  av_packet_unref(&pktl->pkt);
1124  av_freep(&pktl);
1125  flush = 0;
1126  }
1127  }
1128 
1129  if (stream_count && flush) {
1130  AVStream *st;
1131  pktl = s->internal->packet_buffer;
1132  *out = pktl->pkt;
1133  st = s->streams[out->stream_index];
1134 
1135  s->internal->packet_buffer = pktl->next;
1136  if (!s->internal->packet_buffer)
1138 
1139  if (st->last_in_packet_buffer == pktl)
1141  av_freep(&pktl);
1142 
1143  return 1;
1144  } else {
1145  av_init_packet(out);
1146  return 0;
1147  }
1148 }
1149 
1151  AVPacket *pkt, int add_offset)
1152 {
1153  AVPacketList *pktl = s->internal->packet_buffer;
1154  while (pktl) {
1155  if (pktl->pkt.stream_index == stream) {
1156  *pkt = pktl->pkt;
1157  if (add_offset) {
1158  AVStream *st = s->streams[pkt->stream_index];
1159  int64_t offset = st->mux_ts_offset;
1160 
1161  if (s->output_ts_offset)
1163 
1164  if (pkt->dts != AV_NOPTS_VALUE)
1165  pkt->dts += offset;
1166  if (pkt->pts != AV_NOPTS_VALUE)
1167  pkt->pts += offset;
1168  }
1169  return 0;
1170  }
1171  pktl = pktl->next;
1172  }
1173  return AVERROR(ENOENT);
1174 }
1175 
1176 /**
1177  * Interleave an AVPacket correctly so it can be muxed.
1178  * @param out the interleaved packet will be output here
1179  * @param in the input packet
1180  * @param flush 1 if no further packets are available as input and all
1181  * remaining packets should be output
1182  * @return 1 if a packet was output, 0 if no packet could be output,
1183  * < 0 if an error occurred
1184  */
1186 {
1187  if (s->oformat->interleave_packet) {
1188  int ret = s->oformat->interleave_packet(s, out, in, flush);
1189  if (in)
1190  av_packet_unref(in);
1191  return ret;
1192  } else
1193  return ff_interleave_packet_per_dts(s, out, in, flush);
1194 }
1195 
1197 {
1198  int ret, flush = 0;
1199 
1200  ret = prepare_input_packet(s, pkt);
1201  if (ret < 0)
1202  goto fail;
1203 
1204  if (pkt) {
1205  AVStream *st = s->streams[pkt->stream_index];
1206 
1207  ret = do_packet_auto_bsf(s, pkt);
1208  if (ret == 0)
1209  return 0;
1210  else if (ret < 0)
1211  goto fail;
1212 
1213  if (s->debug & FF_FDEBUG_TS)
1214  av_log(s, AV_LOG_DEBUG, "av_interleaved_write_frame size:%d dts:%s pts:%s\n",
1215  pkt->size, av_ts2str(pkt->dts), av_ts2str(pkt->pts));
1216 
1217 #if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
1218  if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1219  goto fail;
1220 #endif
1221 
1222  if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
1223  ret = AVERROR(EINVAL);
1224  goto fail;
1225  }
1226  } else {
1227  av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");
1228  flush = 1;
1229  }
1230 
1231  for (;; ) {
1232  AVPacket opkt;
1233  int ret = interleave_packet(s, &opkt, pkt, flush);
1234  if (pkt) {
1235  memset(pkt, 0, sizeof(*pkt));
1236  av_init_packet(pkt);
1237  pkt = NULL;
1238  }
1239  if (ret <= 0) //FIXME cleanup needed for ret<0 ?
1240  return ret;
1241 
1242  ret = write_packet(s, &opkt);
1243  if (ret >= 0)
1244  s->streams[opkt.stream_index]->nb_frames++;
1245 
1246  av_packet_unref(&opkt);
1247 
1248  if (ret < 0)
1249  return ret;
1250  if(s->pb && s->pb->error)
1251  return s->pb->error;
1252  }
1253 fail:
1254  av_packet_unref(pkt);
1255  return ret;
1256 }
1257 
1259 {
1260  int ret, i;
1261 
1262  for (;; ) {
1263  AVPacket pkt;
1264  ret = interleave_packet(s, &pkt, NULL, 1);
1265  if (ret < 0)
1266  goto fail;
1267  if (!ret)
1268  break;
1269 
1270  ret = write_packet(s, &pkt);
1271  if (ret >= 0)
1272  s->streams[pkt.stream_index]->nb_frames++;
1273 
1274  av_packet_unref(&pkt);
1275 
1276  if (ret < 0)
1277  goto fail;
1278  if(s->pb && s->pb->error)
1279  goto fail;
1280  }
1281 
1282 fail:
1283  if (s->oformat->write_trailer) {
1284  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1286  if (ret >= 0) {
1287  ret = s->oformat->write_trailer(s);
1288  } else {
1289  s->oformat->write_trailer(s);
1290  }
1291  }
1292 
1293  deinit_muxer(s);
1294 
1295  if (s->pb)
1296  avio_flush(s->pb);
1297  if (ret == 0)
1298  ret = s->pb ? s->pb->error : 0;
1299  for (i = 0; i < s->nb_streams; i++) {
1300  av_freep(&s->streams[i]->priv_data);
1301  av_freep(&s->streams[i]->index_entries);
1302  }
1303  if (s->oformat->priv_class)
1304  av_opt_free(s->priv_data);
1305  av_freep(&s->priv_data);
1306  return ret;
1307 }
1308 
1309 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
1310  int64_t *dts, int64_t *wall)
1311 {
1312  if (!s->oformat || !s->oformat->get_output_timestamp)
1313  return AVERROR(ENOSYS);
1314  s->oformat->get_output_timestamp(s, stream, dts, wall);
1315  return 0;
1316 }
1317 
1318 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
1320 {
1321  AVPacket local_pkt;
1322  int ret;
1323 
1324  local_pkt = *pkt;
1325  local_pkt.stream_index = dst_stream;
1326 
1327  av_packet_rescale_ts(&local_pkt,
1328  src->streams[pkt->stream_index]->time_base,
1329  dst->streams[dst_stream]->time_base);
1330 
1331  if (interleave) ret = av_interleaved_write_frame(dst, &local_pkt);
1332  else ret = av_write_frame(dst, &local_pkt);
1333  pkt->buf = local_pkt.buf;
1334  pkt->side_data = local_pkt.side_data;
1335  pkt->side_data_elems = local_pkt.side_data_elems;
1336  return ret;
1337 }
1338 
1339 static int av_write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
1340  AVFrame *frame, int interleaved)
1341 {
1342  AVPacket pkt, *pktp;
1343 
1344  av_assert0(s->oformat);
1345  if (!s->oformat->write_uncoded_frame)
1346  return AVERROR(ENOSYS);
1347 
1348  if (!frame) {
1349  pktp = NULL;
1350  } else {
1351  pktp = &pkt;
1352  av_init_packet(&pkt);
1353  pkt.data = (void *)frame;
1355  pkt.pts =
1356  pkt.dts = frame->pts;
1357  pkt.duration = frame->pkt_duration;
1358  pkt.stream_index = stream_index;
1360  }
1361 
1362  return interleaved ? av_interleaved_write_frame(s, pktp) :
1363  av_write_frame(s, pktp);
1364 }
1365 
1366 int av_write_uncoded_frame(AVFormatContext *s, int stream_index,
1367  AVFrame *frame)
1368 {
1369  return av_write_uncoded_frame_internal(s, stream_index, frame, 0);
1370 }
1371 
1373  AVFrame *frame)
1374 {
1375  return av_write_uncoded_frame_internal(s, stream_index, frame, 1);
1376 }
1377 
1379 {
1380  av_assert0(s->oformat);
1381  if (!s->oformat->write_uncoded_frame)
1382  return AVERROR(ENOSYS);
1383  return s->oformat->write_uncoded_frame(s, stream_index, NULL,
1385 }
int avformat_alloc_output_context2(AVFormatContext **avctx, ff_const59 AVOutputFormat *oformat, const char *format, const char *filename)
Allocate an AVFormatContext for an output format.
Definition: mux.c:148
#define AV_CODEC_PROP_REORDER
Codec supports frame reordering.
Definition: avcodec.h:777
static float compare(const AVFrame *haystack, const AVFrame *obj, int offx, int offy)
Definition: vf_find_rect.c:104
int64_t interleaver_chunk_size
Definition: avformat.h:1128
enum AVChromaLocation chroma_location
Definition: avcodec.h:4077
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:863
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:4068
int audio_preload
Audio preload in microseconds.
Definition: avformat.h:1705
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int check_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:771
enum AVCodecID id
Definition: internal.h:43
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:544
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file ensuring correct interleaving.
Definition: mux.c:1196
int bitstream_checked
Whether or not check_bitstream should still be run on each packet.
Definition: internal.h:165
FFFrac * priv_pts
Definition: internal.h:192
static void flush(AVCodecContext *avctx)
int flush_packets
Flush the I/O context after each packet.
Definition: avformat.h:1772
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
Definition: mux.c:885
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int reorder
Set to 1 if the codec allows reordering, so pts can be different from dts.
Definition: internal.h:152
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4931
int64_t pts_buffer[MAX_REORDER_DELAY+1]
Definition: avformat.h:1107
const char * desc
Definition: nvenc.c:68
int(* init)(struct AVFormatContext *)
Initialize format.
Definition: avformat.h:624
#define AVSTREAM_INIT_IN_INIT_OUTPUT
stream parameters initialized in avformat_init_output
Definition: avformat.h:2528
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:1842
AVRational sample_aspect_ratio
Video only.
Definition: avcodec.h:4063
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1359
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3987
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: avcodec.h:5802
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:942
int num
Numerator.
Definition: rational.h:59
The bitstream filter state.
Definition: avcodec.h:5793
int index
stream index in AVFormatContext
Definition: avformat.h:881
int size
Definition: avcodec.h:1495
int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
Interleave a packet per dts in an output media file.
Definition: mux.c:1031
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1109
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1810
static void deinit_muxer(AVFormatContext *s)
Definition: mux.c:488
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
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:1309
int64_t offset
Offset to remap timestamps to be non-negative.
Definition: internal.h:106
void * priv_data
Definition: avformat.h:895
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
int avoid_negative_ts_use_pts
Definition: internal.h:119
static AVPacket pkt
int av_write_uncoded_frame_query(AVFormatContext *s, int stream_index)
Test whether a muxer supports uncoded frame.
Definition: mux.c:1378
static void error(const char *err)
#define src
Definition: vp8dsp.c:254
#define AVFMT_ALLOW_FLUSH
Format allows flushing.
Definition: avformat.h:476
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
static int av_write_uncoded_frame_internal(AVFormatContext *s, int stream_index, AVFrame *frame, int interleaved)
Definition: mux.c:1339
int strict_std_compliance
Allow non-standard and experimental extension.
Definition: avformat.h:1665
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:477
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3979
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:1318
int(* interleave_packet)(struct AVFormatContext *, AVPacket *out, AVPacket *in, int flush)
Currently only used to set pixel format if not YUV420P.
Definition: avformat.h:570
Trailer data, which doesn&#39;t contain actual content, but only for finalizing the output file...
Definition: avio.h:140
Format I/O context.
Definition: avformat.h:1357
int64_t output_ts_offset
Output timestamp offset, in microseconds.
Definition: avformat.h:1874
int64_t cur_dts
Definition: avformat.h:1083
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:117
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
internal metadata API header see avformat.h or the public API!
#define CHUNK_START
Definition: mux.c:924
Public dictionary API.
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:217
static void flush_if_needed(AVFormatContext *s)
Definition: mux.c:478
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT, AVFMT_TS_NEGATIVE
Definition: avformat.h:524
Round toward +infinity.
Definition: mathematics.h:83
#define av_malloc(s)
Opaque data information usually continuous.
Definition: avutil.h:203
int width
Video only.
Definition: avcodec.h:4053
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
AVOptions.
A point in the output bytestream where the underlying AVIOContext might flush the buffer depending on...
Definition: avio.h:146
timestamp utils, mostly useful for debugging/logging purposes
Query whether the feature is possible on this stream.
Definition: internal.h:630
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
AVPacket pkt
Definition: avformat.h:2031
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
#define f(width, name)
Definition: cbs_vp9.c:255
int priv_data_size
size of private data so that it can be allocated in the wrapper
Definition: avformat.h:555
The exact value of the fractional number is: &#39;val + num / den&#39;.
Definition: internal.h:59
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1512
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:496
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1425
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:144
const char * name
Definition: avcodec.h:5843
void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st, AVCodecParserContext *pc, AVPacket *pkt)
Return the frame duration in seconds.
Definition: utils.c:957
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1488
uint8_t * data
Definition: avcodec.h:1494
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
int64_t max_interleave_delta
Maximum buffering duration for interleaving.
Definition: avformat.h:1659
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:655
uint32_t tag
Definition: movenc.c:1532
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define max(a, b)
Definition: cuda_runtime.h:33
struct AVPacketList * packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:76
#define AVSTREAM_INIT_IN_WRITE_HEADER
stream parameters initialized in avformat_write_header
Definition: avformat.h:2527
static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush)
Interleave an AVPacket correctly so it can be muxed.
Definition: mux.c:1185
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1505
#define av_log(a,...)
static int interleave_compare_dts(AVFormatContext *s, const AVPacket *next, const AVPacket *pkt)
Definition: mux.c:1001
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
#define ff_const59
The ff_const59 define is not part of the public API and will be removed without further warning...
Definition: avformat.h:549
#define AVFMT_FLAG_FLUSH_PACKETS
Flush the AVIOContext every packet.
Definition: avformat.h:1498
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1597
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1536
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst)
Convert valid timing fields (timestamps / durations) in a packet from one timebase to another...
Definition: avpacket.c:704
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
Definition: mux.c:209
#define AV_PKT_FLAG_UNCODED_FRAME
Definition: mux.c:551
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
int(* check_bitstream)(struct AVFormatContext *, const AVPacket *pkt)
Set up any necessary bitstream filtering and extract any extra data needed for the global header...
Definition: avformat.h:639
char * url
input or output URL.
Definition: avformat.h:1453
int video_delay
Video only.
Definition: avcodec.h:4082
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3983
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1477
simple assert() macros that are a bit more flexible than ISO C assert().
int side_data_elems
Definition: avcodec.h:1506
#define FFMAX(a, b)
Definition: common.h:94
int64_t val
Definition: internal.h:60
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
#define fail()
Definition: checkasm.h:122
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1500
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3308
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
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: avcodec.h:739
static int write_packet(AVFormatContext *s, AVPacket *pkt)
Make timestamps non negative, move side data from payload to internal struct, call muxer...
Definition: mux.c:681
int streams_initialized
Whether or not avformat_init_output fully initialized streams.
Definition: internal.h:134
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1413
AVBSFContext ** bsfcs
bitstream filters to run on stream
Definition: internal.h:159
#define LIBAVFORMAT_IDENT
Definition: version.h:46
int block_align
Audio only.
Definition: avcodec.h:4104
This is any, unlabelled data.
Definition: avio.h:135
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:915
int(* write_header)(struct AVFormatContext *)
Definition: avformat.h:557
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
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
int64_t shortest_end
Timestamp of the end of the shortest stream.
Definition: internal.h:124
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
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:516
int(* write_uncoded_frame)(struct AVFormatContext *, int stream_index, AVFrame **frame, unsigned flags)
Write an uncoded AVFrame.
Definition: avformat.h:597
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:557
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:663
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:546
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:190
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
AVFormatContext * ctx
Definition: movenc.c:48
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
#define s(width, name)
Definition: cbs_vp9.c:257
int avoid_negative_ts
Avoid negative timestamps during muxing.
Definition: avformat.h:1688
static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
f = val + (num / den) + 0.5.
Definition: mux.c:64
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2722
int n
Definition: avisynth_c.h:760
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
static int init_muxer(AVFormatContext *s, AVDictionary **options)
Definition: mux.c:243
Opaque data information usually sparse.
Definition: avutil.h:205
int64_t num
Definition: internal.h:60
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:533
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:496
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:1632
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:848
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1376
if(ret)
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:83
Stream structure.
Definition: avformat.h:880
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:467
int ff_interleaved_peek(AVFormatContext *s, int stream, AVPacket *pkt, int add_offset)
Find the next packet in the interleaving queue for the given stream.
Definition: mux.c:1150
#define FF_FDEBUG_TS
Definition: avformat.h:1641
int frame_size
Definition: mxfenc.c:2140
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1237
int64_t pkt_duration
duration of the corresponding packet, expressed in AVStream->time_base units, 0 if unknown...
Definition: frame.h:574
int debug
Flags to enable debugging.
Definition: avformat.h:1640
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1657
AVIOContext * pb
I/O context.
Definition: avformat.h:1399
const struct AVCodecTag *const * codec_tag
List of supported codec_id-codec_tag pairs, ordered by "better choice first".
Definition: avformat.h:530
int64_t den
Definition: internal.h:60
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
int(* write_trailer)(struct AVFormatContext *)
Definition: avformat.h:566
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
#define UNCODED_FRAME_PACKET_SIZE
Definition: mux.c:557
int nb_interleaved_streams
Number of streams relevant for interleaving.
Definition: internal.h:69
Describe the class of an AVClass context structure.
Definition: log.h:67
int initialized
Whether or not avformat_init_output has already been called.
Definition: internal.h:129
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2648
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:1816
ff_const59 AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)
Return the output format in the list of registered output formats which best matches the provided par...
Definition: format.c:51
int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt, int(*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
Add packet to AVFormatContext->packet_buffer list, determining its interleaved position using compare...
Definition: mux.c:926
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define AV_DISPOSITION_TIMED_THUMBNAILS
The stream is sparse, and contains thumbnail images, often corresponding to chapter markers...
Definition: avformat.h:853
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: utils.c:2061
void(* get_output_timestamp)(struct AVFormatContext *s, int stream, int64_t *dts, int64_t *wall)
Definition: avformat.h:581
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:118
static int do_packet_auto_bsf(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:842
AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:102
#define AVFMT_AVOID_NEG_TS_AUTO
Enabled when required by target format.
Definition: avformat.h:1689
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4435
#define AVFMT_FLAG_AUTO_BSF
Add bitstream filters as requested by the muxer.
Definition: avformat.h:1516
int error
contains the error code or 0 if no error happened
Definition: avio.h:245
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:1740
misc parsing utilities
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:723
unsigned int tag
Definition: internal.h:44
AVRational offset_timebase
Timebase for the timestamp offset.
Definition: internal.h:111
int sample_rate
Audio only.
Definition: avcodec.h:4097
int64_t interleaver_chunk_duration
Definition: avformat.h:1129
#define AVFMT_AVOID_NEG_TS_MAKE_ZERO
Shift timestamps so that they start at 0.
Definition: avformat.h:1691
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
Main libavformat public API header.
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: avcodec.h:1505
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1612
const OptionDef options[]
Definition: ffmpeg_opt.c:3374
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
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:1372
common internal api header.
struct AVPacketList * next
Definition: avformat.h:2032
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:463
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:472
int max_chunk_size
Max chunk size in bytes Note, not all formats support this and unpredictable things may happen if it ...
Definition: avformat.h:1721
int error_recognition
Error recognition; higher values will detect more errors but may misdetect some more or less valid pa...
Definition: avformat.h:1624
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:933
static void frac_add(FFFrac *f, int64_t incr)
Fractional addition to f: f = f + (incr / f->den).
Definition: mux.c:82
static int init_pts(AVFormatContext *s)
Definition: mux.c:433
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:931
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
int av_write_uncoded_frame(AVFormatContext *s, int stream_index, AVFrame *frame)
Write an uncoded frame to an output media file.
Definition: mux.c:1366
int64_t mux_ts_offset
Timestamp offset added to timestamps before muxing NOT PART OF PUBLIC API.
Definition: avformat.h:1184
#define AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE
Shift timestamps so they are non negative.
Definition: avformat.h:1690
struct AVPacketList * packet_buffer_end
Definition: internal.h:77
#define av_free(p)
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
int max_chunk_duration
Max chunk time in microseconds.
Definition: avformat.h:1713
void * priv_data
Format private data.
Definition: avformat.h:1385
void(* deinit)(struct AVFormatContext *)
Deinitialize format.
Definition: avformat.h:633
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:471
int(* write_packet)(struct AVFormatContext *, AVPacket *pkt)
Write a packet.
Definition: avformat.h:565
int channels
Audio only.
Definition: avcodec.h:4093
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:170
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1493
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
Definition: mux.c:1258
FILE * out
Definition: movenc.c:54
#define av_freep(p)
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:542
unbuffered private I/O API
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:545
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1027
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
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3991
#define FFSWAP(type, a, b)
Definition: common.h:99
int stream_index
Definition: avcodec.h:1496
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:909
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
#define MKTAG(a, b, c, d)
Definition: common.h:366
unsigned int av_codec_get_tag(const struct AVCodecTag *const *tags, enum AVCodecID id)
Get the codec tag for the given codec id id.
#define AVFMT_TS_NEGATIVE
Format allows muxing negative timestamps.
Definition: avformat.h:482
This structure stores compressed data.
Definition: avcodec.h:1471
static int prepare_input_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:790
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1487
struct AVPacketList * last_in_packet_buffer
last packet in packet_buffer for this stream when muxing.
Definition: avformat.h:1104
Header data; this needs to be present for the stream to be decodeable.
Definition: avio.h:115
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define AVFMT_FLAG_SHORTEST
Stop muxing when the shortest stream stops.
Definition: avformat.h:1515
static uint8_t tmp[11]
Definition: aes_ctr.c:26