ist->sub2video.frame->width = ist->dec_ctx->width ? ist->dec_ctx->width : ist->sub2video.w;
ist->sub2video.frame->height = ist->dec_ctx->height ? ist->dec_ctx->height : ist->sub2video.h;
ist->sub2video.frame->format = AV_PIX_FMT_RGB32;
- if ((ret = av_frame_get_buffer(frame, 32)) < 0)
+ if ((ret = av_frame_get_buffer(frame, 0)) < 0)
return ret;
memset(frame->data[0], 0, frame->height * frame->linesize[0]);
return 0;
}
}
-void sub2video_update(InputStream *ist, AVSubtitle *sub)
+void sub2video_update(InputStream *ist, int64_t heartbeat_pts, AVSubtitle *sub)
{
AVFrame *frame = ist->sub2video.frame;
int8_t *dst;
AV_TIME_BASE_Q, ist->st->time_base);
num_rects = sub->num_rects;
} else {
- pts = ist->sub2video.end_pts;
+ /* If we are initializing the system, utilize current heartbeat
+ PTS as the start time, and show until the following subpicture
+ is received. Otherwise, utilize the previous subpicture's end time
+ as the fall-back value. */
+ pts = ist->sub2video.initialize ?
+ heartbeat_pts : ist->sub2video.end_pts;
end_pts = INT64_MAX;
num_rects = 0;
}
sub2video_copy_rect(dst, dst_linesize, frame->width, frame->height, sub->rects[i]);
sub2video_push_ref(ist, pts);
ist->sub2video.end_pts = end_pts;
+ ist->sub2video.initialize = 0;
}
static void sub2video_heartbeat(InputStream *ist, int64_t pts)
/* do not send the heartbeat frame if the subtitle is already ahead */
if (pts2 <= ist2->sub2video.last_pts)
continue;
- if (pts2 >= ist2->sub2video.end_pts ||
- (!ist2->sub2video.frame->data[0] && ist2->sub2video.end_pts < INT64_MAX))
- sub2video_update(ist2, NULL);
+ if (pts2 >= ist2->sub2video.end_pts || ist2->sub2video.initialize)
+ /* if we have hit the end of the current displayed subpicture,
+ or if we need to initialize the system, update the
+ overlayed subpicture and its start/end times */
+ sub2video_update(ist2, pts2 + 1, NULL);
for (j = 0, nb_reqs = 0; j < ist2->nb_filters; j++)
nb_reqs += av_buffersrc_get_nb_failed_requests(ist2->filters[j]->filter);
if (nb_reqs)
int ret;
if (ist->sub2video.end_pts < INT64_MAX)
- sub2video_update(ist, NULL);
+ sub2video_update(ist, INT64_MAX, NULL);
for (i = 0; i < ist->nb_filters; i++) {
ret = av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
if (ret != AVERROR_EOF && ret < 0)
static atomic_int transcode_init_done = ATOMIC_VAR_INIT(0);
static volatile int ffmpeg_exited = 0;
static int main_return_code = 0;
+static int64_t copy_ts_first_pts = AV_NOPTS_VALUE;
static void
sigterm_handler(int sig)
FilterGraph *fg = filtergraphs[i];
avfilter_graph_free(&fg->graph);
for (j = 0; j < fg->nb_inputs; j++) {
- while (av_fifo_size(fg->inputs[j]->frame_queue)) {
+ InputFilter *ifilter = fg->inputs[j];
+ struct InputStream *ist = ifilter->ist;
+
+ while (av_fifo_size(ifilter->frame_queue)) {
AVFrame *frame;
- av_fifo_generic_read(fg->inputs[j]->frame_queue, &frame,
+ av_fifo_generic_read(ifilter->frame_queue, &frame,
sizeof(frame), NULL);
av_frame_free(&frame);
}
- av_fifo_freep(&fg->inputs[j]->frame_queue);
- if (fg->inputs[j]->ist->sub2video.sub_queue) {
- while (av_fifo_size(fg->inputs[j]->ist->sub2video.sub_queue)) {
+ av_fifo_freep(&ifilter->frame_queue);
+ if (ist->sub2video.sub_queue) {
+ while (av_fifo_size(ist->sub2video.sub_queue)) {
AVSubtitle sub;
- av_fifo_generic_read(fg->inputs[j]->ist->sub2video.sub_queue,
+ av_fifo_generic_read(ist->sub2video.sub_queue,
&sub, sizeof(sub), NULL);
avsubtitle_free(&sub);
}
- av_fifo_freep(&fg->inputs[j]->ist->sub2video.sub_queue);
+ av_fifo_freep(&ist->sub2video.sub_queue);
}
- av_buffer_unref(&fg->inputs[j]->hw_frames_ctx);
- av_freep(&fg->inputs[j]->name);
+ av_buffer_unref(&ifilter->hw_frames_ctx);
+ av_freep(&ifilter->name);
av_freep(&fg->inputs[j]);
}
av_freep(&fg->inputs);
for (j = 0; j < fg->nb_outputs; j++) {
- av_freep(&fg->outputs[j]->name);
- av_freep(&fg->outputs[j]->formats);
- av_freep(&fg->outputs[j]->channel_layouts);
- av_freep(&fg->outputs[j]->sample_rates);
+ OutputFilter *ofilter = fg->outputs[j];
+
+ avfilter_inout_free(&ofilter->out_tmp);
+ av_freep(&ofilter->name);
+ av_freep(&ofilter->formats);
+ av_freep(&ofilter->channel_layouts);
+ av_freep(&ofilter->sample_rates);
av_freep(&fg->outputs[j]);
}
av_freep(&fg->outputs);
if (!ost)
continue;
- for (j = 0; j < ost->nb_bitstream_filters; j++)
- av_bsf_free(&ost->bsf_ctx[j]);
- av_freep(&ost->bsf_ctx);
+ av_bsf_free(&ost->bsf_ctx);
av_frame_free(&ost->filtered_frame);
av_frame_free(&ost->last_frame);
AVPacket tmp_pkt = {0};
/* the muxer is not initialized yet, buffer the packet */
if (!av_fifo_space(ost->muxing_queue)) {
- int new_size = FFMIN(2 * av_fifo_size(ost->muxing_queue),
- ost->max_muxing_queue_size);
+ unsigned int are_we_over_size =
+ (ost->muxing_queue_data_size + pkt->size) > ost->muxing_queue_data_threshold;
+ int new_size = are_we_over_size ?
+ FFMIN(2 * av_fifo_size(ost->muxing_queue),
+ ost->max_muxing_queue_size) :
+ 2 * av_fifo_size(ost->muxing_queue);
+
if (new_size <= av_fifo_size(ost->muxing_queue)) {
av_log(NULL, AV_LOG_ERROR,
"Too many packets buffered for output stream %d:%d.\n",
if (ret < 0)
exit_program(1);
av_packet_move_ref(&tmp_pkt, pkt);
+ ost->muxing_queue_data_size += tmp_pkt.size;
av_fifo_generic_write(ost->muxing_queue, &tmp_pkt, sizeof(tmp_pkt), NULL);
return;
}
int64_t max = ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
if (pkt->dts < max) {
int loglevel = max - pkt->dts > 2 || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ? AV_LOG_WARNING : AV_LOG_DEBUG;
+ if (exit_on_error)
+ loglevel = AV_LOG_ERROR;
av_log(s, loglevel, "Non-monotonous DTS in output stream "
"%d:%d; previous: %"PRId64", current: %"PRId64"; ",
ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);
{
int ret = 0;
- /* apply the output bitstream filters, if any */
- if (ost->nb_bitstream_filters) {
- int idx;
-
- ret = av_bsf_send_packet(ost->bsf_ctx[0], eof ? NULL : pkt);
+ /* apply the output bitstream filters */
+ if (ost->bsf_ctx) {
+ ret = av_bsf_send_packet(ost->bsf_ctx, eof ? NULL : pkt);
if (ret < 0)
goto finish;
-
- eof = 0;
- idx = 1;
- while (idx) {
- /* get a packet from the previous filter up the chain */
- ret = av_bsf_receive_packet(ost->bsf_ctx[idx - 1], pkt);
- if (ret == AVERROR(EAGAIN)) {
- ret = 0;
- idx--;
- continue;
- } else if (ret == AVERROR_EOF) {
- eof = 1;
- } else if (ret < 0)
- goto finish;
-
- /* send it to the next filter down the chain or to the muxer */
- if (idx < ost->nb_bitstream_filters) {
- ret = av_bsf_send_packet(ost->bsf_ctx[idx], eof ? NULL : pkt);
- if (ret < 0)
- goto finish;
- idx++;
- eof = 0;
- } else if (eof)
- goto finish;
- else
- write_packet(of, pkt, ost, 0);
- }
+ while ((ret = av_bsf_receive_packet(ost->bsf_ctx, pkt)) >= 0)
+ write_packet(of, pkt, ost, 0);
+ if (ret == AVERROR(EAGAIN))
+ ret = 0;
} else if (!eof)
write_packet(of, pkt, ost, 0);
return 1;
}
+static double adjust_frame_pts_to_encoder_tb(OutputFile *of, OutputStream *ost,
+ AVFrame *frame)
+{
+ double float_pts = AV_NOPTS_VALUE; // this is identical to frame.pts but with higher precision
+ AVCodecContext *enc = ost->enc_ctx;
+ if (!frame || frame->pts == AV_NOPTS_VALUE ||
+ !enc || !ost->filter || !ost->filter->graph->graph)
+ goto early_exit;
+
+ {
+ AVFilterContext *filter = ost->filter->filter;
+
+ int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
+ AVRational filter_tb = av_buffersink_get_time_base(filter);
+ AVRational tb = enc->time_base;
+ int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);
+
+ tb.den <<= extra_bits;
+ float_pts =
+ av_rescale_q(frame->pts, filter_tb, tb) -
+ av_rescale_q(start_time, AV_TIME_BASE_Q, tb);
+ float_pts /= 1 << extra_bits;
+ // avoid exact midoints to reduce the chance of rounding differences, this can be removed in case the fps code is changed to work with integers
+ float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);
+
+ frame->pts =
+ av_rescale_q(frame->pts, filter_tb, enc->time_base) -
+ av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
+ }
+
+early_exit:
+
+ if (debug_ts) {
+ av_log(NULL, AV_LOG_INFO, "filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\n",
+ frame ? av_ts2str(frame->pts) : "NULL",
+ frame ? av_ts2timestr(frame->pts, &enc->time_base) : "NULL",
+ float_pts,
+ enc ? enc->time_base.num : -1,
+ enc ? enc->time_base.den : -1);
+ }
+
+ return float_pts;
+}
+
+static int init_output_stream(OutputStream *ost, AVFrame *frame,
+ char *error, int error_len);
+
+static int init_output_stream_wrapper(OutputStream *ost, AVFrame *frame,
+ unsigned int fatal)
+{
+ int ret = AVERROR_BUG;
+ char error[1024] = {0};
+
+ if (ost->initialized)
+ return 0;
+
+ ret = init_output_stream(ost, frame, error, sizeof(error));
+ if (ret < 0) {
+ av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
+ ost->file_index, ost->index, error);
+
+ if (fatal)
+ exit_program(1);
+ }
+
+ return ret;
+}
+
static void do_audio_out(OutputFile *of, OutputStream *ost,
AVFrame *frame)
{
pkt.data = NULL;
pkt.size = 0;
+ adjust_frame_pts_to_encoder_tb(of, ost, frame);
+
if (!check_recording_time(ost))
return;
static void do_video_out(OutputFile *of,
OutputStream *ost,
- AVFrame *next_picture,
- double sync_ipts)
+ AVFrame *next_picture)
{
int ret, format_video_sync;
AVPacket pkt;
AVCodecContext *enc = ost->enc_ctx;
- AVCodecParameters *mux_par = ost->st->codecpar;
AVRational frame_rate;
int nb_frames, nb0_frames, i;
double delta, delta0;
double duration = 0;
+ double sync_ipts = AV_NOPTS_VALUE;
int frame_size = 0;
InputStream *ist = NULL;
AVFilterContext *filter = ost->filter->filter;
+ init_output_stream_wrapper(ost, next_picture, 1);
+ sync_ipts = adjust_frame_pts_to_encoder_tb(of, ost, next_picture);
+
if (ost->source_index >= 0)
ist = input_streams[ost->source_index];
av_log(NULL, AV_LOG_DEBUG, "Not duplicating %d initial frames\n", (int)lrintf(delta0));
delta = duration;
delta0 = 0;
- ost->sync_opts = lrint(sync_ipts);
+ ost->sync_opts = llrint(sync_ipts);
}
case VSYNC_CFR:
// FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
else if (delta > 1.1) {
nb_frames = lrintf(delta);
if (delta0 > 1.1)
- nb0_frames = lrintf(delta0 - 0.6);
+ nb0_frames = llrintf(delta0 - 0.6);
}
break;
case VSYNC_VFR:
if (delta <= -0.6)
nb_frames = 0;
else if (delta > 0.6)
- ost->sync_opts = lrint(sync_ipts);
+ ost->sync_opts = llrint(sync_ipts);
break;
case VSYNC_DROP:
case VSYNC_PASSTHROUGH:
- ost->sync_opts = lrint(sync_ipts);
+ ost->sync_opts = llrint(sync_ipts);
break;
default:
av_assert0(0);
if (!check_recording_time(ost))
return;
- if (enc->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME) &&
- ost->top_field_first >= 0)
- in_picture->top_field_first = !!ost->top_field_first;
-
- if (in_picture->interlaced_frame) {
- if (enc->codec->id == AV_CODEC_ID_MJPEG)
- mux_par->field_order = in_picture->top_field_first ? AV_FIELD_TT:AV_FIELD_BB;
- else
- mux_par->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
- } else
- mux_par->field_order = AV_FIELD_PROGRESSIVE;
-
in_picture->quality = enc->global_quality;
in_picture->pict_type = 0;
}
}
-static int init_output_stream(OutputStream *ost, char *error, int error_len);
-
static void finish_output_stream(OutputStream *ost)
{
OutputFile *of = output_files[ost->file_index];
continue;
filter = ost->filter->filter;
- if (!ost->initialized) {
- char error[1024] = "";
- ret = init_output_stream(ost, error, sizeof(error));
- if (ret < 0) {
- av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
- ost->file_index, ost->index, error);
- exit_program(1);
- }
- }
+ /*
+ * Unlike video, with audio the audio frame size matters.
+ * Currently we are fully reliant on the lavfi filter chain to
+ * do the buffering deed for us, and thus the frame size parameter
+ * needs to be set accordingly. Where does one get the required
+ * frame size? From the initialized AVCodecContext of an audio
+ * encoder. Thus, if we have gotten to an audio stream, initialize
+ * the encoder earlier than receiving the first AVFrame.
+ */
+ if (av_buffersink_get_type(filter) == AVMEDIA_TYPE_AUDIO)
+ init_output_stream_wrapper(ost, NULL, 1);
if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
return AVERROR(ENOMEM);
filtered_frame = ost->filtered_frame;
while (1) {
- double float_pts = AV_NOPTS_VALUE; // this is identical to filtered_frame.pts but with higher precision
ret = av_buffersink_get_frame_flags(filter, filtered_frame,
AV_BUFFERSINK_FLAG_NO_REQUEST);
if (ret < 0) {
"Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
} else if (flush && ret == AVERROR_EOF) {
if (av_buffersink_get_type(filter) == AVMEDIA_TYPE_VIDEO)
- do_video_out(of, ost, NULL, AV_NOPTS_VALUE);
+ do_video_out(of, ost, NULL);
}
break;
}
av_frame_unref(filtered_frame);
continue;
}
- if (filtered_frame->pts != AV_NOPTS_VALUE) {
- int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
- AVRational filter_tb = av_buffersink_get_time_base(filter);
- AVRational tb = enc->time_base;
- int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);
-
- tb.den <<= extra_bits;
- float_pts =
- av_rescale_q(filtered_frame->pts, filter_tb, tb) -
- av_rescale_q(start_time, AV_TIME_BASE_Q, tb);
- float_pts /= 1 << extra_bits;
- // avoid exact midoints to reduce the chance of rounding differences, this can be removed in case the fps code is changed to work with integers
- float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);
-
- filtered_frame->pts =
- av_rescale_q(filtered_frame->pts, filter_tb, enc->time_base) -
- av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
- }
switch (av_buffersink_get_type(filter)) {
case AVMEDIA_TYPE_VIDEO:
if (!ost->frame_aspect_ratio.num)
enc->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
- if (debug_ts) {
- av_log(NULL, AV_LOG_INFO, "filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\n",
- av_ts2str(filtered_frame->pts), av_ts2timestr(filtered_frame->pts, &enc->time_base),
- float_pts,
- enc->time_base.num, enc->time_base.den);
- }
-
- do_video_out(of, ost, filtered_frame, float_pts);
+ do_video_out(of, ost, filtered_frame);
break;
case AVMEDIA_TYPE_AUDIO:
if (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
vid = 1;
}
/* compute min output value */
- if (av_stream_get_end_pts(ost->st) != AV_NOPTS_VALUE)
+ if (av_stream_get_end_pts(ost->st) != AV_NOPTS_VALUE) {
pts = FFMAX(pts, av_rescale_q(av_stream_get_end_pts(ost->st),
ost->st->time_base, AV_TIME_BASE_Q));
+ if (copy_ts) {
+ if (copy_ts_first_pts == AV_NOPTS_VALUE && pts > 1)
+ copy_ts_first_pts = pts;
+ if (copy_ts_first_pts != AV_NOPTS_VALUE)
+ pts -= copy_ts_first_pts;
+ }
+ }
+
if (is_last_report)
nb_frames_drop += ost->last_dropped;
}
// Maybe we should just let encoding fail instead.
if (!ost->initialized) {
FilterGraph *fg = ost->filter->graph;
- char error[1024] = "";
av_log(NULL, AV_LOG_WARNING,
"Finishing stream %d:%d without any data written to it.\n",
finish_output_stream(ost);
}
- ret = init_output_stream(ost, error, sizeof(error));
- if (ret < 0) {
- av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
- ost->file_index, ost->index, error);
- exit_program(1);
- }
+ init_output_stream_wrapper(ost, NULL, 1);
}
- if (enc->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
- continue;
-
if (enc->codec_type != AVMEDIA_TYPE_VIDEO && enc->codec_type != AVMEDIA_TYPE_AUDIO)
continue;
av_log(ist->dec_ctx, AV_LOG_WARNING,
"video_delay is larger in decoder than demuxer %d > %d.\n"
"If you want to help, upload a sample "
- "of this file to ftp://upload.ffmpeg.org/incoming/ "
+ "of this file to https://streams.videolan.org/upload/ "
"and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)\n",
ist->dec_ctx->has_b_frames,
ist->st->codecpar->video_delay);
return ret;
if (ist->sub2video.frame) {
- sub2video_update(ist, &subtitle);
+ sub2video_update(ist, INT64_MIN, &subtitle);
} else if (ist->nb_filters) {
if (!ist->sub2video.sub_queue)
ist->sub2video.sub_queue = av_fifo_alloc(8 * sizeof(AVSubtitle));
ist->dec_ctx->opaque = ist;
ist->dec_ctx->get_format = get_format;
ist->dec_ctx->get_buffer2 = get_buffer;
+#if LIBAVCODEC_VERSION_MAJOR < 60
ist->dec_ctx->thread_safe_callbacks = 1;
+#endif
av_opt_set_int(ist->dec_ctx, "refcounted_frames", 1, 0);
if (ist->dec_ctx->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
while (av_fifo_size(ost->muxing_queue)) {
AVPacket pkt;
av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
+ ost->muxing_queue_data_size -= pkt.size;
write_packet(of, &pkt, ost, 1);
}
}
static int init_output_bsfs(OutputStream *ost)
{
- AVBSFContext *ctx;
- int i, ret;
+ AVBSFContext *ctx = ost->bsf_ctx;
+ int ret;
- if (!ost->nb_bitstream_filters)
+ if (!ctx)
return 0;
- for (i = 0; i < ost->nb_bitstream_filters; i++) {
- ctx = ost->bsf_ctx[i];
-
- ret = avcodec_parameters_copy(ctx->par_in,
- i ? ost->bsf_ctx[i - 1]->par_out : ost->st->codecpar);
- if (ret < 0)
- return ret;
+ ret = avcodec_parameters_copy(ctx->par_in, ost->st->codecpar);
+ if (ret < 0)
+ return ret;
- ctx->time_base_in = i ? ost->bsf_ctx[i - 1]->time_base_out : ost->st->time_base;
+ ctx->time_base_in = ost->st->time_base;
- ret = av_bsf_init(ctx);
- if (ret < 0) {
- av_log(NULL, AV_LOG_ERROR, "Error initializing bitstream filter: %s\n",
- ost->bsf_ctx[i]->filter->name);
- return ret;
- }
+ ret = av_bsf_init(ctx);
+ if (ret < 0) {
+ av_log(NULL, AV_LOG_ERROR, "Error initializing bitstream filter: %s\n",
+ ctx->filter->name);
+ return ret;
}
- ctx = ost->bsf_ctx[ost->nb_bitstream_filters - 1];
ret = avcodec_parameters_copy(ost->st->codecpar, ctx->par_out);
if (ret < 0)
return ret;
-
ost->st->time_base = ctx->time_base_out;
return 0;
enc_ctx->time_base = default_time_base;
}
-static int init_output_stream_encode(OutputStream *ost)
+static int init_output_stream_encode(OutputStream *ost, AVFrame *frame)
{
InputStream *ist = get_input_stream(ost);
AVCodecContext *enc_ctx = ost->enc_ctx;
enc_ctx->bits_per_raw_sample = FFMIN(dec_ctx->bits_per_raw_sample,
av_pix_fmt_desc_get(enc_ctx->pix_fmt)->comp[0].depth);
+ if (frame) {
+ enc_ctx->color_range = frame->color_range;
+ enc_ctx->color_primaries = frame->color_primaries;
+ enc_ctx->color_trc = frame->color_trc;
+ enc_ctx->colorspace = frame->colorspace;
+ enc_ctx->chroma_sample_location = frame->chroma_location;
+ }
+
enc_ctx->framerate = ost->frame_rate;
ost->st->avg_frame_rate = ost->frame_rate;
enc_ctx->field_order = AV_FIELD_TT;
}
+ if (frame) {
+ if (enc_ctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME) &&
+ ost->top_field_first >= 0)
+ frame->top_field_first = !!ost->top_field_first;
+
+ if (frame->interlaced_frame) {
+ if (enc_ctx->codec->id == AV_CODEC_ID_MJPEG)
+ enc_ctx->field_order = frame->top_field_first ? AV_FIELD_TT:AV_FIELD_BB;
+ else
+ enc_ctx->field_order = frame->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
+ } else
+ enc_ctx->field_order = AV_FIELD_PROGRESSIVE;
+ }
+
if (ost->forced_keyframes) {
if (!strncmp(ost->forced_keyframes, "expr:", 5)) {
ret = av_expr_parse(&ost->forced_keyframes_pexpr, ost->forced_keyframes+5,
return 0;
}
-static int init_output_stream(OutputStream *ost, char *error, int error_len)
+static int init_output_stream(OutputStream *ost, AVFrame *frame,
+ char *error, int error_len)
{
int ret = 0;
AVCodecContext *dec = NULL;
InputStream *ist;
- ret = init_output_stream_encode(ost);
+ ret = init_output_stream_encode(ost, frame);
if (ret < 0)
return ret;
!av_dict_get(ost->encoder_opts, "ab", NULL, 0))
av_dict_set(&ost->encoder_opts, "b", "128000", 0);
- if (ost->filter && av_buffersink_get_hw_frames_ctx(ost->filter->filter) &&
- ((AVHWFramesContext*)av_buffersink_get_hw_frames_ctx(ost->filter->filter)->data)->format ==
- av_buffersink_get_format(ost->filter->filter)) {
- ost->enc_ctx->hw_frames_ctx = av_buffer_ref(av_buffersink_get_hw_frames_ctx(ost->filter->filter));
- if (!ost->enc_ctx->hw_frames_ctx)
- return AVERROR(ENOMEM);
- } else {
- ret = hw_device_setup_for_encode(ost);
- if (ret < 0) {
- snprintf(error, error_len, "Device setup failed for "
- "encoder on output stream #%d:%d : %s",
+ ret = hw_device_setup_for_encode(ost);
+ if (ret < 0) {
+ snprintf(error, error_len, "Device setup failed for "
+ "encoder on output stream #%d:%d : %s",
ost->file_index, ost->index, av_err2str(ret));
- return ret;
- }
+ return ret;
}
+
if (ist && ist->dec->type == AVMEDIA_TYPE_SUBTITLE && ost->enc->type == AVMEDIA_TYPE_SUBTITLE) {
int input_props = 0, output_props = 0;
AVCodecDescriptor const *input_descriptor =
goto dump_format;
}
- /* open each encoder */
+ /*
+ * initialize stream copy and subtitle/data streams.
+ * Encoded AVFrame based streams will get initialized as follows:
+ * - when the first AVFrame is received in do_video_out
+ * - just before the first AVFrame is received in either transcode_step
+ * or reap_filters due to us requiring the filter chain buffer sink
+ * to be configured with the correct audio frame size, which is only
+ * known after the encoder is initialized.
+ */
for (i = 0; i < nb_output_streams; i++) {
- // skip streams fed from filtergraphs until we have a frame for them
- if (output_streams[i]->filter)
+ if (!output_streams[i]->stream_copy &&
+ (output_streams[i]->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
+ output_streams[i]->enc_ctx->codec_type == AVMEDIA_TYPE_AUDIO))
continue;
- ret = init_output_stream(output_streams[i], error, sizeof(error));
+ ret = init_output_stream_wrapper(output_streams[i], NULL, 0);
if (ret < 0)
goto dump_format;
}
int ret;
InputFile *f = input_files[i];
- if (nb_input_files == 1)
+ if (f->thread_queue_size < 0)
+ f->thread_queue_size = (nb_input_files > 1 ? 8 : 0);
+ if (!f->thread_queue_size)
return 0;
if (f->ctx->pb ? !f->ctx->pb->seekable :
}
#if HAVE_THREADS
- if (nb_input_files > 1)
+ if (f->thread_queue_size)
return get_input_packet_mt(f, pkt);
#endif
return av_read_frame(f->ctx, pkt);
ifile->time_base = ist->st->time_base;
/* the total duration of the stream, max_pts - min_pts is
* the duration of the stream without the last frame */
- duration += ist->max_pts - ist->min_pts;
+ if (ist->max_pts > ist->min_pts && ist->max_pts - (uint64_t)ist->min_pts < INT64_MAX - duration)
+ duration += ist->max_pts - ist->min_pts;
ifile->time_base = duration_max(duration, &ifile->duration, ist->st->time_base,
ifile->time_base);
}
int ret, thread_ret, i, j;
int64_t duration;
int64_t pkt_dts;
+ int disable_discontinuity_correction = copy_ts;
is = ifile->ctx;
ret = get_input_packet(ifile, &pkt);
pkt.dts += duration;
pkt_dts = av_rescale_q_rnd(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
+
+ if (copy_ts && pkt_dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE &&
+ (is->iformat->flags & AVFMT_TS_DISCONT) && ist->st->pts_wrap_bits < 60) {
+ int64_t wrap_dts = av_rescale_q_rnd(pkt.dts + (1LL<<ist->st->pts_wrap_bits),
+ ist->st->time_base, AV_TIME_BASE_Q,
+ AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
+ if (FFABS(wrap_dts - ist->next_dts) < FFABS(pkt_dts - ist->next_dts)/10)
+ disable_discontinuity_correction = 0;
+ }
+
if ((ist->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
ist->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) &&
pkt_dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE &&
- !copy_ts) {
+ !disable_discontinuity_correction) {
int64_t delta = pkt_dts - ist->next_dts;
if (is->iformat->flags & AVFMT_TS_DISCONT) {
if (delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
}
if (ost->filter && ost->filter->graph->graph) {
- if (!ost->initialized) {
- char error[1024] = {0};
- ret = init_output_stream(ost, error, sizeof(error));
- if (ret < 0) {
- av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
- ost->file_index, ost->index, error);
- exit_program(1);
- }
- }
+ /*
+ * Similar case to the early audio initialization in reap_filters.
+ * Audio is special in ffmpeg.c currently as we depend on lavfi's
+ * audio frame buffering/creation to get the output audio frame size
+ * in samples correct. The audio frame size for the filter chain is
+ * configured during the output stream initialization.
+ *
+ * Apparently avfilter_graph_request_oldest (called in
+ * transcode_from_filter just down the line) peeks. Peeking already
+ * puts one frame "ready to be given out", which means that any
+ * update in filter buffer sink configuration afterwards will not
+ * help us. And yes, even if it would be utilized,
+ * av_buffersink_get_samples is affected, as it internally utilizes
+ * the same early exit for peeked frames.
+ *
+ * In other words, if avfilter_graph_request_oldest would not make
+ * further filter chain configuration or usage of
+ * av_buffersink_get_samples useless (by just causing the return
+ * of the peeked AVFrame as-is), we could get rid of this additional
+ * early encoder initialization.
+ */
+ if (av_buffersink_get_type(ost->filter->filter) == AVMEDIA_TYPE_AUDIO)
+ init_output_stream_wrapper(ost, NULL, 1);
+
if ((ret = transcode_from_filter(ost->filter->graph, &ist)) < 0)
return ret;
if (!ist)
av_freep(&ost->enc_ctx->stats_in);
}
total_packets_written += ost->packets_written;
+ if (!ost->packets_written && (abort_on_flags & ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM)) {
+ av_log(NULL, AV_LOG_FATAL, "Empty output on stream %d.\n", i);
+ exit_program(1);
+ }
}
if (!total_packets_written && (abort_on_flags & ABORT_ON_FLAG_EMPTY_OUTPUT)) {
}
}
- av_buffer_unref(&hw_device_ctx);
hw_device_free_all();
/* finished ! */
projects / ffmpeg / blobdiff