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.num != 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  if (s->flush_packets && s->pb && s->pb->error >= 0 && s->flags & AVFMT_FLAG_FLUSH_PACKETS)
425  avio_flush(s->pb);
426  }
427 
428  if ((ret = init_pts(s)) < 0)
429  return ret;
430 
431  if (s->avoid_negative_ts < 0) {
433  s->avoid_negative_ts = 0;
434  } else
435  s->avoid_negative_ts = 1;
436  }
437 
438  return 0;
439 }
440 
441 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
442 
443 /* Note: using sizeof(AVFrame) from outside lavu is unsafe in general, but
444  it is only being used internally to this file as a consistency check.
445  The value is chosen to be very unlikely to appear on its own and to cause
446  immediate failure if used anywhere as a real size. */
447 #define UNCODED_FRAME_PACKET_SIZE (INT_MIN / 3 * 2 + (int)sizeof(AVFrame))
448 
449 
450 //FIXME merge with compute_pkt_fields
452 {
453  int delay = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames > 0);
454  int num, den, i;
455  int frame_size;
456 
457  av_dlog(s, "compute_pkt_fields2: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
458  av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), delay, pkt->size, pkt->stream_index);
459 
460  if (pkt->duration < 0 && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) {
461  av_log(s, AV_LOG_WARNING, "Packet with invalid duration %d in stream %d\n",
462  pkt->duration, pkt->stream_index);
463  pkt->duration = 0;
464  }
465 
466  /* duration field */
467  if (pkt->duration == 0) {
468  ff_compute_frame_duration(&num, &den, st, NULL, pkt);
469  if (den && num) {
470  pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
471  }
472  }
473 
474  if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
475  pkt->pts = pkt->dts;
476 
477  //XXX/FIXME this is a temporary hack until all encoders output pts
478  if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
479  static int warned;
480  if (!warned) {
481  av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
482  warned = 1;
483  }
484  pkt->dts =
485 // pkt->pts= st->cur_dts;
486  pkt->pts = st->pts.val;
487  }
488 
489  //calculate dts from pts
490  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
491  st->pts_buffer[0] = pkt->pts;
492  for (i = 1; i < delay + 1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
493  st->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
494  for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
495  FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
496 
497  pkt->dts = st->pts_buffer[0];
498  }
499 
500  if (st->cur_dts && st->cur_dts != AV_NOPTS_VALUE &&
501  ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
502  st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
503  av_log(s, AV_LOG_ERROR,
504  "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
505  st->index, av_ts2str(st->cur_dts), av_ts2str(pkt->dts));
506  return AVERROR(EINVAL);
507  }
508  if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
509  av_log(s, AV_LOG_ERROR, "pts (%s) < dts (%s) in stream %d\n",
510  av_ts2str(pkt->pts), av_ts2str(pkt->dts), st->index);
511  return AVERROR(EINVAL);
512  }
513 
514  av_dlog(s, "av_write_frame: pts2:%s dts2:%s\n",
515  av_ts2str(pkt->pts), av_ts2str(pkt->dts));
516  st->cur_dts = pkt->dts;
517  st->pts.val = pkt->dts;
518 
519  /* update pts */
520  switch (st->codec->codec_type) {
521  case AVMEDIA_TYPE_AUDIO:
522  frame_size = (pkt->flags & AV_PKT_FLAG_UNCODED_FRAME) ?
523  ((AVFrame *)pkt->data)->nb_samples :
525 
526  /* HACK/FIXME, we skip the initial 0 size packets as they are most
527  * likely equal to the encoder delay, but it would be better if we
528  * had the real timestamps from the encoder */
529  if (frame_size >= 0 && (pkt->size || st->pts.num != st->pts.den >> 1 || st->pts.val)) {
530  frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
531  }
532  break;
533  case AVMEDIA_TYPE_VIDEO:
534  frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
535  break;
536  }
537  return 0;
538 }
539 
540 /**
541  * Make timestamps non negative, move side data from payload to internal struct, call muxer, and restore
542  * sidedata.
543  *
544  * FIXME: this function should NEVER get undefined pts/dts beside when the
545  * AVFMT_NOTIMESTAMPS is set.
546  * Those additional safety checks should be dropped once the correct checks
547  * are set in the callers.
548  */
550 {
551  int ret, did_split;
552 
553  if (s->output_ts_offset) {
554  AVStream *st = s->streams[pkt->stream_index];
556 
557  if (pkt->dts != AV_NOPTS_VALUE)
558  pkt->dts += offset;
559  if (pkt->pts != AV_NOPTS_VALUE)
560  pkt->pts += offset;
561  }
562 
563  if (s->avoid_negative_ts > 0) {
564  AVStream *st = s->streams[pkt->stream_index];
565  int64_t offset = st->mux_ts_offset;
566 
567  if ((pkt->dts < 0 || s->avoid_negative_ts == 2) && pkt->dts != AV_NOPTS_VALUE && !s->offset) {
568  s->offset = -pkt->dts;
569  s->offset_timebase = st->time_base;
570  }
571 
572  if (s->offset && !offset) {
573  offset = st->mux_ts_offset =
575  s->offset_timebase,
576  st->time_base,
577  AV_ROUND_UP);
578  }
579 
580  if (pkt->dts != AV_NOPTS_VALUE)
581  pkt->dts += offset;
582  if (pkt->pts != AV_NOPTS_VALUE)
583  pkt->pts += offset;
584 
585  av_assert2(pkt->dts == AV_NOPTS_VALUE || pkt->dts >= 0);
586  }
587 
588  did_split = av_packet_split_side_data(pkt);
589  if ((pkt->flags & AV_PKT_FLAG_UNCODED_FRAME)) {
590  AVFrame *frame = (AVFrame *)pkt->data;
592  ret = s->oformat->write_uncoded_frame(s, pkt->stream_index, &frame, 0);
593  av_frame_free(&frame);
594  } else {
595  ret = s->oformat->write_packet(s, pkt);
596  }
597 
598  if (s->flush_packets && s->pb && ret >= 0 && s->flags & AVFMT_FLAG_FLUSH_PACKETS)
599  avio_flush(s->pb);
600 
601  if (did_split)
603 
604  return ret;
605 }
606 
608 {
609  if (!pkt)
610  return 0;
611 
612  if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
613  av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
614  pkt->stream_index);
615  return AVERROR(EINVAL);
616  }
617 
619  av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
620  return AVERROR(EINVAL);
621  }
622 
623  return 0;
624 }
625 
627 {
628  int ret;
629 
630  ret = check_packet(s, pkt);
631  if (ret < 0)
632  return ret;
633 
634  if (!pkt) {
635  if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
636  ret = s->oformat->write_packet(s, NULL);
637  if (s->flush_packets && s->pb && s->pb->error >= 0 && s->flags & AVFMT_FLAG_FLUSH_PACKETS)
638  avio_flush(s->pb);
639  if (ret >= 0 && s->pb && s->pb->error < 0)
640  ret = s->pb->error;
641  return ret;
642  }
643  return 1;
644  }
645 
646  ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
647 
648  if (ret < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
649  return ret;
650 
651  ret = write_packet(s, pkt);
652  if (ret >= 0 && s->pb && s->pb->error < 0)
653  ret = s->pb->error;
654 
655  if (ret >= 0)
656  s->streams[pkt->stream_index]->nb_frames++;
657  return ret;
658 }
659 
660 #define CHUNK_START 0x1000
661 
663  int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
664 {
665  int ret;
666  AVPacketList **next_point, *this_pktl;
667  AVStream *st = s->streams[pkt->stream_index];
668  int chunked = s->max_chunk_size || s->max_chunk_duration;
669 
670  this_pktl = av_mallocz(sizeof(AVPacketList));
671  if (!this_pktl)
672  return AVERROR(ENOMEM);
673  this_pktl->pkt = *pkt;
674 #if FF_API_DESTRUCT_PACKET
676  pkt->destruct = NULL; // do not free original but only the copy
678 #endif
679  pkt->buf = NULL;
680  pkt->side_data = NULL;
681  pkt->side_data_elems = 0;
682  if ((pkt->flags & AV_PKT_FLAG_UNCODED_FRAME)) {
684  av_assert0(((AVFrame *)pkt->data)->buf);
685  } else {
686  // Duplicate the packet if it uses non-allocated memory
687  if ((ret = av_dup_packet(&this_pktl->pkt)) < 0) {
688  av_free(this_pktl);
689  return ret;
690  }
691  }
692 
694  next_point = &(st->last_in_packet_buffer->next);
695  } else {
696  next_point = &s->packet_buffer;
697  }
698 
699  if (chunked) {
701  st->interleaver_chunk_size += pkt->size;
704  || (max && st->interleaver_chunk_duration > max)) {
705  st->interleaver_chunk_size = 0;
706  this_pktl->pkt.flags |= CHUNK_START;
707  if (max && st->interleaver_chunk_duration > max) {
708  int64_t syncoffset = (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
709  int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
710 
711  st->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
712  } else
714  }
715  }
716  if (*next_point) {
717  if (chunked && !(this_pktl->pkt.flags & CHUNK_START))
718  goto next_non_null;
719 
720  if (compare(s, &s->packet_buffer_end->pkt, pkt)) {
721  while ( *next_point
722  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
723  || !compare(s, &(*next_point)->pkt, pkt)))
724  next_point = &(*next_point)->next;
725  if (*next_point)
726  goto next_non_null;
727  } else {
728  next_point = &(s->packet_buffer_end->next);
729  }
730  }
731  av_assert1(!*next_point);
732 
733  s->packet_buffer_end = this_pktl;
734 next_non_null:
735 
736  this_pktl->next = *next_point;
737 
739  *next_point = this_pktl;
740 
741  return 0;
742 }
743 
745  AVPacket *pkt)
746 {
747  AVStream *st = s->streams[pkt->stream_index];
748  AVStream *st2 = s->streams[next->stream_index];
749  int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
750  st->time_base);
752  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);
753  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);
754  if (ts == ts2) {
755  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
756  -( 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;
757  ts2=0;
758  }
759  comp= (ts>ts2) - (ts<ts2);
760  }
761 
762  if (comp == 0)
763  return pkt->stream_index < next->stream_index;
764  return comp > 0;
765 }
766 
768  AVPacket *pkt, int flush)
769 {
770  AVPacketList *pktl;
771  int stream_count = 0;
772  int noninterleaved_count = 0;
773  int i, ret;
774 
775  if (pkt) {
776  if ((ret = ff_interleave_add_packet(s, pkt, interleave_compare_dts)) < 0)
777  return ret;
778  }
779 
780  for (i = 0; i < s->nb_streams; i++) {
781  if (s->streams[i]->last_in_packet_buffer) {
782  ++stream_count;
783  } else if (s->streams[i]->codec->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
784  s->streams[i]->codec->codec_id != AV_CODEC_ID_VP8 &&
785  s->streams[i]->codec->codec_id != AV_CODEC_ID_VP9) {
786  ++noninterleaved_count;
787  }
788  }
789 
790  if (s->internal->nb_interleaved_streams == stream_count)
791  flush = 1;
792 
793  if (s->max_interleave_delta > 0 &&
794  s->packet_buffer &&
795  !flush &&
796  s->internal->nb_interleaved_streams == stream_count+noninterleaved_count
797  ) {
798  AVPacket *top_pkt = &s->packet_buffer->pkt;
799  int64_t delta_dts = INT64_MIN;
800  int64_t top_dts = av_rescale_q(top_pkt->dts,
801  s->streams[top_pkt->stream_index]->time_base,
803 
804  for (i = 0; i < s->nb_streams; i++) {
805  int64_t last_dts;
806  const AVPacketList *last = s->streams[i]->last_in_packet_buffer;
807 
808  if (!last)
809  continue;
810 
811  last_dts = av_rescale_q(last->pkt.dts,
812  s->streams[i]->time_base,
814  delta_dts = FFMAX(delta_dts, last_dts - top_dts);
815  }
816 
817  if (delta_dts > s->max_interleave_delta) {
818  av_log(s, AV_LOG_DEBUG,
819  "Delay between the first packet and last packet in the "
820  "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
821  delta_dts, s->max_interleave_delta);
822  flush = 1;
823  }
824  }
825 
826  if (stream_count && flush) {
827  AVStream *st;
828  pktl = s->packet_buffer;
829  *out = pktl->pkt;
830  st = s->streams[out->stream_index];
831 
832  s->packet_buffer = pktl->next;
833  if (!s->packet_buffer)
834  s->packet_buffer_end = NULL;
835 
836  if (st->last_in_packet_buffer == pktl)
837  st->last_in_packet_buffer = NULL;
838  av_freep(&pktl);
839 
840  return 1;
841  } else {
842  av_init_packet(out);
843  return 0;
844  }
845 }
846 
847 /**
848  * Interleave an AVPacket correctly so it can be muxed.
849  * @param out the interleaved packet will be output here
850  * @param in the input packet
851  * @param flush 1 if no further packets are available as input and all
852  * remaining packets should be output
853  * @return 1 if a packet was output, 0 if no packet could be output,
854  * < 0 if an error occurred
855  */
857 {
858  if (s->oformat->interleave_packet) {
859  int ret = s->oformat->interleave_packet(s, out, in, flush);
860  if (in)
861  av_free_packet(in);
862  return ret;
863  } else
864  return ff_interleave_packet_per_dts(s, out, in, flush);
865 }
866 
868 {
869  int ret, flush = 0;
870 
871  ret = check_packet(s, pkt);
872  if (ret < 0)
873  goto fail;
874 
875  if (pkt) {
876  AVStream *st = s->streams[pkt->stream_index];
877 
878  av_dlog(s, "av_interleaved_write_frame size:%d dts:%s pts:%s\n",
879  pkt->size, av_ts2str(pkt->dts), av_ts2str(pkt->pts));
880  if ((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
881  goto fail;
882 
883  if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
884  ret = AVERROR(EINVAL);
885  goto fail;
886  }
887  } else {
888  av_dlog(s, "av_interleaved_write_frame FLUSH\n");
889  flush = 1;
890  }
891 
892  for (;; ) {
893  AVPacket opkt;
894  int ret = interleave_packet(s, &opkt, pkt, flush);
895  if (pkt) {
896  memset(pkt, 0, sizeof(*pkt));
897  av_init_packet(pkt);
898  pkt = NULL;
899  }
900  if (ret <= 0) //FIXME cleanup needed for ret<0 ?
901  return ret;
902 
903  ret = write_packet(s, &opkt);
904  if (ret >= 0)
905  s->streams[opkt.stream_index]->nb_frames++;
906 
907  av_free_packet(&opkt);
908 
909  if (ret < 0)
910  return ret;
911  if(s->pb && s->pb->error)
912  return s->pb->error;
913  }
914 fail:
915  av_packet_unref(pkt);
916  return ret;
917 }
918 
920 {
921  int ret, i;
922 
923  for (;; ) {
924  AVPacket pkt;
925  ret = interleave_packet(s, &pkt, NULL, 1);
926  if (ret < 0) //FIXME cleanup needed for ret<0 ?
927  goto fail;
928  if (!ret)
929  break;
930 
931  ret = write_packet(s, &pkt);
932  if (ret >= 0)
933  s->streams[pkt.stream_index]->nb_frames++;
934 
935  av_free_packet(&pkt);
936 
937  if (ret < 0)
938  goto fail;
939  if(s->pb && s->pb->error)
940  goto fail;
941  }
942 
943  if (s->oformat->write_trailer)
944  ret = s->oformat->write_trailer(s);
945 
946 fail:
947  if (s->pb)
948  avio_flush(s->pb);
949  if (ret == 0)
950  ret = s->pb ? s->pb->error : 0;
951  for (i = 0; i < s->nb_streams; i++) {
952  av_freep(&s->streams[i]->priv_data);
953  av_freep(&s->streams[i]->index_entries);
954  }
955  if (s->oformat->priv_class)
957  av_freep(&s->priv_data);
958  return ret;
959 }
960 
961 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
962  int64_t *dts, int64_t *wall)
963 {
964  if (!s->oformat || !s->oformat->get_output_timestamp)
965  return AVERROR(ENOSYS);
966  s->oformat->get_output_timestamp(s, stream, dts, wall);
967  return 0;
968 }
969 
970 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
972 {
973  AVPacket local_pkt;
974  int ret;
975 
976  local_pkt = *pkt;
977  local_pkt.stream_index = dst_stream;
978  if (pkt->pts != AV_NOPTS_VALUE)
979  local_pkt.pts = av_rescale_q(pkt->pts,
980  src->streams[pkt->stream_index]->time_base,
981  dst->streams[dst_stream]->time_base);
982  if (pkt->dts != AV_NOPTS_VALUE)
983  local_pkt.dts = av_rescale_q(pkt->dts,
984  src->streams[pkt->stream_index]->time_base,
985  dst->streams[dst_stream]->time_base);
986  if (pkt->duration)
987  local_pkt.duration = av_rescale_q(pkt->duration,
988  src->streams[pkt->stream_index]->time_base,
989  dst->streams[dst_stream]->time_base);
990 
991  if (interleave) ret = av_interleaved_write_frame(dst, &local_pkt);
992  else ret = av_write_frame(dst, &local_pkt);
993  pkt->buf = local_pkt.buf;
994  pkt->destruct = local_pkt.destruct;
995  return ret;
996 }
997 
998 static int av_write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
999  AVFrame *frame, int interleaved)
1000 {
1001  AVPacket pkt, *pktp;
1002 
1003  av_assert0(s->oformat);
1004  if (!s->oformat->write_uncoded_frame)
1005  return AVERROR(ENOSYS);
1006 
1007  if (!frame) {
1008  pktp = NULL;
1009  } else {
1010  pktp = &pkt;
1011  av_init_packet(&pkt);
1012  pkt.data = (void *)frame;
1014  pkt.pts =
1015  pkt.dts = frame->pts;
1016  pkt.duration = av_frame_get_pkt_duration(frame);
1017  pkt.stream_index = stream_index;
1019  }
1020 
1021  return interleaved ? av_interleaved_write_frame(s, pktp) :
1022  av_write_frame(s, pktp);
1023 }
1024 
1025 int av_write_uncoded_frame(AVFormatContext *s, int stream_index,
1026  AVFrame *frame)
1027 {
1028  return av_write_uncoded_frame_internal(s, stream_index, frame, 0);
1029 }
1030 
1032  AVFrame *frame)
1033 {
1034  return av_write_uncoded_frame_internal(s, stream_index, frame, 1);
1035 }
1036 
1038 {
1039  av_assert0(s->oformat);
1040  if (!s->oformat->write_uncoded_frame)
1041  return AVERROR(ENOSYS);
1042  return s->oformat->write_uncoded_frame(s, stream_index, NULL,
1044 }