X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=ffplay.c;h=86040bec3fdd410c884546c871f0e0eab9aecb5b;hb=35f7c39a5d2f417720fd8ed1e365114d7abffb5d;hp=b32c6091d277767e36284ee7b5ecd73d9cfc4444;hpb=092421cf0e44bb4e4700a4e2f3a86fab0038dbda;p=ffmpeg diff --git a/ffplay.c b/ffplay.c index b32c6091d27..86040bec3fd 100644 --- a/ffplay.c +++ b/ffplay.c @@ -1,5 +1,5 @@ /* - * FFplay : Simple Media Player based on the ffmpeg libraries + * FFplay : Simple Media Player based on the FFmpeg libraries * Copyright (c) 2003 Fabrice Bellard * * This file is part of FFmpeg. @@ -20,6 +20,7 @@ */ #include "config.h" +#include #include #include #include "libavutil/avstring.h" @@ -30,7 +31,13 @@ #include "libavcodec/audioconvert.h" #include "libavcodec/colorspace.h" #include "libavcodec/opt.h" -#include "libavcodec/dsputil.h" +#include "libavcodec/avfft.h" + +#if CONFIG_AVFILTER +# include "libavfilter/avfilter.h" +# include "libavfilter/avfiltergraph.h" +# include "libavfilter/graphparser.h" +#endif #include "cmdutils.h" @@ -41,9 +48,8 @@ #undef main /* We don't want SDL to override our main() */ #endif -#undef exit -#undef printf -#undef fprintf +#include +#include const char program_name[] = "FFplay"; const int program_birth_year = 2003; @@ -63,6 +69,8 @@ const int program_birth_year = 2003; /* no AV correction is done if too big error */ #define AV_NOSYNC_THRESHOLD 10.0 +#define FRAME_SKIP_FACTOR 0.05 + /* maximum audio speed change to get correct sync */ #define SAMPLE_CORRECTION_PERCENT_MAX 10 @@ -83,16 +91,21 @@ typedef struct PacketQueue { SDL_cond *cond; } PacketQueue; -#define VIDEO_PICTURE_QUEUE_SIZE 1 +#define VIDEO_PICTURE_QUEUE_SIZE 2 #define SUBPICTURE_QUEUE_SIZE 4 typedef struct VideoPicture { double pts; ///pictq[is->pictq_rindex]; if (vp->bmp) { +#if CONFIG_AVFILTER + if (vp->picref->pixel_aspect.num == 0) + aspect_ratio = 0; + else + aspect_ratio = av_q2d(vp->picref->pixel_aspect); +#else + /* XXX: use variable in the frame */ if (is->video_st->sample_aspect_ratio.num) aspect_ratio = av_q2d(is->video_st->sample_aspect_ratio); @@ -673,9 +714,10 @@ static void video_image_display(VideoState *is) aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio); else aspect_ratio = 0; +#endif if (aspect_ratio <= 0.0) aspect_ratio = 1.0; - aspect_ratio *= (float)is->video_st->codec->width / is->video_st->codec->height; + aspect_ratio *= (float)vp->width / (float)vp->height; /* if an active format is indicated, then it overrides the mpeg format */ #if 0 @@ -782,11 +824,17 @@ static void video_audio_display(VideoState *s) int i, i_start, x, y1, y, ys, delay, n, nb_display_channels; int ch, channels, h, h2, bgcolor, fgcolor; int16_t time_diff; + int rdft_bits, nb_freq; + + for(rdft_bits=1; (1<height; rdft_bits++) + ; + nb_freq= 1<<(rdft_bits-1); /* compute display index : center on currently output samples */ channels = s->audio_st->codec->channels; nb_display_channels = channels; if (!s->paused) { + int data_used= s->show_audio==1 ? s->width : (2*nb_freq); n = 2 * channels; delay = audio_write_get_buf_size(s); delay /= n; @@ -795,29 +843,29 @@ static void video_audio_display(VideoState *s) the last buffer computation */ if (audio_callback_time) { time_diff = av_gettime() - audio_callback_time; - delay += (time_diff * s->audio_st->codec->sample_rate) / 1000000; + delay -= (time_diff * s->audio_st->codec->sample_rate) / 1000000; } - delay -= s->width / 2; - if (delay < s->width) - delay = s->width; + delay += 2*data_used; + if (delay < data_used) + delay = data_used; i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE); if(s->show_audio==1){ - h= INT_MIN; - for(i=0; i<1000; i+=channels){ - int idx= (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE; - int a= s->sample_array[idx]; - int b= s->sample_array[(idx + 4*channels)%SAMPLE_ARRAY_SIZE]; - int c= s->sample_array[(idx + 5*channels)%SAMPLE_ARRAY_SIZE]; - int d= s->sample_array[(idx + 9*channels)%SAMPLE_ARRAY_SIZE]; - int score= a-d; - if(hsample_array[idx]; + int b= s->sample_array[(idx + 4*channels)%SAMPLE_ARRAY_SIZE]; + int c= s->sample_array[(idx + 5*channels)%SAMPLE_ARRAY_SIZE]; + int d= s->sample_array[(idx + 9*channels)%SAMPLE_ARRAY_SIZE]; + int score= a-d; + if(hlast_i_start = i_start; } else { @@ -826,56 +874,52 @@ static void video_audio_display(VideoState *s) bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00); if(s->show_audio==1){ - fill_rectangle(screen, - s->xleft, s->ytop, s->width, s->height, - bgcolor); - - fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff); - - /* total height for one channel */ - h = s->height / nb_display_channels; - /* graph height / 2 */ - h2 = (h * 9) / 20; - for(ch = 0;ch < nb_display_channels; ch++) { - i = i_start + ch; - y1 = s->ytop + ch * h + (h / 2); /* position of center line */ - for(x = 0; x < s->width; x++) { - y = (s->sample_array[i] * h2) >> 15; - if (y < 0) { - y = -y; - ys = y1 - y; - } else { - ys = y1; + fill_rectangle(screen, + s->xleft, s->ytop, s->width, s->height, + bgcolor); + + fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff); + + /* total height for one channel */ + h = s->height / nb_display_channels; + /* graph height / 2 */ + h2 = (h * 9) / 20; + for(ch = 0;ch < nb_display_channels; ch++) { + i = i_start + ch; + y1 = s->ytop + ch * h + (h / 2); /* position of center line */ + for(x = 0; x < s->width; x++) { + y = (s->sample_array[i] * h2) >> 15; + if (y < 0) { + y = -y; + ys = y1 - y; + } else { + ys = y1; + } + fill_rectangle(screen, + s->xleft + x, ys, 1, y, + fgcolor); + i += channels; + if (i >= SAMPLE_ARRAY_SIZE) + i -= SAMPLE_ARRAY_SIZE; } - fill_rectangle(screen, - s->xleft + x, ys, 1, y, - fgcolor); - i += channels; - if (i >= SAMPLE_ARRAY_SIZE) - i -= SAMPLE_ARRAY_SIZE; } - } - fgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff); + fgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff); - for(ch = 1;ch < nb_display_channels; ch++) { - y = s->ytop + ch * h; - fill_rectangle(screen, - s->xleft, y, s->width, 1, - fgcolor); - } - SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height); + for(ch = 1;ch < nb_display_channels; ch++) { + y = s->ytop + ch * h; + fill_rectangle(screen, + s->xleft, y, s->width, 1, + fgcolor); + } + SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height); }else{ - int rdft_bits, nb_freq; nb_display_channels= FFMIN(nb_display_channels, 2); - for(rdft_bits=1; (1<height; rdft_bits++) - ; if(rdft_bits != s->rdft_bits){ - ff_rdft_end(&s->rdft); - ff_rdft_init(&s->rdft, rdft_bits, RDFT); + av_rdft_end(s->rdft); + s->rdft = av_rdft_init(rdft_bits, DFT_R2C); s->rdft_bits= rdft_bits; } - nb_freq= 1<<(rdft_bits-1); { FFTSample data[2][2*nb_freq]; for(ch = 0;ch < nb_display_channels; ch++) { @@ -887,7 +931,7 @@ static void video_audio_display(VideoState *s) if (i >= SAMPLE_ARRAY_SIZE) i -= SAMPLE_ARRAY_SIZE; } - ff_rdft_calc(&s->rdft, data[ch]); + av_rdft_calc(s->rdft, data[ch]); } //least efficient way to do this, we should of course directly access it but its more than fast enough for(y=0; yheight; y++){ @@ -923,13 +967,23 @@ static int video_open(VideoState *is){ } else if(!is_full_screen && screen_width){ w = screen_width; h = screen_height; +#if CONFIG_AVFILTER + }else if (is->out_video_filter && is->out_video_filter->inputs[0]){ + w = is->out_video_filter->inputs[0]->w; + h = is->out_video_filter->inputs[0]->h; +#else }else if (is->video_st && is->video_st->codec->width){ w = is->video_st->codec->width; h = is->video_st->codec->height; +#endif } else { w = 640; h = 480; } + if(screen && is->width == screen->w && screen->w == w + && is->height== screen->h && screen->h == h) + return 0; + #ifndef __APPLE__ screen = SDL_SetVideoMode(w, h, 0, flags); #else @@ -940,7 +994,9 @@ static int video_open(VideoState *is){ fprintf(stderr, "SDL: could not set video mode - exiting\n"); return -1; } - SDL_WM_SetCaption("FFplay", "FFplay"); + if (!window_title) + window_title = input_filename; + SDL_WM_SetCaption(window_title, window_title); is->width = screen->w; is->height = screen->h; @@ -959,20 +1015,20 @@ static void video_display(VideoState *is) video_image_display(is); } -static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque) +static int refresh_thread(void *opaque) { + VideoState *is= opaque; + while(!is->abort_request){ SDL_Event event; event.type = FF_REFRESH_EVENT; event.user.data1 = opaque; + if(!is->refresh){ + is->refresh=1; SDL_PushEvent(&event); - return 0; /* 0 means stop timer */ -} - -/* schedule a video refresh in 'delay' ms */ -static SDL_TimerID schedule_refresh(VideoState *is, int delay) -{ - if(!delay) delay=1; //SDL seems to be buggy when the delay is 0 - return SDL_AddTimer(delay, sdl_refresh_timer_cb, is); + } + usleep(is->audio_st && is->show_audio ? rdftspeed*1000 : 5000); //FIXME ideally we should wait the correct time but SDLs event passing is so slow it would be silly + } + return 0; } /* get the current audio clock value */ @@ -1057,9 +1113,9 @@ static void stream_pause(VideoState *is) is->paused = !is->paused; } -static double compute_frame_delay(double frame_current_pts, VideoState *is) +static double compute_target_time(double frame_current_pts, VideoState *is) { - double actual_delay, delay, sync_threshold, ref_clock, diff; + double delay, sync_threshold, diff; /* compute nominal delay */ delay = frame_current_pts - is->frame_last_pts; @@ -1089,22 +1145,13 @@ static double compute_frame_delay(double frame_current_pts, VideoState *is) delay = 2 * delay; } } - is->frame_timer += delay; - /* compute the REAL delay (we need to do that to avoid - long term errors */ - actual_delay = is->frame_timer - (av_gettime() / 1000000.0); - if (actual_delay < 0.010) { - /* XXX: should skip picture */ - actual_delay = 0.010; - } - #if defined(DEBUG_SYNC) printf("video: delay=%0.3f actual_delay=%0.3f pts=%0.3f A-V=%f\n", delay, actual_delay, frame_current_pts, -diff); #endif - return actual_delay; + return is->frame_timer; } /* called to display each frame */ @@ -1116,16 +1163,42 @@ static void video_refresh_timer(void *opaque) SubPicture *sp, *sp2; if (is->video_st) { +retry: if (is->pictq_size == 0) { - fprintf(stderr, "Internal error detected in the SDL timer\n"); + //nothing to do, no picture to display in the que } else { + double time= av_gettime()/1000000.0; + double next_target; /* dequeue the picture */ vp = &is->pictq[is->pictq_rindex]; + if(time < vp->target_clock) + return; /* update current video pts */ is->video_current_pts = vp->pts; - is->video_current_pts_drift = is->video_current_pts - av_gettime() / 1000000.0; + is->video_current_pts_drift = is->video_current_pts - time; is->video_current_pos = vp->pos; + if(is->pictq_size > 1){ + VideoPicture *nextvp= &is->pictq[(is->pictq_rindex+1)%VIDEO_PICTURE_QUEUE_SIZE]; + assert(nextvp->target_clock >= vp->target_clock); + next_target= nextvp->target_clock; + }else{ + next_target= vp->target_clock + is->video_clock - vp->pts; //FIXME pass durations cleanly + } + if(framedrop && time > next_target){ + is->skip_frames *= 1.0 + FRAME_SKIP_FACTOR; + if(is->pictq_size > 1 || time > next_target + 0.5){ + /* update queue size and signal for next picture */ + if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE) + is->pictq_rindex = 0; + + SDL_LockMutex(is->pictq_mutex); + is->pictq_size--; + SDL_CondSignal(is->pictq_cond); + SDL_UnlockMutex(is->pictq_mutex); + goto retry; + } + } if(is->subtitle_st) { if (is->subtitle_stream_changed) { @@ -1179,7 +1252,6 @@ static void video_refresh_timer(void *opaque) is->pictq_rindex = 0; SDL_LockMutex(is->pictq_mutex); - vp->timer_id= 0; is->pictq_size--; SDL_CondSignal(is->pictq_cond); SDL_UnlockMutex(is->pictq_mutex); @@ -1187,15 +1259,11 @@ static void video_refresh_timer(void *opaque) } else if (is->audio_st) { /* draw the next audio frame */ - schedule_refresh(is, 40); - /* if only audio stream, then display the audio bars (better than nothing, just to test the implementation */ /* display picture */ video_display(is); - } else { - schedule_refresh(is, 100); } if (show_status) { static int64_t last_time; @@ -1217,8 +1285,8 @@ static void video_refresh_timer(void *opaque) 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=%Ld/%Ld \r", - get_master_clock(is), av_diff, aqsize / 1024, vqsize / 1024, sqsize, is->faulty_dts, is->faulty_pts); + printf("%7.2f A-V:%7.3f s:%3.1f aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64" \r", + get_master_clock(is), av_diff, FFMAX(is->skip_frames-1, 0), aqsize / 1024, vqsize / 1024, sqsize, is->faulty_dts, is->faulty_pts); fflush(stdout); last_time = cur_time; } @@ -1237,12 +1305,23 @@ static void alloc_picture(void *opaque) if (vp->bmp) SDL_FreeYUVOverlay(vp->bmp); - vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec->width, - is->video_st->codec->height, +#if CONFIG_AVFILTER + if (vp->picref) + avfilter_unref_pic(vp->picref); + vp->picref = NULL; + + vp->width = is->out_video_filter->inputs[0]->w; + vp->height = is->out_video_filter->inputs[0]->h; + vp->pix_fmt = is->out_video_filter->inputs[0]->format; +#else + vp->width = is->video_st->codec->width; + vp->height = is->video_st->codec->height; + vp->pix_fmt = is->video_st->codec->pix_fmt; +#endif + + vp->bmp = SDL_CreateYUVOverlay(vp->width, vp->height, SDL_YV12_OVERLAY, screen); - vp->width = is->video_st->codec->width; - vp->height = is->video_st->codec->height; SDL_LockMutex(is->pictq_mutex); vp->allocated = 1; @@ -1258,9 +1337,15 @@ static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, int64_t { VideoPicture *vp; int dst_pix_fmt; - +#if CONFIG_AVFILTER + AVPicture pict_src; +#endif /* wait until we have space to put a new picture */ SDL_LockMutex(is->pictq_mutex); + + if(is->pictq_size>=VIDEO_PICTURE_QUEUE_SIZE && !is->refresh) + is->skip_frames= FFMAX(1.0 - FRAME_SKIP_FACTOR, is->skip_frames * (1.0-FRAME_SKIP_FACTOR)); + while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE && !is->videoq.abort_request) { SDL_CondWait(is->pictq_cond, is->pictq_mutex); @@ -1274,8 +1359,13 @@ static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, int64_t /* alloc or resize hardware picture buffer */ if (!vp->bmp || +#if CONFIG_AVFILTER + vp->width != is->out_video_filter->inputs[0]->w || + vp->height != is->out_video_filter->inputs[0]->h) { +#else vp->width != is->video_st->codec->width || vp->height != is->video_st->codec->height) { +#endif SDL_Event event; vp->allocated = 0; @@ -1300,6 +1390,11 @@ static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, int64_t /* if the frame is not skipped, then display it */ if (vp->bmp) { AVPicture pict; +#if CONFIG_AVFILTER + if(vp->picref) + avfilter_unref_pic(vp->picref); + vp->picref = src_frame->opaque; +#endif /* get a pointer on the bitmap */ SDL_LockYUVOverlay (vp->bmp); @@ -1313,18 +1408,31 @@ static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, int64_t pict.linesize[0] = vp->bmp->pitches[0]; pict.linesize[1] = vp->bmp->pitches[2]; pict.linesize[2] = vp->bmp->pitches[1]; + +#if CONFIG_AVFILTER + pict_src.data[0] = src_frame->data[0]; + pict_src.data[1] = src_frame->data[1]; + pict_src.data[2] = src_frame->data[2]; + + pict_src.linesize[0] = src_frame->linesize[0]; + pict_src.linesize[1] = src_frame->linesize[1]; + pict_src.linesize[2] = src_frame->linesize[2]; + + //FIXME use direct rendering + av_picture_copy(&pict, &pict_src, + vp->pix_fmt, vp->width, vp->height); +#else sws_flags = av_get_int(sws_opts, "sws_flags", NULL); is->img_convert_ctx = sws_getCachedContext(is->img_convert_ctx, - is->video_st->codec->width, is->video_st->codec->height, - is->video_st->codec->pix_fmt, - is->video_st->codec->width, is->video_st->codec->height, + vp->width, vp->height, vp->pix_fmt, vp->width, vp->height, dst_pix_fmt, sws_flags, NULL, NULL, NULL); if (is->img_convert_ctx == NULL) { fprintf(stderr, "Cannot initialize the conversion context\n"); exit(1); } sws_scale(is->img_convert_ctx, src_frame->data, src_frame->linesize, - 0, is->video_st->codec->height, pict.data, pict.linesize); + 0, vp->height, pict.data, pict.linesize); +#endif /* update the bitmap content */ SDL_UnlockYUVOverlay(vp->bmp); @@ -1335,9 +1443,9 @@ static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, int64_t if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE) is->pictq_windex = 0; SDL_LockMutex(is->pictq_mutex); + vp->target_clock= compute_target_time(vp->pts, is); + is->pictq_size++; - //We must schedule in a mutex as we must store the timer id before the timer dies or might end up freeing a alraedy freed id - vp->timer_id= schedule_refresh(is, (int)(compute_frame_delay(vp->pts, is) * 1000 + 0.5)); SDL_UnlockMutex(is->pictq_mutex); } return 0; @@ -1367,35 +1475,18 @@ static int output_picture2(VideoState *is, AVFrame *src_frame, double pts1, int6 is->video_clock += frame_delay; #if defined(DEBUG_SYNC) && 0 - { - int ftype; - if (src_frame->pict_type == FF_B_TYPE) - ftype = 'B'; - else if (src_frame->pict_type == FF_I_TYPE) - ftype = 'I'; - else - ftype = 'P'; - printf("frame_type=%c clock=%0.3f pts=%0.3f\n", - ftype, pts, pts1); - } + printf("frame_type=%c clock=%0.3f pts=%0.3f\n", + av_get_pict_type_char(src_frame->pict_type), pts, pts1); #endif return queue_picture(is, src_frame, pts, pos); } -static int video_thread(void *arg) +static int get_video_frame(VideoState *is, AVFrame *frame, int64_t *pts, AVPacket *pkt) { - VideoState *is = arg; - AVPacket pkt1, *pkt = &pkt1; int len1, got_picture, i; - AVFrame *frame= avcodec_alloc_frame(); - double pts; - for(;;) { - while (is->paused && !is->videoq.abort_request) { - SDL_Delay(10); - } if (packet_queue_get(&is->videoq, pkt, 1) < 0) - break; + return -1; if(pkt->data == flush_pkt.data){ avcodec_flush_buffers(is->video_st->codec); @@ -1403,11 +1494,7 @@ static int video_thread(void *arg) SDL_LockMutex(is->pictq_mutex); //Make sure there are no long delay timers (ideally we should just flush the que but thats harder) for(i=0; ipictq[i].timer_id){ - SDL_RemoveTimer(is->pictq[i].timer_id); - is->pictq[i].timer_id=0; - schedule_refresh(is, 1); - } + is->pictq[i].target_clock= 0; } while (is->pictq_size && !is->videoq.abort_request) { SDL_CondWait(is->pictq_cond, is->pictq_mutex); @@ -1420,8 +1507,9 @@ static int video_thread(void *arg) is->frame_last_pts= AV_NOPTS_VALUE; is->frame_last_delay = 0; is->frame_timer = (double)av_gettime() / 1000000.0; - - continue; + is->skip_frames= 1; + is->skip_frames_index= 0; + return 0; } /* NOTE: ipts is the PTS of the _first_ picture beginning in @@ -1446,25 +1534,338 @@ static int video_thread(void *arg) || (decoder_reorder_pts && is->faulty_ptsfaulty_dts) || pkt->dts == AV_NOPTS_VALUE) && frame->reordered_opaque != AV_NOPTS_VALUE) - pts= frame->reordered_opaque; + *pts= frame->reordered_opaque; else if(pkt->dts != AV_NOPTS_VALUE) - pts= pkt->dts; + *pts= pkt->dts; else - pts= 0; - pts *= av_q2d(is->video_st->time_base); + *pts= 0; // if (len1 < 0) // break; - if (got_picture) { - if (output_picture2(is, frame, pts, pkt->pos) < 0) - goto the_end; + if (got_picture){ + is->skip_frames_index += 1; + if(is->skip_frames_index >= is->skip_frames){ + is->skip_frames_index -= FFMAX(is->skip_frames, 1.0); + return 1; } - av_free_packet(pkt); + + } + return 0; +} + +#if CONFIG_AVFILTER +typedef struct { + VideoState *is; + AVFrame *frame; + int use_dr1; +} FilterPriv; + +static int input_get_buffer(AVCodecContext *codec, AVFrame *pic) +{ + AVFilterContext *ctx = codec->opaque; + AVFilterPicRef *ref; + int perms = AV_PERM_WRITE; + int i, w, h, stride[4]; + unsigned edge; + + if(pic->buffer_hints & FF_BUFFER_HINTS_VALID) { + if(pic->buffer_hints & FF_BUFFER_HINTS_READABLE) perms |= AV_PERM_READ; + if(pic->buffer_hints & FF_BUFFER_HINTS_PRESERVE) perms |= AV_PERM_PRESERVE; + if(pic->buffer_hints & FF_BUFFER_HINTS_REUSABLE) perms |= AV_PERM_REUSE2; + } + if(pic->reference) perms |= AV_PERM_READ | AV_PERM_PRESERVE; + + w = codec->width; + h = codec->height; + avcodec_align_dimensions2(codec, &w, &h, stride); + edge = codec->flags & CODEC_FLAG_EMU_EDGE ? 0 : avcodec_get_edge_width(); + w += edge << 1; + h += edge << 1; + + if(!(ref = avfilter_get_video_buffer(ctx->outputs[0], perms, w, h))) + return -1; + + ref->w = codec->width; + ref->h = codec->height; + for(i = 0; i < 3; i ++) { + unsigned hshift = i == 0 ? 0 : av_pix_fmt_descriptors[ref->pic->format].log2_chroma_w; + unsigned vshift = i == 0 ? 0 : av_pix_fmt_descriptors[ref->pic->format].log2_chroma_h; + + if (ref->data[i]) { + ref->data[i] += (edge >> hshift) + ((edge * ref->linesize[i]) >> vshift); + } + pic->data[i] = ref->data[i]; + pic->linesize[i] = ref->linesize[i]; + } + pic->opaque = ref; + pic->age = INT_MAX; + pic->type = FF_BUFFER_TYPE_USER; + return 0; +} + +static void input_release_buffer(AVCodecContext *codec, AVFrame *pic) +{ + memset(pic->data, 0, sizeof(pic->data)); + avfilter_unref_pic(pic->opaque); +} + +static int input_reget_buffer(AVCodecContext *codec, AVFrame *pic) +{ + AVFilterPicRef *ref = pic->opaque; + + if (pic->data[0] == NULL) { + pic->buffer_hints |= FF_BUFFER_HINTS_READABLE; + return codec->get_buffer(codec, pic); + } + + if ((codec->width != ref->w) || (codec->height != ref->h) || + (codec->pix_fmt != ref->pic->format)) { + av_log(codec, AV_LOG_ERROR, "Picture properties changed.\n"); + return -1; + } + + pic->reordered_opaque = codec->reordered_opaque; + return 0; +} + +static int input_init(AVFilterContext *ctx, const char *args, void *opaque) +{ + FilterPriv *priv = ctx->priv; + AVCodecContext *codec; + if(!opaque) return -1; + + priv->is = opaque; + codec = priv->is->video_st->codec; + codec->opaque = ctx; + if(codec->codec->capabilities & CODEC_CAP_DR1) { + priv->use_dr1 = 1; + codec->get_buffer = input_get_buffer; + codec->release_buffer = input_release_buffer; + codec->reget_buffer = input_reget_buffer; + } + + priv->frame = avcodec_alloc_frame(); + + return 0; +} + +static void input_uninit(AVFilterContext *ctx) +{ + FilterPriv *priv = ctx->priv; + av_free(priv->frame); +} + +static int input_request_frame(AVFilterLink *link) +{ + FilterPriv *priv = link->src->priv; + AVFilterPicRef *picref; + int64_t pts = 0; + AVPacket pkt; + int ret; + + while (!(ret = get_video_frame(priv->is, priv->frame, &pts, &pkt))) + av_free_packet(&pkt); + if (ret < 0) + return -1; + + if(priv->use_dr1) { + picref = avfilter_ref_pic(priv->frame->opaque, ~0); + } else { + picref = avfilter_get_video_buffer(link, AV_PERM_WRITE, link->w, link->h); + av_picture_copy((AVPicture *)&picref->data, (AVPicture *)priv->frame, + picref->pic->format, link->w, link->h); + } + av_free_packet(&pkt); + + picref->pts = pts; + picref->pos = pkt.pos; + picref->pixel_aspect = priv->is->video_st->codec->sample_aspect_ratio; + avfilter_start_frame(link, picref); + avfilter_draw_slice(link, 0, link->h, 1); + avfilter_end_frame(link); + + return 0; +} + +static int input_query_formats(AVFilterContext *ctx) +{ + FilterPriv *priv = ctx->priv; + enum PixelFormat pix_fmts[] = { + priv->is->video_st->codec->pix_fmt, PIX_FMT_NONE + }; + + avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts)); + return 0; +} + +static int input_config_props(AVFilterLink *link) +{ + FilterPriv *priv = link->src->priv; + AVCodecContext *c = priv->is->video_st->codec; + + link->w = c->width; + link->h = c->height; + + return 0; +} + +static AVFilter input_filter = +{ + .name = "ffplay_input", + + .priv_size = sizeof(FilterPriv), + + .init = input_init, + .uninit = input_uninit, + + .query_formats = input_query_formats, + + .inputs = (AVFilterPad[]) {{ .name = NULL }}, + .outputs = (AVFilterPad[]) {{ .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .request_frame = input_request_frame, + .config_props = input_config_props, }, + { .name = NULL }}, +}; + +static void output_end_frame(AVFilterLink *link) +{ +} + +static int output_query_formats(AVFilterContext *ctx) +{ + enum PixelFormat pix_fmts[] = { PIX_FMT_YUV420P, PIX_FMT_NONE }; + + avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts)); + return 0; +} + +static int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame, + int64_t *pts, int64_t *pos) +{ + AVFilterPicRef *pic; + + if(avfilter_request_frame(ctx->inputs[0])) + return -1; + if(!(pic = ctx->inputs[0]->cur_pic)) + return -1; + ctx->inputs[0]->cur_pic = NULL; + + frame->opaque = pic; + *pts = pic->pts; + *pos = pic->pos; + + memcpy(frame->data, pic->data, sizeof(frame->data)); + memcpy(frame->linesize, pic->linesize, sizeof(frame->linesize)); + + return 1; +} + +static AVFilter output_filter = +{ + .name = "ffplay_output", + + .query_formats = output_query_formats, + + .inputs = (AVFilterPad[]) {{ .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .end_frame = output_end_frame, + .min_perms = AV_PERM_READ, }, + { .name = NULL }}, + .outputs = (AVFilterPad[]) {{ .name = NULL }}, +}; +#endif /* CONFIG_AVFILTER */ + +static int video_thread(void *arg) +{ + VideoState *is = arg; + AVFrame *frame= avcodec_alloc_frame(); + int64_t pts_int; + double pts; + int ret; + +#if CONFIG_AVFILTER + int64_t pos; + char sws_flags_str[128]; + AVFilterContext *filt_src = NULL, *filt_out = NULL; + AVFilterGraph *graph = av_mallocz(sizeof(AVFilterGraph)); + snprintf(sws_flags_str, sizeof(sws_flags_str), "flags=%d", sws_flags); + graph->scale_sws_opts = av_strdup(sws_flags_str); + + if(!(filt_src = avfilter_open(&input_filter, "src"))) goto the_end; + if(!(filt_out = avfilter_open(&output_filter, "out"))) goto the_end; + + if(avfilter_init_filter(filt_src, NULL, is)) goto the_end; + if(avfilter_init_filter(filt_out, NULL, frame)) goto the_end; + + + if(vfilters) { + AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut)); + AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut)); + + outputs->name = av_strdup("in"); + outputs->filter = filt_src; + outputs->pad_idx = 0; + outputs->next = NULL; + + inputs->name = av_strdup("out"); + inputs->filter = filt_out; + inputs->pad_idx = 0; + inputs->next = NULL; + + if (avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL) < 0) + goto the_end; + av_freep(&vfilters); + } else { + if(avfilter_link(filt_src, 0, filt_out, 0) < 0) goto the_end; + } + avfilter_graph_add_filter(graph, filt_src); + avfilter_graph_add_filter(graph, filt_out); + + if(avfilter_graph_check_validity(graph, NULL)) goto the_end; + if(avfilter_graph_config_formats(graph, NULL)) goto the_end; + if(avfilter_graph_config_links(graph, NULL)) goto the_end; + + is->out_video_filter = filt_out; +#endif + + for(;;) { +#if !CONFIG_AVFILTER + AVPacket pkt; +#endif + while (is->paused && !is->videoq.abort_request) + SDL_Delay(10); +#if CONFIG_AVFILTER + ret = get_filtered_video_frame(filt_out, frame, &pts_int, &pos); +#else + ret = get_video_frame(is, frame, &pts_int, &pkt); +#endif + + if (ret < 0) goto the_end; + + if (!ret) + continue; + + pts = pts_int*av_q2d(is->video_st->time_base); + +#if CONFIG_AVFILTER + ret = output_picture2(is, frame, pts, pos); +#else + ret = output_picture2(is, frame, pts, pkt.pos); + av_free_packet(&pkt); +#endif + if (ret < 0) + goto the_end; + if (step) if (cur_stream) stream_pause(cur_stream); } the_end: +#if CONFIG_AVFILTER + avfilter_graph_destroy(graph); + av_freep(&graph); +#endif av_free(frame); return 0; } @@ -1793,49 +2194,49 @@ static void sdl_audio_callback(void *opaque, Uint8 *stream, int len) static int stream_component_open(VideoState *is, int stream_index) { AVFormatContext *ic = is->ic; - AVCodecContext *enc; + AVCodecContext *avctx; AVCodec *codec; SDL_AudioSpec wanted_spec, spec; if (stream_index < 0 || stream_index >= ic->nb_streams) return -1; - enc = ic->streams[stream_index]->codec; + avctx = ic->streams[stream_index]->codec; /* prepare audio output */ - if (enc->codec_type == CODEC_TYPE_AUDIO) { - if (enc->channels > 0) { - enc->request_channels = FFMIN(2, enc->channels); + if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) { + if (avctx->channels > 0) { + avctx->request_channels = FFMIN(2, avctx->channels); } else { - enc->request_channels = 2; + avctx->request_channels = 2; } } - codec = avcodec_find_decoder(enc->codec_id); - enc->debug_mv = debug_mv; - enc->debug = debug; - enc->workaround_bugs = workaround_bugs; - enc->lowres = lowres; - if(lowres) enc->flags |= CODEC_FLAG_EMU_EDGE; - enc->idct_algo= idct; - if(fast) enc->flags2 |= CODEC_FLAG2_FAST; - enc->skip_frame= skip_frame; - enc->skip_idct= skip_idct; - enc->skip_loop_filter= skip_loop_filter; - enc->error_recognition= error_recognition; - enc->error_concealment= error_concealment; - avcodec_thread_init(enc, thread_count); + codec = avcodec_find_decoder(avctx->codec_id); + avctx->debug_mv = debug_mv; + avctx->debug = debug; + avctx->workaround_bugs = workaround_bugs; + avctx->lowres = lowres; + if(lowres) avctx->flags |= CODEC_FLAG_EMU_EDGE; + avctx->idct_algo= idct; + if(fast) avctx->flags2 |= CODEC_FLAG2_FAST; + avctx->skip_frame= skip_frame; + avctx->skip_idct= skip_idct; + avctx->skip_loop_filter= skip_loop_filter; + avctx->error_recognition= error_recognition; + avctx->error_concealment= error_concealment; + avcodec_thread_init(avctx, thread_count); - set_context_opts(enc, avcodec_opts[enc->codec_type], 0); + set_context_opts(avctx, avcodec_opts[avctx->codec_type], 0); if (!codec || - avcodec_open(enc, codec) < 0) + avcodec_open(avctx, codec) < 0) return -1; /* prepare audio output */ - if (enc->codec_type == CODEC_TYPE_AUDIO) { - wanted_spec.freq = enc->sample_rate; + if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) { + wanted_spec.freq = avctx->sample_rate; wanted_spec.format = AUDIO_S16SYS; - wanted_spec.channels = enc->channels; + wanted_spec.channels = avctx->channels; wanted_spec.silence = 0; wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE; wanted_spec.callback = sdl_audio_callback; @@ -1849,8 +2250,8 @@ static int stream_component_open(VideoState *is, int stream_index) } ic->streams[stream_index]->discard = AVDISCARD_DEFAULT; - switch(enc->codec_type) { - case CODEC_TYPE_AUDIO: + switch(avctx->codec_type) { + case AVMEDIA_TYPE_AUDIO: is->audio_stream = stream_index; is->audio_st = ic->streams[stream_index]; is->audio_buf_size = 0; @@ -1861,13 +2262,13 @@ static int stream_component_open(VideoState *is, int stream_index) is->audio_diff_avg_count = 0; /* since we do not have a precise anough audio fifo fullness, we correct audio sync only if larger than this threshold */ - is->audio_diff_threshold = 2.0 * SDL_AUDIO_BUFFER_SIZE / enc->sample_rate; + is->audio_diff_threshold = 2.0 * SDL_AUDIO_BUFFER_SIZE / avctx->sample_rate; memset(&is->audio_pkt, 0, sizeof(is->audio_pkt)); packet_queue_init(&is->audioq); SDL_PauseAudio(0); break; - case CODEC_TYPE_VIDEO: + case AVMEDIA_TYPE_VIDEO: is->video_stream = stream_index; is->video_st = ic->streams[stream_index]; @@ -1876,7 +2277,7 @@ static int stream_component_open(VideoState *is, int stream_index) packet_queue_init(&is->videoq); is->video_tid = SDL_CreateThread(video_thread, is); break; - case CODEC_TYPE_SUBTITLE: + case AVMEDIA_TYPE_SUBTITLE: is->subtitle_stream = stream_index; is->subtitle_st = ic->streams[stream_index]; packet_queue_init(&is->subtitleq); @@ -1892,14 +2293,14 @@ static int stream_component_open(VideoState *is, int stream_index) static void stream_component_close(VideoState *is, int stream_index) { AVFormatContext *ic = is->ic; - AVCodecContext *enc; + AVCodecContext *avctx; if (stream_index < 0 || stream_index >= ic->nb_streams) return; - enc = ic->streams[stream_index]->codec; + avctx = ic->streams[stream_index]->codec; - switch(enc->codec_type) { - case CODEC_TYPE_AUDIO: + switch(avctx->codec_type) { + case AVMEDIA_TYPE_AUDIO: packet_queue_abort(&is->audioq); SDL_CloseAudio(); @@ -1907,8 +2308,9 @@ static void stream_component_close(VideoState *is, int stream_index) packet_queue_end(&is->audioq); if (is->reformat_ctx) av_audio_convert_free(is->reformat_ctx); + is->reformat_ctx = NULL; break; - case CODEC_TYPE_VIDEO: + case AVMEDIA_TYPE_VIDEO: packet_queue_abort(&is->videoq); /* note: we also signal this mutex to make sure we deblock the @@ -1921,7 +2323,7 @@ static void stream_component_close(VideoState *is, int stream_index) packet_queue_end(&is->videoq); break; - case CODEC_TYPE_SUBTITLE: + case AVMEDIA_TYPE_SUBTITLE: packet_queue_abort(&is->subtitleq); /* note: we also signal this mutex to make sure we deblock the @@ -1941,17 +2343,17 @@ static void stream_component_close(VideoState *is, int stream_index) } ic->streams[stream_index]->discard = AVDISCARD_ALL; - avcodec_close(enc); - switch(enc->codec_type) { - case CODEC_TYPE_AUDIO: + avcodec_close(avctx); + switch(avctx->codec_type) { + case AVMEDIA_TYPE_AUDIO: is->audio_st = NULL; is->audio_stream = -1; break; - case CODEC_TYPE_VIDEO: + case AVMEDIA_TYPE_VIDEO: is->video_st = NULL; is->video_stream = -1; break; - case CODEC_TYPE_SUBTITLE: + case AVMEDIA_TYPE_SUBTITLE: is->subtitle_st = NULL; is->subtitle_stream = -1; break; @@ -1974,16 +2376,19 @@ static int decode_thread(void *arg) { VideoState *is = arg; AVFormatContext *ic; - int err, i, ret, video_index, audio_index, subtitle_index; + int err, i, ret; + int st_index[AVMEDIA_TYPE_NB]; + int st_count[AVMEDIA_TYPE_NB]={0}; + int st_best_packet_count[AVMEDIA_TYPE_NB]; AVPacket pkt1, *pkt = &pkt1; AVFormatParameters params, *ap = ¶ms; int eof=0; + int pkt_in_play_range = 0; ic = avformat_alloc_context(); - video_index = -1; - audio_index = -1; - subtitle_index = -1; + memset(st_index, -1, sizeof(st_index)); + memset(st_best_packet_count, -1, sizeof(st_best_packet_count)); is->video_stream = -1; is->audio_stream = -1; is->subtitle_stream = -1; @@ -2040,20 +2445,27 @@ static int decode_thread(void *arg) } for(i = 0; i < ic->nb_streams; i++) { - AVCodecContext *enc = ic->streams[i]->codec; + AVStream *st= ic->streams[i]; + AVCodecContext *avctx = st->codec; ic->streams[i]->discard = AVDISCARD_ALL; - switch(enc->codec_type) { - case CODEC_TYPE_AUDIO: - if (wanted_audio_stream-- >= 0 && !audio_disable) - audio_index = i; - break; - case CODEC_TYPE_VIDEO: - if (wanted_video_stream-- >= 0 && !video_disable) - video_index = i; + if(avctx->codec_type >= (unsigned)AVMEDIA_TYPE_NB) + continue; + if(st_count[avctx->codec_type]++ != wanted_stream[avctx->codec_type] && wanted_stream[avctx->codec_type] >= 0) + continue; + + if(st_best_packet_count[avctx->codec_type] >= st->codec_info_nb_frames) + continue; + st_best_packet_count[avctx->codec_type]= st->codec_info_nb_frames; + + switch(avctx->codec_type) { + case AVMEDIA_TYPE_AUDIO: + if (!audio_disable) + st_index[AVMEDIA_TYPE_AUDIO] = i; break; - case CODEC_TYPE_SUBTITLE: - if (wanted_subtitle_stream-- >= 0 && !video_disable) - subtitle_index = i; + case AVMEDIA_TYPE_VIDEO: + case AVMEDIA_TYPE_SUBTITLE: + if (!video_disable) + st_index[avctx->codec_type] = i; break; default: break; @@ -2064,22 +2476,22 @@ static int decode_thread(void *arg) } /* open the streams */ - if (audio_index >= 0) { - stream_component_open(is, audio_index); + if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) { + stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]); } - if (video_index >= 0) { - stream_component_open(is, video_index); - } else { - /* add the refresh timer to draw the picture */ - schedule_refresh(is, 40); - + ret=-1; + if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) { + ret= stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]); + } + is->refresh_tid = SDL_CreateThread(refresh_thread, is); + if(ret<0) { if (!display_disable) - is->show_audio = 1; + is->show_audio = 2; } - if (subtitle_index >= 0) { - stream_component_open(is, subtitle_index); + if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) { + stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]); } if (is->video_stream < 0 && is->audio_stream < 0) { @@ -2152,9 +2564,13 @@ static int decode_thread(void *arg) packet_queue_put(&is->videoq, pkt); } SDL_Delay(10); - if(autoexit && is->audioq.size + is->videoq.size + is->subtitleq.size ==0){ - ret=AVERROR_EOF; - goto fail; + if(is->audioq.size + is->videoq.size + is->subtitleq.size ==0){ + if(loop!=1 && (!loop || --loop)){ + stream_seek(cur_stream, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0); + }else if(autoexit){ + ret=AVERROR_EOF; + goto fail; + } } continue; } @@ -2167,11 +2583,17 @@ static int decode_thread(void *arg) SDL_Delay(100); /* wait for user event */ continue; } - if (pkt->stream_index == is->audio_stream) { + /* check if packet is in play range specified by user, then queue, otherwise discard */ + pkt_in_play_range = duration == AV_NOPTS_VALUE || + (pkt->pts - ic->streams[pkt->stream_index]->start_time) * + av_q2d(ic->streams[pkt->stream_index]->time_base) - + (double)(start_time != AV_NOPTS_VALUE ? start_time : 0)/1000000 + <= ((double)duration/1000000); + if (pkt->stream_index == is->audio_stream && pkt_in_play_range) { packet_queue_put(&is->audioq, pkt); - } else if (pkt->stream_index == is->video_stream) { + } else if (pkt->stream_index == is->video_stream && pkt_in_play_range) { packet_queue_put(&is->videoq, pkt); - } else if (pkt->stream_index == is->subtitle_stream) { + } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) { packet_queue_put(&is->subtitleq, pkt); } else { av_free_packet(pkt); @@ -2245,10 +2667,17 @@ static void stream_close(VideoState *is) /* XXX: use a special url_shutdown call to abort parse cleanly */ is->abort_request = 1; SDL_WaitThread(is->parse_tid, NULL); + SDL_WaitThread(is->refresh_tid, NULL); /* free all pictures */ for(i=0;ipictq[i]; +#if CONFIG_AVFILTER + if (vp->picref) { + avfilter_unref_pic(vp->picref); + vp->picref = NULL; + } +#endif if (vp->bmp) { SDL_FreeYUVOverlay(vp->bmp); vp->bmp = NULL; @@ -2258,8 +2687,10 @@ static void stream_close(VideoState *is) SDL_DestroyCond(is->pictq_cond); SDL_DestroyMutex(is->subpq_mutex); SDL_DestroyCond(is->subpq_cond); +#if !CONFIG_AVFILTER if (is->img_convert_ctx) sws_freeContext(is->img_convert_ctx); +#endif av_free(is); } @@ -2269,19 +2700,19 @@ static void stream_cycle_channel(VideoState *is, int codec_type) int start_index, stream_index; AVStream *st; - if (codec_type == CODEC_TYPE_VIDEO) + if (codec_type == AVMEDIA_TYPE_VIDEO) start_index = is->video_stream; - else if (codec_type == CODEC_TYPE_AUDIO) + else if (codec_type == AVMEDIA_TYPE_AUDIO) start_index = is->audio_stream; else start_index = is->subtitle_stream; - if (start_index < (codec_type == CODEC_TYPE_SUBTITLE ? -1 : 0)) + if (start_index < (codec_type == AVMEDIA_TYPE_SUBTITLE ? -1 : 0)) return; stream_index = start_index; for(;;) { if (++stream_index >= is->ic->nb_streams) { - if (codec_type == CODEC_TYPE_SUBTITLE) + if (codec_type == AVMEDIA_TYPE_SUBTITLE) { stream_index = -1; goto the_end; @@ -2294,13 +2725,13 @@ static void stream_cycle_channel(VideoState *is, int codec_type) if (st->codec->codec_type == codec_type) { /* check that parameters are OK */ switch(codec_type) { - case CODEC_TYPE_AUDIO: + case AVMEDIA_TYPE_AUDIO: if (st->codec->sample_rate != 0 && st->codec->channels != 0) goto the_end; break; - case CODEC_TYPE_VIDEO: - case CODEC_TYPE_SUBTITLE: + case AVMEDIA_TYPE_VIDEO: + case AVMEDIA_TYPE_SUBTITLE: goto the_end; default: break; @@ -2347,10 +2778,13 @@ static void do_exit(void) stream_close(cur_stream); cur_stream = NULL; } - for (i = 0; i < CODEC_TYPE_NB; i++) + for (i = 0; i < AVMEDIA_TYPE_NB; i++) av_free(avcodec_opts[i]); av_free(avformat_opts); av_free(sws_opts); +#if CONFIG_AVFILTER + avfilter_uninit(); +#endif if (show_status) printf("\n"); SDL_Quit(); @@ -2397,15 +2831,15 @@ static void event_loop(void) break; case SDLK_a: if (cur_stream) - stream_cycle_channel(cur_stream, CODEC_TYPE_AUDIO); + stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO); break; case SDLK_v: if (cur_stream) - stream_cycle_channel(cur_stream, CODEC_TYPE_VIDEO); + stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO); break; case SDLK_t: if (cur_stream) - stream_cycle_channel(cur_stream, CODEC_TYPE_SUBTITLE); + stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE); break; case SDLK_w: toggle_audio_display(); @@ -2500,6 +2934,7 @@ static void event_loop(void) break; case FF_REFRESH_EVENT: video_refresh_timer(event.user.data1); + cur_stream->refresh=0; break; default: break; @@ -2566,6 +3001,12 @@ static int opt_seek(const char *opt, const char *arg) return 0; } +static int opt_duration(const char *opt, const char *arg) +{ + duration = parse_time_or_die(opt, arg, 1); + return 0; +} + static int opt_debug(const char *opt, const char *arg) { av_log_set_level(99); @@ -2596,10 +3037,11 @@ static const OptionDef options[] = { { "fs", OPT_BOOL, {(void*)&is_full_screen}, "force full screen" }, { "an", OPT_BOOL, {(void*)&audio_disable}, "disable audio" }, { "vn", OPT_BOOL, {(void*)&video_disable}, "disable video" }, - { "ast", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_audio_stream}, "select desired audio stream", "stream_number" }, - { "vst", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_video_stream}, "select desired video stream", "stream_number" }, - { "sst", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_subtitle_stream}, "select desired subtitle stream", "stream_number" }, + { "ast", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_stream[AVMEDIA_TYPE_AUDIO]}, "select desired audio stream", "stream_number" }, + { "vst", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_stream[AVMEDIA_TYPE_VIDEO]}, "select desired video stream", "stream_number" }, + { "sst", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_stream[AVMEDIA_TYPE_SUBTITLE]}, "select desired subtitle stream", "stream_number" }, { "ss", HAS_ARG | OPT_FUNC2, {(void*)&opt_seek}, "seek to a given position in seconds", "pos" }, + { "t", HAS_ARG | OPT_FUNC2, {(void*)&opt_duration}, "play \"duration\" seconds of audio/video", "duration" }, { "bytes", OPT_INT | HAS_ARG, {(void*)&seek_by_bytes}, "seek by bytes 0=off 1=on -1=auto", "val" }, { "nodisp", OPT_BOOL, {(void*)&display_disable}, "disable graphical display" }, { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" }, @@ -2621,6 +3063,13 @@ static const OptionDef options[] = { { "sync", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_sync}, "set audio-video sync. type (type=audio/video/ext)", "type" }, { "threads", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" }, { "autoexit", OPT_BOOL | OPT_EXPERT, {(void*)&autoexit}, "exit at the end", "" }, + { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&loop}, "set number of times the playback shall be looped", "loop count" }, + { "framedrop", OPT_BOOL | OPT_EXPERT, {(void*)&framedrop}, "drop frames when cpu is too slow", "" }, + { "window_title", OPT_STRING | HAS_ARG, {(void*)&window_title}, "set window title", "window title" }, +#if CONFIG_AVFILTER + { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" }, +#endif + { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, {(void*)&rdftspeed}, "rdft speed", "msecs" }, { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" }, { NULL, }, }; @@ -2647,6 +3096,7 @@ static void show_help(void) "v cycle video channel\n" "t cycle subtitle channel\n" "w show audio waves\n" + "s activate frame-step mode\n" "left/right seek backward/forward 10 seconds\n" "down/up seek backward/forward 1 minute\n" "mouse click seek to percentage in file corresponding to fraction of width\n" @@ -2655,6 +3105,11 @@ static void show_help(void) static void opt_input_file(const char *filename) { + if (input_filename) { + fprintf(stderr, "Argument '%s' provided as input filename, but '%s' was already specified.\n", + filename, input_filename); + exit(1); + } if (!strcmp(filename, "-")) filename = "pipe:"; input_filename = filename; @@ -2667,14 +3122,21 @@ int main(int argc, char **argv) /* register all codecs, demux and protocols */ avcodec_register_all(); +#if CONFIG_AVDEVICE avdevice_register_all(); +#endif +#if CONFIG_AVFILTER + avfilter_register_all(); +#endif av_register_all(); - for(i=0; i