FFmpeg
mux.c
Go to the documentation of this file.
1 /*
2  * muxing functions for use within FFmpeg
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "avformat.h"
23 #include "internal.h"
24 #include "libavcodec/internal.h"
26 #include "libavutil/opt.h"
27 #include "libavutil/dict.h"
28 #include "libavutil/pixdesc.h"
29 #include "libavutil/timestamp.h"
30 #include "libavutil/avassert.h"
31 #include "libavutil/avstring.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mathematics.h"
34 
35 /**
36  * @file
37  * muxing functions for use within libavformat
38  */
39 
40 /* fraction handling */
41 
42 /**
43  * f = val + (num / den) + 0.5.
44  *
45  * 'num' is normalized so that it is such as 0 <= num < den.
46  *
47  * @param f fractional number
48  * @param val integer value
49  * @param num must be >= 0
50  * @param den must be >= 1
51  */
52 static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
53 {
54  num += (den >> 1);
55  if (num >= den) {
56  val += num / den;
57  num = num % den;
58  }
59  f->val = val;
60  f->num = num;
61  f->den = den;
62 }
63 
64 /**
65  * Fractional addition to f: f = f + (incr / f->den).
66  *
67  * @param f fractional number
68  * @param incr increment, can be positive or negative
69  */
70 static void frac_add(FFFrac *f, int64_t incr)
71 {
72  int64_t num, den;
73 
74  num = f->num + incr;
75  den = f->den;
76  if (num < 0) {
77  f->val += num / den;
78  num = num % den;
79  if (num < 0) {
80  num += den;
81  f->val--;
82  }
83  } else if (num >= den) {
84  f->val += num / den;
85  num = num % den;
86  }
87  f->num = num;
88 }
89 
91 {
92  AVRational q;
93  int j;
94 
95  q = st->time_base;
96 
97  for (j=2; j<14; j+= 1+(j>2))
98  while (q.den / q.num < min_precision && q.num % j == 0)
99  q.num /= j;
100  while (q.den / q.num < min_precision && q.den < (1<<24))
101  q.den <<= 1;
102 
103  return q;
104 }
105 
107 {
108  AVCodecParameters *par = st->codecpar;
109  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(par->format);
110 
112  return par->chroma_location;
113 
114  if (pix_desc) {
115  if (pix_desc->log2_chroma_h == 0) {
116  return AVCHROMA_LOC_TOPLEFT;
117  } else if (pix_desc->log2_chroma_w == 1 && pix_desc->log2_chroma_h == 1) {
119  switch (par->codec_id) {
120  case AV_CODEC_ID_MJPEG:
122  }
123  }
125  switch (par->codec_id) {
127  }
128  }
129  }
130  }
131 
133 
134 }
135 
137  const char *format, const char *filename)
138 {
140  int ret = 0;
141 
142  *avctx = NULL;
143  if (!s)
144  goto nomem;
145 
146  if (!oformat) {
147  if (format) {
148  oformat = av_guess_format(format, NULL, NULL);
149  if (!oformat) {
150  av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
151  ret = AVERROR(EINVAL);
152  goto error;
153  }
154  } else {
155  oformat = av_guess_format(NULL, filename, NULL);
156  if (!oformat) {
157  ret = AVERROR(EINVAL);
158  av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
159  filename);
160  goto error;
161  }
162  }
163  }
164 
165  s->oformat = oformat;
166  if (s->oformat->priv_data_size > 0) {
168  if (!s->priv_data)
169  goto nomem;
170  if (s->oformat->priv_class) {
171  *(const AVClass**)s->priv_data= s->oformat->priv_class;
173  }
174  } else
175  s->priv_data = NULL;
176 
177  if (filename) {
178 #if FF_API_FORMAT_FILENAME
180  av_strlcpy(s->filename, filename, sizeof(s->filename));
182 #endif
183  if (!(s->url = av_strdup(filename)))
184  goto nomem;
185 
186  }
187  *avctx = s;
188  return 0;
189 nomem:
190  av_log(s, AV_LOG_ERROR, "Out of memory\n");
191  ret = AVERROR(ENOMEM);
192 error:
194  return ret;
195 }
196 
198 {
199  const AVCodecTag *avctag;
200  int n;
201  enum AVCodecID id = AV_CODEC_ID_NONE;
202  int64_t tag = -1;
203 
204  /**
205  * Check that tag + id is in the table
206  * If neither is in the table -> OK
207  * If tag is in the table with another id -> FAIL
208  * If id is in the table with another tag -> FAIL unless strict < normal
209  */
210  for (n = 0; s->oformat->codec_tag[n]; n++) {
211  avctag = s->oformat->codec_tag[n];
212  while (avctag->id != AV_CODEC_ID_NONE) {
213  if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codecpar->codec_tag)) {
214  id = avctag->id;
215  if (id == st->codecpar->codec_id)
216  return 1;
217  }
218  if (avctag->id == st->codecpar->codec_id)
219  tag = avctag->tag;
220  avctag++;
221  }
222  }
223  if (id != AV_CODEC_ID_NONE)
224  return 0;
225  if (tag >= 0 && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
226  return 0;
227  return 1;
228 }
229 
230 
232 {
233  int ret = 0, i;
234  AVStream *st;
235  AVDictionary *tmp = NULL;
236  AVCodecParameters *par = NULL;
237  const AVOutputFormat *of = s->oformat;
238  const AVCodecDescriptor *desc;
240 
241  if (options)
242  av_dict_copy(&tmp, *options, 0);
243 
244  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
245  goto fail;
246  if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
247  (ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
248  goto fail;
249 
250 #if FF_API_FORMAT_FILENAME
252  if (!s->url && !(s->url = av_strdup(s->filename))) {
254 #else
255  if (!s->url && !(s->url = av_strdup(""))) {
256 #endif
257  ret = AVERROR(ENOMEM);
258  goto fail;
259  }
260 
261 #if FF_API_LAVF_AVCTX
263  if (s->nb_streams && s->streams[0]->codec->flags & AV_CODEC_FLAG_BITEXACT) {
264  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
266  "The AVFormatContext is not in set to bitexact mode, only "
267  "the AVCodecContext. If this is not intended, set "
268  "AVFormatContext.flags |= AVFMT_FLAG_BITEXACT.\n");
269  }
270  }
272 #endif
273 
274  // some sanity checks
275  if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) {
276  av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");
277  ret = AVERROR(EINVAL);
278  goto fail;
279  }
280 
281  for (i = 0; i < s->nb_streams; i++) {
282  st = s->streams[i];
283  par = st->codecpar;
284 
285 #if FF_API_LAVF_AVCTX
288  st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN) {
289  av_log(s, AV_LOG_WARNING, "Using AVStream.codec to pass codec "
290  "parameters to muxers is deprecated, use AVStream.codecpar "
291  "instead.\n");
292  ret = avcodec_parameters_from_context(st->codecpar, st->codec);
293  if (ret < 0)
294  goto fail;
295  }
297 #endif
298 
299  if (!st->time_base.num) {
300  /* fall back on the default timebase values */
301  if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)
302  avpriv_set_pts_info(st, 64, 1, par->sample_rate);
303  else
304  avpriv_set_pts_info(st, 33, 1, 90000);
305  }
306 
307  switch (par->codec_type) {
308  case AVMEDIA_TYPE_AUDIO:
309  if (par->sample_rate <= 0) {
310  av_log(s, AV_LOG_ERROR, "sample rate not set\n");
311  ret = AVERROR(EINVAL);
312  goto fail;
313  }
314  if (!par->block_align)
315  par->block_align = par->channels *
316  av_get_bits_per_sample(par->codec_id) >> 3;
317  break;
318  case AVMEDIA_TYPE_VIDEO:
319  if ((par->width <= 0 || par->height <= 0) &&
320  !(of->flags & AVFMT_NODIMENSIONS)) {
321  av_log(s, AV_LOG_ERROR, "dimensions not set\n");
322  ret = AVERROR(EINVAL);
323  goto fail;
324  }
327  ) {
328  if (st->sample_aspect_ratio.num != 0 &&
329  st->sample_aspect_ratio.den != 0 &&
330  par->sample_aspect_ratio.num != 0 &&
331  par->sample_aspect_ratio.den != 0) {
332  av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
333  "(%d/%d) and encoder layer (%d/%d)\n",
336  par->sample_aspect_ratio.den);
337  ret = AVERROR(EINVAL);
338  goto fail;
339  }
340  }
341  break;
342  }
343 
344  desc = avcodec_descriptor_get(par->codec_id);
345  if (desc && desc->props & AV_CODEC_PROP_REORDER)
346  st->internal->reorder = 1;
347 
349 
350  if (of->codec_tag) {
351  if ( par->codec_tag
352  && par->codec_id == AV_CODEC_ID_RAWVIDEO
353  && ( av_codec_get_tag(of->codec_tag, par->codec_id) == 0
354  || av_codec_get_tag(of->codec_tag, par->codec_id) == MKTAG('r', 'a', 'w', ' '))
355  && !validate_codec_tag(s, st)) {
356  // the current rawvideo encoding system ends up setting
357  // the wrong codec_tag for avi/mov, we override it here
358  par->codec_tag = 0;
359  }
360  if (par->codec_tag) {
361  if (!validate_codec_tag(s, st)) {
362  const uint32_t otag = av_codec_get_tag(s->oformat->codec_tag, par->codec_id);
363  av_log(s, AV_LOG_ERROR,
364  "Tag %s incompatible with output codec id '%d' (%s)\n",
365  av_fourcc2str(par->codec_tag), par->codec_id, av_fourcc2str(otag));
366  ret = AVERROR_INVALIDDATA;
367  goto fail;
368  }
369  } else
370  par->codec_tag = av_codec_get_tag(of->codec_tag, par->codec_id);
371  }
372 
375  }
376 
377  if (!s->priv_data && of->priv_data_size > 0) {
379  if (!s->priv_data) {
380  ret = AVERROR(ENOMEM);
381  goto fail;
382  }
383  if (of->priv_class) {
384  *(const AVClass **)s->priv_data = of->priv_class;
386  if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
387  goto fail;
388  }
389  }
390 
391  /* set muxer identification string */
392  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
393  av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
394  } else {
395  av_dict_set(&s->metadata, "encoder", NULL, 0);
396  }
397 
398  for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {
399  av_dict_set(&s->metadata, e->key, NULL, 0);
400  }
401 
402  if (options) {
403  av_dict_free(options);
404  *options = tmp;
405  }
406 
407  if (s->oformat->init) {
408  if ((ret = s->oformat->init(s)) < 0) {
409  if (s->oformat->deinit)
410  s->oformat->deinit(s);
411  return ret;
412  }
413  return ret == 0;
414  }
415 
416  return 0;
417 
418 fail:
419  av_dict_free(&tmp);
420  return ret;
421 }
422 
423 static int init_pts(AVFormatContext *s)
424 {
425  int i;
426  AVStream *st;
427 
428  /* init PTS generation */
429  for (i = 0; i < s->nb_streams; i++) {
430  int64_t den = AV_NOPTS_VALUE;
431  st = s->streams[i];
432 
433  switch (st->codecpar->codec_type) {
434  case AVMEDIA_TYPE_AUDIO:
435  den = (int64_t)st->time_base.num * st->codecpar->sample_rate;
436  break;
437  case AVMEDIA_TYPE_VIDEO:
438  den = (int64_t)st->time_base.num * st->time_base.den;
439  break;
440  default:
441  break;
442  }
443 
444  if (!st->internal->priv_pts)
445  st->internal->priv_pts = av_mallocz(sizeof(*st->internal->priv_pts));
446  if (!st->internal->priv_pts)
447  return AVERROR(ENOMEM);
448 
449  if (den != AV_NOPTS_VALUE) {
450  if (den <= 0)
451  return AVERROR_INVALIDDATA;
452 
453  frac_init(st->internal->priv_pts, 0, 0, den);
454  }
455  }
456 
457  if (s->avoid_negative_ts < 0) {
460  s->avoid_negative_ts = 0;
461  } else
463  }
464 
465  return 0;
466 }
467 
469 {
470  if (s->pb && s->pb->error >= 0) {
471  if (s->flush_packets == 1 || s->flags & AVFMT_FLAG_FLUSH_PACKETS)
472  avio_flush(s->pb);
473  else if (s->flush_packets && !(s->oformat->flags & AVFMT_NOFILE))
475  }
476 }
477 
479 {
480  if (s->oformat && s->oformat->deinit && s->internal->initialized)
481  s->oformat->deinit(s);
482  s->internal->initialized =
484 }
485 
487 {
488  int ret = 0;
489 
490  if ((ret = init_muxer(s, options)) < 0)
491  return ret;
492 
493  s->internal->initialized = 1;
495 
496  if (s->oformat->init && ret) {
497  if ((ret = init_pts(s)) < 0)
498  return ret;
499 
501  }
502 
504 }
505 
507 {
508  int ret = 0;
509  int already_initialized = s->internal->initialized;
510  int streams_already_initialized = s->internal->streams_initialized;
511 
512  if (!already_initialized)
513  if ((ret = avformat_init_output(s, options)) < 0)
514  return ret;
515 
516  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
518  if (s->oformat->write_header) {
519  ret = s->oformat->write_header(s);
520  if (ret >= 0 && s->pb && s->pb->error < 0)
521  ret = s->pb->error;
522  if (ret < 0)
523  goto fail;
524  flush_if_needed(s);
525  }
526  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
528 
529  if (!s->internal->streams_initialized) {
530  if ((ret = init_pts(s)) < 0)
531  goto fail;
532  }
533 
534  return streams_already_initialized;
535 
536 fail:
537  deinit_muxer(s);
538  return ret;
539 }
540 
541 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
542 
543 
544 #if FF_API_COMPUTE_PKT_FIELDS2
546 //FIXME merge with compute_pkt_fields
547 static int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)
548 {
549  int delay = FFMAX(st->codecpar->video_delay, st->internal->avctx->max_b_frames > 0);
550  int i;
551  int frame_size;
552 
553  if (!s->internal->missing_ts_warning &&
554  !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
556  (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
558  "Timestamps are unset in a packet for stream %d. "
559  "This is deprecated and will stop working in the future. "
560  "Fix your code to set the timestamps properly\n", st->index);
561  s->internal->missing_ts_warning = 1;
562  }
563 
564  if (s->debug & FF_FDEBUG_TS)
565  av_log(s, AV_LOG_DEBUG, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
566  av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), delay, pkt->size, pkt->stream_index);
567 
568  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
569  pkt->pts = pkt->dts;
570 
571  //XXX/FIXME this is a temporary hack until all encoders output pts
572  if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
573  static int warned;
574  if (!warned) {
575  av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
576  warned = 1;
577  }
578  pkt->dts =
579 // pkt->pts= st->cur_dts;
580  pkt->pts = st->internal->priv_pts->val;
581  }
582 
583  //calculate dts from pts
584  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
585  st->internal->pts_buffer[0] = pkt->pts;
586  for (i = 1; i < delay + 1 && st->internal->pts_buffer[i] == AV_NOPTS_VALUE; i++)
587  st->internal->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
588  for (i = 0; i<delay && st->internal->pts_buffer[i] > st->internal->pts_buffer[i + 1]; i++)
589  FFSWAP(int64_t, st->internal->pts_buffer[i], st->internal->pts_buffer[i + 1]);
590 
591  pkt->dts = st->internal->pts_buffer[0];
592  }
593 
594  if (st->cur_dts && st->cur_dts != AV_NOPTS_VALUE &&
595  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
598  st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
599  av_log(s, AV_LOG_ERROR,
600  "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
601  st->index, av_ts2str(st->cur_dts), av_ts2str(pkt->dts));
602  return AVERROR(EINVAL);
603  }
604  if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
605  av_log(s, AV_LOG_ERROR,
606  "pts (%s) < dts (%s) in stream %d\n",
607  av_ts2str(pkt->pts), av_ts2str(pkt->dts),
608  st->index);
609  return AVERROR(EINVAL);
610  }
611 
612  if (s->debug & FF_FDEBUG_TS)
613  av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n",
614  av_ts2str(pkt->pts), av_ts2str(pkt->dts));
615 
616  st->cur_dts = pkt->dts;
617  st->internal->priv_pts->val = pkt->dts;
618 
619  /* update pts */
620  switch (st->codecpar->codec_type) {
621  case AVMEDIA_TYPE_AUDIO:
622  frame_size = (pkt->flags & AV_PKT_FLAG_UNCODED_FRAME) ?
623  (*(AVFrame **)pkt->data)->nb_samples :
625 
626  /* HACK/FIXME, we skip the initial 0 size packets as they are most
627  * likely equal to the encoder delay, but it would be better if we
628  * had the real timestamps from the encoder */
629  if (frame_size >= 0 && (pkt->size || st->internal->priv_pts->num != st->internal->priv_pts->den >> 1 || st->internal->priv_pts->val)) {
630  frac_add(st->internal->priv_pts, (int64_t)st->time_base.den * frame_size);
631  }
632  break;
633  case AVMEDIA_TYPE_VIDEO:
634  frac_add(st->internal->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
635  break;
636  }
637  return 0;
638 }
640 #endif
641 
643 {
644  if (pkt->duration < 0 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
645  av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
646  pkt->duration, pkt->stream_index);
647  pkt->duration = 0;
648  }
649 
650  if (pkt->duration)
651  return;
652 
653  switch (st->codecpar->codec_type) {
654  case AVMEDIA_TYPE_VIDEO:
655  if (st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0) {
657  st->time_base);
658  } else if (st->time_base.num * 1000LL > st->time_base.den)
659  pkt->duration = 1;
660  break;
661  case AVMEDIA_TYPE_AUDIO: {
663  if (frame_size && st->codecpar->sample_rate) {
664  pkt->duration = av_rescale_q(frame_size,
665  (AVRational){1, st->codecpar->sample_rate},
666  st->time_base);
667  }
668  break;
669  }
670  }
671 }
672 
673 /**
674  * Shift timestamps and call muxer; the original pts/dts are not kept.
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 
685  // If the timestamp offsetting below is adjusted, adjust
686  // ff_interleaved_peek similarly.
687  if (s->output_ts_offset) {
688  AVStream *st = s->streams[pkt->stream_index];
690 
691  if (pkt->dts != AV_NOPTS_VALUE)
692  pkt->dts += offset;
693  if (pkt->pts != AV_NOPTS_VALUE)
694  pkt->pts += offset;
695  }
696 
697  if (s->avoid_negative_ts > 0) {
698  AVStream *st = s->streams[pkt->stream_index];
699  int64_t offset = st->internal->mux_ts_offset;
700  int64_t ts = s->internal->avoid_negative_ts_use_pts ? pkt->pts : pkt->dts;
701 
702  if (s->internal->offset == AV_NOPTS_VALUE && ts != AV_NOPTS_VALUE &&
703  (ts < 0 || s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO)) {
704  s->internal->offset = -ts;
706  }
707 
708  if (s->internal->offset != AV_NOPTS_VALUE && !offset) {
709  offset = st->internal->mux_ts_offset =
712  st->time_base,
713  AV_ROUND_UP);
714  }
715 
716  if (pkt->dts != AV_NOPTS_VALUE)
717  pkt->dts += offset;
718  if (pkt->pts != AV_NOPTS_VALUE)
719  pkt->pts += offset;
720 
722  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < 0) {
723  av_log(s, AV_LOG_WARNING, "failed to avoid negative "
724  "pts %s in stream %d.\n"
725  "Try -avoid_negative_ts 1 as a possible workaround.\n",
726  av_ts2str(pkt->pts),
727  pkt->stream_index
728  );
729  }
730  } else {
731  av_assert2(pkt->dts == AV_NOPTS_VALUE || pkt->dts >= 0 || s->max_interleave_delta > 0);
732  if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < 0) {
734  "Packets poorly interleaved, failed to avoid negative "
735  "timestamp %s in stream %d.\n"
736  "Try -max_interleave_delta 0 as a possible workaround.\n",
737  av_ts2str(pkt->dts),
738  pkt->stream_index
739  );
740  }
741  }
742  }
743 
744  if ((pkt->flags & AV_PKT_FLAG_UNCODED_FRAME)) {
745  AVFrame **frame = (AVFrame **)pkt->data;
746  av_assert0(pkt->size == sizeof(*frame));
747  ret = s->oformat->write_uncoded_frame(s, pkt->stream_index, frame, 0);
748  } else {
749  ret = s->oformat->write_packet(s, pkt);
750  }
751 
752  if (s->pb && ret >= 0) {
753  flush_if_needed(s);
754  if (s->pb->error < 0)
755  ret = s->pb->error;
756  }
757 
758  if (ret >= 0)
759  s->streams[pkt->stream_index]->nb_frames++;
760 
761  return ret;
762 }
763 
765 {
766  if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
767  av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
768  pkt->stream_index);
769  return AVERROR(EINVAL);
770  }
771 
773  av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
774  return AVERROR(EINVAL);
775  }
776 
777  return 0;
778 }
779 
781 {
782 #if !FF_API_COMPUTE_PKT_FIELDS2
783  /* sanitize the timestamps */
784  if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
785 
786  /* when there is no reordering (so dts is equal to pts), but
787  * only one of them is set, set the other as well */
788  if (!st->internal->reorder) {
789  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)
790  pkt->pts = pkt->dts;
791  if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
792  pkt->dts = pkt->pts;
793  }
794 
795  /* check that the timestamps are set */
796  if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {
797  av_log(s, AV_LOG_ERROR,
798  "Timestamps are unset in a packet for stream %d\n", st->index);
799  return AVERROR(EINVAL);
800  }
801 
802  /* check that the dts are increasing (or at least non-decreasing,
803  * if the format allows it */
804  if (st->cur_dts != AV_NOPTS_VALUE &&
805  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && st->cur_dts >= pkt->dts) ||
806  st->cur_dts > pkt->dts)) {
807  av_log(s, AV_LOG_ERROR,
808  "Application provided invalid, non monotonically increasing "
809  "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
810  st->index, st->cur_dts, pkt->dts);
811  return AVERROR(EINVAL);
812  }
813 
814  if (pkt->pts < pkt->dts) {
815  av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
816  pkt->pts, pkt->dts, st->index);
817  return AVERROR(EINVAL);
818  }
819  }
820 #endif
821  /* update flags */
822  if (st->internal->is_intra_only)
823  pkt->flags |= AV_PKT_FLAG_KEY;
824 
825  return 0;
826 }
827 
828 #define CHUNK_START 0x1000
829 
831  int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
832 {
833  int ret;
834  PacketList **next_point, *this_pktl;
835  AVStream *st = s->streams[pkt->stream_index];
836  int chunked = s->max_chunk_size || s->max_chunk_duration;
837 
838  this_pktl = av_malloc(sizeof(PacketList));
839  if (!this_pktl) {
840  av_packet_unref(pkt);
841  return AVERROR(ENOMEM);
842  }
843  if ((ret = av_packet_make_refcounted(pkt)) < 0) {
844  av_free(this_pktl);
845  av_packet_unref(pkt);
846  return ret;
847  }
848 
849  av_packet_move_ref(&this_pktl->pkt, pkt);
850  pkt = &this_pktl->pkt;
851 
852  if (st->internal->last_in_packet_buffer) {
853  next_point = &(st->internal->last_in_packet_buffer->next);
854  } else {
855  next_point = &s->internal->packet_buffer;
856  }
857 
858  if (chunked) {
860  st->internal->interleaver_chunk_size += pkt->size;
863  || (max && st->internal->interleaver_chunk_duration > max)) {
865  pkt->flags |= CHUNK_START;
866  if (max && st->internal->interleaver_chunk_duration > max) {
867  int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
868  int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
869 
870  st->internal->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
871  } else
873  }
874  }
875  if (*next_point) {
876  if (chunked && !(pkt->flags & CHUNK_START))
877  goto next_non_null;
878 
879  if (compare(s, &s->internal->packet_buffer_end->pkt, pkt)) {
880  while ( *next_point
881  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
882  || !compare(s, &(*next_point)->pkt, pkt)))
883  next_point = &(*next_point)->next;
884  if (*next_point)
885  goto next_non_null;
886  } else {
887  next_point = &(s->internal->packet_buffer_end->next);
888  }
889  }
890  av_assert1(!*next_point);
891 
892  s->internal->packet_buffer_end = this_pktl;
893 next_non_null:
894 
895  this_pktl->next = *next_point;
896 
897  st->internal->last_in_packet_buffer = *next_point = this_pktl;
898 
899  return 0;
900 }
901 
903  const AVPacket *pkt)
904 {
905  AVStream *st = s->streams[pkt->stream_index];
906  AVStream *st2 = s->streams[next->stream_index];
907  int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
908  st->time_base);
909  if (s->audio_preload) {
910  int preload = st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
911  int preload2 = st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
912  if (preload != preload2) {
913  int64_t ts, ts2;
914  preload *= s->audio_preload;
915  preload2 *= s->audio_preload;
916  ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - preload;
917  ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - preload2;
918  if (ts == ts2) {
919  ts = ((uint64_t)pkt ->dts*st ->time_base.num*AV_TIME_BASE - (uint64_t)preload *st ->time_base.den)*st2->time_base.den
920  - ((uint64_t)next->dts*st2->time_base.num*AV_TIME_BASE - (uint64_t)preload2*st2->time_base.den)*st ->time_base.den;
921  ts2 = 0;
922  }
923  comp = (ts2 > ts) - (ts2 < ts);
924  }
925  }
926 
927  if (comp == 0)
928  return pkt->stream_index < next->stream_index;
929  return comp > 0;
930 }
931 
933  AVPacket *pkt, int flush)
934 {
935  PacketList *pktl;
936  int stream_count = 0;
937  int noninterleaved_count = 0;
938  int i, ret;
939  int eof = flush;
940 
941  if (pkt) {
942  if ((ret = ff_interleave_add_packet(s, pkt, interleave_compare_dts)) < 0)
943  return ret;
944  }
945 
946  for (i = 0; i < s->nb_streams; i++) {
947  if (s->streams[i]->internal->last_in_packet_buffer) {
948  ++stream_count;
949  } else if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
952  ++noninterleaved_count;
953  }
954  }
955 
956  if (s->internal->nb_interleaved_streams == stream_count)
957  flush = 1;
958 
959  if (s->max_interleave_delta > 0 &&
960  s->internal->packet_buffer &&
961  !flush &&
962  s->internal->nb_interleaved_streams == stream_count+noninterleaved_count
963  ) {
964  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
965  int64_t delta_dts = INT64_MIN;
966  int64_t top_dts = av_rescale_q(top_pkt->dts,
967  s->streams[top_pkt->stream_index]->time_base,
969 
970  for (i = 0; i < s->nb_streams; i++) {
971  int64_t last_dts;
972  const PacketList *last = s->streams[i]->internal->last_in_packet_buffer;
973 
974  if (!last)
975  continue;
976 
977  last_dts = av_rescale_q(last->pkt.dts,
978  s->streams[i]->time_base,
980  delta_dts = FFMAX(delta_dts, last_dts - top_dts);
981  }
982 
983  if (delta_dts > s->max_interleave_delta) {
984  av_log(s, AV_LOG_DEBUG,
985  "Delay between the first packet and last packet in the "
986  "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
987  delta_dts, s->max_interleave_delta);
988  flush = 1;
989  }
990  }
991 
992  if (s->internal->packet_buffer &&
993  eof &&
994  (s->flags & AVFMT_FLAG_SHORTEST) &&
996  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
997 
998  s->internal->shortest_end = av_rescale_q(top_pkt->dts,
999  s->streams[top_pkt->stream_index]->time_base,
1000  AV_TIME_BASE_Q);
1001  }
1002 
1003  if (s->internal->shortest_end != AV_NOPTS_VALUE) {
1004  while (s->internal->packet_buffer) {
1005  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
1006  AVStream *st;
1007  int64_t top_dts = av_rescale_q(top_pkt->dts,
1008  s->streams[top_pkt->stream_index]->time_base,
1009  AV_TIME_BASE_Q);
1010 
1011  if (s->internal->shortest_end + 1 >= top_dts)
1012  break;
1013 
1014  pktl = s->internal->packet_buffer;
1015  st = s->streams[pktl->pkt.stream_index];
1016 
1017  s->internal->packet_buffer = pktl->next;
1018  if (!s->internal->packet_buffer)
1020 
1021  if (st->internal->last_in_packet_buffer == pktl)
1023 
1024  av_packet_unref(&pktl->pkt);
1025  av_freep(&pktl);
1026  flush = 0;
1027  }
1028  }
1029 
1030  if (stream_count && flush) {
1031  AVStream *st;
1032  pktl = s->internal->packet_buffer;
1033  *out = pktl->pkt;
1034  st = s->streams[out->stream_index];
1035 
1036  s->internal->packet_buffer = pktl->next;
1037  if (!s->internal->packet_buffer)
1039 
1040  if (st->internal->last_in_packet_buffer == pktl)
1042  av_freep(&pktl);
1043 
1044  return 1;
1045  } else {
1046  return 0;
1047  }
1048 }
1049 
1050 int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
1051 {
1052  AVStream *st;
1053 
1054  if (stream_index < 0 || stream_index >= s->nb_streams)
1055  return AVERROR(EINVAL);
1056 
1057  st = s->streams[stream_index];
1058  *offset = st->internal->mux_ts_offset;
1059 
1060  if (s->output_ts_offset)
1062 
1063  return 0;
1064 }
1065 
1067 {
1068  PacketList *pktl = s->internal->packet_buffer;
1069  while (pktl) {
1070  if (pktl->pkt.stream_index == stream) {
1071  return &pktl->pkt;
1072  }
1073  pktl = pktl->next;
1074  }
1075  return NULL;
1076 }
1077 
1078 /**
1079  * Interleave an AVPacket correctly so it can be muxed.
1080  * @param out the interleaved packet will be output here
1081  * @param in the input packet; will always be blank on return if not NULL
1082  * @param flush 1 if no further packets are available as input and all
1083  * remaining packets should be output
1084  * @return 1 if a packet was output, 0 if no packet could be output,
1085  * < 0 if an error occurred
1086  */
1088 {
1089  if (s->oformat->interleave_packet) {
1090  return s->oformat->interleave_packet(s, out, in, flush);
1091  } else
1092  return ff_interleave_packet_per_dts(s, out, in, flush);
1093 }
1094 
1096 {
1097  int ret;
1098 
1099  if (!(s->flags & AVFMT_FLAG_AUTO_BSF))
1100  return 1;
1101 
1102  if (s->oformat->check_bitstream) {
1103  if (!st->internal->bitstream_checked) {
1104  if ((ret = s->oformat->check_bitstream(s, pkt)) < 0)
1105  return ret;
1106  else if (ret == 1)
1107  st->internal->bitstream_checked = 1;
1108  }
1109  }
1110 
1111  return 1;
1112 }
1113 
1115 {
1116  for (;; ) {
1117  AVPacket opkt;
1118  int ret = interleave_packet(s, &opkt, pkt, flush);
1119  if (ret <= 0)
1120  return ret;
1121 
1122  pkt = NULL;
1123 
1124  ret = write_packet(s, &opkt);
1125 
1126  av_packet_unref(&opkt);
1127 
1128  if (ret < 0)
1129  return ret;
1130  }
1131 }
1132 
1133 static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1134 {
1135  int ret;
1136 
1137  if (s->debug & FF_FDEBUG_TS)
1138  av_log(s, AV_LOG_DEBUG, "%s size:%d dts:%s pts:%s\n", __FUNCTION__,
1139  pkt->size, av_ts2str(pkt->dts), av_ts2str(pkt->pts));
1140 
1141  guess_pkt_duration(s, st, pkt);
1142 
1143 #if FF_API_COMPUTE_PKT_FIELDS2
1144  if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1145  return ret;
1146 #endif
1147 
1148  if (interleaved) {
1149  if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1150  return AVERROR(EINVAL);
1151  return interleaved_write_packet(s, pkt, 0);
1152  } else {
1153  return write_packet(s, pkt);
1154  }
1155 }
1156 
1157 static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1158 {
1159  AVBSFContext *bsfc = st->internal->bsfc;
1160  int ret;
1161 
1162  if ((ret = av_bsf_send_packet(bsfc, pkt)) < 0) {
1163  av_log(s, AV_LOG_ERROR,
1164  "Failed to send packet to filter %s for stream %d\n",
1165  bsfc->filter->name, st->index);
1166  return ret;
1167  }
1168 
1169  do {
1170  ret = av_bsf_receive_packet(bsfc, pkt);
1171  if (ret < 0) {
1172  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
1173  return 0;
1174  av_log(s, AV_LOG_ERROR, "Error applying bitstream filters to an output "
1175  "packet for stream #%d: %s\n", st->index, av_err2str(ret));
1176  if (!(s->error_recognition & AV_EF_EXPLODE) && ret != AVERROR(ENOMEM))
1177  continue;
1178  return ret;
1179  }
1180  av_packet_rescale_ts(pkt, bsfc->time_base_out, st->time_base);
1181  ret = write_packet_common(s, st, pkt, interleaved);
1182  if (ret >= 0 && !interleaved) // a successful write_packet_common already unrefed pkt for interleaved
1183  av_packet_unref(pkt);
1184  } while (ret >= 0);
1185 
1186  return ret;
1187 }
1188 
1189 static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
1190 {
1191  AVStream *st;
1192  int ret = check_packet(s, pkt);
1193  if (ret < 0)
1194  return ret;
1195  st = s->streams[pkt->stream_index];
1196 
1197  ret = prepare_input_packet(s, st, pkt);
1198  if (ret < 0)
1199  return ret;
1200 
1201  ret = check_bitstream(s, st, pkt);
1202  if (ret < 0)
1203  return ret;
1204 
1205  if (st->internal->bsfc) {
1206  return write_packets_from_bsfs(s, st, pkt, interleaved);
1207  } else {
1208  return write_packet_common(s, st, pkt, interleaved);
1209  }
1210 }
1211 
1213 {
1214  AVPacket *pkt = s->internal->pkt;
1215  int ret;
1216 
1217  if (!in) {
1218  if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
1219  ret = s->oformat->write_packet(s, NULL);
1220  flush_if_needed(s);
1221  if (ret >= 0 && s->pb && s->pb->error < 0)
1222  ret = s->pb->error;
1223  return ret;
1224  }
1225  return 1;
1226  }
1227 
1228  if (in->flags & AV_PKT_FLAG_UNCODED_FRAME) {
1229  pkt = in;
1230  } else {
1231  /* We don't own in, so we have to make sure not to modify it.
1232  * The following avoids copying in's data unnecessarily.
1233  * Copying side data is unavoidable as a bitstream filter
1234  * may change it, e.g. free it on errors. */
1235  av_packet_unref(pkt);
1236  pkt->buf = NULL;
1237  pkt->data = in->data;
1238  pkt->size = in->size;
1239  ret = av_packet_copy_props(pkt, in);
1240  if (ret < 0)
1241  return ret;
1242  if (in->buf) {
1243  pkt->buf = av_buffer_ref(in->buf);
1244  if (!pkt->buf) {
1245  ret = AVERROR(ENOMEM);
1246  goto fail;
1247  }
1248  }
1249  }
1250 
1251  ret = write_packets_common(s, pkt, 0/*non-interleaved*/);
1252 
1253 fail:
1254  // Uncoded frames using the noninterleaved codepath are also freed here
1255  av_packet_unref(pkt);
1256  return ret;
1257 }
1258 
1260 {
1261  int ret;
1262 
1263  if (pkt) {
1264  ret = write_packets_common(s, pkt, 1/*interleaved*/);
1265  if (ret < 0)
1266  av_packet_unref(pkt);
1267  return ret;
1268  } else {
1269  av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");
1270  return interleaved_write_packet(s, NULL, 1/*flush*/);
1271  }
1272 }
1273 
1275 {
1276  int i, ret1, ret = 0;
1277  AVPacket *pkt = s->internal->pkt;
1278 
1279  av_packet_unref(pkt);
1280  for (i = 0; i < s->nb_streams; i++) {
1281  if (s->streams[i]->internal->bsfc) {
1282  ret1 = write_packets_from_bsfs(s, s->streams[i], pkt, 1/*interleaved*/);
1283  if (ret1 < 0)
1284  av_packet_unref(pkt);
1285  if (ret >= 0)
1286  ret = ret1;
1287  }
1288  }
1289  ret1 = interleaved_write_packet(s, NULL, 1);
1290  if (ret >= 0)
1291  ret = ret1;
1292 
1293  if (s->oformat->write_trailer) {
1294  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1296  if (ret >= 0) {
1297  ret = s->oformat->write_trailer(s);
1298  } else {
1299  s->oformat->write_trailer(s);
1300  }
1301  }
1302 
1303  deinit_muxer(s);
1304 
1305  if (s->pb)
1306  avio_flush(s->pb);
1307  if (ret == 0)
1308  ret = s->pb ? s->pb->error : 0;
1309  for (i = 0; i < s->nb_streams; i++) {
1310  av_freep(&s->streams[i]->priv_data);
1312  }
1313  if (s->oformat->priv_class)
1314  av_opt_free(s->priv_data);
1315  av_freep(&s->priv_data);
1316  return ret;
1317 }
1318 
1319 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
1320  int64_t *dts, int64_t *wall)
1321 {
1322  if (!s->oformat || !s->oformat->get_output_timestamp)
1323  return AVERROR(ENOSYS);
1324  s->oformat->get_output_timestamp(s, stream, dts, wall);
1325  return 0;
1326 }
1327 
1328 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
1330 {
1331  AVPacket local_pkt;
1332  int ret;
1333 
1334  local_pkt = *pkt;
1335  local_pkt.stream_index = dst_stream;
1336 
1337  av_packet_rescale_ts(&local_pkt,
1338  src->streams[pkt->stream_index]->time_base,
1339  dst->streams[dst_stream]->time_base);
1340 
1341  if (interleave) ret = av_interleaved_write_frame(dst, &local_pkt);
1342  else ret = av_write_frame(dst, &local_pkt);
1343  pkt->buf = local_pkt.buf;
1344  pkt->side_data = local_pkt.side_data;
1345  pkt->side_data_elems = local_pkt.side_data_elems;
1346  return ret;
1347 }
1348 
1349 static void uncoded_frame_free(void *unused, uint8_t *data)
1350 {
1351  av_frame_free((AVFrame **)data);
1352  av_free(data);
1353 }
1354 
1355 static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
1356  AVFrame *frame, int interleaved)
1357 {
1358  AVPacket *pkt = s->internal->pkt;
1359 
1360  av_assert0(s->oformat);
1361  if (!s->oformat->write_uncoded_frame) {
1362  av_frame_free(&frame);
1363  return AVERROR(ENOSYS);
1364  }
1365 
1366  if (!frame) {
1367  pkt = NULL;
1368  } else {
1369  size_t bufsize = sizeof(frame) + AV_INPUT_BUFFER_PADDING_SIZE;
1370  AVFrame **framep = av_mallocz(bufsize);
1371 
1372  if (!framep)
1373  goto fail;
1374  av_packet_unref(pkt);
1375  pkt->buf = av_buffer_create((void *)framep, bufsize,
1376  uncoded_frame_free, NULL, 0);
1377  if (!pkt->buf) {
1378  av_free(framep);
1379  fail:
1380  av_frame_free(&frame);
1381  return AVERROR(ENOMEM);
1382  }
1383  *framep = frame;
1384 
1385  pkt->data = (void *)framep;
1386  pkt->size = sizeof(frame);
1387  pkt->pts =
1388  pkt->dts = frame->pts;
1389  pkt->duration = frame->pkt_duration;
1390  pkt->stream_index = stream_index;
1392  }
1393 
1394  return interleaved ? av_interleaved_write_frame(s, pkt) :
1395  av_write_frame(s, pkt);
1396 }
1397 
1398 int av_write_uncoded_frame(AVFormatContext *s, int stream_index,
1399  AVFrame *frame)
1400 {
1401  return write_uncoded_frame_internal(s, stream_index, frame, 0);
1402 }
1403 
1405  AVFrame *frame)
1406 {
1407  return write_uncoded_frame_internal(s, stream_index, frame, 1);
1408 }
1409 
1411 {
1412  av_assert0(s->oformat);
1413  if (!s->oformat->write_uncoded_frame)
1414  return AVERROR(ENOSYS);
1415  return s->oformat->write_uncoded_frame(s, stream_index, NULL,
1417 }
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:136
#define AV_CODEC_PROP_REORDER
Codec supports frame reordering.
Definition: codec_desc.h:92
static float compare(const AVFrame *haystack, const AVFrame *obj, int offx, int offy)
Definition: vf_find_rect.c:106
enum AVChromaLocation chroma_location
Definition: codec_par.h:150
fg outputs[0] format
#define NULL
Definition: coverity.c:32
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
AVBSFContext * bsfc
bitstream filter to run on stream
Definition: internal.h:182
int audio_preload
Audio preload in microseconds.
Definition: avformat.h:1609
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int check_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:764
enum AVCodecID id
Definition: internal.h:43
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:607
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file ensuring correct interleaving.
Definition: mux.c:1259
int bitstream_checked
Whether or not check_bitstream should still be run on each packet.
Definition: internal.h:187
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
FFFrac * priv_pts
Definition: internal.h:215
static void flush(AVCodecContext *avctx)
static void uncoded_frame_free(void *unused, uint8_t *data)
Definition: mux.c:1349
int flush_packets
Flush the I/O context after each packet.
Definition: avformat.h:1676
int av_write_frame(AVFormatContext *s, AVPacket *in)
Write a packet to an output media file.
Definition: mux.c:1212
const char * desc
Definition: libsvtav1.c:79
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
int reorder
Set to 1 if the codec allows reordering, so pts can be different from dts.
Definition: internal.h:175
AVPacket * pkt
Used to hold temporary packets.
Definition: internal.h:112
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:4999
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:2441
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:796
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:136
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1358
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: bsf.h:58
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:946
int num
Numerator.
Definition: rational.h:59
struct PacketList * packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:76
The bitstream filter state.
Definition: bsf.h:49
int index
stream index in AVFormatContext
Definition: avformat.h:885
static int prepare_input_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:780
int size
Definition: packet.h:370
int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
Interleave an AVPacket per dts so it can be muxed.
Definition: mux.c:932
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1714
static void deinit_muxer(AVFormatContext *s)
Definition: mux.c:478
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:1319
static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index, AVFrame *frame, int interleaved)
Definition: mux.c:1355
int64_t offset
Offset to remap timestamps to be non-negative.
Definition: internal.h:124
int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)
Definition: mux.c:1050
void * priv_data
Definition: avformat.h:899
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
int avoid_negative_ts_use_pts
Definition: internal.h:137
int av_write_uncoded_frame_query(AVFormatContext *s, int stream_index)
Test whether a muxer supports uncoded frame.
Definition: mux.c:1410
AVPacket * pkt
Definition: movenc.c:59
static void error(const char *err)
int64_t interleaver_chunk_size
Definition: internal.h:255
#define AVFMT_ALLOW_FLUSH
Format allows flushing.
Definition: avformat.h:471
int strict_std_compliance
Allow non-standard and experimental extension.
Definition: avformat.h:1557
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:472
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
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:1328
static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
Definition: mux.c:1189
int(* interleave_packet)(struct AVFormatContext *, AVPacket *out, AVPacket *in, int flush)
A format-specific function for interleavement.
Definition: avformat.h:568
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:1247
int64_t output_ts_offset
Output timestamp offset, in microseconds.
Definition: avformat.h:1778
int64_t cur_dts
Definition: avformat.h:1077
static void interleave(uint8_t *dst, uint8_t *src, int w, int h, int dst_linesize, int src_linesize, enum FilterMode mode, int swap)
Definition: vf_il.c:114
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define CHUNK_START
Definition: mux.c:828
Public dictionary API.
static void flush_if_needed(AVFormatContext *s)
Definition: mux.c:468
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:519
uint8_t
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: codec_par.h:126
#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:820
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
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:552
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: packet.h:387
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:411
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:479
int64_t mux_ts_offset
Timestamp offset added to timestamps before muxing.
Definition: internal.h:309
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1315
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:211
const char * name
Definition: bsf.h:99
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:1378
uint8_t * data
Definition: packet.h:369
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:1551
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:690
uint32_t tag
Definition: movenc.c:1600
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define max(a, b)
Definition: cuda_runtime.h:33
#define AVSTREAM_INIT_IN_WRITE_HEADER
stream parameters initialized in avformat_write_header
Definition: avformat.h:2440
static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush)
Interleave an AVPacket correctly so it can be muxed.
Definition: mux.c:1087
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1395
struct PacketList * next
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
static int interleave_compare_dts(AVFormatContext *s, const AVPacket *next, const AVPacket *pkt)
Definition: mux.c:902
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 src
Definition: vp8dsp.c:255
#define ff_const59
The ff_const59 define is not part of the public API and will be removed without further warning...
Definition: avformat.h:544
#define AVFMT_FLAG_FLUSH_PACKETS
Flush the AVIOContext every packet.
Definition: avformat.h:1388
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1489
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:613
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 src_tb, AVRational dst_tb)
Convert valid timing fields (timestamps / durations) in a packet from one timebase to another...
Definition: avpacket.c:737
static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1133
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
Definition: mux.c:197
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
#define AV_PKT_FLAG_UNCODED_FRAME
Definition: mux.c:541
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:204
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:1343
int video_delay
Video only.
Definition: codec_par.h:155
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
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: codec_par.h:56
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:352
simple assert() macros that are a bit more flexible than ISO C assert().
int side_data_elems
Definition: packet.h:381
AVBufferRef * av_buffer_create(uint8_t *data, buffer_size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:29
int ff_is_intra_only(enum AVCodecID id)
Definition: utils.c:1041
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:957
#define FFMAX(a, b)
Definition: common.h:103
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:835
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:133
static void guess_pkt_duration(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:642
const AVPacket * ff_interleaved_peek(AVFormatContext *s, int stream)
Find the next packet in the interleaving queue for the given stream.
Definition: mux.c:1066
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
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: codec_desc.h:54
static int write_packet(AVFormatContext *s, AVPacket *pkt)
Shift timestamps and call muxer; the original pts/dts are not kept.
Definition: mux.c:681
int streams_initialized
Whether or not avformat_init_output fully initialized streams.
Definition: internal.h:152
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:250
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1303
#define LIBAVFORMAT_IDENT
Definition: version.h:46
int block_align
Audio only.
Definition: codec_par.h:177
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:600
This is any, unlabelled data.
Definition: avio.h:135
struct PacketList * last_in_packet_buffer
last packet in packet_buffer for this stream when muxing.
Definition: internal.h:367
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
int(* write_header)(struct AVFormatContext *)
Definition: avformat.h:554
#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:142
#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:506
int(* write_uncoded_frame)(struct AVFormatContext *, int stream_index, AVFrame **frame, unsigned flags)
Write an uncoded AVFrame.
Definition: avformat.h:595
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:560
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: bsf.h:95
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:696
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:609
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
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:1592
static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
f = val + (num / den) + 0.5.
Definition: mux.c:52
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1656
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
static int init_muxer(AVFormatContext *s, AVDictionary **options)
Definition: mux.c:231
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:528
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:486
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
Definition: opt.c:1631
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
AVPacket pkt
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:852
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1266
if(ret)
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:85
Stream structure.
Definition: avformat.h:884
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:462
#define FF_FDEBUG_TS
Definition: avformat.h:1533
int frame_size
Definition: mxfenc.c:2206
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:201
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1157
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1123
int64_t pkt_duration
duration of the corresponding packet, expressed in AVStream->time_base units, 0 if unknown...
Definition: frame.h:597
int debug
Flags to enable debugging.
Definition: avformat.h:1532
#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:1656
AVIOContext * pb
I/O context.
Definition: avformat.h:1289
const struct AVCodecTag *const * codec_tag
List of supported codec_id-codec_tag pairs, ordered by "better choice first".
Definition: avformat.h:525
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:634
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:227
int(* write_trailer)(struct AVFormatContext *)
Definition: avformat.h:563
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
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:147
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1604
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:895
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 an AVFormatContext&#39;s packet_buffer list, determining its interleaved position using com...
Definition: mux.c:830
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:857
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: codec_par.c:90
void(* get_output_timestamp)(struct AVFormatContext *s, int stream, int64_t *dts, int64_t *wall)
Definition: avformat.h:579
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:245
enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:106
AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:90
#define AVFMT_AVOID_NEG_TS_AUTO
Enabled when required by target format.
Definition: avformat.h:1593
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4480
#define AVFMT_FLAG_AUTO_BSF
Add bitstream filters as requested by the muxer.
Definition: avformat.h:1408
int error
contains the error code or 0 if no error happened
Definition: avio.h:245
struct PacketList * packet_buffer_end
Definition: internal.h:77
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: codec_desc.h:38
unsigned int tag
Definition: internal.h:44
AVRational offset_timebase
Timebase for the timestamp offset.
Definition: internal.h:129
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
int sample_rate
Audio only.
Definition: codec_par.h:170
#define AVFMT_AVOID_NEG_TS_MAKE_ZERO
Shift timestamps so that they start at 0.
Definition: avformat.h:1595
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: packet.h:380
int64_t pts_buffer[MAX_REORDER_DELAY+1]
Definition: internal.h:341
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1611
const OptionDef options[]
Definition: ffmpeg_opt.c:3427
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
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:1404
common internal api header.
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:458
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:467
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:1625
int error_recognition
Error recognition; higher values will detect more errors but may misdetect some more or less valid pa...
Definition: avformat.h:1516
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:937
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
static void frac_add(FFFrac *f, int64_t incr)
Fractional addition to f: f = f + (incr / f->den).
Definition: mux.c:70
static int init_pts(AVFormatContext *s)
Definition: mux.c:423
int64_t interleaver_chunk_duration
Definition: internal.h:256
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:935
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:1398
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
static int interleaved_write_packet(AVFormatContext *s, AVPacket *pkt, int flush)
Definition: mux.c:1114
#define AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE
Shift timestamps so they are non negative.
Definition: avformat.h:1594
#define av_free(p)
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
#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:1617
void * priv_data
Format private data.
Definition: avformat.h:1275
void(* deinit)(struct AVFormatContext *)
Deinitialize format.
Definition: avformat.h:633
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:466
static int check_bitstream(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:1095
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3501
int(* write_packet)(struct AVFormatContext *, AVPacket *pkt)
Write a packet.
Definition: avformat.h:562
int channels
Audio only.
Definition: codec_par.h:166
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:192
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:368
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
Definition: mux.c:1274
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:605
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:608
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1049
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: codec_par.h:64
#define FFSWAP(type, a, b)
Definition: common.h:108
int stream_index
Definition: packet.h:371
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:913
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:478
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:477
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:346
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
Header data; this needs to be present for the stream to be decodeable.
Definition: avio.h:115
int i
Definition: input.c:407
#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:1407
static uint8_t tmp[11]
Definition: aes_ctr.c:27