2 * Copyright (c) 2003 Fabrice Bellard
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * simple media player based on the FFmpeg libraries
33 #include "libavutil/avstring.h"
34 #include "libavutil/eval.h"
35 #include "libavutil/mathematics.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/imgutils.h"
38 #include "libavutil/dict.h"
39 #include "libavutil/parseutils.h"
40 #include "libavutil/samplefmt.h"
41 #include "libavutil/avassert.h"
42 #include "libavutil/time.h"
43 #include "libavutil/bprint.h"
44 #include "libavformat/avformat.h"
45 #include "libavdevice/avdevice.h"
46 #include "libswscale/swscale.h"
47 #include "libavutil/opt.h"
48 #include "libavcodec/avfft.h"
49 #include "libswresample/swresample.h"
52 # include "libavfilter/avfilter.h"
53 # include "libavfilter/buffersink.h"
54 # include "libavfilter/buffersrc.h"
58 #include <SDL_thread.h>
64 const char program_name[] = "ffplay";
65 const int program_birth_year = 2003;
67 #define MAX_QUEUE_SIZE (15 * 1024 * 1024)
69 #define EXTERNAL_CLOCK_MIN_FRAMES 2
70 #define EXTERNAL_CLOCK_MAX_FRAMES 10
72 /* Minimum SDL audio buffer size, in samples. */
73 #define SDL_AUDIO_MIN_BUFFER_SIZE 512
74 /* Calculate actual buffer size keeping in mind not cause too frequent audio callbacks */
75 #define SDL_AUDIO_MAX_CALLBACKS_PER_SEC 30
77 /* Step size for volume control in dB */
78 #define SDL_VOLUME_STEP (0.75)
80 /* no AV sync correction is done if below the minimum AV sync threshold */
81 #define AV_SYNC_THRESHOLD_MIN 0.04
82 /* AV sync correction is done if above the maximum AV sync threshold */
83 #define AV_SYNC_THRESHOLD_MAX 0.1
84 /* If a frame duration is longer than this, it will not be duplicated to compensate AV sync */
85 #define AV_SYNC_FRAMEDUP_THRESHOLD 0.1
86 /* no AV correction is done if too big error */
87 #define AV_NOSYNC_THRESHOLD 10.0
89 /* maximum audio speed change to get correct sync */
90 #define SAMPLE_CORRECTION_PERCENT_MAX 10
92 /* external clock speed adjustment constants for realtime sources based on buffer fullness */
93 #define EXTERNAL_CLOCK_SPEED_MIN 0.900
94 #define EXTERNAL_CLOCK_SPEED_MAX 1.010
95 #define EXTERNAL_CLOCK_SPEED_STEP 0.001
97 /* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
98 #define AUDIO_DIFF_AVG_NB 20
100 /* polls for possible required screen refresh at least this often, should be less than 1/fps */
101 #define REFRESH_RATE 0.01
103 /* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
104 /* TODO: We assume that a decoded and resampled frame fits into this buffer */
105 #define SAMPLE_ARRAY_SIZE (8 * 65536)
107 #define CURSOR_HIDE_DELAY 1000000
109 #define USE_ONEPASS_SUBTITLE_RENDER 1
111 static unsigned sws_flags = SWS_BICUBIC;
113 typedef struct MyAVPacketList {
115 struct MyAVPacketList *next;
119 typedef struct PacketQueue {
120 MyAVPacketList *first_pkt, *last_pkt;
130 #define VIDEO_PICTURE_QUEUE_SIZE 3
131 #define SUBPICTURE_QUEUE_SIZE 16
132 #define SAMPLE_QUEUE_SIZE 9
133 #define FRAME_QUEUE_SIZE FFMAX(SAMPLE_QUEUE_SIZE, FFMAX(VIDEO_PICTURE_QUEUE_SIZE, SUBPICTURE_QUEUE_SIZE))
135 typedef struct AudioParams {
138 int64_t channel_layout;
139 enum AVSampleFormat fmt;
144 typedef struct Clock {
145 double pts; /* clock base */
146 double pts_drift; /* clock base minus time at which we updated the clock */
149 int serial; /* clock is based on a packet with this serial */
151 int *queue_serial; /* pointer to the current packet queue serial, used for obsolete clock detection */
154 /* Common struct for handling all types of decoded data and allocated render buffers. */
155 typedef struct Frame {
159 double pts; /* presentation timestamp for the frame */
160 double duration; /* estimated duration of the frame */
161 int64_t pos; /* byte position of the frame in the input file */
170 typedef struct FrameQueue {
171 Frame queue[FRAME_QUEUE_SIZE];
184 AV_SYNC_AUDIO_MASTER, /* default choice */
185 AV_SYNC_VIDEO_MASTER,
186 AV_SYNC_EXTERNAL_CLOCK, /* synchronize to an external clock */
189 typedef struct Decoder {
192 AVCodecContext *avctx;
196 SDL_cond *empty_queue_cond;
198 AVRational start_pts_tb;
200 AVRational next_pts_tb;
201 SDL_Thread *decoder_tid;
204 typedef struct VideoState {
205 SDL_Thread *read_tid;
206 AVInputFormat *iformat;
211 int queue_attachments_req;
216 int read_pause_return;
237 int audio_clock_serial;
238 double audio_diff_cum; /* used for AV difference average computation */
239 double audio_diff_avg_coef;
240 double audio_diff_threshold;
241 int audio_diff_avg_count;
244 int audio_hw_buf_size;
247 unsigned int audio_buf_size; /* in bytes */
248 unsigned int audio_buf1_size;
249 int audio_buf_index; /* in bytes */
250 int audio_write_buf_size;
253 struct AudioParams audio_src;
255 struct AudioParams audio_filter_src;
257 struct AudioParams audio_tgt;
258 struct SwrContext *swr_ctx;
259 int frame_drops_early;
260 int frame_drops_late;
263 SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO = 0, SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB
265 int16_t sample_array[SAMPLE_ARRAY_SIZE];
266 int sample_array_index;
270 FFTSample *rdft_data;
272 double last_vis_time;
273 SDL_Texture *vis_texture;
274 SDL_Texture *sub_texture;
275 SDL_Texture *vid_texture;
278 AVStream *subtitle_st;
279 PacketQueue subtitleq;
282 double frame_last_returned_time;
283 double frame_last_filter_delay;
287 double max_frame_duration; // maximum duration of a frame - above this, we consider the jump a timestamp discontinuity
288 struct SwsContext *img_convert_ctx;
289 struct SwsContext *sub_convert_ctx;
293 int width, height, xleft, ytop;
298 AVFilterContext *in_video_filter; // the first filter in the video chain
299 AVFilterContext *out_video_filter; // the last filter in the video chain
300 AVFilterContext *in_audio_filter; // the first filter in the audio chain
301 AVFilterContext *out_audio_filter; // the last filter in the audio chain
302 AVFilterGraph *agraph; // audio filter graph
305 int last_video_stream, last_audio_stream, last_subtitle_stream;
307 SDL_cond *continue_read_thread;
310 /* options specified by the user */
311 static AVInputFormat *file_iformat;
312 static const char *input_filename;
313 static const char *window_title;
314 static int default_width = 640;
315 static int default_height = 480;
316 static int screen_width = 0;
317 static int screen_height = 0;
318 static int screen_left = SDL_WINDOWPOS_CENTERED;
319 static int screen_top = SDL_WINDOWPOS_CENTERED;
320 static int audio_disable;
321 static int video_disable;
322 static int subtitle_disable;
323 static const char* wanted_stream_spec[AVMEDIA_TYPE_NB] = {0};
324 static int seek_by_bytes = -1;
325 static float seek_interval = 10;
326 static int display_disable;
327 static int borderless;
328 static int alwaysontop;
329 static int startup_volume = 100;
330 static int show_status = -1;
331 static int av_sync_type = AV_SYNC_AUDIO_MASTER;
332 static int64_t start_time = AV_NOPTS_VALUE;
333 static int64_t duration = AV_NOPTS_VALUE;
335 static int genpts = 0;
336 static int lowres = 0;
337 static int decoder_reorder_pts = -1;
339 static int exit_on_keydown;
340 static int exit_on_mousedown;
342 static int framedrop = -1;
343 static int infinite_buffer = -1;
344 static enum ShowMode show_mode = SHOW_MODE_NONE;
345 static const char *audio_codec_name;
346 static const char *subtitle_codec_name;
347 static const char *video_codec_name;
348 double rdftspeed = 0.02;
349 static int64_t cursor_last_shown;
350 static int cursor_hidden = 0;
352 static const char **vfilters_list = NULL;
353 static int nb_vfilters = 0;
354 static char *afilters = NULL;
356 static int autorotate = 1;
357 static int find_stream_info = 1;
358 static int filter_nbthreads = 0;
360 /* current context */
361 static int is_full_screen;
362 static int64_t audio_callback_time;
364 #define FF_QUIT_EVENT (SDL_USEREVENT + 2)
366 static SDL_Window *window;
367 static SDL_Renderer *renderer;
368 static SDL_RendererInfo renderer_info = {0};
369 static SDL_AudioDeviceID audio_dev;
371 static const struct TextureFormatEntry {
372 enum AVPixelFormat format;
374 } sdl_texture_format_map[] = {
375 { AV_PIX_FMT_RGB8, SDL_PIXELFORMAT_RGB332 },
376 { AV_PIX_FMT_RGB444, SDL_PIXELFORMAT_RGB444 },
377 { AV_PIX_FMT_RGB555, SDL_PIXELFORMAT_RGB555 },
378 { AV_PIX_FMT_BGR555, SDL_PIXELFORMAT_BGR555 },
379 { AV_PIX_FMT_RGB565, SDL_PIXELFORMAT_RGB565 },
380 { AV_PIX_FMT_BGR565, SDL_PIXELFORMAT_BGR565 },
381 { AV_PIX_FMT_RGB24, SDL_PIXELFORMAT_RGB24 },
382 { AV_PIX_FMT_BGR24, SDL_PIXELFORMAT_BGR24 },
383 { AV_PIX_FMT_0RGB32, SDL_PIXELFORMAT_RGB888 },
384 { AV_PIX_FMT_0BGR32, SDL_PIXELFORMAT_BGR888 },
385 { AV_PIX_FMT_NE(RGB0, 0BGR), SDL_PIXELFORMAT_RGBX8888 },
386 { AV_PIX_FMT_NE(BGR0, 0RGB), SDL_PIXELFORMAT_BGRX8888 },
387 { AV_PIX_FMT_RGB32, SDL_PIXELFORMAT_ARGB8888 },
388 { AV_PIX_FMT_RGB32_1, SDL_PIXELFORMAT_RGBA8888 },
389 { AV_PIX_FMT_BGR32, SDL_PIXELFORMAT_ABGR8888 },
390 { AV_PIX_FMT_BGR32_1, SDL_PIXELFORMAT_BGRA8888 },
391 { AV_PIX_FMT_YUV420P, SDL_PIXELFORMAT_IYUV },
392 { AV_PIX_FMT_YUYV422, SDL_PIXELFORMAT_YUY2 },
393 { AV_PIX_FMT_UYVY422, SDL_PIXELFORMAT_UYVY },
394 { AV_PIX_FMT_NONE, SDL_PIXELFORMAT_UNKNOWN },
398 static int opt_add_vfilter(void *optctx, const char *opt, const char *arg)
400 GROW_ARRAY(vfilters_list, nb_vfilters);
401 vfilters_list[nb_vfilters - 1] = arg;
407 int cmp_audio_fmts(enum AVSampleFormat fmt1, int64_t channel_count1,
408 enum AVSampleFormat fmt2, int64_t channel_count2)
410 /* If channel count == 1, planar and non-planar formats are the same */
411 if (channel_count1 == 1 && channel_count2 == 1)
412 return av_get_packed_sample_fmt(fmt1) != av_get_packed_sample_fmt(fmt2);
414 return channel_count1 != channel_count2 || fmt1 != fmt2;
418 int64_t get_valid_channel_layout(int64_t channel_layout, int channels)
420 if (channel_layout && av_get_channel_layout_nb_channels(channel_layout) == channels)
421 return channel_layout;
426 static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
428 MyAVPacketList *pkt1;
430 if (q->abort_request)
433 pkt1 = av_malloc(sizeof(MyAVPacketList));
438 pkt1->serial = q->serial;
443 q->last_pkt->next = pkt1;
446 q->size += pkt1->pkt.size + sizeof(*pkt1);
447 q->duration += pkt1->pkt.duration;
448 /* XXX: should duplicate packet data in DV case */
449 SDL_CondSignal(q->cond);
453 static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
457 SDL_LockMutex(q->mutex);
458 ret = packet_queue_put_private(q, pkt);
459 SDL_UnlockMutex(q->mutex);
462 av_packet_unref(pkt);
467 static int packet_queue_put_nullpacket(PacketQueue *q, int stream_index)
469 AVPacket pkt1, *pkt = &pkt1;
473 pkt->stream_index = stream_index;
474 return packet_queue_put(q, pkt);
477 /* packet queue handling */
478 static int packet_queue_init(PacketQueue *q)
480 memset(q, 0, sizeof(PacketQueue));
481 q->mutex = SDL_CreateMutex();
483 av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
484 return AVERROR(ENOMEM);
486 q->cond = SDL_CreateCond();
488 av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
489 return AVERROR(ENOMEM);
491 q->abort_request = 1;
495 static void packet_queue_flush(PacketQueue *q)
497 MyAVPacketList *pkt, *pkt1;
499 SDL_LockMutex(q->mutex);
500 for (pkt = q->first_pkt; pkt; pkt = pkt1) {
502 av_packet_unref(&pkt->pkt);
511 SDL_UnlockMutex(q->mutex);
514 static void packet_queue_destroy(PacketQueue *q)
516 packet_queue_flush(q);
517 SDL_DestroyMutex(q->mutex);
518 SDL_DestroyCond(q->cond);
521 static void packet_queue_abort(PacketQueue *q)
523 SDL_LockMutex(q->mutex);
525 q->abort_request = 1;
527 SDL_CondSignal(q->cond);
529 SDL_UnlockMutex(q->mutex);
532 static void packet_queue_start(PacketQueue *q)
534 SDL_LockMutex(q->mutex);
535 q->abort_request = 0;
537 SDL_UnlockMutex(q->mutex);
540 /* return < 0 if aborted, 0 if no packet and > 0 if packet. */
541 static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)
543 MyAVPacketList *pkt1;
546 SDL_LockMutex(q->mutex);
549 if (q->abort_request) {
556 q->first_pkt = pkt1->next;
560 q->size -= pkt1->pkt.size + sizeof(*pkt1);
561 q->duration -= pkt1->pkt.duration;
564 *serial = pkt1->serial;
572 SDL_CondWait(q->cond, q->mutex);
575 SDL_UnlockMutex(q->mutex);
579 static void decoder_init(Decoder *d, AVCodecContext *avctx, PacketQueue *queue, SDL_cond *empty_queue_cond) {
580 memset(d, 0, sizeof(Decoder));
583 d->empty_queue_cond = empty_queue_cond;
584 d->start_pts = AV_NOPTS_VALUE;
588 static int decoder_decode_frame(Decoder *d, AVFrame *frame, AVSubtitle *sub) {
589 int ret = AVERROR(EAGAIN);
592 if (d->queue->serial == d->pkt_serial) {
594 if (d->queue->abort_request)
597 switch (d->avctx->codec_type) {
598 case AVMEDIA_TYPE_VIDEO:
599 ret = avcodec_receive_frame(d->avctx, frame);
601 if (decoder_reorder_pts == -1) {
602 frame->pts = frame->best_effort_timestamp;
603 } else if (!decoder_reorder_pts) {
604 frame->pts = frame->pkt_dts;
608 case AVMEDIA_TYPE_AUDIO:
609 ret = avcodec_receive_frame(d->avctx, frame);
611 AVRational tb = (AVRational){1, frame->sample_rate};
612 if (frame->pts != AV_NOPTS_VALUE)
613 frame->pts = av_rescale_q(frame->pts, d->avctx->pkt_timebase, tb);
614 else if (d->next_pts != AV_NOPTS_VALUE)
615 frame->pts = av_rescale_q(d->next_pts, d->next_pts_tb, tb);
616 if (frame->pts != AV_NOPTS_VALUE) {
617 d->next_pts = frame->pts + frame->nb_samples;
623 if (ret == AVERROR_EOF) {
624 d->finished = d->pkt_serial;
625 avcodec_flush_buffers(d->avctx);
630 } while (ret != AVERROR(EAGAIN));
634 if (d->queue->nb_packets == 0)
635 SDL_CondSignal(d->empty_queue_cond);
636 if (d->packet_pending) {
637 d->packet_pending = 0;
639 int old_serial = d->pkt_serial;
640 if (packet_queue_get(d->queue, &d->pkt, 1, &d->pkt_serial) < 0)
642 if (old_serial != d->pkt_serial) {
643 avcodec_flush_buffers(d->avctx);
645 d->next_pts = d->start_pts;
646 d->next_pts_tb = d->start_pts_tb;
649 if (d->queue->serial == d->pkt_serial)
651 av_packet_unref(&d->pkt);
655 if (d->avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
657 ret = avcodec_decode_subtitle2(d->avctx, sub, &got_frame, &d->pkt);
659 ret = AVERROR(EAGAIN);
661 if (got_frame && !d->pkt.data) {
662 d->packet_pending = 1;
664 ret = got_frame ? 0 : (d->pkt.data ? AVERROR(EAGAIN) : AVERROR_EOF);
666 av_packet_unref(&d->pkt);
668 if (avcodec_send_packet(d->avctx, &d->pkt) == AVERROR(EAGAIN)) {
669 av_log(d->avctx, AV_LOG_ERROR, "Receive_frame and send_packet both returned EAGAIN, which is an API violation.\n");
670 d->packet_pending = 1;
672 av_packet_unref(&d->pkt);
679 static void decoder_destroy(Decoder *d) {
680 av_packet_unref(&d->pkt);
681 avcodec_free_context(&d->avctx);
684 static void frame_queue_unref_item(Frame *vp)
686 av_frame_unref(vp->frame);
687 avsubtitle_free(&vp->sub);
690 static int frame_queue_init(FrameQueue *f, PacketQueue *pktq, int max_size, int keep_last)
693 memset(f, 0, sizeof(FrameQueue));
694 if (!(f->mutex = SDL_CreateMutex())) {
695 av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
696 return AVERROR(ENOMEM);
698 if (!(f->cond = SDL_CreateCond())) {
699 av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
700 return AVERROR(ENOMEM);
703 f->max_size = FFMIN(max_size, FRAME_QUEUE_SIZE);
704 f->keep_last = !!keep_last;
705 for (i = 0; i < f->max_size; i++)
706 if (!(f->queue[i].frame = av_frame_alloc()))
707 return AVERROR(ENOMEM);
711 static void frame_queue_destory(FrameQueue *f)
714 for (i = 0; i < f->max_size; i++) {
715 Frame *vp = &f->queue[i];
716 frame_queue_unref_item(vp);
717 av_frame_free(&vp->frame);
719 SDL_DestroyMutex(f->mutex);
720 SDL_DestroyCond(f->cond);
723 static void frame_queue_signal(FrameQueue *f)
725 SDL_LockMutex(f->mutex);
726 SDL_CondSignal(f->cond);
727 SDL_UnlockMutex(f->mutex);
730 static Frame *frame_queue_peek(FrameQueue *f)
732 return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
735 static Frame *frame_queue_peek_next(FrameQueue *f)
737 return &f->queue[(f->rindex + f->rindex_shown + 1) % f->max_size];
740 static Frame *frame_queue_peek_last(FrameQueue *f)
742 return &f->queue[f->rindex];
745 static Frame *frame_queue_peek_writable(FrameQueue *f)
747 /* wait until we have space to put a new frame */
748 SDL_LockMutex(f->mutex);
749 while (f->size >= f->max_size &&
750 !f->pktq->abort_request) {
751 SDL_CondWait(f->cond, f->mutex);
753 SDL_UnlockMutex(f->mutex);
755 if (f->pktq->abort_request)
758 return &f->queue[f->windex];
761 static Frame *frame_queue_peek_readable(FrameQueue *f)
763 /* wait until we have a readable a new frame */
764 SDL_LockMutex(f->mutex);
765 while (f->size - f->rindex_shown <= 0 &&
766 !f->pktq->abort_request) {
767 SDL_CondWait(f->cond, f->mutex);
769 SDL_UnlockMutex(f->mutex);
771 if (f->pktq->abort_request)
774 return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
777 static void frame_queue_push(FrameQueue *f)
779 if (++f->windex == f->max_size)
781 SDL_LockMutex(f->mutex);
783 SDL_CondSignal(f->cond);
784 SDL_UnlockMutex(f->mutex);
787 static void frame_queue_next(FrameQueue *f)
789 if (f->keep_last && !f->rindex_shown) {
793 frame_queue_unref_item(&f->queue[f->rindex]);
794 if (++f->rindex == f->max_size)
796 SDL_LockMutex(f->mutex);
798 SDL_CondSignal(f->cond);
799 SDL_UnlockMutex(f->mutex);
802 /* return the number of undisplayed frames in the queue */
803 static int frame_queue_nb_remaining(FrameQueue *f)
805 return f->size - f->rindex_shown;
808 /* return last shown position */
809 static int64_t frame_queue_last_pos(FrameQueue *f)
811 Frame *fp = &f->queue[f->rindex];
812 if (f->rindex_shown && fp->serial == f->pktq->serial)
818 static void decoder_abort(Decoder *d, FrameQueue *fq)
820 packet_queue_abort(d->queue);
821 frame_queue_signal(fq);
822 SDL_WaitThread(d->decoder_tid, NULL);
823 d->decoder_tid = NULL;
824 packet_queue_flush(d->queue);
827 static inline void fill_rectangle(int x, int y, int w, int h)
835 SDL_RenderFillRect(renderer, &rect);
838 static int realloc_texture(SDL_Texture **texture, Uint32 new_format, int new_width, int new_height, SDL_BlendMode blendmode, int init_texture)
842 if (!*texture || SDL_QueryTexture(*texture, &format, &access, &w, &h) < 0 || new_width != w || new_height != h || new_format != format) {
846 SDL_DestroyTexture(*texture);
847 if (!(*texture = SDL_CreateTexture(renderer, new_format, SDL_TEXTUREACCESS_STREAMING, new_width, new_height)))
849 if (SDL_SetTextureBlendMode(*texture, blendmode) < 0)
852 if (SDL_LockTexture(*texture, NULL, &pixels, &pitch) < 0)
854 memset(pixels, 0, pitch * new_height);
855 SDL_UnlockTexture(*texture);
857 av_log(NULL, AV_LOG_VERBOSE, "Created %dx%d texture with %s.\n", new_width, new_height, SDL_GetPixelFormatName(new_format));
862 static void calculate_display_rect(SDL_Rect *rect,
863 int scr_xleft, int scr_ytop, int scr_width, int scr_height,
864 int pic_width, int pic_height, AVRational pic_sar)
866 AVRational aspect_ratio = pic_sar;
867 int64_t width, height, x, y;
869 if (av_cmp_q(aspect_ratio, av_make_q(0, 1)) <= 0)
870 aspect_ratio = av_make_q(1, 1);
872 aspect_ratio = av_mul_q(aspect_ratio, av_make_q(pic_width, pic_height));
874 /* XXX: we suppose the screen has a 1.0 pixel ratio */
876 width = av_rescale(height, aspect_ratio.num, aspect_ratio.den) & ~1;
877 if (width > scr_width) {
879 height = av_rescale(width, aspect_ratio.den, aspect_ratio.num) & ~1;
881 x = (scr_width - width) / 2;
882 y = (scr_height - height) / 2;
883 rect->x = scr_xleft + x;
884 rect->y = scr_ytop + y;
885 rect->w = FFMAX((int)width, 1);
886 rect->h = FFMAX((int)height, 1);
889 static void get_sdl_pix_fmt_and_blendmode(int format, Uint32 *sdl_pix_fmt, SDL_BlendMode *sdl_blendmode)
892 *sdl_blendmode = SDL_BLENDMODE_NONE;
893 *sdl_pix_fmt = SDL_PIXELFORMAT_UNKNOWN;
894 if (format == AV_PIX_FMT_RGB32 ||
895 format == AV_PIX_FMT_RGB32_1 ||
896 format == AV_PIX_FMT_BGR32 ||
897 format == AV_PIX_FMT_BGR32_1)
898 *sdl_blendmode = SDL_BLENDMODE_BLEND;
899 for (i = 0; i < FF_ARRAY_ELEMS(sdl_texture_format_map) - 1; i++) {
900 if (format == sdl_texture_format_map[i].format) {
901 *sdl_pix_fmt = sdl_texture_format_map[i].texture_fmt;
907 static int upload_texture(SDL_Texture **tex, AVFrame *frame, struct SwsContext **img_convert_ctx) {
910 SDL_BlendMode sdl_blendmode;
911 get_sdl_pix_fmt_and_blendmode(frame->format, &sdl_pix_fmt, &sdl_blendmode);
912 if (realloc_texture(tex, sdl_pix_fmt == SDL_PIXELFORMAT_UNKNOWN ? SDL_PIXELFORMAT_ARGB8888 : sdl_pix_fmt, frame->width, frame->height, sdl_blendmode, 0) < 0)
914 switch (sdl_pix_fmt) {
915 case SDL_PIXELFORMAT_UNKNOWN:
916 /* This should only happen if we are not using avfilter... */
917 *img_convert_ctx = sws_getCachedContext(*img_convert_ctx,
918 frame->width, frame->height, frame->format, frame->width, frame->height,
919 AV_PIX_FMT_BGRA, sws_flags, NULL, NULL, NULL);
920 if (*img_convert_ctx != NULL) {
923 if (!SDL_LockTexture(*tex, NULL, (void **)pixels, pitch)) {
924 sws_scale(*img_convert_ctx, (const uint8_t * const *)frame->data, frame->linesize,
925 0, frame->height, pixels, pitch);
926 SDL_UnlockTexture(*tex);
929 av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
933 case SDL_PIXELFORMAT_IYUV:
934 if (frame->linesize[0] > 0 && frame->linesize[1] > 0 && frame->linesize[2] > 0) {
935 ret = SDL_UpdateYUVTexture(*tex, NULL, frame->data[0], frame->linesize[0],
936 frame->data[1], frame->linesize[1],
937 frame->data[2], frame->linesize[2]);
938 } else if (frame->linesize[0] < 0 && frame->linesize[1] < 0 && frame->linesize[2] < 0) {
939 ret = SDL_UpdateYUVTexture(*tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height - 1), -frame->linesize[0],
940 frame->data[1] + frame->linesize[1] * (AV_CEIL_RSHIFT(frame->height, 1) - 1), -frame->linesize[1],
941 frame->data[2] + frame->linesize[2] * (AV_CEIL_RSHIFT(frame->height, 1) - 1), -frame->linesize[2]);
943 av_log(NULL, AV_LOG_ERROR, "Mixed negative and positive linesizes are not supported.\n");
948 if (frame->linesize[0] < 0) {
949 ret = SDL_UpdateTexture(*tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height - 1), -frame->linesize[0]);
951 ret = SDL_UpdateTexture(*tex, NULL, frame->data[0], frame->linesize[0]);
958 static void set_sdl_yuv_conversion_mode(AVFrame *frame)
960 #if SDL_VERSION_ATLEAST(2,0,8)
961 SDL_YUV_CONVERSION_MODE mode = SDL_YUV_CONVERSION_AUTOMATIC;
962 if (frame && (frame->format == AV_PIX_FMT_YUV420P || frame->format == AV_PIX_FMT_YUYV422 || frame->format == AV_PIX_FMT_UYVY422)) {
963 if (frame->color_range == AVCOL_RANGE_JPEG)
964 mode = SDL_YUV_CONVERSION_JPEG;
965 else if (frame->colorspace == AVCOL_SPC_BT709)
966 mode = SDL_YUV_CONVERSION_BT709;
967 else if (frame->colorspace == AVCOL_SPC_BT470BG || frame->colorspace == AVCOL_SPC_SMPTE170M || frame->colorspace == AVCOL_SPC_SMPTE240M)
968 mode = SDL_YUV_CONVERSION_BT601;
970 SDL_SetYUVConversionMode(mode);
974 static void video_image_display(VideoState *is)
980 vp = frame_queue_peek_last(&is->pictq);
981 if (is->subtitle_st) {
982 if (frame_queue_nb_remaining(&is->subpq) > 0) {
983 sp = frame_queue_peek(&is->subpq);
985 if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {
990 if (!sp->width || !sp->height) {
991 sp->width = vp->width;
992 sp->height = vp->height;
994 if (realloc_texture(&is->sub_texture, SDL_PIXELFORMAT_ARGB8888, sp->width, sp->height, SDL_BLENDMODE_BLEND, 1) < 0)
997 for (i = 0; i < sp->sub.num_rects; i++) {
998 AVSubtitleRect *sub_rect = sp->sub.rects[i];
1000 sub_rect->x = av_clip(sub_rect->x, 0, sp->width );
1001 sub_rect->y = av_clip(sub_rect->y, 0, sp->height);
1002 sub_rect->w = av_clip(sub_rect->w, 0, sp->width - sub_rect->x);
1003 sub_rect->h = av_clip(sub_rect->h, 0, sp->height - sub_rect->y);
1005 is->sub_convert_ctx = sws_getCachedContext(is->sub_convert_ctx,
1006 sub_rect->w, sub_rect->h, AV_PIX_FMT_PAL8,
1007 sub_rect->w, sub_rect->h, AV_PIX_FMT_BGRA,
1008 0, NULL, NULL, NULL);
1009 if (!is->sub_convert_ctx) {
1010 av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
1013 if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)pixels, pitch)) {
1014 sws_scale(is->sub_convert_ctx, (const uint8_t * const *)sub_rect->data, sub_rect->linesize,
1015 0, sub_rect->h, pixels, pitch);
1016 SDL_UnlockTexture(is->sub_texture);
1026 calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp->width, vp->height, vp->sar);
1028 if (!vp->uploaded) {
1029 if (upload_texture(&is->vid_texture, vp->frame, &is->img_convert_ctx) < 0)
1032 vp->flip_v = vp->frame->linesize[0] < 0;
1035 set_sdl_yuv_conversion_mode(vp->frame);
1036 SDL_RenderCopyEx(renderer, is->vid_texture, NULL, &rect, 0, NULL, vp->flip_v ? SDL_FLIP_VERTICAL : 0);
1037 set_sdl_yuv_conversion_mode(NULL);
1039 #if USE_ONEPASS_SUBTITLE_RENDER
1040 SDL_RenderCopy(renderer, is->sub_texture, NULL, &rect);
1043 double xratio = (double)rect.w / (double)sp->width;
1044 double yratio = (double)rect.h / (double)sp->height;
1045 for (i = 0; i < sp->sub.num_rects; i++) {
1046 SDL_Rect *sub_rect = (SDL_Rect*)sp->sub.rects[i];
1047 SDL_Rect target = {.x = rect.x + sub_rect->x * xratio,
1048 .y = rect.y + sub_rect->y * yratio,
1049 .w = sub_rect->w * xratio,
1050 .h = sub_rect->h * yratio};
1051 SDL_RenderCopy(renderer, is->sub_texture, sub_rect, &target);
1057 static inline int compute_mod(int a, int b)
1059 return a < 0 ? a%b + b : a%b;
1062 static void video_audio_display(VideoState *s)
1064 int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
1065 int ch, channels, h, h2;
1067 int rdft_bits, nb_freq;
1069 for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++)
1071 nb_freq = 1 << (rdft_bits - 1);
1073 /* compute display index : center on currently output samples */
1074 channels = s->audio_tgt.channels;
1075 nb_display_channels = channels;
1077 int data_used= s->show_mode == SHOW_MODE_WAVES ? s->width : (2*nb_freq);
1079 delay = s->audio_write_buf_size;
1082 /* to be more precise, we take into account the time spent since
1083 the last buffer computation */
1084 if (audio_callback_time) {
1085 time_diff = av_gettime_relative() - audio_callback_time;
1086 delay -= (time_diff * s->audio_tgt.freq) / 1000000;
1089 delay += 2 * data_used;
1090 if (delay < data_used)
1093 i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
1094 if (s->show_mode == SHOW_MODE_WAVES) {
1096 for (i = 0; i < 1000; i += channels) {
1097 int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
1098 int a = s->sample_array[idx];
1099 int b = s->sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];
1100 int c = s->sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];
1101 int d = s->sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];
1103 if (h < score && (b ^ c) < 0) {
1110 s->last_i_start = i_start;
1112 i_start = s->last_i_start;
1115 if (s->show_mode == SHOW_MODE_WAVES) {
1116 SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
1118 /* total height for one channel */
1119 h = s->height / nb_display_channels;
1120 /* graph height / 2 */
1122 for (ch = 0; ch < nb_display_channels; ch++) {
1124 y1 = s->ytop + ch * h + (h / 2); /* position of center line */
1125 for (x = 0; x < s->width; x++) {
1126 y = (s->sample_array[i] * h2) >> 15;
1133 fill_rectangle(s->xleft + x, ys, 1, y);
1135 if (i >= SAMPLE_ARRAY_SIZE)
1136 i -= SAMPLE_ARRAY_SIZE;
1140 SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255);
1142 for (ch = 1; ch < nb_display_channels; ch++) {
1143 y = s->ytop + ch * h;
1144 fill_rectangle(s->xleft, y, s->width, 1);
1147 if (realloc_texture(&s->vis_texture, SDL_PIXELFORMAT_ARGB8888, s->width, s->height, SDL_BLENDMODE_NONE, 1) < 0)
1150 nb_display_channels= FFMIN(nb_display_channels, 2);
1151 if (rdft_bits != s->rdft_bits) {
1152 av_rdft_end(s->rdft);
1153 av_free(s->rdft_data);
1154 s->rdft = av_rdft_init(rdft_bits, DFT_R2C);
1155 s->rdft_bits = rdft_bits;
1156 s->rdft_data = av_malloc_array(nb_freq, 4 *sizeof(*s->rdft_data));
1158 if (!s->rdft || !s->rdft_data){
1159 av_log(NULL, AV_LOG_ERROR, "Failed to allocate buffers for RDFT, switching to waves display\n");
1160 s->show_mode = SHOW_MODE_WAVES;
1163 SDL_Rect rect = {.x = s->xpos, .y = 0, .w = 1, .h = s->height};
1166 for (ch = 0; ch < nb_display_channels; ch++) {
1167 data[ch] = s->rdft_data + 2 * nb_freq * ch;
1169 for (x = 0; x < 2 * nb_freq; x++) {
1170 double w = (x-nb_freq) * (1.0 / nb_freq);
1171 data[ch][x] = s->sample_array[i] * (1.0 - w * w);
1173 if (i >= SAMPLE_ARRAY_SIZE)
1174 i -= SAMPLE_ARRAY_SIZE;
1176 av_rdft_calc(s->rdft, data[ch]);
1178 /* Least efficient way to do this, we should of course
1179 * directly access it but it is more than fast enough. */
1180 if (!SDL_LockTexture(s->vis_texture, &rect, (void **)&pixels, &pitch)) {
1182 pixels += pitch * s->height;
1183 for (y = 0; y < s->height; y++) {
1184 double w = 1 / sqrt(nb_freq);
1185 int a = sqrt(w * sqrt(data[0][2 * y + 0] * data[0][2 * y + 0] + data[0][2 * y + 1] * data[0][2 * y + 1]));
1186 int b = (nb_display_channels == 2 ) ? sqrt(w * hypot(data[1][2 * y + 0], data[1][2 * y + 1]))
1191 *pixels = (a << 16) + (b << 8) + ((a+b) >> 1);
1193 SDL_UnlockTexture(s->vis_texture);
1195 SDL_RenderCopy(renderer, s->vis_texture, NULL, NULL);
1199 if (s->xpos >= s->width)
1204 static void stream_component_close(VideoState *is, int stream_index)
1206 AVFormatContext *ic = is->ic;
1207 AVCodecParameters *codecpar;
1209 if (stream_index < 0 || stream_index >= ic->nb_streams)
1211 codecpar = ic->streams[stream_index]->codecpar;
1213 switch (codecpar->codec_type) {
1214 case AVMEDIA_TYPE_AUDIO:
1215 decoder_abort(&is->auddec, &is->sampq);
1216 SDL_CloseAudioDevice(audio_dev);
1217 decoder_destroy(&is->auddec);
1218 swr_free(&is->swr_ctx);
1219 av_freep(&is->audio_buf1);
1220 is->audio_buf1_size = 0;
1221 is->audio_buf = NULL;
1224 av_rdft_end(is->rdft);
1225 av_freep(&is->rdft_data);
1230 case AVMEDIA_TYPE_VIDEO:
1231 decoder_abort(&is->viddec, &is->pictq);
1232 decoder_destroy(&is->viddec);
1234 case AVMEDIA_TYPE_SUBTITLE:
1235 decoder_abort(&is->subdec, &is->subpq);
1236 decoder_destroy(&is->subdec);
1242 ic->streams[stream_index]->discard = AVDISCARD_ALL;
1243 switch (codecpar->codec_type) {
1244 case AVMEDIA_TYPE_AUDIO:
1245 is->audio_st = NULL;
1246 is->audio_stream = -1;
1248 case AVMEDIA_TYPE_VIDEO:
1249 is->video_st = NULL;
1250 is->video_stream = -1;
1252 case AVMEDIA_TYPE_SUBTITLE:
1253 is->subtitle_st = NULL;
1254 is->subtitle_stream = -1;
1261 static void stream_close(VideoState *is)
1263 /* XXX: use a special url_shutdown call to abort parse cleanly */
1264 is->abort_request = 1;
1265 SDL_WaitThread(is->read_tid, NULL);
1267 /* close each stream */
1268 if (is->audio_stream >= 0)
1269 stream_component_close(is, is->audio_stream);
1270 if (is->video_stream >= 0)
1271 stream_component_close(is, is->video_stream);
1272 if (is->subtitle_stream >= 0)
1273 stream_component_close(is, is->subtitle_stream);
1275 avformat_close_input(&is->ic);
1277 packet_queue_destroy(&is->videoq);
1278 packet_queue_destroy(&is->audioq);
1279 packet_queue_destroy(&is->subtitleq);
1281 /* free all pictures */
1282 frame_queue_destory(&is->pictq);
1283 frame_queue_destory(&is->sampq);
1284 frame_queue_destory(&is->subpq);
1285 SDL_DestroyCond(is->continue_read_thread);
1286 sws_freeContext(is->img_convert_ctx);
1287 sws_freeContext(is->sub_convert_ctx);
1288 av_free(is->filename);
1289 if (is->vis_texture)
1290 SDL_DestroyTexture(is->vis_texture);
1291 if (is->vid_texture)
1292 SDL_DestroyTexture(is->vid_texture);
1293 if (is->sub_texture)
1294 SDL_DestroyTexture(is->sub_texture);
1298 static void do_exit(VideoState *is)
1304 SDL_DestroyRenderer(renderer);
1306 SDL_DestroyWindow(window);
1309 av_freep(&vfilters_list);
1311 avformat_network_deinit();
1315 av_log(NULL, AV_LOG_QUIET, "%s", "");
1319 static void sigterm_handler(int sig)
1324 static void set_default_window_size(int width, int height, AVRational sar)
1327 int max_width = screen_width ? screen_width : INT_MAX;
1328 int max_height = screen_height ? screen_height : INT_MAX;
1329 if (max_width == INT_MAX && max_height == INT_MAX)
1330 max_height = height;
1331 calculate_display_rect(&rect, 0, 0, max_width, max_height, width, height, sar);
1332 default_width = rect.w;
1333 default_height = rect.h;
1336 static int video_open(VideoState *is)
1340 w = screen_width ? screen_width : default_width;
1341 h = screen_height ? screen_height : default_height;
1344 window_title = input_filename;
1345 SDL_SetWindowTitle(window, window_title);
1347 SDL_SetWindowSize(window, w, h);
1348 SDL_SetWindowPosition(window, screen_left, screen_top);
1350 SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
1351 SDL_ShowWindow(window);
1359 /* display the current picture, if any */
1360 static void video_display(VideoState *is)
1365 SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
1366 SDL_RenderClear(renderer);
1367 if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
1368 video_audio_display(is);
1369 else if (is->video_st)
1370 video_image_display(is);
1371 SDL_RenderPresent(renderer);
1374 static double get_clock(Clock *c)
1376 if (*c->queue_serial != c->serial)
1381 double time = av_gettime_relative() / 1000000.0;
1382 return c->pts_drift + time - (time - c->last_updated) * (1.0 - c->speed);
1386 static void set_clock_at(Clock *c, double pts, int serial, double time)
1389 c->last_updated = time;
1390 c->pts_drift = c->pts - time;
1394 static void set_clock(Clock *c, double pts, int serial)
1396 double time = av_gettime_relative() / 1000000.0;
1397 set_clock_at(c, pts, serial, time);
1400 static void set_clock_speed(Clock *c, double speed)
1402 set_clock(c, get_clock(c), c->serial);
1406 static void init_clock(Clock *c, int *queue_serial)
1410 c->queue_serial = queue_serial;
1411 set_clock(c, NAN, -1);
1414 static void sync_clock_to_slave(Clock *c, Clock *slave)
1416 double clock = get_clock(c);
1417 double slave_clock = get_clock(slave);
1418 if (!isnan(slave_clock) && (isnan(clock) || fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))
1419 set_clock(c, slave_clock, slave->serial);
1422 static int get_master_sync_type(VideoState *is) {
1423 if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
1425 return AV_SYNC_VIDEO_MASTER;
1427 return AV_SYNC_AUDIO_MASTER;
1428 } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
1430 return AV_SYNC_AUDIO_MASTER;
1432 return AV_SYNC_EXTERNAL_CLOCK;
1434 return AV_SYNC_EXTERNAL_CLOCK;
1438 /* get the current master clock value */
1439 static double get_master_clock(VideoState *is)
1443 switch (get_master_sync_type(is)) {
1444 case AV_SYNC_VIDEO_MASTER:
1445 val = get_clock(&is->vidclk);
1447 case AV_SYNC_AUDIO_MASTER:
1448 val = get_clock(&is->audclk);
1451 val = get_clock(&is->extclk);
1457 static void check_external_clock_speed(VideoState *is) {
1458 if (is->video_stream >= 0 && is->videoq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES ||
1459 is->audio_stream >= 0 && is->audioq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES) {
1460 set_clock_speed(&is->extclk, FFMAX(EXTERNAL_CLOCK_SPEED_MIN, is->extclk.speed - EXTERNAL_CLOCK_SPEED_STEP));
1461 } else if ((is->video_stream < 0 || is->videoq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES) &&
1462 (is->audio_stream < 0 || is->audioq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES)) {
1463 set_clock_speed(&is->extclk, FFMIN(EXTERNAL_CLOCK_SPEED_MAX, is->extclk.speed + EXTERNAL_CLOCK_SPEED_STEP));
1465 double speed = is->extclk.speed;
1467 set_clock_speed(&is->extclk, speed + EXTERNAL_CLOCK_SPEED_STEP * (1.0 - speed) / fabs(1.0 - speed));
1471 /* seek in the stream */
1472 static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)
1474 if (!is->seek_req) {
1477 is->seek_flags &= ~AVSEEK_FLAG_BYTE;
1479 is->seek_flags |= AVSEEK_FLAG_BYTE;
1481 SDL_CondSignal(is->continue_read_thread);
1485 /* pause or resume the video */
1486 static void stream_toggle_pause(VideoState *is)
1489 is->frame_timer += av_gettime_relative() / 1000000.0 - is->vidclk.last_updated;
1490 if (is->read_pause_return != AVERROR(ENOSYS)) {
1491 is->vidclk.paused = 0;
1493 set_clock(&is->vidclk, get_clock(&is->vidclk), is->vidclk.serial);
1495 set_clock(&is->extclk, get_clock(&is->extclk), is->extclk.serial);
1496 is->paused = is->audclk.paused = is->vidclk.paused = is->extclk.paused = !is->paused;
1499 static void toggle_pause(VideoState *is)
1501 stream_toggle_pause(is);
1505 static void toggle_mute(VideoState *is)
1507 is->muted = !is->muted;
1510 static void update_volume(VideoState *is, int sign, double step)
1512 double volume_level = is->audio_volume ? (20 * log(is->audio_volume / (double)SDL_MIX_MAXVOLUME) / log(10)) : -1000.0;
1513 int new_volume = lrint(SDL_MIX_MAXVOLUME * pow(10.0, (volume_level + sign * step) / 20.0));
1514 is->audio_volume = av_clip(is->audio_volume == new_volume ? (is->audio_volume + sign) : new_volume, 0, SDL_MIX_MAXVOLUME);
1517 static void step_to_next_frame(VideoState *is)
1519 /* if the stream is paused unpause it, then step */
1521 stream_toggle_pause(is);
1525 static double compute_target_delay(double delay, VideoState *is)
1527 double sync_threshold, diff = 0;
1529 /* update delay to follow master synchronisation source */
1530 if (get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER) {
1531 /* if video is slave, we try to correct big delays by
1532 duplicating or deleting a frame */
1533 diff = get_clock(&is->vidclk) - get_master_clock(is);
1535 /* skip or repeat frame. We take into account the
1536 delay to compute the threshold. I still don't know
1537 if it is the best guess */
1538 sync_threshold = FFMAX(AV_SYNC_THRESHOLD_MIN, FFMIN(AV_SYNC_THRESHOLD_MAX, delay));
1539 if (!isnan(diff) && fabs(diff) < is->max_frame_duration) {
1540 if (diff <= -sync_threshold)
1541 delay = FFMAX(0, delay + diff);
1542 else if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD)
1543 delay = delay + diff;
1544 else if (diff >= sync_threshold)
1549 av_log(NULL, AV_LOG_TRACE, "video: delay=%0.3f A-V=%f\n",
1555 static double vp_duration(VideoState *is, Frame *vp, Frame *nextvp) {
1556 if (vp->serial == nextvp->serial) {
1557 double duration = nextvp->pts - vp->pts;
1558 if (isnan(duration) || duration <= 0 || duration > is->max_frame_duration)
1559 return vp->duration;
1567 static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
1568 /* update current video pts */
1569 set_clock(&is->vidclk, pts, serial);
1570 sync_clock_to_slave(&is->extclk, &is->vidclk);
1573 /* called to display each frame */
1574 static void video_refresh(void *opaque, double *remaining_time)
1576 VideoState *is = opaque;
1581 if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
1582 check_external_clock_speed(is);
1584 if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {
1585 time = av_gettime_relative() / 1000000.0;
1586 if (is->force_refresh || is->last_vis_time + rdftspeed < time) {
1588 is->last_vis_time = time;
1590 *remaining_time = FFMIN(*remaining_time, is->last_vis_time + rdftspeed - time);
1595 if (frame_queue_nb_remaining(&is->pictq) == 0) {
1596 // nothing to do, no picture to display in the queue
1598 double last_duration, duration, delay;
1601 /* dequeue the picture */
1602 lastvp = frame_queue_peek_last(&is->pictq);
1603 vp = frame_queue_peek(&is->pictq);
1605 if (vp->serial != is->videoq.serial) {
1606 frame_queue_next(&is->pictq);
1610 if (lastvp->serial != vp->serial)
1611 is->frame_timer = av_gettime_relative() / 1000000.0;
1616 /* compute nominal last_duration */
1617 last_duration = vp_duration(is, lastvp, vp);
1618 delay = compute_target_delay(last_duration, is);
1620 time= av_gettime_relative()/1000000.0;
1621 if (time < is->frame_timer + delay) {
1622 *remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);
1626 is->frame_timer += delay;
1627 if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)
1628 is->frame_timer = time;
1630 SDL_LockMutex(is->pictq.mutex);
1631 if (!isnan(vp->pts))
1632 update_video_pts(is, vp->pts, vp->pos, vp->serial);
1633 SDL_UnlockMutex(is->pictq.mutex);
1635 if (frame_queue_nb_remaining(&is->pictq) > 1) {
1636 Frame *nextvp = frame_queue_peek_next(&is->pictq);
1637 duration = vp_duration(is, vp, nextvp);
1638 if(!is->step && (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
1639 is->frame_drops_late++;
1640 frame_queue_next(&is->pictq);
1645 if (is->subtitle_st) {
1646 while (frame_queue_nb_remaining(&is->subpq) > 0) {
1647 sp = frame_queue_peek(&is->subpq);
1649 if (frame_queue_nb_remaining(&is->subpq) > 1)
1650 sp2 = frame_queue_peek_next(&is->subpq);
1654 if (sp->serial != is->subtitleq.serial
1655 || (is->vidclk.pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1656 || (sp2 && is->vidclk.pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1660 for (i = 0; i < sp->sub.num_rects; i++) {
1661 AVSubtitleRect *sub_rect = sp->sub.rects[i];
1665 if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)&pixels, &pitch)) {
1666 for (j = 0; j < sub_rect->h; j++, pixels += pitch)
1667 memset(pixels, 0, sub_rect->w << 2);
1668 SDL_UnlockTexture(is->sub_texture);
1672 frame_queue_next(&is->subpq);
1679 frame_queue_next(&is->pictq);
1680 is->force_refresh = 1;
1682 if (is->step && !is->paused)
1683 stream_toggle_pause(is);
1686 /* display picture */
1687 if (!display_disable && is->force_refresh && is->show_mode == SHOW_MODE_VIDEO && is->pictq.rindex_shown)
1690 is->force_refresh = 0;
1693 static int64_t last_time;
1695 int aqsize, vqsize, sqsize;
1698 cur_time = av_gettime_relative();
1699 if (!last_time || (cur_time - last_time) >= 30000) {
1704 aqsize = is->audioq.size;
1706 vqsize = is->videoq.size;
1707 if (is->subtitle_st)
1708 sqsize = is->subtitleq.size;
1710 if (is->audio_st && is->video_st)
1711 av_diff = get_clock(&is->audclk) - get_clock(&is->vidclk);
1712 else if (is->video_st)
1713 av_diff = get_master_clock(is) - get_clock(&is->vidclk);
1714 else if (is->audio_st)
1715 av_diff = get_master_clock(is) - get_clock(&is->audclk);
1717 av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
1719 "%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64" \r",
1720 get_master_clock(is),
1721 (is->audio_st && is->video_st) ? "A-V" : (is->video_st ? "M-V" : (is->audio_st ? "M-A" : " ")),
1723 is->frame_drops_early + is->frame_drops_late,
1727 is->video_st ? is->viddec.avctx->pts_correction_num_faulty_dts : 0,
1728 is->video_st ? is->viddec.avctx->pts_correction_num_faulty_pts : 0);
1730 if (show_status == 1 && AV_LOG_INFO > av_log_get_level())
1731 fprintf(stderr, "%s", buf.str);
1733 av_log(NULL, AV_LOG_INFO, "%s", buf.str);
1736 av_bprint_finalize(&buf, NULL);
1738 last_time = cur_time;
1743 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, double duration, int64_t pos, int serial)
1747 #if defined(DEBUG_SYNC)
1748 printf("frame_type=%c pts=%0.3f\n",
1749 av_get_picture_type_char(src_frame->pict_type), pts);
1752 if (!(vp = frame_queue_peek_writable(&is->pictq)))
1755 vp->sar = src_frame->sample_aspect_ratio;
1758 vp->width = src_frame->width;
1759 vp->height = src_frame->height;
1760 vp->format = src_frame->format;
1763 vp->duration = duration;
1765 vp->serial = serial;
1767 set_default_window_size(vp->width, vp->height, vp->sar);
1769 av_frame_move_ref(vp->frame, src_frame);
1770 frame_queue_push(&is->pictq);
1774 static int get_video_frame(VideoState *is, AVFrame *frame)
1778 if ((got_picture = decoder_decode_frame(&is->viddec, frame, NULL)) < 0)
1784 if (frame->pts != AV_NOPTS_VALUE)
1785 dpts = av_q2d(is->video_st->time_base) * frame->pts;
1787 frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
1789 if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
1790 if (frame->pts != AV_NOPTS_VALUE) {
1791 double diff = dpts - get_master_clock(is);
1792 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD &&
1793 diff - is->frame_last_filter_delay < 0 &&
1794 is->viddec.pkt_serial == is->vidclk.serial &&
1795 is->videoq.nb_packets) {
1796 is->frame_drops_early++;
1797 av_frame_unref(frame);
1808 static int configure_filtergraph(AVFilterGraph *graph, const char *filtergraph,
1809 AVFilterContext *source_ctx, AVFilterContext *sink_ctx)
1812 int nb_filters = graph->nb_filters;
1813 AVFilterInOut *outputs = NULL, *inputs = NULL;
1816 outputs = avfilter_inout_alloc();
1817 inputs = avfilter_inout_alloc();
1818 if (!outputs || !inputs) {
1819 ret = AVERROR(ENOMEM);
1823 outputs->name = av_strdup("in");
1824 outputs->filter_ctx = source_ctx;
1825 outputs->pad_idx = 0;
1826 outputs->next = NULL;
1828 inputs->name = av_strdup("out");
1829 inputs->filter_ctx = sink_ctx;
1830 inputs->pad_idx = 0;
1831 inputs->next = NULL;
1833 if ((ret = avfilter_graph_parse_ptr(graph, filtergraph, &inputs, &outputs, NULL)) < 0)
1836 if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
1840 /* Reorder the filters to ensure that inputs of the custom filters are merged first */
1841 for (i = 0; i < graph->nb_filters - nb_filters; i++)
1842 FFSWAP(AVFilterContext*, graph->filters[i], graph->filters[i + nb_filters]);
1844 ret = avfilter_graph_config(graph, NULL);
1846 avfilter_inout_free(&outputs);
1847 avfilter_inout_free(&inputs);
1851 static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const char *vfilters, AVFrame *frame)
1853 enum AVPixelFormat pix_fmts[FF_ARRAY_ELEMS(sdl_texture_format_map)];
1854 char sws_flags_str[512] = "";
1855 char buffersrc_args[256];
1857 AVFilterContext *filt_src = NULL, *filt_out = NULL, *last_filter = NULL;
1858 AVCodecParameters *codecpar = is->video_st->codecpar;
1859 AVRational fr = av_guess_frame_rate(is->ic, is->video_st, NULL);
1860 AVDictionaryEntry *e = NULL;
1861 int nb_pix_fmts = 0;
1864 for (i = 0; i < renderer_info.num_texture_formats; i++) {
1865 for (j = 0; j < FF_ARRAY_ELEMS(sdl_texture_format_map) - 1; j++) {
1866 if (renderer_info.texture_formats[i] == sdl_texture_format_map[j].texture_fmt) {
1867 pix_fmts[nb_pix_fmts++] = sdl_texture_format_map[j].format;
1872 pix_fmts[nb_pix_fmts] = AV_PIX_FMT_NONE;
1874 while ((e = av_dict_get(sws_dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
1875 if (!strcmp(e->key, "sws_flags")) {
1876 av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", "flags", e->value);
1878 av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", e->key, e->value);
1880 if (strlen(sws_flags_str))
1881 sws_flags_str[strlen(sws_flags_str)-1] = '\0';
1883 graph->scale_sws_opts = av_strdup(sws_flags_str);
1885 snprintf(buffersrc_args, sizeof(buffersrc_args),
1886 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
1887 frame->width, frame->height, frame->format,
1888 is->video_st->time_base.num, is->video_st->time_base.den,
1889 codecpar->sample_aspect_ratio.num, FFMAX(codecpar->sample_aspect_ratio.den, 1));
1890 if (fr.num && fr.den)
1891 av_strlcatf(buffersrc_args, sizeof(buffersrc_args), ":frame_rate=%d/%d", fr.num, fr.den);
1893 if ((ret = avfilter_graph_create_filter(&filt_src,
1894 avfilter_get_by_name("buffer"),
1895 "ffplay_buffer", buffersrc_args, NULL,
1899 ret = avfilter_graph_create_filter(&filt_out,
1900 avfilter_get_by_name("buffersink"),
1901 "ffplay_buffersink", NULL, NULL, graph);
1905 if ((ret = av_opt_set_int_list(filt_out, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1908 last_filter = filt_out;
1910 /* Note: this macro adds a filter before the lastly added filter, so the
1911 * processing order of the filters is in reverse */
1912 #define INSERT_FILT(name, arg) do { \
1913 AVFilterContext *filt_ctx; \
1915 ret = avfilter_graph_create_filter(&filt_ctx, \
1916 avfilter_get_by_name(name), \
1917 "ffplay_" name, arg, NULL, graph); \
1921 ret = avfilter_link(filt_ctx, 0, last_filter, 0); \
1925 last_filter = filt_ctx; \
1929 double theta = get_rotation(is->video_st);
1931 if (fabs(theta - 90) < 1.0) {
1932 INSERT_FILT("transpose", "clock");
1933 } else if (fabs(theta - 180) < 1.0) {
1934 INSERT_FILT("hflip", NULL);
1935 INSERT_FILT("vflip", NULL);
1936 } else if (fabs(theta - 270) < 1.0) {
1937 INSERT_FILT("transpose", "cclock");
1938 } else if (fabs(theta) > 1.0) {
1939 char rotate_buf[64];
1940 snprintf(rotate_buf, sizeof(rotate_buf), "%f*PI/180", theta);
1941 INSERT_FILT("rotate", rotate_buf);
1945 if ((ret = configure_filtergraph(graph, vfilters, filt_src, last_filter)) < 0)
1948 is->in_video_filter = filt_src;
1949 is->out_video_filter = filt_out;
1955 static int configure_audio_filters(VideoState *is, const char *afilters, int force_output_format)
1957 static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
1958 int sample_rates[2] = { 0, -1 };
1959 int64_t channel_layouts[2] = { 0, -1 };
1960 int channels[2] = { 0, -1 };
1961 AVFilterContext *filt_asrc = NULL, *filt_asink = NULL;
1962 char aresample_swr_opts[512] = "";
1963 AVDictionaryEntry *e = NULL;
1964 char asrc_args[256];
1967 avfilter_graph_free(&is->agraph);
1968 if (!(is->agraph = avfilter_graph_alloc()))
1969 return AVERROR(ENOMEM);
1970 is->agraph->nb_threads = filter_nbthreads;
1972 while ((e = av_dict_get(swr_opts, "", e, AV_DICT_IGNORE_SUFFIX)))
1973 av_strlcatf(aresample_swr_opts, sizeof(aresample_swr_opts), "%s=%s:", e->key, e->value);
1974 if (strlen(aresample_swr_opts))
1975 aresample_swr_opts[strlen(aresample_swr_opts)-1] = '\0';
1976 av_opt_set(is->agraph, "aresample_swr_opts", aresample_swr_opts, 0);
1978 ret = snprintf(asrc_args, sizeof(asrc_args),
1979 "sample_rate=%d:sample_fmt=%s:channels=%d:time_base=%d/%d",
1980 is->audio_filter_src.freq, av_get_sample_fmt_name(is->audio_filter_src.fmt),
1981 is->audio_filter_src.channels,
1982 1, is->audio_filter_src.freq);
1983 if (is->audio_filter_src.channel_layout)
1984 snprintf(asrc_args + ret, sizeof(asrc_args) - ret,
1985 ":channel_layout=0x%"PRIx64, is->audio_filter_src.channel_layout);
1987 ret = avfilter_graph_create_filter(&filt_asrc,
1988 avfilter_get_by_name("abuffer"), "ffplay_abuffer",
1989 asrc_args, NULL, is->agraph);
1994 ret = avfilter_graph_create_filter(&filt_asink,
1995 avfilter_get_by_name("abuffersink"), "ffplay_abuffersink",
1996 NULL, NULL, is->agraph);
2000 if ((ret = av_opt_set_int_list(filt_asink, "sample_fmts", sample_fmts, AV_SAMPLE_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
2002 if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 1, AV_OPT_SEARCH_CHILDREN)) < 0)
2005 if (force_output_format) {
2006 channel_layouts[0] = is->audio_tgt.channel_layout;
2007 channels [0] = is->audio_tgt.channel_layout ? -1 : is->audio_tgt.channels;
2008 sample_rates [0] = is->audio_tgt.freq;
2009 if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 0, AV_OPT_SEARCH_CHILDREN)) < 0)
2011 if ((ret = av_opt_set_int_list(filt_asink, "channel_layouts", channel_layouts, -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2013 if ((ret = av_opt_set_int_list(filt_asink, "channel_counts" , channels , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2015 if ((ret = av_opt_set_int_list(filt_asink, "sample_rates" , sample_rates , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2020 if ((ret = configure_filtergraph(is->agraph, afilters, filt_asrc, filt_asink)) < 0)
2023 is->in_audio_filter = filt_asrc;
2024 is->out_audio_filter = filt_asink;
2028 avfilter_graph_free(&is->agraph);
2031 #endif /* CONFIG_AVFILTER */
2033 static int audio_thread(void *arg)
2035 VideoState *is = arg;
2036 AVFrame *frame = av_frame_alloc();
2039 int last_serial = -1;
2040 int64_t dec_channel_layout;
2048 return AVERROR(ENOMEM);
2051 if ((got_frame = decoder_decode_frame(&is->auddec, frame, NULL)) < 0)
2055 tb = (AVRational){1, frame->sample_rate};
2058 dec_channel_layout = get_valid_channel_layout(frame->channel_layout, frame->channels);
2061 cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
2062 frame->format, frame->channels) ||
2063 is->audio_filter_src.channel_layout != dec_channel_layout ||
2064 is->audio_filter_src.freq != frame->sample_rate ||
2065 is->auddec.pkt_serial != last_serial;
2068 char buf1[1024], buf2[1024];
2069 av_get_channel_layout_string(buf1, sizeof(buf1), -1, is->audio_filter_src.channel_layout);
2070 av_get_channel_layout_string(buf2, sizeof(buf2), -1, dec_channel_layout);
2071 av_log(NULL, AV_LOG_DEBUG,
2072 "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",
2073 is->audio_filter_src.freq, is->audio_filter_src.channels, av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, last_serial,
2074 frame->sample_rate, frame->channels, av_get_sample_fmt_name(frame->format), buf2, is->auddec.pkt_serial);
2076 is->audio_filter_src.fmt = frame->format;
2077 is->audio_filter_src.channels = frame->channels;
2078 is->audio_filter_src.channel_layout = dec_channel_layout;
2079 is->audio_filter_src.freq = frame->sample_rate;
2080 last_serial = is->auddec.pkt_serial;
2082 if ((ret = configure_audio_filters(is, afilters, 1)) < 0)
2086 if ((ret = av_buffersrc_add_frame(is->in_audio_filter, frame)) < 0)
2089 while ((ret = av_buffersink_get_frame_flags(is->out_audio_filter, frame, 0)) >= 0) {
2090 tb = av_buffersink_get_time_base(is->out_audio_filter);
2092 if (!(af = frame_queue_peek_writable(&is->sampq)))
2095 af->pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2096 af->pos = frame->pkt_pos;
2097 af->serial = is->auddec.pkt_serial;
2098 af->duration = av_q2d((AVRational){frame->nb_samples, frame->sample_rate});
2100 av_frame_move_ref(af->frame, frame);
2101 frame_queue_push(&is->sampq);
2104 if (is->audioq.serial != is->auddec.pkt_serial)
2107 if (ret == AVERROR_EOF)
2108 is->auddec.finished = is->auddec.pkt_serial;
2111 } while (ret >= 0 || ret == AVERROR(EAGAIN) || ret == AVERROR_EOF);
2114 avfilter_graph_free(&is->agraph);
2116 av_frame_free(&frame);
2120 static int decoder_start(Decoder *d, int (*fn)(void *), const char *thread_name, void* arg)
2122 packet_queue_start(d->queue);
2123 d->decoder_tid = SDL_CreateThread(fn, thread_name, arg);
2124 if (!d->decoder_tid) {
2125 av_log(NULL, AV_LOG_ERROR, "SDL_CreateThread(): %s\n", SDL_GetError());
2126 return AVERROR(ENOMEM);
2131 static int video_thread(void *arg)
2133 VideoState *is = arg;
2134 AVFrame *frame = av_frame_alloc();
2138 AVRational tb = is->video_st->time_base;
2139 AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);
2142 AVFilterGraph *graph = NULL;
2143 AVFilterContext *filt_out = NULL, *filt_in = NULL;
2146 enum AVPixelFormat last_format = -2;
2147 int last_serial = -1;
2148 int last_vfilter_idx = 0;
2152 return AVERROR(ENOMEM);
2155 ret = get_video_frame(is, frame);
2162 if ( last_w != frame->width
2163 || last_h != frame->height
2164 || last_format != frame->format
2165 || last_serial != is->viddec.pkt_serial
2166 || last_vfilter_idx != is->vfilter_idx) {
2167 av_log(NULL, AV_LOG_DEBUG,
2168 "Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
2170 (const char *)av_x_if_null(av_get_pix_fmt_name(last_format), "none"), last_serial,
2171 frame->width, frame->height,
2172 (const char *)av_x_if_null(av_get_pix_fmt_name(frame->format), "none"), is->viddec.pkt_serial);
2173 avfilter_graph_free(&graph);
2174 graph = avfilter_graph_alloc();
2176 ret = AVERROR(ENOMEM);
2179 graph->nb_threads = filter_nbthreads;
2180 if ((ret = configure_video_filters(graph, is, vfilters_list ? vfilters_list[is->vfilter_idx] : NULL, frame)) < 0) {
2182 event.type = FF_QUIT_EVENT;
2183 event.user.data1 = is;
2184 SDL_PushEvent(&event);
2187 filt_in = is->in_video_filter;
2188 filt_out = is->out_video_filter;
2189 last_w = frame->width;
2190 last_h = frame->height;
2191 last_format = frame->format;
2192 last_serial = is->viddec.pkt_serial;
2193 last_vfilter_idx = is->vfilter_idx;
2194 frame_rate = av_buffersink_get_frame_rate(filt_out);
2197 ret = av_buffersrc_add_frame(filt_in, frame);
2202 is->frame_last_returned_time = av_gettime_relative() / 1000000.0;
2204 ret = av_buffersink_get_frame_flags(filt_out, frame, 0);
2206 if (ret == AVERROR_EOF)
2207 is->viddec.finished = is->viddec.pkt_serial;
2212 is->frame_last_filter_delay = av_gettime_relative() / 1000000.0 - is->frame_last_returned_time;
2213 if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
2214 is->frame_last_filter_delay = 0;
2215 tb = av_buffersink_get_time_base(filt_out);
2217 duration = (frame_rate.num && frame_rate.den ? av_q2d((AVRational){frame_rate.den, frame_rate.num}) : 0);
2218 pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2219 ret = queue_picture(is, frame, pts, duration, frame->pkt_pos, is->viddec.pkt_serial);
2220 av_frame_unref(frame);
2222 if (is->videoq.serial != is->viddec.pkt_serial)
2232 avfilter_graph_free(&graph);
2234 av_frame_free(&frame);
2238 static int subtitle_thread(void *arg)
2240 VideoState *is = arg;
2246 if (!(sp = frame_queue_peek_writable(&is->subpq)))
2249 if ((got_subtitle = decoder_decode_frame(&is->subdec, NULL, &sp->sub)) < 0)
2254 if (got_subtitle && sp->sub.format == 0) {
2255 if (sp->sub.pts != AV_NOPTS_VALUE)
2256 pts = sp->sub.pts / (double)AV_TIME_BASE;
2258 sp->serial = is->subdec.pkt_serial;
2259 sp->width = is->subdec.avctx->width;
2260 sp->height = is->subdec.avctx->height;
2263 /* now we can update the picture count */
2264 frame_queue_push(&is->subpq);
2265 } else if (got_subtitle) {
2266 avsubtitle_free(&sp->sub);
2272 /* copy samples for viewing in editor window */
2273 static void update_sample_display(VideoState *is, short *samples, int samples_size)
2277 size = samples_size / sizeof(short);
2279 len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
2282 memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
2284 is->sample_array_index += len;
2285 if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
2286 is->sample_array_index = 0;
2291 /* return the wanted number of samples to get better sync if sync_type is video
2292 * or external master clock */
2293 static int synchronize_audio(VideoState *is, int nb_samples)
2295 int wanted_nb_samples = nb_samples;
2297 /* if not master, then we try to remove or add samples to correct the clock */
2298 if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
2299 double diff, avg_diff;
2300 int min_nb_samples, max_nb_samples;
2302 diff = get_clock(&is->audclk) - get_master_clock(is);
2304 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD) {
2305 is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
2306 if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
2307 /* not enough measures to have a correct estimate */
2308 is->audio_diff_avg_count++;
2310 /* estimate the A-V difference */
2311 avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
2313 if (fabs(avg_diff) >= is->audio_diff_threshold) {
2314 wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);
2315 min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2316 max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2317 wanted_nb_samples = av_clip(wanted_nb_samples, min_nb_samples, max_nb_samples);
2319 av_log(NULL, AV_LOG_TRACE, "diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
2320 diff, avg_diff, wanted_nb_samples - nb_samples,
2321 is->audio_clock, is->audio_diff_threshold);
2324 /* too big difference : may be initial PTS errors, so
2326 is->audio_diff_avg_count = 0;
2327 is->audio_diff_cum = 0;
2331 return wanted_nb_samples;
2335 * Decode one audio frame and return its uncompressed size.
2337 * The processed audio frame is decoded, converted if required, and
2338 * stored in is->audio_buf, with size in bytes given by the return
2341 static int audio_decode_frame(VideoState *is)
2343 int data_size, resampled_data_size;
2344 int64_t dec_channel_layout;
2345 av_unused double audio_clock0;
2346 int wanted_nb_samples;
2354 while (frame_queue_nb_remaining(&is->sampq) == 0) {
2355 if ((av_gettime_relative() - audio_callback_time) > 1000000LL * is->audio_hw_buf_size / is->audio_tgt.bytes_per_sec / 2)
2360 if (!(af = frame_queue_peek_readable(&is->sampq)))
2362 frame_queue_next(&is->sampq);
2363 } while (af->serial != is->audioq.serial);
2365 data_size = av_samples_get_buffer_size(NULL, af->frame->channels,
2366 af->frame->nb_samples,
2367 af->frame->format, 1);
2369 dec_channel_layout =
2370 (af->frame->channel_layout && af->frame->channels == av_get_channel_layout_nb_channels(af->frame->channel_layout)) ?
2371 af->frame->channel_layout : av_get_default_channel_layout(af->frame->channels);
2372 wanted_nb_samples = synchronize_audio(is, af->frame->nb_samples);
2374 if (af->frame->format != is->audio_src.fmt ||
2375 dec_channel_layout != is->audio_src.channel_layout ||
2376 af->frame->sample_rate != is->audio_src.freq ||
2377 (wanted_nb_samples != af->frame->nb_samples && !is->swr_ctx)) {
2378 swr_free(&is->swr_ctx);
2379 is->swr_ctx = swr_alloc_set_opts(NULL,
2380 is->audio_tgt.channel_layout, is->audio_tgt.fmt, is->audio_tgt.freq,
2381 dec_channel_layout, af->frame->format, af->frame->sample_rate,
2383 if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
2384 av_log(NULL, AV_LOG_ERROR,
2385 "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
2386 af->frame->sample_rate, av_get_sample_fmt_name(af->frame->format), af->frame->channels,
2387 is->audio_tgt.freq, av_get_sample_fmt_name(is->audio_tgt.fmt), is->audio_tgt.channels);
2388 swr_free(&is->swr_ctx);
2391 is->audio_src.channel_layout = dec_channel_layout;
2392 is->audio_src.channels = af->frame->channels;
2393 is->audio_src.freq = af->frame->sample_rate;
2394 is->audio_src.fmt = af->frame->format;
2398 const uint8_t **in = (const uint8_t **)af->frame->extended_data;
2399 uint8_t **out = &is->audio_buf1;
2400 int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate + 256;
2401 int out_size = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, out_count, is->audio_tgt.fmt, 0);
2404 av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size() failed\n");
2407 if (wanted_nb_samples != af->frame->nb_samples) {
2408 if (swr_set_compensation(is->swr_ctx, (wanted_nb_samples - af->frame->nb_samples) * is->audio_tgt.freq / af->frame->sample_rate,
2409 wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate) < 0) {
2410 av_log(NULL, AV_LOG_ERROR, "swr_set_compensation() failed\n");
2414 av_fast_malloc(&is->audio_buf1, &is->audio_buf1_size, out_size);
2415 if (!is->audio_buf1)
2416 return AVERROR(ENOMEM);
2417 len2 = swr_convert(is->swr_ctx, out, out_count, in, af->frame->nb_samples);
2419 av_log(NULL, AV_LOG_ERROR, "swr_convert() failed\n");
2422 if (len2 == out_count) {
2423 av_log(NULL, AV_LOG_WARNING, "audio buffer is probably too small\n");
2424 if (swr_init(is->swr_ctx) < 0)
2425 swr_free(&is->swr_ctx);
2427 is->audio_buf = is->audio_buf1;
2428 resampled_data_size = len2 * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2430 is->audio_buf = af->frame->data[0];
2431 resampled_data_size = data_size;
2434 audio_clock0 = is->audio_clock;
2435 /* update the audio clock with the pts */
2436 if (!isnan(af->pts))
2437 is->audio_clock = af->pts + (double) af->frame->nb_samples / af->frame->sample_rate;
2439 is->audio_clock = NAN;
2440 is->audio_clock_serial = af->serial;
2443 static double last_clock;
2444 printf("audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
2445 is->audio_clock - last_clock,
2446 is->audio_clock, audio_clock0);
2447 last_clock = is->audio_clock;
2450 return resampled_data_size;
2453 /* prepare a new audio buffer */
2454 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
2456 VideoState *is = opaque;
2457 int audio_size, len1;
2459 audio_callback_time = av_gettime_relative();
2462 if (is->audio_buf_index >= is->audio_buf_size) {
2463 audio_size = audio_decode_frame(is);
2464 if (audio_size < 0) {
2465 /* if error, just output silence */
2466 is->audio_buf = NULL;
2467 is->audio_buf_size = SDL_AUDIO_MIN_BUFFER_SIZE / is->audio_tgt.frame_size * is->audio_tgt.frame_size;
2469 if (is->show_mode != SHOW_MODE_VIDEO)
2470 update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
2471 is->audio_buf_size = audio_size;
2473 is->audio_buf_index = 0;
2475 len1 = is->audio_buf_size - is->audio_buf_index;
2478 if (!is->muted && is->audio_buf && is->audio_volume == SDL_MIX_MAXVOLUME)
2479 memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
2481 memset(stream, 0, len1);
2482 if (!is->muted && is->audio_buf)
2483 SDL_MixAudioFormat(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, AUDIO_S16SYS, len1, is->audio_volume);
2487 is->audio_buf_index += len1;
2489 is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
2490 /* Let's assume the audio driver that is used by SDL has two periods. */
2491 if (!isnan(is->audio_clock)) {
2492 set_clock_at(&is->audclk, is->audio_clock - (double)(2 * is->audio_hw_buf_size + is->audio_write_buf_size) / is->audio_tgt.bytes_per_sec, is->audio_clock_serial, audio_callback_time / 1000000.0);
2493 sync_clock_to_slave(&is->extclk, &is->audclk);
2497 static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
2499 SDL_AudioSpec wanted_spec, spec;
2501 static const int next_nb_channels[] = {0, 0, 1, 6, 2, 6, 4, 6};
2502 static const int next_sample_rates[] = {0, 44100, 48000, 96000, 192000};
2503 int next_sample_rate_idx = FF_ARRAY_ELEMS(next_sample_rates) - 1;
2505 env = SDL_getenv("SDL_AUDIO_CHANNELS");
2507 wanted_nb_channels = atoi(env);
2508 wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2510 if (!wanted_channel_layout || wanted_nb_channels != av_get_channel_layout_nb_channels(wanted_channel_layout)) {
2511 wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2512 wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
2514 wanted_nb_channels = av_get_channel_layout_nb_channels(wanted_channel_layout);
2515 wanted_spec.channels = wanted_nb_channels;
2516 wanted_spec.freq = wanted_sample_rate;
2517 if (wanted_spec.freq <= 0 || wanted_spec.channels <= 0) {
2518 av_log(NULL, AV_LOG_ERROR, "Invalid sample rate or channel count!\n");
2521 while (next_sample_rate_idx && next_sample_rates[next_sample_rate_idx] >= wanted_spec.freq)
2522 next_sample_rate_idx--;
2523 wanted_spec.format = AUDIO_S16SYS;
2524 wanted_spec.silence = 0;
2525 wanted_spec.samples = FFMAX(SDL_AUDIO_MIN_BUFFER_SIZE, 2 << av_log2(wanted_spec.freq / SDL_AUDIO_MAX_CALLBACKS_PER_SEC));
2526 wanted_spec.callback = sdl_audio_callback;
2527 wanted_spec.userdata = opaque;
2528 while (!(audio_dev = SDL_OpenAudioDevice(NULL, 0, &wanted_spec, &spec, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE | SDL_AUDIO_ALLOW_CHANNELS_CHANGE))) {
2529 av_log(NULL, AV_LOG_WARNING, "SDL_OpenAudio (%d channels, %d Hz): %s\n",
2530 wanted_spec.channels, wanted_spec.freq, SDL_GetError());
2531 wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
2532 if (!wanted_spec.channels) {
2533 wanted_spec.freq = next_sample_rates[next_sample_rate_idx--];
2534 wanted_spec.channels = wanted_nb_channels;
2535 if (!wanted_spec.freq) {
2536 av_log(NULL, AV_LOG_ERROR,
2537 "No more combinations to try, audio open failed\n");
2541 wanted_channel_layout = av_get_default_channel_layout(wanted_spec.channels);
2543 if (spec.format != AUDIO_S16SYS) {
2544 av_log(NULL, AV_LOG_ERROR,
2545 "SDL advised audio format %d is not supported!\n", spec.format);
2548 if (spec.channels != wanted_spec.channels) {
2549 wanted_channel_layout = av_get_default_channel_layout(spec.channels);
2550 if (!wanted_channel_layout) {
2551 av_log(NULL, AV_LOG_ERROR,
2552 "SDL advised channel count %d is not supported!\n", spec.channels);
2557 audio_hw_params->fmt = AV_SAMPLE_FMT_S16;
2558 audio_hw_params->freq = spec.freq;
2559 audio_hw_params->channel_layout = wanted_channel_layout;
2560 audio_hw_params->channels = spec.channels;
2561 audio_hw_params->frame_size = av_samples_get_buffer_size(NULL, audio_hw_params->channels, 1, audio_hw_params->fmt, 1);
2562 audio_hw_params->bytes_per_sec = av_samples_get_buffer_size(NULL, audio_hw_params->channels, audio_hw_params->freq, audio_hw_params->fmt, 1);
2563 if (audio_hw_params->bytes_per_sec <= 0 || audio_hw_params->frame_size <= 0) {
2564 av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size failed\n");
2570 /* open a given stream. Return 0 if OK */
2571 static int stream_component_open(VideoState *is, int stream_index)
2573 AVFormatContext *ic = is->ic;
2574 AVCodecContext *avctx;
2576 const char *forced_codec_name = NULL;
2577 AVDictionary *opts = NULL;
2578 AVDictionaryEntry *t = NULL;
2579 int sample_rate, nb_channels;
2580 int64_t channel_layout;
2582 int stream_lowres = lowres;
2584 if (stream_index < 0 || stream_index >= ic->nb_streams)
2587 avctx = avcodec_alloc_context3(NULL);
2589 return AVERROR(ENOMEM);
2591 ret = avcodec_parameters_to_context(avctx, ic->streams[stream_index]->codecpar);
2594 avctx->pkt_timebase = ic->streams[stream_index]->time_base;
2596 codec = avcodec_find_decoder(avctx->codec_id);
2598 switch(avctx->codec_type){
2599 case AVMEDIA_TYPE_AUDIO : is->last_audio_stream = stream_index; forced_codec_name = audio_codec_name; break;
2600 case AVMEDIA_TYPE_SUBTITLE: is->last_subtitle_stream = stream_index; forced_codec_name = subtitle_codec_name; break;
2601 case AVMEDIA_TYPE_VIDEO : is->last_video_stream = stream_index; forced_codec_name = video_codec_name; break;
2603 if (forced_codec_name)
2604 codec = avcodec_find_decoder_by_name(forced_codec_name);
2606 if (forced_codec_name) av_log(NULL, AV_LOG_WARNING,
2607 "No codec could be found with name '%s'\n", forced_codec_name);
2608 else av_log(NULL, AV_LOG_WARNING,
2609 "No decoder could be found for codec %s\n", avcodec_get_name(avctx->codec_id));
2610 ret = AVERROR(EINVAL);
2614 avctx->codec_id = codec->id;
2615 if (stream_lowres > codec->max_lowres) {
2616 av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2618 stream_lowres = codec->max_lowres;
2620 avctx->lowres = stream_lowres;
2623 avctx->flags2 |= AV_CODEC_FLAG2_FAST;
2625 opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
2626 if (!av_dict_get(opts, "threads", NULL, 0))
2627 av_dict_set(&opts, "threads", "auto", 0);
2629 av_dict_set_int(&opts, "lowres", stream_lowres, 0);
2630 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
2631 av_dict_set(&opts, "refcounted_frames", "1", 0);
2632 if ((ret = avcodec_open2(avctx, codec, &opts)) < 0) {
2635 if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2636 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2637 ret = AVERROR_OPTION_NOT_FOUND;
2642 ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
2643 switch (avctx->codec_type) {
2644 case AVMEDIA_TYPE_AUDIO:
2647 AVFilterContext *sink;
2649 is->audio_filter_src.freq = avctx->sample_rate;
2650 is->audio_filter_src.channels = avctx->channels;
2651 is->audio_filter_src.channel_layout = get_valid_channel_layout(avctx->channel_layout, avctx->channels);
2652 is->audio_filter_src.fmt = avctx->sample_fmt;
2653 if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
2655 sink = is->out_audio_filter;
2656 sample_rate = av_buffersink_get_sample_rate(sink);
2657 nb_channels = av_buffersink_get_channels(sink);
2658 channel_layout = av_buffersink_get_channel_layout(sink);
2661 sample_rate = avctx->sample_rate;
2662 nb_channels = avctx->channels;
2663 channel_layout = avctx->channel_layout;
2666 /* prepare audio output */
2667 if ((ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)) < 0)
2669 is->audio_hw_buf_size = ret;
2670 is->audio_src = is->audio_tgt;
2671 is->audio_buf_size = 0;
2672 is->audio_buf_index = 0;
2674 /* init averaging filter */
2675 is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
2676 is->audio_diff_avg_count = 0;
2677 /* since we do not have a precise anough audio FIFO fullness,
2678 we correct audio sync only if larger than this threshold */
2679 is->audio_diff_threshold = (double)(is->audio_hw_buf_size) / is->audio_tgt.bytes_per_sec;
2681 is->audio_stream = stream_index;
2682 is->audio_st = ic->streams[stream_index];
2684 decoder_init(&is->auddec, avctx, &is->audioq, is->continue_read_thread);
2685 if ((is->ic->iformat->flags & (AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH | AVFMT_NO_BYTE_SEEK)) && !is->ic->iformat->read_seek) {
2686 is->auddec.start_pts = is->audio_st->start_time;
2687 is->auddec.start_pts_tb = is->audio_st->time_base;
2689 if ((ret = decoder_start(&is->auddec, audio_thread, "audio_decoder", is)) < 0)
2691 SDL_PauseAudioDevice(audio_dev, 0);
2693 case AVMEDIA_TYPE_VIDEO:
2694 is->video_stream = stream_index;
2695 is->video_st = ic->streams[stream_index];
2697 decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread);
2698 if ((ret = decoder_start(&is->viddec, video_thread, "video_decoder", is)) < 0)
2700 is->queue_attachments_req = 1;
2702 case AVMEDIA_TYPE_SUBTITLE:
2703 is->subtitle_stream = stream_index;
2704 is->subtitle_st = ic->streams[stream_index];
2706 decoder_init(&is->subdec, avctx, &is->subtitleq, is->continue_read_thread);
2707 if ((ret = decoder_start(&is->subdec, subtitle_thread, "subtitle_decoder", is)) < 0)
2716 avcodec_free_context(&avctx);
2718 av_dict_free(&opts);
2723 static int decode_interrupt_cb(void *ctx)
2725 VideoState *is = ctx;
2726 return is->abort_request;
2729 static int stream_has_enough_packets(AVStream *st, int stream_id, PacketQueue *queue) {
2730 return stream_id < 0 ||
2731 queue->abort_request ||
2732 (st->disposition & AV_DISPOSITION_ATTACHED_PIC) ||
2733 queue->nb_packets > MIN_FRAMES && (!queue->duration || av_q2d(st->time_base) * queue->duration > 1.0);
2736 static int is_realtime(AVFormatContext *s)
2738 if( !strcmp(s->iformat->name, "rtp")
2739 || !strcmp(s->iformat->name, "rtsp")
2740 || !strcmp(s->iformat->name, "sdp")
2744 if(s->pb && ( !strncmp(s->url, "rtp:", 4)
2745 || !strncmp(s->url, "udp:", 4)
2752 /* this thread gets the stream from the disk or the network */
2753 static int read_thread(void *arg)
2755 VideoState *is = arg;
2756 AVFormatContext *ic = NULL;
2758 int st_index[AVMEDIA_TYPE_NB];
2759 AVPacket pkt1, *pkt = &pkt1;
2760 int64_t stream_start_time;
2761 int pkt_in_play_range = 0;
2762 AVDictionaryEntry *t;
2763 SDL_mutex *wait_mutex = SDL_CreateMutex();
2764 int scan_all_pmts_set = 0;
2768 av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
2769 ret = AVERROR(ENOMEM);
2773 memset(st_index, -1, sizeof(st_index));
2776 ic = avformat_alloc_context();
2778 av_log(NULL, AV_LOG_FATAL, "Could not allocate context.\n");
2779 ret = AVERROR(ENOMEM);
2782 ic->interrupt_callback.callback = decode_interrupt_cb;
2783 ic->interrupt_callback.opaque = is;
2784 if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
2785 av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
2786 scan_all_pmts_set = 1;
2788 err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
2790 print_error(is->filename, err);
2794 if (scan_all_pmts_set)
2795 av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
2797 if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2798 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2799 ret = AVERROR_OPTION_NOT_FOUND;
2805 ic->flags |= AVFMT_FLAG_GENPTS;
2807 av_format_inject_global_side_data(ic);
2809 if (find_stream_info) {
2810 AVDictionary **opts = setup_find_stream_info_opts(ic, codec_opts);
2811 int orig_nb_streams = ic->nb_streams;
2813 err = avformat_find_stream_info(ic, opts);
2815 for (i = 0; i < orig_nb_streams; i++)
2816 av_dict_free(&opts[i]);
2820 av_log(NULL, AV_LOG_WARNING,
2821 "%s: could not find codec parameters\n", is->filename);
2828 ic->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use avio_feof() to test for the end
2830 if (seek_by_bytes < 0)
2831 seek_by_bytes = !!(ic->iformat->flags & AVFMT_TS_DISCONT) && strcmp("ogg", ic->iformat->name);
2833 is->max_frame_duration = (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;
2835 if (!window_title && (t = av_dict_get(ic->metadata, "title", NULL, 0)))
2836 window_title = av_asprintf("%s - %s", t->value, input_filename);
2838 /* if seeking requested, we execute it */
2839 if (start_time != AV_NOPTS_VALUE) {
2842 timestamp = start_time;
2843 /* add the stream start time */
2844 if (ic->start_time != AV_NOPTS_VALUE)
2845 timestamp += ic->start_time;
2846 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
2848 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2849 is->filename, (double)timestamp / AV_TIME_BASE);
2853 is->realtime = is_realtime(ic);
2856 av_dump_format(ic, 0, is->filename, 0);
2858 for (i = 0; i < ic->nb_streams; i++) {
2859 AVStream *st = ic->streams[i];
2860 enum AVMediaType type = st->codecpar->codec_type;
2861 st->discard = AVDISCARD_ALL;
2862 if (type >= 0 && wanted_stream_spec[type] && st_index[type] == -1)
2863 if (avformat_match_stream_specifier(ic, st, wanted_stream_spec[type]) > 0)
2866 for (i = 0; i < AVMEDIA_TYPE_NB; i++) {
2867 if (wanted_stream_spec[i] && st_index[i] == -1) {
2868 av_log(NULL, AV_LOG_ERROR, "Stream specifier %s does not match any %s stream\n", wanted_stream_spec[i], av_get_media_type_string(i));
2869 st_index[i] = INT_MAX;
2874 st_index[AVMEDIA_TYPE_VIDEO] =
2875 av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
2876 st_index[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
2878 st_index[AVMEDIA_TYPE_AUDIO] =
2879 av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
2880 st_index[AVMEDIA_TYPE_AUDIO],
2881 st_index[AVMEDIA_TYPE_VIDEO],
2883 if (!video_disable && !subtitle_disable)
2884 st_index[AVMEDIA_TYPE_SUBTITLE] =
2885 av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
2886 st_index[AVMEDIA_TYPE_SUBTITLE],
2887 (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
2888 st_index[AVMEDIA_TYPE_AUDIO] :
2889 st_index[AVMEDIA_TYPE_VIDEO]),
2892 is->show_mode = show_mode;
2893 if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2894 AVStream *st = ic->streams[st_index[AVMEDIA_TYPE_VIDEO]];
2895 AVCodecParameters *codecpar = st->codecpar;
2896 AVRational sar = av_guess_sample_aspect_ratio(ic, st, NULL);
2897 if (codecpar->width)
2898 set_default_window_size(codecpar->width, codecpar->height, sar);
2901 /* open the streams */
2902 if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
2903 stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
2907 if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2908 ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
2910 if (is->show_mode == SHOW_MODE_NONE)
2911 is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
2913 if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
2914 stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
2917 if (is->video_stream < 0 && is->audio_stream < 0) {
2918 av_log(NULL, AV_LOG_FATAL, "Failed to open file '%s' or configure filtergraph\n",
2924 if (infinite_buffer < 0 && is->realtime)
2925 infinite_buffer = 1;
2928 if (is->abort_request)
2930 if (is->paused != is->last_paused) {
2931 is->last_paused = is->paused;
2933 is->read_pause_return = av_read_pause(ic);
2937 #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
2939 (!strcmp(ic->iformat->name, "rtsp") ||
2940 (ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
2941 /* wait 10 ms to avoid trying to get another packet */
2948 int64_t seek_target = is->seek_pos;
2949 int64_t seek_min = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
2950 int64_t seek_max = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
2951 // FIXME the +-2 is due to rounding being not done in the correct direction in generation
2952 // of the seek_pos/seek_rel variables
2954 ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
2956 av_log(NULL, AV_LOG_ERROR,
2957 "%s: error while seeking\n", is->ic->url);
2959 if (is->audio_stream >= 0) {
2960 packet_queue_flush(&is->audioq);
2962 if (is->subtitle_stream >= 0) {
2963 packet_queue_flush(&is->subtitleq);
2965 if (is->video_stream >= 0) {
2966 packet_queue_flush(&is->videoq);
2968 if (is->seek_flags & AVSEEK_FLAG_BYTE) {
2969 set_clock(&is->extclk, NAN, 0);
2971 set_clock(&is->extclk, seek_target / (double)AV_TIME_BASE, 0);
2975 is->queue_attachments_req = 1;
2978 step_to_next_frame(is);
2980 if (is->queue_attachments_req) {
2981 if (is->video_st && is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC) {
2983 if ((ret = av_packet_ref(©, &is->video_st->attached_pic)) < 0)
2985 packet_queue_put(&is->videoq, ©);
2986 packet_queue_put_nullpacket(&is->videoq, is->video_stream);
2988 is->queue_attachments_req = 0;
2991 /* if the queue are full, no need to read more */
2992 if (infinite_buffer<1 &&
2993 (is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
2994 || (stream_has_enough_packets(is->audio_st, is->audio_stream, &is->audioq) &&
2995 stream_has_enough_packets(is->video_st, is->video_stream, &is->videoq) &&
2996 stream_has_enough_packets(is->subtitle_st, is->subtitle_stream, &is->subtitleq)))) {
2998 SDL_LockMutex(wait_mutex);
2999 SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3000 SDL_UnlockMutex(wait_mutex);
3004 (!is->audio_st || (is->auddec.finished == is->audioq.serial && frame_queue_nb_remaining(&is->sampq) == 0)) &&
3005 (!is->video_st || (is->viddec.finished == is->videoq.serial && frame_queue_nb_remaining(&is->pictq) == 0))) {
3006 if (loop != 1 && (!loop || --loop)) {
3007 stream_seek(is, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
3008 } else if (autoexit) {
3013 ret = av_read_frame(ic, pkt);
3015 if ((ret == AVERROR_EOF || avio_feof(ic->pb)) && !is->eof) {
3016 if (is->video_stream >= 0)
3017 packet_queue_put_nullpacket(&is->videoq, is->video_stream);
3018 if (is->audio_stream >= 0)
3019 packet_queue_put_nullpacket(&is->audioq, is->audio_stream);
3020 if (is->subtitle_stream >= 0)
3021 packet_queue_put_nullpacket(&is->subtitleq, is->subtitle_stream);
3024 if (ic->pb && ic->pb->error) {
3030 SDL_LockMutex(wait_mutex);
3031 SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3032 SDL_UnlockMutex(wait_mutex);
3037 /* check if packet is in play range specified by user, then queue, otherwise discard */
3038 stream_start_time = ic->streams[pkt->stream_index]->start_time;
3039 pkt_ts = pkt->pts == AV_NOPTS_VALUE ? pkt->dts : pkt->pts;
3040 pkt_in_play_range = duration == AV_NOPTS_VALUE ||
3041 (pkt_ts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
3042 av_q2d(ic->streams[pkt->stream_index]->time_base) -
3043 (double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
3044 <= ((double)duration / 1000000);
3045 if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
3046 packet_queue_put(&is->audioq, pkt);
3047 } else if (pkt->stream_index == is->video_stream && pkt_in_play_range
3048 && !(is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
3049 packet_queue_put(&is->videoq, pkt);
3050 } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
3051 packet_queue_put(&is->subtitleq, pkt);
3053 av_packet_unref(pkt);
3060 avformat_close_input(&ic);
3065 event.type = FF_QUIT_EVENT;
3066 event.user.data1 = is;
3067 SDL_PushEvent(&event);
3069 SDL_DestroyMutex(wait_mutex);
3073 static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
3077 is = av_mallocz(sizeof(VideoState));
3080 is->last_video_stream = is->video_stream = -1;
3081 is->last_audio_stream = is->audio_stream = -1;
3082 is->last_subtitle_stream = is->subtitle_stream = -1;
3083 is->filename = av_strdup(filename);
3086 is->iformat = iformat;
3090 /* start video display */
3091 if (frame_queue_init(&is->pictq, &is->videoq, VIDEO_PICTURE_QUEUE_SIZE, 1) < 0)
3093 if (frame_queue_init(&is->subpq, &is->subtitleq, SUBPICTURE_QUEUE_SIZE, 0) < 0)
3095 if (frame_queue_init(&is->sampq, &is->audioq, SAMPLE_QUEUE_SIZE, 1) < 0)
3098 if (packet_queue_init(&is->videoq) < 0 ||
3099 packet_queue_init(&is->audioq) < 0 ||
3100 packet_queue_init(&is->subtitleq) < 0)
3103 if (!(is->continue_read_thread = SDL_CreateCond())) {
3104 av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
3108 init_clock(&is->vidclk, &is->videoq.serial);
3109 init_clock(&is->audclk, &is->audioq.serial);
3110 init_clock(&is->extclk, &is->extclk.serial);
3111 is->audio_clock_serial = -1;
3112 if (startup_volume < 0)
3113 av_log(NULL, AV_LOG_WARNING, "-volume=%d < 0, setting to 0\n", startup_volume);
3114 if (startup_volume > 100)
3115 av_log(NULL, AV_LOG_WARNING, "-volume=%d > 100, setting to 100\n", startup_volume);
3116 startup_volume = av_clip(startup_volume, 0, 100);
3117 startup_volume = av_clip(SDL_MIX_MAXVOLUME * startup_volume / 100, 0, SDL_MIX_MAXVOLUME);
3118 is->audio_volume = startup_volume;
3120 is->av_sync_type = av_sync_type;
3121 is->read_tid = SDL_CreateThread(read_thread, "read_thread", is);
3122 if (!is->read_tid) {
3123 av_log(NULL, AV_LOG_FATAL, "SDL_CreateThread(): %s\n", SDL_GetError());
3131 static void stream_cycle_channel(VideoState *is, int codec_type)
3133 AVFormatContext *ic = is->ic;
3134 int start_index, stream_index;
3137 AVProgram *p = NULL;
3138 int nb_streams = is->ic->nb_streams;
3140 if (codec_type == AVMEDIA_TYPE_VIDEO) {
3141 start_index = is->last_video_stream;
3142 old_index = is->video_stream;
3143 } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
3144 start_index = is->last_audio_stream;
3145 old_index = is->audio_stream;
3147 start_index = is->last_subtitle_stream;
3148 old_index = is->subtitle_stream;
3150 stream_index = start_index;
3152 if (codec_type != AVMEDIA_TYPE_VIDEO && is->video_stream != -1) {
3153 p = av_find_program_from_stream(ic, NULL, is->video_stream);
3155 nb_streams = p->nb_stream_indexes;
3156 for (start_index = 0; start_index < nb_streams; start_index++)
3157 if (p->stream_index[start_index] == stream_index)
3159 if (start_index == nb_streams)
3161 stream_index = start_index;
3166 if (++stream_index >= nb_streams)
3168 if (codec_type == AVMEDIA_TYPE_SUBTITLE)
3171 is->last_subtitle_stream = -1;
3174 if (start_index == -1)
3178 if (stream_index == start_index)
3180 st = is->ic->streams[p ? p->stream_index[stream_index] : stream_index];
3181 if (st->codecpar->codec_type == codec_type) {
3182 /* check that parameters are OK */
3183 switch (codec_type) {
3184 case AVMEDIA_TYPE_AUDIO:
3185 if (st->codecpar->sample_rate != 0 &&
3186 st->codecpar->channels != 0)
3189 case AVMEDIA_TYPE_VIDEO:
3190 case AVMEDIA_TYPE_SUBTITLE:
3198 if (p && stream_index != -1)
3199 stream_index = p->stream_index[stream_index];
3200 av_log(NULL, AV_LOG_INFO, "Switch %s stream from #%d to #%d\n",
3201 av_get_media_type_string(codec_type),
3205 stream_component_close(is, old_index);
3206 stream_component_open(is, stream_index);
3210 static void toggle_full_screen(VideoState *is)
3212 is_full_screen = !is_full_screen;
3213 SDL_SetWindowFullscreen(window, is_full_screen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
3216 static void toggle_audio_display(VideoState *is)
3218 int next = is->show_mode;
3220 next = (next + 1) % SHOW_MODE_NB;
3221 } while (next != is->show_mode && (next == SHOW_MODE_VIDEO && !is->video_st || next != SHOW_MODE_VIDEO && !is->audio_st));
3222 if (is->show_mode != next) {
3223 is->force_refresh = 1;
3224 is->show_mode = next;
3228 static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
3229 double remaining_time = 0.0;
3231 while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) {
3232 if (!cursor_hidden && av_gettime_relative() - cursor_last_shown > CURSOR_HIDE_DELAY) {
3236 if (remaining_time > 0.0)
3237 av_usleep((int64_t)(remaining_time * 1000000.0));
3238 remaining_time = REFRESH_RATE;
3239 if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
3240 video_refresh(is, &remaining_time);
3245 static void seek_chapter(VideoState *is, int incr)
3247 int64_t pos = get_master_clock(is) * AV_TIME_BASE;
3250 if (!is->ic->nb_chapters)
3253 /* find the current chapter */
3254 for (i = 0; i < is->ic->nb_chapters; i++) {
3255 AVChapter *ch = is->ic->chapters[i];
3256 if (av_compare_ts(pos, AV_TIME_BASE_Q, ch->start, ch->time_base) < 0) {
3264 if (i >= is->ic->nb_chapters)
3267 av_log(NULL, AV_LOG_VERBOSE, "Seeking to chapter %d.\n", i);
3268 stream_seek(is, av_rescale_q(is->ic->chapters[i]->start, is->ic->chapters[i]->time_base,
3269 AV_TIME_BASE_Q), 0, 0);
3272 /* handle an event sent by the GUI */
3273 static void event_loop(VideoState *cur_stream)
3276 double incr, pos, frac;
3280 refresh_loop_wait_event(cur_stream, &event);
3281 switch (event.type) {
3283 if (exit_on_keydown || event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_q) {
3284 do_exit(cur_stream);
3287 // If we don't yet have a window, skip all key events, because read_thread might still be initializing...
3288 if (!cur_stream->width)
3290 switch (event.key.keysym.sym) {
3292 toggle_full_screen(cur_stream);
3293 cur_stream->force_refresh = 1;
3297 toggle_pause(cur_stream);
3300 toggle_mute(cur_stream);
3302 case SDLK_KP_MULTIPLY:
3304 update_volume(cur_stream, 1, SDL_VOLUME_STEP);
3306 case SDLK_KP_DIVIDE:
3308 update_volume(cur_stream, -1, SDL_VOLUME_STEP);
3310 case SDLK_s: // S: Step to next frame
3311 step_to_next_frame(cur_stream);
3314 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3317 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3320 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3321 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3322 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3325 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3329 if (cur_stream->show_mode == SHOW_MODE_VIDEO && cur_stream->vfilter_idx < nb_vfilters - 1) {
3330 if (++cur_stream->vfilter_idx >= nb_vfilters)
3331 cur_stream->vfilter_idx = 0;
3333 cur_stream->vfilter_idx = 0;
3334 toggle_audio_display(cur_stream);
3337 toggle_audio_display(cur_stream);
3341 if (cur_stream->ic->nb_chapters <= 1) {
3345 seek_chapter(cur_stream, 1);
3348 if (cur_stream->ic->nb_chapters <= 1) {
3352 seek_chapter(cur_stream, -1);
3355 incr = seek_interval ? -seek_interval : -10.0;
3358 incr = seek_interval ? seek_interval : 10.0;
3366 if (seek_by_bytes) {
3368 if (pos < 0 && cur_stream->video_stream >= 0)
3369 pos = frame_queue_last_pos(&cur_stream->pictq);
3370 if (pos < 0 && cur_stream->audio_stream >= 0)
3371 pos = frame_queue_last_pos(&cur_stream->sampq);
3373 pos = avio_tell(cur_stream->ic->pb);
3374 if (cur_stream->ic->bit_rate)
3375 incr *= cur_stream->ic->bit_rate / 8.0;
3379 stream_seek(cur_stream, pos, incr, 1);
3381 pos = get_master_clock(cur_stream);
3383 pos = (double)cur_stream->seek_pos / AV_TIME_BASE;
3385 if (cur_stream->ic->start_time != AV_NOPTS_VALUE && pos < cur_stream->ic->start_time / (double)AV_TIME_BASE)
3386 pos = cur_stream->ic->start_time / (double)AV_TIME_BASE;
3387 stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE), 0);
3394 case SDL_MOUSEBUTTONDOWN:
3395 if (exit_on_mousedown) {
3396 do_exit(cur_stream);
3399 if (event.button.button == SDL_BUTTON_LEFT) {
3400 static int64_t last_mouse_left_click = 0;
3401 if (av_gettime_relative() - last_mouse_left_click <= 500000) {
3402 toggle_full_screen(cur_stream);
3403 cur_stream->force_refresh = 1;
3404 last_mouse_left_click = 0;
3406 last_mouse_left_click = av_gettime_relative();
3409 case SDL_MOUSEMOTION:
3410 if (cursor_hidden) {
3414 cursor_last_shown = av_gettime_relative();
3415 if (event.type == SDL_MOUSEBUTTONDOWN) {
3416 if (event.button.button != SDL_BUTTON_RIGHT)
3420 if (!(event.motion.state & SDL_BUTTON_RMASK))
3424 if (seek_by_bytes || cur_stream->ic->duration <= 0) {
3425 uint64_t size = avio_size(cur_stream->ic->pb);
3426 stream_seek(cur_stream, size*x/cur_stream->width, 0, 1);
3430 int tns, thh, tmm, tss;
3431 tns = cur_stream->ic->duration / 1000000LL;
3433 tmm = (tns % 3600) / 60;
3435 frac = x / cur_stream->width;
3438 mm = (ns % 3600) / 60;
3440 av_log(NULL, AV_LOG_INFO,
3441 "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d) \n", frac*100,
3442 hh, mm, ss, thh, tmm, tss);
3443 ts = frac * cur_stream->ic->duration;
3444 if (cur_stream->ic->start_time != AV_NOPTS_VALUE)
3445 ts += cur_stream->ic->start_time;
3446 stream_seek(cur_stream, ts, 0, 0);
3449 case SDL_WINDOWEVENT:
3450 switch (event.window.event) {
3451 case SDL_WINDOWEVENT_SIZE_CHANGED:
3452 screen_width = cur_stream->width = event.window.data1;
3453 screen_height = cur_stream->height = event.window.data2;
3454 if (cur_stream->vis_texture) {
3455 SDL_DestroyTexture(cur_stream->vis_texture);
3456 cur_stream->vis_texture = NULL;
3458 case SDL_WINDOWEVENT_EXPOSED:
3459 cur_stream->force_refresh = 1;
3464 do_exit(cur_stream);
3472 static int opt_frame_size(void *optctx, const char *opt, const char *arg)
3474 av_log(NULL, AV_LOG_WARNING, "Option -s is deprecated, use -video_size.\n");
3475 return opt_default(NULL, "video_size", arg);
3478 static int opt_width(void *optctx, const char *opt, const char *arg)
3480 screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3484 static int opt_height(void *optctx, const char *opt, const char *arg)
3486 screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3490 static int opt_format(void *optctx, const char *opt, const char *arg)
3492 file_iformat = av_find_input_format(arg);
3493 if (!file_iformat) {
3494 av_log(NULL, AV_LOG_FATAL, "Unknown input format: %s\n", arg);
3495 return AVERROR(EINVAL);
3500 static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
3502 av_log(NULL, AV_LOG_WARNING, "Option -pix_fmt is deprecated, use -pixel_format.\n");
3503 return opt_default(NULL, "pixel_format", arg);
3506 static int opt_sync(void *optctx, const char *opt, const char *arg)
3508 if (!strcmp(arg, "audio"))
3509 av_sync_type = AV_SYNC_AUDIO_MASTER;
3510 else if (!strcmp(arg, "video"))
3511 av_sync_type = AV_SYNC_VIDEO_MASTER;
3512 else if (!strcmp(arg, "ext"))
3513 av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
3515 av_log(NULL, AV_LOG_ERROR, "Unknown value for %s: %s\n", opt, arg);
3521 static int opt_seek(void *optctx, const char *opt, const char *arg)
3523 start_time = parse_time_or_die(opt, arg, 1);
3527 static int opt_duration(void *optctx, const char *opt, const char *arg)
3529 duration = parse_time_or_die(opt, arg, 1);
3533 static int opt_show_mode(void *optctx, const char *opt, const char *arg)
3535 show_mode = !strcmp(arg, "video") ? SHOW_MODE_VIDEO :
3536 !strcmp(arg, "waves") ? SHOW_MODE_WAVES :
3537 !strcmp(arg, "rdft" ) ? SHOW_MODE_RDFT :
3538 parse_number_or_die(opt, arg, OPT_INT, 0, SHOW_MODE_NB-1);
3542 static void opt_input_file(void *optctx, const char *filename)
3544 if (input_filename) {
3545 av_log(NULL, AV_LOG_FATAL,
3546 "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3547 filename, input_filename);
3550 if (!strcmp(filename, "-"))
3552 input_filename = filename;
3555 static int opt_codec(void *optctx, const char *opt, const char *arg)
3557 const char *spec = strchr(opt, ':');
3559 av_log(NULL, AV_LOG_ERROR,
3560 "No media specifier was specified in '%s' in option '%s'\n",
3562 return AVERROR(EINVAL);
3566 case 'a' : audio_codec_name = arg; break;
3567 case 's' : subtitle_codec_name = arg; break;
3568 case 'v' : video_codec_name = arg; break;
3570 av_log(NULL, AV_LOG_ERROR,
3571 "Invalid media specifier '%s' in option '%s'\n", spec, opt);
3572 return AVERROR(EINVAL);
3579 static const OptionDef options[] = {
3580 CMDUTILS_COMMON_OPTIONS
3581 { "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
3582 { "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
3583 { "s", HAS_ARG | OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
3584 { "fs", OPT_BOOL, { &is_full_screen }, "force full screen" },
3585 { "an", OPT_BOOL, { &audio_disable }, "disable audio" },
3586 { "vn", OPT_BOOL, { &video_disable }, "disable video" },
3587 { "sn", OPT_BOOL, { &subtitle_disable }, "disable subtitling" },
3588 { "ast", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_specifier" },
3589 { "vst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_specifier" },
3590 { "sst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_specifier" },
3591 { "ss", HAS_ARG, { .func_arg = opt_seek }, "seek to a given position in seconds", "pos" },
3592 { "t", HAS_ARG, { .func_arg = opt_duration }, "play \"duration\" seconds of audio/video", "duration" },
3593 { "bytes", OPT_INT | HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
3594 { "seek_interval", OPT_FLOAT | HAS_ARG, { &seek_interval }, "set seek interval for left/right keys, in seconds", "seconds" },
3595 { "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
3596 { "noborder", OPT_BOOL, { &borderless }, "borderless window" },
3597 { "alwaysontop", OPT_BOOL, { &alwaysontop }, "window always on top" },
3598 { "volume", OPT_INT | HAS_ARG, { &startup_volume}, "set startup volume 0=min 100=max", "volume" },
3599 { "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
3600 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
3601 { "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" },
3602 { "fast", OPT_BOOL | OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
3603 { "genpts", OPT_BOOL | OPT_EXPERT, { &genpts }, "generate pts", "" },
3604 { "drp", OPT_INT | HAS_ARG | OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
3605 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, { &lowres }, "", "" },
3606 { "sync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
3607 { "autoexit", OPT_BOOL | OPT_EXPERT, { &autoexit }, "exit at the end", "" },
3608 { "exitonkeydown", OPT_BOOL | OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
3609 { "exitonmousedown", OPT_BOOL | OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
3610 { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
3611 { "framedrop", OPT_BOOL | OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
3612 { "infbuf", OPT_BOOL | OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
3613 { "window_title", OPT_STRING | HAS_ARG, { &window_title }, "set window title", "window title" },
3614 { "left", OPT_INT | HAS_ARG | OPT_EXPERT, { &screen_left }, "set the x position for the left of the window", "x pos" },
3615 { "top", OPT_INT | HAS_ARG | OPT_EXPERT, { &screen_top }, "set the y position for the top of the window", "y pos" },
3617 { "vf", OPT_EXPERT | HAS_ARG, { .func_arg = opt_add_vfilter }, "set video filters", "filter_graph" },
3618 { "af", OPT_STRING | HAS_ARG, { &afilters }, "set audio filters", "filter_graph" },
3620 { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
3621 { "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
3622 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default }, "generic catch all option", "" },
3623 { "i", OPT_BOOL, { &dummy}, "read specified file", "input_file"},
3624 { "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
3625 { "acodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &audio_codec_name }, "force audio decoder", "decoder_name" },
3626 { "scodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
3627 { "vcodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &video_codec_name }, "force video decoder", "decoder_name" },
3628 { "autorotate", OPT_BOOL, { &autorotate }, "automatically rotate video", "" },
3629 { "find_stream_info", OPT_BOOL | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3630 "read and decode the streams to fill missing information with heuristics" },
3631 { "filter_threads", HAS_ARG | OPT_INT | OPT_EXPERT, { &filter_nbthreads }, "number of filter threads per graph" },
3635 static void show_usage(void)
3637 av_log(NULL, AV_LOG_INFO, "Simple media player\n");
3638 av_log(NULL, AV_LOG_INFO, "usage: %s [options] input_file\n", program_name);
3639 av_log(NULL, AV_LOG_INFO, "\n");
3642 void show_help_default(const char *opt, const char *arg)
3644 av_log_set_callback(log_callback_help);
3646 show_help_options(options, "Main options:", 0, OPT_EXPERT, 0);
3647 show_help_options(options, "Advanced options:", OPT_EXPERT, 0, 0);
3649 show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3650 show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3651 #if !CONFIG_AVFILTER
3652 show_help_children(sws_get_class(), AV_OPT_FLAG_ENCODING_PARAM);
3654 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
3656 printf("\nWhile playing:\n"
3658 "f toggle full screen\n"
3661 "9, 0 decrease and increase volume respectively\n"
3662 "/, * decrease and increase volume respectively\n"
3663 "a cycle audio channel in the current program\n"
3664 "v cycle video channel\n"
3665 "t cycle subtitle channel in the current program\n"
3667 "w cycle video filters or show modes\n"
3668 "s activate frame-step mode\n"
3669 "left/right seek backward/forward 10 seconds or to custom interval if -seek_interval is set\n"
3670 "down/up seek backward/forward 1 minute\n"
3671 "page down/page up seek backward/forward 10 minutes\n"
3672 "right mouse click seek to percentage in file corresponding to fraction of width\n"
3673 "left double-click toggle full screen\n"
3677 /* Called from the main */
3678 int main(int argc, char **argv)
3685 av_log_set_flags(AV_LOG_SKIP_REPEATED);
3686 parse_loglevel(argc, argv, options);
3688 /* register all codecs, demux and protocols */
3690 avdevice_register_all();
3692 avformat_network_init();
3696 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
3697 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
3699 show_banner(argc, argv, options);
3701 parse_options(NULL, argc, argv, options, opt_input_file);
3703 if (!input_filename) {
3705 av_log(NULL, AV_LOG_FATAL, "An input file must be specified\n");
3706 av_log(NULL, AV_LOG_FATAL,
3707 "Use -h to get full help or, even better, run 'man %s'\n", program_name);
3711 if (display_disable) {
3714 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
3716 flags &= ~SDL_INIT_AUDIO;
3718 /* Try to work around an occasional ALSA buffer underflow issue when the
3719 * period size is NPOT due to ALSA resampling by forcing the buffer size. */
3720 if (!SDL_getenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE"))
3721 SDL_setenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE","1", 1);
3723 if (display_disable)
3724 flags &= ~SDL_INIT_VIDEO;
3725 if (SDL_Init (flags)) {
3726 av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n", SDL_GetError());
3727 av_log(NULL, AV_LOG_FATAL, "(Did you set the DISPLAY variable?)\n");
3731 SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
3732 SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
3734 if (!display_disable) {
3735 int flags = SDL_WINDOW_HIDDEN;
3737 #if SDL_VERSION_ATLEAST(2,0,5)
3738 flags |= SDL_WINDOW_ALWAYS_ON_TOP;
3740 av_log(NULL, AV_LOG_WARNING, "Your SDL version doesn't support SDL_WINDOW_ALWAYS_ON_TOP. Feature will be inactive.\n");
3743 flags |= SDL_WINDOW_BORDERLESS;
3745 flags |= SDL_WINDOW_RESIZABLE;
3746 window = SDL_CreateWindow(program_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, default_width, default_height, flags);
3747 SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
3749 renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
3751 av_log(NULL, AV_LOG_WARNING, "Failed to initialize a hardware accelerated renderer: %s\n", SDL_GetError());
3752 renderer = SDL_CreateRenderer(window, -1, 0);
3755 if (!SDL_GetRendererInfo(renderer, &renderer_info))
3756 av_log(NULL, AV_LOG_VERBOSE, "Initialized %s renderer.\n", renderer_info.name);
3759 if (!window || !renderer || !renderer_info.num_texture_formats) {
3760 av_log(NULL, AV_LOG_FATAL, "Failed to create window or renderer: %s", SDL_GetError());
3765 is = stream_open(input_filename, file_iformat);
3767 av_log(NULL, AV_LOG_FATAL, "Failed to initialize VideoState!\n");