FFmpeg
mux.c
Go to the documentation of this file.
1 /*
2  * muxing functions for use within FFmpeg
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "avformat.h"
23 #include "avio_internal.h"
24 #include "internal.h"
25 #include "libavcodec/internal.h"
26 #include "libavcodec/bytestream.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/pixdesc.h"
30 #include "libavutil/timestamp.h"
31 #include "metadata.h"
32 #include "id3v2.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/internal.h"
36 #include "libavutil/mathematics.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/time.h"
39 #include "riff.h"
40 #include "audiointerleave.h"
41 #include "url.h"
42 #include <stdarg.h>
43 #if CONFIG_NETWORK
44 #include "network.h"
45 #endif
46 
47 /**
48  * @file
49  * muxing functions for use within libavformat
50  */
51 
52 /* fraction handling */
53 
54 /**
55  * f = val + (num / den) + 0.5.
56  *
57  * 'num' is normalized so that it is such as 0 <= num < den.
58  *
59  * @param f fractional number
60  * @param val integer value
61  * @param num must be >= 0
62  * @param den must be >= 1
63  */
64 static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
65 {
66  num += (den >> 1);
67  if (num >= den) {
68  val += num / den;
69  num = num % den;
70  }
71  f->val = val;
72  f->num = num;
73  f->den = den;
74 }
75 
76 /**
77  * Fractional addition to f: f = f + (incr / f->den).
78  *
79  * @param f fractional number
80  * @param incr increment, can be positive or negative
81  */
82 static void frac_add(FFFrac *f, int64_t incr)
83 {
84  int64_t num, den;
85 
86  num = f->num + incr;
87  den = f->den;
88  if (num < 0) {
89  f->val += num / den;
90  num = num % den;
91  if (num < 0) {
92  num += den;
93  f->val--;
94  }
95  } else if (num >= den) {
96  f->val += num / den;
97  num = num % den;
98  }
99  f->num = num;
100 }
101 
103 {
104  AVRational q;
105  int j;
106 
107  q = st->time_base;
108 
109  for (j=2; j<14; j+= 1+(j>2))
110  while (q.den / q.num < min_precision && q.num % j == 0)
111  q.num /= j;
112  while (q.den / q.num < min_precision && q.den < (1<<24))
113  q.den <<= 1;
114 
115  return q;
116 }
117 
119 {
120  AVCodecParameters *par = st->codecpar;
121  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(par->format);
122 
124  return par->chroma_location;
125 
126  if (pix_desc) {
127  if (pix_desc->log2_chroma_h == 0) {
128  return AVCHROMA_LOC_TOPLEFT;
129  } else if (pix_desc->log2_chroma_w == 1 && pix_desc->log2_chroma_h == 1) {
131  switch (par->codec_id) {
132  case AV_CODEC_ID_MJPEG:
134  }
135  }
137  switch (par->codec_id) {
139  }
140  }
141  }
142  }
143 
145 
146 }
147 
149  const char *format, const char *filename)
150 {
152  int ret = 0;
153 
154  *avctx = NULL;
155  if (!s)
156  goto nomem;
157 
158  if (!oformat) {
159  if (format) {
160  oformat = av_guess_format(format, NULL, NULL);
161  if (!oformat) {
162  av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
163  ret = AVERROR(EINVAL);
164  goto error;
165  }
166  } else {
167  oformat = av_guess_format(NULL, filename, NULL);
168  if (!oformat) {
169  ret = AVERROR(EINVAL);
170  av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
171  filename);
172  goto error;
173  }
174  }
175  }
176 
177  s->oformat = oformat;
178  if (s->oformat->priv_data_size > 0) {
179  s->priv_data = av_mallocz(s->oformat->priv_data_size);
180  if (!s->priv_data)
181  goto nomem;
182  if (s->oformat->priv_class) {
183  *(const AVClass**)s->priv_data= s->oformat->priv_class;
184  av_opt_set_defaults(s->priv_data);
185  }
186  } else
187  s->priv_data = NULL;
188 
189  if (filename) {
190 #if FF_API_FORMAT_FILENAME
192  av_strlcpy(s->filename, filename, sizeof(s->filename));
194 #endif
195  if (!(s->url = av_strdup(filename)))
196  goto nomem;
197 
198  }
199  *avctx = s;
200  return 0;
201 nomem:
202  av_log(s, AV_LOG_ERROR, "Out of memory\n");
203  ret = AVERROR(ENOMEM);
204 error:
206  return ret;
207 }
208 
210 {
211  const AVCodecTag *avctag;
212  int n;
213  enum AVCodecID id = AV_CODEC_ID_NONE;
214  int64_t tag = -1;
215 
216  /**
217  * Check that tag + id is in the table
218  * If neither is in the table -> OK
219  * If tag is in the table with another id -> FAIL
220  * If id is in the table with another tag -> FAIL unless strict < normal
221  */
222  for (n = 0; s->oformat->codec_tag[n]; n++) {
223  avctag = s->oformat->codec_tag[n];
224  while (avctag->id != AV_CODEC_ID_NONE) {
225  if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codecpar->codec_tag)) {
226  id = avctag->id;
227  if (id == st->codecpar->codec_id)
228  return 1;
229  }
230  if (avctag->id == st->codecpar->codec_id)
231  tag = avctag->tag;
232  avctag++;
233  }
234  }
235  if (id != AV_CODEC_ID_NONE)
236  return 0;
237  if (tag >= 0 && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
238  return 0;
239  return 1;
240 }
241 
242 
244 {
245  int ret = 0, i;
246  AVStream *st;
247  AVDictionary *tmp = NULL;
248  AVCodecParameters *par = NULL;
249  const AVOutputFormat *of = s->oformat;
250  const AVCodecDescriptor *desc;
252 
253  if (options)
254  av_dict_copy(&tmp, *options, 0);
255 
256  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
257  goto fail;
258  if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
259  (ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
260  goto fail;
261 
262 #if FF_API_FORMAT_FILENAME
264  if (!s->url && !(s->url = av_strdup(s->filename))) {
266 #else
267  if (!s->url && !(s->url = av_strdup(""))) {
268 #endif
269  ret = AVERROR(ENOMEM);
270  goto fail;
271  }
272 
273 #if FF_API_LAVF_AVCTX
275  if (s->nb_streams && s->streams[0]->codec->flags & AV_CODEC_FLAG_BITEXACT) {
276  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
278  "The AVFormatContext is not in set to bitexact mode, only "
279  "the AVCodecContext. If this is not intended, set "
280  "AVFormatContext.flags |= AVFMT_FLAG_BITEXACT.\n");
281  }
282  }
284 #endif
285 
286  // some sanity checks
287  if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) {
288  av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");
289  ret = AVERROR(EINVAL);
290  goto fail;
291  }
292 
293  for (i = 0; i < s->nb_streams; i++) {
294  st = s->streams[i];
295  par = st->codecpar;
296 
297 #if FF_API_LAVF_AVCTX
300  st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN) {
301  av_log(s, AV_LOG_WARNING, "Using AVStream.codec to pass codec "
302  "parameters to muxers is deprecated, use AVStream.codecpar "
303  "instead.\n");
304  ret = avcodec_parameters_from_context(st->codecpar, st->codec);
305  if (ret < 0)
306  goto fail;
307  }
309 #endif
310 
311  if (!st->time_base.num) {
312  /* fall back on the default timebase values */
313  if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)
314  avpriv_set_pts_info(st, 64, 1, par->sample_rate);
315  else
316  avpriv_set_pts_info(st, 33, 1, 90000);
317  }
318 
319  switch (par->codec_type) {
320  case AVMEDIA_TYPE_AUDIO:
321  if (par->sample_rate <= 0) {
322  av_log(s, AV_LOG_ERROR, "sample rate not set\n");
323  ret = AVERROR(EINVAL);
324  goto fail;
325  }
326  if (!par->block_align)
327  par->block_align = par->channels *
328  av_get_bits_per_sample(par->codec_id) >> 3;
329  break;
330  case AVMEDIA_TYPE_VIDEO:
331  if ((par->width <= 0 || par->height <= 0) &&
332  !(of->flags & AVFMT_NODIMENSIONS)) {
333  av_log(s, AV_LOG_ERROR, "dimensions not set\n");
334  ret = AVERROR(EINVAL);
335  goto fail;
336  }
339  ) {
340  if (st->sample_aspect_ratio.num != 0 &&
341  st->sample_aspect_ratio.den != 0 &&
342  par->sample_aspect_ratio.num != 0 &&
343  par->sample_aspect_ratio.den != 0) {
344  av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
345  "(%d/%d) and encoder layer (%d/%d)\n",
348  par->sample_aspect_ratio.den);
349  ret = AVERROR(EINVAL);
350  goto fail;
351  }
352  }
353  break;
354  }
355 
357  if (desc && desc->props & AV_CODEC_PROP_REORDER)
358  st->internal->reorder = 1;
359 
360  if (of->codec_tag) {
361  if ( par->codec_tag
362  && par->codec_id == AV_CODEC_ID_RAWVIDEO
363  && ( av_codec_get_tag(of->codec_tag, par->codec_id) == 0
364  || av_codec_get_tag(of->codec_tag, par->codec_id) == MKTAG('r', 'a', 'w', ' '))
365  && !validate_codec_tag(s, st)) {
366  // the current rawvideo encoding system ends up setting
367  // the wrong codec_tag for avi/mov, we override it here
368  par->codec_tag = 0;
369  }
370  if (par->codec_tag) {
371  if (!validate_codec_tag(s, st)) {
372  const uint32_t otag = av_codec_get_tag(s->oformat->codec_tag, par->codec_id);
374  "Tag %s incompatible with output codec id '%d' (%s)\n",
375  av_fourcc2str(par->codec_tag), par->codec_id, av_fourcc2str(otag));
377  goto fail;
378  }
379  } else
380  par->codec_tag = av_codec_get_tag(of->codec_tag, par->codec_id);
381  }
382 
384  s->internal->nb_interleaved_streams++;
385  }
386 
387  if (!s->priv_data && of->priv_data_size > 0) {
388  s->priv_data = av_mallocz(of->priv_data_size);
389  if (!s->priv_data) {
390  ret = AVERROR(ENOMEM);
391  goto fail;
392  }
393  if (of->priv_class) {
394  *(const AVClass **)s->priv_data = of->priv_class;
395  av_opt_set_defaults(s->priv_data);
396  if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
397  goto fail;
398  }
399  }
400 
401  /* set muxer identification string */
402  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
403  av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
404  } else {
405  av_dict_set(&s->metadata, "encoder", NULL, 0);
406  }
407 
408  for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {
409  av_dict_set(&s->metadata, e->key, NULL, 0);
410  }
411 
412  if (options) {
414  *options = tmp;
415  }
416 
417  if (s->oformat->init) {
418  if ((ret = s->oformat->init(s)) < 0) {
419  if (s->oformat->deinit)
420  s->oformat->deinit(s);
421  return ret;
422  }
423  return ret == 0;
424  }
425 
426  return 0;
427 
428 fail:
429  av_dict_free(&tmp);
430  return ret;
431 }
432 
434 {
435  int i;
436  AVStream *st;
437 
438  /* init PTS generation */
439  for (i = 0; i < s->nb_streams; i++) {
440  int64_t den = AV_NOPTS_VALUE;
441  st = s->streams[i];
442 
443  switch (st->codecpar->codec_type) {
444  case AVMEDIA_TYPE_AUDIO:
445  den = (int64_t)st->time_base.num * st->codecpar->sample_rate;
446  break;
447  case AVMEDIA_TYPE_VIDEO:
448  den = (int64_t)st->time_base.num * st->time_base.den;
449  break;
450  default:
451  break;
452  }
453 
454  if (!st->internal->priv_pts)
455  st->internal->priv_pts = av_mallocz(sizeof(*st->internal->priv_pts));
456  if (!st->internal->priv_pts)
457  return AVERROR(ENOMEM);
458 
459  if (den != AV_NOPTS_VALUE) {
460  if (den <= 0)
461  return AVERROR_INVALIDDATA;
462 
463  frac_init(st->internal->priv_pts, 0, 0, den);
464  }
465  }
466 
467  if (s->avoid_negative_ts < 0) {
468  av_assert2(s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO);
469  if (s->oformat->flags & (AVFMT_TS_NEGATIVE | AVFMT_NOTIMESTAMPS)) {
470  s->avoid_negative_ts = 0;
471  } else
472  s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE;
473  }
474 
475  return 0;
476 }
477 
479 {
480  if (s->pb && s->pb->error >= 0) {
481  if (s->flush_packets == 1 || s->flags & AVFMT_FLAG_FLUSH_PACKETS)
482  avio_flush(s->pb);
483  else if (s->flush_packets && !(s->oformat->flags & AVFMT_NOFILE))
485  }
486 }
487 
489 {
490  int ret = 0;
491 
492  if ((ret = init_muxer(s, options)) < 0)
493  return ret;
494 
495  s->internal->initialized = 1;
496  s->internal->streams_initialized = ret;
497 
498  if (s->oformat->init && ret) {
499  if ((ret = init_pts(s)) < 0)
500  return ret;
501 
503  }
504 
506 }
507 
509 {
510  int ret = 0;
511  int already_initialized = s->internal->initialized;
512  int streams_already_initialized = s->internal->streams_initialized;
513 
514  if (!already_initialized)
515  if ((ret = avformat_init_output(s, options)) < 0)
516  return ret;
517 
518  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
520  if (s->oformat->write_header) {
521  ret = s->oformat->write_header(s);
522  if (ret >= 0 && s->pb && s->pb->error < 0)
523  ret = s->pb->error;
524  if (ret < 0)
525  goto fail;
527  }
528  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
530 
531  if (!s->internal->streams_initialized) {
532  if ((ret = init_pts(s)) < 0)
533  goto fail;
534  }
535 
536  return streams_already_initialized;
537 
538 fail:
539  if (s->oformat->deinit)
540  s->oformat->deinit(s);
541  return ret;
542 }
543 
544 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
545 
546 /* Note: using sizeof(AVFrame) from outside lavu is unsafe in general, but
547  it is only being used internally to this file as a consistency check.
548  The value is chosen to be very unlikely to appear on its own and to cause
549  immediate failure if used anywhere as a real size. */
550 #define UNCODED_FRAME_PACKET_SIZE (INT_MIN / 3 * 2 + (int)sizeof(AVFrame))
551 
552 
553 #if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
555 //FIXME merge with compute_pkt_fields
556 static int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)
557 {
558  int delay = FFMAX(st->codecpar->video_delay, st->internal->avctx->max_b_frames > 0);
559  int num, den, i;
560  int frame_size;
561 
562  if (!s->internal->missing_ts_warning &&
563  !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
565  (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
567  "Timestamps are unset in a packet for stream %d. "
568  "This is deprecated and will stop working in the future. "
569  "Fix your code to set the timestamps properly\n", st->index);
570  s->internal->missing_ts_warning = 1;
571  }
572 
573  if (s->debug & FF_FDEBUG_TS)
574  av_log(s, AV_LOG_DEBUG, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
576 
577  if (pkt->duration < 0 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
578  av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
580  pkt->duration = 0;
581  }
582 
583  /* duration field */
584  if (pkt->duration == 0) {
585  ff_compute_frame_duration(s, &num, &den, st, NULL, pkt);
586  if (den && num) {
587  pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
588  }
589  }
590 
591  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
592  pkt->pts = pkt->dts;
593 
594  //XXX/FIXME this is a temporary hack until all encoders output pts
595  if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
596  static int warned;
597  if (!warned) {
598  av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
599  warned = 1;
600  }
601  pkt->dts =
602 // pkt->pts= st->cur_dts;
603  pkt->pts = st->internal->priv_pts->val;
604  }
605 
606  //calculate dts from pts
607  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
608  st->pts_buffer[0] = pkt->pts;
609  for (i = 1; i < delay + 1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
610  st->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
611  for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
612  FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
613 
614  pkt->dts = st->pts_buffer[0];
615  }
616 
617  if (st->cur_dts && st->cur_dts != AV_NOPTS_VALUE &&
618  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
621  st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
623  "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
624  st->index, av_ts2str(st->cur_dts), av_ts2str(pkt->dts));
625  return AVERROR(EINVAL);
626  }
627  if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
629  "pts (%s) < dts (%s) in stream %d\n",
631  st->index);
632  return AVERROR(EINVAL);
633  }
634 
635  if (s->debug & FF_FDEBUG_TS)
636  av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n",
638 
639  st->cur_dts = pkt->dts;
640  st->internal->priv_pts->val = pkt->dts;
641 
642  /* update pts */
643  switch (st->codecpar->codec_type) {
644  case AVMEDIA_TYPE_AUDIO:
646  ((AVFrame *)pkt->data)->nb_samples :
647  av_get_audio_frame_duration(st->codec, pkt->size);
648 
649  /* HACK/FIXME, we skip the initial 0 size packets as they are most
650  * likely equal to the encoder delay, but it would be better if we
651  * had the real timestamps from the encoder */
652  if (frame_size >= 0 && (pkt->size || st->internal->priv_pts->num != st->internal->priv_pts->den >> 1 || st->internal->priv_pts->val)) {
653  frac_add(st->internal->priv_pts, (int64_t)st->time_base.den * frame_size);
654  }
655  break;
656  case AVMEDIA_TYPE_VIDEO:
657  frac_add(st->internal->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
658  break;
659  }
660  return 0;
661 }
663 #endif
664 
665 /**
666  * Make timestamps non negative, move side data from payload to internal struct, call muxer, and restore
667  * sidedata.
668  *
669  * FIXME: this function should NEVER get undefined pts/dts beside when the
670  * AVFMT_NOTIMESTAMPS is set.
671  * Those additional safety checks should be dropped once the correct checks
672  * are set in the callers.
673  */
675 {
676  int ret;
677  int64_t pts_backup, dts_backup;
678 
679  pts_backup = pkt->pts;
680  dts_backup = pkt->dts;
681 
682  // If the timestamp offsetting below is adjusted, adjust
683  // ff_interleaved_peek similarly.
684  if (s->output_ts_offset) {
685  AVStream *st = s->streams[pkt->stream_index];
686  int64_t offset = av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
687 
688  if (pkt->dts != AV_NOPTS_VALUE)
689  pkt->dts += offset;
690  if (pkt->pts != AV_NOPTS_VALUE)
691  pkt->pts += offset;
692  }
693 
694  if (s->avoid_negative_ts > 0) {
695  AVStream *st = s->streams[pkt->stream_index];
696  int64_t offset = st->mux_ts_offset;
697  int64_t ts = s->internal->avoid_negative_ts_use_pts ? pkt->pts : pkt->dts;
698 
699  if (s->internal->offset == AV_NOPTS_VALUE && ts != AV_NOPTS_VALUE &&
700  (ts < 0 || s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO)) {
701  s->internal->offset = -ts;
702  s->internal->offset_timebase = st->time_base;
703  }
704 
705  if (s->internal->offset != AV_NOPTS_VALUE && !offset) {
706  offset = st->mux_ts_offset =
707  av_rescale_q_rnd(s->internal->offset,
708  s->internal->offset_timebase,
709  st->time_base,
710  AV_ROUND_UP);
711  }
712 
713  if (pkt->dts != AV_NOPTS_VALUE)
714  pkt->dts += offset;
715  if (pkt->pts != AV_NOPTS_VALUE)
716  pkt->pts += offset;
717 
718  if (s->internal->avoid_negative_ts_use_pts) {
719  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < 0) {
720  av_log(s, AV_LOG_WARNING, "failed to avoid negative "
721  "pts %s in stream %d.\n"
722  "Try -avoid_negative_ts 1 as a possible workaround.\n",
723  av_ts2str(pkt->pts),
725  );
726  }
727  } else {
728  av_assert2(pkt->dts == AV_NOPTS_VALUE || pkt->dts >= 0 || s->max_interleave_delta > 0);
729  if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < 0) {
731  "Packets poorly interleaved, failed to avoid negative "
732  "timestamp %s in stream %d.\n"
733  "Try -max_interleave_delta 0 as a possible workaround.\n",
734  av_ts2str(pkt->dts),
736  );
737  }
738  }
739  }
740 
742  AVFrame *frame = (AVFrame *)pkt->data;
744  ret = s->oformat->write_uncoded_frame(s, pkt->stream_index, &frame, 0);
746  } else {
747  ret = s->oformat->write_packet(s, pkt);
748  }
749 
750  if (s->pb && ret >= 0) {
752  if (s->pb->error < 0)
753  ret = s->pb->error;
754  }
755 
756  if (ret < 0) {
757  pkt->pts = pts_backup;
758  pkt->dts = dts_backup;
759  }
760 
761  return ret;
762 }
763 
765 {
766  if (!pkt)
767  return 0;
768 
769  if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
770  av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
771  pkt->stream_index);
772  return AVERROR(EINVAL);
773  }
774 
775  if (s->streams[pkt->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
776  av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
777  return AVERROR(EINVAL);
778  }
779 
780  return 0;
781 }
782 
784 {
785  int ret;
786 
787  ret = check_packet(s, pkt);
788  if (ret < 0)
789  return ret;
790 
791 #if !FF_API_COMPUTE_PKT_FIELDS2 || !FF_API_LAVF_AVCTX
792  /* sanitize the timestamps */
793  if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
794  AVStream *st = s->streams[pkt->stream_index];
795 
796  /* when there is no reordering (so dts is equal to pts), but
797  * only one of them is set, set the other as well */
798  if (!st->internal->reorder) {
799  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)
800  pkt->pts = pkt->dts;
801  if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
802  pkt->dts = pkt->pts;
803  }
804 
805  /* check that the timestamps are set */
806  if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {
808  "Timestamps are unset in a packet for stream %d\n", st->index);
809  return AVERROR(EINVAL);
810  }
811 
812  /* check that the dts are increasing (or at least non-decreasing,
813  * if the format allows it */
814  if (st->cur_dts != AV_NOPTS_VALUE &&
815  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && st->cur_dts >= pkt->dts) ||
816  st->cur_dts > pkt->dts)) {
818  "Application provided invalid, non monotonically increasing "
819  "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
820  st->index, st->cur_dts, pkt->dts);
821  return AVERROR(EINVAL);
822  }
823 
824  if (pkt->pts < pkt->dts) {
825  av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
826  pkt->pts, pkt->dts, st->index);
827  return AVERROR(EINVAL);
828  }
829  }
830 #endif
831 
832  return 0;
833 }
834 
836  AVStream *st = s->streams[pkt->stream_index];
837  int i, ret;
838 
839  if (!(s->flags & AVFMT_FLAG_AUTO_BSF))
840  return 1;
841 
842  if (s->oformat->check_bitstream) {
843  if (!st->internal->bitstream_checked) {
844  if ((ret = s->oformat->check_bitstream(s, pkt)) < 0)
845  return ret;
846  else if (ret == 1)
847  st->internal->bitstream_checked = 1;
848  }
849  }
850 
851  for (i = 0; i < st->internal->nb_bsfcs; i++) {
852  AVBSFContext *ctx = st->internal->bsfcs[i];
853  // TODO: when any bitstream filter requires flushing at EOF, we'll need to
854  // flush each stream's BSF chain on write_trailer.
855  if ((ret = av_bsf_send_packet(ctx, pkt)) < 0) {
857  "Failed to send packet to filter %s for stream %d\n",
858  ctx->filter->name, pkt->stream_index);
859  return ret;
860  }
861  // TODO: when any automatically-added bitstream filter is generating multiple
862  // output packets for a single input one, we'll need to call this in a loop
863  // and write each output packet.
864  if ((ret = av_bsf_receive_packet(ctx, pkt)) < 0) {
865  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
866  return 0;
868  "Failed to receive packet from filter %s for stream %d\n",
869  ctx->filter->name, pkt->stream_index);
870  if (s->error_recognition & AV_EF_EXPLODE)
871  return ret;
872  return 0;
873  }
874  }
875  return 1;
876 }
877 
879 {
880  int ret;
881 
883  if (ret < 0)
884  return ret;
885 
886  if (!pkt) {
887  if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
888  ret = s->oformat->write_packet(s, NULL);
890  if (ret >= 0 && s->pb && s->pb->error < 0)
891  ret = s->pb->error;
892  return ret;
893  }
894  return 1;
895  }
896 
898  if (ret <= 0)
899  return ret;
900 
901 #if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
902  ret = compute_muxer_pkt_fields(s, s->streams[pkt->stream_index], pkt);
903 
904  if (ret < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
905  return ret;
906 #endif
907 
908  ret = write_packet(s, pkt);
909  if (ret >= 0 && s->pb && s->pb->error < 0)
910  ret = s->pb->error;
911 
912  if (ret >= 0)
913  s->streams[pkt->stream_index]->nb_frames++;
914  return ret;
915 }
916 
917 #define CHUNK_START 0x1000
918 
920  int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
921 {
922  int ret;
923  AVPacketList **next_point, *this_pktl;
924  AVStream *st = s->streams[pkt->stream_index];
925  int chunked = s->max_chunk_size || s->max_chunk_duration;
926 
927  this_pktl = av_mallocz(sizeof(AVPacketList));
928  if (!this_pktl)
929  return AVERROR(ENOMEM);
932  av_assert0(((AVFrame *)pkt->data)->buf);
933  this_pktl->pkt = *pkt;
934  pkt->buf = NULL;
935  pkt->side_data = NULL;
936  pkt->side_data_elems = 0;
937  } else {
938  if ((ret = av_packet_ref(&this_pktl->pkt, pkt)) < 0) {
939  av_free(this_pktl);
940  return ret;
941  }
942  }
943 
944  if (s->streams[pkt->stream_index]->last_in_packet_buffer) {
945  next_point = &(st->last_in_packet_buffer->next);
946  } else {
947  next_point = &s->internal->packet_buffer;
948  }
949 
950  if (chunked) {
951  uint64_t max= av_rescale_q_rnd(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base, AV_ROUND_UP);
954  if ( (s->max_chunk_size && st->interleaver_chunk_size > s->max_chunk_size)
955  || (max && st->interleaver_chunk_duration > max)) {
956  st->interleaver_chunk_size = 0;
957  this_pktl->pkt.flags |= CHUNK_START;
958  if (max && st->interleaver_chunk_duration > max) {
959  int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
960  int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
961 
962  st->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
963  } else
965  }
966  }
967  if (*next_point) {
968  if (chunked && !(this_pktl->pkt.flags & CHUNK_START))
969  goto next_non_null;
970 
971  if (compare(s, &s->internal->packet_buffer_end->pkt, pkt)) {
972  while ( *next_point
973  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
974  || !compare(s, &(*next_point)->pkt, pkt)))
975  next_point = &(*next_point)->next;
976  if (*next_point)
977  goto next_non_null;
978  } else {
979  next_point = &(s->internal->packet_buffer_end->next);
980  }
981  }
982  av_assert1(!*next_point);
983 
984  s->internal->packet_buffer_end = this_pktl;
985 next_non_null:
986 
987  this_pktl->next = *next_point;
988 
989  s->streams[pkt->stream_index]->last_in_packet_buffer =
990  *next_point = this_pktl;
991 
993 
994  return 0;
995 }
996 
998  AVPacket *pkt)
999 {
1000  AVStream *st = s->streams[pkt->stream_index];
1001  AVStream *st2 = s->streams[next->stream_index];
1002  int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
1003  st->time_base);
1004  if (s->audio_preload) {
1005  int preload = st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
1006  int preload2 = st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
1007  if (preload != preload2) {
1008  int64_t ts, ts2;
1009  preload *= s->audio_preload;
1010  preload2 *= s->audio_preload;
1011  ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - preload;
1012  ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - preload2;
1013  if (ts == ts2) {
1014  ts = ((uint64_t)pkt ->dts*st ->time_base.num*AV_TIME_BASE - (uint64_t)preload *st ->time_base.den)*st2->time_base.den
1015  - ((uint64_t)next->dts*st2->time_base.num*AV_TIME_BASE - (uint64_t)preload2*st2->time_base.den)*st ->time_base.den;
1016  ts2 = 0;
1017  }
1018  comp = (ts2 > ts) - (ts2 < ts);
1019  }
1020  }
1021 
1022  if (comp == 0)
1023  return pkt->stream_index < next->stream_index;
1024  return comp > 0;
1025 }
1026 
1028  AVPacket *pkt, int flush)
1029 {
1030  AVPacketList *pktl;
1031  int stream_count = 0;
1032  int noninterleaved_count = 0;
1033  int i, ret;
1034  int eof = flush;
1035 
1036  if (pkt) {
1038  return ret;
1039  }
1040 
1041  for (i = 0; i < s->nb_streams; i++) {
1042  if (s->streams[i]->last_in_packet_buffer) {
1043  ++stream_count;
1044  } else if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
1045  s->streams[i]->codecpar->codec_id != AV_CODEC_ID_VP8 &&
1046  s->streams[i]->codecpar->codec_id != AV_CODEC_ID_VP9) {
1047  ++noninterleaved_count;
1048  }
1049  }
1050 
1051  if (s->internal->nb_interleaved_streams == stream_count)
1052  flush = 1;
1053 
1054  if (s->max_interleave_delta > 0 &&
1055  s->internal->packet_buffer &&
1056  !flush &&
1057  s->internal->nb_interleaved_streams == stream_count+noninterleaved_count
1058  ) {
1059  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
1060  int64_t delta_dts = INT64_MIN;
1061  int64_t top_dts = av_rescale_q(top_pkt->dts,
1062  s->streams[top_pkt->stream_index]->time_base,
1063  AV_TIME_BASE_Q);
1064 
1065  for (i = 0; i < s->nb_streams; i++) {
1066  int64_t last_dts;
1067  const AVPacketList *last = s->streams[i]->last_in_packet_buffer;
1068 
1069  if (!last)
1070  continue;
1071 
1072  last_dts = av_rescale_q(last->pkt.dts,
1073  s->streams[i]->time_base,
1074  AV_TIME_BASE_Q);
1075  delta_dts = FFMAX(delta_dts, last_dts - top_dts);
1076  }
1077 
1078  if (delta_dts > s->max_interleave_delta) {
1080  "Delay between the first packet and last packet in the "
1081  "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
1082  delta_dts, s->max_interleave_delta);
1083  flush = 1;
1084  }
1085  }
1086 
1087  if (s->internal->packet_buffer &&
1088  eof &&
1089  (s->flags & AVFMT_FLAG_SHORTEST) &&
1090  s->internal->shortest_end == AV_NOPTS_VALUE) {
1091  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
1092 
1093  s->internal->shortest_end = av_rescale_q(top_pkt->dts,
1094  s->streams[top_pkt->stream_index]->time_base,
1095  AV_TIME_BASE_Q);
1096  }
1097 
1098  if (s->internal->shortest_end != AV_NOPTS_VALUE) {
1099  while (s->internal->packet_buffer) {
1100  AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
1101  AVStream *st;
1102  int64_t top_dts = av_rescale_q(top_pkt->dts,
1103  s->streams[top_pkt->stream_index]->time_base,
1104  AV_TIME_BASE_Q);
1105 
1106  if (s->internal->shortest_end + 1 >= top_dts)
1107  break;
1108 
1109  pktl = s->internal->packet_buffer;
1110  st = s->streams[pktl->pkt.stream_index];
1111 
1112  s->internal->packet_buffer = pktl->next;
1113  if (!s->internal->packet_buffer)
1114  s->internal->packet_buffer_end = NULL;
1115 
1116  if (st->last_in_packet_buffer == pktl)
1118 
1119  av_packet_unref(&pktl->pkt);
1120  av_freep(&pktl);
1121  flush = 0;
1122  }
1123  }
1124 
1125  if (stream_count && flush) {
1126  AVStream *st;
1127  pktl = s->internal->packet_buffer;
1128  *out = pktl->pkt;
1129  st = s->streams[out->stream_index];
1130 
1131  s->internal->packet_buffer = pktl->next;
1132  if (!s->internal->packet_buffer)
1133  s->internal->packet_buffer_end = NULL;
1134 
1135  if (st->last_in_packet_buffer == pktl)
1137  av_freep(&pktl);
1138 
1139  return 1;
1140  } else {
1142  return 0;
1143  }
1144 }
1145 
1147  AVPacket *pkt, int add_offset)
1148 {
1149  AVPacketList *pktl = s->internal->packet_buffer;
1150  while (pktl) {
1151  if (pktl->pkt.stream_index == stream) {
1152  *pkt = pktl->pkt;
1153  if (add_offset) {
1154  AVStream *st = s->streams[pkt->stream_index];
1155  int64_t offset = st->mux_ts_offset;
1156 
1157  if (s->output_ts_offset)
1158  offset += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
1159 
1160  if (pkt->dts != AV_NOPTS_VALUE)
1161  pkt->dts += offset;
1162  if (pkt->pts != AV_NOPTS_VALUE)
1163  pkt->pts += offset;
1164  }
1165  return 0;
1166  }
1167  pktl = pktl->next;
1168  }
1169  return AVERROR(ENOENT);
1170 }
1171 
1172 /**
1173  * Interleave an AVPacket correctly so it can be muxed.
1174  * @param out the interleaved packet will be output here
1175  * @param in the input packet
1176  * @param flush 1 if no further packets are available as input and all
1177  * remaining packets should be output
1178  * @return 1 if a packet was output, 0 if no packet could be output,
1179  * < 0 if an error occurred
1180  */
1182 {
1183  if (s->oformat->interleave_packet) {
1184  int ret = s->oformat->interleave_packet(s, out, in, flush);
1185  if (in)
1187  return ret;
1188  } else
1190 }
1191 
1193 {
1194  int ret, flush = 0;
1195 
1197  if (ret < 0)
1198  goto fail;
1199 
1200  if (pkt) {
1201  AVStream *st = s->streams[pkt->stream_index];
1202 
1204  if (ret == 0)
1205  return 0;
1206  else if (ret < 0)
1207  goto fail;
1208 
1209  if (s->debug & FF_FDEBUG_TS)
1210  av_log(s, AV_LOG_DEBUG, "av_interleaved_write_frame size:%d dts:%s pts:%s\n",
1212 
1213 #if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
1214  if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
1215  goto fail;
1216 #endif
1217 
1218  if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
1219  ret = AVERROR(EINVAL);
1220  goto fail;
1221  }
1222  } else {
1223  av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");
1224  flush = 1;
1225  }
1226 
1227  for (;; ) {
1228  AVPacket opkt;
1229  int ret = interleave_packet(s, &opkt, pkt, flush);
1230  if (pkt) {
1231  memset(pkt, 0, sizeof(*pkt));
1233  pkt = NULL;
1234  }
1235  if (ret <= 0) //FIXME cleanup needed for ret<0 ?
1236  return ret;
1237 
1238  ret = write_packet(s, &opkt);
1239  if (ret >= 0)
1240  s->streams[opkt.stream_index]->nb_frames++;
1241 
1242  av_packet_unref(&opkt);
1243 
1244  if (ret < 0)
1245  return ret;
1246  if(s->pb && s->pb->error)
1247  return s->pb->error;
1248  }
1249 fail:
1251  return ret;
1252 }
1253 
1255 {
1256  int ret, i;
1257 
1258  for (;; ) {
1259  AVPacket pkt;
1260  ret = interleave_packet(s, &pkt, NULL, 1);
1261  if (ret < 0)
1262  goto fail;
1263  if (!ret)
1264  break;
1265 
1266  ret = write_packet(s, &pkt);
1267  if (ret >= 0)
1268  s->streams[pkt.stream_index]->nb_frames++;
1269 
1270  av_packet_unref(&pkt);
1271 
1272  if (ret < 0)
1273  goto fail;
1274  if(s->pb && s->pb->error)
1275  goto fail;
1276  }
1277 
1278 fail:
1279  if (s->oformat->write_trailer) {
1280  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1282  if (ret >= 0) {
1283  ret = s->oformat->write_trailer(s);
1284  } else {
1285  s->oformat->write_trailer(s);
1286  }
1287  }
1288 
1289  if (s->oformat->deinit)
1290  s->oformat->deinit(s);
1291 
1292  s->internal->initialized =
1293  s->internal->streams_initialized = 0;
1294 
1295  if (s->pb)
1296  avio_flush(s->pb);
1297  if (ret == 0)
1298  ret = s->pb ? s->pb->error : 0;
1299  for (i = 0; i < s->nb_streams; i++) {
1300  av_freep(&s->streams[i]->priv_data);
1301  av_freep(&s->streams[i]->index_entries);
1302  }
1303  if (s->oformat->priv_class)
1304  av_opt_free(s->priv_data);
1305  av_freep(&s->priv_data);
1306  return ret;
1307 }
1308 
1310  int64_t *dts, int64_t *wall)
1311 {
1312  if (!s->oformat || !s->oformat->get_output_timestamp)
1313  return AVERROR(ENOSYS);
1314  s->oformat->get_output_timestamp(s, stream, dts, wall);
1315  return 0;
1316 }
1317 
1318 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
1320 {
1321  AVPacket local_pkt;
1322  int ret;
1323 
1324  local_pkt = *pkt;
1325  local_pkt.stream_index = dst_stream;
1326  if (pkt->pts != AV_NOPTS_VALUE)
1327  local_pkt.pts = av_rescale_q(pkt->pts,
1328  src->streams[pkt->stream_index]->time_base,
1329  dst->streams[dst_stream]->time_base);
1330  if (pkt->dts != AV_NOPTS_VALUE)
1331  local_pkt.dts = av_rescale_q(pkt->dts,
1332  src->streams[pkt->stream_index]->time_base,
1333  dst->streams[dst_stream]->time_base);
1334  if (pkt->duration)
1335  local_pkt.duration = av_rescale_q(pkt->duration,
1336  src->streams[pkt->stream_index]->time_base,
1337  dst->streams[dst_stream]->time_base);
1338 
1339  if (interleave) ret = av_interleaved_write_frame(dst, &local_pkt);
1340  else ret = av_write_frame(dst, &local_pkt);
1341  pkt->buf = local_pkt.buf;
1342  pkt->side_data = local_pkt.side_data;
1343  pkt->side_data_elems = local_pkt.side_data_elems;
1344  return ret;
1345 }
1346 
1347 static int av_write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
1348  AVFrame *frame, int interleaved)
1349 {
1350  AVPacket pkt, *pktp;
1351 
1352  av_assert0(s->oformat);
1353  if (!s->oformat->write_uncoded_frame)
1354  return AVERROR(ENOSYS);
1355 
1356  if (!frame) {
1357  pktp = NULL;
1358  } else {
1359  pktp = &pkt;
1360  av_init_packet(&pkt);
1361  pkt.data = (void *)frame;
1363  pkt.pts =
1364  pkt.dts = frame->pts;
1365  pkt.duration = frame->pkt_duration;
1366  pkt.stream_index = stream_index;
1368  }
1369 
1370  return interleaved ? av_interleaved_write_frame(s, pktp) :
1371  av_write_frame(s, pktp);
1372 }
1373 
1375  AVFrame *frame)
1376 {
1377  return av_write_uncoded_frame_internal(s, stream_index, frame, 0);
1378 }
1379 
1381  AVFrame *frame)
1382 {
1383  return av_write_uncoded_frame_internal(s, stream_index, frame, 1);
1384 }
1385 
1387 {
1388  av_assert0(s->oformat);
1389  if (!s->oformat->write_uncoded_frame)
1390  return AVERROR(ENOSYS);
1391  return s->oformat->write_uncoded_frame(s, stream_index, NULL,
1393 }
AVStreamInternal::priv_pts
FFFrac * priv_pts
Definition: internal.h:194
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
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
LIBAVFORMAT_IDENT
#define LIBAVFORMAT_IDENT
Definition: version.h:46
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: avcodec.h:1545
AVStreamInternal::reorder
int reorder
Set to 1 if the codec allows reordering, so pts can be different from dts.
Definition: internal.h:154
prepare_input_packet
static int prepare_input_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:783
AVSTREAM_INIT_IN_WRITE_HEADER
#define AVSTREAM_INIT_IN_WRITE_HEADER
stream parameters initialized in avformat_write_header
Definition: avformat.h:2505
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: avcodec.h:3953
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:1305
AVFMT_NODIMENSIONS
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:471
FF_FDEBUG_TS
#define FF_FDEBUG_TS
Definition: avformat.h:1626
out
FILE * out
Definition: movenc.c:54
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:172
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: avcodec.h:3949
n
int n
Definition: avisynth_c.h:760
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:960
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:366
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:838
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:2098
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:467
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:45
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: avcodec.h:231
AVPacketList::next
struct AVPacketList * next
Definition: avformat.h:2010
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:186
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
id3v2.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
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:1410
avpriv_toupper4
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:1853
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:1374
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
AVStream::internal
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1227
ff_interleave_add_packet
int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt, int(*compare)(AVFormatContext *, AVPacket *, AVPacket *))
Add packet to AVFormatContext->packet_buffer list, determining its interleaved position using compare...
Definition: mux.c:919
AVStream::cur_dts
int64_t cur_dts
Definition: avformat.h:1073
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:1500
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1495
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3961
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:1386
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:488
AVBSFContext
The bitstream filter state.
Definition: avcodec.h:5763
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:540
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:493
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: avcodec.h:4063
fail
#define fail()
Definition: checkasm.h:120
AVFMT_FLAG_AUTO_BSF
#define AVFMT_FLAG_AUTO_BSF
Add bitstream filters as requested by the muxer.
Definition: avformat.h:1501
AVFMT_AVOID_NEG_TS_MAKE_ZERO
#define AVFMT_AVOID_NEG_TS_MAKE_ZERO
Shift timestamps so that they start at 0.
Definition: avformat.h:1676
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:1181
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition: avcodec.h:1544
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:843
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:83
AVRational::num
int num
Numerator.
Definition: rational.h:59
src
#define src
Definition: vp8dsp.c:254
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)
Make timestamps non negative, move side data from payload to internal struct, call muxer,...
Definition: mux.c:674
AVCodecTag
Definition: internal.h:44
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:1603
AV_PKT_FLAG_UNCODED_FRAME
#define AV_PKT_FLAG_UNCODED_FRAME
Definition: mux.c:544
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: avcodec.h:716
s
#define s(width, name)
Definition: cbs_vp9.c:257
UNCODED_FRAME_PACKET_SIZE
#define UNCODED_FRAME_PACKET_SIZE
Definition: mux.c:550
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: avcodec.h:4033
AVDictionaryEntry::key
char * key
Definition: dict.h:82
frame_size
int frame_size
Definition: mxfenc.c:2215
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: avcodec.h:386
AVCodecParameters::width
int width
Video only.
Definition: avcodec.h:4023
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:917
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
ctx
AVFormatContext * ctx
Definition: movenc.c:48
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:521
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:1380
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
av_write_uncoded_frame_internal
static int av_write_uncoded_frame_internal(AVFormatContext *s, int stream_index, AVFrame *frame, int interleaved)
Definition: mux.c:1347
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:508
init_muxer
static int init_muxer(AVFormatContext *s, AVDictionary **options)
Definition: mux.c:243
if
if(ret)
Definition: filter_design.txt:179
AVFormatContext
Format I/O context.
Definition: avformat.h:1342
AVStreamInternal::bsfcs
AVBSFContext ** bsfcs
bitstream filters to run on stream
Definition: internal.h:161
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1460
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1017
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:899
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:543
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
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:545
AVStream::interleaver_chunk_duration
int64_t interleaver_chunk_duration
Definition: avformat.h:1119
parseutils.h
AVStream::last_in_packet_buffer
struct AVPacketList * last_in_packet_buffer
last packet in packet_buffer for this stream when muxing.
Definition: avformat.h:1094
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1558
frac_add
static void frac_add(FFFrac *f, int64_t incr)
Fractional addition to f: f = f + (incr / f->den).
Definition: mux.c:82
time.h
AVOutputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:524
av_write_frame
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
Definition: mux.c:878
av_packet_ref
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:608
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2705
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:1318
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: avcodec.h:4067
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: avcodec.h:219
error
static void error(const char *err)
Definition: target_dec_fuzzer.c:61
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
validate_codec_tag
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
Definition: mux.c:209
AVOutputFormat::flags
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:515
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:1550
options
const OptionDef options[]
AVStream::mux_ts_offset
int64_t mux_ts_offset
Timestamp offset added to timestamps before muxing NOT PART OF PUBLIC API.
Definition: avformat.h:1174
desc
const char * desc
Definition: nvenc.c:68
AVPacket::size
int size
Definition: avcodec.h:1478
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:62
flush_if_needed
static void flush_if_needed(AVFormatContext *s)
Definition: mux.c:478
AV_CODEC_PROP_REORDER
#define AV_CODEC_PROP_REORDER
Codec supports frame reordering.
Definition: avcodec.h:770
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:4910
AVStream::pts_buffer
int64_t pts_buffer[MAX_REORDER_DELAY+1]
Definition: avformat.h:1097
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
MAX_REORDER_DELAY
@ MAX_REORDER_DELAY
Definition: vaapi_encode.h:43
AVFMT_ALLOW_FLUSH
#define AVFMT_ALLOW_FLUSH
Format allows flushing.
Definition: avformat.h:476
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:463
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:542
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:932
val
const char const char void * val
Definition: avisynth_c.h:863
AVFMT_NOSTREAMS
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:472
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:556
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: avcodec.h:1476
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:1578
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
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
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2631
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:541
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: avcodec.h:225
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:1254
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: avcodec.h:216
AVOutputFormat
Definition: avformat.h:495
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
avio_internal.h
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3257
internal.h
AVCodecParameters::height
int height
Definition: avcodec.h:4024
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: avcodec.h:4074
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:1309
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:1675
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:205
url.h
av_get_audio_frame_duration
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:1775
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:236
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
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:4038
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:480
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:477
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:923
tag
uint32_t tag
Definition: movenc.c:1496
AVFMT_FLAG_BITEXACT
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1490
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:870
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
metadata.h
avformat.h
dict.h
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: avcodec.h:1488
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:102
network.h
AVCodecParameters::chroma_location
enum AVChromaLocation chroma_location
Definition: avcodec.h:4047
check_packet
static int check_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:764
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:871
compare
static float compare(const AVFrame *haystack, const AVFrame *obj, int offx, int offy)
Definition: vf_find_rect.c:104
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:544
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:4414
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:212
AVSTREAM_INIT_IN_INIT_OUTPUT
#define AVSTREAM_INIT_IN_INIT_OUTPUT
stream parameters initialized in avformat_init_output
Definition: avformat.h:2506
AVPacket::stream_index
int stream_index
Definition: avcodec.h:1479
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:1146
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FFFrac::num
int64_t num
Definition: internal.h:62
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:1825
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:908
ff_interleave_packet_per_dts
int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
Interleave a packet per dts in an output media file.
Definition: mux.c:1027
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:118
AVCodecParameters::video_delay
int video_delay
Video only.
Definition: avcodec.h:4052
AVCodecParameters::format
int format
Definition: avcodec.h:3981
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
avio_flush
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
init_pts
static int init_pts(AVFormatContext *s)
Definition: mux.c:433
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: avcodec.h:3957
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:64
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
AV_WRITE_UNCODED_FRAME_QUERY
@ AV_WRITE_UNCODED_FRAME_QUERY
Query whether the feature is possible on this stream.
Definition: internal.h:644
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:1192
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
riff.h
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
bytestream.h
timestamp.h
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: avcodec.h:358
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
interleave_compare_dts
static int interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
Definition: mux.c:997
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:1483
AVStream::interleaver_chunk_size
int64_t interleaver_chunk_size
Definition: avformat.h:1118
AVFMT_AVOID_NEG_TS_AUTO
#define AVFMT_AVOID_NEG_TS_AUTO
Enabled when required by target format.
Definition: avformat.h:1674
avstring.h
AVStreamInternal::nb_bsfcs
int nb_bsfcs
Definition: internal.h:162
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:148
FFFrac
The exact value of the fractional number is: 'val + num / den'.
Definition: internal.h:61
FFFrac::den
int64_t den
Definition: internal.h:62
AVCodecTag::tag
unsigned int tag
Definition: internal.h:46
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
do_packet_auto_bsf
static int do_packet_auto_bsf(AVFormatContext *s, AVPacket *pkt)
Definition: mux.c:835
audiointerleave.h
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: avcodec.h:1489
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:33
AVStreamInternal::bitstream_checked
int bitstream_checked
Whether or not check_bitstream should still be run on each packet.
Definition: internal.h:167
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:546