2 * muxing functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
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.
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.
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
23 #include "avio_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"
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"
40 #include "audiointerleave.h"
52 * muxing functions for use within libavformat
55 /* fraction handling */
58 * f = val + (num / den) + 0.5.
60 * 'num' is normalized so that it is such as 0 <= num < den.
62 * @param f fractional number
63 * @param val integer value
64 * @param num must be >= 0
65 * @param den must be >= 1
67 static void frac_init(AVFrac
*f
, int64_t val
, int64_t num
, int64_t den
)
80 * Fractional addition to f: f = f + (incr / f->den).
82 * @param f fractional number
83 * @param incr increment, can be positive or negative
85 static void frac_add(AVFrac
*f
, int64_t incr
)
98 } else if (num
>= den
) {
105 AVRational
ff_choose_timebase(AVFormatContext
*s
, AVStream
*st
, int min_precision
)
112 for (j
=2; j
<14; j
+= 1+(j
>2))
113 while (q
.den
/ q
.num
< min_precision
&& q
.num
% j
== 0)
115 while (q
.den
/ q
.num
< min_precision
&& q
.den
< (1<<24))
121 int avformat_alloc_output_context2(AVFormatContext
**avctx
, AVOutputFormat
*oformat
,
122 const char *format
, const char *filename
)
124 AVFormatContext
*s
= avformat_alloc_context();
133 oformat
= av_guess_format(format
, NULL
, NULL
);
135 av_log(s
, AV_LOG_ERROR
, "Requested output format '%s' is not a suitable output format\n", format
);
136 ret
= AVERROR(EINVAL
);
140 oformat
= av_guess_format(NULL
, filename
, NULL
);
142 ret
= AVERROR(EINVAL
);
143 av_log(s
, AV_LOG_ERROR
, "Unable to find a suitable output format for '%s'\n",
150 s
->oformat
= oformat
;
151 if (s
->oformat
->priv_data_size
> 0) {
152 s
->priv_data
= av_mallocz(s
->oformat
->priv_data_size
);
155 if (s
->oformat
->priv_class
) {
156 *(const AVClass
**)s
->priv_data
= s
->oformat
->priv_class
;
157 av_opt_set_defaults(s
->priv_data
);
163 av_strlcpy(s
->filename
, filename
, sizeof(s
->filename
));
167 av_log(s
, AV_LOG_ERROR
, "Out of memory\n");
168 ret
= AVERROR(ENOMEM
);
170 avformat_free_context(s
);
174 static int validate_codec_tag(AVFormatContext
*s
, AVStream
*st
)
176 const AVCodecTag
*avctag
;
178 enum AVCodecID id
= AV_CODEC_ID_NONE
;
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
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
)) {
192 if (id
== st
->codec
->codec_id
)
195 if (avctag
->id
== st
->codec
->codec_id
)
200 if (id
!= AV_CODEC_ID_NONE
)
202 if (tag
>= 0 && (s
->strict_std_compliance
>= FF_COMPLIANCE_NORMAL
))
208 static int init_muxer(AVFormatContext
*s
, AVDictionary
**options
)
212 AVDictionary
*tmp
= NULL
;
213 AVCodecContext
*codec
= NULL
;
214 AVOutputFormat
*of
= s
->oformat
;
215 AVDictionaryEntry
*e
;
218 av_dict_copy(&tmp
, *options
, 0);
220 if ((ret
= av_opt_set_dict(s
, &tmp
)) < 0)
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)
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
;
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
);
238 for (i
= 0; i
< s
->nb_streams
; i
++) {
242 #if FF_API_LAVF_CODEC_TB
243 FF_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
);
250 FF_ENABLE_DEPRECATION_WARNINGS
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
);
258 avpriv_set_pts_info(st
, 33, 1, 90000);
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
);
268 if (!codec
->block_align
)
269 codec
->block_align
= codec
->channels
*
270 av_get_bits_per_sample(codec
->codec_id
) >> 3;
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
);
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
)
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
);
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;
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
;
320 codec
->codec_tag
= av_codec_get_tag(of
->codec_tag
, codec
->codec_id
);
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
);
329 if (codec
->codec_type
!= AVMEDIA_TYPE_ATTACHMENT
)
330 s
->internal
->nb_interleaved_streams
++;
333 if (!s
->priv_data
&& of
->priv_data_size
> 0) {
334 s
->priv_data
= av_mallocz(of
->priv_data_size
);
336 ret
= AVERROR(ENOMEM
);
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)
347 /* set muxer identification string */
348 if (!(s
->flags
& AVFMT_FLAG_BITEXACT
)) {
349 av_dict_set(&s
->metadata
, "encoder", LIBAVFORMAT_IDENT
, 0);
351 av_dict_set(&s
->metadata
, "encoder", NULL
, 0);
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);
359 av_dict_free(options
);
370 static int init_pts(AVFormatContext
*s
)
375 /* init PTS generation */
376 for (i
= 0; i
< s
->nb_streams
; i
++) {
377 int64_t den
= AV_NOPTS_VALUE
;
380 switch (st
->codec
->codec_type
) {
381 case AVMEDIA_TYPE_AUDIO
:
382 den
= (int64_t)st
->time_base
.num
* st
->codec
->sample_rate
;
384 case AVMEDIA_TYPE_VIDEO
:
385 den
= (int64_t)st
->time_base
.num
* st
->codec
->time_base
.den
;
390 if (den
!= AV_NOPTS_VALUE
) {
392 return AVERROR_INVALIDDATA
;
394 frac_init(&st
->pts
, 0, 0, den
);
401 int avformat_write_header(AVFormatContext
*s
, AVDictionary
**options
)
405 if (ret
= init_muxer(s
, options
))
408 if (s
->oformat
->write_header
) {
409 ret
= s
->oformat
->write_header(s
);
410 if (ret
>= 0 && s
->pb
&& s
->pb
->error
< 0)
414 if (s
->flush_packets
&& s
->pb
&& s
->pb
->error
>= 0 && s
->flags
& AVFMT_FLAG_FLUSH_PACKETS
)
418 if ((ret
= init_pts(s
)) < 0)
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;
426 s
->avoid_negative_ts
= AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE
;
432 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
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))
441 //FIXME merge with compute_pkt_fields
442 static int compute_pkt_fields2(AVFormatContext
*s
, AVStream
*st
, AVPacket
*pkt
)
444 int delay
= FFMAX(st
->codec
->has_b_frames
, st
->codec
->max_b_frames
> 0);
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
);
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
);
458 if (pkt
->duration
== 0) {
459 ff_compute_frame_duration(s
, &num
, &den
, st
, NULL
, pkt
);
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
);
465 if (pkt
->pts
== AV_NOPTS_VALUE
&& pkt
->dts
!= AV_NOPTS_VALUE
&& delay
== 0)
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
) {
472 av_log(s
, AV_LOG_WARNING
, "Encoder did not produce proper pts, making some up.\n");
476 // pkt->pts= st->cur_dts;
477 pkt
->pts
= st
->pts
.val
;
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]);
488 pkt
->dts
= st
->pts_buffer
[0];
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
);
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
),
504 return AVERROR(EINVAL
);
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
;
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
);
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
);
526 case AVMEDIA_TYPE_VIDEO
:
527 frac_add(&st
->pts
, (int64_t)st
->time_base
.den
* st
->codec
->time_base
.num
);
534 * Make timestamps non negative, move side data from payload to internal struct, call muxer, and restore
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.
542 static int write_packet(AVFormatContext
*s
, AVPacket
*pkt
)
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
);
550 if (pkt
->dts
!= AV_NOPTS_VALUE
)
552 if (pkt
->pts
!= AV_NOPTS_VALUE
)
556 if (s
->avoid_negative_ts
> 0) {
557 AVStream
*st
= s
->streams
[pkt
->stream_index
];
558 int64_t offset
= st
->mux_ts_offset
;
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
;
566 if (s
->offset
!= AV_NOPTS_VALUE
&& !offset
) {
567 offset
= st
->mux_ts_offset
=
568 av_rescale_q_rnd(s
->offset
,
574 if (pkt
->dts
!= AV_NOPTS_VALUE
)
576 if (pkt
->pts
!= AV_NOPTS_VALUE
)
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",
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
);
598 ret
= s
->oformat
->write_packet(s
, pkt
);
601 if (s
->flush_packets
&& s
->pb
&& ret
>= 0 && s
->flags
& AVFMT_FLAG_FLUSH_PACKETS
)
605 av_packet_merge_side_data(pkt
);
610 static int check_packet(AVFormatContext
*s
, AVPacket
*pkt
)
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",
618 return AVERROR(EINVAL
);
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
);
629 int av_write_frame(AVFormatContext
*s
, AVPacket
*pkt
)
633 ret
= check_packet(s
, 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
)
642 if (ret
>= 0 && s
->pb
&& s
->pb
->error
< 0)
649 ret
= compute_pkt_fields2(s
, s
->streams
[pkt
->stream_index
], pkt
);
651 if (ret
< 0 && !(s
->oformat
->flags
& AVFMT_NOTIMESTAMPS
))
654 ret
= write_packet(s
, pkt
);
655 if (ret
>= 0 && s
->pb
&& s
->pb
->error
< 0)
659 s
->streams
[pkt
->stream_index
]->nb_frames
++;
663 #define CHUNK_START 0x1000
665 int ff_interleave_add_packet(AVFormatContext
*s
, AVPacket
*pkt
,
666 int (*compare
)(AVFormatContext
*, AVPacket
*, AVPacket
*))
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
;
673 this_pktl
= av_mallocz(sizeof(AVPacketList
));
675 return AVERROR(ENOMEM
);
676 this_pktl
->pkt
= *pkt
;
677 #if FF_API_DESTRUCT_PACKET
678 FF_DISABLE_DEPRECATION_WARNINGS
679 pkt
->destruct
= NULL
; // do not free original but only the copy
680 FF_ENABLE_DEPRECATION_WARNINGS
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
);
689 // Duplicate the packet if it uses non-allocated memory
690 if ((ret
= av_dup_packet(&this_pktl
->pkt
)) < 0) {
696 if (s
->streams
[pkt
->stream_index
]->last_in_packet_buffer
) {
697 next_point
= &(st
->last_in_packet_buffer
->next
);
699 next_point
= &s
->packet_buffer
;
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
;
714 st
->interleaver_chunk_duration
+= (pkt
->dts
- syncto
)/8 - max
;
716 st
->interleaver_chunk_duration
= 0;
720 if (chunked
&& !(this_pktl
->pkt
.flags
& CHUNK_START
))
723 if (compare(s
, &s
->packet_buffer_end
->pkt
, pkt
)) {
725 && ((chunked
&& !((*next_point
)->pkt
.flags
&CHUNK_START
))
726 || !compare(s
, &(*next_point
)->pkt
, pkt
)))
727 next_point
= &(*next_point
)->next
;
731 next_point
= &(s
->packet_buffer_end
->next
);
734 av_assert1(!*next_point
);
736 s
->packet_buffer_end
= this_pktl
;
739 this_pktl
->next
= *next_point
;
741 s
->streams
[pkt
->stream_index
]->last_in_packet_buffer
=
742 *next_point
= this_pktl
;
747 static int interleave_compare_dts(AVFormatContext
*s
, AVPacket
*next
,
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
,
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
);
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
;
762 comp
= (ts
>ts2
) - (ts
<ts2
);
766 return pkt
->stream_index
< next
->stream_index
;
770 int ff_interleave_packet_per_dts(AVFormatContext
*s
, AVPacket
*out
,
771 AVPacket
*pkt
, int flush
)
774 int stream_count
= 0;
775 int noninterleaved_count
= 0;
779 if ((ret
= ff_interleave_add_packet(s
, pkt
, interleave_compare_dts
)) < 0)
783 for (i
= 0; i
< s
->nb_streams
; i
++) {
784 if (s
->streams
[i
]->last_in_packet_buffer
) {
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
;
793 if (s
->internal
->nb_interleaved_streams
== stream_count
)
796 if (s
->max_interleave_delta
> 0 &&
799 s
->internal
->nb_interleaved_streams
== stream_count
+noninterleaved_count
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
,
807 for (i
= 0; i
< s
->nb_streams
; i
++) {
809 const AVPacketList
*last
= s
->streams
[i
]->last_in_packet_buffer
;
814 last_dts
= av_rescale_q(last
->pkt
.dts
,
815 s
->streams
[i
]->time_base
,
817 delta_dts
= FFMAX(delta_dts
, last_dts
- top_dts
);
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
);
829 if (stream_count
&& flush
) {
831 pktl
= s
->packet_buffer
;
833 st
= s
->streams
[out
->stream_index
];
835 s
->packet_buffer
= pktl
->next
;
836 if (!s
->packet_buffer
)
837 s
->packet_buffer_end
= NULL
;
839 if (st
->last_in_packet_buffer
== pktl
)
840 st
->last_in_packet_buffer
= NULL
;
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
859 static int interleave_packet(AVFormatContext
*s
, AVPacket
*out
, AVPacket
*in
, int flush
)
861 if (s
->oformat
->interleave_packet
) {
862 int ret
= s
->oformat
->interleave_packet(s
, out
, in
, flush
);
867 return ff_interleave_packet_per_dts(s
, out
, in
, flush
);
870 int av_interleaved_write_frame(AVFormatContext
*s
, AVPacket
*pkt
)
874 ret
= check_packet(s
, pkt
);
879 AVStream
*st
= s
->streams
[pkt
->stream_index
];
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
))
886 if (pkt
->dts
== AV_NOPTS_VALUE
&& !(s
->oformat
->flags
& AVFMT_NOTIMESTAMPS
)) {
887 ret
= AVERROR(EINVAL
);
891 av_dlog(s
, "av_interleaved_write_frame FLUSH\n");
897 int ret
= interleave_packet(s
, &opkt
, pkt
, flush
);
899 memset(pkt
, 0, sizeof(*pkt
));
903 if (ret
<= 0) //FIXME cleanup needed for ret<0 ?
906 ret
= write_packet(s
, &opkt
);
908 s
->streams
[opkt
.stream_index
]->nb_frames
++;
910 av_free_packet(&opkt
);
914 if(s
->pb
&& s
->pb
->error
)
918 av_packet_unref(pkt
);
922 int av_write_trailer(AVFormatContext
*s
)
928 ret
= interleave_packet(s
, &pkt
, NULL
, 1);
934 ret
= write_packet(s
, &pkt
);
936 s
->streams
[pkt
.stream_index
]->nb_frames
++;
938 av_free_packet(&pkt
);
942 if(s
->pb
&& s
->pb
->error
)
947 if (s
->oformat
->write_trailer
)
949 ret
= s
->oformat
->write_trailer(s
);
951 s
->oformat
->write_trailer(s
);
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
);
962 if (s
->oformat
->priv_class
)
963 av_opt_free(s
->priv_data
);
964 av_freep(&s
->priv_data
);
968 int av_get_output_timestamp(struct AVFormatContext
*s
, int stream
,
969 int64_t *dts
, int64_t *wall
)
971 if (!s
->oformat
|| !s
->oformat
->get_output_timestamp
)
972 return AVERROR(ENOSYS
);
973 s
->oformat
->get_output_timestamp(s
, stream
, dts
, wall
);
977 int ff_write_chained(AVFormatContext
*dst
, int dst_stream
, AVPacket
*pkt
,
978 AVFormatContext
*src
, int interleave
)
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
);
994 local_pkt
.duration
= av_rescale_q(pkt
->duration
,
995 src
->streams
[pkt
->stream_index
]->time_base
,
996 dst
->streams
[dst_stream
]->time_base
);
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
;
1005 static int av_write_uncoded_frame_internal(AVFormatContext
*s
, int stream_index
,
1006 AVFrame
*frame
, int interleaved
)
1008 AVPacket pkt
, *pktp
;
1010 av_assert0(s
->oformat
);
1011 if (!s
->oformat
->write_uncoded_frame
)
1012 return AVERROR(ENOSYS
);
1018 av_init_packet(&pkt
);
1019 pkt
.data
= (void *)frame
;
1020 pkt
.size
= UNCODED_FRAME_PACKET_SIZE
;
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
;
1028 return interleaved
? av_interleaved_write_frame(s
, pktp
) :
1029 av_write_frame(s
, pktp
);
1032 int av_write_uncoded_frame(AVFormatContext
*s
, int stream_index
,
1035 return av_write_uncoded_frame_internal(s
, stream_index
, frame
, 0);
1038 int av_interleaved_write_uncoded_frame(AVFormatContext
*s
, int stream_index
,
1041 return av_write_uncoded_frame_internal(s
, stream_index
, frame
, 1);
1044 int av_write_uncoded_frame_query(AVFormatContext
*s
, int stream_index
)
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
);