X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavformat%2Fmux.c;h=76662ee0338e742dcdde2e0c8882b98c256bd5bb;hb=70c77fdfc1076fd7f6cd20079237ddc97e1a10bc;hp=76b0fb4dc6c02a77d82b44b728e3b27d7227d593;hpb=32e5194969e026d790e72e0b3f8f254979ea0f36;p=ffmpeg diff --git a/libavformat/mux.c b/libavformat/mux.c index 76b0fb4dc6c..76662ee0338 100644 --- a/libavformat/mux.c +++ b/libavformat/mux.c @@ -19,8 +19,6 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -/* #define DEBUG */ - #include "avformat.h" #include "avio_internal.h" #include "internal.h" @@ -33,6 +31,7 @@ #include "id3v2.h" #include "libavutil/avassert.h" #include "libavutil/avstring.h" +#include "libavutil/internal.h" #include "libavutil/mathematics.h" #include "libavutil/parseutils.h" #include "libavutil/time.h" @@ -52,56 +51,6 @@ * muxing functions for use within Libav */ -/* fraction handling */ - -/** - * f = val + (num / den) + 0.5. - * - * 'num' is normalized so that it is such as 0 <= num < den. - * - * @param f fractional number - * @param val integer value - * @param num must be >= 0 - * @param den must be >= 1 - */ -static void frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den) -{ - num += (den >> 1); - if (num >= den) { - val += num / den; - num = num % den; - } - f->val = val; - f->num = num; - f->den = den; -} - -/** - * Fractional addition to f: f = f + (incr / f->den). - * - * @param f fractional number - * @param incr increment, can be positive or negative - */ -static void frac_add(AVFrac *f, int64_t incr) -{ - int64_t num, den; - - num = f->num + incr; - den = f->den; - if (num < 0) { - f->val += num / den; - num = num % den; - if (num < 0) { - num += den; - f->val--; - } - } else if (num >= den) { - f->val += num / den; - num = num % den; - } - f->num = num; -} - static int validate_codec_tag(AVFormatContext *s, AVStream *st) { const AVCodecTag *avctag; @@ -118,19 +67,19 @@ static int validate_codec_tag(AVFormatContext *s, AVStream *st) for (n = 0; s->oformat->codec_tag[n]; n++) { avctag = s->oformat->codec_tag[n]; while (avctag->id != AV_CODEC_ID_NONE) { - if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) { + if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codecpar->codec_tag)) { id = avctag->id; - if (id == st->codec->codec_id) + if (id == st->codecpar->codec_id) return 1; } - if (avctag->id == st->codec->codec_id) + if (avctag->id == st->codecpar->codec_id) tag = avctag->tag; avctag++; } } if (id != AV_CODEC_ID_NONE) return 0; - if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL)) + if (tag && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL)) return 0; return 1; } @@ -141,8 +90,9 @@ static int init_muxer(AVFormatContext *s, AVDictionary **options) int ret = 0, i; AVStream *st; AVDictionary *tmp = NULL; - AVCodecContext *codec = NULL; + AVCodecParameters *par = NULL; AVOutputFormat *of = s->oformat; + const AVCodecDescriptor *desc; if (options) av_dict_copy(&tmp, *options, 0); @@ -150,6 +100,13 @@ static int init_muxer(AVFormatContext *s, AVDictionary **options) if ((ret = av_opt_set_dict(s, &tmp)) < 0) goto fail; +#if FF_API_LAVF_BITEXACT +FF_DISABLE_DEPRECATION_WARNINGS + if (s->nb_streams && s->streams[0]->codec->flags & AV_CODEC_FLAG_BITEXACT) + s->flags |= AVFMT_FLAG_BITEXACT; +FF_ENABLE_DEPRECATION_WARNINGS +#endif + // some sanity checks if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) { av_log(s, AV_LOG_ERROR, "no streams\n"); @@ -158,29 +115,55 @@ static int init_muxer(AVFormatContext *s, AVDictionary **options) } for (i = 0; i < s->nb_streams; i++) { - st = s->streams[i]; - codec = st->codec; + st = s->streams[i]; + par = st->codecpar; + +#if FF_API_LAVF_CODEC_TB +FF_DISABLE_DEPRECATION_WARNINGS + if (!st->time_base.num && st->codec->time_base.num) { + av_log(s, AV_LOG_WARNING, "Using AVStream.codec.time_base as a " + "timebase hint to the muxer is deprecated. Set " + "AVStream.time_base instead.\n"); + avpriv_set_pts_info(st, 64, st->codec->time_base.num, st->codec->time_base.den); + } +FF_ENABLE_DEPRECATION_WARNINGS +#endif + +#if FF_API_LAVF_AVCTX +FF_DISABLE_DEPRECATION_WARNINGS + if (st->codecpar->codec_type == AVMEDIA_TYPE_UNKNOWN && + st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN) { + av_log(s, AV_LOG_WARNING, "Using AVStream.codec to pass codec " + "parameters to muxers is deprecated, use AVStream.codecpar " + "instead.\n"); + ret = avcodec_parameters_from_context(st->codecpar, st->codec); + if (ret < 0) + goto fail; + } +FF_ENABLE_DEPRECATION_WARNINGS +#endif - switch (codec->codec_type) { + if (!st->time_base.num) { + /* fall back on the default timebase values */ + if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate) + avpriv_set_pts_info(st, 64, 1, par->sample_rate); + else + avpriv_set_pts_info(st, 33, 1, 90000); + } + + switch (par->codec_type) { case AVMEDIA_TYPE_AUDIO: - if (codec->sample_rate <= 0) { + if (par->sample_rate <= 0) { av_log(s, AV_LOG_ERROR, "sample rate not set\n"); ret = AVERROR(EINVAL); goto fail; } - if (!codec->block_align) - codec->block_align = codec->channels * - av_get_bits_per_sample(codec->codec_id) >> 3; + if (!par->block_align) + par->block_align = par->channels * + av_get_bits_per_sample(par->codec_id) >> 3; break; case AVMEDIA_TYPE_VIDEO: - if (codec->time_base.num <= 0 || - codec->time_base.den <= 0) { //FIXME audio too? - av_log(s, AV_LOG_ERROR, "time base not set\n"); - ret = AVERROR(EINVAL); - goto fail; - } - - if ((codec->width <= 0 || codec->height <= 0) && + if ((par->width <= 0 || par->height <= 0) && !(of->flags & AVFMT_NODIMENSIONS)) { av_log(s, AV_LOG_ERROR, "dimensions not set\n"); ret = AVERROR(EINVAL); @@ -188,46 +171,52 @@ static int init_muxer(AVFormatContext *s, AVDictionary **options) } if (av_cmp_q(st->sample_aspect_ratio, - codec->sample_aspect_ratio)) { - av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer " - "(%d/%d) and encoder layer (%d/%d)\n", - st->sample_aspect_ratio.num, st->sample_aspect_ratio.den, - codec->sample_aspect_ratio.num, - codec->sample_aspect_ratio.den); - ret = AVERROR(EINVAL); - goto fail; + par->sample_aspect_ratio)) { + if (st->sample_aspect_ratio.num != 0 && + st->sample_aspect_ratio.den != 0 && + par->sample_aspect_ratio.den != 0 && + par->sample_aspect_ratio.den != 0) { + av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer " + "(%d/%d) and encoder layer (%d/%d)\n", + st->sample_aspect_ratio.num, st->sample_aspect_ratio.den, + par->sample_aspect_ratio.num, + par->sample_aspect_ratio.den); + ret = AVERROR(EINVAL); + goto fail; + } } break; } + desc = avcodec_descriptor_get(par->codec_id); + if (desc && desc->props & AV_CODEC_PROP_REORDER) + st->internal->reorder = 1; + if (of->codec_tag) { - if (codec->codec_tag && - codec->codec_id == AV_CODEC_ID_RAWVIDEO && - !av_codec_get_tag(of->codec_tag, codec->codec_id) && + if (par->codec_tag && + par->codec_id == AV_CODEC_ID_RAWVIDEO && + !av_codec_get_tag(of->codec_tag, par->codec_id) && !validate_codec_tag(s, st)) { // the current rawvideo encoding system ends up setting // the wrong codec_tag for avi, we override it here - codec->codec_tag = 0; + par->codec_tag = 0; } - if (codec->codec_tag) { + if (par->codec_tag) { if (!validate_codec_tag(s, st)) { char tagbuf[32]; - av_get_codec_tag_string(tagbuf, sizeof(tagbuf), codec->codec_tag); + av_get_codec_tag_string(tagbuf, sizeof(tagbuf), par->codec_tag); av_log(s, AV_LOG_ERROR, "Tag %s/0x%08x incompatible with output codec id '%d'\n", - tagbuf, codec->codec_tag, codec->codec_id); + tagbuf, par->codec_tag, par->codec_id); ret = AVERROR_INVALIDDATA; goto fail; } } else - codec->codec_tag = av_codec_get_tag(of->codec_tag, codec->codec_id); + par->codec_tag = av_codec_get_tag(of->codec_tag, par->codec_id); } - if (of->flags & AVFMT_GLOBALHEADER && - !(codec->flags & CODEC_FLAG_GLOBAL_HEADER)) - av_log(s, AV_LOG_WARNING, - "Codec for stream %d does not use global headers " - "but container format requires global headers\n", i); + if (par->codec_type != AVMEDIA_TYPE_ATTACHMENT) + s->internal->nb_interleaved_streams++; } if (!s->priv_data && of->priv_data_size > 0) { @@ -245,7 +234,7 @@ static int init_muxer(AVFormatContext *s, AVDictionary **options) } /* set muxer identification string */ - if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) { + if (!(s->flags & AVFMT_FLAG_BITEXACT)) { av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0); } @@ -261,37 +250,6 @@ fail: return ret; } -static int init_pts(AVFormatContext *s) -{ - int i; - AVStream *st; - - /* init PTS generation */ - for (i = 0; i < s->nb_streams; i++) { - int64_t den = AV_NOPTS_VALUE; - st = s->streams[i]; - - switch (st->codec->codec_type) { - case AVMEDIA_TYPE_AUDIO: - den = (int64_t)st->time_base.num * st->codec->sample_rate; - break; - case AVMEDIA_TYPE_VIDEO: - den = (int64_t)st->time_base.num * st->codec->time_base.den; - break; - default: - break; - } - if (den != AV_NOPTS_VALUE) { - if (den <= 0) - return AVERROR_INVALIDDATA; - - frac_init(&st->pts, 0, 0, den); - } - } - - return 0; -} - int avformat_write_header(AVFormatContext *s, AVDictionary **options) { int ret = 0; @@ -305,19 +263,35 @@ int avformat_write_header(AVFormatContext *s, AVDictionary **options) return ret; } - if ((ret = init_pts(s)) < 0) - return ret; + if (s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO) { + if (s->oformat->flags & (AVFMT_TS_NEGATIVE | AVFMT_NOTIMESTAMPS)) { + s->avoid_negative_ts = 0; + } else + s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE; + } return 0; } +#if FF_API_COMPUTE_PKT_FIELDS2 +FF_DISABLE_DEPRECATION_WARNINGS //FIXME merge with compute_pkt_fields static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt) { int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames); - int num, den, frame_size, i; + int num, den, i; + + if (!s->internal->missing_ts_warning && + !(s->oformat->flags & AVFMT_NOTIMESTAMPS) && + (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) { + av_log(s, AV_LOG_WARNING, + "Timestamps are unset in a packet for stream %d. " + "This is deprecated and will stop working in the future. " + "Fix your code to set the timestamps properly\n", st->index); + s->internal->missing_ts_warning = 1; + } - av_dlog(s, "compute_pkt_fields2: pts:%" PRId64 " dts:%" PRId64 " cur_dts:%" PRId64 " b:%d size:%d st:%d\n", + av_log(s, AV_LOG_TRACE, "compute_pkt_fields2: pts:%" PRId64 " dts:%" PRId64 " cur_dts:%" PRId64 " b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index); /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE) @@ -325,7 +299,7 @@ static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt) /* duration field */ if (pkt->duration == 0) { - ff_compute_frame_duration(&num, &den, st, NULL, pkt); + ff_compute_frame_duration(s, &num, &den, st, NULL, pkt); if (den && num) { pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num); } @@ -334,13 +308,6 @@ static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt) if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0) pkt->pts = pkt->dts; - //XXX/FIXME this is a temporary hack until all encoders output pts - if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) { - pkt->dts = -// pkt->pts= st->cur_dts; - pkt->pts = st->pts.val; - } - //calculate dts from pts if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) { st->pts_buffer[0] = pkt->pts; @@ -361,33 +328,137 @@ static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt) return AVERROR(EINVAL); } if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) { - av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index); + av_log(s, AV_LOG_ERROR, + "pts %" PRId64 " < dts %" PRId64 " in stream %d\n", + pkt->pts, pkt->dts, + st->index); return AVERROR(EINVAL); } - av_dlog(s, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", + av_log(s, AV_LOG_TRACE, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts); st->cur_dts = pkt->dts; - st->pts.val = pkt->dts; - - /* update pts */ - switch (st->codec->codec_type) { - case AVMEDIA_TYPE_AUDIO: - frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 1); - - /* HACK/FIXME, we skip the initial 0 size packets as they are most - * likely equal to the encoder delay, but it would be better if we - * had the real timestamps from the encoder */ - if (frame_size >= 0 && (pkt->size || st->pts.num != st->pts.den >> 1 || st->pts.val)) { - frac_add(&st->pts, (int64_t)st->time_base.den * frame_size); + + return 0; +} +FF_ENABLE_DEPRECATION_WARNINGS +#endif + +/* + * FIXME: this function should NEVER get undefined pts/dts beside when the + * AVFMT_NOTIMESTAMPS is set. + * Those additional safety checks should be dropped once the correct checks + * are set in the callers. + */ + +static int write_packet(AVFormatContext *s, AVPacket *pkt) +{ + int ret; + if (s->avoid_negative_ts > 0) { + AVRational time_base = s->streams[pkt->stream_index]->time_base; + int64_t offset = 0; + + if (s->internal->offset == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && + (pkt->dts < 0 || s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO)) { + s->internal->offset = -pkt->dts; + s->internal->offset_timebase = time_base; + } + if (s->internal->offset != AV_NOPTS_VALUE) + offset = av_rescale_q(s->internal->offset, s->internal->offset_timebase, time_base); + + if (pkt->dts != AV_NOPTS_VALUE) + pkt->dts += offset; + if (pkt->pts != AV_NOPTS_VALUE) + pkt->pts += offset; + + if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < 0) { + av_log(s, AV_LOG_WARNING, + "Packets poorly interleaved, failed to avoid negative " + "timestamp %"PRId64" in stream %d.\n" + "Try -max_interleave_delta 0 as a possible workaround.\n", + pkt->dts, pkt->stream_index); + } + } + ret = s->oformat->write_packet(s, pkt); + + if (s->pb && ret >= 0) { + if (s->flags & AVFMT_FLAG_FLUSH_PACKETS) + avio_flush(s->pb); + if (s->pb->error < 0) + ret = s->pb->error; + } + + return ret; +} + +static int check_packet(AVFormatContext *s, AVPacket *pkt) +{ + if (!pkt) + return 0; + + if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) { + av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n", + pkt->stream_index); + return AVERROR(EINVAL); + } + + if (s->streams[pkt->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_ATTACHMENT) { + av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n"); + return AVERROR(EINVAL); + } + + return 0; +} + +static int prepare_input_packet(AVFormatContext *s, AVPacket *pkt) +{ + int ret; + + ret = check_packet(s, pkt); + if (ret < 0) + return ret; + +#if !FF_API_COMPUTE_PKT_FIELDS2 + /* sanitize the timestamps */ + if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) { + AVStream *st = s->streams[pkt->stream_index]; + + /* when there is no reordering (so dts is equal to pts), but + * only one of them is set, set the other as well */ + if (!st->internal->reorder) { + if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE) + pkt->pts = pkt->dts; + if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE) + pkt->dts = pkt->pts; + } + + /* check that the timestamps are set */ + if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) { + av_log(s, AV_LOG_ERROR, + "Timestamps are unset in a packet for stream %d\n", st->index); + return AVERROR(EINVAL); + } + + /* check that the dts are increasing (or at least non-decreasing, + * if the format allows it */ + if (st->cur_dts != AV_NOPTS_VALUE && + ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && st->cur_dts >= pkt->dts) || + st->cur_dts > pkt->dts)) { + av_log(s, AV_LOG_ERROR, + "Application provided invalid, non monotonically increasing " + "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n", + st->index, st->cur_dts, pkt->dts); + return AVERROR(EINVAL); + } + + if (pkt->pts < pkt->dts) { + av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n", + pkt->pts, pkt->dts, st->index); + return AVERROR(EINVAL); } - break; - case AVMEDIA_TYPE_VIDEO: - frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num); - break; - default: - break; } +#endif + return 0; } @@ -395,63 +466,76 @@ int av_write_frame(AVFormatContext *s, AVPacket *pkt) { int ret; + ret = prepare_input_packet(s, pkt); + if (ret < 0) + return ret; + if (!pkt) { if (s->oformat->flags & AVFMT_ALLOW_FLUSH) return s->oformat->write_packet(s, pkt); return 1; } +#if FF_API_COMPUTE_PKT_FIELDS2 ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt); if (ret < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS)) return ret; +#endif - ret = s->oformat->write_packet(s, pkt); + ret = write_packet(s, pkt); if (ret >= 0) s->streams[pkt->stream_index]->nb_frames++; return ret; } -void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt, - int (*compare)(AVFormatContext *, AVPacket *, AVPacket *)) +int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt, + int (*compare)(AVFormatContext *, AVPacket *, AVPacket *)) { + int ret; AVPacketList **next_point, *this_pktl; this_pktl = av_mallocz(sizeof(AVPacketList)); - this_pktl->pkt = *pkt; -#if FF_API_DESTRUCT_PACKET - pkt->destruct = NULL; // do not free original but only the copy -#endif - pkt->buf = NULL; - av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory + if (!this_pktl) + return AVERROR(ENOMEM); + + if ((ret = av_packet_ref(&this_pktl->pkt, pkt)) < 0) { + av_free(this_pktl); + return ret; + } if (s->streams[pkt->stream_index]->last_in_packet_buffer) { next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next); } else - next_point = &s->packet_buffer; + next_point = &s->internal->packet_buffer; if (*next_point) { - if (compare(s, &s->packet_buffer_end->pkt, pkt)) { + if (compare(s, &s->internal->packet_buffer_end->pkt, pkt)) { while (!compare(s, &(*next_point)->pkt, pkt)) next_point = &(*next_point)->next; goto next_non_null; } else { - next_point = &(s->packet_buffer_end->next); + next_point = &(s->internal->packet_buffer_end->next); } } assert(!*next_point); - s->packet_buffer_end = this_pktl; + s->internal->packet_buffer_end = this_pktl; next_non_null: this_pktl->next = *next_point; s->streams[pkt->stream_index]->last_in_packet_buffer = *next_point = this_pktl; + + av_packet_unref(pkt); + + return 0; } -static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt) +static int interleave_compare_dts(AVFormatContext *s, AVPacket *next, + AVPacket *pkt) { AVStream *st = s->streams[pkt->stream_index]; AVStream *st2 = s->streams[next->stream_index]; @@ -468,22 +552,54 @@ int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, { AVPacketList *pktl; int stream_count = 0; - int i; + int i, ret; if (pkt) { - ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts); + if ((ret = ff_interleave_add_packet(s, pkt, interleave_compare_dts)) < 0) + return ret; } - for (i = 0; i < s->nb_streams; i++) - stream_count += !!s->streams[i]->last_in_packet_buffer; + if (s->max_interleave_delta > 0 && s->internal->packet_buffer && !flush) { + AVPacket *top_pkt = &s->internal->packet_buffer->pkt; + int64_t delta_dts = INT64_MIN; + int64_t top_dts = av_rescale_q(top_pkt->dts, + s->streams[top_pkt->stream_index]->time_base, + AV_TIME_BASE_Q); + + for (i = 0; i < s->nb_streams; i++) { + int64_t last_dts; + const AVPacketList *last = s->streams[i]->last_in_packet_buffer; + + if (!last) + continue; + + last_dts = av_rescale_q(last->pkt.dts, + s->streams[i]->time_base, + AV_TIME_BASE_Q); + delta_dts = FFMAX(delta_dts, last_dts - top_dts); + stream_count++; + } - if (stream_count && (s->nb_streams == stream_count || flush)) { - pktl = s->packet_buffer; + if (delta_dts > s->max_interleave_delta) { + av_log(s, AV_LOG_DEBUG, + "Delay between the first packet and last packet in the " + "muxing queue is %"PRId64" > %"PRId64": forcing output\n", + delta_dts, s->max_interleave_delta); + flush = 1; + } + } else { + for (i = 0; i < s->nb_streams; i++) + stream_count += !!s->streams[i]->last_in_packet_buffer; + } + + + if (stream_count && (s->internal->nb_interleaved_streams == stream_count || flush)) { + pktl = s->internal->packet_buffer; *out = pktl->pkt; - s->packet_buffer = pktl->next; - if (!s->packet_buffer) - s->packet_buffer_end = NULL; + s->internal->packet_buffer = pktl->next; + if (!s->internal->packet_buffer) + s->internal->packet_buffer_end = NULL; if (s->streams[out->stream_index]->last_in_packet_buffer == pktl) s->streams[out->stream_index]->last_in_packet_buffer = NULL; @@ -509,7 +625,7 @@ static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, in if (s->oformat->interleave_packet) { int ret = s->oformat->interleave_packet(s, out, in, flush); if (in) - av_free_packet(in); + av_packet_unref(in); return ret; } else return ff_interleave_packet_per_dts(s, out, in, flush); @@ -519,41 +635,52 @@ int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt) { int ret, flush = 0; + ret = prepare_input_packet(s, pkt); + if (ret < 0) + goto fail; + if (pkt) { AVStream *st = s->streams[pkt->stream_index]; - //FIXME/XXX/HACK drop zero sized packets - if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size == 0) - return 0; - - av_dlog(s, "av_interleaved_write_frame size:%d dts:%" PRId64 " pts:%" PRId64 "\n", + av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame size:%d dts:%" PRId64 " pts:%" PRId64 "\n", pkt->size, pkt->dts, pkt->pts); +#if FF_API_COMPUTE_PKT_FIELDS2 if ((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS)) - return ret; + goto fail; +#endif - if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS)) - return AVERROR(EINVAL); + if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS)) { + ret = AVERROR(EINVAL); + goto fail; + } } else { - av_dlog(s, "av_interleaved_write_frame FLUSH\n"); + av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n"); flush = 1; } for (;; ) { AVPacket opkt; int ret = interleave_packet(s, &opkt, pkt, flush); + if (pkt) { + memset(pkt, 0, sizeof(*pkt)); + av_init_packet(pkt); + pkt = NULL; + } if (ret <= 0) //FIXME cleanup needed for ret<0 ? return ret; - ret = s->oformat->write_packet(s, &opkt); + ret = write_packet(s, &opkt); if (ret >= 0) s->streams[opkt.stream_index]->nb_frames++; - av_free_packet(&opkt); - pkt = NULL; + av_packet_unref(&opkt); if (ret < 0) return ret; } +fail: + av_packet_unref(pkt); + return ret; } int av_write_trailer(AVFormatContext *s) @@ -568,11 +695,11 @@ int av_write_trailer(AVFormatContext *s) if (!ret) break; - ret = s->oformat->write_packet(s, &pkt); + ret = write_packet(s, &pkt); if (ret >= 0) s->streams[pkt.stream_index]->nb_frames++; - av_free_packet(&pkt); + av_packet_unref(&pkt); if (ret < 0) goto fail; @@ -581,7 +708,7 @@ int av_write_trailer(AVFormatContext *s) if (s->oformat->write_trailer) ret = s->oformat->write_trailer(s); - if (!(s->oformat->flags & AVFMT_NOFILE)) + if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb) avio_flush(s->pb); fail: @@ -594,3 +721,21 @@ fail: av_freep(&s->priv_data); return ret; } + +int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt, + AVFormatContext *src) +{ + AVPacket local_pkt; + + local_pkt = *pkt; + local_pkt.stream_index = dst_stream; + if (pkt->pts != AV_NOPTS_VALUE) + local_pkt.pts = av_rescale_q(pkt->pts, + src->streams[pkt->stream_index]->time_base, + dst->streams[dst_stream]->time_base); + if (pkt->dts != AV_NOPTS_VALUE) + local_pkt.dts = av_rescale_q(pkt->dts, + src->streams[pkt->stream_index]->time_base, + dst->streams[dst_stream]->time_base); + return av_write_frame(dst, &local_pkt); +}