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