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"
25 #include "libavutil/opt.h"
26 #include "libavutil/dict.h"
27 #include "libavutil/pixdesc.h"
28 #include "libavutil/timestamp.h"
29 #include "libavutil/avassert.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/internal.h"
32 #include "libavutil/mathematics.h"
33 
34 /**
35  * @file
36  * muxing functions for use within libavformat
37  */
38 
39 /* fraction handling */
40 
41 /**
42  * f = val + (num / den) + 0.5.
43  *
44  * 'num' is normalized so that it is such as 0 <= num < den.
45  *
46  * @param f fractional number
47  * @param val integer value
48  * @param num must be >= 0
49  * @param den must be >= 1
50  */
51 static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
52 {
53  num += (den >> 1);
54  if (num >= den) {
55  val += num / den;
56  num = num % den;
57  }
58  f->val = val;
59  f->num = num;
60  f->den = den;
61 }
62 
63 /**
64  * Fractional addition to f: f = f + (incr / f->den).
65  *
66  * @param f fractional number
67  * @param incr increment, can be positive or negative
68  */
69 static void frac_add(FFFrac *f, int64_t incr)
70 {
71  int64_t num, den;
72 
73  num = f->num + incr;
74  den = f->den;
75  if (num < 0) {
76  f->val += num / den;
77  num = num % den;
78  if (num < 0) {
79  num += den;
80  f->val--;
81  }
82  } else if (num >= den) {
83  f->val += num / den;
84  num = num % den;
85  }
86  f->num = num;
87 }
88 
90 {
91  AVRational q;
92  int j;
93 
94  q = st->time_base;
95 
96  for (j=2; j<14; j+= 1+(j>2))
97  while (q.den / q.num < min_precision && q.num % j == 0)
98  q.num /= j;
99  while (q.den / q.num < min_precision && q.den < (1<<24))
100  q.den <<= 1;
101 
102  return q;
103 }
104 
106 {
107  AVCodecParameters *par = st->codecpar;
108  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(par->format);
109 
111  return par->chroma_location;
112 
113  if (pix_desc) {
114  if (pix_desc->log2_chroma_h == 0) {
115  return AVCHROMA_LOC_TOPLEFT;
116  } else if (pix_desc->log2_chroma_w == 1 && pix_desc->log2_chroma_h == 1) {
118  switch (par->codec_id) {
119  case AV_CODEC_ID_MJPEG:
121  }
122  }
124  switch (par->codec_id) {
126  }
127  }
128  }
129  }
130 
132 
133 }
134 
136  const char *format, const char *filename)
137 {
139  int ret = 0;
140 
141  *avctx = NULL;
142  if (!s)
143  goto nomem;
144 
145  if (!oformat) {
146  if (format) {
147  oformat = av_guess_format(format, NULL, NULL);
148  if (!oformat) {
149  av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
150  ret = AVERROR(EINVAL);
151  goto error;
152  }
153  } else {
154  oformat = av_guess_format(NULL, filename, NULL);
155  if (!oformat) {
156  ret = AVERROR(EINVAL);
157  av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
158  filename);
159  goto error;
160  }
161  }
162  }
163 
164  s->oformat = oformat;
165  if (s->oformat->priv_data_size > 0) {
166  s->priv_data = av_mallocz(s->oformat->priv_data_size);
167  if (!s->priv_data)
168  goto nomem;
169  if (s->oformat->priv_class) {
170  *(const AVClass**)s->priv_data= s->oformat->priv_class;
171  av_opt_set_defaults(s->priv_data);
172  }
173  } else
174  s->priv_data = NULL;
175 
176  if (filename) {
177 #if FF_API_FORMAT_FILENAME
179  av_strlcpy(s->filename, filename, sizeof(s->filename));
181 #endif
182  if (!(s->url = av_strdup(filename)))
183  goto nomem;
184 
185  }
186  *avctx = s;
187  return 0;
188 nomem:
189  av_log(s, AV_LOG_ERROR, "Out of memory\n");
190  ret = AVERROR(ENOMEM);
191 error:
193  return ret;
194 }
195 
197 {
198  const AVCodecTag *avctag;
199  int n;
200  enum AVCodecID id = AV_CODEC_ID_NONE;
201  int64_t tag = -1;
202 
203  /**
204  * Check that tag + id is in the table
205  * If neither is in the table -> OK
206  * If tag is in the table with another id -> FAIL
207  * If id is in the table with another tag -> FAIL unless strict < normal
208  */
209  for (n = 0; s->oformat->codec_tag[n]; n++) {
210  avctag = s->oformat->codec_tag[n];
211  while (avctag->id != AV_CODEC_ID_NONE) {
212  if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codecpar->codec_tag)) {
213  id = avctag->id;
214  if (id == st->codecpar->codec_id)
215  return 1;
216  }
217  if (avctag->id == st->codecpar->codec_id)
218  tag = avctag->tag;
219  avctag++;
220  }
221  }
222  if (id != AV_CODEC_ID_NONE)
223  return 0;
224  if (tag >= 0 && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
225  return 0;
226  return 1;
227 }
228 
229 
231 {
232  int ret = 0, i;
233  AVStream *st;
234  AVDictionary *tmp = NULL;
235  AVCodecParameters *par = NULL;
236  const AVOutputFormat *of = s->oformat;
237  const AVCodecDescriptor *desc;
239 
240  if (options)
241  av_dict_copy(&tmp, *options, 0);
242 
243  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
244  goto fail;
245  if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
246  (ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
247  goto fail;
248 
249 #if FF_API_FORMAT_FILENAME
251  if (!s->url && !(s->url = av_strdup(s->filename))) {
253 #else
254  if (!s->url && !(s->url = av_strdup(""))) {
255 #endif
256  ret = AVERROR(ENOMEM);
257  goto fail;
258  }
259 
260 #if FF_API_LAVF_AVCTX
262  if (s->nb_streams && s->streams[0]->codec->flags & AV_CODEC_FLAG_BITEXACT) {
263  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
265  "The AVFormatContext is not in set to bitexact mode, only "
266  "the AVCodecContext. If this is not intended, set "
267  "AVFormatContext.flags |= AVFMT_FLAG_BITEXACT.\n");
268  }
269  }
271 #endif
272 
273  // some sanity checks
274  if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) {
275  av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");
276  ret = AVERROR(EINVAL);
277  goto fail;
278  }
279 
280  for (i = 0; i < s->nb_streams; i++) {
281  st = s->streams[i];
282  par = st->codecpar;
283 
284 #if FF_API_LAVF_AVCTX
287  st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN) {
288  av_log(s, AV_LOG_WARNING, "Using AVStream.codec to pass codec "
289  "parameters to muxers is deprecated, use AVStream.codecpar "
290  "instead.\n");
291  ret = avcodec_parameters_from_context(st->codecpar, st->codec);
292  if (ret < 0)
293  goto fail;
294  }
296 #endif
297 
298  if (!st->time_base.num) {
299  /* fall back on the default timebase values */
300  if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)
301  avpriv_set_pts_info(st, 64, 1, par->sample_rate);
302  else
303  avpriv_set_pts_info(st, 33, 1, 90000);
304  }
305 
306  switch (par->codec_type) {
307  case AVMEDIA_TYPE_AUDIO:
308  if (par->sample_rate <= 0) {
309  av_log(s, AV_LOG_ERROR, "sample rate not set\n");
310  ret = AVERROR(EINVAL);
311  goto fail;
312  }
313  if (!par->block_align)
314  par->block_align = par->channels *
315  av_get_bits_per_sample(par->codec_id) >> 3;
316  break;
317  case AVMEDIA_TYPE_VIDEO:
318  if ((par->width <= 0 || par->height <= 0) &&
319  !(of->flags & AVFMT_NODIMENSIONS)) {
320  av_log(s, AV_LOG_ERROR, "dimensions not set\n");
321  ret = AVERROR(EINVAL);
322  goto fail;
323  }
326  ) {
327  if (st->sample_aspect_ratio.num != 0 &&
328  st->sample_aspect_ratio.den != 0 &&
329  par->sample_aspect_ratio.num != 0 &&
330  par->sample_aspect_ratio.den != 0) {
331  av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
332  "(%d/%d) and encoder layer (%d/%d)\n",
335  par->sample_aspect_ratio.den);
336  ret = AVERROR(EINVAL);
337  goto fail;
338  }
339  }
340  break;
341  }
342 
344  if (desc && desc->props & AV_CODEC_PROP_REORDER)
345  st->internal->reorder = 1;
346 
348 
349  if (of->codec_tag) {
350  if ( par->codec_tag
351  && par->codec_id == AV_CODEC_ID_RAWVIDEO
352  && ( av_codec_get_tag(of->codec_tag, par->codec_id) == 0
353  || av_codec_get_tag(of->codec_tag, par->codec_id) == MKTAG('r', 'a', 'w', ' '))
354  && !validate_codec_tag(s, st)) {
355  // the current rawvideo encoding system ends up setting
356  // the wrong codec_tag for avi/mov, we override it here
357  par->codec_tag = 0;
358  }
359  if (par->codec_tag) {
360  if (!validate_codec_tag(s, st)) {
361  const uint32_t otag = av_codec_get_tag(s->oformat->codec_tag, par->codec_id);
363  "Tag %s incompatible with output codec id '%d' (%s)\n",
364  av_fourcc2str(par->codec_tag), par->codec_id, av_fourcc2str(otag));
366  goto fail;
367  }
368  } else
369  par->codec_tag = av_codec_get_tag(of->codec_tag, par->codec_id);
370  }
371 
373  s->internal->nb_interleaved_streams++;
374  }
375 
376  if (!s->priv_data && of->priv_data_size > 0) {
377  s->priv_data = av_mallocz(of->priv_data_size);
378  if (!s->priv_data) {
379  ret = AVERROR(ENOMEM);
380  goto fail;
381  }
382  if (of->priv_class) {
383  *(const AVClass **)s->priv_data = of->priv_class;
384  av_opt_set_defaults(s->priv_data);
385  if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
386  goto fail;
387  }
388  }
389 
390  /* set muxer identification string */
391  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
392  av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
393  } else {
394  av_dict_set(&s->metadata, "encoder", NULL, 0);
395  }
396 
397  for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {
398  av_dict_set(&s->metadata, e->key, NULL, 0);
399  }
400 
401  if (options) {
403  *options = tmp;
404  }
405 
406  if (s->oformat->init) {
407  if ((ret = s->oformat->init(s)) < 0) {
408  if (s->oformat->deinit)
409  s->oformat->deinit(s);
410  return ret;
411  }
412  return ret == 0;
413  }
414 
415  return 0;
416 
417 fail:
418  av_dict_free(&tmp);
419  return ret;
420 }
421 
423 {
424  int i;
425  AVStream *st;
426 
427  /* init PTS generation */
428  for (i = 0; i < s->nb_streams; i++) {
429  int64_t den = AV_NOPTS_VALUE;
430  st = s->streams[i];
431 
432  switch (st->codecpar->codec_type) {
433  case AVMEDIA_TYPE_AUDIO:
434  den = (int64_t)st->time_base.num * st->codecpar->sample_rate;
435  break;
436  case AVMEDIA_TYPE_VIDEO:
437  den = (int64_t)st->time_base.num * st->time_base.den;
438  break;
439  default:
440  break;
441  }
442 
443  if (!st->internal->priv_pts)
444  st->internal->priv_pts = av_mallocz(sizeof(*st->internal->priv_pts));
445  if (!st->internal->priv_pts)
446  return AVERROR(ENOMEM);
447 
448  if (den != AV_NOPTS_VALUE) {
449  if (den <= 0)
450  return AVERROR_INVALIDDATA;
451 
452  frac_init(st->internal->priv_pts, 0, 0, den);
453  }
454  }
455 
456  if (s->avoid_negative_ts < 0) {
457  av_assert2(s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO);
458  if (s->oformat->flags & (AVFMT_TS_NEGATIVE | AVFMT_NOTIMESTAMPS)) {
459  s->avoid_negative_ts = 0;
460  } else
461  s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE;
462  }
463 
464  return 0;
465 }
466 
468 {
469  if (s->pb && s->pb->error >= 0) {
470  if (s->flush_packets == 1 || s->flags & AVFMT_FLAG_FLUSH_PACKETS)
471  avio_flush(s->pb);
472  else if (s->flush_packets && !(s->oformat->flags & AVFMT_NOFILE))
474  }
475 }
476 
478 {
479  if (s->oformat && s->oformat->deinit && s->internal->initialized)
480  s->oformat->deinit(s);
481  s->internal->initialized =
482  s->internal->streams_initialized = 0;
483 }
484 
486 {
487  int ret = 0;
488 
489  if ((ret = init_muxer(s, options)) < 0)
490  return ret;
491 
492  s->internal->initialized = 1;
493  s->internal->streams_initialized = ret;
494 
495  if (s->oformat->init && ret) {
496  if ((ret = init_pts(s)) < 0)
497  return ret;
498 
500  }
501 
503 }
504 
506 {
507  int ret = 0;
508  int already_initialized = s->internal->initialized;
509  int streams_already_initialized = s->internal->streams_initialized;
510 
511  if (!already_initialized)
512  if ((ret = avformat_init_output(s, options)) < 0)
513  return ret;
514 
515  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
517  if (s->oformat->write_header) {
518  ret = s->oformat->write_header(s);
519  if (ret >= 0 && s->pb && s->pb->error < 0)
520  ret = s->pb->error;
521  if (ret < 0)
522  goto fail;
524  }
525  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
527 
528  if (!s->internal->streams_initialized) {
529  if ((ret = init_pts(s)) < 0)
530  goto fail;
531  }
532 
533  return streams_already_initialized;
534 
535 fail:
536  deinit_muxer(s);
537  return ret;
538 }
539 
540 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
541 
542 
543 #if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
545 //FIXME merge with compute_pkt_fields
546 static int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)
547 {
548  int delay = FFMAX(st->codecpar->video_delay, st->internal->avctx->max_b_frames > 0);
549  int num, den, i;
550  int frame_size;
551 
552  if (!s->internal->missing_ts_warning &&
553  !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
555  (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
557  "Timestamps are unset in a packet for stream %d. "
558  "This is deprecated and will stop working in the future. "
559  "Fix your code to set the timestamps properly\n", st->index);
560  s->internal->missing_ts_warning = 1;
561  }
562 
563  if (s->debug & FF_FDEBUG_TS)
564  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 
567  if (pkt->duration < 0 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
568  av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
570  pkt->duration = 0;
571  }
572 
573  /* duration field */
574  if (pkt->duration == 0) {
575  ff_compute_frame_duration(s, &num, &den, st, NULL, pkt);
576  if (den && num) {
577  pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
578  }
579  }
580 
581  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
582  pkt->pts = pkt->dts;
583 
584  //XXX/FIXME this is a temporary hack until all encoders output pts
585  if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
586  static int warned;
587  if (!warned) {
588  av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
589  warned = 1;
590  }
591  pkt->dts =
592 // pkt->pts= st->cur_dts;
593  pkt->pts = st->internal->priv_pts->val;
594  }
595 
596  //calculate dts from pts
597  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
598  st->pts_buffer[0] = pkt->pts;
599  for (i = 1; i < delay + 1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
600  st->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
601  for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
602  FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
603 
604  pkt->dts = st->pts_buffer[0];
605  }
606 
607  if (st->cur_dts && st->cur_dts != AV_NOPTS_VALUE &&
608  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
611  st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
613  "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
614  st->index, av_ts2str(st->cur_dts), av_ts2str(pkt->dts));
615  return AVERROR(EINVAL);
616  }
617  if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
619  "pts (%s) < dts (%s) in stream %d\n",
621  st->index);
622  return AVERROR(EINVAL);
623  }
624 
625  if (s->debug & FF_FDEBUG_TS)
626  av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n",
628 
629  st->cur_dts = pkt->dts;
630  st->internal->priv_pts->val = pkt->dts;
631 
632  /* update pts */
633  switch (st->codecpar->codec_type) {
634  case AVMEDIA_TYPE_AUDIO:
636  (*(AVFrame **)pkt->data)->nb_samples :
637  av_get_audio_frame_duration(st->codec, pkt->size);
638 
639  /* HACK/FIXME, we skip the initial 0 size packets as they are most
640  * likely equal to the encoder delay, but it would be better if we
641  * had the real timestamps from the encoder */
642  if (frame_size >= 0 && (pkt->size || st->internal->priv_pts->num != st->internal->priv_pts->den >> 1 || st->internal->priv_pts->val)) {
643  frac_add(st->internal->priv_pts, (int64_t)st->time_base.den * frame_size);
644  }
645  break;
646  case AVMEDIA_TYPE_VIDEO:
647  frac_add(st->internal->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
648  break;
649  }
650  return 0;
651 }
653 #endif
654 
655 /**
656  * Shift timestamps and call muxer; the original pts/dts are not kept.
657  *
658  * FIXME: this function should NEVER get undefined pts/dts beside when the
659  * AVFMT_NOTIMESTAMPS is set.
660  * Those additional safety checks should be dropped once the correct checks
661  * are set in the callers.
662  */
664 {
665  int ret;
666 
667  // If the timestamp offsetting below is adjusted, adjust
668  // ff_interleaved_peek similarly.
669  if (s->output_ts_offset) {
670  AVStream *st = s->streams[pkt->stream_index];
671  int64_t offset = av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
672 
673  if (pkt->dts != AV_NOPTS_VALUE)
674  pkt->dts += offset;
675  if (pkt->pts != AV_NOPTS_VALUE)
676  pkt->pts += offset;
677  }
678 
679  if (s->avoid_negative_ts > 0) {
680  AVStream *st = s->streams[pkt->stream_index];
681  int64_t offset = st->mux_ts_offset;
682  int64_t ts = s->internal->avoid_negative_ts_use_pts ? pkt->pts : pkt->dts;
683 
684  if (s->internal->offset == AV_NOPTS_VALUE && ts != AV_NOPTS_VALUE &&
685  (ts < 0 || s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO)) {
686  s->internal->offset = -ts;
687  s->internal->offset_timebase = st->time_base;
688  }
689 
690  if (s->internal->offset != AV_NOPTS_VALUE && !offset) {
691  offset = st->mux_ts_offset =
692  av_rescale_q_rnd(s->internal->offset,
693  s->internal->offset_timebase,
694  st->time_base,
695  AV_ROUND_UP);
696  }
697 
698  if (pkt->dts != AV_NOPTS_VALUE)
699  pkt->dts += offset;
700  if (pkt->pts != AV_NOPTS_VALUE)
701  pkt->pts += offset;
702 
703  if (s->internal->avoid_negative_ts_use_pts) {
704  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < 0) {
705  av_log(s, AV_LOG_WARNING, "failed to avoid negative "
706  "pts %s in stream %d.\n"
707  "Try -avoid_negative_ts 1 as a possible workaround.\n",
708  av_ts2str(pkt->pts),
710  );
711  }
712  } else {
713  av_assert2(pkt->dts == AV_NOPTS_VALUE || pkt->dts >= 0 || s->max_interleave_delta > 0);
714  if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < 0) {
716  "Packets poorly interleaved, failed to avoid negative "
717  "timestamp %s in stream %d.\n"
718  "Try -max_interleave_delta 0 as a possible workaround.\n",
719  av_ts2str(pkt->dts),
721  );
722  }
723  }
724  }
725 
727  AVFrame **frame = (AVFrame **)pkt->data;
728  av_assert0(pkt->size == sizeof(*frame));
729  ret = s->oformat->write_uncoded_frame(s, pkt->stream_index, frame, 0);
730  } else {
731  ret = s->oformat->write_packet(s, pkt);
732  }
733 
734  if (s->pb && ret >= 0) {
736  if (s->pb->error < 0)
737  ret = s->pb->error;
738  }
739 
740  if (ret >= 0)
741  s->streams[pkt->stream_index]->nb_frames++;
742 
743  return ret;
744 }
745 
747 {
748  if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
749  av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
750  pkt->stream_index);
751  return AVERROR(EINVAL);
752  }
753 
754  if (s->streams[pkt->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
755  av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
756  return AVERROR(EINVAL);
757  }
758 
759  return 0;
760 }
761 
763 {
764 #if !FF_API_COMPUTE_PKT_FIELDS2 || !FF_API_LAVF_AVCTX
765  /* sanitize the timestamps */
766  if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
767 
768  /* when there is no reordering (so dts is equal to pts), but
769  * only one of them is set, set the other as well */
770  if (!st->internal->reorder) {
771  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)
772  pkt->pts = pkt->dts;
773  if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
774  pkt->dts = pkt->pts;
775  }
776 
777  /* check that the timestamps are set */
778  if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {
780  "Timestamps are unset in a packet for stream %d\n", st->index);
781  return AVERROR(EINVAL);
782  }
783 
784  /* check that the dts are increasing (or at least non-decreasing,
785  * if the format allows it */
786  if (st->cur_dts != AV_NOPTS_VALUE &&
787  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && st->cur_dts >= pkt->dts) ||
788  st->cur_dts > pkt->dts)) {
790  "Application provided invalid, non monotonically increasing "
791  "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
792  st->index, st->cur_dts, pkt->dts);
793  return AVERROR(EINVAL);
794  }
795 
796  if (pkt->pts < pkt->dts) {
797  av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
798  pkt->pts, pkt->dts, st->index);
799  return AVERROR(EINVAL);
800  }
801  }
802 #endif
803  /* update flags */
804  if (st->internal->is_intra_only)
806 
807  return 0;
808 }
809 
810 #define CHUNK_START 0x1000
811 
813  int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
814 {
815  int ret;
816  AVPacketList **next_point, *this_pktl;
817  AVStream *st = s->streams[pkt->stream_index];
818  int chunked = s->max_chunk_size || s->max_chunk_duration;
819 
820  this_pktl = av_malloc(sizeof(AVPacketList));
821  if (!this_pktl) {
823  return AVERROR(ENOMEM);
824  }
825  if ((ret = av_packet_make_refcounted(pkt)) < 0) {
826  av_free(this_pktl);
828  return ret;
829  }
830 
831  av_packet_move_ref(&this_pktl->pkt, pkt);
832  pkt = &this_pktl->pkt;
833 
834  if (st->last_in_packet_buffer) {
835  next_point = &(st->last_in_packet_buffer->next);
836  } else {
837  next_point = &s->internal->packet_buffer;
838  }
839 
840  if (chunked) {
841  uint64_t max= av_rescale_q_rnd(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base, AV_ROUND_UP);
844  if ( (s->max_chunk_size && st->interleaver_chunk_size > s->max_chunk_size)
845  || (max && st->interleaver_chunk_duration > max)) {
846  st->interleaver_chunk_size = 0;
847  pkt->flags |= CHUNK_START;
848  if (max && st->interleaver_chunk_duration > max) {
849  int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
850  int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
851 
852  st->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
853  } else
855  }
856  }
857  if (*next_point) {
858  if (chunked && !(pkt->flags & CHUNK_START))
859  goto next_non_null;
860 
861  if (compare(s, &s->internal->packet_buffer_end->pkt, pkt)) {
862  while ( *next_point
863  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
864  || !compare(s, &(*next_point)->pkt, pkt)))
865  next_point = &(*next_point)->next;
866  if (*next_point)
867  goto next_non_null;
868  } else {
869  next_point = &(s->internal->packet_buffer_end->next);
870  }
871  }
872  av_assert1(!*next_point);
873 
874  s->internal->packet_buffer_end = this_pktl;
875 next_non_null:
876 
877  this_pktl->next = *next_point;
878 
879  st->last_in_packet_buffer = *next_point = this_pktl;
880 
881  return 0;
882 }
883 
885  const AVPacket *pkt)
886 {
887  AVStream *st = s->streams[pkt->stream_index];
888  AVStream *st2 = s->streams[next->stream_index];
889  int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
890  st->time_base);
891  if (s->audio_preload) {
892  int preload = st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
893  int preload2 = st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
894  if (preload != preload2) {
895  int64_t ts, ts2;
896  preload *= s->audio_preload;
897  preload2 *= s->audio_preload;
898  ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - preload;
899  ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - preload2;
900  if (ts == ts2) {
901  ts = ((uint64_t)pkt ->dts*st ->time_base.num*AV_TIME_BASE - (uint64_t)preload *st ->time_base.den)*st2->time_base.den
902  - ((uint64_t)next->dts*st2->time_base.num*AV_TIME_BASE - (uint64_t)preload2*st2->time_base.den)*st ->time_base.den;
903  ts2 = 0;
904  }
905  comp = (ts2 > ts) - (ts2 < ts);
906  }
907  }
908 
909  if (comp == 0)
910  return pkt->stream_index < next->stream_index;
911  return comp > 0;
912 }
913 
915  AVPacket *pkt, int flush)
916 {
917  AVPacketList *pktl;
918  int stream_count = 0;
919  int noninterleaved_count = 0;
920  int i, ret;
921  int eof = flush;
922 
923  if (pkt) {
925  return ret;
926  }
927 
928  for (i = 0; i < s->nb_streams; i++) {
929  if (s->streams[i]->last_in_packet_buffer) {
930  ++stream_count;
931  } else if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
932  s->streams[i]->codecpar->codec_id != AV_CODEC_ID_VP8 &&
933  s->streams[i]->codecpar->codec_id != AV_CODEC_ID_VP9) {
934  ++noninterleaved_count;
935  }
936  }
937 
938  if (s->internal->nb_interleaved_streams == stream_count)
939  flush = 1;
940 
941  if (s->max_interleave_delta > 0 &&
942  s->internal->packet_buffer &&
943  !flush &&
944  s->internal->nb_interleaved_streams == stream_count+noninterleaved_count
945  ) {
946  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
947  int64_t delta_dts = INT64_MIN;
948  int64_t top_dts = av_rescale_q(top_pkt->dts,
949  s->streams[top_pkt->stream_index]->time_base,
951 
952  for (i = 0; i < s->nb_streams; i++) {
953  int64_t last_dts;
954  const AVPacketList *last = s->streams[i]->last_in_packet_buffer;
955 
956  if (!last)
957  continue;
958 
959  last_dts = av_rescale_q(last->pkt.dts,
960  s->streams[i]->time_base,
962  delta_dts = FFMAX(delta_dts, last_dts - top_dts);
963  }
964 
965  if (delta_dts > s->max_interleave_delta) {
967  "Delay between the first packet and last packet in the "
968  "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
969  delta_dts, s->max_interleave_delta);
970  flush = 1;
971  }
972  }
973 
974  if (s->internal->packet_buffer &&
975  eof &&
976  (s->flags & AVFMT_FLAG_SHORTEST) &&
977  s->internal->shortest_end == AV_NOPTS_VALUE) {
978  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
979 
980  s->internal->shortest_end = av_rescale_q(top_pkt->dts,
981  s->streams[top_pkt->stream_index]->time_base,
983  }
984 
985  if (s->internal->shortest_end != AV_NOPTS_VALUE) {
986  while (s->internal->packet_buffer) {
987  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
988  AVStream *st;
989  int64_t top_dts = av_rescale_q(top_pkt->dts,
990  s->streams[top_pkt->stream_index]->time_base,
992 
993  if (s->internal->shortest_end + 1 >= top_dts)
994  break;
995 
996  pktl = s->internal->packet_buffer;
997  st = s->streams[pktl->pkt.stream_index];
998 
999  s->internal->packet_buffer = pktl->next;
1000  if (!s->internal->packet_buffer)
1001  s->internal->packet_buffer_end = NULL;
1002 
1003  if (st->last_in_packet_buffer == pktl)
1005 
1006  av_packet_unref(&pktl->pkt);
1007  av_freep(&pktl);
1008  flush = 0;
1009  }
1010  }
1011 
1012  if (stream_count && flush) {
1013  AVStream *st;
1014  pktl = s->internal->packet_buffer;
1015  *out = pktl->pkt;
1016  st = s->streams[out->stream_index];
1017 
1018  s->internal->packet_buffer = pktl->next;
1019  if (!s->internal->packet_buffer)
1020  s->internal->packet_buffer_end = NULL;
1021 
1022  if (st->last_in_packet_buffer == pktl)
1024  av_freep(&pktl);
1025 
1026  return 1;
1027  } else {
1028  return 0;
1029  }
1030 }
1031 
1033  AVPacket *pkt, int add_offset)
1034 {
1035  AVPacketList *pktl = s->internal->packet_buffer;
1036  while (pktl) {
1037  if (pktl->pkt.stream_index == stream) {
1038  *pkt = pktl->pkt;
1039  if (add_offset) {
1040  AVStream *st = s->streams[pkt->stream_index];
1041  int64_t offset = st->mux_ts_offset;
1042 
1043  if (s->output_ts_offset)
1044  offset += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
1045 
1046  if (pkt->dts != AV_NOPTS_VALUE)
1047  pkt->dts += offset;
1048  if (pkt->pts != AV_NOPTS_VALUE)
1049  pkt->pts += offset;
1050  }
1051  return 0;
1052  }
1053  pktl = pktl->next;
1054  }
1055  return AVERROR(ENOENT);
1056 }
1057 
1058 /**
1059  * Interleave an AVPacket correctly so it can be muxed.
1060  * @param out the interleaved packet will be output here
1061  * @param in the input packet; will always be blank on return if not NULL
1062  * @param flush 1 if no further packets are available as input and all
1063  * remaining packets should be output
1064  * @return 1 if a packet was output, 0 if no packet could be output,
1065  * < 0 if an error occurred
1066  */
1068 {
1069  if (s->oformat->interleave_packet) {
1070  return s->oformat->interleave_packet(s, out, in, flush);
1071  } else
1073 }
1074 
1076 {
1077  int ret;
1078 
1079  if (!(s->flags & AVFMT_FLAG_AUTO_BSF))
1080  return 1;
1081 
1082  if (s->oformat->check_bitstream) {
1083  if (!st->internal->bitstream_checked) {
1084  if ((ret = s->oformat->check_bitstream(s, pkt)) < 0)
1085  return ret;
1086  else if (ret == 1)
1087  st->internal->bitstream_checked = 1;
1088  }
1089  }
1090 
1091  return 1;
1092 }
1093 
1095 {
1096  for (;; ) {
1097  AVPacket opkt;
1098  int ret = interleave_packet(s, &opkt, pkt, flush);
1099  if (ret <= 0)
1100  return ret;
1101 
1102  pkt = NULL;
1103 
1104  ret = write_packet(s, &opkt);
1105 
1106  av_packet_unref(&opkt);
1107 
1108  if (ret < 0)
1109  return ret;
1110  }
1111 }
1112 
1113 static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1114 {
1115  int ret;
1116 
1117  if (s->debug & FF_FDEBUG_TS)
1118  av_log(s, AV_LOG_DEBUG, "%s size:%d dts:%s pts:%s\n", __FUNCTION__,
1120 
1121 #if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
1122  if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1123  return ret;
1124 #endif
1125 
1126  if (interleaved) {
1127  if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1128  return AVERROR(EINVAL);
1129  return interleaved_write_packet(s, pkt, 0);
1130  } else {
1131  return write_packet(s, pkt);
1132  }
1133 }
1134 
1135 static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
1136 {
1137  AVBSFContext *bsfc = st->internal->bsfc;
1138  int ret;
1139 
1140  if ((ret = av_bsf_send_packet(bsfc, pkt)) < 0) {
1142  "Failed to send packet to filter %s for stream %d\n",
1143  bsfc->filter->name, st->index);
1144  return ret;
1145  }
1146 
1147  do {
1148  ret = av_bsf_receive_packet(bsfc, pkt);
1149  if (ret < 0) {
1150  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
1151  return 0;
1152  av_log(s, AV_LOG_ERROR, "Error applying bitstream filters to an output "
1153  "packet for stream #%d: %s\n", st->index, av_err2str(ret));
1154  if (!(s->error_recognition & AV_EF_EXPLODE) && ret != AVERROR(ENOMEM))
1155  continue;
1156  return ret;
1157  }
1159  ret = write_packet_common(s, st, pkt, interleaved);
1160  if (ret >= 0 && !interleaved) // a successful write_packet_common already unrefed pkt for interleaved
1162  } while (ret >= 0);
1163 
1164  return ret;
1165 }
1166 
1167 static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
1168 {
1169  AVStream *st;
1170  int ret = check_packet(s, pkt);
1171  if (ret < 0)
1172  return ret;
1173  st = s->streams[pkt->stream_index];
1174 
1175  ret = prepare_input_packet(s, st, pkt);
1176  if (ret < 0)
1177  return ret;
1178 
1179  ret = check_bitstream(s, st, pkt);
1180  if (ret < 0)
1181  return ret;
1182 
1183  if (st->internal->bsfc) {
1184  return write_packets_from_bsfs(s, st, pkt, interleaved);
1185  } else {
1186  return write_packet_common(s, st, pkt, interleaved);
1187  }
1188 }
1189 
1191 {
1192  AVPacket local_pkt, *pkt = &local_pkt;
1193  int ret;
1194 
1195  if (!in) {
1196  if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
1197  ret = s->oformat->write_packet(s, NULL);
1198  flush_if_needed(s);
1199  if (ret >= 0 && s->pb && s->pb->error < 0)
1200  ret = s->pb->error;
1201  return ret;
1202  }
1203  return 1;
1204  }
1205 
1206  if (in->flags & AV_PKT_FLAG_UNCODED_FRAME) {
1207  pkt = in;
1208  } else {
1209  /* We don't own in, so we have to make sure not to modify it.
1210  * The following avoids copying in's data unnecessarily.
1211  * Copying side data is unavoidable as a bitstream filter
1212  * may change it, e.g. free it on errors. */
1213  pkt->buf = NULL;
1214  pkt->data = in->data;
1215  pkt->size = in->size;
1217  if (ret < 0)
1218  return ret;
1219  if (in->buf) {
1220  pkt->buf = av_buffer_ref(in->buf);
1221  if (!pkt->buf) {
1222  ret = AVERROR(ENOMEM);
1223  goto fail;
1224  }
1225  }
1226  }
1227 
1228  ret = write_packets_common(s, pkt, 0/*non-interleaved*/);
1229 
1230 fail:
1231  // Uncoded frames using the noninterleaved codepath are also freed here
1233  return ret;
1234 }
1235 
1237 {
1238  int ret;
1239 
1240  if (pkt) {
1241  ret = write_packets_common(s, pkt, 1/*interleaved*/);
1242  if (ret < 0)
1244  return ret;
1245  } else {
1246  av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");
1247  return interleaved_write_packet(s, NULL, 1/*flush*/);
1248  }
1249 }
1250 
1252 {
1253  int i, ret1, ret = 0;
1254  AVPacket pkt = {0};
1255  av_init_packet(&pkt);
1256 
1257  for (i = 0; i < s->nb_streams; i++) {
1258  if (s->streams[i]->internal->bsfc) {
1259  ret1 = write_packets_from_bsfs(s, s->streams[i], &pkt, 1/*interleaved*/);
1260  if (ret1 < 0)
1261  av_packet_unref(&pkt);
1262  if (ret >= 0)
1263  ret = ret1;
1264  }
1265  }
1266  ret1 = interleaved_write_packet(s, NULL, 1);
1267  if (ret >= 0)
1268  ret = ret1;
1269 
1270  if (s->oformat->write_trailer) {
1271  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1273  if (ret >= 0) {
1274  ret = s->oformat->write_trailer(s);
1275  } else {
1276  s->oformat->write_trailer(s);
1277  }
1278  }
1279 
1280  deinit_muxer(s);
1281 
1282  if (s->pb)
1283  avio_flush(s->pb);
1284  if (ret == 0)
1285  ret = s->pb ? s->pb->error : 0;
1286  for (i = 0; i < s->nb_streams; i++) {
1287  av_freep(&s->streams[i]->priv_data);
1288  av_freep(&s->streams[i]->index_entries);
1289  }
1290  if (s->oformat->priv_class)
1291  av_opt_free(s->priv_data);
1292  av_freep(&s->priv_data);
1293  return ret;
1294 }
1295 
1297  int64_t *dts, int64_t *wall)
1298 {
1299  if (!s->oformat || !s->oformat->get_output_timestamp)
1300  return AVERROR(ENOSYS);
1301  s->oformat->get_output_timestamp(s, stream, dts, wall);
1302  return 0;
1303 }
1304 
1305 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
1307 {
1308  AVPacket local_pkt;
1309  int ret;
1310 
1311  local_pkt = *pkt;
1312  local_pkt.stream_index = dst_stream;
1313 
1314  av_packet_rescale_ts(&local_pkt,
1315  src->streams[pkt->stream_index]->time_base,
1316  dst->streams[dst_stream]->time_base);
1317 
1318  if (interleave) ret = av_interleaved_write_frame(dst, &local_pkt);
1319  else ret = av_write_frame(dst, &local_pkt);
1320  pkt->buf = local_pkt.buf;
1321  pkt->side_data = local_pkt.side_data;
1322  pkt->side_data_elems = local_pkt.side_data_elems;
1323  return ret;
1324 }
1325 
1326 static void uncoded_frame_free(void *unused, uint8_t *data)
1327 {
1328  av_frame_free((AVFrame **)data);
1329  av_free(data);
1330 }
1331 
1332 static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
1333  AVFrame *frame, int interleaved)
1334 {
1335  AVPacket pkt, *pktp;
1336 
1337  av_assert0(s->oformat);
1338  if (!s->oformat->write_uncoded_frame) {
1339  av_frame_free(&frame);
1340  return AVERROR(ENOSYS);
1341  }
1342 
1343  if (!frame) {
1344  pktp = NULL;
1345  } else {
1346  size_t bufsize = sizeof(frame) + AV_INPUT_BUFFER_PADDING_SIZE;
1347  AVFrame **framep = av_mallocz(bufsize);
1348 
1349  if (!framep)
1350  goto fail;
1351  pktp = &pkt;
1352  av_init_packet(&pkt);
1353  pkt.buf = av_buffer_create((void *)framep, bufsize,
1354  uncoded_frame_free, NULL, 0);
1355  if (!pkt.buf) {
1356  av_free(framep);
1357  fail:
1358  av_frame_free(&frame);
1359  return AVERROR(ENOMEM);
1360  }
1361  *framep = frame;
1362 
1363  pkt.data = (void *)framep;
1364  pkt.size = sizeof(frame);
1365  pkt.pts =
1366  pkt.dts = frame->pts;
1367  pkt.duration = frame->pkt_duration;
1368  pkt.stream_index = stream_index;
1370  }
1371 
1372  return interleaved ? av_interleaved_write_frame(s, pktp) :
1373  av_write_frame(s, pktp);
1374 }
1375 
1377  AVFrame *frame)
1378 {
1379  return write_uncoded_frame_internal(s, stream_index, frame, 0);
1380 }
1381 
1383  AVFrame *frame)
1384 {
1385  return write_uncoded_frame_internal(s, stream_index, frame, 1);
1386 }
1387 
1389 {
1390  av_assert0(s->oformat);
1391  if (!s->oformat->write_uncoded_frame)
1392  return AVERROR(ENOSYS);
1393  return s->oformat->write_uncoded_frame(s, stream_index, NULL,
1395 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:29
AVStreamInternal::priv_pts
FFFrac * priv_pts
Definition: internal.h:193
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:605
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
interleave_compare_dts
static int interleave_compare_dts(AVFormatContext *s, const AVPacket *next, const AVPacket *pkt)
Definition: mux.c:884
LIBAVFORMAT_IDENT
#define LIBAVFORMAT_IDENT
Definition: version.h:46
AVStreamInternal::reorder
int reorder
Set to 1 if the codec allows reordering, so pts can be different from dts.
Definition: internal.h:152
AVSTREAM_INIT_IN_WRITE_HEADER
#define AVSTREAM_INIT_IN_WRITE_HEADER
stream parameters initialized in avformat_write_header
Definition: avformat.h:2506
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
av_compare_ts
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
Definition: mathematics.c:147
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1357
AVFMT_NODIMENSIONS
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:466
FF_FDEBUG_TS
#define FF_FDEBUG_TS
Definition: avformat.h:1619
out
FILE * out
Definition: movenc.c:54
prepare_input_packet
static int prepare_input_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:762
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:99
AVStreamInternal::avctx
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:169
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:83
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
ff_compute_frame_duration
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:954
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2549
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:406
AV_DISPOSITION_ATTACHED_PIC
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:833
avcodec_parameters_from_context
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:2127
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:462
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AVCodecTag::id
enum AVCodecID id
Definition: internal.h:43
AVBitStreamFilter::name
const char * name
Definition: bsf.h:99
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:62
AVPacketList::next
struct AVPacketList * next
Definition: avformat.h:2010
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
pixdesc.h
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1403
avpriv_toupper4
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:1877
internal.h
av_write_uncoded_frame
int av_write_uncoded_frame(AVFormatContext *s, int stream_index, AVFrame *frame)
Write an uncoded frame to an output media file.
Definition: mux.c:1376
AVPacket::data
uint8_t * data
Definition: packet.h:355
AVStream::internal
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1220
data
const char data[16]
Definition: mxf.c:91
AVStream::cur_dts
int64_t cur_dts
Definition: avformat.h:1068
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:70
AVFMT_FLAG_SHORTEST
#define AVFMT_FLAG_SHORTEST
Stop muxing when the shortest stream stops.
Definition: avformat.h:1493
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:29
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:373
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
max
#define max(a, b)
Definition: cuda_runtime.h:33
mathematics.h
AVDictionary
Definition: dict.c:30
av_write_uncoded_frame_query
int av_write_uncoded_frame_query(AVFormatContext *s, int stream_index)
Test whether a muxer supports uncoded frame.
Definition: mux.c:1388
avformat_init_output
int avformat_init_output(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and initialize the codec, but do not write the header.
Definition: mux.c:485
AVStreamInternal::bsfc
AVBSFContext * bsfc
bitstream filter to run on stream
Definition: internal.h:159
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:388
AVBSFContext
The bitstream filter state.
Definition: bsf.h:49
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
ff_const59
#define ff_const59
The ff_const59 define is not part of the public API and will be removed without further warning.
Definition: avformat.h:535
ff_is_intra_only
int ff_is_intra_only(enum AVCodecID id)
Definition: utils.c:1017
avio_write_marker
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:471
av_guess_format
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
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
fail
#define fail()
Definition: checkasm.h:123
AVFMT_FLAG_AUTO_BSF
#define AVFMT_FLAG_AUTO_BSF
Add bitstream filters as requested by the muxer.
Definition: avformat.h:1494
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AVFMT_AVOID_NEG_TS_MAKE_ZERO
#define AVFMT_AVOID_NEG_TS_MAKE_ZERO
Shift timestamps so that they start at 0.
Definition: avformat.h:1669
interleave_packet
static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush)
Interleave an AVPacket correctly so it can be muxed.
Definition: mux.c:1067
AV_DISPOSITION_TIMED_THUMBNAILS
#define AV_DISPOSITION_TIMED_THUMBNAILS
The stream is sparse, and contains thumbnail images, often corresponding to chapter markers.
Definition: avformat.h:838
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:83
AVRational::num
int num
Numerator.
Definition: rational.h:59
avassert.h
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
write_packet
static int write_packet(AVFormatContext *s, AVPacket *pkt)
Shift timestamps and call muxer; the original pts/dts are not kept.
Definition: mux.c:663
AVCodecTag
Definition: internal.h:42
write_packet_common
static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1113
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
av_opt_set_dict
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1655
AV_PKT_FLAG_UNCODED_FRAME
#define AV_PKT_FLAG_UNCODED_FRAME
Definition: mux.c:540
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
s
#define s(width, name)
Definition: cbs_vp9.c:257
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:136
AVDictionaryEntry::key
char * key
Definition: dict.h:82
frame_size
int frame_size
Definition: mxfenc.c:2137
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:217
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
CHUNK_START
#define CHUNK_START
Definition: mux.c:810
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition: codec_par.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
AVOutputFormat::codec_tag
const struct AVCodecTag *const * codec_tag
List of supported codec_id-codec_tag pairs, ordered by "better choice first".
Definition: avformat.h:516
av_interleaved_write_uncoded_frame
int av_interleaved_write_uncoded_frame(AVFormatContext *s, int stream_index, AVFrame *frame)
Write an uncoded frame to an output media file.
Definition: mux.c:1382
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
f
#define f(width, name)
Definition: cbs_vp9.c:255
avformat_write_header
int avformat_write_header(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and write the stream header to an output media file.
Definition: mux.c:505
init_muxer
static int init_muxer(AVFormatContext *s, AVDictionary **options)
Definition: mux.c:230
if
if(ret)
Definition: filter_design.txt:179
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:233
AVFormatContext
Format I/O context.
Definition: avformat.h:1335
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:338
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1012
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:894
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:500
NULL
#define NULL
Definition: coverity.c:32
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:556
AVIO_DATA_MARKER_TRAILER
@ AVIO_DATA_MARKER_TRAILER
Trailer data, which doesn't contain actual content, but only for finalizing the output file.
Definition: avio.h:140
ff_interleave_add_packet
int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt, int(*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
Add packet to an AVFormatContext's packet_buffer list, determining its interleaved position using com...
Definition: mux.c:812
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:558
AVStream::interleaver_chunk_duration
int64_t interleaver_chunk_duration
Definition: avformat.h:1114
src
#define src
Definition: vp8dsp.c:254
AVStream::last_in_packet_buffer
struct AVPacketList * last_in_packet_buffer
last packet in packet_buffer for this stream when muxing.
Definition: avformat.h:1089
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1610
frac_add
static void frac_add(FFFrac *f, int64_t incr)
Fractional addition to f: f = f + (incr / f->den).
Definition: mux.c:69
AVOutputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:519
av_write_frame
int av_write_frame(AVFormatContext *s, AVPacket *in)
Write a packet to an output media file.
Definition: mux.c:1190
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1666
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:663
ff_write_chained
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt, AVFormatContext *src, int interleave)
Write a packet to another muxer than the one the user originally intended.
Definition: mux.c:1305
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:50
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
write_packets_common
static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)
Definition: mux.c:1167
validate_codec_tag
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
Definition: mux.c:196
AVOutputFormat::flags
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:510
interleave
static void interleave(uint8_t *dst, uint8_t *src, int w, int h, int dst_linesize, int src_linesize, enum FilterMode mode, int swap)
Definition: vf_il.c:117
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1574
options
const OptionDef options[]
AVStream::mux_ts_offset
int64_t mux_ts_offset
Timestamp offset added to timestamps before muxing.
Definition: avformat.h:1167
desc
const char * desc
Definition: nvenc.c:79
AVPacket::size
int size
Definition: packet.h:356
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:144
av_codec_get_tag
unsigned int av_codec_get_tag(const struct AVCodecTag *const *tags, enum AVCodecID id)
Get the codec tag for the given codec id id.
FFFrac::val
int64_t val
Definition: internal.h:60
flush_if_needed
static void flush_if_needed(AVFormatContext *s)
Definition: mux.c:467
AV_CODEC_PROP_REORDER
#define AV_CODEC_PROP_REORDER
Codec supports frame reordering.
Definition: codec_desc.h:92
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
avpriv_set_pts_info
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:4948
AVStreamInternal::is_intra_only
int is_intra_only
Definition: internal.h:191
AVStream::pts_buffer
int64_t pts_buffer[MAX_REORDER_DELAY+1]
Definition: avformat.h:1092
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVFMT_ALLOW_FLUSH
#define AVFMT_ALLOW_FLUSH
Format allows flushing.
Definition: avformat.h:471
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:458
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:555
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:927
AVFMT_NOSTREAMS
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:467
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:558
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:354
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
av_opt_set_dict2
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
Definition: opt.c:1630
av_packet_make_refcounted
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:671
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:361
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:203
av_packet_rescale_ts
void av_packet_rescale_ts(AVPacket *pkt, AVRational src_tb, AVRational dst_tb)
Convert valid timing fields (timestamps / durations) in a packet from one timebase to another.
Definition: avpacket.c:712
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1592
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:554
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:56
in
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
Definition: audio_convert.c:326
av_write_trailer
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
Definition: mux.c:1251
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
av_packet_copy_props
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:571
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:223
AVOutputFormat
Definition: avformat.h:490
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:348
internal.h
AVCodecParameters::height
int height
Definition: codec_par.h:127
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:177
av_get_output_timestamp
int av_get_output_timestamp(struct AVFormatContext *s, int stream, int64_t *dts, int64_t *wall)
Get timing information for the data currently output.
Definition: mux.c:1296
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE
#define AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE
Shift timestamps so they are non negative.
Definition: avformat.h:1668
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:205
uint8_t
uint8_t
Definition: audio_convert.c:194
av_get_audio_frame_duration
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:1799
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
AVBSFContext::time_base_out
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: bsf.h:95
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
AVIO_DATA_MARKER_UNKNOWN
@ AVIO_DATA_MARKER_UNKNOWN
This is any, unlabelled data.
Definition: avio.h:135
AVFMT_TS_NEGATIVE
#define AVFMT_TS_NEGATIVE
Format allows muxing negative timestamps.
Definition: avformat.h:475
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:472
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
AVStream::disposition
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:918
tag
uint32_t tag
Definition: movenc.c:1532
AVFMT_FLAG_BITEXACT
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1483
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:865
AVPacketList::pkt
AVPacket pkt
Definition: avformat.h:2009
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
avformat.h
dict.h
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:366
ff_choose_timebase
AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:89
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:215
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:197
AVCodecParameters::chroma_location
enum AVChromaLocation chroma_location
Definition: codec_par.h:150
deinit_muxer
static void deinit_muxer(AVFormatContext *s)
Definition: mux.c:477
check_packet
static int check_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:746
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:866
compare
static float compare(const AVFrame *haystack, const AVFrame *obj, int offx, int offy)
Definition: vf_find_rect.c:104
write_uncoded_frame_internal
static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index, AVFrame *frame, int interleaved)
Definition: mux.c:1332
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
AVCHROMA_LOC_CENTER
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:557
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVIO_DATA_MARKER_HEADER
@ AVIO_DATA_MARKER_HEADER
Header data; this needs to be present for the stream to be decodeable.
Definition: avio.h:115
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4455
AVSTREAM_INIT_IN_INIT_OUTPUT
#define AVSTREAM_INIT_IN_INIT_OUTPUT
stream parameters initialized in avformat_init_output
Definition: avformat.h:2507
AVPacket::stream_index
int stream_index
Definition: packet.h:357
av_buffer_ref
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
ff_interleaved_peek
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:1032
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
AVBSFContext::filter
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: bsf.h:58
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FFFrac::num
int64_t num
Definition: internal.h:60
AVCodecContext::max_b_frames
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:786
write_packets_from_bsfs
static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)
Definition: mux.c:1135
MAX_REORDER_DELAY
@ MAX_REORDER_DELAY
Definition: vaapi_encode.h:44
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
ff_interleave_packet_per_dts
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:914
ff_choose_chroma_location
enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:105
AVCodecParameters::video_delay
int video_delay
Video only.
Definition: codec_par.h:155
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: codec_par.h:38
AVCodecParameters::format
int format
Definition: codec_par.h:84
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
init_pts
static int init_pts(AVFormatContext *s)
Definition: mux.c:422
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:81
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
frac_init
static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
f = val + (num / den) + 0.5.
Definition: mux.c:51
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AV_WRITE_UNCODED_FRAME_QUERY
@ AV_WRITE_UNCODED_FRAME_QUERY
Query whether the feature is possible on this stream.
Definition: internal.h:620
av_interleaved_write_frame
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file ensuring correct interleaving.
Definition: mux.c:1236
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
uncoded_frame_free
static void uncoded_frame_free(void *unused, uint8_t *data)
Definition: mux.c:1326
timestamp.h
interleaved_write_packet
static int interleaved_write_packet(AVFormatContext *s, AVPacket *pkt, int flush)
Definition: mux.c:1094
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:189
av_strlcpy
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
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
AVFMT_FLAG_FLUSH_PACKETS
#define AVFMT_FLAG_FLUSH_PACKETS
Flush the AVIOContext every packet.
Definition: avformat.h:1476
AVStream::interleaver_chunk_size
int64_t interleaver_chunk_size
Definition: avformat.h:1113
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3394
AVFMT_AVOID_NEG_TS_AUTO
#define AVFMT_AVOID_NEG_TS_AUTO
Enabled when required by target format.
Definition: avformat.h:1667
avstring.h
avformat_alloc_output_context2
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:135
FFFrac
The exact value of the fractional number is: 'val + num / den'.
Definition: internal.h:59
FFFrac::den
int64_t den
Definition: internal.h:60
check_bitstream
static int check_bitstream(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:1075
AVCodecTag::tag
unsigned int tag
Definition: internal.h:44
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
av_rescale_q_rnd
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.
Definition: mathematics.c:134
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:367
AVPacketList
Definition: avformat.h:2008
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
av_init_packet
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
AVStreamInternal::bitstream_checked
int bitstream_checked
Whether or not check_bitstream should still be run on each packet.
Definition: internal.h:164
AVIO_DATA_MARKER_FLUSH_POINT
@ AVIO_DATA_MARKER_FLUSH_POINT
A point in the output bytestream where the underlying AVIOContext might flush the buffer depending on...
Definition: avio.h:146
AVOutputFormat::priv_data_size
int priv_data_size
size of private data so that it can be allocated in the wrapper
Definition: avformat.h:541