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);
657 if (d->avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
659 ret = avcodec_decode_subtitle2(d->avctx, sub, &got_frame, d->pkt);
661 ret = AVERROR(EAGAIN);
663 if (got_frame && !d->pkt->data) {
664 d->packet_pending = 1;
666 ret = got_frame ? 0 : (d->pkt->data ? AVERROR(EAGAIN) : AVERROR_EOF);
668 av_packet_unref(d->pkt);
670 if (avcodec_send_packet(d->avctx, d->pkt) == AVERROR(EAGAIN)) {
671 av_log(d->avctx, AV_LOG_ERROR, "Receive_frame and send_packet both returned EAGAIN, which is an API violation.\n");
672 d->packet_pending = 1;
674 av_packet_unref(d->pkt);
680 static void decoder_destroy(Decoder *d) {
681 av_packet_free(&d->pkt);
682 avcodec_free_context(&d->avctx);
685 static void frame_queue_unref_item(Frame *vp)
687 av_frame_unref(vp->frame);
688 avsubtitle_free(&vp->sub);
691 static int frame_queue_init(FrameQueue *f, PacketQueue *pktq, int max_size, int keep_last)
694 memset(f, 0, sizeof(FrameQueue));
695 if (!(f->mutex = SDL_CreateMutex())) {
696 av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
697 return AVERROR(ENOMEM);
699 if (!(f->cond = SDL_CreateCond())) {
700 av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
701 return AVERROR(ENOMEM);
704 f->max_size = FFMIN(max_size, FRAME_QUEUE_SIZE);
705 f->keep_last = !!keep_last;
706 for (i = 0; i < f->max_size; i++)
707 if (!(f->queue[i].frame = av_frame_alloc()))
708 return AVERROR(ENOMEM);
712 static void frame_queue_destory(FrameQueue *f)
715 for (i = 0; i < f->max_size; i++) {
716 Frame *vp = &f->queue[i];
717 frame_queue_unref_item(vp);
718 av_frame_free(&vp->frame);
720 SDL_DestroyMutex(f->mutex);
721 SDL_DestroyCond(f->cond);
724 static void frame_queue_signal(FrameQueue *f)
726 SDL_LockMutex(f->mutex);
727 SDL_CondSignal(f->cond);
728 SDL_UnlockMutex(f->mutex);
731 static Frame *frame_queue_peek(FrameQueue *f)
733 return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
736 static Frame *frame_queue_peek_next(FrameQueue *f)
738 return &f->queue[(f->rindex + f->rindex_shown + 1) % f->max_size];
741 static Frame *frame_queue_peek_last(FrameQueue *f)
743 return &f->queue[f->rindex];
746 static Frame *frame_queue_peek_writable(FrameQueue *f)
748 /* wait until we have space to put a new frame */
749 SDL_LockMutex(f->mutex);
750 while (f->size >= f->max_size &&
751 !f->pktq->abort_request) {
752 SDL_CondWait(f->cond, f->mutex);
754 SDL_UnlockMutex(f->mutex);
756 if (f->pktq->abort_request)
759 return &f->queue[f->windex];
762 static Frame *frame_queue_peek_readable(FrameQueue *f)
764 /* wait until we have a readable a new frame */
765 SDL_LockMutex(f->mutex);
766 while (f->size - f->rindex_shown <= 0 &&
767 !f->pktq->abort_request) {
768 SDL_CondWait(f->cond, f->mutex);
770 SDL_UnlockMutex(f->mutex);
772 if (f->pktq->abort_request)
775 return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
778 static void frame_queue_push(FrameQueue *f)
780 if (++f->windex == f->max_size)
782 SDL_LockMutex(f->mutex);
784 SDL_CondSignal(f->cond);
785 SDL_UnlockMutex(f->mutex);
788 static void frame_queue_next(FrameQueue *f)
790 if (f->keep_last && !f->rindex_shown) {
794 frame_queue_unref_item(&f->queue[f->rindex]);
795 if (++f->rindex == f->max_size)
797 SDL_LockMutex(f->mutex);
799 SDL_CondSignal(f->cond);
800 SDL_UnlockMutex(f->mutex);
803 /* return the number of undisplayed frames in the queue */
804 static int frame_queue_nb_remaining(FrameQueue *f)
806 return f->size - f->rindex_shown;
809 /* return last shown position */
810 static int64_t frame_queue_last_pos(FrameQueue *f)
812 Frame *fp = &f->queue[f->rindex];
813 if (f->rindex_shown && fp->serial == f->pktq->serial)
819 static void decoder_abort(Decoder *d, FrameQueue *fq)
821 packet_queue_abort(d->queue);
822 frame_queue_signal(fq);
823 SDL_WaitThread(d->decoder_tid, NULL);
824 d->decoder_tid = NULL;
825 packet_queue_flush(d->queue);
828 static inline void fill_rectangle(int x, int y, int w, int h)
836 SDL_RenderFillRect(renderer, &rect);
839 static int realloc_texture(SDL_Texture **texture, Uint32 new_format, int new_width, int new_height, SDL_BlendMode blendmode, int init_texture)
843 if (!*texture || SDL_QueryTexture(*texture, &format, &access, &w, &h) < 0 || new_width != w || new_height != h || new_format != format) {
847 SDL_DestroyTexture(*texture);
848 if (!(*texture = SDL_CreateTexture(renderer, new_format, SDL_TEXTUREACCESS_STREAMING, new_width, new_height)))
850 if (SDL_SetTextureBlendMode(*texture, blendmode) < 0)
853 if (SDL_LockTexture(*texture, NULL, &pixels, &pitch) < 0)
855 memset(pixels, 0, pitch * new_height);
856 SDL_UnlockTexture(*texture);
858 av_log(NULL, AV_LOG_VERBOSE, "Created %dx%d texture with %s.\n", new_width, new_height, SDL_GetPixelFormatName(new_format));
863 static void calculate_display_rect(SDL_Rect *rect,
864 int scr_xleft, int scr_ytop, int scr_width, int scr_height,
865 int pic_width, int pic_height, AVRational pic_sar)
867 AVRational aspect_ratio = pic_sar;
868 int64_t width, height, x, y;
870 if (av_cmp_q(aspect_ratio, av_make_q(0, 1)) <= 0)
871 aspect_ratio = av_make_q(1, 1);
873 aspect_ratio = av_mul_q(aspect_ratio, av_make_q(pic_width, pic_height));
875 /* XXX: we suppose the screen has a 1.0 pixel ratio */
877 width = av_rescale(height, aspect_ratio.num, aspect_ratio.den) & ~1;
878 if (width > scr_width) {
880 height = av_rescale(width, aspect_ratio.den, aspect_ratio.num) & ~1;
882 x = (scr_width - width) / 2;
883 y = (scr_height - height) / 2;
884 rect->x = scr_xleft + x;
885 rect->y = scr_ytop + y;
886 rect->w = FFMAX((int)width, 1);
887 rect->h = FFMAX((int)height, 1);
890 static void get_sdl_pix_fmt_and_blendmode(int format, Uint32 *sdl_pix_fmt, SDL_BlendMode *sdl_blendmode)
893 *sdl_blendmode = SDL_BLENDMODE_NONE;
894 *sdl_pix_fmt = SDL_PIXELFORMAT_UNKNOWN;
895 if (format == AV_PIX_FMT_RGB32 ||
896 format == AV_PIX_FMT_RGB32_1 ||
897 format == AV_PIX_FMT_BGR32 ||
898 format == AV_PIX_FMT_BGR32_1)
899 *sdl_blendmode = SDL_BLENDMODE_BLEND;
900 for (i = 0; i < FF_ARRAY_ELEMS(sdl_texture_format_map) - 1; i++) {
901 if (format == sdl_texture_format_map[i].format) {
902 *sdl_pix_fmt = sdl_texture_format_map[i].texture_fmt;
908 static int upload_texture(SDL_Texture **tex, AVFrame *frame, struct SwsContext **img_convert_ctx) {
911 SDL_BlendMode sdl_blendmode;
912 get_sdl_pix_fmt_and_blendmode(frame->format, &sdl_pix_fmt, &sdl_blendmode);
913 if (realloc_texture(tex, sdl_pix_fmt == SDL_PIXELFORMAT_UNKNOWN ? SDL_PIXELFORMAT_ARGB8888 : sdl_pix_fmt, frame->width, frame->height, sdl_blendmode, 0) < 0)
915 switch (sdl_pix_fmt) {
916 case SDL_PIXELFORMAT_UNKNOWN:
917 /* This should only happen if we are not using avfilter... */
918 *img_convert_ctx = sws_getCachedContext(*img_convert_ctx,
919 frame->width, frame->height, frame->format, frame->width, frame->height,
920 AV_PIX_FMT_BGRA, sws_flags, NULL, NULL, NULL);
921 if (*img_convert_ctx != NULL) {
924 if (!SDL_LockTexture(*tex, NULL, (void **)pixels, pitch)) {
925 sws_scale(*img_convert_ctx, (const uint8_t * const *)frame->data, frame->linesize,
926 0, frame->height, pixels, pitch);
927 SDL_UnlockTexture(*tex);
930 av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
934 case SDL_PIXELFORMAT_IYUV:
935 if (frame->linesize[0] > 0 && frame->linesize[1] > 0 && frame->linesize[2] > 0) {
936 ret = SDL_UpdateYUVTexture(*tex, NULL, frame->data[0], frame->linesize[0],
937 frame->data[1], frame->linesize[1],
938 frame->data[2], frame->linesize[2]);
939 } else if (frame->linesize[0] < 0 && frame->linesize[1] < 0 && frame->linesize[2] < 0) {
940 ret = SDL_UpdateYUVTexture(*tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height - 1), -frame->linesize[0],
941 frame->data[1] + frame->linesize[1] * (AV_CEIL_RSHIFT(frame->height, 1) - 1), -frame->linesize[1],
942 frame->data[2] + frame->linesize[2] * (AV_CEIL_RSHIFT(frame->height, 1) - 1), -frame->linesize[2]);
944 av_log(NULL, AV_LOG_ERROR, "Mixed negative and positive linesizes are not supported.\n");
949 if (frame->linesize[0] < 0) {
950 ret = SDL_UpdateTexture(*tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height - 1), -frame->linesize[0]);
952 ret = SDL_UpdateTexture(*tex, NULL, frame->data[0], frame->linesize[0]);
959 static void set_sdl_yuv_conversion_mode(AVFrame *frame)
961 #if SDL_VERSION_ATLEAST(2,0,8)
962 SDL_YUV_CONVERSION_MODE mode = SDL_YUV_CONVERSION_AUTOMATIC;
963 if (frame && (frame->format == AV_PIX_FMT_YUV420P || frame->format == AV_PIX_FMT_YUYV422 || frame->format == AV_PIX_FMT_UYVY422)) {
964 if (frame->color_range == AVCOL_RANGE_JPEG)
965 mode = SDL_YUV_CONVERSION_JPEG;
966 else if (frame->colorspace == AVCOL_SPC_BT709)
967 mode = SDL_YUV_CONVERSION_BT709;
968 else if (frame->colorspace == AVCOL_SPC_BT470BG || frame->colorspace == AVCOL_SPC_SMPTE170M || frame->colorspace == AVCOL_SPC_SMPTE240M)
969 mode = SDL_YUV_CONVERSION_BT601;
971 SDL_SetYUVConversionMode(mode);
975 static void video_image_display(VideoState *is)
981 vp = frame_queue_peek_last(&is->pictq);
982 if (is->subtitle_st) {
983 if (frame_queue_nb_remaining(&is->subpq) > 0) {
984 sp = frame_queue_peek(&is->subpq);
986 if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {
991 if (!sp->width || !sp->height) {
992 sp->width = vp->width;
993 sp->height = vp->height;
995 if (realloc_texture(&is->sub_texture, SDL_PIXELFORMAT_ARGB8888, sp->width, sp->height, SDL_BLENDMODE_BLEND, 1) < 0)
998 for (i = 0; i < sp->sub.num_rects; i++) {
999 AVSubtitleRect *sub_rect = sp->sub.rects[i];
1001 sub_rect->x = av_clip(sub_rect->x, 0, sp->width );
1002 sub_rect->y = av_clip(sub_rect->y, 0, sp->height);
1003 sub_rect->w = av_clip(sub_rect->w, 0, sp->width - sub_rect->x);
1004 sub_rect->h = av_clip(sub_rect->h, 0, sp->height - sub_rect->y);
1006 is->sub_convert_ctx = sws_getCachedContext(is->sub_convert_ctx,
1007 sub_rect->w, sub_rect->h, AV_PIX_FMT_PAL8,
1008 sub_rect->w, sub_rect->h, AV_PIX_FMT_BGRA,
1009 0, NULL, NULL, NULL);
1010 if (!is->sub_convert_ctx) {
1011 av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
1014 if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)pixels, pitch)) {
1015 sws_scale(is->sub_convert_ctx, (const uint8_t * const *)sub_rect->data, sub_rect->linesize,
1016 0, sub_rect->h, pixels, pitch);
1017 SDL_UnlockTexture(is->sub_texture);
1027 calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp->width, vp->height, vp->sar);
1029 if (!vp->uploaded) {
1030 if (upload_texture(&is->vid_texture, vp->frame, &is->img_convert_ctx) < 0)
1033 vp->flip_v = vp->frame->linesize[0] < 0;
1036 set_sdl_yuv_conversion_mode(vp->frame);
1037 SDL_RenderCopyEx(renderer, is->vid_texture, NULL, &rect, 0, NULL, vp->flip_v ? SDL_FLIP_VERTICAL : 0);
1038 set_sdl_yuv_conversion_mode(NULL);
1040 #if USE_ONEPASS_SUBTITLE_RENDER
1041 SDL_RenderCopy(renderer, is->sub_texture, NULL, &rect);
1044 double xratio = (double)rect.w / (double)sp->width;
1045 double yratio = (double)rect.h / (double)sp->height;
1046 for (i = 0; i < sp->sub.num_rects; i++) {
1047 SDL_Rect *sub_rect = (SDL_Rect*)sp->sub.rects[i];
1048 SDL_Rect target = {.x = rect.x + sub_rect->x * xratio,
1049 .y = rect.y + sub_rect->y * yratio,
1050 .w = sub_rect->w * xratio,
1051 .h = sub_rect->h * yratio};
1052 SDL_RenderCopy(renderer, is->sub_texture, sub_rect, &target);
1058 static inline int compute_mod(int a, int b)
1060 return a < 0 ? a%b + b : a%b;
1063 static void video_audio_display(VideoState *s)
1065 int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
1066 int ch, channels, h, h2;
1068 int rdft_bits, nb_freq;
1070 for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++)
1072 nb_freq = 1 << (rdft_bits - 1);
1074 /* compute display index : center on currently output samples */
1075 channels = s->audio_tgt.channels;
1076 nb_display_channels = channels;
1078 int data_used= s->show_mode == SHOW_MODE_WAVES ? s->width : (2*nb_freq);
1080 delay = s->audio_write_buf_size;
1083 /* to be more precise, we take into account the time spent since
1084 the last buffer computation */
1085 if (audio_callback_time) {
1086 time_diff = av_gettime_relative() - audio_callback_time;
1087 delay -= (time_diff * s->audio_tgt.freq) / 1000000;
1090 delay += 2 * data_used;
1091 if (delay < data_used)
1094 i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
1095 if (s->show_mode == SHOW_MODE_WAVES) {
1097 for (i = 0; i < 1000; i += channels) {
1098 int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
1099 int a = s->sample_array[idx];
1100 int b = s->sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];
1101 int c = s->sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];
1102 int d = s->sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];
1104 if (h < score && (b ^ c) < 0) {
1111 s->last_i_start = i_start;
1113 i_start = s->last_i_start;
1116 if (s->show_mode == SHOW_MODE_WAVES) {
1117 SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
1119 /* total height for one channel */
1120 h = s->height / nb_display_channels;
1121 /* graph height / 2 */
1123 for (ch = 0; ch < nb_display_channels; ch++) {
1125 y1 = s->ytop + ch * h + (h / 2); /* position of center line */
1126 for (x = 0; x < s->width; x++) {
1127 y = (s->sample_array[i] * h2) >> 15;
1134 fill_rectangle(s->xleft + x, ys, 1, y);
1136 if (i >= SAMPLE_ARRAY_SIZE)
1137 i -= SAMPLE_ARRAY_SIZE;
1141 SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255);
1143 for (ch = 1; ch < nb_display_channels; ch++) {
1144 y = s->ytop + ch * h;
1145 fill_rectangle(s->xleft, y, s->width, 1);
1148 if (realloc_texture(&s->vis_texture, SDL_PIXELFORMAT_ARGB8888, s->width, s->height, SDL_BLENDMODE_NONE, 1) < 0)
1151 nb_display_channels= FFMIN(nb_display_channels, 2);
1152 if (rdft_bits != s->rdft_bits) {
1153 av_rdft_end(s->rdft);
1154 av_free(s->rdft_data);
1155 s->rdft = av_rdft_init(rdft_bits, DFT_R2C);
1156 s->rdft_bits = rdft_bits;
1157 s->rdft_data = av_malloc_array(nb_freq, 4 *sizeof(*s->rdft_data));
1159 if (!s->rdft || !s->rdft_data){
1160 av_log(NULL, AV_LOG_ERROR, "Failed to allocate buffers for RDFT, switching to waves display\n");
1161 s->show_mode = SHOW_MODE_WAVES;
1164 SDL_Rect rect = {.x = s->xpos, .y = 0, .w = 1, .h = s->height};
1167 for (ch = 0; ch < nb_display_channels; ch++) {
1168 data[ch] = s->rdft_data + 2 * nb_freq * ch;
1170 for (x = 0; x < 2 * nb_freq; x++) {
1171 double w = (x-nb_freq) * (1.0 / nb_freq);
1172 data[ch][x] = s->sample_array[i] * (1.0 - w * w);
1174 if (i >= SAMPLE_ARRAY_SIZE)
1175 i -= SAMPLE_ARRAY_SIZE;
1177 av_rdft_calc(s->rdft, data[ch]);
1179 /* Least efficient way to do this, we should of course
1180 * directly access it but it is more than fast enough. */
1181 if (!SDL_LockTexture(s->vis_texture, &rect, (void **)&pixels, &pitch)) {
1183 pixels += pitch * s->height;
1184 for (y = 0; y < s->height; y++) {
1185 double w = 1 / sqrt(nb_freq);
1186 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]));
1187 int b = (nb_display_channels == 2 ) ? sqrt(w * hypot(data[1][2 * y + 0], data[1][2 * y + 1]))
1192 *pixels = (a << 16) + (b << 8) + ((a+b) >> 1);
1194 SDL_UnlockTexture(s->vis_texture);
1196 SDL_RenderCopy(renderer, s->vis_texture, NULL, NULL);
1200 if (s->xpos >= s->width)
1205 static void stream_component_close(VideoState *is, int stream_index)
1207 AVFormatContext *ic = is->ic;
1208 AVCodecParameters *codecpar;
1210 if (stream_index < 0 || stream_index >= ic->nb_streams)
1212 codecpar = ic->streams[stream_index]->codecpar;
1214 switch (codecpar->codec_type) {
1215 case AVMEDIA_TYPE_AUDIO:
1216 decoder_abort(&is->auddec, &is->sampq);
1217 SDL_CloseAudioDevice(audio_dev);
1218 decoder_destroy(&is->auddec);
1219 swr_free(&is->swr_ctx);
1220 av_freep(&is->audio_buf1);
1221 is->audio_buf1_size = 0;
1222 is->audio_buf = NULL;
1225 av_rdft_end(is->rdft);
1226 av_freep(&is->rdft_data);
1231 case AVMEDIA_TYPE_VIDEO:
1232 decoder_abort(&is->viddec, &is->pictq);
1233 decoder_destroy(&is->viddec);
1235 case AVMEDIA_TYPE_SUBTITLE:
1236 decoder_abort(&is->subdec, &is->subpq);
1237 decoder_destroy(&is->subdec);
1243 ic->streams[stream_index]->discard = AVDISCARD_ALL;
1244 switch (codecpar->codec_type) {
1245 case AVMEDIA_TYPE_AUDIO:
1246 is->audio_st = NULL;
1247 is->audio_stream = -1;
1249 case AVMEDIA_TYPE_VIDEO:
1250 is->video_st = NULL;
1251 is->video_stream = -1;
1253 case AVMEDIA_TYPE_SUBTITLE:
1254 is->subtitle_st = NULL;
1255 is->subtitle_stream = -1;
1262 static void stream_close(VideoState *is)
1264 /* XXX: use a special url_shutdown call to abort parse cleanly */
1265 is->abort_request = 1;
1266 SDL_WaitThread(is->read_tid, NULL);
1268 /* close each stream */
1269 if (is->audio_stream >= 0)
1270 stream_component_close(is, is->audio_stream);
1271 if (is->video_stream >= 0)
1272 stream_component_close(is, is->video_stream);
1273 if (is->subtitle_stream >= 0)
1274 stream_component_close(is, is->subtitle_stream);
1276 avformat_close_input(&is->ic);
1278 packet_queue_destroy(&is->videoq);
1279 packet_queue_destroy(&is->audioq);
1280 packet_queue_destroy(&is->subtitleq);
1282 /* free all pictures */
1283 frame_queue_destory(&is->pictq);
1284 frame_queue_destory(&is->sampq);
1285 frame_queue_destory(&is->subpq);
1286 SDL_DestroyCond(is->continue_read_thread);
1287 sws_freeContext(is->img_convert_ctx);
1288 sws_freeContext(is->sub_convert_ctx);
1289 av_free(is->filename);
1290 if (is->vis_texture)
1291 SDL_DestroyTexture(is->vis_texture);
1292 if (is->vid_texture)
1293 SDL_DestroyTexture(is->vid_texture);
1294 if (is->sub_texture)
1295 SDL_DestroyTexture(is->sub_texture);
1299 static void do_exit(VideoState *is)
1305 SDL_DestroyRenderer(renderer);
1307 SDL_DestroyWindow(window);
1310 av_freep(&vfilters_list);
1312 avformat_network_deinit();
1316 av_log(NULL, AV_LOG_QUIET, "%s", "");
1320 static void sigterm_handler(int sig)
1325 static void set_default_window_size(int width, int height, AVRational sar)
1328 int max_width = screen_width ? screen_width : INT_MAX;
1329 int max_height = screen_height ? screen_height : INT_MAX;
1330 if (max_width == INT_MAX && max_height == INT_MAX)
1331 max_height = height;
1332 calculate_display_rect(&rect, 0, 0, max_width, max_height, width, height, sar);
1333 default_width = rect.w;
1334 default_height = rect.h;
1337 static int video_open(VideoState *is)
1341 w = screen_width ? screen_width : default_width;
1342 h = screen_height ? screen_height : default_height;
1345 window_title = input_filename;
1346 SDL_SetWindowTitle(window, window_title);
1348 SDL_SetWindowSize(window, w, h);
1349 SDL_SetWindowPosition(window, screen_left, screen_top);
1351 SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
1352 SDL_ShowWindow(window);
1360 /* display the current picture, if any */
1361 static void video_display(VideoState *is)
1366 SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
1367 SDL_RenderClear(renderer);
1368 if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
1369 video_audio_display(is);
1370 else if (is->video_st)
1371 video_image_display(is);
1372 SDL_RenderPresent(renderer);
1375 static double get_clock(Clock *c)
1377 if (*c->queue_serial != c->serial)
1382 double time = av_gettime_relative() / 1000000.0;
1383 return c->pts_drift + time - (time - c->last_updated) * (1.0 - c->speed);
1387 static void set_clock_at(Clock *c, double pts, int serial, double time)
1390 c->last_updated = time;
1391 c->pts_drift = c->pts - time;
1395 static void set_clock(Clock *c, double pts, int serial)
1397 double time = av_gettime_relative() / 1000000.0;
1398 set_clock_at(c, pts, serial, time);
1401 static void set_clock_speed(Clock *c, double speed)
1403 set_clock(c, get_clock(c), c->serial);
1407 static void init_clock(Clock *c, int *queue_serial)
1411 c->queue_serial = queue_serial;
1412 set_clock(c, NAN, -1);
1415 static void sync_clock_to_slave(Clock *c, Clock *slave)
1417 double clock = get_clock(c);
1418 double slave_clock = get_clock(slave);
1419 if (!isnan(slave_clock) && (isnan(clock) || fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))
1420 set_clock(c, slave_clock, slave->serial);
1423 static int get_master_sync_type(VideoState *is) {
1424 if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
1426 return AV_SYNC_VIDEO_MASTER;
1428 return AV_SYNC_AUDIO_MASTER;
1429 } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
1431 return AV_SYNC_AUDIO_MASTER;
1433 return AV_SYNC_EXTERNAL_CLOCK;
1435 return AV_SYNC_EXTERNAL_CLOCK;
1439 /* get the current master clock value */
1440 static double get_master_clock(VideoState *is)
1444 switch (get_master_sync_type(is)) {
1445 case AV_SYNC_VIDEO_MASTER:
1446 val = get_clock(&is->vidclk);
1448 case AV_SYNC_AUDIO_MASTER:
1449 val = get_clock(&is->audclk);
1452 val = get_clock(&is->extclk);
1458 static void check_external_clock_speed(VideoState *is) {
1459 if (is->video_stream >= 0 && is->videoq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES ||
1460 is->audio_stream >= 0 && is->audioq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES) {
1461 set_clock_speed(&is->extclk, FFMAX(EXTERNAL_CLOCK_SPEED_MIN, is->extclk.speed - EXTERNAL_CLOCK_SPEED_STEP));
1462 } else if ((is->video_stream < 0 || is->videoq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES) &&
1463 (is->audio_stream < 0 || is->audioq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES)) {
1464 set_clock_speed(&is->extclk, FFMIN(EXTERNAL_CLOCK_SPEED_MAX, is->extclk.speed + EXTERNAL_CLOCK_SPEED_STEP));
1466 double speed = is->extclk.speed;
1468 set_clock_speed(&is->extclk, speed + EXTERNAL_CLOCK_SPEED_STEP * (1.0 - speed) / fabs(1.0 - speed));
1472 /* seek in the stream */
1473 static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)
1475 if (!is->seek_req) {
1478 is->seek_flags &= ~AVSEEK_FLAG_BYTE;
1480 is->seek_flags |= AVSEEK_FLAG_BYTE;
1482 SDL_CondSignal(is->continue_read_thread);
1486 /* pause or resume the video */
1487 static void stream_toggle_pause(VideoState *is)
1490 is->frame_timer += av_gettime_relative() / 1000000.0 - is->vidclk.last_updated;
1491 if (is->read_pause_return != AVERROR(ENOSYS)) {
1492 is->vidclk.paused = 0;
1494 set_clock(&is->vidclk, get_clock(&is->vidclk), is->vidclk.serial);
1496 set_clock(&is->extclk, get_clock(&is->extclk), is->extclk.serial);
1497 is->paused = is->audclk.paused = is->vidclk.paused = is->extclk.paused = !is->paused;
1500 static void toggle_pause(VideoState *is)
1502 stream_toggle_pause(is);
1506 static void toggle_mute(VideoState *is)
1508 is->muted = !is->muted;
1511 static void update_volume(VideoState *is, int sign, double step)
1513 double volume_level = is->audio_volume ? (20 * log(is->audio_volume / (double)SDL_MIX_MAXVOLUME) / log(10)) : -1000.0;
1514 int new_volume = lrint(SDL_MIX_MAXVOLUME * pow(10.0, (volume_level + sign * step) / 20.0));
1515 is->audio_volume = av_clip(is->audio_volume == new_volume ? (is->audio_volume + sign) : new_volume, 0, SDL_MIX_MAXVOLUME);
1518 static void step_to_next_frame(VideoState *is)
1520 /* if the stream is paused unpause it, then step */
1522 stream_toggle_pause(is);
1526 static double compute_target_delay(double delay, VideoState *is)
1528 double sync_threshold, diff = 0;
1530 /* update delay to follow master synchronisation source */
1531 if (get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER) {
1532 /* if video is slave, we try to correct big delays by
1533 duplicating or deleting a frame */
1534 diff = get_clock(&is->vidclk) - get_master_clock(is);
1536 /* skip or repeat frame. We take into account the
1537 delay to compute the threshold. I still don't know
1538 if it is the best guess */
1539 sync_threshold = FFMAX(AV_SYNC_THRESHOLD_MIN, FFMIN(AV_SYNC_THRESHOLD_MAX, delay));
1540 if (!isnan(diff) && fabs(diff) < is->max_frame_duration) {
1541 if (diff <= -sync_threshold)
1542 delay = FFMAX(0, delay + diff);
1543 else if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD)
1544 delay = delay + diff;
1545 else if (diff >= sync_threshold)
1550 av_log(NULL, AV_LOG_TRACE, "video: delay=%0.3f A-V=%f\n",
1556 static double vp_duration(VideoState *is, Frame *vp, Frame *nextvp) {
1557 if (vp->serial == nextvp->serial) {
1558 double duration = nextvp->pts - vp->pts;
1559 if (isnan(duration) || duration <= 0 || duration > is->max_frame_duration)
1560 return vp->duration;
1568 static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
1569 /* update current video pts */
1570 set_clock(&is->vidclk, pts, serial);
1571 sync_clock_to_slave(&is->extclk, &is->vidclk);
1574 /* called to display each frame */
1575 static void video_refresh(void *opaque, double *remaining_time)
1577 VideoState *is = opaque;
1582 if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
1583 check_external_clock_speed(is);
1585 if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {
1586 time = av_gettime_relative() / 1000000.0;
1587 if (is->force_refresh || is->last_vis_time + rdftspeed < time) {
1589 is->last_vis_time = time;
1591 *remaining_time = FFMIN(*remaining_time, is->last_vis_time + rdftspeed - time);
1596 if (frame_queue_nb_remaining(&is->pictq) == 0) {
1597 // nothing to do, no picture to display in the queue
1599 double last_duration, duration, delay;
1602 /* dequeue the picture */
1603 lastvp = frame_queue_peek_last(&is->pictq);
1604 vp = frame_queue_peek(&is->pictq);
1606 if (vp->serial != is->videoq.serial) {
1607 frame_queue_next(&is->pictq);
1611 if (lastvp->serial != vp->serial)
1612 is->frame_timer = av_gettime_relative() / 1000000.0;
1617 /* compute nominal last_duration */
1618 last_duration = vp_duration(is, lastvp, vp);
1619 delay = compute_target_delay(last_duration, is);
1621 time= av_gettime_relative()/1000000.0;
1622 if (time < is->frame_timer + delay) {
1623 *remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);
1627 is->frame_timer += delay;
1628 if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)
1629 is->frame_timer = time;
1631 SDL_LockMutex(is->pictq.mutex);
1632 if (!isnan(vp->pts))
1633 update_video_pts(is, vp->pts, vp->pos, vp->serial);
1634 SDL_UnlockMutex(is->pictq.mutex);
1636 if (frame_queue_nb_remaining(&is->pictq) > 1) {
1637 Frame *nextvp = frame_queue_peek_next(&is->pictq);
1638 duration = vp_duration(is, vp, nextvp);
1639 if(!is->step && (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
1640 is->frame_drops_late++;
1641 frame_queue_next(&is->pictq);
1646 if (is->subtitle_st) {
1647 while (frame_queue_nb_remaining(&is->subpq) > 0) {
1648 sp = frame_queue_peek(&is->subpq);
1650 if (frame_queue_nb_remaining(&is->subpq) > 1)
1651 sp2 = frame_queue_peek_next(&is->subpq);
1655 if (sp->serial != is->subtitleq.serial
1656 || (is->vidclk.pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1657 || (sp2 && is->vidclk.pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1661 for (i = 0; i < sp->sub.num_rects; i++) {
1662 AVSubtitleRect *sub_rect = sp->sub.rects[i];
1666 if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)&pixels, &pitch)) {
1667 for (j = 0; j < sub_rect->h; j++, pixels += pitch)
1668 memset(pixels, 0, sub_rect->w << 2);
1669 SDL_UnlockTexture(is->sub_texture);
1673 frame_queue_next(&is->subpq);
1680 frame_queue_next(&is->pictq);
1681 is->force_refresh = 1;
1683 if (is->step && !is->paused)
1684 stream_toggle_pause(is);
1687 /* display picture */
1688 if (!display_disable && is->force_refresh && is->show_mode == SHOW_MODE_VIDEO && is->pictq.rindex_shown)
1691 is->force_refresh = 0;
1694 static int64_t last_time;
1696 int aqsize, vqsize, sqsize;
1699 cur_time = av_gettime_relative();
1700 if (!last_time || (cur_time - last_time) >= 30000) {
1705 aqsize = is->audioq.size;
1707 vqsize = is->videoq.size;
1708 if (is->subtitle_st)
1709 sqsize = is->subtitleq.size;
1711 if (is->audio_st && is->video_st)
1712 av_diff = get_clock(&is->audclk) - get_clock(&is->vidclk);
1713 else if (is->video_st)
1714 av_diff = get_master_clock(is) - get_clock(&is->vidclk);
1715 else if (is->audio_st)
1716 av_diff = get_master_clock(is) - get_clock(&is->audclk);
1718 av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
1720 "%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64" \r",
1721 get_master_clock(is),
1722 (is->audio_st && is->video_st) ? "A-V" : (is->video_st ? "M-V" : (is->audio_st ? "M-A" : " ")),
1724 is->frame_drops_early + is->frame_drops_late,
1728 is->video_st ? is->viddec.avctx->pts_correction_num_faulty_dts : 0,
1729 is->video_st ? is->viddec.avctx->pts_correction_num_faulty_pts : 0);
1731 if (show_status == 1 && AV_LOG_INFO > av_log_get_level())
1732 fprintf(stderr, "%s", buf.str);
1734 av_log(NULL, AV_LOG_INFO, "%s", buf.str);
1737 av_bprint_finalize(&buf, NULL);
1739 last_time = cur_time;
1744 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, double duration, int64_t pos, int serial)
1748 #if defined(DEBUG_SYNC)
1749 printf("frame_type=%c pts=%0.3f\n",
1750 av_get_picture_type_char(src_frame->pict_type), pts);
1753 if (!(vp = frame_queue_peek_writable(&is->pictq)))
1756 vp->sar = src_frame->sample_aspect_ratio;
1759 vp->width = src_frame->width;
1760 vp->height = src_frame->height;
1761 vp->format = src_frame->format;
1764 vp->duration = duration;
1766 vp->serial = serial;
1768 set_default_window_size(vp->width, vp->height, vp->sar);
1770 av_frame_move_ref(vp->frame, src_frame);
1771 frame_queue_push(&is->pictq);
1775 static int get_video_frame(VideoState *is, AVFrame *frame)
1779 if ((got_picture = decoder_decode_frame(&is->viddec, frame, NULL)) < 0)
1785 if (frame->pts != AV_NOPTS_VALUE)
1786 dpts = av_q2d(is->video_st->time_base) * frame->pts;
1788 frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
1790 if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
1791 if (frame->pts != AV_NOPTS_VALUE) {
1792 double diff = dpts - get_master_clock(is);
1793 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD &&
1794 diff - is->frame_last_filter_delay < 0 &&
1795 is->viddec.pkt_serial == is->vidclk.serial &&
1796 is->videoq.nb_packets) {
1797 is->frame_drops_early++;
1798 av_frame_unref(frame);
1809 static int configure_filtergraph(AVFilterGraph *graph, const char *filtergraph,
1810 AVFilterContext *source_ctx, AVFilterContext *sink_ctx)
1813 int nb_filters = graph->nb_filters;
1814 AVFilterInOut *outputs = NULL, *inputs = NULL;
1817 outputs = avfilter_inout_alloc();
1818 inputs = avfilter_inout_alloc();
1819 if (!outputs || !inputs) {
1820 ret = AVERROR(ENOMEM);
1824 outputs->name = av_strdup("in");
1825 outputs->filter_ctx = source_ctx;
1826 outputs->pad_idx = 0;
1827 outputs->next = NULL;
1829 inputs->name = av_strdup("out");
1830 inputs->filter_ctx = sink_ctx;
1831 inputs->pad_idx = 0;
1832 inputs->next = NULL;
1834 if ((ret = avfilter_graph_parse_ptr(graph, filtergraph, &inputs, &outputs, NULL)) < 0)
1837 if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
1841 /* Reorder the filters to ensure that inputs of the custom filters are merged first */
1842 for (i = 0; i < graph->nb_filters - nb_filters; i++)
1843 FFSWAP(AVFilterContext*, graph->filters[i], graph->filters[i + nb_filters]);
1845 ret = avfilter_graph_config(graph, NULL);
1847 avfilter_inout_free(&outputs);
1848 avfilter_inout_free(&inputs);
1852 static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const char *vfilters, AVFrame *frame)
1854 enum AVPixelFormat pix_fmts[FF_ARRAY_ELEMS(sdl_texture_format_map)];
1855 char sws_flags_str[512] = "";
1856 char buffersrc_args[256];
1858 AVFilterContext *filt_src = NULL, *filt_out = NULL, *last_filter = NULL;
1859 AVCodecParameters *codecpar = is->video_st->codecpar;
1860 AVRational fr = av_guess_frame_rate(is->ic, is->video_st, NULL);
1861 AVDictionaryEntry *e = NULL;
1862 int nb_pix_fmts = 0;
1865 for (i = 0; i < renderer_info.num_texture_formats; i++) {
1866 for (j = 0; j < FF_ARRAY_ELEMS(sdl_texture_format_map) - 1; j++) {
1867 if (renderer_info.texture_formats[i] == sdl_texture_format_map[j].texture_fmt) {
1868 pix_fmts[nb_pix_fmts++] = sdl_texture_format_map[j].format;
1873 pix_fmts[nb_pix_fmts] = AV_PIX_FMT_NONE;
1875 while ((e = av_dict_get(sws_dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
1876 if (!strcmp(e->key, "sws_flags")) {
1877 av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", "flags", e->value);
1879 av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", e->key, e->value);
1881 if (strlen(sws_flags_str))
1882 sws_flags_str[strlen(sws_flags_str)-1] = '\0';
1884 graph->scale_sws_opts = av_strdup(sws_flags_str);
1886 snprintf(buffersrc_args, sizeof(buffersrc_args),
1887 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
1888 frame->width, frame->height, frame->format,
1889 is->video_st->time_base.num, is->video_st->time_base.den,
1890 codecpar->sample_aspect_ratio.num, FFMAX(codecpar->sample_aspect_ratio.den, 1));
1891 if (fr.num && fr.den)
1892 av_strlcatf(buffersrc_args, sizeof(buffersrc_args), ":frame_rate=%d/%d", fr.num, fr.den);
1894 if ((ret = avfilter_graph_create_filter(&filt_src,
1895 avfilter_get_by_name("buffer"),
1896 "ffplay_buffer", buffersrc_args, NULL,
1900 ret = avfilter_graph_create_filter(&filt_out,
1901 avfilter_get_by_name("buffersink"),
1902 "ffplay_buffersink", NULL, NULL, graph);
1906 if ((ret = av_opt_set_int_list(filt_out, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1909 last_filter = filt_out;
1911 /* Note: this macro adds a filter before the lastly added filter, so the
1912 * processing order of the filters is in reverse */
1913 #define INSERT_FILT(name, arg) do { \
1914 AVFilterContext *filt_ctx; \
1916 ret = avfilter_graph_create_filter(&filt_ctx, \
1917 avfilter_get_by_name(name), \
1918 "ffplay_" name, arg, NULL, graph); \
1922 ret = avfilter_link(filt_ctx, 0, last_filter, 0); \
1926 last_filter = filt_ctx; \
1930 double theta = get_rotation(is->video_st);
1932 if (fabs(theta - 90) < 1.0) {
1933 INSERT_FILT("transpose", "clock");
1934 } else if (fabs(theta - 180) < 1.0) {
1935 INSERT_FILT("hflip", NULL);
1936 INSERT_FILT("vflip", NULL);
1937 } else if (fabs(theta - 270) < 1.0) {
1938 INSERT_FILT("transpose", "cclock");
1939 } else if (fabs(theta) > 1.0) {
1940 char rotate_buf[64];
1941 snprintf(rotate_buf, sizeof(rotate_buf), "%f*PI/180", theta);
1942 INSERT_FILT("rotate", rotate_buf);
1946 if ((ret = configure_filtergraph(graph, vfilters, filt_src, last_filter)) < 0)
1949 is->in_video_filter = filt_src;
1950 is->out_video_filter = filt_out;
1956 static int configure_audio_filters(VideoState *is, const char *afilters, int force_output_format)
1958 static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
1959 int sample_rates[2] = { 0, -1 };
1960 int64_t channel_layouts[2] = { 0, -1 };
1961 int channels[2] = { 0, -1 };
1962 AVFilterContext *filt_asrc = NULL, *filt_asink = NULL;
1963 char aresample_swr_opts[512] = "";
1964 AVDictionaryEntry *e = NULL;
1965 char asrc_args[256];
1968 avfilter_graph_free(&is->agraph);
1969 if (!(is->agraph = avfilter_graph_alloc()))
1970 return AVERROR(ENOMEM);
1971 is->agraph->nb_threads = filter_nbthreads;
1973 while ((e = av_dict_get(swr_opts, "", e, AV_DICT_IGNORE_SUFFIX)))
1974 av_strlcatf(aresample_swr_opts, sizeof(aresample_swr_opts), "%s=%s:", e->key, e->value);
1975 if (strlen(aresample_swr_opts))
1976 aresample_swr_opts[strlen(aresample_swr_opts)-1] = '\0';
1977 av_opt_set(is->agraph, "aresample_swr_opts", aresample_swr_opts, 0);
1979 ret = snprintf(asrc_args, sizeof(asrc_args),
1980 "sample_rate=%d:sample_fmt=%s:channels=%d:time_base=%d/%d",
1981 is->audio_filter_src.freq, av_get_sample_fmt_name(is->audio_filter_src.fmt),
1982 is->audio_filter_src.channels,
1983 1, is->audio_filter_src.freq);
1984 if (is->audio_filter_src.channel_layout)
1985 snprintf(asrc_args + ret, sizeof(asrc_args) - ret,
1986 ":channel_layout=0x%"PRIx64, is->audio_filter_src.channel_layout);
1988 ret = avfilter_graph_create_filter(&filt_asrc,
1989 avfilter_get_by_name("abuffer"), "ffplay_abuffer",
1990 asrc_args, NULL, is->agraph);
1995 ret = avfilter_graph_create_filter(&filt_asink,
1996 avfilter_get_by_name("abuffersink"), "ffplay_abuffersink",
1997 NULL, NULL, is->agraph);
2001 if ((ret = av_opt_set_int_list(filt_asink, "sample_fmts", sample_fmts, AV_SAMPLE_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
2003 if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 1, AV_OPT_SEARCH_CHILDREN)) < 0)
2006 if (force_output_format) {
2007 channel_layouts[0] = is->audio_tgt.channel_layout;
2008 channels [0] = is->audio_tgt.channel_layout ? -1 : is->audio_tgt.channels;
2009 sample_rates [0] = is->audio_tgt.freq;
2010 if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 0, AV_OPT_SEARCH_CHILDREN)) < 0)
2012 if ((ret = av_opt_set_int_list(filt_asink, "channel_layouts", channel_layouts, -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2014 if ((ret = av_opt_set_int_list(filt_asink, "channel_counts" , channels , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2016 if ((ret = av_opt_set_int_list(filt_asink, "sample_rates" , sample_rates , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2021 if ((ret = configure_filtergraph(is->agraph, afilters, filt_asrc, filt_asink)) < 0)
2024 is->in_audio_filter = filt_asrc;
2025 is->out_audio_filter = filt_asink;
2029 avfilter_graph_free(&is->agraph);
2032 #endif /* CONFIG_AVFILTER */
2034 static int audio_thread(void *arg)
2036 VideoState *is = arg;
2037 AVFrame *frame = av_frame_alloc();
2040 int last_serial = -1;
2041 int64_t dec_channel_layout;
2049 return AVERROR(ENOMEM);
2052 if ((got_frame = decoder_decode_frame(&is->auddec, frame, NULL)) < 0)
2056 tb = (AVRational){1, frame->sample_rate};
2059 dec_channel_layout = get_valid_channel_layout(frame->channel_layout, frame->channels);
2062 cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
2063 frame->format, frame->channels) ||
2064 is->audio_filter_src.channel_layout != dec_channel_layout ||
2065 is->audio_filter_src.freq != frame->sample_rate ||
2066 is->auddec.pkt_serial != last_serial;
2069 char buf1[1024], buf2[1024];
2070 av_get_channel_layout_string(buf1, sizeof(buf1), -1, is->audio_filter_src.channel_layout);
2071 av_get_channel_layout_string(buf2, sizeof(buf2), -1, dec_channel_layout);
2072 av_log(NULL, AV_LOG_DEBUG,
2073 "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",
2074 is->audio_filter_src.freq, is->audio_filter_src.channels, av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, last_serial,
2075 frame->sample_rate, frame->channels, av_get_sample_fmt_name(frame->format), buf2, is->auddec.pkt_serial);
2077 is->audio_filter_src.fmt = frame->format;
2078 is->audio_filter_src.channels = frame->channels;
2079 is->audio_filter_src.channel_layout = dec_channel_layout;
2080 is->audio_filter_src.freq = frame->sample_rate;
2081 last_serial = is->auddec.pkt_serial;
2083 if ((ret = configure_audio_filters(is, afilters, 1)) < 0)
2087 if ((ret = av_buffersrc_add_frame(is->in_audio_filter, frame)) < 0)
2090 while ((ret = av_buffersink_get_frame_flags(is->out_audio_filter, frame, 0)) >= 0) {
2091 tb = av_buffersink_get_time_base(is->out_audio_filter);
2093 if (!(af = frame_queue_peek_writable(&is->sampq)))
2096 af->pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2097 af->pos = frame->pkt_pos;
2098 af->serial = is->auddec.pkt_serial;
2099 af->duration = av_q2d((AVRational){frame->nb_samples, frame->sample_rate});
2101 av_frame_move_ref(af->frame, frame);
2102 frame_queue_push(&is->sampq);
2105 if (is->audioq.serial != is->auddec.pkt_serial)
2108 if (ret == AVERROR_EOF)
2109 is->auddec.finished = is->auddec.pkt_serial;
2112 } while (ret >= 0 || ret == AVERROR(EAGAIN) || ret == AVERROR_EOF);
2115 avfilter_graph_free(&is->agraph);
2117 av_frame_free(&frame);
2121 static int decoder_start(Decoder *d, int (*fn)(void *), const char *thread_name, void* arg)
2123 packet_queue_start(d->queue);
2124 d->decoder_tid = SDL_CreateThread(fn, thread_name, arg);
2125 if (!d->decoder_tid) {
2126 av_log(NULL, AV_LOG_ERROR, "SDL_CreateThread(): %s\n", SDL_GetError());
2127 return AVERROR(ENOMEM);
2132 static int video_thread(void *arg)
2134 VideoState *is = arg;
2135 AVFrame *frame = av_frame_alloc();
2139 AVRational tb = is->video_st->time_base;
2140 AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);
2143 AVFilterGraph *graph = NULL;
2144 AVFilterContext *filt_out = NULL, *filt_in = NULL;
2147 enum AVPixelFormat last_format = -2;
2148 int last_serial = -1;
2149 int last_vfilter_idx = 0;
2153 return AVERROR(ENOMEM);
2156 ret = get_video_frame(is, frame);
2163 if ( last_w != frame->width
2164 || last_h != frame->height
2165 || last_format != frame->format
2166 || last_serial != is->viddec.pkt_serial
2167 || last_vfilter_idx != is->vfilter_idx) {
2168 av_log(NULL, AV_LOG_DEBUG,
2169 "Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
2171 (const char *)av_x_if_null(av_get_pix_fmt_name(last_format), "none"), last_serial,
2172 frame->width, frame->height,
2173 (const char *)av_x_if_null(av_get_pix_fmt_name(frame->format), "none"), is->viddec.pkt_serial);
2174 avfilter_graph_free(&graph);
2175 graph = avfilter_graph_alloc();
2177 ret = AVERROR(ENOMEM);
2180 graph->nb_threads = filter_nbthreads;
2181 if ((ret = configure_video_filters(graph, is, vfilters_list ? vfilters_list[is->vfilter_idx] : NULL, frame)) < 0) {
2183 event.type = FF_QUIT_EVENT;
2184 event.user.data1 = is;
2185 SDL_PushEvent(&event);
2188 filt_in = is->in_video_filter;
2189 filt_out = is->out_video_filter;
2190 last_w = frame->width;
2191 last_h = frame->height;
2192 last_format = frame->format;
2193 last_serial = is->viddec.pkt_serial;
2194 last_vfilter_idx = is->vfilter_idx;
2195 frame_rate = av_buffersink_get_frame_rate(filt_out);
2198 ret = av_buffersrc_add_frame(filt_in, frame);
2203 is->frame_last_returned_time = av_gettime_relative() / 1000000.0;
2205 ret = av_buffersink_get_frame_flags(filt_out, frame, 0);
2207 if (ret == AVERROR_EOF)
2208 is->viddec.finished = is->viddec.pkt_serial;
2213 is->frame_last_filter_delay = av_gettime_relative() / 1000000.0 - is->frame_last_returned_time;
2214 if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
2215 is->frame_last_filter_delay = 0;
2216 tb = av_buffersink_get_time_base(filt_out);
2218 duration = (frame_rate.num && frame_rate.den ? av_q2d((AVRational){frame_rate.den, frame_rate.num}) : 0);
2219 pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2220 ret = queue_picture(is, frame, pts, duration, frame->pkt_pos, is->viddec.pkt_serial);
2221 av_frame_unref(frame);
2223 if (is->videoq.serial != is->viddec.pkt_serial)
2233 avfilter_graph_free(&graph);
2235 av_frame_free(&frame);
2239 static int subtitle_thread(void *arg)
2241 VideoState *is = arg;
2247 if (!(sp = frame_queue_peek_writable(&is->subpq)))
2250 if ((got_subtitle = decoder_decode_frame(&is->subdec, NULL, &sp->sub)) < 0)
2255 if (got_subtitle && sp->sub.format == 0) {
2256 if (sp->sub.pts != AV_NOPTS_VALUE)
2257 pts = sp->sub.pts / (double)AV_TIME_BASE;
2259 sp->serial = is->subdec.pkt_serial;
2260 sp->width = is->subdec.avctx->width;
2261 sp->height = is->subdec.avctx->height;
2264 /* now we can update the picture count */
2265 frame_queue_push(&is->subpq);
2266 } else if (got_subtitle) {
2267 avsubtitle_free(&sp->sub);
2273 /* copy samples for viewing in editor window */
2274 static void update_sample_display(VideoState *is, short *samples, int samples_size)
2278 size = samples_size / sizeof(short);
2280 len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
2283 memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
2285 is->sample_array_index += len;
2286 if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
2287 is->sample_array_index = 0;
2292 /* return the wanted number of samples to get better sync if sync_type is video
2293 * or external master clock */
2294 static int synchronize_audio(VideoState *is, int nb_samples)
2296 int wanted_nb_samples = nb_samples;
2298 /* if not master, then we try to remove or add samples to correct the clock */
2299 if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
2300 double diff, avg_diff;
2301 int min_nb_samples, max_nb_samples;
2303 diff = get_clock(&is->audclk) - get_master_clock(is);
2305 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD) {
2306 is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
2307 if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
2308 /* not enough measures to have a correct estimate */
2309 is->audio_diff_avg_count++;
2311 /* estimate the A-V difference */
2312 avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
2314 if (fabs(avg_diff) >= is->audio_diff_threshold) {
2315 wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);
2316 min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2317 max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2318 wanted_nb_samples = av_clip(wanted_nb_samples, min_nb_samples, max_nb_samples);
2320 av_log(NULL, AV_LOG_TRACE, "diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
2321 diff, avg_diff, wanted_nb_samples - nb_samples,
2322 is->audio_clock, is->audio_diff_threshold);
2325 /* too big difference : may be initial PTS errors, so
2327 is->audio_diff_avg_count = 0;
2328 is->audio_diff_cum = 0;
2332 return wanted_nb_samples;
2336 * Decode one audio frame and return its uncompressed size.
2338 * The processed audio frame is decoded, converted if required, and
2339 * stored in is->audio_buf, with size in bytes given by the return
2342 static int audio_decode_frame(VideoState *is)
2344 int data_size, resampled_data_size;
2345 int64_t dec_channel_layout;
2346 av_unused double audio_clock0;
2347 int wanted_nb_samples;
2355 while (frame_queue_nb_remaining(&is->sampq) == 0) {
2356 if ((av_gettime_relative() - audio_callback_time) > 1000000LL * is->audio_hw_buf_size / is->audio_tgt.bytes_per_sec / 2)
2361 if (!(af = frame_queue_peek_readable(&is->sampq)))
2363 frame_queue_next(&is->sampq);
2364 } while (af->serial != is->audioq.serial);
2366 data_size = av_samples_get_buffer_size(NULL, af->frame->channels,
2367 af->frame->nb_samples,
2368 af->frame->format, 1);
2370 dec_channel_layout =
2371 (af->frame->channel_layout && af->frame->channels == av_get_channel_layout_nb_channels(af->frame->channel_layout)) ?
2372 af->frame->channel_layout : av_get_default_channel_layout(af->frame->channels);
2373 wanted_nb_samples = synchronize_audio(is, af->frame->nb_samples);
2375 if (af->frame->format != is->audio_src.fmt ||
2376 dec_channel_layout != is->audio_src.channel_layout ||
2377 af->frame->sample_rate != is->audio_src.freq ||
2378 (wanted_nb_samples != af->frame->nb_samples && !is->swr_ctx)) {
2379 swr_free(&is->swr_ctx);
2380 is->swr_ctx = swr_alloc_set_opts(NULL,
2381 is->audio_tgt.channel_layout, is->audio_tgt.fmt, is->audio_tgt.freq,
2382 dec_channel_layout, af->frame->format, af->frame->sample_rate,
2384 if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
2385 av_log(NULL, AV_LOG_ERROR,
2386 "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
2387 af->frame->sample_rate, av_get_sample_fmt_name(af->frame->format), af->frame->channels,
2388 is->audio_tgt.freq, av_get_sample_fmt_name(is->audio_tgt.fmt), is->audio_tgt.channels);
2389 swr_free(&is->swr_ctx);
2392 is->audio_src.channel_layout = dec_channel_layout;
2393 is->audio_src.channels = af->frame->channels;
2394 is->audio_src.freq = af->frame->sample_rate;
2395 is->audio_src.fmt = af->frame->format;
2399 const uint8_t **in = (const uint8_t **)af->frame->extended_data;
2400 uint8_t **out = &is->audio_buf1;
2401 int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate + 256;
2402 int out_size = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, out_count, is->audio_tgt.fmt, 0);
2405 av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size() failed\n");
2408 if (wanted_nb_samples != af->frame->nb_samples) {
2409 if (swr_set_compensation(is->swr_ctx, (wanted_nb_samples - af->frame->nb_samples) * is->audio_tgt.freq / af->frame->sample_rate,
2410 wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate) < 0) {
2411 av_log(NULL, AV_LOG_ERROR, "swr_set_compensation() failed\n");
2415 av_fast_malloc(&is->audio_buf1, &is->audio_buf1_size, out_size);
2416 if (!is->audio_buf1)
2417 return AVERROR(ENOMEM);
2418 len2 = swr_convert(is->swr_ctx, out, out_count, in, af->frame->nb_samples);
2420 av_log(NULL, AV_LOG_ERROR, "swr_convert() failed\n");
2423 if (len2 == out_count) {
2424 av_log(NULL, AV_LOG_WARNING, "audio buffer is probably too small\n");
2425 if (swr_init(is->swr_ctx) < 0)
2426 swr_free(&is->swr_ctx);
2428 is->audio_buf = is->audio_buf1;
2429 resampled_data_size = len2 * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2431 is->audio_buf = af->frame->data[0];
2432 resampled_data_size = data_size;
2435 audio_clock0 = is->audio_clock;
2436 /* update the audio clock with the pts */
2437 if (!isnan(af->pts))
2438 is->audio_clock = af->pts + (double) af->frame->nb_samples / af->frame->sample_rate;
2440 is->audio_clock = NAN;
2441 is->audio_clock_serial = af->serial;
2444 static double last_clock;
2445 printf("audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
2446 is->audio_clock - last_clock,
2447 is->audio_clock, audio_clock0);
2448 last_clock = is->audio_clock;
2451 return resampled_data_size;
2454 /* prepare a new audio buffer */
2455 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
2457 VideoState *is = opaque;
2458 int audio_size, len1;
2460 audio_callback_time = av_gettime_relative();
2463 if (is->audio_buf_index >= is->audio_buf_size) {
2464 audio_size = audio_decode_frame(is);
2465 if (audio_size < 0) {
2466 /* if error, just output silence */
2467 is->audio_buf = NULL;
2468 is->audio_buf_size = SDL_AUDIO_MIN_BUFFER_SIZE / is->audio_tgt.frame_size * is->audio_tgt.frame_size;
2470 if (is->show_mode != SHOW_MODE_VIDEO)
2471 update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
2472 is->audio_buf_size = audio_size;
2474 is->audio_buf_index = 0;
2476 len1 = is->audio_buf_size - is->audio_buf_index;
2479 if (!is->muted && is->audio_buf && is->audio_volume == SDL_MIX_MAXVOLUME)
2480 memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
2482 memset(stream, 0, len1);
2483 if (!is->muted && is->audio_buf)
2484 SDL_MixAudioFormat(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, AUDIO_S16SYS, len1, is->audio_volume);
2488 is->audio_buf_index += len1;
2490 is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
2491 /* Let's assume the audio driver that is used by SDL has two periods. */
2492 if (!isnan(is->audio_clock)) {
2493 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);
2494 sync_clock_to_slave(&is->extclk, &is->audclk);
2498 static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
2500 SDL_AudioSpec wanted_spec, spec;
2502 static const int next_nb_channels[] = {0, 0, 1, 6, 2, 6, 4, 6};
2503 static const int next_sample_rates[] = {0, 44100, 48000, 96000, 192000};
2504 int next_sample_rate_idx = FF_ARRAY_ELEMS(next_sample_rates) - 1;
2506 env = SDL_getenv("SDL_AUDIO_CHANNELS");
2508 wanted_nb_channels = atoi(env);
2509 wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2511 if (!wanted_channel_layout || wanted_nb_channels != av_get_channel_layout_nb_channels(wanted_channel_layout)) {
2512 wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2513 wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
2515 wanted_nb_channels = av_get_channel_layout_nb_channels(wanted_channel_layout);
2516 wanted_spec.channels = wanted_nb_channels;
2517 wanted_spec.freq = wanted_sample_rate;
2518 if (wanted_spec.freq <= 0 || wanted_spec.channels <= 0) {
2519 av_log(NULL, AV_LOG_ERROR, "Invalid sample rate or channel count!\n");
2522 while (next_sample_rate_idx && next_sample_rates[next_sample_rate_idx] >= wanted_spec.freq)
2523 next_sample_rate_idx--;
2524 wanted_spec.format = AUDIO_S16SYS;
2525 wanted_spec.silence = 0;
2526 wanted_spec.samples = FFMAX(SDL_AUDIO_MIN_BUFFER_SIZE, 2 << av_log2(wanted_spec.freq / SDL_AUDIO_MAX_CALLBACKS_PER_SEC));
2527 wanted_spec.callback = sdl_audio_callback;
2528 wanted_spec.userdata = opaque;
2529 while (!(audio_dev = SDL_OpenAudioDevice(NULL, 0, &wanted_spec, &spec, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE | SDL_AUDIO_ALLOW_CHANNELS_CHANGE))) {
2530 av_log(NULL, AV_LOG_WARNING, "SDL_OpenAudio (%d channels, %d Hz): %s\n",
2531 wanted_spec.channels, wanted_spec.freq, SDL_GetError());
2532 wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
2533 if (!wanted_spec.channels) {
2534 wanted_spec.freq = next_sample_rates[next_sample_rate_idx--];
2535 wanted_spec.channels = wanted_nb_channels;
2536 if (!wanted_spec.freq) {
2537 av_log(NULL, AV_LOG_ERROR,
2538 "No more combinations to try, audio open failed\n");
2542 wanted_channel_layout = av_get_default_channel_layout(wanted_spec.channels);
2544 if (spec.format != AUDIO_S16SYS) {
2545 av_log(NULL, AV_LOG_ERROR,
2546 "SDL advised audio format %d is not supported!\n", spec.format);
2549 if (spec.channels != wanted_spec.channels) {
2550 wanted_channel_layout = av_get_default_channel_layout(spec.channels);
2551 if (!wanted_channel_layout) {
2552 av_log(NULL, AV_LOG_ERROR,
2553 "SDL advised channel count %d is not supported!\n", spec.channels);
2558 audio_hw_params->fmt = AV_SAMPLE_FMT_S16;
2559 audio_hw_params->freq = spec.freq;
2560 audio_hw_params->channel_layout = wanted_channel_layout;
2561 audio_hw_params->channels = spec.channels;
2562 audio_hw_params->frame_size = av_samples_get_buffer_size(NULL, audio_hw_params->channels, 1, audio_hw_params->fmt, 1);
2563 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);
2564 if (audio_hw_params->bytes_per_sec <= 0 || audio_hw_params->frame_size <= 0) {
2565 av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size failed\n");
2571 /* open a given stream. Return 0 if OK */
2572 static int stream_component_open(VideoState *is, int stream_index)
2574 AVFormatContext *ic = is->ic;
2575 AVCodecContext *avctx;
2577 const char *forced_codec_name = NULL;
2578 AVDictionary *opts = NULL;
2579 AVDictionaryEntry *t = NULL;
2580 int sample_rate, nb_channels;
2581 int64_t channel_layout;
2583 int stream_lowres = lowres;
2585 if (stream_index < 0 || stream_index >= ic->nb_streams)
2588 avctx = avcodec_alloc_context3(NULL);
2590 return AVERROR(ENOMEM);
2592 ret = avcodec_parameters_to_context(avctx, ic->streams[stream_index]->codecpar);
2595 avctx->pkt_timebase = ic->streams[stream_index]->time_base;
2597 codec = avcodec_find_decoder(avctx->codec_id);
2599 switch(avctx->codec_type){
2600 case AVMEDIA_TYPE_AUDIO : is->last_audio_stream = stream_index; forced_codec_name = audio_codec_name; break;
2601 case AVMEDIA_TYPE_SUBTITLE: is->last_subtitle_stream = stream_index; forced_codec_name = subtitle_codec_name; break;
2602 case AVMEDIA_TYPE_VIDEO : is->last_video_stream = stream_index; forced_codec_name = video_codec_name; break;
2604 if (forced_codec_name)
2605 codec = avcodec_find_decoder_by_name(forced_codec_name);
2607 if (forced_codec_name) av_log(NULL, AV_LOG_WARNING,
2608 "No codec could be found with name '%s'\n", forced_codec_name);
2609 else av_log(NULL, AV_LOG_WARNING,
2610 "No decoder could be found for codec %s\n", avcodec_get_name(avctx->codec_id));
2611 ret = AVERROR(EINVAL);
2615 avctx->codec_id = codec->id;
2616 if (stream_lowres > codec->max_lowres) {
2617 av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2619 stream_lowres = codec->max_lowres;
2621 avctx->lowres = stream_lowres;
2624 avctx->flags2 |= AV_CODEC_FLAG2_FAST;
2626 opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
2627 if (!av_dict_get(opts, "threads", NULL, 0))
2628 av_dict_set(&opts, "threads", "auto", 0);
2630 av_dict_set_int(&opts, "lowres", stream_lowres, 0);
2631 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
2632 av_dict_set(&opts, "refcounted_frames", "1", 0);
2633 if ((ret = avcodec_open2(avctx, codec, &opts)) < 0) {
2636 if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2637 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2638 ret = AVERROR_OPTION_NOT_FOUND;
2643 ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
2644 switch (avctx->codec_type) {
2645 case AVMEDIA_TYPE_AUDIO:
2648 AVFilterContext *sink;
2650 is->audio_filter_src.freq = avctx->sample_rate;
2651 is->audio_filter_src.channels = avctx->channels;
2652 is->audio_filter_src.channel_layout = get_valid_channel_layout(avctx->channel_layout, avctx->channels);
2653 is->audio_filter_src.fmt = avctx->sample_fmt;
2654 if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
2656 sink = is->out_audio_filter;
2657 sample_rate = av_buffersink_get_sample_rate(sink);
2658 nb_channels = av_buffersink_get_channels(sink);
2659 channel_layout = av_buffersink_get_channel_layout(sink);
2662 sample_rate = avctx->sample_rate;
2663 nb_channels = avctx->channels;
2664 channel_layout = avctx->channel_layout;
2667 /* prepare audio output */
2668 if ((ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)) < 0)
2670 is->audio_hw_buf_size = ret;
2671 is->audio_src = is->audio_tgt;
2672 is->audio_buf_size = 0;
2673 is->audio_buf_index = 0;
2675 /* init averaging filter */
2676 is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
2677 is->audio_diff_avg_count = 0;
2678 /* since we do not have a precise anough audio FIFO fullness,
2679 we correct audio sync only if larger than this threshold */
2680 is->audio_diff_threshold = (double)(is->audio_hw_buf_size) / is->audio_tgt.bytes_per_sec;
2682 is->audio_stream = stream_index;
2683 is->audio_st = ic->streams[stream_index];
2685 if ((ret = decoder_init(&is->auddec, avctx, &is->audioq, is->continue_read_thread)) < 0)
2687 if ((is->ic->iformat->flags & (AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH | AVFMT_NO_BYTE_SEEK)) && !is->ic->iformat->read_seek) {
2688 is->auddec.start_pts = is->audio_st->start_time;
2689 is->auddec.start_pts_tb = is->audio_st->time_base;
2691 if ((ret = decoder_start(&is->auddec, audio_thread, "audio_decoder", is)) < 0)
2693 SDL_PauseAudioDevice(audio_dev, 0);
2695 case AVMEDIA_TYPE_VIDEO:
2696 is->video_stream = stream_index;
2697 is->video_st = ic->streams[stream_index];
2699 if ((ret = decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread)) < 0)
2701 if ((ret = decoder_start(&is->viddec, video_thread, "video_decoder", is)) < 0)
2703 is->queue_attachments_req = 1;
2705 case AVMEDIA_TYPE_SUBTITLE:
2706 is->subtitle_stream = stream_index;
2707 is->subtitle_st = ic->streams[stream_index];
2709 if ((ret = decoder_init(&is->subdec, avctx, &is->subtitleq, is->continue_read_thread)) < 0)
2711 if ((ret = decoder_start(&is->subdec, subtitle_thread, "subtitle_decoder", is)) < 0)
2720 avcodec_free_context(&avctx);
2722 av_dict_free(&opts);
2727 static int decode_interrupt_cb(void *ctx)
2729 VideoState *is = ctx;
2730 return is->abort_request;
2733 static int stream_has_enough_packets(AVStream *st, int stream_id, PacketQueue *queue) {
2734 return stream_id < 0 ||
2735 queue->abort_request ||
2736 (st->disposition & AV_DISPOSITION_ATTACHED_PIC) ||
2737 queue->nb_packets > MIN_FRAMES && (!queue->duration || av_q2d(st->time_base) * queue->duration > 1.0);
2740 static int is_realtime(AVFormatContext *s)
2742 if( !strcmp(s->iformat->name, "rtp")
2743 || !strcmp(s->iformat->name, "rtsp")
2744 || !strcmp(s->iformat->name, "sdp")
2748 if(s->pb && ( !strncmp(s->url, "rtp:", 4)
2749 || !strncmp(s->url, "udp:", 4)
2756 /* this thread gets the stream from the disk or the network */
2757 static int read_thread(void *arg)
2759 VideoState *is = arg;
2760 AVFormatContext *ic = NULL;
2762 int st_index[AVMEDIA_TYPE_NB];
2763 AVPacket *pkt = NULL;
2764 int64_t stream_start_time;
2765 int pkt_in_play_range = 0;
2766 AVDictionaryEntry *t;
2767 SDL_mutex *wait_mutex = SDL_CreateMutex();
2768 int scan_all_pmts_set = 0;
2772 av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
2773 ret = AVERROR(ENOMEM);
2777 memset(st_index, -1, sizeof(st_index));
2780 pkt = av_packet_alloc();
2782 av_log(NULL, AV_LOG_FATAL, "Could not allocate packet.\n");
2783 ret = AVERROR(ENOMEM);
2786 ic = avformat_alloc_context();
2788 av_log(NULL, AV_LOG_FATAL, "Could not allocate context.\n");
2789 ret = AVERROR(ENOMEM);
2792 ic->interrupt_callback.callback = decode_interrupt_cb;
2793 ic->interrupt_callback.opaque = is;
2794 if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
2795 av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
2796 scan_all_pmts_set = 1;
2798 err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
2800 print_error(is->filename, err);
2804 if (scan_all_pmts_set)
2805 av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
2807 if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2808 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2809 ret = AVERROR_OPTION_NOT_FOUND;
2815 ic->flags |= AVFMT_FLAG_GENPTS;
2817 av_format_inject_global_side_data(ic);
2819 if (find_stream_info) {
2820 AVDictionary **opts = setup_find_stream_info_opts(ic, codec_opts);
2821 int orig_nb_streams = ic->nb_streams;
2823 err = avformat_find_stream_info(ic, opts);
2825 for (i = 0; i < orig_nb_streams; i++)
2826 av_dict_free(&opts[i]);
2830 av_log(NULL, AV_LOG_WARNING,
2831 "%s: could not find codec parameters\n", is->filename);
2838 ic->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use avio_feof() to test for the end
2840 if (seek_by_bytes < 0)
2841 seek_by_bytes = !!(ic->iformat->flags & AVFMT_TS_DISCONT) && strcmp("ogg", ic->iformat->name);
2843 is->max_frame_duration = (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;
2845 if (!window_title && (t = av_dict_get(ic->metadata, "title", NULL, 0)))
2846 window_title = av_asprintf("%s - %s", t->value, input_filename);
2848 /* if seeking requested, we execute it */
2849 if (start_time != AV_NOPTS_VALUE) {
2852 timestamp = start_time;
2853 /* add the stream start time */
2854 if (ic->start_time != AV_NOPTS_VALUE)
2855 timestamp += ic->start_time;
2856 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
2858 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2859 is->filename, (double)timestamp / AV_TIME_BASE);
2863 is->realtime = is_realtime(ic);
2866 av_dump_format(ic, 0, is->filename, 0);
2868 for (i = 0; i < ic->nb_streams; i++) {
2869 AVStream *st = ic->streams[i];
2870 enum AVMediaType type = st->codecpar->codec_type;
2871 st->discard = AVDISCARD_ALL;
2872 if (type >= 0 && wanted_stream_spec[type] && st_index[type] == -1)
2873 if (avformat_match_stream_specifier(ic, st, wanted_stream_spec[type]) > 0)
2876 for (i = 0; i < AVMEDIA_TYPE_NB; i++) {
2877 if (wanted_stream_spec[i] && st_index[i] == -1) {
2878 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));
2879 st_index[i] = INT_MAX;
2884 st_index[AVMEDIA_TYPE_VIDEO] =
2885 av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
2886 st_index[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
2888 st_index[AVMEDIA_TYPE_AUDIO] =
2889 av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
2890 st_index[AVMEDIA_TYPE_AUDIO],
2891 st_index[AVMEDIA_TYPE_VIDEO],
2893 if (!video_disable && !subtitle_disable)
2894 st_index[AVMEDIA_TYPE_SUBTITLE] =
2895 av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
2896 st_index[AVMEDIA_TYPE_SUBTITLE],
2897 (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
2898 st_index[AVMEDIA_TYPE_AUDIO] :
2899 st_index[AVMEDIA_TYPE_VIDEO]),
2902 is->show_mode = show_mode;
2903 if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2904 AVStream *st = ic->streams[st_index[AVMEDIA_TYPE_VIDEO]];
2905 AVCodecParameters *codecpar = st->codecpar;
2906 AVRational sar = av_guess_sample_aspect_ratio(ic, st, NULL);
2907 if (codecpar->width)
2908 set_default_window_size(codecpar->width, codecpar->height, sar);
2911 /* open the streams */
2912 if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
2913 stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
2917 if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2918 ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
2920 if (is->show_mode == SHOW_MODE_NONE)
2921 is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
2923 if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
2924 stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
2927 if (is->video_stream < 0 && is->audio_stream < 0) {
2928 av_log(NULL, AV_LOG_FATAL, "Failed to open file '%s' or configure filtergraph\n",
2934 if (infinite_buffer < 0 && is->realtime)
2935 infinite_buffer = 1;
2938 if (is->abort_request)
2940 if (is->paused != is->last_paused) {
2941 is->last_paused = is->paused;
2943 is->read_pause_return = av_read_pause(ic);
2947 #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
2949 (!strcmp(ic->iformat->name, "rtsp") ||
2950 (ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
2951 /* wait 10 ms to avoid trying to get another packet */
2958 int64_t seek_target = is->seek_pos;
2959 int64_t seek_min = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
2960 int64_t seek_max = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
2961 // FIXME the +-2 is due to rounding being not done in the correct direction in generation
2962 // of the seek_pos/seek_rel variables
2964 ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
2966 av_log(NULL, AV_LOG_ERROR,
2967 "%s: error while seeking\n", is->ic->url);
2969 if (is->audio_stream >= 0)
2970 packet_queue_flush(&is->audioq);
2971 if (is->subtitle_stream >= 0)
2972 packet_queue_flush(&is->subtitleq);
2973 if (is->video_stream >= 0)
2974 packet_queue_flush(&is->videoq);
2975 if (is->seek_flags & AVSEEK_FLAG_BYTE) {
2976 set_clock(&is->extclk, NAN, 0);
2978 set_clock(&is->extclk, seek_target / (double)AV_TIME_BASE, 0);
2982 is->queue_attachments_req = 1;
2985 step_to_next_frame(is);
2987 if (is->queue_attachments_req) {
2988 if (is->video_st && is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC) {
2989 if ((ret = av_packet_ref(pkt, &is->video_st->attached_pic)) < 0)
2991 packet_queue_put(&is->videoq, pkt);
2992 packet_queue_put_nullpacket(&is->videoq, pkt, is->video_stream);
2994 is->queue_attachments_req = 0;
2997 /* if the queue are full, no need to read more */
2998 if (infinite_buffer<1 &&
2999 (is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
3000 || (stream_has_enough_packets(is->audio_st, is->audio_stream, &is->audioq) &&
3001 stream_has_enough_packets(is->video_st, is->video_stream, &is->videoq) &&
3002 stream_has_enough_packets(is->subtitle_st, is->subtitle_stream, &is->subtitleq)))) {
3004 SDL_LockMutex(wait_mutex);
3005 SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3006 SDL_UnlockMutex(wait_mutex);
3010 (!is->audio_st || (is->auddec.finished == is->audioq.serial && frame_queue_nb_remaining(&is->sampq) == 0)) &&
3011 (!is->video_st || (is->viddec.finished == is->videoq.serial && frame_queue_nb_remaining(&is->pictq) == 0))) {
3012 if (loop != 1 && (!loop || --loop)) {
3013 stream_seek(is, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
3014 } else if (autoexit) {
3019 ret = av_read_frame(ic, pkt);
3021 if ((ret == AVERROR_EOF || avio_feof(ic->pb)) && !is->eof) {
3022 if (is->video_stream >= 0)
3023 packet_queue_put_nullpacket(&is->videoq, pkt, is->video_stream);
3024 if (is->audio_stream >= 0)
3025 packet_queue_put_nullpacket(&is->audioq, pkt, is->audio_stream);
3026 if (is->subtitle_stream >= 0)
3027 packet_queue_put_nullpacket(&is->subtitleq, pkt, is->subtitle_stream);
3030 if (ic->pb && ic->pb->error) {
3036 SDL_LockMutex(wait_mutex);
3037 SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3038 SDL_UnlockMutex(wait_mutex);
3043 /* check if packet is in play range specified by user, then queue, otherwise discard */
3044 stream_start_time = ic->streams[pkt->stream_index]->start_time;
3045 pkt_ts = pkt->pts == AV_NOPTS_VALUE ? pkt->dts : pkt->pts;
3046 pkt_in_play_range = duration == AV_NOPTS_VALUE ||
3047 (pkt_ts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
3048 av_q2d(ic->streams[pkt->stream_index]->time_base) -
3049 (double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
3050 <= ((double)duration / 1000000);
3051 if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
3052 packet_queue_put(&is->audioq, pkt);
3053 } else if (pkt->stream_index == is->video_stream && pkt_in_play_range
3054 && !(is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
3055 packet_queue_put(&is->videoq, pkt);
3056 } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
3057 packet_queue_put(&is->subtitleq, pkt);
3059 av_packet_unref(pkt);
3066 avformat_close_input(&ic);
3068 av_packet_free(&pkt);
3072 event.type = FF_QUIT_EVENT;
3073 event.user.data1 = is;
3074 SDL_PushEvent(&event);
3076 SDL_DestroyMutex(wait_mutex);
3080 static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
3084 is = av_mallocz(sizeof(VideoState));
3087 is->last_video_stream = is->video_stream = -1;
3088 is->last_audio_stream = is->audio_stream = -1;
3089 is->last_subtitle_stream = is->subtitle_stream = -1;
3090 is->filename = av_strdup(filename);
3093 is->iformat = iformat;
3097 /* start video display */
3098 if (frame_queue_init(&is->pictq, &is->videoq, VIDEO_PICTURE_QUEUE_SIZE, 1) < 0)
3100 if (frame_queue_init(&is->subpq, &is->subtitleq, SUBPICTURE_QUEUE_SIZE, 0) < 0)
3102 if (frame_queue_init(&is->sampq, &is->audioq, SAMPLE_QUEUE_SIZE, 1) < 0)
3105 if (packet_queue_init(&is->videoq) < 0 ||
3106 packet_queue_init(&is->audioq) < 0 ||
3107 packet_queue_init(&is->subtitleq) < 0)
3110 if (!(is->continue_read_thread = SDL_CreateCond())) {
3111 av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
3115 init_clock(&is->vidclk, &is->videoq.serial);
3116 init_clock(&is->audclk, &is->audioq.serial);
3117 init_clock(&is->extclk, &is->extclk.serial);
3118 is->audio_clock_serial = -1;
3119 if (startup_volume < 0)
3120 av_log(NULL, AV_LOG_WARNING, "-volume=%d < 0, setting to 0\n", startup_volume);
3121 if (startup_volume > 100)
3122 av_log(NULL, AV_LOG_WARNING, "-volume=%d > 100, setting to 100\n", startup_volume);
3123 startup_volume = av_clip(startup_volume, 0, 100);
3124 startup_volume = av_clip(SDL_MIX_MAXVOLUME * startup_volume / 100, 0, SDL_MIX_MAXVOLUME);
3125 is->audio_volume = startup_volume;
3127 is->av_sync_type = av_sync_type;
3128 is->read_tid = SDL_CreateThread(read_thread, "read_thread", is);
3129 if (!is->read_tid) {
3130 av_log(NULL, AV_LOG_FATAL, "SDL_CreateThread(): %s\n", SDL_GetError());
3138 static void stream_cycle_channel(VideoState *is, int codec_type)
3140 AVFormatContext *ic = is->ic;
3141 int start_index, stream_index;
3144 AVProgram *p = NULL;
3145 int nb_streams = is->ic->nb_streams;
3147 if (codec_type == AVMEDIA_TYPE_VIDEO) {
3148 start_index = is->last_video_stream;
3149 old_index = is->video_stream;
3150 } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
3151 start_index = is->last_audio_stream;
3152 old_index = is->audio_stream;
3154 start_index = is->last_subtitle_stream;
3155 old_index = is->subtitle_stream;
3157 stream_index = start_index;
3159 if (codec_type != AVMEDIA_TYPE_VIDEO && is->video_stream != -1) {
3160 p = av_find_program_from_stream(ic, NULL, is->video_stream);
3162 nb_streams = p->nb_stream_indexes;
3163 for (start_index = 0; start_index < nb_streams; start_index++)
3164 if (p->stream_index[start_index] == stream_index)
3166 if (start_index == nb_streams)
3168 stream_index = start_index;
3173 if (++stream_index >= nb_streams)
3175 if (codec_type == AVMEDIA_TYPE_SUBTITLE)
3178 is->last_subtitle_stream = -1;
3181 if (start_index == -1)
3185 if (stream_index == start_index)
3187 st = is->ic->streams[p ? p->stream_index[stream_index] : stream_index];
3188 if (st->codecpar->codec_type == codec_type) {
3189 /* check that parameters are OK */
3190 switch (codec_type) {
3191 case AVMEDIA_TYPE_AUDIO:
3192 if (st->codecpar->sample_rate != 0 &&
3193 st->codecpar->channels != 0)
3196 case AVMEDIA_TYPE_VIDEO:
3197 case AVMEDIA_TYPE_SUBTITLE:
3205 if (p && stream_index != -1)
3206 stream_index = p->stream_index[stream_index];
3207 av_log(NULL, AV_LOG_INFO, "Switch %s stream from #%d to #%d\n",
3208 av_get_media_type_string(codec_type),
3212 stream_component_close(is, old_index);
3213 stream_component_open(is, stream_index);
3217 static void toggle_full_screen(VideoState *is)
3219 is_full_screen = !is_full_screen;
3220 SDL_SetWindowFullscreen(window, is_full_screen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
3223 static void toggle_audio_display(VideoState *is)
3225 int next = is->show_mode;
3227 next = (next + 1) % SHOW_MODE_NB;
3228 } while (next != is->show_mode && (next == SHOW_MODE_VIDEO && !is->video_st || next != SHOW_MODE_VIDEO && !is->audio_st));
3229 if (is->show_mode != next) {
3230 is->force_refresh = 1;
3231 is->show_mode = next;
3235 static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
3236 double remaining_time = 0.0;
3238 while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) {
3239 if (!cursor_hidden && av_gettime_relative() - cursor_last_shown > CURSOR_HIDE_DELAY) {
3243 if (remaining_time > 0.0)
3244 av_usleep((int64_t)(remaining_time * 1000000.0));
3245 remaining_time = REFRESH_RATE;
3246 if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
3247 video_refresh(is, &remaining_time);
3252 static void seek_chapter(VideoState *is, int incr)
3254 int64_t pos = get_master_clock(is) * AV_TIME_BASE;
3257 if (!is->ic->nb_chapters)
3260 /* find the current chapter */
3261 for (i = 0; i < is->ic->nb_chapters; i++) {
3262 AVChapter *ch = is->ic->chapters[i];
3263 if (av_compare_ts(pos, AV_TIME_BASE_Q, ch->start, ch->time_base) < 0) {
3271 if (i >= is->ic->nb_chapters)
3274 av_log(NULL, AV_LOG_VERBOSE, "Seeking to chapter %d.\n", i);
3275 stream_seek(is, av_rescale_q(is->ic->chapters[i]->start, is->ic->chapters[i]->time_base,
3276 AV_TIME_BASE_Q), 0, 0);
3279 /* handle an event sent by the GUI */
3280 static void event_loop(VideoState *cur_stream)
3283 double incr, pos, frac;
3287 refresh_loop_wait_event(cur_stream, &event);
3288 switch (event.type) {
3290 if (exit_on_keydown || event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_q) {
3291 do_exit(cur_stream);
3294 // If we don't yet have a window, skip all key events, because read_thread might still be initializing...
3295 if (!cur_stream->width)
3297 switch (event.key.keysym.sym) {
3299 toggle_full_screen(cur_stream);
3300 cur_stream->force_refresh = 1;
3304 toggle_pause(cur_stream);
3307 toggle_mute(cur_stream);
3309 case SDLK_KP_MULTIPLY:
3311 update_volume(cur_stream, 1, SDL_VOLUME_STEP);
3313 case SDLK_KP_DIVIDE:
3315 update_volume(cur_stream, -1, SDL_VOLUME_STEP);
3317 case SDLK_s: // S: Step to next frame
3318 step_to_next_frame(cur_stream);
3321 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3324 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3327 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3328 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3329 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3332 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3336 if (cur_stream->show_mode == SHOW_MODE_VIDEO && cur_stream->vfilter_idx < nb_vfilters - 1) {
3337 if (++cur_stream->vfilter_idx >= nb_vfilters)
3338 cur_stream->vfilter_idx = 0;
3340 cur_stream->vfilter_idx = 0;
3341 toggle_audio_display(cur_stream);
3344 toggle_audio_display(cur_stream);
3348 if (cur_stream->ic->nb_chapters <= 1) {
3352 seek_chapter(cur_stream, 1);
3355 if (cur_stream->ic->nb_chapters <= 1) {
3359 seek_chapter(cur_stream, -1);
3362 incr = seek_interval ? -seek_interval : -10.0;
3365 incr = seek_interval ? seek_interval : 10.0;
3373 if (seek_by_bytes) {
3375 if (pos < 0 && cur_stream->video_stream >= 0)
3376 pos = frame_queue_last_pos(&cur_stream->pictq);
3377 if (pos < 0 && cur_stream->audio_stream >= 0)
3378 pos = frame_queue_last_pos(&cur_stream->sampq);
3380 pos = avio_tell(cur_stream->ic->pb);
3381 if (cur_stream->ic->bit_rate)
3382 incr *= cur_stream->ic->bit_rate / 8.0;
3386 stream_seek(cur_stream, pos, incr, 1);
3388 pos = get_master_clock(cur_stream);
3390 pos = (double)cur_stream->seek_pos / AV_TIME_BASE;
3392 if (cur_stream->ic->start_time != AV_NOPTS_VALUE && pos < cur_stream->ic->start_time / (double)AV_TIME_BASE)
3393 pos = cur_stream->ic->start_time / (double)AV_TIME_BASE;
3394 stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE), 0);
3401 case SDL_MOUSEBUTTONDOWN:
3402 if (exit_on_mousedown) {
3403 do_exit(cur_stream);
3406 if (event.button.button == SDL_BUTTON_LEFT) {
3407 static int64_t last_mouse_left_click = 0;
3408 if (av_gettime_relative() - last_mouse_left_click <= 500000) {
3409 toggle_full_screen(cur_stream);
3410 cur_stream->force_refresh = 1;
3411 last_mouse_left_click = 0;
3413 last_mouse_left_click = av_gettime_relative();
3416 case SDL_MOUSEMOTION:
3417 if (cursor_hidden) {
3421 cursor_last_shown = av_gettime_relative();
3422 if (event.type == SDL_MOUSEBUTTONDOWN) {
3423 if (event.button.button != SDL_BUTTON_RIGHT)
3427 if (!(event.motion.state & SDL_BUTTON_RMASK))
3431 if (seek_by_bytes || cur_stream->ic->duration <= 0) {
3432 uint64_t size = avio_size(cur_stream->ic->pb);
3433 stream_seek(cur_stream, size*x/cur_stream->width, 0, 1);
3437 int tns, thh, tmm, tss;
3438 tns = cur_stream->ic->duration / 1000000LL;
3440 tmm = (tns % 3600) / 60;
3442 frac = x / cur_stream->width;
3445 mm = (ns % 3600) / 60;
3447 av_log(NULL, AV_LOG_INFO,
3448 "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d) \n", frac*100,
3449 hh, mm, ss, thh, tmm, tss);
3450 ts = frac * cur_stream->ic->duration;
3451 if (cur_stream->ic->start_time != AV_NOPTS_VALUE)
3452 ts += cur_stream->ic->start_time;
3453 stream_seek(cur_stream, ts, 0, 0);
3456 case SDL_WINDOWEVENT:
3457 switch (event.window.event) {
3458 case SDL_WINDOWEVENT_SIZE_CHANGED:
3459 screen_width = cur_stream->width = event.window.data1;
3460 screen_height = cur_stream->height = event.window.data2;
3461 if (cur_stream->vis_texture) {
3462 SDL_DestroyTexture(cur_stream->vis_texture);
3463 cur_stream->vis_texture = NULL;
3465 case SDL_WINDOWEVENT_EXPOSED:
3466 cur_stream->force_refresh = 1;
3471 do_exit(cur_stream);
3479 static int opt_frame_size(void *optctx, const char *opt, const char *arg)
3481 av_log(NULL, AV_LOG_WARNING, "Option -s is deprecated, use -video_size.\n");
3482 return opt_default(NULL, "video_size", arg);
3485 static int opt_width(void *optctx, const char *opt, const char *arg)
3487 screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3491 static int opt_height(void *optctx, const char *opt, const char *arg)
3493 screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3497 static int opt_format(void *optctx, const char *opt, const char *arg)
3499 file_iformat = av_find_input_format(arg);
3500 if (!file_iformat) {
3501 av_log(NULL, AV_LOG_FATAL, "Unknown input format: %s\n", arg);
3502 return AVERROR(EINVAL);
3507 static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
3509 av_log(NULL, AV_LOG_WARNING, "Option -pix_fmt is deprecated, use -pixel_format.\n");
3510 return opt_default(NULL, "pixel_format", arg);
3513 static int opt_sync(void *optctx, const char *opt, const char *arg)
3515 if (!strcmp(arg, "audio"))
3516 av_sync_type = AV_SYNC_AUDIO_MASTER;
3517 else if (!strcmp(arg, "video"))
3518 av_sync_type = AV_SYNC_VIDEO_MASTER;
3519 else if (!strcmp(arg, "ext"))
3520 av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
3522 av_log(NULL, AV_LOG_ERROR, "Unknown value for %s: %s\n", opt, arg);
3528 static int opt_seek(void *optctx, const char *opt, const char *arg)
3530 start_time = parse_time_or_die(opt, arg, 1);
3534 static int opt_duration(void *optctx, const char *opt, const char *arg)
3536 duration = parse_time_or_die(opt, arg, 1);
3540 static int opt_show_mode(void *optctx, const char *opt, const char *arg)
3542 show_mode = !strcmp(arg, "video") ? SHOW_MODE_VIDEO :
3543 !strcmp(arg, "waves") ? SHOW_MODE_WAVES :
3544 !strcmp(arg, "rdft" ) ? SHOW_MODE_RDFT :
3545 parse_number_or_die(opt, arg, OPT_INT, 0, SHOW_MODE_NB-1);
3549 static void opt_input_file(void *optctx, const char *filename)
3551 if (input_filename) {
3552 av_log(NULL, AV_LOG_FATAL,
3553 "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3554 filename, input_filename);
3557 if (!strcmp(filename, "-"))
3559 input_filename = filename;
3562 static int opt_codec(void *optctx, const char *opt, const char *arg)
3564 const char *spec = strchr(opt, ':');
3566 av_log(NULL, AV_LOG_ERROR,
3567 "No media specifier was specified in '%s' in option '%s'\n",
3569 return AVERROR(EINVAL);
3573 case 'a' : audio_codec_name = arg; break;
3574 case 's' : subtitle_codec_name = arg; break;
3575 case 'v' : video_codec_name = arg; break;
3577 av_log(NULL, AV_LOG_ERROR,
3578 "Invalid media specifier '%s' in option '%s'\n", spec, opt);
3579 return AVERROR(EINVAL);
3586 static const OptionDef options[] = {
3587 CMDUTILS_COMMON_OPTIONS
3588 { "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
3589 { "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
3590 { "s", HAS_ARG | OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
3591 { "fs", OPT_BOOL, { &is_full_screen }, "force full screen" },
3592 { "an", OPT_BOOL, { &audio_disable }, "disable audio" },
3593 { "vn", OPT_BOOL, { &video_disable }, "disable video" },
3594 { "sn", OPT_BOOL, { &subtitle_disable }, "disable subtitling" },
3595 { "ast", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_specifier" },
3596 { "vst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_specifier" },
3597 { "sst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_specifier" },
3598 { "ss", HAS_ARG, { .func_arg = opt_seek }, "seek to a given position in seconds", "pos" },
3599 { "t", HAS_ARG, { .func_arg = opt_duration }, "play \"duration\" seconds of audio/video", "duration" },
3600 { "bytes", OPT_INT | HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
3601 { "seek_interval", OPT_FLOAT | HAS_ARG, { &seek_interval }, "set seek interval for left/right keys, in seconds", "seconds" },
3602 { "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
3603 { "noborder", OPT_BOOL, { &borderless }, "borderless window" },
3604 { "alwaysontop", OPT_BOOL, { &alwaysontop }, "window always on top" },
3605 { "volume", OPT_INT | HAS_ARG, { &startup_volume}, "set startup volume 0=min 100=max", "volume" },
3606 { "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
3607 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
3608 { "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" },
3609 { "fast", OPT_BOOL | OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
3610 { "genpts", OPT_BOOL | OPT_EXPERT, { &genpts }, "generate pts", "" },
3611 { "drp", OPT_INT | HAS_ARG | OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
3612 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, { &lowres }, "", "" },
3613 { "sync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
3614 { "autoexit", OPT_BOOL | OPT_EXPERT, { &autoexit }, "exit at the end", "" },
3615 { "exitonkeydown", OPT_BOOL | OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
3616 { "exitonmousedown", OPT_BOOL | OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
3617 { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
3618 { "framedrop", OPT_BOOL | OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
3619 { "infbuf", OPT_BOOL | OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
3620 { "window_title", OPT_STRING | HAS_ARG, { &window_title }, "set window title", "window title" },
3621 { "left", OPT_INT | HAS_ARG | OPT_EXPERT, { &screen_left }, "set the x position for the left of the window", "x pos" },
3622 { "top", OPT_INT | HAS_ARG | OPT_EXPERT, { &screen_top }, "set the y position for the top of the window", "y pos" },
3624 { "vf", OPT_EXPERT | HAS_ARG, { .func_arg = opt_add_vfilter }, "set video filters", "filter_graph" },
3625 { "af", OPT_STRING | HAS_ARG, { &afilters }, "set audio filters", "filter_graph" },
3627 { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
3628 { "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
3629 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default }, "generic catch all option", "" },
3630 { "i", OPT_BOOL, { &dummy}, "read specified file", "input_file"},
3631 { "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
3632 { "acodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &audio_codec_name }, "force audio decoder", "decoder_name" },
3633 { "scodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
3634 { "vcodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &video_codec_name }, "force video decoder", "decoder_name" },
3635 { "autorotate", OPT_BOOL, { &autorotate }, "automatically rotate video", "" },
3636 { "find_stream_info", OPT_BOOL | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3637 "read and decode the streams to fill missing information with heuristics" },
3638 { "filter_threads", HAS_ARG | OPT_INT | OPT_EXPERT, { &filter_nbthreads }, "number of filter threads per graph" },
3642 static void show_usage(void)
3644 av_log(NULL, AV_LOG_INFO, "Simple media player\n");
3645 av_log(NULL, AV_LOG_INFO, "usage: %s [options] input_file\n", program_name);
3646 av_log(NULL, AV_LOG_INFO, "\n");
3649 void show_help_default(const char *opt, const char *arg)
3651 av_log_set_callback(log_callback_help);
3653 show_help_options(options, "Main options:", 0, OPT_EXPERT, 0);
3654 show_help_options(options, "Advanced options:", OPT_EXPERT, 0, 0);
3656 show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3657 show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3658 #if !CONFIG_AVFILTER
3659 show_help_children(sws_get_class(), AV_OPT_FLAG_ENCODING_PARAM);
3661 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
3663 printf("\nWhile playing:\n"
3665 "f toggle full screen\n"
3668 "9, 0 decrease and increase volume respectively\n"
3669 "/, * decrease and increase volume respectively\n"
3670 "a cycle audio channel in the current program\n"
3671 "v cycle video channel\n"
3672 "t cycle subtitle channel in the current program\n"
3674 "w cycle video filters or show modes\n"
3675 "s activate frame-step mode\n"
3676 "left/right seek backward/forward 10 seconds or to custom interval if -seek_interval is set\n"
3677 "down/up seek backward/forward 1 minute\n"
3678 "page down/page up seek backward/forward 10 minutes\n"
3679 "right mouse click seek to percentage in file corresponding to fraction of width\n"
3680 "left double-click toggle full screen\n"
3684 /* Called from the main */
3685 int main(int argc, char **argv)
3692 av_log_set_flags(AV_LOG_SKIP_REPEATED);
3693 parse_loglevel(argc, argv, options);
3695 /* register all codecs, demux and protocols */
3697 avdevice_register_all();
3699 avformat_network_init();
3703 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
3704 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
3706 show_banner(argc, argv, options);
3708 parse_options(NULL, argc, argv, options, opt_input_file);
3710 if (!input_filename) {
3712 av_log(NULL, AV_LOG_FATAL, "An input file must be specified\n");
3713 av_log(NULL, AV_LOG_FATAL,
3714 "Use -h to get full help or, even better, run 'man %s'\n", program_name);
3718 if (display_disable) {
3721 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
3723 flags &= ~SDL_INIT_AUDIO;
3725 /* Try to work around an occasional ALSA buffer underflow issue when the
3726 * period size is NPOT due to ALSA resampling by forcing the buffer size. */
3727 if (!SDL_getenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE"))
3728 SDL_setenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE","1", 1);
3730 if (display_disable)
3731 flags &= ~SDL_INIT_VIDEO;
3732 if (SDL_Init (flags)) {
3733 av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n", SDL_GetError());
3734 av_log(NULL, AV_LOG_FATAL, "(Did you set the DISPLAY variable?)\n");
3738 SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
3739 SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
3741 if (!display_disable) {
3742 int flags = SDL_WINDOW_HIDDEN;
3744 #if SDL_VERSION_ATLEAST(2,0,5)
3745 flags |= SDL_WINDOW_ALWAYS_ON_TOP;
3747 av_log(NULL, AV_LOG_WARNING, "Your SDL version doesn't support SDL_WINDOW_ALWAYS_ON_TOP. Feature will be inactive.\n");
3750 flags |= SDL_WINDOW_BORDERLESS;
3752 flags |= SDL_WINDOW_RESIZABLE;
3753 window = SDL_CreateWindow(program_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, default_width, default_height, flags);
3754 SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
3756 renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
3758 av_log(NULL, AV_LOG_WARNING, "Failed to initialize a hardware accelerated renderer: %s\n", SDL_GetError());
3759 renderer = SDL_CreateRenderer(window, -1, 0);
3762 if (!SDL_GetRendererInfo(renderer, &renderer_info))
3763 av_log(NULL, AV_LOG_VERBOSE, "Initialized %s renderer.\n", renderer_info.name);
3766 if (!window || !renderer || !renderer_info.num_texture_formats) {
3767 av_log(NULL, AV_LOG_FATAL, "Failed to create window or renderer: %s", SDL_GetError());
3772 is = stream_open(input_filename, file_iformat);
3774 av_log(NULL, AV_LOG_FATAL, "Failed to initialize VideoState!\n");