SDL_Overlay *bmp;
int width, height; /* source height & width */
int allocated;
+ int reallocate;
enum PixelFormat pix_fmt;
#if CONFIG_AVFILTER
AVStream *audio_st;
PacketQueue audioq;
int audio_hw_buf_size;
- /* samples output by the codec. we reserve more space for avsync
- compensation, resampling and format conversion */
- DECLARE_ALIGNED(16,uint8_t,audio_buf1)[AVCODEC_MAX_AUDIO_FRAME_SIZE * 4];
DECLARE_ALIGNED(16,uint8_t,audio_buf2)[AVCODEC_MAX_AUDIO_FRAME_SIZE * 4];
+ uint8_t silence_buf[SDL_AUDIO_BUFFER_SIZE];
uint8_t *audio_buf;
+ uint8_t *audio_buf1;
unsigned int audio_buf_size; /* in bytes */
int audio_buf_index; /* in bytes */
int audio_write_buf_size;
struct SwrContext *swr_ctx;
double audio_current_pts;
double audio_current_pts_drift;
+ int frame_drops_early;
+ int frame_drops_late;
+ AVFrame *frame;
enum ShowMode {
SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO = 0, SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB
double frame_timer;
double frame_last_pts;
double frame_last_duration;
+ double frame_last_dropped_pts;
+ double frame_last_returned_time;
+ double frame_last_filter_delay;
+ int64_t frame_last_dropped_pos;
double video_clock; ///<pts of last decoded frame / predicted pts of next decoded frame
int video_stream;
AVStream *video_st;
static SDL_Surface *screen;
-void exit_program(int ret)
+void av_noreturn exit_program(int ret)
{
exit(ret);
}
#if CONFIG_AVFILTER
avfilter_uninit();
#endif
+ avformat_network_deinit();
if (show_status)
printf("\n");
SDL_Quit();
SDL_UnlockMutex(is->pictq_mutex);
}
+static void update_video_pts(VideoState *is, double pts, int64_t pos) {
+ double time = av_gettime() / 1000000.0;
+ /* update current video pts */
+ is->video_current_pts = pts;
+ is->video_current_pts_drift = is->video_current_pts - time;
+ is->video_current_pos = pos;
+ is->frame_last_pts = pts;
+}
+
/* called to display each frame */
static void video_refresh(void *opaque)
{
VideoState *is = opaque;
VideoPicture *vp;
+ double time;
SubPicture *sp, *sp2;
if (is->video_st) {
retry:
if (is->pictq_size == 0) {
+ SDL_LockMutex(is->pictq_mutex);
+ if (is->frame_last_dropped_pts != AV_NOPTS_VALUE && is->frame_last_dropped_pts > is->frame_last_pts) {
+ update_video_pts(is, is->frame_last_dropped_pts, is->frame_last_dropped_pos);
+ is->frame_last_dropped_pts = AV_NOPTS_VALUE;
+ }
+ SDL_UnlockMutex(is->pictq_mutex);
//nothing to do, no picture to display in the que
} else {
- double time= av_gettime()/1000000.0;
double last_duration, duration, delay;
/* dequeue the picture */
vp = &is->pictq[is->pictq_rindex];
}
delay = compute_target_delay(is->frame_last_duration, is);
+ time= av_gettime()/1000000.0;
if(time < is->frame_timer + delay)
return;
- is->frame_last_pts = vp->pts;
if (delay > 0)
is->frame_timer += delay * FFMAX(1, floor((time-is->frame_timer) / delay));
- /* update current video pts */
- is->video_current_pts = vp->pts;
- is->video_current_pts_drift = is->video_current_pts - time;
- is->video_current_pos = vp->pos;
+ SDL_LockMutex(is->pictq_mutex);
+ update_video_pts(is, vp->pts, vp->pos);
+ SDL_UnlockMutex(is->pictq_mutex);
if(is->pictq_size > 1) {
VideoPicture *nextvp= &is->pictq[(is->pictq_rindex+1)%VIDEO_PICTURE_QUEUE_SIZE];
if((framedrop>0 || (framedrop && is->audio_st)) && time > is->frame_timer + duration){
if(is->pictq_size > 1){
+ is->frame_drops_late++;
pictq_next_picture(is);
goto retry;
}
av_diff = 0;
if (is->audio_st && is->video_st)
av_diff = get_audio_clock(is) - get_video_clock(is);
- printf("%7.2f A-V:%7.3f aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64" \r",
+ printf("%7.2f A-V:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64" \r",
get_master_clock(is),
av_diff,
+ is->frame_drops_early + is->frame_drops_late,
aqsize / 1024,
vqsize / 1024,
sqsize,
vp->duration = frame_delay;
/* alloc or resize hardware picture buffer */
- if (!vp->bmp ||
+ if (!vp->bmp || vp->reallocate ||
#if CONFIG_AVFILTER
vp->width != is->out_video_filter->inputs[0]->w ||
vp->height != is->out_video_filter->inputs[0]->h) {
#endif
SDL_Event event;
- vp->allocated = 0;
+ vp->allocated = 0;
+ vp->reallocate = 0;
/* the allocation must be done in the main thread to avoid
locking problems */
SDL_CondWait(is->pictq_cond, is->pictq_mutex);
}
is->video_current_pos = -1;
- SDL_UnlockMutex(is->pictq_mutex);
-
is->frame_last_pts = AV_NOPTS_VALUE;
is->frame_last_duration = 0;
is->frame_timer = (double)av_gettime() / 1000000.0;
+ is->frame_last_dropped_pts = AV_NOPTS_VALUE;
+ SDL_UnlockMutex(is->pictq_mutex);
+
return 0;
}
avcodec_decode_video2(is->video_st->codec, frame, &got_picture, pkt);
if (got_picture) {
+ int ret = 1;
+
if (decoder_reorder_pts == -1) {
- *pts = frame->best_effort_timestamp;
+ *pts = *(int64_t*)av_opt_ptr(avcodec_get_frame_class(), frame, "best_effort_timestamp");
} else if (decoder_reorder_pts) {
*pts = frame->pkt_pts;
} else {
*pts = 0;
}
- return 1;
+ if (((is->av_sync_type == AV_SYNC_AUDIO_MASTER && is->audio_st) || is->av_sync_type == AV_SYNC_EXTERNAL_CLOCK) &&
+ (framedrop>0 || (framedrop && is->audio_st))) {
+ SDL_LockMutex(is->pictq_mutex);
+ if (is->frame_last_pts != AV_NOPTS_VALUE && *pts) {
+ double clockdiff = get_video_clock(is) - get_master_clock(is);
+ double dpts = av_q2d(is->video_st->time_base) * *pts;
+ double ptsdiff = dpts - is->frame_last_pts;
+ if (fabs(clockdiff) < AV_NOSYNC_THRESHOLD &&
+ ptsdiff > 0 && ptsdiff < AV_NOSYNC_THRESHOLD &&
+ clockdiff + ptsdiff - is->frame_last_filter_delay < 0) {
+ is->frame_last_dropped_pos = pkt->pos;
+ is->frame_last_dropped_pts = dpts;
+ is->frame_drops_early++;
+ ret = 0;
+ }
+ }
+ SDL_UnlockMutex(is->pictq_mutex);
+ }
+
+ if (ret)
+ is->frame_last_returned_time = av_gettime() / 1000000.0;
+ return ret;
}
return 0;
}
edge = codec->flags & CODEC_FLAG_EMU_EDGE ? 0 : avcodec_get_edge_width();
w += edge << 1;
h += edge << 1;
-
+ if (codec->pix_fmt != ctx->outputs[0]->format) {
+ av_log(codec, AV_LOG_ERROR, "Pixel format mismatches %d %d\n", codec->pix_fmt, ctx->outputs[0]->format);
+ return -1;
+ }
if(!(ref = avfilter_get_video_buffer(ctx->outputs[0], perms, w, h)))
return -1;
if (ret < 0) goto the_end;
+ is->frame_last_filter_delay = av_gettime() / 1000000.0 - is->frame_last_returned_time;
+ if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
+ is->frame_last_filter_delay = 0;
+
#if CONFIG_AVFILTER
if (!picref)
continue;
max_size = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX)) / 100) * n;
if (wanted_size < min_size)
wanted_size = min_size;
- else if (wanted_size > FFMIN3(max_size, sizeof(is->audio_buf1), sizeof(is->audio_buf2)))
- wanted_size = FFMIN3(max_size, sizeof(is->audio_buf1), sizeof(is->audio_buf2));
+ else if (wanted_size > FFMIN3(max_size, samples_size, sizeof(is->audio_buf2)))
+ wanted_size = FFMIN3(max_size, samples_size, sizeof(is->audio_buf2));
/* add or remove samples to correction the synchro */
if (wanted_size < samples_size) {
AVPacket *pkt = &is->audio_pkt;
AVCodecContext *dec= is->audio_st->codec;
int len1, len2, data_size, resampled_data_size;
- int64_t dec_channel_layout;
+ int64_t dec_channel_layout, got_frame;
double pts;
int new_packet = 0;
int flush_complete = 0;
for(;;) {
/* NOTE: the audio packet can contain several frames */
while (pkt_temp->size > 0 || (!pkt_temp->data && new_packet)) {
+ if (!is->frame) {
+ if (!(is->frame = avcodec_alloc_frame()))
+ return AVERROR(ENOMEM);
+ } else
+ avcodec_get_frame_defaults(is->frame);
+
if (flush_complete)
break;
new_packet = 0;
- data_size = sizeof(is->audio_buf1);
- len1 = avcodec_decode_audio3(dec,
- (int16_t *)is->audio_buf1, &data_size,
- pkt_temp);
+ len1 = avcodec_decode_audio4(dec, is->frame, &got_frame, pkt_temp);
if (len1 < 0) {
/* if error, we skip the frame */
pkt_temp->size = 0;
pkt_temp->data += len1;
pkt_temp->size -= len1;
- if (data_size <= 0) {
+ if (!got_frame) {
/* stop sending empty packets if the decoder is finished */
if (!pkt_temp->data && dec->codec->capabilities & CODEC_CAP_DELAY)
flush_complete = 1;
continue;
}
+ data_size = av_samples_get_buffer_size(NULL, dec->channels,
+ is->frame->nb_samples,
+ dec->sample_fmt, 1);
dec_channel_layout = (dec->channel_layout && dec->channels == av_get_channel_layout_nb_channels(dec->channel_layout)) ? dec->channel_layout : av_get_default_channel_layout(dec->channels);
if (dec->sample_fmt != is->audio_src_fmt || dec_channel_layout != is->audio_src_channel_layout || dec->sample_rate != is->audio_src_freq) {
if (is->swr_ctx)
swr_free(&is->swr_ctx);
- is->swr_ctx = swr_alloc2(NULL, is->audio_tgt_channel_layout, is->audio_tgt_fmt, is->audio_tgt_freq,
- dec_channel_layout, dec->sample_fmt, dec->sample_rate,
- 0, NULL);
+ is->swr_ctx = swr_alloc_set_opts(NULL,
+ is->audio_tgt_channel_layout, is->audio_tgt_fmt, is->audio_tgt_freq,
+ dec_channel_layout, dec->sample_fmt, dec->sample_rate,
+ 0, NULL);
if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
fprintf(stderr, "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
dec->sample_rate,
resampled_data_size = data_size;
if (is->swr_ctx) {
- const uint8_t *in[] = {is->audio_buf1};
+ const uint8_t *in[] = { is->frame->data[0] };
uint8_t *out[] = {is->audio_buf2};
len2 = swr_convert(is->swr_ctx, out, sizeof(is->audio_buf2) / is->audio_tgt_channels / av_get_bytes_per_sample(is->audio_tgt_fmt),
in, data_size / dec->channels / av_get_bytes_per_sample(dec->sample_fmt));
is->audio_buf = is->audio_buf2;
resampled_data_size = len2 * is->audio_tgt_channels * av_get_bytes_per_sample(is->audio_tgt_fmt);
} else {
- is->audio_buf= is->audio_buf1;
+ is->audio_buf = is->frame->data[0];
}
/* if no pts, then compute it */
if (pkt->data == flush_pkt.data)
avcodec_flush_buffers(dec);
- pkt_temp->data = pkt->data;
- pkt_temp->size = pkt->size;
+ *pkt_temp = *pkt;
/* if update the audio clock with the pts */
if (pkt->pts != AV_NOPTS_VALUE) {
audio_size = audio_decode_frame(is, &pts);
if (audio_size < 0) {
/* if error, just output silence */
- is->audio_buf = is->audio_buf1;
- is->audio_buf_size = 256 * is->audio_tgt_channels * av_get_bytes_per_sample(is->audio_tgt_fmt);
- memset(is->audio_buf, 0, is->audio_buf_size);
+ is->audio_buf = is->silence_buf;
+ is->audio_buf_size = sizeof(is->silence_buf);
} else {
if (is->show_mode != SHOW_MODE_VIDEO)
update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
return -1;
avctx = ic->streams[stream_index]->codec;
- opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index]);
-
codec = avcodec_find_decoder(avctx->codec_id);
+ opts = filter_codec_opts(codec_opts, codec, ic, ic->streams[stream_index]);
+
switch(avctx->codec_type){
case AVMEDIA_TYPE_AUDIO : if(audio_codec_name ) codec= avcodec_find_decoder_by_name( audio_codec_name); break;
case AVMEDIA_TYPE_SUBTITLE: if(subtitle_codec_name) codec= avcodec_find_decoder_by_name(subtitle_codec_name); break;
avctx->workaround_bugs = workaround_bugs;
avctx->lowres = lowres;
- if(lowres) avctx->flags |= CODEC_FLAG_EMU_EDGE;
+ if(avctx->lowres > codec->max_lowres){
+ av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
+ codec->max_lowres);
+ avctx->lowres= codec->max_lowres;
+ }
+ if(avctx->lowres) avctx->flags |= CODEC_FLAG_EMU_EDGE;
avctx->idct_algo= idct;
if(fast) avctx->flags2 |= CODEC_FLAG2_FAST;
avctx->skip_frame= skip_frame;
if (is->swr_ctx)
swr_free(&is->swr_ctx);
av_free_packet(&is->audio_pkt);
+ av_freep(&is->audio_buf1);
+ is->audio_buf = NULL;
+ av_freep(&is->frame);
if (is->rdft) {
av_rdft_end(is->rdft);
av_freep(&is->rdft_data);
+ is->rdft = NULL;
+ is->rdft_bits = 0;
}
break;
case AVMEDIA_TYPE_VIDEO:
variable instead of a thread local variable */
static VideoState *global_video_state;
-static int decode_interrupt_cb(void)
+static int decode_interrupt_cb(void *ctx)
{
return (global_video_state && global_video_state->abort_request);
}
is->subtitle_stream = -1;
global_video_state = is;
- avio_set_interrupt_cb(decode_interrupt_cb);
+ ic = avformat_alloc_context();
+ ic->interrupt_callback.callback = decode_interrupt_cb;
err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
if (err < 0) {
print_error(is->filename, err);
else
av_read_play(ic);
}
-#if CONFIG_RTSP_DEMUXER
- if (is->paused && !strcmp(ic->iformat->name, "rtsp")) {
+#if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
+ if (is->paused &&
+ (!strcmp(ic->iformat->name, "rtsp") ||
+ (ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
/* wait 10 ms to avoid trying to get another packet */
/* XXX: horrible */
SDL_Delay(10);
static void toggle_full_screen(VideoState *is)
{
is_full_screen = !is_full_screen;
+#if defined(__APPLE__) && SDL_VERSION_ATLEAST(1, 2, 14)
+ /* OS X needs to reallocate the SDL overlays */
+ for (int i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++) {
+ is->pictq[i].reallocate = 1;
+ }
+#endif
video_open(is);
}
avfilter_register_all();
#endif
av_register_all();
+ avformat_network_init();
init_opts();
projects / ffmpeg / blobdiff