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