int64_t pos; // byte position in file
SDL_Overlay *bmp;
int width, height; /* source height & width */
- AVRational sample_aspect_ratio;
int allocated;
int reallocate;
int serial;
-#if CONFIG_AVFILTER
- AVFilterBufferRef *picref;
-#endif
+ AVRational sar;
} VideoPicture;
typedef struct SubPicture {
AVPacket audio_pkt_temp;
AVPacket audio_pkt;
int audio_pkt_temp_serial;
+ int audio_last_serial;
struct AudioParams audio_src;
+#if CONFIG_AVFILTER
+ struct AudioParams audio_filter_src;
+#endif
struct AudioParams audio_tgt;
struct SwrContext *swr_ctx;
double audio_current_pts;
#if CONFIG_AVFILTER
AVFilterContext *in_video_filter; // the first filter in the video chain
AVFilterContext *out_video_filter; // the last filter in the video chain
- int use_dr1;
- FrameBuffer *buffer_pool;
+ AVFilterContext *in_audio_filter; // the first filter in the audio chain
+ AVFilterContext *out_audio_filter; // the last filter in the audio chain
+ AVFilterGraph *agraph; // audio filter graph
#endif
int last_video_stream, last_audio_stream, last_subtitle_stream;
static int cursor_hidden = 0;
#if CONFIG_AVFILTER
static char *vfilters = NULL;
+static char *afilters = NULL;
#endif
/* current context */
static SDL_Surface *screen;
+static inline
+int cmp_audio_fmts(enum AVSampleFormat fmt1, int64_t channel_count1,
+ enum AVSampleFormat fmt2, int64_t channel_count2)
+{
+ /* If channel count == 1, planar and non-planar formats are the same */
+ if (channel_count1 == 1 && channel_count2 == 1)
+ return av_get_packed_sample_fmt(fmt1) != av_get_packed_sample_fmt(fmt2);
+ else
+ return channel_count1 != channel_count2 || fmt1 != fmt2;
+}
+
+static inline
+int64_t get_valid_channel_layout(int64_t channel_layout, int channels)
+{
+ if (channel_layout && av_get_channel_layout_nb_channels(channel_layout) == channels)
+ return channel_layout;
+ else
+ return 0;
+}
+
static int packet_queue_put(PacketQueue *q, AVPacket *pkt);
static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
float aspect_ratio;
int width, height, x, y;
- if (vp->sample_aspect_ratio.num == 0)
+ if (vp->sar.num == 0)
aspect_ratio = 0;
else
- aspect_ratio = av_q2d(vp->sample_aspect_ratio);
+ aspect_ratio = av_q2d(vp->sar);
if (aspect_ratio <= 0.0)
aspect_ratio = 1.0;
/* free all pictures */
for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++) {
vp = &is->pictq[i];
-#if CONFIG_AVFILTER
- avfilter_unref_bufferp(&vp->picref);
-#endif
if (vp->bmp) {
SDL_FreeYUVOverlay(vp->bmp);
vp->bmp = NULL;
if (vp->bmp)
SDL_FreeYUVOverlay(vp->bmp);
-#if CONFIG_AVFILTER
- avfilter_unref_bufferp(&vp->picref);
-#endif
-
video_open(is, 0, vp);
vp->bmp = SDL_CreateYUVOverlay(vp->width, vp->height,
vp = &is->pictq[is->pictq_windex];
#if CONFIG_AVFILTER
- vp->sample_aspect_ratio = ((AVFilterBufferRef *)src_frame->opaque)->video->sample_aspect_ratio;
+ vp->sar = src_frame->sample_aspect_ratio;
#else
- vp->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, src_frame);
+ vp->sar = av_guess_sample_aspect_ratio(is->ic, is->video_st, src_frame);
#endif
/* alloc or resize hardware picture buffer */
/* if the frame is not skipped, then display it */
if (vp->bmp) {
AVPicture pict = { { 0 } };
-#if CONFIG_AVFILTER
- avfilter_unref_bufferp(&vp->picref);
- vp->picref = src_frame->opaque;
-#endif
/* get a pointer on the bitmap */
SDL_LockYUVOverlay (vp->bmp);
is->frame_timer = (double)av_gettime() / 1000000.0;
is->frame_last_dropped_pts = AV_NOPTS_VALUE;
SDL_UnlockMutex(is->pictq_mutex);
-
return 0;
}
buffersink_params->pixel_fmts = pix_fmts;
ret = avfilter_graph_create_filter(&filt_out,
- avfilter_get_by_name("ffbuffersink"),
+ avfilter_get_by_name("buffersink"),
"ffplay_buffersink", NULL, buffersink_params, graph);
if (ret < 0)
goto fail;
return ret;
}
+static int configure_audio_filters(VideoState *is, const char *afilters, int force_output_format)
+{
+ static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, PIX_FMT_NONE };
+ int sample_rates[2] = { 0, -1 };
+ int64_t channel_layouts[2] = { 0, -1 };
+ int channels[2] = { 0, -1 };
+ AVFilterContext *filt_asrc = NULL, *filt_asink = NULL;
+ char asrc_args[256];
+ AVABufferSinkParams *asink_params = NULL;
+ int ret;
+
+ avfilter_graph_free(&is->agraph);
+ if (!(is->agraph = avfilter_graph_alloc()))
+ return AVERROR(ENOMEM);
+
+ ret = snprintf(asrc_args, sizeof(asrc_args),
+ "sample_rate=%d:sample_fmt=%s:channels=%d",
+ is->audio_filter_src.freq, av_get_sample_fmt_name(is->audio_filter_src.fmt),
+ is->audio_filter_src.channels);
+ if (is->audio_filter_src.channel_layout)
+ snprintf(asrc_args + ret, sizeof(asrc_args) - ret,
+ ":channel_layout=0x%"PRIx64, is->audio_filter_src.channel_layout);
+
+ ret = avfilter_graph_create_filter(&filt_asrc,
+ avfilter_get_by_name("abuffer"), "ffplay_abuffer",
+ asrc_args, NULL, is->agraph);
+ if (ret < 0)
+ goto end;
+
+ if (!(asink_params = av_abuffersink_params_alloc())) {
+ ret = AVERROR(ENOMEM);
+ goto end;
+ }
+ asink_params->sample_fmts = sample_fmts;
+
+ asink_params->all_channel_counts = 1;
+ if (force_output_format) {
+ channel_layouts[0] = is->audio_tgt.channel_layout;
+ asink_params->channel_layouts = channel_layouts;
+ asink_params->all_channel_counts = 0;
+ channels[0] = is->audio_tgt.channels;
+ asink_params->channel_counts = channels;
+ asink_params->all_channel_counts = 0;
+ sample_rates[0] = is->audio_tgt.freq;
+ asink_params->sample_rates = sample_rates;
+ }
+
+ ret = avfilter_graph_create_filter(&filt_asink,
+ avfilter_get_by_name("abuffersink"), "ffplay_abuffersink",
+ NULL, asink_params, is->agraph);
+ if (ret < 0)
+ goto end;
+
+ if ((ret = configure_filtergraph(is->agraph, afilters, filt_asrc, filt_asink)) < 0)
+ goto end;
+
+ is->in_audio_filter = filt_asrc;
+ is->out_audio_filter = filt_asink;
+
+end:
+ av_freep(&asink_params);
+ if (ret < 0)
+ avfilter_graph_free(&is->agraph);
+ return ret;
+}
#endif /* CONFIG_AVFILTER */
static int video_thread(void *arg)
{
AVPacket pkt = { 0 };
VideoState *is = arg;
- AVFrame *frame = avcodec_alloc_frame();
+ AVFrame *frame = av_frame_alloc();
int64_t pts_int = AV_NOPTS_VALUE, pos = -1;
double pts;
int ret;
int serial = 0;
#if CONFIG_AVFILTER
- AVCodecContext *codec = is->video_st->codec;
AVFilterGraph *graph = avfilter_graph_alloc();
AVFilterContext *filt_out = NULL, *filt_in = NULL;
int last_w = 0;
int last_h = 0;
enum AVPixelFormat last_format = -2;
int last_serial = -1;
-
- if (codec->codec->capabilities & CODEC_CAP_DR1) {
- is->use_dr1 = 1;
- codec->get_buffer = codec_get_buffer;
- codec->release_buffer = codec_release_buffer;
- codec->opaque = &is->buffer_pool;
- }
#endif
for (;;) {
#if CONFIG_AVFILTER
- AVFilterBufferRef *picref;
AVRational tb;
#endif
while (is->paused && !is->videoq.abort_request)
frame->pts = pts_int;
frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
- if (is->use_dr1 && frame->opaque) {
- FrameBuffer *buf = frame->opaque;
- AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
- frame->data, frame->linesize,
- AV_PERM_READ | AV_PERM_PRESERVE,
- frame->width, frame->height,
- frame->format);
-
- avfilter_copy_frame_props(fb, frame);
- fb->buf->priv = buf;
- fb->buf->free = filter_release_buffer;
-
- buf->refcount++;
- av_buffersrc_add_ref(filt_in, fb, AV_BUFFERSRC_FLAG_NO_COPY);
-
- } else
- av_buffersrc_write_frame(filt_in, frame);
-
+ ret = av_buffersrc_add_frame(filt_in, frame);
+ if (ret < 0)
+ goto the_end;
+ av_frame_unref(frame);
+ avcodec_get_frame_defaults(frame);
av_free_packet(&pkt);
while (ret >= 0) {
is->frame_last_returned_time = av_gettime() / 1000000.0;
- ret = av_buffersink_get_buffer_ref(filt_out, &picref, 0);
+ ret = av_buffersink_get_frame_flags(filt_out, frame, 0);
if (ret < 0) {
ret = 0;
break;
if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
is->frame_last_filter_delay = 0;
- avfilter_copy_buf_props(frame, picref);
-
- pts_int = picref->pts;
+ pts_int = frame->pts;
tb = filt_out->inputs[0]->time_base;
- pos = picref->pos;
- frame->opaque = picref;
-
+ pos = av_frame_get_pkt_pos(frame);
if (av_cmp_q(tb, is->video_st->time_base)) {
av_unused int64_t pts1 = pts_int;
pts_int = av_rescale_q(pts_int, tb, is->video_st->time_base);
}
pts = pts_int * av_q2d(is->video_st->time_base);
ret = queue_picture(is, frame, pts, pos, serial);
+ av_frame_unref(frame);
}
#else
pts = pts_int * av_q2d(is->video_st->time_base);
ret = queue_picture(is, frame, pts, pkt.pos, serial);
+ av_frame_unref(frame);
#endif
if (ret < 0)
avfilter_graph_free(&graph);
#endif
av_free_packet(&pkt);
- avcodec_free_frame(&frame);
+ av_frame_free(&frame);
return 0;
}
AVPacket *pkt_temp = &is->audio_pkt_temp;
AVPacket *pkt = &is->audio_pkt;
AVCodecContext *dec = is->audio_st->codec;
- int len1, len2, data_size, resampled_data_size;
+ int len1, data_size, resampled_data_size;
int64_t dec_channel_layout;
int got_frame;
av_unused double audio_clock0;
int new_packet = 0;
int flush_complete = 0;
int wanted_nb_samples;
+ AVRational tb;
for (;;) {
/* NOTE: the audio packet can contain several frames */
if (!is->frame) {
if (!(is->frame = avcodec_alloc_frame()))
return AVERROR(ENOMEM);
- } else
+ } else {
+ av_frame_unref(is->frame);
avcodec_get_frame_defaults(is->frame);
+ }
if (is->audioq.serial != is->audio_pkt_temp_serial)
break;
flush_complete = 1;
continue;
}
+
+ if (is->frame->pts == AV_NOPTS_VALUE && pkt_temp->pts != AV_NOPTS_VALUE)
+ is->frame->pts = av_rescale_q(pkt_temp->pts, is->audio_st->time_base, dec->time_base);
+ if (pkt_temp->pts != AV_NOPTS_VALUE)
+ pkt_temp->pts += (double) is->frame->nb_samples / is->frame->sample_rate / av_q2d(is->audio_st->time_base);
+ tb = dec->time_base;
+
+#if CONFIG_AVFILTER
+ {
+ int ret;
+ int reconfigure;
+
+ dec_channel_layout = get_valid_channel_layout(is->frame->channel_layout, av_frame_get_channels(is->frame));
+
+ reconfigure =
+ cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
+ is->frame->format, av_frame_get_channels(is->frame)) ||
+ is->audio_filter_src.channel_layout != dec_channel_layout ||
+ is->audio_filter_src.freq != is->frame->sample_rate ||
+ is->audio_pkt_temp_serial != is->audio_last_serial;
+
+ if (reconfigure) {
+ char buf1[1024], buf2[1024];
+ av_get_channel_layout_string(buf1, sizeof(buf1), -1, is->audio_filter_src.channel_layout);
+ av_get_channel_layout_string(buf2, sizeof(buf2), -1, dec_channel_layout);
+ av_log(NULL, AV_LOG_DEBUG,
+ "Audio frame changed from rate:%d ch:%d fmt:%s layout:%s serial:%d to rate:%d ch:%d fmt:%s layout:%s serial:%d\n",
+ is->audio_filter_src.freq, is->audio_filter_src.channels, av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, is->audio_last_serial,
+ is->frame->sample_rate, av_frame_get_channels(is->frame), av_get_sample_fmt_name(is->frame->format), buf2, is->audio_pkt_temp_serial);
+
+ is->audio_filter_src.fmt = is->frame->format;
+ is->audio_filter_src.channels = av_frame_get_channels(is->frame);
+ is->audio_filter_src.channel_layout = dec_channel_layout;
+ is->audio_filter_src.freq = is->frame->sample_rate;
+ is->audio_last_serial = is->audio_pkt_temp_serial;
+
+ if ((ret = configure_audio_filters(is, afilters, 1)) < 0)
+ return ret;
+ }
+
+ if ((ret = av_buffersrc_add_frame(is->in_audio_filter, is->frame)) < 0)
+ return ret;
+ av_frame_unref(is->frame);
+ if ((ret = av_buffersink_get_frame_flags(is->out_audio_filter, is->frame, 0)) < 0)
+ return ret;
+ tb = is->out_audio_filter->inputs[0]->time_base;
+ }
+#endif
+
data_size = av_samples_get_buffer_size(NULL, av_frame_get_channels(is->frame),
is->frame->nb_samples,
is->frame->format, 1);
uint8_t **out = &is->audio_buf1;
int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / is->frame->sample_rate + 256;
int out_size = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, out_count, is->audio_tgt.fmt, 0);
+ int len2;
if (wanted_nb_samples != is->frame->nb_samples) {
if (swr_set_compensation(is->swr_ctx, (wanted_nb_samples - is->frame->nb_samples) * is->audio_tgt.freq / is->frame->sample_rate,
wanted_nb_samples * is->audio_tgt.freq / is->frame->sample_rate) < 0) {
}
audio_clock0 = is->audio_clock;
- is->audio_clock += (double)data_size /
- (av_frame_get_channels(is->frame) * is->frame->sample_rate * av_get_bytes_per_sample(is->frame->format));
+ /* update the audio clock with the pts */
+ if (is->frame->pts != AV_NOPTS_VALUE) {
+ is->audio_clock = is->frame->pts * av_q2d(tb) + (double) is->frame->nb_samples / is->frame->sample_rate;
+ is->audio_clock_serial = is->audio_pkt_temp_serial;
+ }
#ifdef DEBUG
{
static double last_clock;
}
*pkt_temp = *pkt;
-
- /* if update the audio clock with the pts */
- if (pkt->pts != AV_NOPTS_VALUE) {
- is->audio_clock = av_q2d(is->audio_st->time_base)*pkt->pts;
- is->audio_clock_serial = is->audio_pkt_temp_serial;
- }
}
}
const char *forced_codec_name = NULL;
AVDictionary *opts;
AVDictionaryEntry *t = NULL;
+ int sample_rate, nb_channels;
+ int64_t channel_layout;
+ int ret;
if (stream_index < 0 || stream_index >= ic->nb_streams)
return -1;
opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
if (!av_dict_get(opts, "threads", NULL, 0))
av_dict_set(&opts, "threads", "auto", 0);
+ if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
+ av_dict_set(&opts, "refcounted_frames", "1", 0);
if (avcodec_open2(avctx, codec, &opts) < 0)
return -1;
if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
return AVERROR_OPTION_NOT_FOUND;
}
- /* prepare audio output */
- if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
- int audio_hw_buf_size = audio_open(is, avctx->channel_layout, avctx->channels, avctx->sample_rate, &is->audio_src);
- if (audio_hw_buf_size < 0)
- return -1;
- is->audio_hw_buf_size = audio_hw_buf_size;
- is->audio_tgt = is->audio_src;
- }
-
ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
switch (avctx->codec_type) {
case AVMEDIA_TYPE_AUDIO:
- is->audio_stream = stream_index;
- is->audio_st = ic->streams[stream_index];
+#if CONFIG_AVFILTER
+ {
+ AVFilterLink *link;
+
+ is->audio_filter_src.freq = avctx->sample_rate;
+ is->audio_filter_src.channels = avctx->channels;
+ is->audio_filter_src.channel_layout = get_valid_channel_layout(avctx->channel_layout, avctx->channels);
+ is->audio_filter_src.fmt = avctx->sample_fmt;
+ if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
+ return ret;
+ link = is->out_audio_filter->inputs[0];
+ sample_rate = link->sample_rate;
+ nb_channels = link->channels;
+ channel_layout = link->channel_layout;
+ }
+#else
+ sample_rate = avctx->sample_rate;
+ nb_channels = avctx->channels;
+ channel_layout = avctx->channel_layout;
+#endif
+
+ /* prepare audio output */
+ if ((ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)) < 0)
+ return ret;
+ is->audio_hw_buf_size = ret;
+ is->audio_src = is->audio_tgt;
is->audio_buf_size = 0;
is->audio_buf_index = 0;
memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
memset(&is->audio_pkt_temp, 0, sizeof(is->audio_pkt_temp));
+
+ is->audio_stream = stream_index;
+ is->audio_st = ic->streams[stream_index];
+
packet_queue_start(&is->audioq);
SDL_PauseAudio(0);
break;
av_freep(&is->audio_buf1);
is->audio_buf1_size = 0;
is->audio_buf = NULL;
- avcodec_free_frame(&is->frame);
+ av_frame_free(&is->frame);
if (is->rdft) {
av_rdft_end(is->rdft);
is->rdft = NULL;
is->rdft_bits = 0;
}
+#if CONFIG_AVFILTER
+ avfilter_graph_free(&is->agraph);
+#endif
break;
case AVMEDIA_TYPE_VIDEO:
packet_queue_abort(&is->videoq);
ic->streams[stream_index]->discard = AVDISCARD_ALL;
avcodec_close(avctx);
-#if CONFIG_AVFILTER
- free_buffer_pool(&is->buffer_pool);
-#endif
switch (avctx->codec_type) {
case AVMEDIA_TYPE_AUDIO:
is->audio_st = NULL;
is->video_current_pts_drift = is->audio_current_pts_drift;
is->audio_clock_serial = -1;
is->video_clock_serial = -1;
+ is->audio_last_serial = -1;
is->av_sync_type = av_sync_type;
is->read_tid = SDL_CreateThread(read_thread, is);
if (!is->read_tid) {
{ "window_title", OPT_STRING | HAS_ARG, { &window_title }, "set window title", "window title" },
#if CONFIG_AVFILTER
{ "vf", OPT_STRING | HAS_ARG, { &vfilters }, "set video filters", "filter_graph" },
+ { "af", OPT_STRING | HAS_ARG, { &afilters }, "set audio filters", "filter_graph" },
#endif
{ "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
{ "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
}
if (!display_disable) {
-#if HAVE_SDL_VIDEO_SIZE
const SDL_VideoInfo *vi = SDL_GetVideoInfo();
fs_screen_width = vi->current_w;
fs_screen_height = vi->current_h;
-#endif
}
SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
projects / ffmpeg / blobdiff