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/fifo.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/samplefmt.h"
42 #include "libavutil/avassert.h"
43 #include "libavutil/time.h"
44 #include "libavutil/bprint.h"
45 #include "libavformat/avformat.h"
46 #include "libavdevice/avdevice.h"
47 #include "libswscale/swscale.h"
48 #include "libavutil/opt.h"
49 #include "libavcodec/avfft.h"
50 #include "libswresample/swresample.h"
53 # include "libavfilter/avfilter.h"
54 # include "libavfilter/buffersink.h"
55 # include "libavfilter/buffersrc.h"
59 #include <SDL_thread.h>
65 const char program_name[] = "ffplay";
66 const int program_birth_year = 2003;
68 #define MAX_QUEUE_SIZE (15 * 1024 * 1024)
70 #define EXTERNAL_CLOCK_MIN_FRAMES 2
71 #define EXTERNAL_CLOCK_MAX_FRAMES 10
73 /* Minimum SDL audio buffer size, in samples. */
74 #define SDL_AUDIO_MIN_BUFFER_SIZE 512
75 /* Calculate actual buffer size keeping in mind not cause too frequent audio callbacks */
76 #define SDL_AUDIO_MAX_CALLBACKS_PER_SEC 30
78 /* Step size for volume control in dB */
79 #define SDL_VOLUME_STEP (0.75)
81 /* no AV sync correction is done if below the minimum AV sync threshold */
82 #define AV_SYNC_THRESHOLD_MIN 0.04
83 /* AV sync correction is done if above the maximum AV sync threshold */
84 #define AV_SYNC_THRESHOLD_MAX 0.1
85 /* If a frame duration is longer than this, it will not be duplicated to compensate AV sync */
86 #define AV_SYNC_FRAMEDUP_THRESHOLD 0.1
87 /* no AV correction is done if too big error */
88 #define AV_NOSYNC_THRESHOLD 10.0
90 /* maximum audio speed change to get correct sync */
91 #define SAMPLE_CORRECTION_PERCENT_MAX 10
93 /* external clock speed adjustment constants for realtime sources based on buffer fullness */
94 #define EXTERNAL_CLOCK_SPEED_MIN 0.900
95 #define EXTERNAL_CLOCK_SPEED_MAX 1.010
96 #define EXTERNAL_CLOCK_SPEED_STEP 0.001
98 /* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
99 #define AUDIO_DIFF_AVG_NB 20
101 /* polls for possible required screen refresh at least this often, should be less than 1/fps */
102 #define REFRESH_RATE 0.01
104 /* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
105 /* TODO: We assume that a decoded and resampled frame fits into this buffer */
106 #define SAMPLE_ARRAY_SIZE (8 * 65536)
108 #define CURSOR_HIDE_DELAY 1000000
110 #define USE_ONEPASS_SUBTITLE_RENDER 1
112 static unsigned sws_flags = SWS_BICUBIC;
114 typedef struct MyAVPacketList {
119 typedef struct PacketQueue {
120 AVFifoBuffer *pkt_list;
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)
430 if (q->abort_request)
433 if (av_fifo_space(q->pkt_list) < sizeof(pkt1)) {
434 if (av_fifo_grow(q->pkt_list, sizeof(pkt1)) < 0)
439 pkt1.serial = q->serial;
441 av_fifo_generic_write(q->pkt_list, &pkt1, sizeof(pkt1), NULL);
443 q->size += pkt1.pkt->size + sizeof(pkt1);
444 q->duration += pkt1.pkt->duration;
445 /* XXX: should duplicate packet data in DV case */
446 SDL_CondSignal(q->cond);
450 static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
455 pkt1 = av_packet_alloc();
457 av_packet_unref(pkt);
460 av_packet_move_ref(pkt1, pkt);
462 SDL_LockMutex(q->mutex);
463 ret = packet_queue_put_private(q, pkt1);
464 SDL_UnlockMutex(q->mutex);
467 av_packet_free(&pkt1);
472 static int packet_queue_put_nullpacket(PacketQueue *q, AVPacket *pkt, int stream_index)
474 pkt->stream_index = stream_index;
475 return packet_queue_put(q, pkt);
478 /* packet queue handling */
479 static int packet_queue_init(PacketQueue *q)
481 memset(q, 0, sizeof(PacketQueue));
482 q->pkt_list = av_fifo_alloc(sizeof(MyAVPacketList));
484 return AVERROR(ENOMEM);
485 q->mutex = SDL_CreateMutex();
487 av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
488 return AVERROR(ENOMEM);
490 q->cond = SDL_CreateCond();
492 av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
493 return AVERROR(ENOMEM);
495 q->abort_request = 1;
499 static void packet_queue_flush(PacketQueue *q)
503 SDL_LockMutex(q->mutex);
504 while (av_fifo_size(q->pkt_list) >= sizeof(pkt1)) {
505 av_fifo_generic_read(q->pkt_list, &pkt1, sizeof(pkt1), NULL);
506 av_packet_free(&pkt1.pkt);
512 SDL_UnlockMutex(q->mutex);
515 static void packet_queue_destroy(PacketQueue *q)
517 packet_queue_flush(q);
518 av_fifo_freep(&q->pkt_list);
519 SDL_DestroyMutex(q->mutex);
520 SDL_DestroyCond(q->cond);
523 static void packet_queue_abort(PacketQueue *q)
525 SDL_LockMutex(q->mutex);
527 q->abort_request = 1;
529 SDL_CondSignal(q->cond);
531 SDL_UnlockMutex(q->mutex);
534 static void packet_queue_start(PacketQueue *q)
536 SDL_LockMutex(q->mutex);
537 q->abort_request = 0;
539 SDL_UnlockMutex(q->mutex);
542 /* return < 0 if aborted, 0 if no packet and > 0 if packet. */
543 static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)
548 SDL_LockMutex(q->mutex);
551 if (q->abort_request) {
556 if (av_fifo_size(q->pkt_list) >= sizeof(pkt1)) {
557 av_fifo_generic_read(q->pkt_list, &pkt1, sizeof(pkt1), NULL);
559 q->size -= pkt1.pkt->size + sizeof(pkt1);
560 q->duration -= pkt1.pkt->duration;
561 av_packet_move_ref(pkt, pkt1.pkt);
563 *serial = pkt1.serial;
564 av_packet_free(&pkt1.pkt);
571 SDL_CondWait(q->cond, q->mutex);
574 SDL_UnlockMutex(q->mutex);
578 static int decoder_init(Decoder *d, AVCodecContext *avctx, PacketQueue *queue, SDL_cond *empty_queue_cond) {
579 memset(d, 0, sizeof(Decoder));
580 d->pkt = av_packet_alloc();
582 return AVERROR(ENOMEM);
585 d->empty_queue_cond = empty_queue_cond;
586 d->start_pts = AV_NOPTS_VALUE;
591 static int decoder_decode_frame(Decoder *d, AVFrame *frame, AVSubtitle *sub) {
592 int ret = AVERROR(EAGAIN);
595 if (d->queue->serial == d->pkt_serial) {
597 if (d->queue->abort_request)
600 switch (d->avctx->codec_type) {
601 case AVMEDIA_TYPE_VIDEO:
602 ret = avcodec_receive_frame(d->avctx, frame);
604 if (decoder_reorder_pts == -1) {
605 frame->pts = frame->best_effort_timestamp;
606 } else if (!decoder_reorder_pts) {
607 frame->pts = frame->pkt_dts;
611 case AVMEDIA_TYPE_AUDIO:
612 ret = avcodec_receive_frame(d->avctx, frame);
614 AVRational tb = (AVRational){1, frame->sample_rate};
615 if (frame->pts != AV_NOPTS_VALUE)
616 frame->pts = av_rescale_q(frame->pts, d->avctx->pkt_timebase, tb);
617 else if (d->next_pts != AV_NOPTS_VALUE)
618 frame->pts = av_rescale_q(d->next_pts, d->next_pts_tb, tb);
619 if (frame->pts != AV_NOPTS_VALUE) {
620 d->next_pts = frame->pts + frame->nb_samples;
626 if (ret == AVERROR_EOF) {
627 d->finished = d->pkt_serial;
628 avcodec_flush_buffers(d->avctx);
633 } while (ret != AVERROR(EAGAIN));
637 if (d->queue->nb_packets == 0)
638 SDL_CondSignal(d->empty_queue_cond);
639 if (d->packet_pending) {
640 d->packet_pending = 0;
642 int old_serial = d->pkt_serial;
643 if (packet_queue_get(d->queue, d->pkt, 1, &d->pkt_serial) < 0)
645 if (old_serial != d->pkt_serial) {
646 avcodec_flush_buffers(d->avctx);
648 d->next_pts = d->start_pts;
649 d->next_pts_tb = d->start_pts_tb;
652 if (d->queue->serial == d->pkt_serial)
654 av_packet_unref(d->pkt);
658 if (d->avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
660 ret = avcodec_decode_subtitle2(d->avctx, sub, &got_frame, d->pkt);
662 ret = AVERROR(EAGAIN);
664 if (got_frame && !d->pkt->data) {
665 d->packet_pending = 1;
667 ret = got_frame ? 0 : (d->pkt->data ? AVERROR(EAGAIN) : AVERROR_EOF);
669 av_packet_unref(d->pkt);
671 if (avcodec_send_packet(d->avctx, d->pkt) == AVERROR(EAGAIN)) {
672 av_log(d->avctx, AV_LOG_ERROR, "Receive_frame and send_packet both returned EAGAIN, which is an API violation.\n");
673 d->packet_pending = 1;
675 av_packet_unref(d->pkt);
682 static void decoder_destroy(Decoder *d) {
683 av_packet_free(&d->pkt);
684 avcodec_free_context(&d->avctx);
687 static void frame_queue_unref_item(Frame *vp)
689 av_frame_unref(vp->frame);
690 avsubtitle_free(&vp->sub);
693 static int frame_queue_init(FrameQueue *f, PacketQueue *pktq, int max_size, int keep_last)
696 memset(f, 0, sizeof(FrameQueue));
697 if (!(f->mutex = SDL_CreateMutex())) {
698 av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
699 return AVERROR(ENOMEM);
701 if (!(f->cond = SDL_CreateCond())) {
702 av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
703 return AVERROR(ENOMEM);
706 f->max_size = FFMIN(max_size, FRAME_QUEUE_SIZE);
707 f->keep_last = !!keep_last;
708 for (i = 0; i < f->max_size; i++)
709 if (!(f->queue[i].frame = av_frame_alloc()))
710 return AVERROR(ENOMEM);
714 static void frame_queue_destory(FrameQueue *f)
717 for (i = 0; i < f->max_size; i++) {
718 Frame *vp = &f->queue[i];
719 frame_queue_unref_item(vp);
720 av_frame_free(&vp->frame);
722 SDL_DestroyMutex(f->mutex);
723 SDL_DestroyCond(f->cond);
726 static void frame_queue_signal(FrameQueue *f)
728 SDL_LockMutex(f->mutex);
729 SDL_CondSignal(f->cond);
730 SDL_UnlockMutex(f->mutex);
733 static Frame *frame_queue_peek(FrameQueue *f)
735 return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
738 static Frame *frame_queue_peek_next(FrameQueue *f)
740 return &f->queue[(f->rindex + f->rindex_shown + 1) % f->max_size];
743 static Frame *frame_queue_peek_last(FrameQueue *f)
745 return &f->queue[f->rindex];
748 static Frame *frame_queue_peek_writable(FrameQueue *f)
750 /* wait until we have space to put a new frame */
751 SDL_LockMutex(f->mutex);
752 while (f->size >= f->max_size &&
753 !f->pktq->abort_request) {
754 SDL_CondWait(f->cond, f->mutex);
756 SDL_UnlockMutex(f->mutex);
758 if (f->pktq->abort_request)
761 return &f->queue[f->windex];
764 static Frame *frame_queue_peek_readable(FrameQueue *f)
766 /* wait until we have a readable a new frame */
767 SDL_LockMutex(f->mutex);
768 while (f->size - f->rindex_shown <= 0 &&
769 !f->pktq->abort_request) {
770 SDL_CondWait(f->cond, f->mutex);
772 SDL_UnlockMutex(f->mutex);
774 if (f->pktq->abort_request)
777 return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
780 static void frame_queue_push(FrameQueue *f)
782 if (++f->windex == f->max_size)
784 SDL_LockMutex(f->mutex);
786 SDL_CondSignal(f->cond);
787 SDL_UnlockMutex(f->mutex);
790 static void frame_queue_next(FrameQueue *f)
792 if (f->keep_last && !f->rindex_shown) {
796 frame_queue_unref_item(&f->queue[f->rindex]);
797 if (++f->rindex == f->max_size)
799 SDL_LockMutex(f->mutex);
801 SDL_CondSignal(f->cond);
802 SDL_UnlockMutex(f->mutex);
805 /* return the number of undisplayed frames in the queue */
806 static int frame_queue_nb_remaining(FrameQueue *f)
808 return f->size - f->rindex_shown;
811 /* return last shown position */
812 static int64_t frame_queue_last_pos(FrameQueue *f)
814 Frame *fp = &f->queue[f->rindex];
815 if (f->rindex_shown && fp->serial == f->pktq->serial)
821 static void decoder_abort(Decoder *d, FrameQueue *fq)
823 packet_queue_abort(d->queue);
824 frame_queue_signal(fq);
825 SDL_WaitThread(d->decoder_tid, NULL);
826 d->decoder_tid = NULL;
827 packet_queue_flush(d->queue);
830 static inline void fill_rectangle(int x, int y, int w, int h)
838 SDL_RenderFillRect(renderer, &rect);
841 static int realloc_texture(SDL_Texture **texture, Uint32 new_format, int new_width, int new_height, SDL_BlendMode blendmode, int init_texture)
845 if (!*texture || SDL_QueryTexture(*texture, &format, &access, &w, &h) < 0 || new_width != w || new_height != h || new_format != format) {
849 SDL_DestroyTexture(*texture);
850 if (!(*texture = SDL_CreateTexture(renderer, new_format, SDL_TEXTUREACCESS_STREAMING, new_width, new_height)))
852 if (SDL_SetTextureBlendMode(*texture, blendmode) < 0)
855 if (SDL_LockTexture(*texture, NULL, &pixels, &pitch) < 0)
857 memset(pixels, 0, pitch * new_height);
858 SDL_UnlockTexture(*texture);
860 av_log(NULL, AV_LOG_VERBOSE, "Created %dx%d texture with %s.\n", new_width, new_height, SDL_GetPixelFormatName(new_format));
865 static void calculate_display_rect(SDL_Rect *rect,
866 int scr_xleft, int scr_ytop, int scr_width, int scr_height,
867 int pic_width, int pic_height, AVRational pic_sar)
869 AVRational aspect_ratio = pic_sar;
870 int64_t width, height, x, y;
872 if (av_cmp_q(aspect_ratio, av_make_q(0, 1)) <= 0)
873 aspect_ratio = av_make_q(1, 1);
875 aspect_ratio = av_mul_q(aspect_ratio, av_make_q(pic_width, pic_height));
877 /* XXX: we suppose the screen has a 1.0 pixel ratio */
879 width = av_rescale(height, aspect_ratio.num, aspect_ratio.den) & ~1;
880 if (width > scr_width) {
882 height = av_rescale(width, aspect_ratio.den, aspect_ratio.num) & ~1;
884 x = (scr_width - width) / 2;
885 y = (scr_height - height) / 2;
886 rect->x = scr_xleft + x;
887 rect->y = scr_ytop + y;
888 rect->w = FFMAX((int)width, 1);
889 rect->h = FFMAX((int)height, 1);
892 static void get_sdl_pix_fmt_and_blendmode(int format, Uint32 *sdl_pix_fmt, SDL_BlendMode *sdl_blendmode)
895 *sdl_blendmode = SDL_BLENDMODE_NONE;
896 *sdl_pix_fmt = SDL_PIXELFORMAT_UNKNOWN;
897 if (format == AV_PIX_FMT_RGB32 ||
898 format == AV_PIX_FMT_RGB32_1 ||
899 format == AV_PIX_FMT_BGR32 ||
900 format == AV_PIX_FMT_BGR32_1)
901 *sdl_blendmode = SDL_BLENDMODE_BLEND;
902 for (i = 0; i < FF_ARRAY_ELEMS(sdl_texture_format_map) - 1; i++) {
903 if (format == sdl_texture_format_map[i].format) {
904 *sdl_pix_fmt = sdl_texture_format_map[i].texture_fmt;
910 static int upload_texture(SDL_Texture **tex, AVFrame *frame, struct SwsContext **img_convert_ctx) {
913 SDL_BlendMode sdl_blendmode;
914 get_sdl_pix_fmt_and_blendmode(frame->format, &sdl_pix_fmt, &sdl_blendmode);
915 if (realloc_texture(tex, sdl_pix_fmt == SDL_PIXELFORMAT_UNKNOWN ? SDL_PIXELFORMAT_ARGB8888 : sdl_pix_fmt, frame->width, frame->height, sdl_blendmode, 0) < 0)
917 switch (sdl_pix_fmt) {
918 case SDL_PIXELFORMAT_UNKNOWN:
919 /* This should only happen if we are not using avfilter... */
920 *img_convert_ctx = sws_getCachedContext(*img_convert_ctx,
921 frame->width, frame->height, frame->format, frame->width, frame->height,
922 AV_PIX_FMT_BGRA, sws_flags, NULL, NULL, NULL);
923 if (*img_convert_ctx != NULL) {
926 if (!SDL_LockTexture(*tex, NULL, (void **)pixels, pitch)) {
927 sws_scale(*img_convert_ctx, (const uint8_t * const *)frame->data, frame->linesize,
928 0, frame->height, pixels, pitch);
929 SDL_UnlockTexture(*tex);
932 av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
936 case SDL_PIXELFORMAT_IYUV:
937 if (frame->linesize[0] > 0 && frame->linesize[1] > 0 && frame->linesize[2] > 0) {
938 ret = SDL_UpdateYUVTexture(*tex, NULL, frame->data[0], frame->linesize[0],
939 frame->data[1], frame->linesize[1],
940 frame->data[2], frame->linesize[2]);
941 } else if (frame->linesize[0] < 0 && frame->linesize[1] < 0 && frame->linesize[2] < 0) {
942 ret = SDL_UpdateYUVTexture(*tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height - 1), -frame->linesize[0],
943 frame->data[1] + frame->linesize[1] * (AV_CEIL_RSHIFT(frame->height, 1) - 1), -frame->linesize[1],
944 frame->data[2] + frame->linesize[2] * (AV_CEIL_RSHIFT(frame->height, 1) - 1), -frame->linesize[2]);
946 av_log(NULL, AV_LOG_ERROR, "Mixed negative and positive linesizes are not supported.\n");
951 if (frame->linesize[0] < 0) {
952 ret = SDL_UpdateTexture(*tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height - 1), -frame->linesize[0]);
954 ret = SDL_UpdateTexture(*tex, NULL, frame->data[0], frame->linesize[0]);
961 static void set_sdl_yuv_conversion_mode(AVFrame *frame)
963 #if SDL_VERSION_ATLEAST(2,0,8)
964 SDL_YUV_CONVERSION_MODE mode = SDL_YUV_CONVERSION_AUTOMATIC;
965 if (frame && (frame->format == AV_PIX_FMT_YUV420P || frame->format == AV_PIX_FMT_YUYV422 || frame->format == AV_PIX_FMT_UYVY422)) {
966 if (frame->color_range == AVCOL_RANGE_JPEG)
967 mode = SDL_YUV_CONVERSION_JPEG;
968 else if (frame->colorspace == AVCOL_SPC_BT709)
969 mode = SDL_YUV_CONVERSION_BT709;
970 else if (frame->colorspace == AVCOL_SPC_BT470BG || frame->colorspace == AVCOL_SPC_SMPTE170M || frame->colorspace == AVCOL_SPC_SMPTE240M)
971 mode = SDL_YUV_CONVERSION_BT601;
973 SDL_SetYUVConversionMode(mode);
977 static void video_image_display(VideoState *is)
983 vp = frame_queue_peek_last(&is->pictq);
984 if (is->subtitle_st) {
985 if (frame_queue_nb_remaining(&is->subpq) > 0) {
986 sp = frame_queue_peek(&is->subpq);
988 if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {
993 if (!sp->width || !sp->height) {
994 sp->width = vp->width;
995 sp->height = vp->height;
997 if (realloc_texture(&is->sub_texture, SDL_PIXELFORMAT_ARGB8888, sp->width, sp->height, SDL_BLENDMODE_BLEND, 1) < 0)
1000 for (i = 0; i < sp->sub.num_rects; i++) {
1001 AVSubtitleRect *sub_rect = sp->sub.rects[i];
1003 sub_rect->x = av_clip(sub_rect->x, 0, sp->width );
1004 sub_rect->y = av_clip(sub_rect->y, 0, sp->height);
1005 sub_rect->w = av_clip(sub_rect->w, 0, sp->width - sub_rect->x);
1006 sub_rect->h = av_clip(sub_rect->h, 0, sp->height - sub_rect->y);
1008 is->sub_convert_ctx = sws_getCachedContext(is->sub_convert_ctx,
1009 sub_rect->w, sub_rect->h, AV_PIX_FMT_PAL8,
1010 sub_rect->w, sub_rect->h, AV_PIX_FMT_BGRA,
1011 0, NULL, NULL, NULL);
1012 if (!is->sub_convert_ctx) {
1013 av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
1016 if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)pixels, pitch)) {
1017 sws_scale(is->sub_convert_ctx, (const uint8_t * const *)sub_rect->data, sub_rect->linesize,
1018 0, sub_rect->h, pixels, pitch);
1019 SDL_UnlockTexture(is->sub_texture);
1029 calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp->width, vp->height, vp->sar);
1031 if (!vp->uploaded) {
1032 if (upload_texture(&is->vid_texture, vp->frame, &is->img_convert_ctx) < 0)
1035 vp->flip_v = vp->frame->linesize[0] < 0;
1038 set_sdl_yuv_conversion_mode(vp->frame);
1039 SDL_RenderCopyEx(renderer, is->vid_texture, NULL, &rect, 0, NULL, vp->flip_v ? SDL_FLIP_VERTICAL : 0);
1040 set_sdl_yuv_conversion_mode(NULL);
1042 #if USE_ONEPASS_SUBTITLE_RENDER
1043 SDL_RenderCopy(renderer, is->sub_texture, NULL, &rect);
1046 double xratio = (double)rect.w / (double)sp->width;
1047 double yratio = (double)rect.h / (double)sp->height;
1048 for (i = 0; i < sp->sub.num_rects; i++) {
1049 SDL_Rect *sub_rect = (SDL_Rect*)sp->sub.rects[i];
1050 SDL_Rect target = {.x = rect.x + sub_rect->x * xratio,
1051 .y = rect.y + sub_rect->y * yratio,
1052 .w = sub_rect->w * xratio,
1053 .h = sub_rect->h * yratio};
1054 SDL_RenderCopy(renderer, is->sub_texture, sub_rect, &target);
1060 static inline int compute_mod(int a, int b)
1062 return a < 0 ? a%b + b : a%b;
1065 static void video_audio_display(VideoState *s)
1067 int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
1068 int ch, channels, h, h2;
1070 int rdft_bits, nb_freq;
1072 for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++)
1074 nb_freq = 1 << (rdft_bits - 1);
1076 /* compute display index : center on currently output samples */
1077 channels = s->audio_tgt.channels;
1078 nb_display_channels = channels;
1080 int data_used= s->show_mode == SHOW_MODE_WAVES ? s->width : (2*nb_freq);
1082 delay = s->audio_write_buf_size;
1085 /* to be more precise, we take into account the time spent since
1086 the last buffer computation */
1087 if (audio_callback_time) {
1088 time_diff = av_gettime_relative() - audio_callback_time;
1089 delay -= (time_diff * s->audio_tgt.freq) / 1000000;
1092 delay += 2 * data_used;
1093 if (delay < data_used)
1096 i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
1097 if (s->show_mode == SHOW_MODE_WAVES) {
1099 for (i = 0; i < 1000; i += channels) {
1100 int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
1101 int a = s->sample_array[idx];
1102 int b = s->sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];
1103 int c = s->sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];
1104 int d = s->sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];
1106 if (h < score && (b ^ c) < 0) {
1113 s->last_i_start = i_start;
1115 i_start = s->last_i_start;
1118 if (s->show_mode == SHOW_MODE_WAVES) {
1119 SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
1121 /* total height for one channel */
1122 h = s->height / nb_display_channels;
1123 /* graph height / 2 */
1125 for (ch = 0; ch < nb_display_channels; ch++) {
1127 y1 = s->ytop + ch * h + (h / 2); /* position of center line */
1128 for (x = 0; x < s->width; x++) {
1129 y = (s->sample_array[i] * h2) >> 15;
1136 fill_rectangle(s->xleft + x, ys, 1, y);
1138 if (i >= SAMPLE_ARRAY_SIZE)
1139 i -= SAMPLE_ARRAY_SIZE;
1143 SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255);
1145 for (ch = 1; ch < nb_display_channels; ch++) {
1146 y = s->ytop + ch * h;
1147 fill_rectangle(s->xleft, y, s->width, 1);
1150 if (realloc_texture(&s->vis_texture, SDL_PIXELFORMAT_ARGB8888, s->width, s->height, SDL_BLENDMODE_NONE, 1) < 0)
1153 nb_display_channels= FFMIN(nb_display_channels, 2);
1154 if (rdft_bits != s->rdft_bits) {
1155 av_rdft_end(s->rdft);
1156 av_free(s->rdft_data);
1157 s->rdft = av_rdft_init(rdft_bits, DFT_R2C);
1158 s->rdft_bits = rdft_bits;
1159 s->rdft_data = av_malloc_array(nb_freq, 4 *sizeof(*s->rdft_data));
1161 if (!s->rdft || !s->rdft_data){
1162 av_log(NULL, AV_LOG_ERROR, "Failed to allocate buffers for RDFT, switching to waves display\n");
1163 s->show_mode = SHOW_MODE_WAVES;
1166 SDL_Rect rect = {.x = s->xpos, .y = 0, .w = 1, .h = s->height};
1169 for (ch = 0; ch < nb_display_channels; ch++) {
1170 data[ch] = s->rdft_data + 2 * nb_freq * ch;
1172 for (x = 0; x < 2 * nb_freq; x++) {
1173 double w = (x-nb_freq) * (1.0 / nb_freq);
1174 data[ch][x] = s->sample_array[i] * (1.0 - w * w);
1176 if (i >= SAMPLE_ARRAY_SIZE)
1177 i -= SAMPLE_ARRAY_SIZE;
1179 av_rdft_calc(s->rdft, data[ch]);
1181 /* Least efficient way to do this, we should of course
1182 * directly access it but it is more than fast enough. */
1183 if (!SDL_LockTexture(s->vis_texture, &rect, (void **)&pixels, &pitch)) {
1185 pixels += pitch * s->height;
1186 for (y = 0; y < s->height; y++) {
1187 double w = 1 / sqrt(nb_freq);
1188 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]));
1189 int b = (nb_display_channels == 2 ) ? sqrt(w * hypot(data[1][2 * y + 0], data[1][2 * y + 1]))
1194 *pixels = (a << 16) + (b << 8) + ((a+b) >> 1);
1196 SDL_UnlockTexture(s->vis_texture);
1198 SDL_RenderCopy(renderer, s->vis_texture, NULL, NULL);
1202 if (s->xpos >= s->width)
1207 static void stream_component_close(VideoState *is, int stream_index)
1209 AVFormatContext *ic = is->ic;
1210 AVCodecParameters *codecpar;
1212 if (stream_index < 0 || stream_index >= ic->nb_streams)
1214 codecpar = ic->streams[stream_index]->codecpar;
1216 switch (codecpar->codec_type) {
1217 case AVMEDIA_TYPE_AUDIO:
1218 decoder_abort(&is->auddec, &is->sampq);
1219 SDL_CloseAudioDevice(audio_dev);
1220 decoder_destroy(&is->auddec);
1221 swr_free(&is->swr_ctx);
1222 av_freep(&is->audio_buf1);
1223 is->audio_buf1_size = 0;
1224 is->audio_buf = NULL;
1227 av_rdft_end(is->rdft);
1228 av_freep(&is->rdft_data);
1233 case AVMEDIA_TYPE_VIDEO:
1234 decoder_abort(&is->viddec, &is->pictq);
1235 decoder_destroy(&is->viddec);
1237 case AVMEDIA_TYPE_SUBTITLE:
1238 decoder_abort(&is->subdec, &is->subpq);
1239 decoder_destroy(&is->subdec);
1245 ic->streams[stream_index]->discard = AVDISCARD_ALL;
1246 switch (codecpar->codec_type) {
1247 case AVMEDIA_TYPE_AUDIO:
1248 is->audio_st = NULL;
1249 is->audio_stream = -1;
1251 case AVMEDIA_TYPE_VIDEO:
1252 is->video_st = NULL;
1253 is->video_stream = -1;
1255 case AVMEDIA_TYPE_SUBTITLE:
1256 is->subtitle_st = NULL;
1257 is->subtitle_stream = -1;
1264 static void stream_close(VideoState *is)
1266 /* XXX: use a special url_shutdown call to abort parse cleanly */
1267 is->abort_request = 1;
1268 SDL_WaitThread(is->read_tid, NULL);
1270 /* close each stream */
1271 if (is->audio_stream >= 0)
1272 stream_component_close(is, is->audio_stream);
1273 if (is->video_stream >= 0)
1274 stream_component_close(is, is->video_stream);
1275 if (is->subtitle_stream >= 0)
1276 stream_component_close(is, is->subtitle_stream);
1278 avformat_close_input(&is->ic);
1280 packet_queue_destroy(&is->videoq);
1281 packet_queue_destroy(&is->audioq);
1282 packet_queue_destroy(&is->subtitleq);
1284 /* free all pictures */
1285 frame_queue_destory(&is->pictq);
1286 frame_queue_destory(&is->sampq);
1287 frame_queue_destory(&is->subpq);
1288 SDL_DestroyCond(is->continue_read_thread);
1289 sws_freeContext(is->img_convert_ctx);
1290 sws_freeContext(is->sub_convert_ctx);
1291 av_free(is->filename);
1292 if (is->vis_texture)
1293 SDL_DestroyTexture(is->vis_texture);
1294 if (is->vid_texture)
1295 SDL_DestroyTexture(is->vid_texture);
1296 if (is->sub_texture)
1297 SDL_DestroyTexture(is->sub_texture);
1301 static void do_exit(VideoState *is)
1307 SDL_DestroyRenderer(renderer);
1309 SDL_DestroyWindow(window);
1312 av_freep(&vfilters_list);
1314 avformat_network_deinit();
1318 av_log(NULL, AV_LOG_QUIET, "%s", "");
1322 static void sigterm_handler(int sig)
1327 static void set_default_window_size(int width, int height, AVRational sar)
1330 int max_width = screen_width ? screen_width : INT_MAX;
1331 int max_height = screen_height ? screen_height : INT_MAX;
1332 if (max_width == INT_MAX && max_height == INT_MAX)
1333 max_height = height;
1334 calculate_display_rect(&rect, 0, 0, max_width, max_height, width, height, sar);
1335 default_width = rect.w;
1336 default_height = rect.h;
1339 static int video_open(VideoState *is)
1343 w = screen_width ? screen_width : default_width;
1344 h = screen_height ? screen_height : default_height;
1347 window_title = input_filename;
1348 SDL_SetWindowTitle(window, window_title);
1350 SDL_SetWindowSize(window, w, h);
1351 SDL_SetWindowPosition(window, screen_left, screen_top);
1353 SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
1354 SDL_ShowWindow(window);
1362 /* display the current picture, if any */
1363 static void video_display(VideoState *is)
1368 SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
1369 SDL_RenderClear(renderer);
1370 if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
1371 video_audio_display(is);
1372 else if (is->video_st)
1373 video_image_display(is);
1374 SDL_RenderPresent(renderer);
1377 static double get_clock(Clock *c)
1379 if (*c->queue_serial != c->serial)
1384 double time = av_gettime_relative() / 1000000.0;
1385 return c->pts_drift + time - (time - c->last_updated) * (1.0 - c->speed);
1389 static void set_clock_at(Clock *c, double pts, int serial, double time)
1392 c->last_updated = time;
1393 c->pts_drift = c->pts - time;
1397 static void set_clock(Clock *c, double pts, int serial)
1399 double time = av_gettime_relative() / 1000000.0;
1400 set_clock_at(c, pts, serial, time);
1403 static void set_clock_speed(Clock *c, double speed)
1405 set_clock(c, get_clock(c), c->serial);
1409 static void init_clock(Clock *c, int *queue_serial)
1413 c->queue_serial = queue_serial;
1414 set_clock(c, NAN, -1);
1417 static void sync_clock_to_slave(Clock *c, Clock *slave)
1419 double clock = get_clock(c);
1420 double slave_clock = get_clock(slave);
1421 if (!isnan(slave_clock) && (isnan(clock) || fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))
1422 set_clock(c, slave_clock, slave->serial);
1425 static int get_master_sync_type(VideoState *is) {
1426 if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
1428 return AV_SYNC_VIDEO_MASTER;
1430 return AV_SYNC_AUDIO_MASTER;
1431 } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
1433 return AV_SYNC_AUDIO_MASTER;
1435 return AV_SYNC_EXTERNAL_CLOCK;
1437 return AV_SYNC_EXTERNAL_CLOCK;
1441 /* get the current master clock value */
1442 static double get_master_clock(VideoState *is)
1446 switch (get_master_sync_type(is)) {
1447 case AV_SYNC_VIDEO_MASTER:
1448 val = get_clock(&is->vidclk);
1450 case AV_SYNC_AUDIO_MASTER:
1451 val = get_clock(&is->audclk);
1454 val = get_clock(&is->extclk);
1460 static void check_external_clock_speed(VideoState *is) {
1461 if (is->video_stream >= 0 && is->videoq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES ||
1462 is->audio_stream >= 0 && is->audioq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES) {
1463 set_clock_speed(&is->extclk, FFMAX(EXTERNAL_CLOCK_SPEED_MIN, is->extclk.speed - EXTERNAL_CLOCK_SPEED_STEP));
1464 } else if ((is->video_stream < 0 || is->videoq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES) &&
1465 (is->audio_stream < 0 || is->audioq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES)) {
1466 set_clock_speed(&is->extclk, FFMIN(EXTERNAL_CLOCK_SPEED_MAX, is->extclk.speed + EXTERNAL_CLOCK_SPEED_STEP));
1468 double speed = is->extclk.speed;
1470 set_clock_speed(&is->extclk, speed + EXTERNAL_CLOCK_SPEED_STEP * (1.0 - speed) / fabs(1.0 - speed));
1474 /* seek in the stream */
1475 static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)
1477 if (!is->seek_req) {
1480 is->seek_flags &= ~AVSEEK_FLAG_BYTE;
1482 is->seek_flags |= AVSEEK_FLAG_BYTE;
1484 SDL_CondSignal(is->continue_read_thread);
1488 /* pause or resume the video */
1489 static void stream_toggle_pause(VideoState *is)
1492 is->frame_timer += av_gettime_relative() / 1000000.0 - is->vidclk.last_updated;
1493 if (is->read_pause_return != AVERROR(ENOSYS)) {
1494 is->vidclk.paused = 0;
1496 set_clock(&is->vidclk, get_clock(&is->vidclk), is->vidclk.serial);
1498 set_clock(&is->extclk, get_clock(&is->extclk), is->extclk.serial);
1499 is->paused = is->audclk.paused = is->vidclk.paused = is->extclk.paused = !is->paused;
1502 static void toggle_pause(VideoState *is)
1504 stream_toggle_pause(is);
1508 static void toggle_mute(VideoState *is)
1510 is->muted = !is->muted;
1513 static void update_volume(VideoState *is, int sign, double step)
1515 double volume_level = is->audio_volume ? (20 * log(is->audio_volume / (double)SDL_MIX_MAXVOLUME) / log(10)) : -1000.0;
1516 int new_volume = lrint(SDL_MIX_MAXVOLUME * pow(10.0, (volume_level + sign * step) / 20.0));
1517 is->audio_volume = av_clip(is->audio_volume == new_volume ? (is->audio_volume + sign) : new_volume, 0, SDL_MIX_MAXVOLUME);
1520 static void step_to_next_frame(VideoState *is)
1522 /* if the stream is paused unpause it, then step */
1524 stream_toggle_pause(is);
1528 static double compute_target_delay(double delay, VideoState *is)
1530 double sync_threshold, diff = 0;
1532 /* update delay to follow master synchronisation source */
1533 if (get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER) {
1534 /* if video is slave, we try to correct big delays by
1535 duplicating or deleting a frame */
1536 diff = get_clock(&is->vidclk) - get_master_clock(is);
1538 /* skip or repeat frame. We take into account the
1539 delay to compute the threshold. I still don't know
1540 if it is the best guess */
1541 sync_threshold = FFMAX(AV_SYNC_THRESHOLD_MIN, FFMIN(AV_SYNC_THRESHOLD_MAX, delay));
1542 if (!isnan(diff) && fabs(diff) < is->max_frame_duration) {
1543 if (diff <= -sync_threshold)
1544 delay = FFMAX(0, delay + diff);
1545 else if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD)
1546 delay = delay + diff;
1547 else if (diff >= sync_threshold)
1552 av_log(NULL, AV_LOG_TRACE, "video: delay=%0.3f A-V=%f\n",
1558 static double vp_duration(VideoState *is, Frame *vp, Frame *nextvp) {
1559 if (vp->serial == nextvp->serial) {
1560 double duration = nextvp->pts - vp->pts;
1561 if (isnan(duration) || duration <= 0 || duration > is->max_frame_duration)
1562 return vp->duration;
1570 static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
1571 /* update current video pts */
1572 set_clock(&is->vidclk, pts, serial);
1573 sync_clock_to_slave(&is->extclk, &is->vidclk);
1576 /* called to display each frame */
1577 static void video_refresh(void *opaque, double *remaining_time)
1579 VideoState *is = opaque;
1584 if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
1585 check_external_clock_speed(is);
1587 if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {
1588 time = av_gettime_relative() / 1000000.0;
1589 if (is->force_refresh || is->last_vis_time + rdftspeed < time) {
1591 is->last_vis_time = time;
1593 *remaining_time = FFMIN(*remaining_time, is->last_vis_time + rdftspeed - time);
1598 if (frame_queue_nb_remaining(&is->pictq) == 0) {
1599 // nothing to do, no picture to display in the queue
1601 double last_duration, duration, delay;
1604 /* dequeue the picture */
1605 lastvp = frame_queue_peek_last(&is->pictq);
1606 vp = frame_queue_peek(&is->pictq);
1608 if (vp->serial != is->videoq.serial) {
1609 frame_queue_next(&is->pictq);
1613 if (lastvp->serial != vp->serial)
1614 is->frame_timer = av_gettime_relative() / 1000000.0;
1619 /* compute nominal last_duration */
1620 last_duration = vp_duration(is, lastvp, vp);
1621 delay = compute_target_delay(last_duration, is);
1623 time= av_gettime_relative()/1000000.0;
1624 if (time < is->frame_timer + delay) {
1625 *remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);
1629 is->frame_timer += delay;
1630 if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)
1631 is->frame_timer = time;
1633 SDL_LockMutex(is->pictq.mutex);
1634 if (!isnan(vp->pts))
1635 update_video_pts(is, vp->pts, vp->pos, vp->serial);
1636 SDL_UnlockMutex(is->pictq.mutex);
1638 if (frame_queue_nb_remaining(&is->pictq) > 1) {
1639 Frame *nextvp = frame_queue_peek_next(&is->pictq);
1640 duration = vp_duration(is, vp, nextvp);
1641 if(!is->step && (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
1642 is->frame_drops_late++;
1643 frame_queue_next(&is->pictq);
1648 if (is->subtitle_st) {
1649 while (frame_queue_nb_remaining(&is->subpq) > 0) {
1650 sp = frame_queue_peek(&is->subpq);
1652 if (frame_queue_nb_remaining(&is->subpq) > 1)
1653 sp2 = frame_queue_peek_next(&is->subpq);
1657 if (sp->serial != is->subtitleq.serial
1658 || (is->vidclk.pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1659 || (sp2 && is->vidclk.pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1663 for (i = 0; i < sp->sub.num_rects; i++) {
1664 AVSubtitleRect *sub_rect = sp->sub.rects[i];
1668 if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)&pixels, &pitch)) {
1669 for (j = 0; j < sub_rect->h; j++, pixels += pitch)
1670 memset(pixels, 0, sub_rect->w << 2);
1671 SDL_UnlockTexture(is->sub_texture);
1675 frame_queue_next(&is->subpq);
1682 frame_queue_next(&is->pictq);
1683 is->force_refresh = 1;
1685 if (is->step && !is->paused)
1686 stream_toggle_pause(is);
1689 /* display picture */
1690 if (!display_disable && is->force_refresh && is->show_mode == SHOW_MODE_VIDEO && is->pictq.rindex_shown)
1693 is->force_refresh = 0;
1696 static int64_t last_time;
1698 int aqsize, vqsize, sqsize;
1701 cur_time = av_gettime_relative();
1702 if (!last_time || (cur_time - last_time) >= 30000) {
1707 aqsize = is->audioq.size;
1709 vqsize = is->videoq.size;
1710 if (is->subtitle_st)
1711 sqsize = is->subtitleq.size;
1713 if (is->audio_st && is->video_st)
1714 av_diff = get_clock(&is->audclk) - get_clock(&is->vidclk);
1715 else if (is->video_st)
1716 av_diff = get_master_clock(is) - get_clock(&is->vidclk);
1717 else if (is->audio_st)
1718 av_diff = get_master_clock(is) - get_clock(&is->audclk);
1720 av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
1722 "%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64" \r",
1723 get_master_clock(is),
1724 (is->audio_st && is->video_st) ? "A-V" : (is->video_st ? "M-V" : (is->audio_st ? "M-A" : " ")),
1726 is->frame_drops_early + is->frame_drops_late,
1730 is->video_st ? is->viddec.avctx->pts_correction_num_faulty_dts : 0,
1731 is->video_st ? is->viddec.avctx->pts_correction_num_faulty_pts : 0);
1733 if (show_status == 1 && AV_LOG_INFO > av_log_get_level())
1734 fprintf(stderr, "%s", buf.str);
1736 av_log(NULL, AV_LOG_INFO, "%s", buf.str);
1739 av_bprint_finalize(&buf, NULL);
1741 last_time = cur_time;
1746 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, double duration, int64_t pos, int serial)
1750 #if defined(DEBUG_SYNC)
1751 printf("frame_type=%c pts=%0.3f\n",
1752 av_get_picture_type_char(src_frame->pict_type), pts);
1755 if (!(vp = frame_queue_peek_writable(&is->pictq)))
1758 vp->sar = src_frame->sample_aspect_ratio;
1761 vp->width = src_frame->width;
1762 vp->height = src_frame->height;
1763 vp->format = src_frame->format;
1766 vp->duration = duration;
1768 vp->serial = serial;
1770 set_default_window_size(vp->width, vp->height, vp->sar);
1772 av_frame_move_ref(vp->frame, src_frame);
1773 frame_queue_push(&is->pictq);
1777 static int get_video_frame(VideoState *is, AVFrame *frame)
1781 if ((got_picture = decoder_decode_frame(&is->viddec, frame, NULL)) < 0)
1787 if (frame->pts != AV_NOPTS_VALUE)
1788 dpts = av_q2d(is->video_st->time_base) * frame->pts;
1790 frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
1792 if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
1793 if (frame->pts != AV_NOPTS_VALUE) {
1794 double diff = dpts - get_master_clock(is);
1795 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD &&
1796 diff - is->frame_last_filter_delay < 0 &&
1797 is->viddec.pkt_serial == is->vidclk.serial &&
1798 is->videoq.nb_packets) {
1799 is->frame_drops_early++;
1800 av_frame_unref(frame);
1811 static int configure_filtergraph(AVFilterGraph *graph, const char *filtergraph,
1812 AVFilterContext *source_ctx, AVFilterContext *sink_ctx)
1815 int nb_filters = graph->nb_filters;
1816 AVFilterInOut *outputs = NULL, *inputs = NULL;
1819 outputs = avfilter_inout_alloc();
1820 inputs = avfilter_inout_alloc();
1821 if (!outputs || !inputs) {
1822 ret = AVERROR(ENOMEM);
1826 outputs->name = av_strdup("in");
1827 outputs->filter_ctx = source_ctx;
1828 outputs->pad_idx = 0;
1829 outputs->next = NULL;
1831 inputs->name = av_strdup("out");
1832 inputs->filter_ctx = sink_ctx;
1833 inputs->pad_idx = 0;
1834 inputs->next = NULL;
1836 if ((ret = avfilter_graph_parse_ptr(graph, filtergraph, &inputs, &outputs, NULL)) < 0)
1839 if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
1843 /* Reorder the filters to ensure that inputs of the custom filters are merged first */
1844 for (i = 0; i < graph->nb_filters - nb_filters; i++)
1845 FFSWAP(AVFilterContext*, graph->filters[i], graph->filters[i + nb_filters]);
1847 ret = avfilter_graph_config(graph, NULL);
1849 avfilter_inout_free(&outputs);
1850 avfilter_inout_free(&inputs);
1854 static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const char *vfilters, AVFrame *frame)
1856 enum AVPixelFormat pix_fmts[FF_ARRAY_ELEMS(sdl_texture_format_map)];
1857 char sws_flags_str[512] = "";
1858 char buffersrc_args[256];
1860 AVFilterContext *filt_src = NULL, *filt_out = NULL, *last_filter = NULL;
1861 AVCodecParameters *codecpar = is->video_st->codecpar;
1862 AVRational fr = av_guess_frame_rate(is->ic, is->video_st, NULL);
1863 AVDictionaryEntry *e = NULL;
1864 int nb_pix_fmts = 0;
1867 for (i = 0; i < renderer_info.num_texture_formats; i++) {
1868 for (j = 0; j < FF_ARRAY_ELEMS(sdl_texture_format_map) - 1; j++) {
1869 if (renderer_info.texture_formats[i] == sdl_texture_format_map[j].texture_fmt) {
1870 pix_fmts[nb_pix_fmts++] = sdl_texture_format_map[j].format;
1875 pix_fmts[nb_pix_fmts] = AV_PIX_FMT_NONE;
1877 while ((e = av_dict_get(sws_dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
1878 if (!strcmp(e->key, "sws_flags")) {
1879 av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", "flags", e->value);
1881 av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", e->key, e->value);
1883 if (strlen(sws_flags_str))
1884 sws_flags_str[strlen(sws_flags_str)-1] = '\0';
1886 graph->scale_sws_opts = av_strdup(sws_flags_str);
1888 snprintf(buffersrc_args, sizeof(buffersrc_args),
1889 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
1890 frame->width, frame->height, frame->format,
1891 is->video_st->time_base.num, is->video_st->time_base.den,
1892 codecpar->sample_aspect_ratio.num, FFMAX(codecpar->sample_aspect_ratio.den, 1));
1893 if (fr.num && fr.den)
1894 av_strlcatf(buffersrc_args, sizeof(buffersrc_args), ":frame_rate=%d/%d", fr.num, fr.den);
1896 if ((ret = avfilter_graph_create_filter(&filt_src,
1897 avfilter_get_by_name("buffer"),
1898 "ffplay_buffer", buffersrc_args, NULL,
1902 ret = avfilter_graph_create_filter(&filt_out,
1903 avfilter_get_by_name("buffersink"),
1904 "ffplay_buffersink", NULL, NULL, graph);
1908 if ((ret = av_opt_set_int_list(filt_out, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1911 last_filter = filt_out;
1913 /* Note: this macro adds a filter before the lastly added filter, so the
1914 * processing order of the filters is in reverse */
1915 #define INSERT_FILT(name, arg) do { \
1916 AVFilterContext *filt_ctx; \
1918 ret = avfilter_graph_create_filter(&filt_ctx, \
1919 avfilter_get_by_name(name), \
1920 "ffplay_" name, arg, NULL, graph); \
1924 ret = avfilter_link(filt_ctx, 0, last_filter, 0); \
1928 last_filter = filt_ctx; \
1932 double theta = get_rotation(is->video_st);
1934 if (fabs(theta - 90) < 1.0) {
1935 INSERT_FILT("transpose", "clock");
1936 } else if (fabs(theta - 180) < 1.0) {
1937 INSERT_FILT("hflip", NULL);
1938 INSERT_FILT("vflip", NULL);
1939 } else if (fabs(theta - 270) < 1.0) {
1940 INSERT_FILT("transpose", "cclock");
1941 } else if (fabs(theta) > 1.0) {
1942 char rotate_buf[64];
1943 snprintf(rotate_buf, sizeof(rotate_buf), "%f*PI/180", theta);
1944 INSERT_FILT("rotate", rotate_buf);
1948 if ((ret = configure_filtergraph(graph, vfilters, filt_src, last_filter)) < 0)
1951 is->in_video_filter = filt_src;
1952 is->out_video_filter = filt_out;
1958 static int configure_audio_filters(VideoState *is, const char *afilters, int force_output_format)
1960 static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
1961 int sample_rates[2] = { 0, -1 };
1962 int64_t channel_layouts[2] = { 0, -1 };
1963 int channels[2] = { 0, -1 };
1964 AVFilterContext *filt_asrc = NULL, *filt_asink = NULL;
1965 char aresample_swr_opts[512] = "";
1966 AVDictionaryEntry *e = NULL;
1967 char asrc_args[256];
1970 avfilter_graph_free(&is->agraph);
1971 if (!(is->agraph = avfilter_graph_alloc()))
1972 return AVERROR(ENOMEM);
1973 is->agraph->nb_threads = filter_nbthreads;
1975 while ((e = av_dict_get(swr_opts, "", e, AV_DICT_IGNORE_SUFFIX)))
1976 av_strlcatf(aresample_swr_opts, sizeof(aresample_swr_opts), "%s=%s:", e->key, e->value);
1977 if (strlen(aresample_swr_opts))
1978 aresample_swr_opts[strlen(aresample_swr_opts)-1] = '\0';
1979 av_opt_set(is->agraph, "aresample_swr_opts", aresample_swr_opts, 0);
1981 ret = snprintf(asrc_args, sizeof(asrc_args),
1982 "sample_rate=%d:sample_fmt=%s:channels=%d:time_base=%d/%d",
1983 is->audio_filter_src.freq, av_get_sample_fmt_name(is->audio_filter_src.fmt),
1984 is->audio_filter_src.channels,
1985 1, is->audio_filter_src.freq);
1986 if (is->audio_filter_src.channel_layout)
1987 snprintf(asrc_args + ret, sizeof(asrc_args) - ret,
1988 ":channel_layout=0x%"PRIx64, is->audio_filter_src.channel_layout);
1990 ret = avfilter_graph_create_filter(&filt_asrc,
1991 avfilter_get_by_name("abuffer"), "ffplay_abuffer",
1992 asrc_args, NULL, is->agraph);
1997 ret = avfilter_graph_create_filter(&filt_asink,
1998 avfilter_get_by_name("abuffersink"), "ffplay_abuffersink",
1999 NULL, NULL, is->agraph);
2003 if ((ret = av_opt_set_int_list(filt_asink, "sample_fmts", sample_fmts, AV_SAMPLE_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
2005 if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 1, AV_OPT_SEARCH_CHILDREN)) < 0)
2008 if (force_output_format) {
2009 channel_layouts[0] = is->audio_tgt.channel_layout;
2010 channels [0] = is->audio_tgt.channel_layout ? -1 : is->audio_tgt.channels;
2011 sample_rates [0] = is->audio_tgt.freq;
2012 if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 0, AV_OPT_SEARCH_CHILDREN)) < 0)
2014 if ((ret = av_opt_set_int_list(filt_asink, "channel_layouts", channel_layouts, -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2016 if ((ret = av_opt_set_int_list(filt_asink, "channel_counts" , channels , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2018 if ((ret = av_opt_set_int_list(filt_asink, "sample_rates" , sample_rates , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2023 if ((ret = configure_filtergraph(is->agraph, afilters, filt_asrc, filt_asink)) < 0)
2026 is->in_audio_filter = filt_asrc;
2027 is->out_audio_filter = filt_asink;
2031 avfilter_graph_free(&is->agraph);
2034 #endif /* CONFIG_AVFILTER */
2036 static int audio_thread(void *arg)
2038 VideoState *is = arg;
2039 AVFrame *frame = av_frame_alloc();
2042 int last_serial = -1;
2043 int64_t dec_channel_layout;
2051 return AVERROR(ENOMEM);
2054 if ((got_frame = decoder_decode_frame(&is->auddec, frame, NULL)) < 0)
2058 tb = (AVRational){1, frame->sample_rate};
2061 dec_channel_layout = get_valid_channel_layout(frame->channel_layout, frame->channels);
2064 cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
2065 frame->format, frame->channels) ||
2066 is->audio_filter_src.channel_layout != dec_channel_layout ||
2067 is->audio_filter_src.freq != frame->sample_rate ||
2068 is->auddec.pkt_serial != last_serial;
2071 char buf1[1024], buf2[1024];
2072 av_get_channel_layout_string(buf1, sizeof(buf1), -1, is->audio_filter_src.channel_layout);
2073 av_get_channel_layout_string(buf2, sizeof(buf2), -1, dec_channel_layout);
2074 av_log(NULL, AV_LOG_DEBUG,
2075 "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",
2076 is->audio_filter_src.freq, is->audio_filter_src.channels, av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, last_serial,
2077 frame->sample_rate, frame->channels, av_get_sample_fmt_name(frame->format), buf2, is->auddec.pkt_serial);
2079 is->audio_filter_src.fmt = frame->format;
2080 is->audio_filter_src.channels = frame->channels;
2081 is->audio_filter_src.channel_layout = dec_channel_layout;
2082 is->audio_filter_src.freq = frame->sample_rate;
2083 last_serial = is->auddec.pkt_serial;
2085 if ((ret = configure_audio_filters(is, afilters, 1)) < 0)
2089 if ((ret = av_buffersrc_add_frame(is->in_audio_filter, frame)) < 0)
2092 while ((ret = av_buffersink_get_frame_flags(is->out_audio_filter, frame, 0)) >= 0) {
2093 tb = av_buffersink_get_time_base(is->out_audio_filter);
2095 if (!(af = frame_queue_peek_writable(&is->sampq)))
2098 af->pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2099 af->pos = frame->pkt_pos;
2100 af->serial = is->auddec.pkt_serial;
2101 af->duration = av_q2d((AVRational){frame->nb_samples, frame->sample_rate});
2103 av_frame_move_ref(af->frame, frame);
2104 frame_queue_push(&is->sampq);
2107 if (is->audioq.serial != is->auddec.pkt_serial)
2110 if (ret == AVERROR_EOF)
2111 is->auddec.finished = is->auddec.pkt_serial;
2114 } while (ret >= 0 || ret == AVERROR(EAGAIN) || ret == AVERROR_EOF);
2117 avfilter_graph_free(&is->agraph);
2119 av_frame_free(&frame);
2123 static int decoder_start(Decoder *d, int (*fn)(void *), const char *thread_name, void* arg)
2125 packet_queue_start(d->queue);
2126 d->decoder_tid = SDL_CreateThread(fn, thread_name, arg);
2127 if (!d->decoder_tid) {
2128 av_log(NULL, AV_LOG_ERROR, "SDL_CreateThread(): %s\n", SDL_GetError());
2129 return AVERROR(ENOMEM);
2134 static int video_thread(void *arg)
2136 VideoState *is = arg;
2137 AVFrame *frame = av_frame_alloc();
2141 AVRational tb = is->video_st->time_base;
2142 AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);
2145 AVFilterGraph *graph = NULL;
2146 AVFilterContext *filt_out = NULL, *filt_in = NULL;
2149 enum AVPixelFormat last_format = -2;
2150 int last_serial = -1;
2151 int last_vfilter_idx = 0;
2155 return AVERROR(ENOMEM);
2158 ret = get_video_frame(is, frame);
2165 if ( last_w != frame->width
2166 || last_h != frame->height
2167 || last_format != frame->format
2168 || last_serial != is->viddec.pkt_serial
2169 || last_vfilter_idx != is->vfilter_idx) {
2170 av_log(NULL, AV_LOG_DEBUG,
2171 "Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
2173 (const char *)av_x_if_null(av_get_pix_fmt_name(last_format), "none"), last_serial,
2174 frame->width, frame->height,
2175 (const char *)av_x_if_null(av_get_pix_fmt_name(frame->format), "none"), is->viddec.pkt_serial);
2176 avfilter_graph_free(&graph);
2177 graph = avfilter_graph_alloc();
2179 ret = AVERROR(ENOMEM);
2182 graph->nb_threads = filter_nbthreads;
2183 if ((ret = configure_video_filters(graph, is, vfilters_list ? vfilters_list[is->vfilter_idx] : NULL, frame)) < 0) {
2185 event.type = FF_QUIT_EVENT;
2186 event.user.data1 = is;
2187 SDL_PushEvent(&event);
2190 filt_in = is->in_video_filter;
2191 filt_out = is->out_video_filter;
2192 last_w = frame->width;
2193 last_h = frame->height;
2194 last_format = frame->format;
2195 last_serial = is->viddec.pkt_serial;
2196 last_vfilter_idx = is->vfilter_idx;
2197 frame_rate = av_buffersink_get_frame_rate(filt_out);
2200 ret = av_buffersrc_add_frame(filt_in, frame);
2205 is->frame_last_returned_time = av_gettime_relative() / 1000000.0;
2207 ret = av_buffersink_get_frame_flags(filt_out, frame, 0);
2209 if (ret == AVERROR_EOF)
2210 is->viddec.finished = is->viddec.pkt_serial;
2215 is->frame_last_filter_delay = av_gettime_relative() / 1000000.0 - is->frame_last_returned_time;
2216 if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
2217 is->frame_last_filter_delay = 0;
2218 tb = av_buffersink_get_time_base(filt_out);
2220 duration = (frame_rate.num && frame_rate.den ? av_q2d((AVRational){frame_rate.den, frame_rate.num}) : 0);
2221 pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2222 ret = queue_picture(is, frame, pts, duration, frame->pkt_pos, is->viddec.pkt_serial);
2223 av_frame_unref(frame);
2225 if (is->videoq.serial != is->viddec.pkt_serial)
2235 avfilter_graph_free(&graph);
2237 av_frame_free(&frame);
2241 static int subtitle_thread(void *arg)
2243 VideoState *is = arg;
2249 if (!(sp = frame_queue_peek_writable(&is->subpq)))
2252 if ((got_subtitle = decoder_decode_frame(&is->subdec, NULL, &sp->sub)) < 0)
2257 if (got_subtitle && sp->sub.format == 0) {
2258 if (sp->sub.pts != AV_NOPTS_VALUE)
2259 pts = sp->sub.pts / (double)AV_TIME_BASE;
2261 sp->serial = is->subdec.pkt_serial;
2262 sp->width = is->subdec.avctx->width;
2263 sp->height = is->subdec.avctx->height;
2266 /* now we can update the picture count */
2267 frame_queue_push(&is->subpq);
2268 } else if (got_subtitle) {
2269 avsubtitle_free(&sp->sub);
2275 /* copy samples for viewing in editor window */
2276 static void update_sample_display(VideoState *is, short *samples, int samples_size)
2280 size = samples_size / sizeof(short);
2282 len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
2285 memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
2287 is->sample_array_index += len;
2288 if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
2289 is->sample_array_index = 0;
2294 /* return the wanted number of samples to get better sync if sync_type is video
2295 * or external master clock */
2296 static int synchronize_audio(VideoState *is, int nb_samples)
2298 int wanted_nb_samples = nb_samples;
2300 /* if not master, then we try to remove or add samples to correct the clock */
2301 if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
2302 double diff, avg_diff;
2303 int min_nb_samples, max_nb_samples;
2305 diff = get_clock(&is->audclk) - get_master_clock(is);
2307 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD) {
2308 is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
2309 if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
2310 /* not enough measures to have a correct estimate */
2311 is->audio_diff_avg_count++;
2313 /* estimate the A-V difference */
2314 avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
2316 if (fabs(avg_diff) >= is->audio_diff_threshold) {
2317 wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);
2318 min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2319 max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2320 wanted_nb_samples = av_clip(wanted_nb_samples, min_nb_samples, max_nb_samples);
2322 av_log(NULL, AV_LOG_TRACE, "diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
2323 diff, avg_diff, wanted_nb_samples - nb_samples,
2324 is->audio_clock, is->audio_diff_threshold);
2327 /* too big difference : may be initial PTS errors, so
2329 is->audio_diff_avg_count = 0;
2330 is->audio_diff_cum = 0;
2334 return wanted_nb_samples;
2338 * Decode one audio frame and return its uncompressed size.
2340 * The processed audio frame is decoded, converted if required, and
2341 * stored in is->audio_buf, with size in bytes given by the return
2344 static int audio_decode_frame(VideoState *is)
2346 int data_size, resampled_data_size;
2347 int64_t dec_channel_layout;
2348 av_unused double audio_clock0;
2349 int wanted_nb_samples;
2357 while (frame_queue_nb_remaining(&is->sampq) == 0) {
2358 if ((av_gettime_relative() - audio_callback_time) > 1000000LL * is->audio_hw_buf_size / is->audio_tgt.bytes_per_sec / 2)
2363 if (!(af = frame_queue_peek_readable(&is->sampq)))
2365 frame_queue_next(&is->sampq);
2366 } while (af->serial != is->audioq.serial);
2368 data_size = av_samples_get_buffer_size(NULL, af->frame->channels,
2369 af->frame->nb_samples,
2370 af->frame->format, 1);
2372 dec_channel_layout =
2373 (af->frame->channel_layout && af->frame->channels == av_get_channel_layout_nb_channels(af->frame->channel_layout)) ?
2374 af->frame->channel_layout : av_get_default_channel_layout(af->frame->channels);
2375 wanted_nb_samples = synchronize_audio(is, af->frame->nb_samples);
2377 if (af->frame->format != is->audio_src.fmt ||
2378 dec_channel_layout != is->audio_src.channel_layout ||
2379 af->frame->sample_rate != is->audio_src.freq ||
2380 (wanted_nb_samples != af->frame->nb_samples && !is->swr_ctx)) {
2381 swr_free(&is->swr_ctx);
2382 is->swr_ctx = swr_alloc_set_opts(NULL,
2383 is->audio_tgt.channel_layout, is->audio_tgt.fmt, is->audio_tgt.freq,
2384 dec_channel_layout, af->frame->format, af->frame->sample_rate,
2386 if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
2387 av_log(NULL, AV_LOG_ERROR,
2388 "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
2389 af->frame->sample_rate, av_get_sample_fmt_name(af->frame->format), af->frame->channels,
2390 is->audio_tgt.freq, av_get_sample_fmt_name(is->audio_tgt.fmt), is->audio_tgt.channels);
2391 swr_free(&is->swr_ctx);
2394 is->audio_src.channel_layout = dec_channel_layout;
2395 is->audio_src.channels = af->frame->channels;
2396 is->audio_src.freq = af->frame->sample_rate;
2397 is->audio_src.fmt = af->frame->format;
2401 const uint8_t **in = (const uint8_t **)af->frame->extended_data;
2402 uint8_t **out = &is->audio_buf1;
2403 int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate + 256;
2404 int out_size = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, out_count, is->audio_tgt.fmt, 0);
2407 av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size() failed\n");
2410 if (wanted_nb_samples != af->frame->nb_samples) {
2411 if (swr_set_compensation(is->swr_ctx, (wanted_nb_samples - af->frame->nb_samples) * is->audio_tgt.freq / af->frame->sample_rate,
2412 wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate) < 0) {
2413 av_log(NULL, AV_LOG_ERROR, "swr_set_compensation() failed\n");
2417 av_fast_malloc(&is->audio_buf1, &is->audio_buf1_size, out_size);
2418 if (!is->audio_buf1)
2419 return AVERROR(ENOMEM);
2420 len2 = swr_convert(is->swr_ctx, out, out_count, in, af->frame->nb_samples);
2422 av_log(NULL, AV_LOG_ERROR, "swr_convert() failed\n");
2425 if (len2 == out_count) {
2426 av_log(NULL, AV_LOG_WARNING, "audio buffer is probably too small\n");
2427 if (swr_init(is->swr_ctx) < 0)
2428 swr_free(&is->swr_ctx);
2430 is->audio_buf = is->audio_buf1;
2431 resampled_data_size = len2 * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2433 is->audio_buf = af->frame->data[0];
2434 resampled_data_size = data_size;
2437 audio_clock0 = is->audio_clock;
2438 /* update the audio clock with the pts */
2439 if (!isnan(af->pts))
2440 is->audio_clock = af->pts + (double) af->frame->nb_samples / af->frame->sample_rate;
2442 is->audio_clock = NAN;
2443 is->audio_clock_serial = af->serial;
2446 static double last_clock;
2447 printf("audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
2448 is->audio_clock - last_clock,
2449 is->audio_clock, audio_clock0);
2450 last_clock = is->audio_clock;
2453 return resampled_data_size;
2456 /* prepare a new audio buffer */
2457 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
2459 VideoState *is = opaque;
2460 int audio_size, len1;
2462 audio_callback_time = av_gettime_relative();
2465 if (is->audio_buf_index >= is->audio_buf_size) {
2466 audio_size = audio_decode_frame(is);
2467 if (audio_size < 0) {
2468 /* if error, just output silence */
2469 is->audio_buf = NULL;
2470 is->audio_buf_size = SDL_AUDIO_MIN_BUFFER_SIZE / is->audio_tgt.frame_size * is->audio_tgt.frame_size;
2472 if (is->show_mode != SHOW_MODE_VIDEO)
2473 update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
2474 is->audio_buf_size = audio_size;
2476 is->audio_buf_index = 0;
2478 len1 = is->audio_buf_size - is->audio_buf_index;
2481 if (!is->muted && is->audio_buf && is->audio_volume == SDL_MIX_MAXVOLUME)
2482 memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
2484 memset(stream, 0, len1);
2485 if (!is->muted && is->audio_buf)
2486 SDL_MixAudioFormat(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, AUDIO_S16SYS, len1, is->audio_volume);
2490 is->audio_buf_index += len1;
2492 is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
2493 /* Let's assume the audio driver that is used by SDL has two periods. */
2494 if (!isnan(is->audio_clock)) {
2495 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);
2496 sync_clock_to_slave(&is->extclk, &is->audclk);
2500 static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
2502 SDL_AudioSpec wanted_spec, spec;
2504 static const int next_nb_channels[] = {0, 0, 1, 6, 2, 6, 4, 6};
2505 static const int next_sample_rates[] = {0, 44100, 48000, 96000, 192000};
2506 int next_sample_rate_idx = FF_ARRAY_ELEMS(next_sample_rates) - 1;
2508 env = SDL_getenv("SDL_AUDIO_CHANNELS");
2510 wanted_nb_channels = atoi(env);
2511 wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2513 if (!wanted_channel_layout || wanted_nb_channels != av_get_channel_layout_nb_channels(wanted_channel_layout)) {
2514 wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2515 wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
2517 wanted_nb_channels = av_get_channel_layout_nb_channels(wanted_channel_layout);
2518 wanted_spec.channels = wanted_nb_channels;
2519 wanted_spec.freq = wanted_sample_rate;
2520 if (wanted_spec.freq <= 0 || wanted_spec.channels <= 0) {
2521 av_log(NULL, AV_LOG_ERROR, "Invalid sample rate or channel count!\n");
2524 while (next_sample_rate_idx && next_sample_rates[next_sample_rate_idx] >= wanted_spec.freq)
2525 next_sample_rate_idx--;
2526 wanted_spec.format = AUDIO_S16SYS;
2527 wanted_spec.silence = 0;
2528 wanted_spec.samples = FFMAX(SDL_AUDIO_MIN_BUFFER_SIZE, 2 << av_log2(wanted_spec.freq / SDL_AUDIO_MAX_CALLBACKS_PER_SEC));
2529 wanted_spec.callback = sdl_audio_callback;
2530 wanted_spec.userdata = opaque;
2531 while (!(audio_dev = SDL_OpenAudioDevice(NULL, 0, &wanted_spec, &spec, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE | SDL_AUDIO_ALLOW_CHANNELS_CHANGE))) {
2532 av_log(NULL, AV_LOG_WARNING, "SDL_OpenAudio (%d channels, %d Hz): %s\n",
2533 wanted_spec.channels, wanted_spec.freq, SDL_GetError());
2534 wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
2535 if (!wanted_spec.channels) {
2536 wanted_spec.freq = next_sample_rates[next_sample_rate_idx--];
2537 wanted_spec.channels = wanted_nb_channels;
2538 if (!wanted_spec.freq) {
2539 av_log(NULL, AV_LOG_ERROR,
2540 "No more combinations to try, audio open failed\n");
2544 wanted_channel_layout = av_get_default_channel_layout(wanted_spec.channels);
2546 if (spec.format != AUDIO_S16SYS) {
2547 av_log(NULL, AV_LOG_ERROR,
2548 "SDL advised audio format %d is not supported!\n", spec.format);
2551 if (spec.channels != wanted_spec.channels) {
2552 wanted_channel_layout = av_get_default_channel_layout(spec.channels);
2553 if (!wanted_channel_layout) {
2554 av_log(NULL, AV_LOG_ERROR,
2555 "SDL advised channel count %d is not supported!\n", spec.channels);
2560 audio_hw_params->fmt = AV_SAMPLE_FMT_S16;
2561 audio_hw_params->freq = spec.freq;
2562 audio_hw_params->channel_layout = wanted_channel_layout;
2563 audio_hw_params->channels = spec.channels;
2564 audio_hw_params->frame_size = av_samples_get_buffer_size(NULL, audio_hw_params->channels, 1, audio_hw_params->fmt, 1);
2565 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);
2566 if (audio_hw_params->bytes_per_sec <= 0 || audio_hw_params->frame_size <= 0) {
2567 av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size failed\n");
2573 /* open a given stream. Return 0 if OK */
2574 static int stream_component_open(VideoState *is, int stream_index)
2576 AVFormatContext *ic = is->ic;
2577 AVCodecContext *avctx;
2579 const char *forced_codec_name = NULL;
2580 AVDictionary *opts = NULL;
2581 AVDictionaryEntry *t = NULL;
2582 int sample_rate, nb_channels;
2583 int64_t channel_layout;
2585 int stream_lowres = lowres;
2587 if (stream_index < 0 || stream_index >= ic->nb_streams)
2590 avctx = avcodec_alloc_context3(NULL);
2592 return AVERROR(ENOMEM);
2594 ret = avcodec_parameters_to_context(avctx, ic->streams[stream_index]->codecpar);
2597 avctx->pkt_timebase = ic->streams[stream_index]->time_base;
2599 codec = avcodec_find_decoder(avctx->codec_id);
2601 switch(avctx->codec_type){
2602 case AVMEDIA_TYPE_AUDIO : is->last_audio_stream = stream_index; forced_codec_name = audio_codec_name; break;
2603 case AVMEDIA_TYPE_SUBTITLE: is->last_subtitle_stream = stream_index; forced_codec_name = subtitle_codec_name; break;
2604 case AVMEDIA_TYPE_VIDEO : is->last_video_stream = stream_index; forced_codec_name = video_codec_name; break;
2606 if (forced_codec_name)
2607 codec = avcodec_find_decoder_by_name(forced_codec_name);
2609 if (forced_codec_name) av_log(NULL, AV_LOG_WARNING,
2610 "No codec could be found with name '%s'\n", forced_codec_name);
2611 else av_log(NULL, AV_LOG_WARNING,
2612 "No decoder could be found for codec %s\n", avcodec_get_name(avctx->codec_id));
2613 ret = AVERROR(EINVAL);
2617 avctx->codec_id = codec->id;
2618 if (stream_lowres > codec->max_lowres) {
2619 av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2621 stream_lowres = codec->max_lowres;
2623 avctx->lowres = stream_lowres;
2626 avctx->flags2 |= AV_CODEC_FLAG2_FAST;
2628 opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
2629 if (!av_dict_get(opts, "threads", NULL, 0))
2630 av_dict_set(&opts, "threads", "auto", 0);
2632 av_dict_set_int(&opts, "lowres", stream_lowres, 0);
2633 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
2634 av_dict_set(&opts, "refcounted_frames", "1", 0);
2635 if ((ret = avcodec_open2(avctx, codec, &opts)) < 0) {
2638 if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2639 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2640 ret = AVERROR_OPTION_NOT_FOUND;
2645 ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
2646 switch (avctx->codec_type) {
2647 case AVMEDIA_TYPE_AUDIO:
2650 AVFilterContext *sink;
2652 is->audio_filter_src.freq = avctx->sample_rate;
2653 is->audio_filter_src.channels = avctx->channels;
2654 is->audio_filter_src.channel_layout = get_valid_channel_layout(avctx->channel_layout, avctx->channels);
2655 is->audio_filter_src.fmt = avctx->sample_fmt;
2656 if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
2658 sink = is->out_audio_filter;
2659 sample_rate = av_buffersink_get_sample_rate(sink);
2660 nb_channels = av_buffersink_get_channels(sink);
2661 channel_layout = av_buffersink_get_channel_layout(sink);
2664 sample_rate = avctx->sample_rate;
2665 nb_channels = avctx->channels;
2666 channel_layout = avctx->channel_layout;
2669 /* prepare audio output */
2670 if ((ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)) < 0)
2672 is->audio_hw_buf_size = ret;
2673 is->audio_src = is->audio_tgt;
2674 is->audio_buf_size = 0;
2675 is->audio_buf_index = 0;
2677 /* init averaging filter */
2678 is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
2679 is->audio_diff_avg_count = 0;
2680 /* since we do not have a precise anough audio FIFO fullness,
2681 we correct audio sync only if larger than this threshold */
2682 is->audio_diff_threshold = (double)(is->audio_hw_buf_size) / is->audio_tgt.bytes_per_sec;
2684 is->audio_stream = stream_index;
2685 is->audio_st = ic->streams[stream_index];
2687 if ((ret = decoder_init(&is->auddec, avctx, &is->audioq, is->continue_read_thread)) < 0)
2689 if ((is->ic->iformat->flags & (AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH | AVFMT_NO_BYTE_SEEK)) && !is->ic->iformat->read_seek) {
2690 is->auddec.start_pts = is->audio_st->start_time;
2691 is->auddec.start_pts_tb = is->audio_st->time_base;
2693 if ((ret = decoder_start(&is->auddec, audio_thread, "audio_decoder", is)) < 0)
2695 SDL_PauseAudioDevice(audio_dev, 0);
2697 case AVMEDIA_TYPE_VIDEO:
2698 is->video_stream = stream_index;
2699 is->video_st = ic->streams[stream_index];
2701 if ((ret = decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread)) < 0)
2703 if ((ret = decoder_start(&is->viddec, video_thread, "video_decoder", is)) < 0)
2705 is->queue_attachments_req = 1;
2707 case AVMEDIA_TYPE_SUBTITLE:
2708 is->subtitle_stream = stream_index;
2709 is->subtitle_st = ic->streams[stream_index];
2711 if ((ret = decoder_init(&is->subdec, avctx, &is->subtitleq, is->continue_read_thread)) < 0)
2713 if ((ret = decoder_start(&is->subdec, subtitle_thread, "subtitle_decoder", is)) < 0)
2722 avcodec_free_context(&avctx);
2724 av_dict_free(&opts);
2729 static int decode_interrupt_cb(void *ctx)
2731 VideoState *is = ctx;
2732 return is->abort_request;
2735 static int stream_has_enough_packets(AVStream *st, int stream_id, PacketQueue *queue) {
2736 return stream_id < 0 ||
2737 queue->abort_request ||
2738 (st->disposition & AV_DISPOSITION_ATTACHED_PIC) ||
2739 queue->nb_packets > MIN_FRAMES && (!queue->duration || av_q2d(st->time_base) * queue->duration > 1.0);
2742 static int is_realtime(AVFormatContext *s)
2744 if( !strcmp(s->iformat->name, "rtp")
2745 || !strcmp(s->iformat->name, "rtsp")
2746 || !strcmp(s->iformat->name, "sdp")
2750 if(s->pb && ( !strncmp(s->url, "rtp:", 4)
2751 || !strncmp(s->url, "udp:", 4)
2758 /* this thread gets the stream from the disk or the network */
2759 static int read_thread(void *arg)
2761 VideoState *is = arg;
2762 AVFormatContext *ic = NULL;
2764 int st_index[AVMEDIA_TYPE_NB];
2765 AVPacket *pkt = NULL;
2766 int64_t stream_start_time;
2767 int pkt_in_play_range = 0;
2768 AVDictionaryEntry *t;
2769 SDL_mutex *wait_mutex = SDL_CreateMutex();
2770 int scan_all_pmts_set = 0;
2774 av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
2775 ret = AVERROR(ENOMEM);
2779 memset(st_index, -1, sizeof(st_index));
2782 pkt = av_packet_alloc();
2784 av_log(NULL, AV_LOG_FATAL, "Could not allocate packet.\n");
2785 ret = AVERROR(ENOMEM);
2788 ic = avformat_alloc_context();
2790 av_log(NULL, AV_LOG_FATAL, "Could not allocate context.\n");
2791 ret = AVERROR(ENOMEM);
2794 ic->interrupt_callback.callback = decode_interrupt_cb;
2795 ic->interrupt_callback.opaque = is;
2796 if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
2797 av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
2798 scan_all_pmts_set = 1;
2800 err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
2802 print_error(is->filename, err);
2806 if (scan_all_pmts_set)
2807 av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
2809 if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2810 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2811 ret = AVERROR_OPTION_NOT_FOUND;
2817 ic->flags |= AVFMT_FLAG_GENPTS;
2819 av_format_inject_global_side_data(ic);
2821 if (find_stream_info) {
2822 AVDictionary **opts = setup_find_stream_info_opts(ic, codec_opts);
2823 int orig_nb_streams = ic->nb_streams;
2825 err = avformat_find_stream_info(ic, opts);
2827 for (i = 0; i < orig_nb_streams; i++)
2828 av_dict_free(&opts[i]);
2832 av_log(NULL, AV_LOG_WARNING,
2833 "%s: could not find codec parameters\n", is->filename);
2840 ic->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use avio_feof() to test for the end
2842 if (seek_by_bytes < 0)
2843 seek_by_bytes = !!(ic->iformat->flags & AVFMT_TS_DISCONT) && strcmp("ogg", ic->iformat->name);
2845 is->max_frame_duration = (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;
2847 if (!window_title && (t = av_dict_get(ic->metadata, "title", NULL, 0)))
2848 window_title = av_asprintf("%s - %s", t->value, input_filename);
2850 /* if seeking requested, we execute it */
2851 if (start_time != AV_NOPTS_VALUE) {
2854 timestamp = start_time;
2855 /* add the stream start time */
2856 if (ic->start_time != AV_NOPTS_VALUE)
2857 timestamp += ic->start_time;
2858 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
2860 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2861 is->filename, (double)timestamp / AV_TIME_BASE);
2865 is->realtime = is_realtime(ic);
2868 av_dump_format(ic, 0, is->filename, 0);
2870 for (i = 0; i < ic->nb_streams; i++) {
2871 AVStream *st = ic->streams[i];
2872 enum AVMediaType type = st->codecpar->codec_type;
2873 st->discard = AVDISCARD_ALL;
2874 if (type >= 0 && wanted_stream_spec[type] && st_index[type] == -1)
2875 if (avformat_match_stream_specifier(ic, st, wanted_stream_spec[type]) > 0)
2878 for (i = 0; i < AVMEDIA_TYPE_NB; i++) {
2879 if (wanted_stream_spec[i] && st_index[i] == -1) {
2880 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));
2881 st_index[i] = INT_MAX;
2886 st_index[AVMEDIA_TYPE_VIDEO] =
2887 av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
2888 st_index[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
2890 st_index[AVMEDIA_TYPE_AUDIO] =
2891 av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
2892 st_index[AVMEDIA_TYPE_AUDIO],
2893 st_index[AVMEDIA_TYPE_VIDEO],
2895 if (!video_disable && !subtitle_disable)
2896 st_index[AVMEDIA_TYPE_SUBTITLE] =
2897 av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
2898 st_index[AVMEDIA_TYPE_SUBTITLE],
2899 (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
2900 st_index[AVMEDIA_TYPE_AUDIO] :
2901 st_index[AVMEDIA_TYPE_VIDEO]),
2904 is->show_mode = show_mode;
2905 if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2906 AVStream *st = ic->streams[st_index[AVMEDIA_TYPE_VIDEO]];
2907 AVCodecParameters *codecpar = st->codecpar;
2908 AVRational sar = av_guess_sample_aspect_ratio(ic, st, NULL);
2909 if (codecpar->width)
2910 set_default_window_size(codecpar->width, codecpar->height, sar);
2913 /* open the streams */
2914 if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
2915 stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
2919 if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2920 ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
2922 if (is->show_mode == SHOW_MODE_NONE)
2923 is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
2925 if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
2926 stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
2929 if (is->video_stream < 0 && is->audio_stream < 0) {
2930 av_log(NULL, AV_LOG_FATAL, "Failed to open file '%s' or configure filtergraph\n",
2936 if (infinite_buffer < 0 && is->realtime)
2937 infinite_buffer = 1;
2940 if (is->abort_request)
2942 if (is->paused != is->last_paused) {
2943 is->last_paused = is->paused;
2945 is->read_pause_return = av_read_pause(ic);
2949 #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
2951 (!strcmp(ic->iformat->name, "rtsp") ||
2952 (ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
2953 /* wait 10 ms to avoid trying to get another packet */
2960 int64_t seek_target = is->seek_pos;
2961 int64_t seek_min = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
2962 int64_t seek_max = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
2963 // FIXME the +-2 is due to rounding being not done in the correct direction in generation
2964 // of the seek_pos/seek_rel variables
2966 ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
2968 av_log(NULL, AV_LOG_ERROR,
2969 "%s: error while seeking\n", is->ic->url);
2971 if (is->audio_stream >= 0) {
2972 packet_queue_flush(&is->audioq);
2974 if (is->subtitle_stream >= 0) {
2975 packet_queue_flush(&is->subtitleq);
2977 if (is->video_stream >= 0) {
2978 packet_queue_flush(&is->videoq);
2980 if (is->seek_flags & AVSEEK_FLAG_BYTE) {
2981 set_clock(&is->extclk, NAN, 0);
2983 set_clock(&is->extclk, seek_target / (double)AV_TIME_BASE, 0);
2987 is->queue_attachments_req = 1;
2990 step_to_next_frame(is);
2992 if (is->queue_attachments_req) {
2993 if (is->video_st && is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC) {
2994 if ((ret = av_packet_ref(pkt, &is->video_st->attached_pic)) < 0)
2996 packet_queue_put(&is->videoq, pkt);
2997 packet_queue_put_nullpacket(&is->videoq, pkt, is->video_stream);
2999 is->queue_attachments_req = 0;
3002 /* if the queue are full, no need to read more */
3003 if (infinite_buffer<1 &&
3004 (is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
3005 || (stream_has_enough_packets(is->audio_st, is->audio_stream, &is->audioq) &&
3006 stream_has_enough_packets(is->video_st, is->video_stream, &is->videoq) &&
3007 stream_has_enough_packets(is->subtitle_st, is->subtitle_stream, &is->subtitleq)))) {
3009 SDL_LockMutex(wait_mutex);
3010 SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3011 SDL_UnlockMutex(wait_mutex);
3015 (!is->audio_st || (is->auddec.finished == is->audioq.serial && frame_queue_nb_remaining(&is->sampq) == 0)) &&
3016 (!is->video_st || (is->viddec.finished == is->videoq.serial && frame_queue_nb_remaining(&is->pictq) == 0))) {
3017 if (loop != 1 && (!loop || --loop)) {
3018 stream_seek(is, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
3019 } else if (autoexit) {
3024 ret = av_read_frame(ic, pkt);
3026 if ((ret == AVERROR_EOF || avio_feof(ic->pb)) && !is->eof) {
3027 if (is->video_stream >= 0)
3028 packet_queue_put_nullpacket(&is->videoq, pkt, is->video_stream);
3029 if (is->audio_stream >= 0)
3030 packet_queue_put_nullpacket(&is->audioq, pkt, is->audio_stream);
3031 if (is->subtitle_stream >= 0)
3032 packet_queue_put_nullpacket(&is->subtitleq, pkt, is->subtitle_stream);
3035 if (ic->pb && ic->pb->error) {
3041 SDL_LockMutex(wait_mutex);
3042 SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3043 SDL_UnlockMutex(wait_mutex);
3048 /* check if packet is in play range specified by user, then queue, otherwise discard */
3049 stream_start_time = ic->streams[pkt->stream_index]->start_time;
3050 pkt_ts = pkt->pts == AV_NOPTS_VALUE ? pkt->dts : pkt->pts;
3051 pkt_in_play_range = duration == AV_NOPTS_VALUE ||
3052 (pkt_ts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
3053 av_q2d(ic->streams[pkt->stream_index]->time_base) -
3054 (double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
3055 <= ((double)duration / 1000000);
3056 if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
3057 packet_queue_put(&is->audioq, pkt);
3058 } else if (pkt->stream_index == is->video_stream && pkt_in_play_range
3059 && !(is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
3060 packet_queue_put(&is->videoq, pkt);
3061 } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
3062 packet_queue_put(&is->subtitleq, pkt);
3064 av_packet_unref(pkt);
3071 avformat_close_input(&ic);
3073 av_packet_free(&pkt);
3077 event.type = FF_QUIT_EVENT;
3078 event.user.data1 = is;
3079 SDL_PushEvent(&event);
3081 SDL_DestroyMutex(wait_mutex);
3085 static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
3089 is = av_mallocz(sizeof(VideoState));
3092 is->last_video_stream = is->video_stream = -1;
3093 is->last_audio_stream = is->audio_stream = -1;
3094 is->last_subtitle_stream = is->subtitle_stream = -1;
3095 is->filename = av_strdup(filename);
3098 is->iformat = iformat;
3102 /* start video display */
3103 if (frame_queue_init(&is->pictq, &is->videoq, VIDEO_PICTURE_QUEUE_SIZE, 1) < 0)
3105 if (frame_queue_init(&is->subpq, &is->subtitleq, SUBPICTURE_QUEUE_SIZE, 0) < 0)
3107 if (frame_queue_init(&is->sampq, &is->audioq, SAMPLE_QUEUE_SIZE, 1) < 0)
3110 if (packet_queue_init(&is->videoq) < 0 ||
3111 packet_queue_init(&is->audioq) < 0 ||
3112 packet_queue_init(&is->subtitleq) < 0)
3115 if (!(is->continue_read_thread = SDL_CreateCond())) {
3116 av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
3120 init_clock(&is->vidclk, &is->videoq.serial);
3121 init_clock(&is->audclk, &is->audioq.serial);
3122 init_clock(&is->extclk, &is->extclk.serial);
3123 is->audio_clock_serial = -1;
3124 if (startup_volume < 0)
3125 av_log(NULL, AV_LOG_WARNING, "-volume=%d < 0, setting to 0\n", startup_volume);
3126 if (startup_volume > 100)
3127 av_log(NULL, AV_LOG_WARNING, "-volume=%d > 100, setting to 100\n", startup_volume);
3128 startup_volume = av_clip(startup_volume, 0, 100);
3129 startup_volume = av_clip(SDL_MIX_MAXVOLUME * startup_volume / 100, 0, SDL_MIX_MAXVOLUME);
3130 is->audio_volume = startup_volume;
3132 is->av_sync_type = av_sync_type;
3133 is->read_tid = SDL_CreateThread(read_thread, "read_thread", is);
3134 if (!is->read_tid) {
3135 av_log(NULL, AV_LOG_FATAL, "SDL_CreateThread(): %s\n", SDL_GetError());
3143 static void stream_cycle_channel(VideoState *is, int codec_type)
3145 AVFormatContext *ic = is->ic;
3146 int start_index, stream_index;
3149 AVProgram *p = NULL;
3150 int nb_streams = is->ic->nb_streams;
3152 if (codec_type == AVMEDIA_TYPE_VIDEO) {
3153 start_index = is->last_video_stream;
3154 old_index = is->video_stream;
3155 } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
3156 start_index = is->last_audio_stream;
3157 old_index = is->audio_stream;
3159 start_index = is->last_subtitle_stream;
3160 old_index = is->subtitle_stream;
3162 stream_index = start_index;
3164 if (codec_type != AVMEDIA_TYPE_VIDEO && is->video_stream != -1) {
3165 p = av_find_program_from_stream(ic, NULL, is->video_stream);
3167 nb_streams = p->nb_stream_indexes;
3168 for (start_index = 0; start_index < nb_streams; start_index++)
3169 if (p->stream_index[start_index] == stream_index)
3171 if (start_index == nb_streams)
3173 stream_index = start_index;
3178 if (++stream_index >= nb_streams)
3180 if (codec_type == AVMEDIA_TYPE_SUBTITLE)
3183 is->last_subtitle_stream = -1;
3186 if (start_index == -1)
3190 if (stream_index == start_index)
3192 st = is->ic->streams[p ? p->stream_index[stream_index] : stream_index];
3193 if (st->codecpar->codec_type == codec_type) {
3194 /* check that parameters are OK */
3195 switch (codec_type) {
3196 case AVMEDIA_TYPE_AUDIO:
3197 if (st->codecpar->sample_rate != 0 &&
3198 st->codecpar->channels != 0)
3201 case AVMEDIA_TYPE_VIDEO:
3202 case AVMEDIA_TYPE_SUBTITLE:
3210 if (p && stream_index != -1)
3211 stream_index = p->stream_index[stream_index];
3212 av_log(NULL, AV_LOG_INFO, "Switch %s stream from #%d to #%d\n",
3213 av_get_media_type_string(codec_type),
3217 stream_component_close(is, old_index);
3218 stream_component_open(is, stream_index);
3222 static void toggle_full_screen(VideoState *is)
3224 is_full_screen = !is_full_screen;
3225 SDL_SetWindowFullscreen(window, is_full_screen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
3228 static void toggle_audio_display(VideoState *is)
3230 int next = is->show_mode;
3232 next = (next + 1) % SHOW_MODE_NB;
3233 } while (next != is->show_mode && (next == SHOW_MODE_VIDEO && !is->video_st || next != SHOW_MODE_VIDEO && !is->audio_st));
3234 if (is->show_mode != next) {
3235 is->force_refresh = 1;
3236 is->show_mode = next;
3240 static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
3241 double remaining_time = 0.0;
3243 while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) {
3244 if (!cursor_hidden && av_gettime_relative() - cursor_last_shown > CURSOR_HIDE_DELAY) {
3248 if (remaining_time > 0.0)
3249 av_usleep((int64_t)(remaining_time * 1000000.0));
3250 remaining_time = REFRESH_RATE;
3251 if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
3252 video_refresh(is, &remaining_time);
3257 static void seek_chapter(VideoState *is, int incr)
3259 int64_t pos = get_master_clock(is) * AV_TIME_BASE;
3262 if (!is->ic->nb_chapters)
3265 /* find the current chapter */
3266 for (i = 0; i < is->ic->nb_chapters; i++) {
3267 AVChapter *ch = is->ic->chapters[i];
3268 if (av_compare_ts(pos, AV_TIME_BASE_Q, ch->start, ch->time_base) < 0) {
3276 if (i >= is->ic->nb_chapters)
3279 av_log(NULL, AV_LOG_VERBOSE, "Seeking to chapter %d.\n", i);
3280 stream_seek(is, av_rescale_q(is->ic->chapters[i]->start, is->ic->chapters[i]->time_base,
3281 AV_TIME_BASE_Q), 0, 0);
3284 /* handle an event sent by the GUI */
3285 static void event_loop(VideoState *cur_stream)
3288 double incr, pos, frac;
3292 refresh_loop_wait_event(cur_stream, &event);
3293 switch (event.type) {
3295 if (exit_on_keydown || event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_q) {
3296 do_exit(cur_stream);
3299 // If we don't yet have a window, skip all key events, because read_thread might still be initializing...
3300 if (!cur_stream->width)
3302 switch (event.key.keysym.sym) {
3304 toggle_full_screen(cur_stream);
3305 cur_stream->force_refresh = 1;
3309 toggle_pause(cur_stream);
3312 toggle_mute(cur_stream);
3314 case SDLK_KP_MULTIPLY:
3316 update_volume(cur_stream, 1, SDL_VOLUME_STEP);
3318 case SDLK_KP_DIVIDE:
3320 update_volume(cur_stream, -1, SDL_VOLUME_STEP);
3322 case SDLK_s: // S: Step to next frame
3323 step_to_next_frame(cur_stream);
3326 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3329 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3332 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3333 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3334 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3337 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3341 if (cur_stream->show_mode == SHOW_MODE_VIDEO && cur_stream->vfilter_idx < nb_vfilters - 1) {
3342 if (++cur_stream->vfilter_idx >= nb_vfilters)
3343 cur_stream->vfilter_idx = 0;
3345 cur_stream->vfilter_idx = 0;
3346 toggle_audio_display(cur_stream);
3349 toggle_audio_display(cur_stream);
3353 if (cur_stream->ic->nb_chapters <= 1) {
3357 seek_chapter(cur_stream, 1);
3360 if (cur_stream->ic->nb_chapters <= 1) {
3364 seek_chapter(cur_stream, -1);
3367 incr = seek_interval ? -seek_interval : -10.0;
3370 incr = seek_interval ? seek_interval : 10.0;
3378 if (seek_by_bytes) {
3380 if (pos < 0 && cur_stream->video_stream >= 0)
3381 pos = frame_queue_last_pos(&cur_stream->pictq);
3382 if (pos < 0 && cur_stream->audio_stream >= 0)
3383 pos = frame_queue_last_pos(&cur_stream->sampq);
3385 pos = avio_tell(cur_stream->ic->pb);
3386 if (cur_stream->ic->bit_rate)
3387 incr *= cur_stream->ic->bit_rate / 8.0;
3391 stream_seek(cur_stream, pos, incr, 1);
3393 pos = get_master_clock(cur_stream);
3395 pos = (double)cur_stream->seek_pos / AV_TIME_BASE;
3397 if (cur_stream->ic->start_time != AV_NOPTS_VALUE && pos < cur_stream->ic->start_time / (double)AV_TIME_BASE)
3398 pos = cur_stream->ic->start_time / (double)AV_TIME_BASE;
3399 stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE), 0);
3406 case SDL_MOUSEBUTTONDOWN:
3407 if (exit_on_mousedown) {
3408 do_exit(cur_stream);
3411 if (event.button.button == SDL_BUTTON_LEFT) {
3412 static int64_t last_mouse_left_click = 0;
3413 if (av_gettime_relative() - last_mouse_left_click <= 500000) {
3414 toggle_full_screen(cur_stream);
3415 cur_stream->force_refresh = 1;
3416 last_mouse_left_click = 0;
3418 last_mouse_left_click = av_gettime_relative();
3421 case SDL_MOUSEMOTION:
3422 if (cursor_hidden) {
3426 cursor_last_shown = av_gettime_relative();
3427 if (event.type == SDL_MOUSEBUTTONDOWN) {
3428 if (event.button.button != SDL_BUTTON_RIGHT)
3432 if (!(event.motion.state & SDL_BUTTON_RMASK))
3436 if (seek_by_bytes || cur_stream->ic->duration <= 0) {
3437 uint64_t size = avio_size(cur_stream->ic->pb);
3438 stream_seek(cur_stream, size*x/cur_stream->width, 0, 1);
3442 int tns, thh, tmm, tss;
3443 tns = cur_stream->ic->duration / 1000000LL;
3445 tmm = (tns % 3600) / 60;
3447 frac = x / cur_stream->width;
3450 mm = (ns % 3600) / 60;
3452 av_log(NULL, AV_LOG_INFO,
3453 "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d) \n", frac*100,
3454 hh, mm, ss, thh, tmm, tss);
3455 ts = frac * cur_stream->ic->duration;
3456 if (cur_stream->ic->start_time != AV_NOPTS_VALUE)
3457 ts += cur_stream->ic->start_time;
3458 stream_seek(cur_stream, ts, 0, 0);
3461 case SDL_WINDOWEVENT:
3462 switch (event.window.event) {
3463 case SDL_WINDOWEVENT_SIZE_CHANGED:
3464 screen_width = cur_stream->width = event.window.data1;
3465 screen_height = cur_stream->height = event.window.data2;
3466 if (cur_stream->vis_texture) {
3467 SDL_DestroyTexture(cur_stream->vis_texture);
3468 cur_stream->vis_texture = NULL;
3470 case SDL_WINDOWEVENT_EXPOSED:
3471 cur_stream->force_refresh = 1;
3476 do_exit(cur_stream);
3484 static int opt_frame_size(void *optctx, const char *opt, const char *arg)
3486 av_log(NULL, AV_LOG_WARNING, "Option -s is deprecated, use -video_size.\n");
3487 return opt_default(NULL, "video_size", arg);
3490 static int opt_width(void *optctx, const char *opt, const char *arg)
3492 screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3496 static int opt_height(void *optctx, const char *opt, const char *arg)
3498 screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3502 static int opt_format(void *optctx, const char *opt, const char *arg)
3504 file_iformat = av_find_input_format(arg);
3505 if (!file_iformat) {
3506 av_log(NULL, AV_LOG_FATAL, "Unknown input format: %s\n", arg);
3507 return AVERROR(EINVAL);
3512 static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
3514 av_log(NULL, AV_LOG_WARNING, "Option -pix_fmt is deprecated, use -pixel_format.\n");
3515 return opt_default(NULL, "pixel_format", arg);
3518 static int opt_sync(void *optctx, const char *opt, const char *arg)
3520 if (!strcmp(arg, "audio"))
3521 av_sync_type = AV_SYNC_AUDIO_MASTER;
3522 else if (!strcmp(arg, "video"))
3523 av_sync_type = AV_SYNC_VIDEO_MASTER;
3524 else if (!strcmp(arg, "ext"))
3525 av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
3527 av_log(NULL, AV_LOG_ERROR, "Unknown value for %s: %s\n", opt, arg);
3533 static int opt_seek(void *optctx, const char *opt, const char *arg)
3535 start_time = parse_time_or_die(opt, arg, 1);
3539 static int opt_duration(void *optctx, const char *opt, const char *arg)
3541 duration = parse_time_or_die(opt, arg, 1);
3545 static int opt_show_mode(void *optctx, const char *opt, const char *arg)
3547 show_mode = !strcmp(arg, "video") ? SHOW_MODE_VIDEO :
3548 !strcmp(arg, "waves") ? SHOW_MODE_WAVES :
3549 !strcmp(arg, "rdft" ) ? SHOW_MODE_RDFT :
3550 parse_number_or_die(opt, arg, OPT_INT, 0, SHOW_MODE_NB-1);
3554 static void opt_input_file(void *optctx, const char *filename)
3556 if (input_filename) {
3557 av_log(NULL, AV_LOG_FATAL,
3558 "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3559 filename, input_filename);
3562 if (!strcmp(filename, "-"))
3564 input_filename = filename;
3567 static int opt_codec(void *optctx, const char *opt, const char *arg)
3569 const char *spec = strchr(opt, ':');
3571 av_log(NULL, AV_LOG_ERROR,
3572 "No media specifier was specified in '%s' in option '%s'\n",
3574 return AVERROR(EINVAL);
3578 case 'a' : audio_codec_name = arg; break;
3579 case 's' : subtitle_codec_name = arg; break;
3580 case 'v' : video_codec_name = arg; break;
3582 av_log(NULL, AV_LOG_ERROR,
3583 "Invalid media specifier '%s' in option '%s'\n", spec, opt);
3584 return AVERROR(EINVAL);
3591 static const OptionDef options[] = {
3592 CMDUTILS_COMMON_OPTIONS
3593 { "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
3594 { "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
3595 { "s", HAS_ARG | OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
3596 { "fs", OPT_BOOL, { &is_full_screen }, "force full screen" },
3597 { "an", OPT_BOOL, { &audio_disable }, "disable audio" },
3598 { "vn", OPT_BOOL, { &video_disable }, "disable video" },
3599 { "sn", OPT_BOOL, { &subtitle_disable }, "disable subtitling" },
3600 { "ast", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_specifier" },
3601 { "vst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_specifier" },
3602 { "sst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_specifier" },
3603 { "ss", HAS_ARG, { .func_arg = opt_seek }, "seek to a given position in seconds", "pos" },
3604 { "t", HAS_ARG, { .func_arg = opt_duration }, "play \"duration\" seconds of audio/video", "duration" },
3605 { "bytes", OPT_INT | HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
3606 { "seek_interval", OPT_FLOAT | HAS_ARG, { &seek_interval }, "set seek interval for left/right keys, in seconds", "seconds" },
3607 { "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
3608 { "noborder", OPT_BOOL, { &borderless }, "borderless window" },
3609 { "alwaysontop", OPT_BOOL, { &alwaysontop }, "window always on top" },
3610 { "volume", OPT_INT | HAS_ARG, { &startup_volume}, "set startup volume 0=min 100=max", "volume" },
3611 { "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
3612 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
3613 { "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" },
3614 { "fast", OPT_BOOL | OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
3615 { "genpts", OPT_BOOL | OPT_EXPERT, { &genpts }, "generate pts", "" },
3616 { "drp", OPT_INT | HAS_ARG | OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
3617 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, { &lowres }, "", "" },
3618 { "sync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
3619 { "autoexit", OPT_BOOL | OPT_EXPERT, { &autoexit }, "exit at the end", "" },
3620 { "exitonkeydown", OPT_BOOL | OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
3621 { "exitonmousedown", OPT_BOOL | OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
3622 { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
3623 { "framedrop", OPT_BOOL | OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
3624 { "infbuf", OPT_BOOL | OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
3625 { "window_title", OPT_STRING | HAS_ARG, { &window_title }, "set window title", "window title" },
3626 { "left", OPT_INT | HAS_ARG | OPT_EXPERT, { &screen_left }, "set the x position for the left of the window", "x pos" },
3627 { "top", OPT_INT | HAS_ARG | OPT_EXPERT, { &screen_top }, "set the y position for the top of the window", "y pos" },
3629 { "vf", OPT_EXPERT | HAS_ARG, { .func_arg = opt_add_vfilter }, "set video filters", "filter_graph" },
3630 { "af", OPT_STRING | HAS_ARG, { &afilters }, "set audio filters", "filter_graph" },
3632 { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
3633 { "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
3634 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default }, "generic catch all option", "" },
3635 { "i", OPT_BOOL, { &dummy}, "read specified file", "input_file"},
3636 { "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
3637 { "acodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &audio_codec_name }, "force audio decoder", "decoder_name" },
3638 { "scodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
3639 { "vcodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &video_codec_name }, "force video decoder", "decoder_name" },
3640 { "autorotate", OPT_BOOL, { &autorotate }, "automatically rotate video", "" },
3641 { "find_stream_info", OPT_BOOL | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3642 "read and decode the streams to fill missing information with heuristics" },
3643 { "filter_threads", HAS_ARG | OPT_INT | OPT_EXPERT, { &filter_nbthreads }, "number of filter threads per graph" },
3647 static void show_usage(void)
3649 av_log(NULL, AV_LOG_INFO, "Simple media player\n");
3650 av_log(NULL, AV_LOG_INFO, "usage: %s [options] input_file\n", program_name);
3651 av_log(NULL, AV_LOG_INFO, "\n");
3654 void show_help_default(const char *opt, const char *arg)
3656 av_log_set_callback(log_callback_help);
3658 show_help_options(options, "Main options:", 0, OPT_EXPERT, 0);
3659 show_help_options(options, "Advanced options:", OPT_EXPERT, 0, 0);
3661 show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3662 show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3663 #if !CONFIG_AVFILTER
3664 show_help_children(sws_get_class(), AV_OPT_FLAG_ENCODING_PARAM);
3666 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
3668 printf("\nWhile playing:\n"
3670 "f toggle full screen\n"
3673 "9, 0 decrease and increase volume respectively\n"
3674 "/, * decrease and increase volume respectively\n"
3675 "a cycle audio channel in the current program\n"
3676 "v cycle video channel\n"
3677 "t cycle subtitle channel in the current program\n"
3679 "w cycle video filters or show modes\n"
3680 "s activate frame-step mode\n"
3681 "left/right seek backward/forward 10 seconds or to custom interval if -seek_interval is set\n"
3682 "down/up seek backward/forward 1 minute\n"
3683 "page down/page up seek backward/forward 10 minutes\n"
3684 "right mouse click seek to percentage in file corresponding to fraction of width\n"
3685 "left double-click toggle full screen\n"
3689 /* Called from the main */
3690 int main(int argc, char **argv)
3697 av_log_set_flags(AV_LOG_SKIP_REPEATED);
3698 parse_loglevel(argc, argv, options);
3700 /* register all codecs, demux and protocols */
3702 avdevice_register_all();
3704 avformat_network_init();
3708 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
3709 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
3711 show_banner(argc, argv, options);
3713 parse_options(NULL, argc, argv, options, opt_input_file);
3715 if (!input_filename) {
3717 av_log(NULL, AV_LOG_FATAL, "An input file must be specified\n");
3718 av_log(NULL, AV_LOG_FATAL,
3719 "Use -h to get full help or, even better, run 'man %s'\n", program_name);
3723 if (display_disable) {
3726 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
3728 flags &= ~SDL_INIT_AUDIO;
3730 /* Try to work around an occasional ALSA buffer underflow issue when the
3731 * period size is NPOT due to ALSA resampling by forcing the buffer size. */
3732 if (!SDL_getenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE"))
3733 SDL_setenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE","1", 1);
3735 if (display_disable)
3736 flags &= ~SDL_INIT_VIDEO;
3737 if (SDL_Init (flags)) {
3738 av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n", SDL_GetError());
3739 av_log(NULL, AV_LOG_FATAL, "(Did you set the DISPLAY variable?)\n");
3743 SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
3744 SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
3746 if (!display_disable) {
3747 int flags = SDL_WINDOW_HIDDEN;
3749 #if SDL_VERSION_ATLEAST(2,0,5)
3750 flags |= SDL_WINDOW_ALWAYS_ON_TOP;
3752 av_log(NULL, AV_LOG_WARNING, "Your SDL version doesn't support SDL_WINDOW_ALWAYS_ON_TOP. Feature will be inactive.\n");
3755 flags |= SDL_WINDOW_BORDERLESS;
3757 flags |= SDL_WINDOW_RESIZABLE;
3758 window = SDL_CreateWindow(program_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, default_width, default_height, flags);
3759 SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
3761 renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
3763 av_log(NULL, AV_LOG_WARNING, "Failed to initialize a hardware accelerated renderer: %s\n", SDL_GetError());
3764 renderer = SDL_CreateRenderer(window, -1, 0);
3767 if (!SDL_GetRendererInfo(renderer, &renderer_info))
3768 av_log(NULL, AV_LOG_VERBOSE, "Initialized %s renderer.\n", renderer_info.name);
3771 if (!window || !renderer || !renderer_info.num_texture_formats) {
3772 av_log(NULL, AV_LOG_FATAL, "Failed to create window or renderer: %s", SDL_GetError());
3777 is = stream_open(input_filename, file_iformat);
3779 av_log(NULL, AV_LOG_FATAL, "Failed to initialize VideoState!\n");