FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 #undef NDEBUG
48 #include <assert.h>
49 
50 /**
51  * @file
52  * muxing functions for use within libavformat
53  */
54 
55 /* fraction handling */
56 
57 /**
58  * f = val + (num / den) + 0.5.
59  *
60  * 'num' is normalized so that it is such as 0 <= num < den.
61  *
62  * @param f fractional number
63  * @param val integer value
64  * @param num must be >= 0
65  * @param den must be >= 1
66  */
67 static void frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
68 {
69  num += (den >> 1);
70  if (num >= den) {
71  val += num / den;
72  num = num % den;
73  }
74  f->val = val;
75  f->num = num;
76  f->den = den;
77 }
78 
79 /**
80  * Fractional addition to f: f = f + (incr / f->den).
81  *
82  * @param f fractional number
83  * @param incr increment, can be positive or negative
84  */
85 static void frac_add(AVFrac *f, int64_t incr)
86 {
87  int64_t num, den;
88 
89  num = f->num + incr;
90  den = f->den;
91  if (num < 0) {
92  f->val += num / den;
93  num = num % den;
94  if (num < 0) {
95  num += den;
96  f->val--;
97  }
98  } else if (num >= den) {
99  f->val += num / den;
100  num = num % den;
101  }
102  f->num = num;
103 }
104 
106 {
107  AVRational q;
108  int j;
109 
110  q = st->time_base;
111 
112  for (j=2; j<14; j+= 1+(j>2))
113  while (q.den / q.num < min_precision && q.num % j == 0)
114  q.num /= j;
115  while (q.den / q.num < min_precision && q.den < (1<<24))
116  q.den <<= 1;
117 
118  return q;
119 }
120 
122  const char *format, const char *filename)
123 {
125  int ret = 0;
126 
127  *avctx = NULL;
128  if (!s)
129  goto nomem;
130 
131  if (!oformat) {
132  if (format) {
133  oformat = av_guess_format(format, NULL, NULL);
134  if (!oformat) {
135  av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
136  ret = AVERROR(EINVAL);
137  goto error;
138  }
139  } else {
140  oformat = av_guess_format(NULL, filename, NULL);
141  if (!oformat) {
142  ret = AVERROR(EINVAL);
143  av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
144  filename);
145  goto error;
146  }
147  }
148  }
149 
150  s->oformat = oformat;
151  if (s->oformat->priv_data_size > 0) {
153  if (!s->priv_data)
154  goto nomem;
155  if (s->oformat->priv_class) {
156  *(const AVClass**)s->priv_data= s->oformat->priv_class;
158  }
159  } else
160  s->priv_data = NULL;
161 
162  if (filename)
163  av_strlcpy(s->filename, filename, sizeof(s->filename));
164  *avctx = s;
165  return 0;
166 nomem:
167  av_log(s, AV_LOG_ERROR, "Out of memory\n");
168  ret = AVERROR(ENOMEM);
169 error:
171  return ret;
172 }
173 
174 #if FF_API_ALLOC_OUTPUT_CONTEXT
175 AVFormatContext *avformat_alloc_output_context(const char *format,
176  AVOutputFormat *oformat, const char *filename)
177 {
178  AVFormatContext *avctx;
179  int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
180  return ret < 0 ? NULL : avctx;
181 }
182 #endif
183 
185 {
186  const AVCodecTag *avctag;
187  int n;
188  enum AVCodecID id = AV_CODEC_ID_NONE;
189  int64_t tag = -1;
190 
191  /**
192  * Check that tag + id is in the table
193  * If neither is in the table -> OK
194  * If tag is in the table with another id -> FAIL
195  * If id is in the table with another tag -> FAIL unless strict < normal
196  */
197  for (n = 0; s->oformat->codec_tag[n]; n++) {
198  avctag = s->oformat->codec_tag[n];
199  while (avctag->id != AV_CODEC_ID_NONE) {
200  if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
201  id = avctag->id;
202  if (id == st->codec->codec_id)
203  return 1;
204  }
205  if (avctag->id == st->codec->codec_id)
206  tag = avctag->tag;
207  avctag++;
208  }
209  }
210  if (id != AV_CODEC_ID_NONE)
211  return 0;
212  if (tag >= 0 && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
213  return 0;
214  return 1;
215 }
216 
217 
219 {
220  int ret = 0, i;
221  AVStream *st;
222  AVDictionary *tmp = NULL;
223  AVCodecContext *codec = NULL;
224  AVOutputFormat *of = s->oformat;
226 
227  if (options)
228  av_dict_copy(&tmp, *options, 0);
229 
230  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
231  goto fail;
232  if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
233  (ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
234  goto fail;
235 
236 #if FF_API_LAVF_BITEXACT
237  if (s->nb_streams && s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)
239 #endif
240 
241  // some sanity checks
242  if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) {
243  av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");
244  ret = AVERROR(EINVAL);
245  goto fail;
246  }
247 
248  for (i = 0; i < s->nb_streams; i++) {
249  st = s->streams[i];
250  codec = st->codec;
251 
252 #if FF_API_LAVF_CODEC_TB
254  if (!st->time_base.num && codec->time_base.num) {
255  av_log(s, AV_LOG_WARNING, "Using AVStream.codec.time_base as a "
256  "timebase hint to the muxer is deprecated. Set "
257  "AVStream.time_base instead.\n");
258  avpriv_set_pts_info(st, 64, codec->time_base.num, codec->time_base.den);
259  }
261 #endif
262 
263  if (!st->time_base.num) {
264  /* fall back on the default timebase values */
265  if (codec->codec_type == AVMEDIA_TYPE_AUDIO && codec->sample_rate)
266  avpriv_set_pts_info(st, 64, 1, codec->sample_rate);
267  else
268  avpriv_set_pts_info(st, 33, 1, 90000);
269  }
270 
271  switch (codec->codec_type) {
272  case AVMEDIA_TYPE_AUDIO:
273  if (codec->sample_rate <= 0) {
274  av_log(s, AV_LOG_ERROR, "sample rate not set\n");
275  ret = AVERROR(EINVAL);
276  goto fail;
277  }
278  if (!codec->block_align)
279  codec->block_align = codec->channels *
280  av_get_bits_per_sample(codec->codec_id) >> 3;
281  break;
282  case AVMEDIA_TYPE_VIDEO:
283  if ((codec->width <= 0 || codec->height <= 0) &&
284  !(of->flags & AVFMT_NODIMENSIONS)) {
285  av_log(s, AV_LOG_ERROR, "dimensions not set\n");
286  ret = AVERROR(EINVAL);
287  goto fail;
288  }
291  ) {
292  if (st->sample_aspect_ratio.num != 0 &&
293  st->sample_aspect_ratio.den != 0 &&
294  codec->sample_aspect_ratio.den != 0 &&
295  codec->sample_aspect_ratio.den != 0) {
296  av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
297  "(%d/%d) and encoder layer (%d/%d)\n",
299  codec->sample_aspect_ratio.num,
300  codec->sample_aspect_ratio.den);
301  ret = AVERROR(EINVAL);
302  goto fail;
303  }
304  }
305  break;
306  }
307 
308  if (of->codec_tag) {
309  if ( codec->codec_tag
310  && codec->codec_id == AV_CODEC_ID_RAWVIDEO
311  && ( av_codec_get_tag(of->codec_tag, codec->codec_id) == 0
312  || av_codec_get_tag(of->codec_tag, codec->codec_id) == MKTAG('r', 'a', 'w', ' '))
313  && !validate_codec_tag(s, st)) {
314  // the current rawvideo encoding system ends up setting
315  // the wrong codec_tag for avi/mov, we override it here
316  codec->codec_tag = 0;
317  }
318  if (codec->codec_tag) {
319  if (!validate_codec_tag(s, st)) {
320  char tagbuf[32], tagbuf2[32];
321  av_get_codec_tag_string(tagbuf, sizeof(tagbuf), codec->codec_tag);
322  av_get_codec_tag_string(tagbuf2, sizeof(tagbuf2), av_codec_get_tag(s->oformat->codec_tag, codec->codec_id));
323  av_log(s, AV_LOG_ERROR,
324  "Tag %s/0x%08x incompatible with output codec id '%d' (%s)\n",
325  tagbuf, codec->codec_tag, codec->codec_id, tagbuf2);
326  ret = AVERROR_INVALIDDATA;
327  goto fail;
328  }
329  } else
330  codec->codec_tag = av_codec_get_tag(of->codec_tag, codec->codec_id);
331  }
332 
333  if (of->flags & AVFMT_GLOBALHEADER &&
334  !(codec->flags & CODEC_FLAG_GLOBAL_HEADER))
336  "Codec for stream %d does not use global headers "
337  "but container format requires global headers\n", i);
338 
339  if (codec->codec_type != AVMEDIA_TYPE_ATTACHMENT)
341  }
342 
343  if (!s->priv_data && of->priv_data_size > 0) {
345  if (!s->priv_data) {
346  ret = AVERROR(ENOMEM);
347  goto fail;
348  }
349  if (of->priv_class) {
350  *(const AVClass **)s->priv_data = of->priv_class;
352  if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
353  goto fail;
354  }
355  }
356 
357  /* set muxer identification string */
358  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
359  av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
360  } else {
361  av_dict_set(&s->metadata, "encoder", NULL, 0);
362  }
363 
364  for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {
365  av_dict_set(&s->metadata, e->key, NULL, 0);
366  }
367 
368  if (options) {
369  av_dict_free(options);
370  *options = tmp;
371  }
372 
373  return 0;
374 
375 fail:
376  av_dict_free(&tmp);
377  return ret;
378 }
379 
381 {
382  int i;
383  AVStream *st;
384 
385  /* init PTS generation */
386  for (i = 0; i < s->nb_streams; i++) {
387  int64_t den = AV_NOPTS_VALUE;
388  st = s->streams[i];
389 
390  switch (st->codec->codec_type) {
391  case AVMEDIA_TYPE_AUDIO:
392  den = (int64_t)st->time_base.num * st->codec->sample_rate;
393  break;
394  case AVMEDIA_TYPE_VIDEO:
395  den = (int64_t)st->time_base.num * st->codec->time_base.den;
396  break;
397  default:
398  break;
399  }
400  if (den != AV_NOPTS_VALUE) {
401  if (den <= 0)
402  return AVERROR_INVALIDDATA;
403 
404  frac_init(&st->pts, 0, 0, den);
405  }
406  }
407 
408  return 0;
409 }
410 
412 {
413  int ret = 0;
414 
415  if (ret = init_muxer(s, options))
416  return ret;
417 
418  if (s->oformat->write_header) {
419  ret = s->oformat->write_header(s);
420  if (ret >= 0 && s->pb && s->pb->error < 0)
421  ret = s->pb->error;
422  if (ret < 0)
423  return ret;
424  }
425 
426  if ((ret = init_pts(s)) < 0)
427  return ret;
428 
429  if (s->avoid_negative_ts < 0) {
431  s->avoid_negative_ts = 0;
432  } else
433  s->avoid_negative_ts = 1;
434  }
435 
436  return 0;
437 }
438 
439 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
440 
441 /* Note: using sizeof(AVFrame) from outside lavu is unsafe in general, but
442  it is only being used internally to this file as a consistency check.
443  The value is chosen to be very unlikely to appear on its own and to cause
444  immediate failure if used anywhere as a real size. */
445 #define UNCODED_FRAME_PACKET_SIZE (INT_MIN / 3 * 2 + (int)sizeof(AVFrame))
446 
447 
448 //FIXME merge with compute_pkt_fields
450 {
451  int delay = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames > 0);
452  int num, den, i;
453  int frame_size;
454 
455  av_dlog(s, "compute_pkt_fields2: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
456  av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), delay, pkt->size, pkt->stream_index);
457 
458  if (pkt->duration < 0 && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) {
459  av_log(s, AV_LOG_WARNING, "Packet with invalid duration %d in stream %d\n",
460  pkt->duration, pkt->stream_index);
461  pkt->duration = 0;
462  }
463 
464  /* duration field */
465  if (pkt->duration == 0) {
466  ff_compute_frame_duration(&num, &den, st, NULL, pkt);
467  if (den && num) {
468  pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
469  }
470  }
471 
472  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
473  pkt->pts = pkt->dts;
474 
475  //XXX/FIXME this is a temporary hack until all encoders output pts
476  if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
477  static int warned;
478  if (!warned) {
479  av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
480  warned = 1;
481  }
482  pkt->dts =
483 // pkt->pts= st->cur_dts;
484  pkt->pts = st->pts.val;
485  }
486 
487  //calculate dts from pts
488  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
489  st->pts_buffer[0] = pkt->pts;
490  for (i = 1; i < delay + 1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
491  st->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
492  for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
493  FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
494 
495  pkt->dts = st->pts_buffer[0];
496  }
497 
498  if (st->cur_dts && st->cur_dts != AV_NOPTS_VALUE &&
499  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
500  st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
501  av_log(s, AV_LOG_ERROR,
502  "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
503  st->index, av_ts2str(st->cur_dts), av_ts2str(pkt->dts));
504  return AVERROR(EINVAL);
505  }
506  if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
507  av_log(s, AV_LOG_ERROR, "pts (%s) < dts (%s) in stream %d\n",
508  av_ts2str(pkt->pts), av_ts2str(pkt->dts), st->index);
509  return AVERROR(EINVAL);
510  }
511 
512  av_dlog(s, "av_write_frame: pts2:%s dts2:%s\n",
513  av_ts2str(pkt->pts), av_ts2str(pkt->dts));
514  st->cur_dts = pkt->dts;
515  st->pts.val = pkt->dts;
516 
517  /* update pts */
518  switch (st->codec->codec_type) {
519  case AVMEDIA_TYPE_AUDIO:
520  frame_size = (pkt->flags & AV_PKT_FLAG_UNCODED_FRAME) ?
521  ((AVFrame *)pkt->data)->nb_samples :
522  ff_get_audio_frame_size(st->codec, pkt->size, 1);
523 
524  /* HACK/FIXME, we skip the initial 0 size packets as they are most
525  * likely equal to the encoder delay, but it would be better if we
526  * had the real timestamps from the encoder */
527  if (frame_size >= 0 && (pkt->size || st->pts.num != st->pts.den >> 1 || st->pts.val)) {
528  frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
529  }
530  break;
531  case AVMEDIA_TYPE_VIDEO:
532  frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
533  break;
534  }
535  return 0;
536 }
537 
538 /**
539  * Make timestamps non negative, move side data from payload to internal struct, call muxer, and restore
540  * sidedata.
541  *
542  * FIXME: this function should NEVER get undefined pts/dts beside when the
543  * AVFMT_NOTIMESTAMPS is set.
544  * Those additional safety checks should be dropped once the correct checks
545  * are set in the callers.
546  */
548 {
549  int ret, did_split;
550 
551  if (s->output_ts_offset) {
552  AVStream *st = s->streams[pkt->stream_index];
554 
555  if (pkt->dts != AV_NOPTS_VALUE)
556  pkt->dts += offset;
557  if (pkt->pts != AV_NOPTS_VALUE)
558  pkt->pts += offset;
559  }
560 
561  if (s->avoid_negative_ts > 0) {
562  AVStream *st = s->streams[pkt->stream_index];
563  int64_t offset = st->mux_ts_offset;
564 
565  if ((pkt->dts < 0 || s->avoid_negative_ts == 2) && pkt->dts != AV_NOPTS_VALUE && !s->offset) {
566  s->offset = -pkt->dts;
567  s->offset_timebase = st->time_base;
568  }
569 
570  if (s->offset && !offset) {
571  offset = st->mux_ts_offset =
573  s->offset_timebase,
574  st->time_base,
575  AV_ROUND_UP);
576  }
577 
578  if (pkt->dts != AV_NOPTS_VALUE)
579  pkt->dts += offset;
580  if (pkt->pts != AV_NOPTS_VALUE)
581  pkt->pts += offset;
582 
583  av_assert2(pkt->dts == AV_NOPTS_VALUE || pkt->dts >= 0);
584  }
585 
586  did_split = av_packet_split_side_data(pkt);
587  if ((pkt->flags & AV_PKT_FLAG_UNCODED_FRAME)) {
588  AVFrame *frame = (AVFrame *)pkt->data;
590  ret = s->oformat->write_uncoded_frame(s, pkt->stream_index, &frame, 0);
591  av_frame_free(&frame);
592  } else {
593  ret = s->oformat->write_packet(s, pkt);
594  }
595 
596  if (s->flush_packets && s->pb && ret >= 0 && s->flags & AVFMT_FLAG_FLUSH_PACKETS)
597  avio_flush(s->pb);
598 
599  if (did_split)
601 
602  return ret;
603 }
604 
606 {
607  if (!pkt)
608  return 0;
609 
610  if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
611  av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
612  pkt->stream_index);
613  return AVERROR(EINVAL);
614  }
615 
617  av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
618  return AVERROR(EINVAL);
619  }
620 
621  return 0;
622 }
623 
625 {
626  int ret;
627 
628  ret = check_packet(s, pkt);
629  if (ret < 0)
630  return ret;
631 
632  if (!pkt) {
633  if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
634  ret = s->oformat->write_packet(s, NULL);
635  if (s->flush_packets && s->pb && s->pb->error >= 0 && s->flags & AVFMT_FLAG_FLUSH_PACKETS)
636  avio_flush(s->pb);
637  if (ret >= 0 && s->pb && s->pb->error < 0)
638  ret = s->pb->error;
639  return ret;
640  }
641  return 1;
642  }
643 
644  ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
645 
646  if (ret < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
647  return ret;
648 
649  ret = write_packet(s, pkt);
650  if (ret >= 0 && s->pb && s->pb->error < 0)
651  ret = s->pb->error;
652 
653  if (ret >= 0)
654  s->streams[pkt->stream_index]->nb_frames++;
655  return ret;
656 }
657 
658 #define CHUNK_START 0x1000
659 
661  int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
662 {
663  int ret;
664  AVPacketList **next_point, *this_pktl;
665  AVStream *st = s->streams[pkt->stream_index];
666  int chunked = s->max_chunk_size || s->max_chunk_duration;
667 
668  this_pktl = av_mallocz(sizeof(AVPacketList));
669  if (!this_pktl)
670  return AVERROR(ENOMEM);
671  this_pktl->pkt = *pkt;
672 #if FF_API_DESTRUCT_PACKET
674  pkt->destruct = NULL; // do not free original but only the copy
676 #endif
677  pkt->buf = NULL;
678  pkt->side_data = NULL;
679  pkt->side_data_elems = 0;
680  if ((pkt->flags & AV_PKT_FLAG_UNCODED_FRAME)) {
682  av_assert0(((AVFrame *)pkt->data)->buf);
683  } else {
684  // Duplicate the packet if it uses non-allocated memory
685  if ((ret = av_dup_packet(&this_pktl->pkt)) < 0) {
686  av_free(this_pktl);
687  return ret;
688  }
689  }
690 
692  next_point = &(st->last_in_packet_buffer->next);
693  } else {
694  next_point = &s->packet_buffer;
695  }
696 
697  if (chunked) {
699  st->interleaver_chunk_size += pkt->size;
702  || (max && st->interleaver_chunk_duration > max)) {
703  st->interleaver_chunk_size = 0;
704  this_pktl->pkt.flags |= CHUNK_START;
705  if (max && st->interleaver_chunk_duration > max) {
706  int64_t syncoffset = (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
707  int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
708 
709  st->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
710  } else
712  }
713  }
714  if (*next_point) {
715  if (chunked && !(this_pktl->pkt.flags & CHUNK_START))
716  goto next_non_null;
717 
718  if (compare(s, &s->packet_buffer_end->pkt, pkt)) {
719  while ( *next_point
720  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
721  || !compare(s, &(*next_point)->pkt, pkt)))
722  next_point = &(*next_point)->next;
723  if (*next_point)
724  goto next_non_null;
725  } else {
726  next_point = &(s->packet_buffer_end->next);
727  }
728  }
729  av_assert1(!*next_point);
730 
731  s->packet_buffer_end = this_pktl;
732 next_non_null:
733 
734  this_pktl->next = *next_point;
735 
737  *next_point = this_pktl;
738 
739  return 0;
740 }
741 
743  AVPacket *pkt)
744 {
745  AVStream *st = s->streams[pkt->stream_index];
746  AVStream *st2 = s->streams[next->stream_index];
747  int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
748  st->time_base);
750  int64_t ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - s->audio_preload*(st ->codec->codec_type == AVMEDIA_TYPE_AUDIO);
751  int64_t ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - s->audio_preload*(st2->codec->codec_type == AVMEDIA_TYPE_AUDIO);
752  if (ts == ts2) {
753  ts= ( pkt ->dts* st->time_base.num*AV_TIME_BASE - s->audio_preload*(int64_t)(st ->codec->codec_type == AVMEDIA_TYPE_AUDIO)* st->time_base.den)*st2->time_base.den
754  -( next->dts*st2->time_base.num*AV_TIME_BASE - s->audio_preload*(int64_t)(st2->codec->codec_type == AVMEDIA_TYPE_AUDIO)*st2->time_base.den)* st->time_base.den;
755  ts2=0;
756  }
757  comp= (ts>ts2) - (ts<ts2);
758  }
759 
760  if (comp == 0)
761  return pkt->stream_index < next->stream_index;
762  return comp > 0;
763 }
764 
766  AVPacket *pkt, int flush)
767 {
768  AVPacketList *pktl;
769  int stream_count = 0;
770  int noninterleaved_count = 0;
771  int i, ret;
772 
773  if (pkt) {
774  if ((ret = ff_interleave_add_packet(s, pkt, interleave_compare_dts)) < 0)
775  return ret;
776  }
777 
778  for (i = 0; i < s->nb_streams; i++) {
779  if (s->streams[i]->last_in_packet_buffer) {
780  ++stream_count;
781  } else if (s->streams[i]->codec->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
782  s->streams[i]->codec->codec_id != AV_CODEC_ID_VP8 &&
783  s->streams[i]->codec->codec_id != AV_CODEC_ID_VP9) {
784  ++noninterleaved_count;
785  }
786  }
787 
788  if (s->internal->nb_interleaved_streams == stream_count)
789  flush = 1;
790 
791  if (s->max_interleave_delta > 0 &&
792  s->packet_buffer &&
793  !flush &&
794  s->internal->nb_interleaved_streams == stream_count+noninterleaved_count
795  ) {
796  AVPacket *top_pkt = &s->packet_buffer->pkt;
797  int64_t delta_dts = INT64_MIN;
798  int64_t top_dts = av_rescale_q(top_pkt->dts,
799  s->streams[top_pkt->stream_index]->time_base,
801 
802  for (i = 0; i < s->nb_streams; i++) {
803  int64_t last_dts;
804  const AVPacketList *last = s->streams[i]->last_in_packet_buffer;
805 
806  if (!last)
807  continue;
808 
809  last_dts = av_rescale_q(last->pkt.dts,
810  s->streams[i]->time_base,
812  delta_dts = FFMAX(delta_dts, last_dts - top_dts);
813  }
814 
815  if (delta_dts > s->max_interleave_delta) {
816  av_log(s, AV_LOG_DEBUG,
817  "Delay between the first packet and last packet in the "
818  "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
819  delta_dts, s->max_interleave_delta);
820  flush = 1;
821  }
822  }
823 
824  if (stream_count && flush) {
825  AVStream *st;
826  pktl = s->packet_buffer;
827  *out = pktl->pkt;
828  st = s->streams[out->stream_index];
829 
830  s->packet_buffer = pktl->next;
831  if (!s->packet_buffer)
832  s->packet_buffer_end = NULL;
833 
834  if (st->last_in_packet_buffer == pktl)
835  st->last_in_packet_buffer = NULL;
836  av_freep(&pktl);
837 
838  return 1;
839  } else {
840  av_init_packet(out);
841  return 0;
842  }
843 }
844 
845 /**
846  * Interleave an AVPacket correctly so it can be muxed.
847  * @param out the interleaved packet will be output here
848  * @param in the input packet
849  * @param flush 1 if no further packets are available as input and all
850  * remaining packets should be output
851  * @return 1 if a packet was output, 0 if no packet could be output,
852  * < 0 if an error occurred
853  */
855 {
856  if (s->oformat->interleave_packet) {
857  int ret = s->oformat->interleave_packet(s, out, in, flush);
858  if (in)
859  av_free_packet(in);
860  return ret;
861  } else
862  return ff_interleave_packet_per_dts(s, out, in, flush);
863 }
864 
866 {
867  int ret, flush = 0;
868 
869  ret = check_packet(s, pkt);
870  if (ret < 0)
871  goto fail;
872 
873  if (pkt) {
874  AVStream *st = s->streams[pkt->stream_index];
875 
876  av_dlog(s, "av_interleaved_write_frame size:%d dts:%s pts:%s\n",
877  pkt->size, av_ts2str(pkt->dts), av_ts2str(pkt->pts));
878  if ((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
879  goto fail;
880 
881  if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
882  ret = AVERROR(EINVAL);
883  goto fail;
884  }
885  } else {
886  av_dlog(s, "av_interleaved_write_frame FLUSH\n");
887  flush = 1;
888  }
889 
890  for (;; ) {
891  AVPacket opkt;
892  int ret = interleave_packet(s, &opkt, pkt, flush);
893  if (pkt) {
894  memset(pkt, 0, sizeof(*pkt));
895  av_init_packet(pkt);
896  pkt = NULL;
897  }
898  if (ret <= 0) //FIXME cleanup needed for ret<0 ?
899  return ret;
900 
901  ret = write_packet(s, &opkt);
902  if (ret >= 0)
903  s->streams[opkt.stream_index]->nb_frames++;
904 
905  av_free_packet(&opkt);
906 
907  if (ret < 0)
908  return ret;
909  if(s->pb && s->pb->error)
910  return s->pb->error;
911  }
912 fail:
913  av_packet_unref(pkt);
914  return ret;
915 }
916 
918 {
919  int ret, i;
920 
921  for (;; ) {
922  AVPacket pkt;
923  ret = interleave_packet(s, &pkt, NULL, 1);
924  if (ret < 0) //FIXME cleanup needed for ret<0 ?
925  goto fail;
926  if (!ret)
927  break;
928 
929  ret = write_packet(s, &pkt);
930  if (ret >= 0)
931  s->streams[pkt.stream_index]->nb_frames++;
932 
933  av_free_packet(&pkt);
934 
935  if (ret < 0)
936  goto fail;
937  if(s->pb && s->pb->error)
938  goto fail;
939  }
940 
941  if (s->oformat->write_trailer)
942  ret = s->oformat->write_trailer(s);
943 
944 fail:
945  if (s->pb)
946  avio_flush(s->pb);
947  if (ret == 0)
948  ret = s->pb ? s->pb->error : 0;
949  for (i = 0; i < s->nb_streams; i++) {
950  av_freep(&s->streams[i]->priv_data);
951  av_freep(&s->streams[i]->index_entries);
952  }
953  if (s->oformat->priv_class)
955  av_freep(&s->priv_data);
956  return ret;
957 }
958 
959 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
960  int64_t *dts, int64_t *wall)
961 {
962  if (!s->oformat || !s->oformat->get_output_timestamp)
963  return AVERROR(ENOSYS);
964  s->oformat->get_output_timestamp(s, stream, dts, wall);
965  return 0;
966 }
967 
968 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
970 {
971  AVPacket local_pkt;
972  int ret;
973 
974  local_pkt = *pkt;
975  local_pkt.stream_index = dst_stream;
976  if (pkt->pts != AV_NOPTS_VALUE)
977  local_pkt.pts = av_rescale_q(pkt->pts,
978  src->streams[pkt->stream_index]->time_base,
979  dst->streams[dst_stream]->time_base);
980  if (pkt->dts != AV_NOPTS_VALUE)
981  local_pkt.dts = av_rescale_q(pkt->dts,
982  src->streams[pkt->stream_index]->time_base,
983  dst->streams[dst_stream]->time_base);
984  if (pkt->duration)
985  local_pkt.duration = av_rescale_q(pkt->duration,
986  src->streams[pkt->stream_index]->time_base,
987  dst->streams[dst_stream]->time_base);
988 
989  if (interleave) ret = av_interleaved_write_frame(dst, &local_pkt);
990  else ret = av_write_frame(dst, &local_pkt);
991  pkt->buf = local_pkt.buf;
992  pkt->destruct = local_pkt.destruct;
993  return ret;
994 }
995 
996 static int av_write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
997  AVFrame *frame, int interleaved)
998 {
999  AVPacket pkt, *pktp;
1000 
1001  av_assert0(s->oformat);
1002  if (!s->oformat->write_uncoded_frame)
1003  return AVERROR(ENOSYS);
1004 
1005  if (!frame) {
1006  pktp = NULL;
1007  } else {
1008  pktp = &pkt;
1009  av_init_packet(&pkt);
1010  pkt.data = (void *)frame;
1012  pkt.pts =
1013  pkt.dts = frame->pts;
1014  pkt.duration = av_frame_get_pkt_duration(frame);
1015  pkt.stream_index = stream_index;
1017  }
1018 
1019  return interleaved ? av_interleaved_write_frame(s, pktp) :
1020  av_write_frame(s, pktp);
1021 }
1022 
1023 int av_write_uncoded_frame(AVFormatContext *s, int stream_index,
1024  AVFrame *frame)
1025 {
1026  return av_write_uncoded_frame_internal(s, stream_index, frame, 0);
1027 }
1028 
1030  AVFrame *frame)
1031 {
1032  return av_write_uncoded_frame_internal(s, stream_index, frame, 1);
1033 }
1034 
1036 {
1037  av_assert0(s->oformat);
1038  if (!s->oformat->write_uncoded_frame)
1039  return AVERROR(ENOSYS);
1040  return s->oformat->write_uncoded_frame(s, stream_index, NULL,
1042 }