ffplay: fix borderless mode on Windows
[ffmpeg.git] / ffplay.c
1 /*
2  * Copyright (c) 2003 Fabrice Bellard
3  *
4  * This file is part of FFmpeg.
5  *
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.
10  *
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.
15  *
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
19  */
20
21 /**
22  * @file
23  * simple media player based on the FFmpeg libraries
24  */
25
26 #include "config.h"
27 #include <inttypes.h>
28 #include <math.h>
29 #include <limits.h>
30 #include <signal.h>
31 #include <stdint.h>
32
33 #include "libavutil/avstring.h"
34 #include "libavutil/eval.h"
35 #include "libavutil/mathematics.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/imgutils.h"
38 #include "libavutil/dict.h"
39 #include "libavutil/parseutils.h"
40 #include "libavutil/samplefmt.h"
41 #include "libavutil/avassert.h"
42 #include "libavutil/time.h"
43 #include "libavformat/avformat.h"
44 #include "libavdevice/avdevice.h"
45 #include "libswscale/swscale.h"
46 #include "libavutil/opt.h"
47 #include "libavcodec/avfft.h"
48 #include "libswresample/swresample.h"
49
50 #if CONFIG_AVFILTER
51 # include "libavfilter/avfilter.h"
52 # include "libavfilter/buffersink.h"
53 # include "libavfilter/buffersrc.h"
54 #endif
55
56 #include <SDL.h>
57 #include <SDL_thread.h>
58
59 #include "cmdutils.h"
60
61 #include <assert.h>
62
63 const char program_name[] = "ffplay";
64 const int program_birth_year = 2003;
65
66 #define MAX_QUEUE_SIZE (15 * 1024 * 1024)
67 #define MIN_FRAMES 25
68 #define EXTERNAL_CLOCK_MIN_FRAMES 2
69 #define EXTERNAL_CLOCK_MAX_FRAMES 10
70
71 /* Minimum SDL audio buffer size, in samples. */
72 #define SDL_AUDIO_MIN_BUFFER_SIZE 512
73 /* Calculate actual buffer size keeping in mind not cause too frequent audio callbacks */
74 #define SDL_AUDIO_MAX_CALLBACKS_PER_SEC 30
75
76 /* Step size for volume control */
77 #define SDL_VOLUME_STEP (SDL_MIX_MAXVOLUME / 50)
78
79 /* no AV sync correction is done if below the minimum AV sync threshold */
80 #define AV_SYNC_THRESHOLD_MIN 0.04
81 /* AV sync correction is done if above the maximum AV sync threshold */
82 #define AV_SYNC_THRESHOLD_MAX 0.1
83 /* If a frame duration is longer than this, it will not be duplicated to compensate AV sync */
84 #define AV_SYNC_FRAMEDUP_THRESHOLD 0.1
85 /* no AV correction is done if too big error */
86 #define AV_NOSYNC_THRESHOLD 10.0
87
88 /* maximum audio speed change to get correct sync */
89 #define SAMPLE_CORRECTION_PERCENT_MAX 10
90
91 /* external clock speed adjustment constants for realtime sources based on buffer fullness */
92 #define EXTERNAL_CLOCK_SPEED_MIN  0.900
93 #define EXTERNAL_CLOCK_SPEED_MAX  1.010
94 #define EXTERNAL_CLOCK_SPEED_STEP 0.001
95
96 /* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
97 #define AUDIO_DIFF_AVG_NB   20
98
99 /* polls for possible required screen refresh at least this often, should be less than 1/fps */
100 #define REFRESH_RATE 0.01
101
102 /* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
103 /* TODO: We assume that a decoded and resampled frame fits into this buffer */
104 #define SAMPLE_ARRAY_SIZE (8 * 65536)
105
106 #define CURSOR_HIDE_DELAY 1000000
107
108 #define USE_ONEPASS_SUBTITLE_RENDER 1
109
110 static unsigned sws_flags = SWS_BICUBIC;
111
112 typedef struct MyAVPacketList {
113     AVPacket pkt;
114     struct MyAVPacketList *next;
115     int serial;
116 } MyAVPacketList;
117
118 typedef struct PacketQueue {
119     MyAVPacketList *first_pkt, *last_pkt;
120     int nb_packets;
121     int size;
122     int64_t duration;
123     int abort_request;
124     int serial;
125     SDL_mutex *mutex;
126     SDL_cond *cond;
127 } PacketQueue;
128
129 #define VIDEO_PICTURE_QUEUE_SIZE 3
130 #define SUBPICTURE_QUEUE_SIZE 16
131 #define SAMPLE_QUEUE_SIZE 9
132 #define FRAME_QUEUE_SIZE FFMAX(SAMPLE_QUEUE_SIZE, FFMAX(VIDEO_PICTURE_QUEUE_SIZE, SUBPICTURE_QUEUE_SIZE))
133
134 typedef struct AudioParams {
135     int freq;
136     int channels;
137     int64_t channel_layout;
138     enum AVSampleFormat fmt;
139     int frame_size;
140     int bytes_per_sec;
141 } AudioParams;
142
143 typedef struct Clock {
144     double pts;           /* clock base */
145     double pts_drift;     /* clock base minus time at which we updated the clock */
146     double last_updated;
147     double speed;
148     int serial;           /* clock is based on a packet with this serial */
149     int paused;
150     int *queue_serial;    /* pointer to the current packet queue serial, used for obsolete clock detection */
151 } Clock;
152
153 /* Common struct for handling all types of decoded data and allocated render buffers. */
154 typedef struct Frame {
155     AVFrame *frame;
156     AVSubtitle sub;
157     int serial;
158     double pts;           /* presentation timestamp for the frame */
159     double duration;      /* estimated duration of the frame */
160     int64_t pos;          /* byte position of the frame in the input file */
161     int width;
162     int height;
163     int format;
164     AVRational sar;
165     int uploaded;
166     int flip_v;
167 } Frame;
168
169 typedef struct FrameQueue {
170     Frame queue[FRAME_QUEUE_SIZE];
171     int rindex;
172     int windex;
173     int size;
174     int max_size;
175     int keep_last;
176     int rindex_shown;
177     SDL_mutex *mutex;
178     SDL_cond *cond;
179     PacketQueue *pktq;
180 } FrameQueue;
181
182 enum {
183     AV_SYNC_AUDIO_MASTER, /* default choice */
184     AV_SYNC_VIDEO_MASTER,
185     AV_SYNC_EXTERNAL_CLOCK, /* synchronize to an external clock */
186 };
187
188 typedef struct Decoder {
189     AVPacket pkt;
190     AVPacket pkt_temp;
191     PacketQueue *queue;
192     AVCodecContext *avctx;
193     int pkt_serial;
194     int finished;
195     int packet_pending;
196     SDL_cond *empty_queue_cond;
197     int64_t start_pts;
198     AVRational start_pts_tb;
199     int64_t next_pts;
200     AVRational next_pts_tb;
201     SDL_Thread *decoder_tid;
202 } Decoder;
203
204 typedef struct VideoState {
205     SDL_Thread *read_tid;
206     AVInputFormat *iformat;
207     int abort_request;
208     int force_refresh;
209     int paused;
210     int last_paused;
211     int queue_attachments_req;
212     int seek_req;
213     int seek_flags;
214     int64_t seek_pos;
215     int64_t seek_rel;
216     int read_pause_return;
217     AVFormatContext *ic;
218     int realtime;
219
220     Clock audclk;
221     Clock vidclk;
222     Clock extclk;
223
224     FrameQueue pictq;
225     FrameQueue subpq;
226     FrameQueue sampq;
227
228     Decoder auddec;
229     Decoder viddec;
230     Decoder subdec;
231
232     int audio_stream;
233
234     int av_sync_type;
235
236     double audio_clock;
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;
242     AVStream *audio_st;
243     PacketQueue audioq;
244     int audio_hw_buf_size;
245     uint8_t *audio_buf;
246     uint8_t *audio_buf1;
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;
251     int audio_volume;
252     int muted;
253     struct AudioParams audio_src;
254 #if CONFIG_AVFILTER
255     struct AudioParams audio_filter_src;
256 #endif
257     struct AudioParams audio_tgt;
258     struct SwrContext *swr_ctx;
259     int frame_drops_early;
260     int frame_drops_late;
261
262     enum ShowMode {
263         SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO = 0, SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB
264     } show_mode;
265     int16_t sample_array[SAMPLE_ARRAY_SIZE];
266     int sample_array_index;
267     int last_i_start;
268     RDFTContext *rdft;
269     int rdft_bits;
270     FFTSample *rdft_data;
271     int xpos;
272     double last_vis_time;
273     SDL_Texture *vis_texture;
274     SDL_Texture *sub_texture;
275     SDL_Texture *vid_texture;
276
277     int subtitle_stream;
278     AVStream *subtitle_st;
279     PacketQueue subtitleq;
280
281     double frame_timer;
282     double frame_last_returned_time;
283     double frame_last_filter_delay;
284     int video_stream;
285     AVStream *video_st;
286     PacketQueue videoq;
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;
290     int eof;
291
292     char *filename;
293     int width, height, xleft, ytop;
294     int step;
295
296 #if CONFIG_AVFILTER
297     int vfilter_idx;
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
303 #endif
304
305     int last_video_stream, last_audio_stream, last_subtitle_stream;
306
307     SDL_cond *continue_read_thread;
308 } VideoState;
309
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 audio_disable;
319 static int video_disable;
320 static int subtitle_disable;
321 static const char* wanted_stream_spec[AVMEDIA_TYPE_NB] = {0};
322 static int seek_by_bytes = -1;
323 static int display_disable;
324 static int borderless;
325 static int startup_volume = 100;
326 static int show_status = 1;
327 static int av_sync_type = AV_SYNC_AUDIO_MASTER;
328 static int64_t start_time = AV_NOPTS_VALUE;
329 static int64_t duration = AV_NOPTS_VALUE;
330 static int fast = 0;
331 static int genpts = 0;
332 static int lowres = 0;
333 static int decoder_reorder_pts = -1;
334 static int autoexit;
335 static int exit_on_keydown;
336 static int exit_on_mousedown;
337 static int loop = 1;
338 static int framedrop = -1;
339 static int infinite_buffer = -1;
340 static enum ShowMode show_mode = SHOW_MODE_NONE;
341 static const char *audio_codec_name;
342 static const char *subtitle_codec_name;
343 static const char *video_codec_name;
344 double rdftspeed = 0.02;
345 static int64_t cursor_last_shown;
346 static int cursor_hidden = 0;
347 #if CONFIG_AVFILTER
348 static const char **vfilters_list = NULL;
349 static int nb_vfilters = 0;
350 static char *afilters = NULL;
351 #endif
352 static int autorotate = 1;
353
354 /* current context */
355 static int is_full_screen;
356 static int64_t audio_callback_time;
357
358 static AVPacket flush_pkt;
359
360 #define FF_QUIT_EVENT    (SDL_USEREVENT + 2)
361
362 static SDL_Window *window;
363 static SDL_Renderer *renderer;
364
365 #if CONFIG_AVFILTER
366 static int opt_add_vfilter(void *optctx, const char *opt, const char *arg)
367 {
368     GROW_ARRAY(vfilters_list, nb_vfilters);
369     vfilters_list[nb_vfilters - 1] = arg;
370     return 0;
371 }
372 #endif
373
374 static inline
375 int cmp_audio_fmts(enum AVSampleFormat fmt1, int64_t channel_count1,
376                    enum AVSampleFormat fmt2, int64_t channel_count2)
377 {
378     /* If channel count == 1, planar and non-planar formats are the same */
379     if (channel_count1 == 1 && channel_count2 == 1)
380         return av_get_packed_sample_fmt(fmt1) != av_get_packed_sample_fmt(fmt2);
381     else
382         return channel_count1 != channel_count2 || fmt1 != fmt2;
383 }
384
385 static inline
386 int64_t get_valid_channel_layout(int64_t channel_layout, int channels)
387 {
388     if (channel_layout && av_get_channel_layout_nb_channels(channel_layout) == channels)
389         return channel_layout;
390     else
391         return 0;
392 }
393
394 static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
395 {
396     MyAVPacketList *pkt1;
397
398     if (q->abort_request)
399        return -1;
400
401     pkt1 = av_malloc(sizeof(MyAVPacketList));
402     if (!pkt1)
403         return -1;
404     pkt1->pkt = *pkt;
405     pkt1->next = NULL;
406     if (pkt == &flush_pkt)
407         q->serial++;
408     pkt1->serial = q->serial;
409
410     if (!q->last_pkt)
411         q->first_pkt = pkt1;
412     else
413         q->last_pkt->next = pkt1;
414     q->last_pkt = pkt1;
415     q->nb_packets++;
416     q->size += pkt1->pkt.size + sizeof(*pkt1);
417     q->duration += pkt1->pkt.duration;
418     /* XXX: should duplicate packet data in DV case */
419     SDL_CondSignal(q->cond);
420     return 0;
421 }
422
423 static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
424 {
425     int ret;
426
427     SDL_LockMutex(q->mutex);
428     ret = packet_queue_put_private(q, pkt);
429     SDL_UnlockMutex(q->mutex);
430
431     if (pkt != &flush_pkt && ret < 0)
432         av_packet_unref(pkt);
433
434     return ret;
435 }
436
437 static int packet_queue_put_nullpacket(PacketQueue *q, int stream_index)
438 {
439     AVPacket pkt1, *pkt = &pkt1;
440     av_init_packet(pkt);
441     pkt->data = NULL;
442     pkt->size = 0;
443     pkt->stream_index = stream_index;
444     return packet_queue_put(q, pkt);
445 }
446
447 /* packet queue handling */
448 static int packet_queue_init(PacketQueue *q)
449 {
450     memset(q, 0, sizeof(PacketQueue));
451     q->mutex = SDL_CreateMutex();
452     if (!q->mutex) {
453         av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
454         return AVERROR(ENOMEM);
455     }
456     q->cond = SDL_CreateCond();
457     if (!q->cond) {
458         av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
459         return AVERROR(ENOMEM);
460     }
461     q->abort_request = 1;
462     return 0;
463 }
464
465 static void packet_queue_flush(PacketQueue *q)
466 {
467     MyAVPacketList *pkt, *pkt1;
468
469     SDL_LockMutex(q->mutex);
470     for (pkt = q->first_pkt; pkt; pkt = pkt1) {
471         pkt1 = pkt->next;
472         av_packet_unref(&pkt->pkt);
473         av_freep(&pkt);
474     }
475     q->last_pkt = NULL;
476     q->first_pkt = NULL;
477     q->nb_packets = 0;
478     q->size = 0;
479     q->duration = 0;
480     SDL_UnlockMutex(q->mutex);
481 }
482
483 static void packet_queue_destroy(PacketQueue *q)
484 {
485     packet_queue_flush(q);
486     SDL_DestroyMutex(q->mutex);
487     SDL_DestroyCond(q->cond);
488 }
489
490 static void packet_queue_abort(PacketQueue *q)
491 {
492     SDL_LockMutex(q->mutex);
493
494     q->abort_request = 1;
495
496     SDL_CondSignal(q->cond);
497
498     SDL_UnlockMutex(q->mutex);
499 }
500
501 static void packet_queue_start(PacketQueue *q)
502 {
503     SDL_LockMutex(q->mutex);
504     q->abort_request = 0;
505     packet_queue_put_private(q, &flush_pkt);
506     SDL_UnlockMutex(q->mutex);
507 }
508
509 /* return < 0 if aborted, 0 if no packet and > 0 if packet.  */
510 static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)
511 {
512     MyAVPacketList *pkt1;
513     int ret;
514
515     SDL_LockMutex(q->mutex);
516
517     for (;;) {
518         if (q->abort_request) {
519             ret = -1;
520             break;
521         }
522
523         pkt1 = q->first_pkt;
524         if (pkt1) {
525             q->first_pkt = pkt1->next;
526             if (!q->first_pkt)
527                 q->last_pkt = NULL;
528             q->nb_packets--;
529             q->size -= pkt1->pkt.size + sizeof(*pkt1);
530             q->duration -= pkt1->pkt.duration;
531             *pkt = pkt1->pkt;
532             if (serial)
533                 *serial = pkt1->serial;
534             av_free(pkt1);
535             ret = 1;
536             break;
537         } else if (!block) {
538             ret = 0;
539             break;
540         } else {
541             SDL_CondWait(q->cond, q->mutex);
542         }
543     }
544     SDL_UnlockMutex(q->mutex);
545     return ret;
546 }
547
548 static void decoder_init(Decoder *d, AVCodecContext *avctx, PacketQueue *queue, SDL_cond *empty_queue_cond) {
549     memset(d, 0, sizeof(Decoder));
550     d->avctx = avctx;
551     d->queue = queue;
552     d->empty_queue_cond = empty_queue_cond;
553     d->start_pts = AV_NOPTS_VALUE;
554 }
555
556 static int decoder_decode_frame(Decoder *d, AVFrame *frame, AVSubtitle *sub) {
557     int got_frame = 0;
558
559     do {
560         int ret = -1;
561
562         if (d->queue->abort_request)
563             return -1;
564
565         if (!d->packet_pending || d->queue->serial != d->pkt_serial) {
566             AVPacket pkt;
567             do {
568                 if (d->queue->nb_packets == 0)
569                     SDL_CondSignal(d->empty_queue_cond);
570                 if (packet_queue_get(d->queue, &pkt, 1, &d->pkt_serial) < 0)
571                     return -1;
572                 if (pkt.data == flush_pkt.data) {
573                     avcodec_flush_buffers(d->avctx);
574                     d->finished = 0;
575                     d->next_pts = d->start_pts;
576                     d->next_pts_tb = d->start_pts_tb;
577                 }
578             } while (pkt.data == flush_pkt.data || d->queue->serial != d->pkt_serial);
579             av_packet_unref(&d->pkt);
580             d->pkt_temp = d->pkt = pkt;
581             d->packet_pending = 1;
582         }
583
584         switch (d->avctx->codec_type) {
585             case AVMEDIA_TYPE_VIDEO:
586                 ret = avcodec_decode_video2(d->avctx, frame, &got_frame, &d->pkt_temp);
587                 if (got_frame) {
588                     if (decoder_reorder_pts == -1) {
589                         frame->pts = av_frame_get_best_effort_timestamp(frame);
590                     } else if (!decoder_reorder_pts) {
591                         frame->pts = frame->pkt_dts;
592                     }
593                 }
594                 break;
595             case AVMEDIA_TYPE_AUDIO:
596                 ret = avcodec_decode_audio4(d->avctx, frame, &got_frame, &d->pkt_temp);
597                 if (got_frame) {
598                     AVRational tb = (AVRational){1, frame->sample_rate};
599                     if (frame->pts != AV_NOPTS_VALUE)
600                         frame->pts = av_rescale_q(frame->pts, av_codec_get_pkt_timebase(d->avctx), tb);
601                     else if (d->next_pts != AV_NOPTS_VALUE)
602                         frame->pts = av_rescale_q(d->next_pts, d->next_pts_tb, tb);
603                     if (frame->pts != AV_NOPTS_VALUE) {
604                         d->next_pts = frame->pts + frame->nb_samples;
605                         d->next_pts_tb = tb;
606                     }
607                 }
608                 break;
609             case AVMEDIA_TYPE_SUBTITLE:
610                 ret = avcodec_decode_subtitle2(d->avctx, sub, &got_frame, &d->pkt_temp);
611                 break;
612         }
613
614         if (ret < 0) {
615             d->packet_pending = 0;
616         } else {
617             d->pkt_temp.dts =
618             d->pkt_temp.pts = AV_NOPTS_VALUE;
619             if (d->pkt_temp.data) {
620                 if (d->avctx->codec_type != AVMEDIA_TYPE_AUDIO)
621                     ret = d->pkt_temp.size;
622                 d->pkt_temp.data += ret;
623                 d->pkt_temp.size -= ret;
624                 if (d->pkt_temp.size <= 0)
625                     d->packet_pending = 0;
626             } else {
627                 if (!got_frame) {
628                     d->packet_pending = 0;
629                     d->finished = d->pkt_serial;
630                 }
631             }
632         }
633     } while (!got_frame && !d->finished);
634
635     return got_frame;
636 }
637
638 static void decoder_destroy(Decoder *d) {
639     av_packet_unref(&d->pkt);
640     avcodec_free_context(&d->avctx);
641 }
642
643 static void frame_queue_unref_item(Frame *vp)
644 {
645     av_frame_unref(vp->frame);
646     avsubtitle_free(&vp->sub);
647 }
648
649 static int frame_queue_init(FrameQueue *f, PacketQueue *pktq, int max_size, int keep_last)
650 {
651     int i;
652     memset(f, 0, sizeof(FrameQueue));
653     if (!(f->mutex = SDL_CreateMutex())) {
654         av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
655         return AVERROR(ENOMEM);
656     }
657     if (!(f->cond = SDL_CreateCond())) {
658         av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
659         return AVERROR(ENOMEM);
660     }
661     f->pktq = pktq;
662     f->max_size = FFMIN(max_size, FRAME_QUEUE_SIZE);
663     f->keep_last = !!keep_last;
664     for (i = 0; i < f->max_size; i++)
665         if (!(f->queue[i].frame = av_frame_alloc()))
666             return AVERROR(ENOMEM);
667     return 0;
668 }
669
670 static void frame_queue_destory(FrameQueue *f)
671 {
672     int i;
673     for (i = 0; i < f->max_size; i++) {
674         Frame *vp = &f->queue[i];
675         frame_queue_unref_item(vp);
676         av_frame_free(&vp->frame);
677     }
678     SDL_DestroyMutex(f->mutex);
679     SDL_DestroyCond(f->cond);
680 }
681
682 static void frame_queue_signal(FrameQueue *f)
683 {
684     SDL_LockMutex(f->mutex);
685     SDL_CondSignal(f->cond);
686     SDL_UnlockMutex(f->mutex);
687 }
688
689 static Frame *frame_queue_peek(FrameQueue *f)
690 {
691     return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
692 }
693
694 static Frame *frame_queue_peek_next(FrameQueue *f)
695 {
696     return &f->queue[(f->rindex + f->rindex_shown + 1) % f->max_size];
697 }
698
699 static Frame *frame_queue_peek_last(FrameQueue *f)
700 {
701     return &f->queue[f->rindex];
702 }
703
704 static Frame *frame_queue_peek_writable(FrameQueue *f)
705 {
706     /* wait until we have space to put a new frame */
707     SDL_LockMutex(f->mutex);
708     while (f->size >= f->max_size &&
709            !f->pktq->abort_request) {
710         SDL_CondWait(f->cond, f->mutex);
711     }
712     SDL_UnlockMutex(f->mutex);
713
714     if (f->pktq->abort_request)
715         return NULL;
716
717     return &f->queue[f->windex];
718 }
719
720 static Frame *frame_queue_peek_readable(FrameQueue *f)
721 {
722     /* wait until we have a readable a new frame */
723     SDL_LockMutex(f->mutex);
724     while (f->size - f->rindex_shown <= 0 &&
725            !f->pktq->abort_request) {
726         SDL_CondWait(f->cond, f->mutex);
727     }
728     SDL_UnlockMutex(f->mutex);
729
730     if (f->pktq->abort_request)
731         return NULL;
732
733     return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
734 }
735
736 static void frame_queue_push(FrameQueue *f)
737 {
738     if (++f->windex == f->max_size)
739         f->windex = 0;
740     SDL_LockMutex(f->mutex);
741     f->size++;
742     SDL_CondSignal(f->cond);
743     SDL_UnlockMutex(f->mutex);
744 }
745
746 static void frame_queue_next(FrameQueue *f)
747 {
748     if (f->keep_last && !f->rindex_shown) {
749         f->rindex_shown = 1;
750         return;
751     }
752     frame_queue_unref_item(&f->queue[f->rindex]);
753     if (++f->rindex == f->max_size)
754         f->rindex = 0;
755     SDL_LockMutex(f->mutex);
756     f->size--;
757     SDL_CondSignal(f->cond);
758     SDL_UnlockMutex(f->mutex);
759 }
760
761 /* return the number of undisplayed frames in the queue */
762 static int frame_queue_nb_remaining(FrameQueue *f)
763 {
764     return f->size - f->rindex_shown;
765 }
766
767 /* return last shown position */
768 static int64_t frame_queue_last_pos(FrameQueue *f)
769 {
770     Frame *fp = &f->queue[f->rindex];
771     if (f->rindex_shown && fp->serial == f->pktq->serial)
772         return fp->pos;
773     else
774         return -1;
775 }
776
777 static void decoder_abort(Decoder *d, FrameQueue *fq)
778 {
779     packet_queue_abort(d->queue);
780     frame_queue_signal(fq);
781     SDL_WaitThread(d->decoder_tid, NULL);
782     d->decoder_tid = NULL;
783     packet_queue_flush(d->queue);
784 }
785
786 static inline void fill_rectangle(int x, int y, int w, int h)
787 {
788     SDL_Rect rect;
789     rect.x = x;
790     rect.y = y;
791     rect.w = w;
792     rect.h = h;
793     if (w && h)
794         SDL_RenderFillRect(renderer, &rect);
795 }
796
797 static int realloc_texture(SDL_Texture **texture, Uint32 new_format, int new_width, int new_height, SDL_BlendMode blendmode, int init_texture)
798 {
799     Uint32 format;
800     int access, w, h;
801     if (SDL_QueryTexture(*texture, &format, &access, &w, &h) < 0 || new_width != w || new_height != h || new_format != format) {
802         void *pixels;
803         int pitch;
804         SDL_DestroyTexture(*texture);
805         if (!(*texture = SDL_CreateTexture(renderer, new_format, SDL_TEXTUREACCESS_STREAMING, new_width, new_height)))
806             return -1;
807         if (SDL_SetTextureBlendMode(*texture, blendmode) < 0)
808             return -1;
809         if (init_texture) {
810             if (SDL_LockTexture(*texture, NULL, &pixels, &pitch) < 0)
811                 return -1;
812             memset(pixels, 0, pitch * new_height);
813             SDL_UnlockTexture(*texture);
814         }
815     }
816     return 0;
817 }
818
819 static void calculate_display_rect(SDL_Rect *rect,
820                                    int scr_xleft, int scr_ytop, int scr_width, int scr_height,
821                                    int pic_width, int pic_height, AVRational pic_sar)
822 {
823     float aspect_ratio;
824     int width, height, x, y;
825
826     if (pic_sar.num == 0)
827         aspect_ratio = 0;
828     else
829         aspect_ratio = av_q2d(pic_sar);
830
831     if (aspect_ratio <= 0.0)
832         aspect_ratio = 1.0;
833     aspect_ratio *= (float)pic_width / (float)pic_height;
834
835     /* XXX: we suppose the screen has a 1.0 pixel ratio */
836     height = scr_height;
837     width = lrint(height * aspect_ratio) & ~1;
838     if (width > scr_width) {
839         width = scr_width;
840         height = lrint(width / aspect_ratio) & ~1;
841     }
842     x = (scr_width - width) / 2;
843     y = (scr_height - height) / 2;
844     rect->x = scr_xleft + x;
845     rect->y = scr_ytop  + y;
846     rect->w = FFMAX(width,  1);
847     rect->h = FFMAX(height, 1);
848 }
849
850 static int upload_texture(SDL_Texture *tex, AVFrame *frame, struct SwsContext **img_convert_ctx) {
851     int ret = 0;
852     switch (frame->format) {
853         case AV_PIX_FMT_YUV420P:
854             if (frame->linesize[0] < 0 || frame->linesize[1] < 0 || frame->linesize[2] < 0) {
855                 av_log(NULL, AV_LOG_ERROR, "Negative linesize is not supported for YUV.\n");
856                 return -1;
857             }
858             ret = SDL_UpdateYUVTexture(tex, NULL, frame->data[0], frame->linesize[0],
859                                                   frame->data[1], frame->linesize[1],
860                                                   frame->data[2], frame->linesize[2]);
861             break;
862         case AV_PIX_FMT_BGRA:
863             if (frame->linesize[0] < 0) {
864                 ret = SDL_UpdateTexture(tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height - 1), -frame->linesize[0]);
865             } else {
866                 ret = SDL_UpdateTexture(tex, NULL, frame->data[0], frame->linesize[0]);
867             }
868             break;
869         default:
870             /* This should only happen if we are not using avfilter... */
871             *img_convert_ctx = sws_getCachedContext(*img_convert_ctx,
872                 frame->width, frame->height, frame->format, frame->width, frame->height,
873                 AV_PIX_FMT_BGRA, sws_flags, NULL, NULL, NULL);
874             if (*img_convert_ctx != NULL) {
875                 uint8_t *pixels[4];
876                 int pitch[4];
877                 if (!SDL_LockTexture(tex, NULL, (void **)pixels, pitch)) {
878                     sws_scale(*img_convert_ctx, (const uint8_t * const *)frame->data, frame->linesize,
879                               0, frame->height, pixels, pitch);
880                     SDL_UnlockTexture(tex);
881                 }
882             } else {
883                 av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
884                 ret = -1;
885             }
886             break;
887     }
888     return ret;
889 }
890
891 static void video_image_display(VideoState *is)
892 {
893     Frame *vp;
894     Frame *sp = NULL;
895     SDL_Rect rect;
896
897     vp = frame_queue_peek_last(&is->pictq);
898     if (is->subtitle_st) {
899         if (frame_queue_nb_remaining(&is->subpq) > 0) {
900             sp = frame_queue_peek(&is->subpq);
901
902             if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {
903                 if (!sp->uploaded) {
904                     uint8_t* pixels[4];
905                     int pitch[4];
906                     int i;
907                     if (!sp->width || !sp->height) {
908                         sp->width = vp->width;
909                         sp->height = vp->height;
910                     }
911                     if (realloc_texture(&is->sub_texture, SDL_PIXELFORMAT_ARGB8888, sp->width, sp->height, SDL_BLENDMODE_BLEND, 1) < 0)
912                         return;
913
914                     for (i = 0; i < sp->sub.num_rects; i++) {
915                         AVSubtitleRect *sub_rect = sp->sub.rects[i];
916
917                         sub_rect->x = av_clip(sub_rect->x, 0, sp->width );
918                         sub_rect->y = av_clip(sub_rect->y, 0, sp->height);
919                         sub_rect->w = av_clip(sub_rect->w, 0, sp->width  - sub_rect->x);
920                         sub_rect->h = av_clip(sub_rect->h, 0, sp->height - sub_rect->y);
921
922                         is->sub_convert_ctx = sws_getCachedContext(is->sub_convert_ctx,
923                             sub_rect->w, sub_rect->h, AV_PIX_FMT_PAL8,
924                             sub_rect->w, sub_rect->h, AV_PIX_FMT_BGRA,
925                             0, NULL, NULL, NULL);
926                         if (!is->sub_convert_ctx) {
927                             av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
928                             return;
929                         }
930                         if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)pixels, pitch)) {
931                             sws_scale(is->sub_convert_ctx, (const uint8_t * const *)sub_rect->data, sub_rect->linesize,
932                                       0, sub_rect->h, pixels, pitch);
933                             SDL_UnlockTexture(is->sub_texture);
934                         }
935                     }
936                     sp->uploaded = 1;
937                 }
938             } else
939                 sp = NULL;
940         }
941     }
942
943     calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp->width, vp->height, vp->sar);
944
945     if (!vp->uploaded) {
946         int sdl_pix_fmt = vp->frame->format == AV_PIX_FMT_YUV420P ? SDL_PIXELFORMAT_YV12 : SDL_PIXELFORMAT_ARGB8888;
947         if (realloc_texture(&is->vid_texture, sdl_pix_fmt, vp->frame->width, vp->frame->height, SDL_BLENDMODE_NONE, 0) < 0)
948             return;
949         if (upload_texture(is->vid_texture, vp->frame, &is->img_convert_ctx) < 0)
950             return;
951         vp->uploaded = 1;
952         vp->flip_v = vp->frame->linesize[0] < 0;
953     }
954
955     SDL_RenderCopyEx(renderer, is->vid_texture, NULL, &rect, 0, NULL, vp->flip_v ? SDL_FLIP_VERTICAL : 0);
956     if (sp) {
957 #if USE_ONEPASS_SUBTITLE_RENDER
958         SDL_RenderCopy(renderer, is->sub_texture, NULL, &rect);
959 #else
960         int i;
961         double xratio = (double)rect.w / (double)sp->width;
962         double yratio = (double)rect.h / (double)sp->height;
963         for (i = 0; i < sp->sub.num_rects; i++) {
964             SDL_Rect *sub_rect = (SDL_Rect*)sp->sub.rects[i];
965             SDL_Rect target = {.x = rect.x + sub_rect->x * xratio,
966                                .y = rect.y + sub_rect->y * yratio,
967                                .w = sub_rect->w * xratio,
968                                .h = sub_rect->h * yratio};
969             SDL_RenderCopy(renderer, is->sub_texture, sub_rect, &target);
970         }
971 #endif
972     }
973 }
974
975 static inline int compute_mod(int a, int b)
976 {
977     return a < 0 ? a%b + b : a%b;
978 }
979
980 static void video_audio_display(VideoState *s)
981 {
982     int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
983     int ch, channels, h, h2;
984     int64_t time_diff;
985     int rdft_bits, nb_freq;
986
987     for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++)
988         ;
989     nb_freq = 1 << (rdft_bits - 1);
990
991     /* compute display index : center on currently output samples */
992     channels = s->audio_tgt.channels;
993     nb_display_channels = channels;
994     if (!s->paused) {
995         int data_used= s->show_mode == SHOW_MODE_WAVES ? s->width : (2*nb_freq);
996         n = 2 * channels;
997         delay = s->audio_write_buf_size;
998         delay /= n;
999
1000         /* to be more precise, we take into account the time spent since
1001            the last buffer computation */
1002         if (audio_callback_time) {
1003             time_diff = av_gettime_relative() - audio_callback_time;
1004             delay -= (time_diff * s->audio_tgt.freq) / 1000000;
1005         }
1006
1007         delay += 2 * data_used;
1008         if (delay < data_used)
1009             delay = data_used;
1010
1011         i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
1012         if (s->show_mode == SHOW_MODE_WAVES) {
1013             h = INT_MIN;
1014             for (i = 0; i < 1000; i += channels) {
1015                 int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
1016                 int a = s->sample_array[idx];
1017                 int b = s->sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];
1018                 int c = s->sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];
1019                 int d = s->sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];
1020                 int score = a - d;
1021                 if (h < score && (b ^ c) < 0) {
1022                     h = score;
1023                     i_start = idx;
1024                 }
1025             }
1026         }
1027
1028         s->last_i_start = i_start;
1029     } else {
1030         i_start = s->last_i_start;
1031     }
1032
1033     if (s->show_mode == SHOW_MODE_WAVES) {
1034         SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
1035
1036         /* total height for one channel */
1037         h = s->height / nb_display_channels;
1038         /* graph height / 2 */
1039         h2 = (h * 9) / 20;
1040         for (ch = 0; ch < nb_display_channels; ch++) {
1041             i = i_start + ch;
1042             y1 = s->ytop + ch * h + (h / 2); /* position of center line */
1043             for (x = 0; x < s->width; x++) {
1044                 y = (s->sample_array[i] * h2) >> 15;
1045                 if (y < 0) {
1046                     y = -y;
1047                     ys = y1 - y;
1048                 } else {
1049                     ys = y1;
1050                 }
1051                 fill_rectangle(s->xleft + x, ys, 1, y);
1052                 i += channels;
1053                 if (i >= SAMPLE_ARRAY_SIZE)
1054                     i -= SAMPLE_ARRAY_SIZE;
1055             }
1056         }
1057
1058         SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255);
1059
1060         for (ch = 1; ch < nb_display_channels; ch++) {
1061             y = s->ytop + ch * h;
1062             fill_rectangle(s->xleft, y, s->width, 1);
1063         }
1064     } else {
1065         if (realloc_texture(&s->vis_texture, SDL_PIXELFORMAT_ARGB8888, s->width, s->height, SDL_BLENDMODE_NONE, 1) < 0)
1066             return;
1067
1068         nb_display_channels= FFMIN(nb_display_channels, 2);
1069         if (rdft_bits != s->rdft_bits) {
1070             av_rdft_end(s->rdft);
1071             av_free(s->rdft_data);
1072             s->rdft = av_rdft_init(rdft_bits, DFT_R2C);
1073             s->rdft_bits = rdft_bits;
1074             s->rdft_data = av_malloc_array(nb_freq, 4 *sizeof(*s->rdft_data));
1075         }
1076         if (!s->rdft || !s->rdft_data){
1077             av_log(NULL, AV_LOG_ERROR, "Failed to allocate buffers for RDFT, switching to waves display\n");
1078             s->show_mode = SHOW_MODE_WAVES;
1079         } else {
1080             FFTSample *data[2];
1081             SDL_Rect rect = {.x = s->xpos, .y = 0, .w = 1, .h = s->height};
1082             uint32_t *pixels;
1083             int pitch;
1084             for (ch = 0; ch < nb_display_channels; ch++) {
1085                 data[ch] = s->rdft_data + 2 * nb_freq * ch;
1086                 i = i_start + ch;
1087                 for (x = 0; x < 2 * nb_freq; x++) {
1088                     double w = (x-nb_freq) * (1.0 / nb_freq);
1089                     data[ch][x] = s->sample_array[i] * (1.0 - w * w);
1090                     i += channels;
1091                     if (i >= SAMPLE_ARRAY_SIZE)
1092                         i -= SAMPLE_ARRAY_SIZE;
1093                 }
1094                 av_rdft_calc(s->rdft, data[ch]);
1095             }
1096             /* Least efficient way to do this, we should of course
1097              * directly access it but it is more than fast enough. */
1098             if (!SDL_LockTexture(s->vis_texture, &rect, (void **)&pixels, &pitch)) {
1099                 pitch >>= 2;
1100                 pixels += pitch * s->height;
1101                 for (y = 0; y < s->height; y++) {
1102                     double w = 1 / sqrt(nb_freq);
1103                     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]));
1104                     int b = (nb_display_channels == 2 ) ? sqrt(w * hypot(data[1][2 * y + 0], data[1][2 * y + 1]))
1105                                                         : a;
1106                     a = FFMIN(a, 255);
1107                     b = FFMIN(b, 255);
1108                     pixels -= pitch;
1109                     *pixels = (a << 16) + (b << 8) + ((a+b) >> 1);
1110                 }
1111                 SDL_UnlockTexture(s->vis_texture);
1112             }
1113             SDL_RenderCopy(renderer, s->vis_texture, NULL, NULL);
1114         }
1115         if (!s->paused)
1116             s->xpos++;
1117         if (s->xpos >= s->width)
1118             s->xpos= s->xleft;
1119     }
1120 }
1121
1122 static void stream_component_close(VideoState *is, int stream_index)
1123 {
1124     AVFormatContext *ic = is->ic;
1125     AVCodecParameters *codecpar;
1126
1127     if (stream_index < 0 || stream_index >= ic->nb_streams)
1128         return;
1129     codecpar = ic->streams[stream_index]->codecpar;
1130
1131     switch (codecpar->codec_type) {
1132     case AVMEDIA_TYPE_AUDIO:
1133         decoder_abort(&is->auddec, &is->sampq);
1134         SDL_CloseAudio();
1135         decoder_destroy(&is->auddec);
1136         swr_free(&is->swr_ctx);
1137         av_freep(&is->audio_buf1);
1138         is->audio_buf1_size = 0;
1139         is->audio_buf = NULL;
1140
1141         if (is->rdft) {
1142             av_rdft_end(is->rdft);
1143             av_freep(&is->rdft_data);
1144             is->rdft = NULL;
1145             is->rdft_bits = 0;
1146         }
1147         break;
1148     case AVMEDIA_TYPE_VIDEO:
1149         decoder_abort(&is->viddec, &is->pictq);
1150         decoder_destroy(&is->viddec);
1151         break;
1152     case AVMEDIA_TYPE_SUBTITLE:
1153         decoder_abort(&is->subdec, &is->subpq);
1154         decoder_destroy(&is->subdec);
1155         break;
1156     default:
1157         break;
1158     }
1159
1160     ic->streams[stream_index]->discard = AVDISCARD_ALL;
1161     switch (codecpar->codec_type) {
1162     case AVMEDIA_TYPE_AUDIO:
1163         is->audio_st = NULL;
1164         is->audio_stream = -1;
1165         break;
1166     case AVMEDIA_TYPE_VIDEO:
1167         is->video_st = NULL;
1168         is->video_stream = -1;
1169         break;
1170     case AVMEDIA_TYPE_SUBTITLE:
1171         is->subtitle_st = NULL;
1172         is->subtitle_stream = -1;
1173         break;
1174     default:
1175         break;
1176     }
1177 }
1178
1179 static void stream_close(VideoState *is)
1180 {
1181     /* XXX: use a special url_shutdown call to abort parse cleanly */
1182     is->abort_request = 1;
1183     SDL_WaitThread(is->read_tid, NULL);
1184
1185     /* close each stream */
1186     if (is->audio_stream >= 0)
1187         stream_component_close(is, is->audio_stream);
1188     if (is->video_stream >= 0)
1189         stream_component_close(is, is->video_stream);
1190     if (is->subtitle_stream >= 0)
1191         stream_component_close(is, is->subtitle_stream);
1192
1193     avformat_close_input(&is->ic);
1194
1195     packet_queue_destroy(&is->videoq);
1196     packet_queue_destroy(&is->audioq);
1197     packet_queue_destroy(&is->subtitleq);
1198
1199     /* free all pictures */
1200     frame_queue_destory(&is->pictq);
1201     frame_queue_destory(&is->sampq);
1202     frame_queue_destory(&is->subpq);
1203     SDL_DestroyCond(is->continue_read_thread);
1204     sws_freeContext(is->img_convert_ctx);
1205     sws_freeContext(is->sub_convert_ctx);
1206     av_free(is->filename);
1207     if (is->vis_texture)
1208         SDL_DestroyTexture(is->vis_texture);
1209     if (is->vid_texture)
1210         SDL_DestroyTexture(is->vid_texture);
1211     if (is->sub_texture)
1212         SDL_DestroyTexture(is->sub_texture);
1213     av_free(is);
1214 }
1215
1216 static void do_exit(VideoState *is)
1217 {
1218     if (is) {
1219         stream_close(is);
1220     }
1221     if (renderer)
1222         SDL_DestroyRenderer(renderer);
1223     if (window)
1224         SDL_DestroyWindow(window);
1225     av_lockmgr_register(NULL);
1226     uninit_opts();
1227 #if CONFIG_AVFILTER
1228     av_freep(&vfilters_list);
1229 #endif
1230     avformat_network_deinit();
1231     if (show_status)
1232         printf("\n");
1233     SDL_Quit();
1234     av_log(NULL, AV_LOG_QUIET, "%s", "");
1235     exit(0);
1236 }
1237
1238 static void sigterm_handler(int sig)
1239 {
1240     exit(123);
1241 }
1242
1243 static void set_default_window_size(int width, int height, AVRational sar)
1244 {
1245     SDL_Rect rect;
1246     calculate_display_rect(&rect, 0, 0, INT_MAX, height, width, height, sar);
1247     default_width  = rect.w;
1248     default_height = rect.h;
1249 }
1250
1251 static int video_open(VideoState *is)
1252 {
1253     int w,h;
1254
1255     if (screen_width) {
1256         w = screen_width;
1257         h = screen_height;
1258     } else {
1259         w = default_width;
1260         h = default_height;
1261     }
1262
1263     if (!window) {
1264         int flags = SDL_WINDOW_SHOWN;
1265         if (!window_title)
1266             window_title = input_filename;
1267         if (is_full_screen)
1268             flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
1269         if (borderless)
1270             flags |= SDL_WINDOW_BORDERLESS;
1271         else
1272             flags |= SDL_WINDOW_RESIZABLE;
1273         window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, w, h, flags);
1274         SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
1275         if (window) {
1276             SDL_RendererInfo info;
1277             renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
1278             if (!renderer) {
1279                 av_log(NULL, AV_LOG_WARNING, "Failed to initialize a hardware accelerated renderer: %s\n", SDL_GetError());
1280                 renderer = SDL_CreateRenderer(window, -1, 0);
1281             }
1282             if (renderer) {
1283                 if (!SDL_GetRendererInfo(renderer, &info))
1284                     av_log(NULL, AV_LOG_VERBOSE, "Initialized %s renderer.\n", info.name);
1285             }
1286         }
1287     } else {
1288         SDL_SetWindowSize(window, w, h);
1289     }
1290
1291     if (!window || !renderer) {
1292         av_log(NULL, AV_LOG_FATAL, "SDL: could not set video mode - exiting\n");
1293         do_exit(is);
1294     }
1295
1296     is->width  = w;
1297     is->height = h;
1298
1299     return 0;
1300 }
1301
1302 /* display the current picture, if any */
1303 static void video_display(VideoState *is)
1304 {
1305     if (!window)
1306         video_open(is);
1307
1308     SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
1309     SDL_RenderClear(renderer);
1310     if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
1311         video_audio_display(is);
1312     else if (is->video_st)
1313         video_image_display(is);
1314     SDL_RenderPresent(renderer);
1315 }
1316
1317 static double get_clock(Clock *c)
1318 {
1319     if (*c->queue_serial != c->serial)
1320         return NAN;
1321     if (c->paused) {
1322         return c->pts;
1323     } else {
1324         double time = av_gettime_relative() / 1000000.0;
1325         return c->pts_drift + time - (time - c->last_updated) * (1.0 - c->speed);
1326     }
1327 }
1328
1329 static void set_clock_at(Clock *c, double pts, int serial, double time)
1330 {
1331     c->pts = pts;
1332     c->last_updated = time;
1333     c->pts_drift = c->pts - time;
1334     c->serial = serial;
1335 }
1336
1337 static void set_clock(Clock *c, double pts, int serial)
1338 {
1339     double time = av_gettime_relative() / 1000000.0;
1340     set_clock_at(c, pts, serial, time);
1341 }
1342
1343 static void set_clock_speed(Clock *c, double speed)
1344 {
1345     set_clock(c, get_clock(c), c->serial);
1346     c->speed = speed;
1347 }
1348
1349 static void init_clock(Clock *c, int *queue_serial)
1350 {
1351     c->speed = 1.0;
1352     c->paused = 0;
1353     c->queue_serial = queue_serial;
1354     set_clock(c, NAN, -1);
1355 }
1356
1357 static void sync_clock_to_slave(Clock *c, Clock *slave)
1358 {
1359     double clock = get_clock(c);
1360     double slave_clock = get_clock(slave);
1361     if (!isnan(slave_clock) && (isnan(clock) || fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))
1362         set_clock(c, slave_clock, slave->serial);
1363 }
1364
1365 static int get_master_sync_type(VideoState *is) {
1366     if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
1367         if (is->video_st)
1368             return AV_SYNC_VIDEO_MASTER;
1369         else
1370             return AV_SYNC_AUDIO_MASTER;
1371     } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
1372         if (is->audio_st)
1373             return AV_SYNC_AUDIO_MASTER;
1374         else
1375             return AV_SYNC_EXTERNAL_CLOCK;
1376     } else {
1377         return AV_SYNC_EXTERNAL_CLOCK;
1378     }
1379 }
1380
1381 /* get the current master clock value */
1382 static double get_master_clock(VideoState *is)
1383 {
1384     double val;
1385
1386     switch (get_master_sync_type(is)) {
1387         case AV_SYNC_VIDEO_MASTER:
1388             val = get_clock(&is->vidclk);
1389             break;
1390         case AV_SYNC_AUDIO_MASTER:
1391             val = get_clock(&is->audclk);
1392             break;
1393         default:
1394             val = get_clock(&is->extclk);
1395             break;
1396     }
1397     return val;
1398 }
1399
1400 static void check_external_clock_speed(VideoState *is) {
1401    if (is->video_stream >= 0 && is->videoq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES ||
1402        is->audio_stream >= 0 && is->audioq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES) {
1403        set_clock_speed(&is->extclk, FFMAX(EXTERNAL_CLOCK_SPEED_MIN, is->extclk.speed - EXTERNAL_CLOCK_SPEED_STEP));
1404    } else if ((is->video_stream < 0 || is->videoq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES) &&
1405               (is->audio_stream < 0 || is->audioq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES)) {
1406        set_clock_speed(&is->extclk, FFMIN(EXTERNAL_CLOCK_SPEED_MAX, is->extclk.speed + EXTERNAL_CLOCK_SPEED_STEP));
1407    } else {
1408        double speed = is->extclk.speed;
1409        if (speed != 1.0)
1410            set_clock_speed(&is->extclk, speed + EXTERNAL_CLOCK_SPEED_STEP * (1.0 - speed) / fabs(1.0 - speed));
1411    }
1412 }
1413
1414 /* seek in the stream */
1415 static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)
1416 {
1417     if (!is->seek_req) {
1418         is->seek_pos = pos;
1419         is->seek_rel = rel;
1420         is->seek_flags &= ~AVSEEK_FLAG_BYTE;
1421         if (seek_by_bytes)
1422             is->seek_flags |= AVSEEK_FLAG_BYTE;
1423         is->seek_req = 1;
1424         SDL_CondSignal(is->continue_read_thread);
1425     }
1426 }
1427
1428 /* pause or resume the video */
1429 static void stream_toggle_pause(VideoState *is)
1430 {
1431     if (is->paused) {
1432         is->frame_timer += av_gettime_relative() / 1000000.0 - is->vidclk.last_updated;
1433         if (is->read_pause_return != AVERROR(ENOSYS)) {
1434             is->vidclk.paused = 0;
1435         }
1436         set_clock(&is->vidclk, get_clock(&is->vidclk), is->vidclk.serial);
1437     }
1438     set_clock(&is->extclk, get_clock(&is->extclk), is->extclk.serial);
1439     is->paused = is->audclk.paused = is->vidclk.paused = is->extclk.paused = !is->paused;
1440 }
1441
1442 static void toggle_pause(VideoState *is)
1443 {
1444     stream_toggle_pause(is);
1445     is->step = 0;
1446 }
1447
1448 static void toggle_mute(VideoState *is)
1449 {
1450     is->muted = !is->muted;
1451 }
1452
1453 static void update_volume(VideoState *is, int sign, int step)
1454 {
1455     is->audio_volume = av_clip(is->audio_volume + sign * step, 0, SDL_MIX_MAXVOLUME);
1456 }
1457
1458 static void step_to_next_frame(VideoState *is)
1459 {
1460     /* if the stream is paused unpause it, then step */
1461     if (is->paused)
1462         stream_toggle_pause(is);
1463     is->step = 1;
1464 }
1465
1466 static double compute_target_delay(double delay, VideoState *is)
1467 {
1468     double sync_threshold, diff = 0;
1469
1470     /* update delay to follow master synchronisation source */
1471     if (get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER) {
1472         /* if video is slave, we try to correct big delays by
1473            duplicating or deleting a frame */
1474         diff = get_clock(&is->vidclk) - get_master_clock(is);
1475
1476         /* skip or repeat frame. We take into account the
1477            delay to compute the threshold. I still don't know
1478            if it is the best guess */
1479         sync_threshold = FFMAX(AV_SYNC_THRESHOLD_MIN, FFMIN(AV_SYNC_THRESHOLD_MAX, delay));
1480         if (!isnan(diff) && fabs(diff) < is->max_frame_duration) {
1481             if (diff <= -sync_threshold)
1482                 delay = FFMAX(0, delay + diff);
1483             else if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD)
1484                 delay = delay + diff;
1485             else if (diff >= sync_threshold)
1486                 delay = 2 * delay;
1487         }
1488     }
1489
1490     av_log(NULL, AV_LOG_TRACE, "video: delay=%0.3f A-V=%f\n",
1491             delay, -diff);
1492
1493     return delay;
1494 }
1495
1496 static double vp_duration(VideoState *is, Frame *vp, Frame *nextvp) {
1497     if (vp->serial == nextvp->serial) {
1498         double duration = nextvp->pts - vp->pts;
1499         if (isnan(duration) || duration <= 0 || duration > is->max_frame_duration)
1500             return vp->duration;
1501         else
1502             return duration;
1503     } else {
1504         return 0.0;
1505     }
1506 }
1507
1508 static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
1509     /* update current video pts */
1510     set_clock(&is->vidclk, pts, serial);
1511     sync_clock_to_slave(&is->extclk, &is->vidclk);
1512 }
1513
1514 /* called to display each frame */
1515 static void video_refresh(void *opaque, double *remaining_time)
1516 {
1517     VideoState *is = opaque;
1518     double time;
1519
1520     Frame *sp, *sp2;
1521
1522     if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
1523         check_external_clock_speed(is);
1524
1525     if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {
1526         time = av_gettime_relative() / 1000000.0;
1527         if (is->force_refresh || is->last_vis_time + rdftspeed < time) {
1528             video_display(is);
1529             is->last_vis_time = time;
1530         }
1531         *remaining_time = FFMIN(*remaining_time, is->last_vis_time + rdftspeed - time);
1532     }
1533
1534     if (is->video_st) {
1535 retry:
1536         if (frame_queue_nb_remaining(&is->pictq) == 0) {
1537             // nothing to do, no picture to display in the queue
1538         } else {
1539             double last_duration, duration, delay;
1540             Frame *vp, *lastvp;
1541
1542             /* dequeue the picture */
1543             lastvp = frame_queue_peek_last(&is->pictq);
1544             vp = frame_queue_peek(&is->pictq);
1545
1546             if (vp->serial != is->videoq.serial) {
1547                 frame_queue_next(&is->pictq);
1548                 goto retry;
1549             }
1550
1551             if (lastvp->serial != vp->serial)
1552                 is->frame_timer = av_gettime_relative() / 1000000.0;
1553
1554             if (is->paused)
1555                 goto display;
1556
1557             /* compute nominal last_duration */
1558             last_duration = vp_duration(is, lastvp, vp);
1559             delay = compute_target_delay(last_duration, is);
1560
1561             time= av_gettime_relative()/1000000.0;
1562             if (time < is->frame_timer + delay) {
1563                 *remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);
1564                 goto display;
1565             }
1566
1567             is->frame_timer += delay;
1568             if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)
1569                 is->frame_timer = time;
1570
1571             SDL_LockMutex(is->pictq.mutex);
1572             if (!isnan(vp->pts))
1573                 update_video_pts(is, vp->pts, vp->pos, vp->serial);
1574             SDL_UnlockMutex(is->pictq.mutex);
1575
1576             if (frame_queue_nb_remaining(&is->pictq) > 1) {
1577                 Frame *nextvp = frame_queue_peek_next(&is->pictq);
1578                 duration = vp_duration(is, vp, nextvp);
1579                 if(!is->step && (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
1580                     is->frame_drops_late++;
1581                     frame_queue_next(&is->pictq);
1582                     goto retry;
1583                 }
1584             }
1585
1586             if (is->subtitle_st) {
1587                     while (frame_queue_nb_remaining(&is->subpq) > 0) {
1588                         sp = frame_queue_peek(&is->subpq);
1589
1590                         if (frame_queue_nb_remaining(&is->subpq) > 1)
1591                             sp2 = frame_queue_peek_next(&is->subpq);
1592                         else
1593                             sp2 = NULL;
1594
1595                         if (sp->serial != is->subtitleq.serial
1596                                 || (is->vidclk.pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1597                                 || (sp2 && is->vidclk.pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1598                         {
1599                             if (sp->uploaded) {
1600                                 int i;
1601                                 for (i = 0; i < sp->sub.num_rects; i++) {
1602                                     AVSubtitleRect *sub_rect = sp->sub.rects[i];
1603                                     uint8_t *pixels;
1604                                     int pitch, j;
1605
1606                                     if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)&pixels, &pitch)) {
1607                                         for (j = 0; j < sub_rect->h; j++, pixels += pitch)
1608                                             memset(pixels, 0, sub_rect->w << 2);
1609                                         SDL_UnlockTexture(is->sub_texture);
1610                                     }
1611                                 }
1612                             }
1613                             frame_queue_next(&is->subpq);
1614                         } else {
1615                             break;
1616                         }
1617                     }
1618             }
1619
1620             frame_queue_next(&is->pictq);
1621             is->force_refresh = 1;
1622
1623             if (is->step && !is->paused)
1624                 stream_toggle_pause(is);
1625         }
1626 display:
1627         /* display picture */
1628         if (!display_disable && is->force_refresh && is->show_mode == SHOW_MODE_VIDEO && is->pictq.rindex_shown)
1629             video_display(is);
1630     }
1631     is->force_refresh = 0;
1632     if (show_status) {
1633         static int64_t last_time;
1634         int64_t cur_time;
1635         int aqsize, vqsize, sqsize;
1636         double av_diff;
1637
1638         cur_time = av_gettime_relative();
1639         if (!last_time || (cur_time - last_time) >= 30000) {
1640             aqsize = 0;
1641             vqsize = 0;
1642             sqsize = 0;
1643             if (is->audio_st)
1644                 aqsize = is->audioq.size;
1645             if (is->video_st)
1646                 vqsize = is->videoq.size;
1647             if (is->subtitle_st)
1648                 sqsize = is->subtitleq.size;
1649             av_diff = 0;
1650             if (is->audio_st && is->video_st)
1651                 av_diff = get_clock(&is->audclk) - get_clock(&is->vidclk);
1652             else if (is->video_st)
1653                 av_diff = get_master_clock(is) - get_clock(&is->vidclk);
1654             else if (is->audio_st)
1655                 av_diff = get_master_clock(is) - get_clock(&is->audclk);
1656             av_log(NULL, AV_LOG_INFO,
1657                    "%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64"   \r",
1658                    get_master_clock(is),
1659                    (is->audio_st && is->video_st) ? "A-V" : (is->video_st ? "M-V" : (is->audio_st ? "M-A" : "   ")),
1660                    av_diff,
1661                    is->frame_drops_early + is->frame_drops_late,
1662                    aqsize / 1024,
1663                    vqsize / 1024,
1664                    sqsize,
1665                    is->video_st ? is->viddec.avctx->pts_correction_num_faulty_dts : 0,
1666                    is->video_st ? is->viddec.avctx->pts_correction_num_faulty_pts : 0);
1667             fflush(stdout);
1668             last_time = cur_time;
1669         }
1670     }
1671 }
1672
1673 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, double duration, int64_t pos, int serial)
1674 {
1675     Frame *vp;
1676
1677 #if defined(DEBUG_SYNC)
1678     printf("frame_type=%c pts=%0.3f\n",
1679            av_get_picture_type_char(src_frame->pict_type), pts);
1680 #endif
1681
1682     if (!(vp = frame_queue_peek_writable(&is->pictq)))
1683         return -1;
1684
1685     vp->sar = src_frame->sample_aspect_ratio;
1686     vp->uploaded = 0;
1687
1688     vp->width = src_frame->width;
1689     vp->height = src_frame->height;
1690     vp->format = src_frame->format;
1691
1692     vp->pts = pts;
1693     vp->duration = duration;
1694     vp->pos = pos;
1695     vp->serial = serial;
1696
1697     set_default_window_size(vp->width, vp->height, vp->sar);
1698
1699     av_frame_move_ref(vp->frame, src_frame);
1700     frame_queue_push(&is->pictq);
1701     return 0;
1702 }
1703
1704 static int get_video_frame(VideoState *is, AVFrame *frame)
1705 {
1706     int got_picture;
1707
1708     if ((got_picture = decoder_decode_frame(&is->viddec, frame, NULL)) < 0)
1709         return -1;
1710
1711     if (got_picture) {
1712         double dpts = NAN;
1713
1714         if (frame->pts != AV_NOPTS_VALUE)
1715             dpts = av_q2d(is->video_st->time_base) * frame->pts;
1716
1717         frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
1718
1719         if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
1720             if (frame->pts != AV_NOPTS_VALUE) {
1721                 double diff = dpts - get_master_clock(is);
1722                 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD &&
1723                     diff - is->frame_last_filter_delay < 0 &&
1724                     is->viddec.pkt_serial == is->vidclk.serial &&
1725                     is->videoq.nb_packets) {
1726                     is->frame_drops_early++;
1727                     av_frame_unref(frame);
1728                     got_picture = 0;
1729                 }
1730             }
1731         }
1732     }
1733
1734     return got_picture;
1735 }
1736
1737 #if CONFIG_AVFILTER
1738 static int configure_filtergraph(AVFilterGraph *graph, const char *filtergraph,
1739                                  AVFilterContext *source_ctx, AVFilterContext *sink_ctx)
1740 {
1741     int ret, i;
1742     int nb_filters = graph->nb_filters;
1743     AVFilterInOut *outputs = NULL, *inputs = NULL;
1744
1745     if (filtergraph) {
1746         outputs = avfilter_inout_alloc();
1747         inputs  = avfilter_inout_alloc();
1748         if (!outputs || !inputs) {
1749             ret = AVERROR(ENOMEM);
1750             goto fail;
1751         }
1752
1753         outputs->name       = av_strdup("in");
1754         outputs->filter_ctx = source_ctx;
1755         outputs->pad_idx    = 0;
1756         outputs->next       = NULL;
1757
1758         inputs->name        = av_strdup("out");
1759         inputs->filter_ctx  = sink_ctx;
1760         inputs->pad_idx     = 0;
1761         inputs->next        = NULL;
1762
1763         if ((ret = avfilter_graph_parse_ptr(graph, filtergraph, &inputs, &outputs, NULL)) < 0)
1764             goto fail;
1765     } else {
1766         if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
1767             goto fail;
1768     }
1769
1770     /* Reorder the filters to ensure that inputs of the custom filters are merged first */
1771     for (i = 0; i < graph->nb_filters - nb_filters; i++)
1772         FFSWAP(AVFilterContext*, graph->filters[i], graph->filters[i + nb_filters]);
1773
1774     ret = avfilter_graph_config(graph, NULL);
1775 fail:
1776     avfilter_inout_free(&outputs);
1777     avfilter_inout_free(&inputs);
1778     return ret;
1779 }
1780
1781 static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const char *vfilters, AVFrame *frame)
1782 {
1783     static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_BGRA, AV_PIX_FMT_NONE };
1784     char sws_flags_str[512] = "";
1785     char buffersrc_args[256];
1786     int ret;
1787     AVFilterContext *filt_src = NULL, *filt_out = NULL, *last_filter = NULL;
1788     AVCodecParameters *codecpar = is->video_st->codecpar;
1789     AVRational fr = av_guess_frame_rate(is->ic, is->video_st, NULL);
1790     AVDictionaryEntry *e = NULL;
1791
1792     while ((e = av_dict_get(sws_dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
1793         if (!strcmp(e->key, "sws_flags")) {
1794             av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", "flags", e->value);
1795         } else
1796             av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", e->key, e->value);
1797     }
1798     if (strlen(sws_flags_str))
1799         sws_flags_str[strlen(sws_flags_str)-1] = '\0';
1800
1801     graph->scale_sws_opts = av_strdup(sws_flags_str);
1802
1803     snprintf(buffersrc_args, sizeof(buffersrc_args),
1804              "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
1805              frame->width, frame->height, frame->format,
1806              is->video_st->time_base.num, is->video_st->time_base.den,
1807              codecpar->sample_aspect_ratio.num, FFMAX(codecpar->sample_aspect_ratio.den, 1));
1808     if (fr.num && fr.den)
1809         av_strlcatf(buffersrc_args, sizeof(buffersrc_args), ":frame_rate=%d/%d", fr.num, fr.den);
1810
1811     if ((ret = avfilter_graph_create_filter(&filt_src,
1812                                             avfilter_get_by_name("buffer"),
1813                                             "ffplay_buffer", buffersrc_args, NULL,
1814                                             graph)) < 0)
1815         goto fail;
1816
1817     ret = avfilter_graph_create_filter(&filt_out,
1818                                        avfilter_get_by_name("buffersink"),
1819                                        "ffplay_buffersink", NULL, NULL, graph);
1820     if (ret < 0)
1821         goto fail;
1822
1823     if ((ret = av_opt_set_int_list(filt_out, "pix_fmts", pix_fmts,  AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1824         goto fail;
1825
1826     last_filter = filt_out;
1827
1828 /* Note: this macro adds a filter before the lastly added filter, so the
1829  * processing order of the filters is in reverse */
1830 #define INSERT_FILT(name, arg) do {                                          \
1831     AVFilterContext *filt_ctx;                                               \
1832                                                                              \
1833     ret = avfilter_graph_create_filter(&filt_ctx,                            \
1834                                        avfilter_get_by_name(name),           \
1835                                        "ffplay_" name, arg, NULL, graph);    \
1836     if (ret < 0)                                                             \
1837         goto fail;                                                           \
1838                                                                              \
1839     ret = avfilter_link(filt_ctx, 0, last_filter, 0);                        \
1840     if (ret < 0)                                                             \
1841         goto fail;                                                           \
1842                                                                              \
1843     last_filter = filt_ctx;                                                  \
1844 } while (0)
1845
1846     if (autorotate) {
1847         double theta  = get_rotation(is->video_st);
1848
1849         if (fabs(theta - 90) < 1.0) {
1850             INSERT_FILT("transpose", "clock");
1851         } else if (fabs(theta - 180) < 1.0) {
1852             INSERT_FILT("hflip", NULL);
1853             INSERT_FILT("vflip", NULL);
1854         } else if (fabs(theta - 270) < 1.0) {
1855             INSERT_FILT("transpose", "cclock");
1856         } else if (fabs(theta) > 1.0) {
1857             char rotate_buf[64];
1858             snprintf(rotate_buf, sizeof(rotate_buf), "%f*PI/180", theta);
1859             INSERT_FILT("rotate", rotate_buf);
1860         }
1861     }
1862
1863     if ((ret = configure_filtergraph(graph, vfilters, filt_src, last_filter)) < 0)
1864         goto fail;
1865
1866     is->in_video_filter  = filt_src;
1867     is->out_video_filter = filt_out;
1868
1869 fail:
1870     return ret;
1871 }
1872
1873 static int configure_audio_filters(VideoState *is, const char *afilters, int force_output_format)
1874 {
1875     static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
1876     int sample_rates[2] = { 0, -1 };
1877     int64_t channel_layouts[2] = { 0, -1 };
1878     int channels[2] = { 0, -1 };
1879     AVFilterContext *filt_asrc = NULL, *filt_asink = NULL;
1880     char aresample_swr_opts[512] = "";
1881     AVDictionaryEntry *e = NULL;
1882     char asrc_args[256];
1883     int ret;
1884
1885     avfilter_graph_free(&is->agraph);
1886     if (!(is->agraph = avfilter_graph_alloc()))
1887         return AVERROR(ENOMEM);
1888
1889     while ((e = av_dict_get(swr_opts, "", e, AV_DICT_IGNORE_SUFFIX)))
1890         av_strlcatf(aresample_swr_opts, sizeof(aresample_swr_opts), "%s=%s:", e->key, e->value);
1891     if (strlen(aresample_swr_opts))
1892         aresample_swr_opts[strlen(aresample_swr_opts)-1] = '\0';
1893     av_opt_set(is->agraph, "aresample_swr_opts", aresample_swr_opts, 0);
1894
1895     ret = snprintf(asrc_args, sizeof(asrc_args),
1896                    "sample_rate=%d:sample_fmt=%s:channels=%d:time_base=%d/%d",
1897                    is->audio_filter_src.freq, av_get_sample_fmt_name(is->audio_filter_src.fmt),
1898                    is->audio_filter_src.channels,
1899                    1, is->audio_filter_src.freq);
1900     if (is->audio_filter_src.channel_layout)
1901         snprintf(asrc_args + ret, sizeof(asrc_args) - ret,
1902                  ":channel_layout=0x%"PRIx64,  is->audio_filter_src.channel_layout);
1903
1904     ret = avfilter_graph_create_filter(&filt_asrc,
1905                                        avfilter_get_by_name("abuffer"), "ffplay_abuffer",
1906                                        asrc_args, NULL, is->agraph);
1907     if (ret < 0)
1908         goto end;
1909
1910
1911     ret = avfilter_graph_create_filter(&filt_asink,
1912                                        avfilter_get_by_name("abuffersink"), "ffplay_abuffersink",
1913                                        NULL, NULL, is->agraph);
1914     if (ret < 0)
1915         goto end;
1916
1917     if ((ret = av_opt_set_int_list(filt_asink, "sample_fmts", sample_fmts,  AV_SAMPLE_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1918         goto end;
1919     if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 1, AV_OPT_SEARCH_CHILDREN)) < 0)
1920         goto end;
1921
1922     if (force_output_format) {
1923         channel_layouts[0] = is->audio_tgt.channel_layout;
1924         channels       [0] = is->audio_tgt.channels;
1925         sample_rates   [0] = is->audio_tgt.freq;
1926         if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 0, AV_OPT_SEARCH_CHILDREN)) < 0)
1927             goto end;
1928         if ((ret = av_opt_set_int_list(filt_asink, "channel_layouts", channel_layouts,  -1, AV_OPT_SEARCH_CHILDREN)) < 0)
1929             goto end;
1930         if ((ret = av_opt_set_int_list(filt_asink, "channel_counts" , channels       ,  -1, AV_OPT_SEARCH_CHILDREN)) < 0)
1931             goto end;
1932         if ((ret = av_opt_set_int_list(filt_asink, "sample_rates"   , sample_rates   ,  -1, AV_OPT_SEARCH_CHILDREN)) < 0)
1933             goto end;
1934     }
1935
1936
1937     if ((ret = configure_filtergraph(is->agraph, afilters, filt_asrc, filt_asink)) < 0)
1938         goto end;
1939
1940     is->in_audio_filter  = filt_asrc;
1941     is->out_audio_filter = filt_asink;
1942
1943 end:
1944     if (ret < 0)
1945         avfilter_graph_free(&is->agraph);
1946     return ret;
1947 }
1948 #endif  /* CONFIG_AVFILTER */
1949
1950 static int audio_thread(void *arg)
1951 {
1952     VideoState *is = arg;
1953     AVFrame *frame = av_frame_alloc();
1954     Frame *af;
1955 #if CONFIG_AVFILTER
1956     int last_serial = -1;
1957     int64_t dec_channel_layout;
1958     int reconfigure;
1959 #endif
1960     int got_frame = 0;
1961     AVRational tb;
1962     int ret = 0;
1963
1964     if (!frame)
1965         return AVERROR(ENOMEM);
1966
1967     do {
1968         if ((got_frame = decoder_decode_frame(&is->auddec, frame, NULL)) < 0)
1969             goto the_end;
1970
1971         if (got_frame) {
1972                 tb = (AVRational){1, frame->sample_rate};
1973
1974 #if CONFIG_AVFILTER
1975                 dec_channel_layout = get_valid_channel_layout(frame->channel_layout, av_frame_get_channels(frame));
1976
1977                 reconfigure =
1978                     cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
1979                                    frame->format, av_frame_get_channels(frame))    ||
1980                     is->audio_filter_src.channel_layout != dec_channel_layout ||
1981                     is->audio_filter_src.freq           != frame->sample_rate ||
1982                     is->auddec.pkt_serial               != last_serial;
1983
1984                 if (reconfigure) {
1985                     char buf1[1024], buf2[1024];
1986                     av_get_channel_layout_string(buf1, sizeof(buf1), -1, is->audio_filter_src.channel_layout);
1987                     av_get_channel_layout_string(buf2, sizeof(buf2), -1, dec_channel_layout);
1988                     av_log(NULL, AV_LOG_DEBUG,
1989                            "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",
1990                            is->audio_filter_src.freq, is->audio_filter_src.channels, av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, last_serial,
1991                            frame->sample_rate, av_frame_get_channels(frame), av_get_sample_fmt_name(frame->format), buf2, is->auddec.pkt_serial);
1992
1993                     is->audio_filter_src.fmt            = frame->format;
1994                     is->audio_filter_src.channels       = av_frame_get_channels(frame);
1995                     is->audio_filter_src.channel_layout = dec_channel_layout;
1996                     is->audio_filter_src.freq           = frame->sample_rate;
1997                     last_serial                         = is->auddec.pkt_serial;
1998
1999                     if ((ret = configure_audio_filters(is, afilters, 1)) < 0)
2000                         goto the_end;
2001                 }
2002
2003             if ((ret = av_buffersrc_add_frame(is->in_audio_filter, frame)) < 0)
2004                 goto the_end;
2005
2006             while ((ret = av_buffersink_get_frame_flags(is->out_audio_filter, frame, 0)) >= 0) {
2007                 tb = av_buffersink_get_time_base(is->out_audio_filter);
2008 #endif
2009                 if (!(af = frame_queue_peek_writable(&is->sampq)))
2010                     goto the_end;
2011
2012                 af->pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2013                 af->pos = av_frame_get_pkt_pos(frame);
2014                 af->serial = is->auddec.pkt_serial;
2015                 af->duration = av_q2d((AVRational){frame->nb_samples, frame->sample_rate});
2016
2017                 av_frame_move_ref(af->frame, frame);
2018                 frame_queue_push(&is->sampq);
2019
2020 #if CONFIG_AVFILTER
2021                 if (is->audioq.serial != is->auddec.pkt_serial)
2022                     break;
2023             }
2024             if (ret == AVERROR_EOF)
2025                 is->auddec.finished = is->auddec.pkt_serial;
2026 #endif
2027         }
2028     } while (ret >= 0 || ret == AVERROR(EAGAIN) || ret == AVERROR_EOF);
2029  the_end:
2030 #if CONFIG_AVFILTER
2031     avfilter_graph_free(&is->agraph);
2032 #endif
2033     av_frame_free(&frame);
2034     return ret;
2035 }
2036
2037 static int decoder_start(Decoder *d, int (*fn)(void *), void *arg)
2038 {
2039     packet_queue_start(d->queue);
2040     d->decoder_tid = SDL_CreateThread(fn, "decoder", arg);
2041     if (!d->decoder_tid) {
2042         av_log(NULL, AV_LOG_ERROR, "SDL_CreateThread(): %s\n", SDL_GetError());
2043         return AVERROR(ENOMEM);
2044     }
2045     return 0;
2046 }
2047
2048 static int video_thread(void *arg)
2049 {
2050     VideoState *is = arg;
2051     AVFrame *frame = av_frame_alloc();
2052     double pts;
2053     double duration;
2054     int ret;
2055     AVRational tb = is->video_st->time_base;
2056     AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);
2057
2058 #if CONFIG_AVFILTER
2059     AVFilterGraph *graph = avfilter_graph_alloc();
2060     AVFilterContext *filt_out = NULL, *filt_in = NULL;
2061     int last_w = 0;
2062     int last_h = 0;
2063     enum AVPixelFormat last_format = -2;
2064     int last_serial = -1;
2065     int last_vfilter_idx = 0;
2066     if (!graph) {
2067         av_frame_free(&frame);
2068         return AVERROR(ENOMEM);
2069     }
2070
2071 #endif
2072
2073     if (!frame) {
2074 #if CONFIG_AVFILTER
2075         avfilter_graph_free(&graph);
2076 #endif
2077         return AVERROR(ENOMEM);
2078     }
2079
2080     for (;;) {
2081         ret = get_video_frame(is, frame);
2082         if (ret < 0)
2083             goto the_end;
2084         if (!ret)
2085             continue;
2086
2087 #if CONFIG_AVFILTER
2088         if (   last_w != frame->width
2089             || last_h != frame->height
2090             || last_format != frame->format
2091             || last_serial != is->viddec.pkt_serial
2092             || last_vfilter_idx != is->vfilter_idx) {
2093             av_log(NULL, AV_LOG_DEBUG,
2094                    "Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
2095                    last_w, last_h,
2096                    (const char *)av_x_if_null(av_get_pix_fmt_name(last_format), "none"), last_serial,
2097                    frame->width, frame->height,
2098                    (const char *)av_x_if_null(av_get_pix_fmt_name(frame->format), "none"), is->viddec.pkt_serial);
2099             avfilter_graph_free(&graph);
2100             graph = avfilter_graph_alloc();
2101             if ((ret = configure_video_filters(graph, is, vfilters_list ? vfilters_list[is->vfilter_idx] : NULL, frame)) < 0) {
2102                 SDL_Event event;
2103                 event.type = FF_QUIT_EVENT;
2104                 event.user.data1 = is;
2105                 SDL_PushEvent(&event);
2106                 goto the_end;
2107             }
2108             filt_in  = is->in_video_filter;
2109             filt_out = is->out_video_filter;
2110             last_w = frame->width;
2111             last_h = frame->height;
2112             last_format = frame->format;
2113             last_serial = is->viddec.pkt_serial;
2114             last_vfilter_idx = is->vfilter_idx;
2115             frame_rate = av_buffersink_get_frame_rate(filt_out);
2116         }
2117
2118         ret = av_buffersrc_add_frame(filt_in, frame);
2119         if (ret < 0)
2120             goto the_end;
2121
2122         while (ret >= 0) {
2123             is->frame_last_returned_time = av_gettime_relative() / 1000000.0;
2124
2125             ret = av_buffersink_get_frame_flags(filt_out, frame, 0);
2126             if (ret < 0) {
2127                 if (ret == AVERROR_EOF)
2128                     is->viddec.finished = is->viddec.pkt_serial;
2129                 ret = 0;
2130                 break;
2131             }
2132
2133             is->frame_last_filter_delay = av_gettime_relative() / 1000000.0 - is->frame_last_returned_time;
2134             if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
2135                 is->frame_last_filter_delay = 0;
2136             tb = av_buffersink_get_time_base(filt_out);
2137 #endif
2138             duration = (frame_rate.num && frame_rate.den ? av_q2d((AVRational){frame_rate.den, frame_rate.num}) : 0);
2139             pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2140             ret = queue_picture(is, frame, pts, duration, av_frame_get_pkt_pos(frame), is->viddec.pkt_serial);
2141             av_frame_unref(frame);
2142 #if CONFIG_AVFILTER
2143         }
2144 #endif
2145
2146         if (ret < 0)
2147             goto the_end;
2148     }
2149  the_end:
2150 #if CONFIG_AVFILTER
2151     avfilter_graph_free(&graph);
2152 #endif
2153     av_frame_free(&frame);
2154     return 0;
2155 }
2156
2157 static int subtitle_thread(void *arg)
2158 {
2159     VideoState *is = arg;
2160     Frame *sp;
2161     int got_subtitle;
2162     double pts;
2163
2164     for (;;) {
2165         if (!(sp = frame_queue_peek_writable(&is->subpq)))
2166             return 0;
2167
2168         if ((got_subtitle = decoder_decode_frame(&is->subdec, NULL, &sp->sub)) < 0)
2169             break;
2170
2171         pts = 0;
2172
2173         if (got_subtitle && sp->sub.format == 0) {
2174             if (sp->sub.pts != AV_NOPTS_VALUE)
2175                 pts = sp->sub.pts / (double)AV_TIME_BASE;
2176             sp->pts = pts;
2177             sp->serial = is->subdec.pkt_serial;
2178             sp->width = is->subdec.avctx->width;
2179             sp->height = is->subdec.avctx->height;
2180             sp->uploaded = 0;
2181
2182             /* now we can update the picture count */
2183             frame_queue_push(&is->subpq);
2184         } else if (got_subtitle) {
2185             avsubtitle_free(&sp->sub);
2186         }
2187     }
2188     return 0;
2189 }
2190
2191 /* copy samples for viewing in editor window */
2192 static void update_sample_display(VideoState *is, short *samples, int samples_size)
2193 {
2194     int size, len;
2195
2196     size = samples_size / sizeof(short);
2197     while (size > 0) {
2198         len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
2199         if (len > size)
2200             len = size;
2201         memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
2202         samples += len;
2203         is->sample_array_index += len;
2204         if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
2205             is->sample_array_index = 0;
2206         size -= len;
2207     }
2208 }
2209
2210 /* return the wanted number of samples to get better sync if sync_type is video
2211  * or external master clock */
2212 static int synchronize_audio(VideoState *is, int nb_samples)
2213 {
2214     int wanted_nb_samples = nb_samples;
2215
2216     /* if not master, then we try to remove or add samples to correct the clock */
2217     if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
2218         double diff, avg_diff;
2219         int min_nb_samples, max_nb_samples;
2220
2221         diff = get_clock(&is->audclk) - get_master_clock(is);
2222
2223         if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD) {
2224             is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
2225             if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
2226                 /* not enough measures to have a correct estimate */
2227                 is->audio_diff_avg_count++;
2228             } else {
2229                 /* estimate the A-V difference */
2230                 avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
2231
2232                 if (fabs(avg_diff) >= is->audio_diff_threshold) {
2233                     wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);
2234                     min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2235                     max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2236                     wanted_nb_samples = av_clip(wanted_nb_samples, min_nb_samples, max_nb_samples);
2237                 }
2238                 av_log(NULL, AV_LOG_TRACE, "diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
2239                         diff, avg_diff, wanted_nb_samples - nb_samples,
2240                         is->audio_clock, is->audio_diff_threshold);
2241             }
2242         } else {
2243             /* too big difference : may be initial PTS errors, so
2244                reset A-V filter */
2245             is->audio_diff_avg_count = 0;
2246             is->audio_diff_cum       = 0;
2247         }
2248     }
2249
2250     return wanted_nb_samples;
2251 }
2252
2253 /**
2254  * Decode one audio frame and return its uncompressed size.
2255  *
2256  * The processed audio frame is decoded, converted if required, and
2257  * stored in is->audio_buf, with size in bytes given by the return
2258  * value.
2259  */
2260 static int audio_decode_frame(VideoState *is)
2261 {
2262     int data_size, resampled_data_size;
2263     int64_t dec_channel_layout;
2264     av_unused double audio_clock0;
2265     int wanted_nb_samples;
2266     Frame *af;
2267
2268     if (is->paused)
2269         return -1;
2270
2271     do {
2272 #if defined(_WIN32)
2273         while (frame_queue_nb_remaining(&is->sampq) == 0) {
2274             if ((av_gettime_relative() - audio_callback_time) > 1000000LL * is->audio_hw_buf_size / is->audio_tgt.bytes_per_sec / 2)
2275                 return -1;
2276             av_usleep (1000);
2277         }
2278 #endif
2279         if (!(af = frame_queue_peek_readable(&is->sampq)))
2280             return -1;
2281         frame_queue_next(&is->sampq);
2282     } while (af->serial != is->audioq.serial);
2283
2284     data_size = av_samples_get_buffer_size(NULL, av_frame_get_channels(af->frame),
2285                                            af->frame->nb_samples,
2286                                            af->frame->format, 1);
2287
2288     dec_channel_layout =
2289         (af->frame->channel_layout && av_frame_get_channels(af->frame) == av_get_channel_layout_nb_channels(af->frame->channel_layout)) ?
2290         af->frame->channel_layout : av_get_default_channel_layout(av_frame_get_channels(af->frame));
2291     wanted_nb_samples = synchronize_audio(is, af->frame->nb_samples);
2292
2293     if (af->frame->format        != is->audio_src.fmt            ||
2294         dec_channel_layout       != is->audio_src.channel_layout ||
2295         af->frame->sample_rate   != is->audio_src.freq           ||
2296         (wanted_nb_samples       != af->frame->nb_samples && !is->swr_ctx)) {
2297         swr_free(&is->swr_ctx);
2298         is->swr_ctx = swr_alloc_set_opts(NULL,
2299                                          is->audio_tgt.channel_layout, is->audio_tgt.fmt, is->audio_tgt.freq,
2300                                          dec_channel_layout,           af->frame->format, af->frame->sample_rate,
2301                                          0, NULL);
2302         if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
2303             av_log(NULL, AV_LOG_ERROR,
2304                    "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
2305                     af->frame->sample_rate, av_get_sample_fmt_name(af->frame->format), av_frame_get_channels(af->frame),
2306                     is->audio_tgt.freq, av_get_sample_fmt_name(is->audio_tgt.fmt), is->audio_tgt.channels);
2307             swr_free(&is->swr_ctx);
2308             return -1;
2309         }
2310         is->audio_src.channel_layout = dec_channel_layout;
2311         is->audio_src.channels       = av_frame_get_channels(af->frame);
2312         is->audio_src.freq = af->frame->sample_rate;
2313         is->audio_src.fmt = af->frame->format;
2314     }
2315
2316     if (is->swr_ctx) {
2317         const uint8_t **in = (const uint8_t **)af->frame->extended_data;
2318         uint8_t **out = &is->audio_buf1;
2319         int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate + 256;
2320         int out_size  = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, out_count, is->audio_tgt.fmt, 0);
2321         int len2;
2322         if (out_size < 0) {
2323             av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size() failed\n");
2324             return -1;
2325         }
2326         if (wanted_nb_samples != af->frame->nb_samples) {
2327             if (swr_set_compensation(is->swr_ctx, (wanted_nb_samples - af->frame->nb_samples) * is->audio_tgt.freq / af->frame->sample_rate,
2328                                         wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate) < 0) {
2329                 av_log(NULL, AV_LOG_ERROR, "swr_set_compensation() failed\n");
2330                 return -1;
2331             }
2332         }
2333         av_fast_malloc(&is->audio_buf1, &is->audio_buf1_size, out_size);
2334         if (!is->audio_buf1)
2335             return AVERROR(ENOMEM);
2336         len2 = swr_convert(is->swr_ctx, out, out_count, in, af->frame->nb_samples);
2337         if (len2 < 0) {
2338             av_log(NULL, AV_LOG_ERROR, "swr_convert() failed\n");
2339             return -1;
2340         }
2341         if (len2 == out_count) {
2342             av_log(NULL, AV_LOG_WARNING, "audio buffer is probably too small\n");
2343             if (swr_init(is->swr_ctx) < 0)
2344                 swr_free(&is->swr_ctx);
2345         }
2346         is->audio_buf = is->audio_buf1;
2347         resampled_data_size = len2 * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2348     } else {
2349         is->audio_buf = af->frame->data[0];
2350         resampled_data_size = data_size;
2351     }
2352
2353     audio_clock0 = is->audio_clock;
2354     /* update the audio clock with the pts */
2355     if (!isnan(af->pts))
2356         is->audio_clock = af->pts + (double) af->frame->nb_samples / af->frame->sample_rate;
2357     else
2358         is->audio_clock = NAN;
2359     is->audio_clock_serial = af->serial;
2360 #ifdef DEBUG
2361     {
2362         static double last_clock;
2363         printf("audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
2364                is->audio_clock - last_clock,
2365                is->audio_clock, audio_clock0);
2366         last_clock = is->audio_clock;
2367     }
2368 #endif
2369     return resampled_data_size;
2370 }
2371
2372 /* prepare a new audio buffer */
2373 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
2374 {
2375     VideoState *is = opaque;
2376     int audio_size, len1;
2377
2378     audio_callback_time = av_gettime_relative();
2379
2380     while (len > 0) {
2381         if (is->audio_buf_index >= is->audio_buf_size) {
2382            audio_size = audio_decode_frame(is);
2383            if (audio_size < 0) {
2384                 /* if error, just output silence */
2385                is->audio_buf = NULL;
2386                is->audio_buf_size = SDL_AUDIO_MIN_BUFFER_SIZE / is->audio_tgt.frame_size * is->audio_tgt.frame_size;
2387            } else {
2388                if (is->show_mode != SHOW_MODE_VIDEO)
2389                    update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
2390                is->audio_buf_size = audio_size;
2391            }
2392            is->audio_buf_index = 0;
2393         }
2394         len1 = is->audio_buf_size - is->audio_buf_index;
2395         if (len1 > len)
2396             len1 = len;
2397         if (!is->muted && is->audio_buf && is->audio_volume == SDL_MIX_MAXVOLUME)
2398             memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
2399         else {
2400             memset(stream, 0, len1);
2401             if (!is->muted && is->audio_buf)
2402                 SDL_MixAudio(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1, is->audio_volume);
2403         }
2404         len -= len1;
2405         stream += len1;
2406         is->audio_buf_index += len1;
2407     }
2408     is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
2409     /* Let's assume the audio driver that is used by SDL has two periods. */
2410     if (!isnan(is->audio_clock)) {
2411         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);
2412         sync_clock_to_slave(&is->extclk, &is->audclk);
2413     }
2414 }
2415
2416 static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
2417 {
2418     SDL_AudioSpec wanted_spec, spec;
2419     const char *env;
2420     static const int next_nb_channels[] = {0, 0, 1, 6, 2, 6, 4, 6};
2421     static const int next_sample_rates[] = {0, 44100, 48000, 96000, 192000};
2422     int next_sample_rate_idx = FF_ARRAY_ELEMS(next_sample_rates) - 1;
2423
2424     env = SDL_getenv("SDL_AUDIO_CHANNELS");
2425     if (env) {
2426         wanted_nb_channels = atoi(env);
2427         wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2428     }
2429     if (!wanted_channel_layout || wanted_nb_channels != av_get_channel_layout_nb_channels(wanted_channel_layout)) {
2430         wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2431         wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
2432     }
2433     wanted_nb_channels = av_get_channel_layout_nb_channels(wanted_channel_layout);
2434     wanted_spec.channels = wanted_nb_channels;
2435     wanted_spec.freq = wanted_sample_rate;
2436     if (wanted_spec.freq <= 0 || wanted_spec.channels <= 0) {
2437         av_log(NULL, AV_LOG_ERROR, "Invalid sample rate or channel count!\n");
2438         return -1;
2439     }
2440     while (next_sample_rate_idx && next_sample_rates[next_sample_rate_idx] >= wanted_spec.freq)
2441         next_sample_rate_idx--;
2442     wanted_spec.format = AUDIO_S16SYS;
2443     wanted_spec.silence = 0;
2444     wanted_spec.samples = FFMAX(SDL_AUDIO_MIN_BUFFER_SIZE, 2 << av_log2(wanted_spec.freq / SDL_AUDIO_MAX_CALLBACKS_PER_SEC));
2445     wanted_spec.callback = sdl_audio_callback;
2446     wanted_spec.userdata = opaque;
2447     while (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
2448         av_log(NULL, AV_LOG_WARNING, "SDL_OpenAudio (%d channels, %d Hz): %s\n",
2449                wanted_spec.channels, wanted_spec.freq, SDL_GetError());
2450         wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
2451         if (!wanted_spec.channels) {
2452             wanted_spec.freq = next_sample_rates[next_sample_rate_idx--];
2453             wanted_spec.channels = wanted_nb_channels;
2454             if (!wanted_spec.freq) {
2455                 av_log(NULL, AV_LOG_ERROR,
2456                        "No more combinations to try, audio open failed\n");
2457                 return -1;
2458             }
2459         }
2460         wanted_channel_layout = av_get_default_channel_layout(wanted_spec.channels);
2461     }
2462     if (spec.format != AUDIO_S16SYS) {
2463         av_log(NULL, AV_LOG_ERROR,
2464                "SDL advised audio format %d is not supported!\n", spec.format);
2465         return -1;
2466     }
2467     if (spec.channels != wanted_spec.channels) {
2468         wanted_channel_layout = av_get_default_channel_layout(spec.channels);
2469         if (!wanted_channel_layout) {
2470             av_log(NULL, AV_LOG_ERROR,
2471                    "SDL advised channel count %d is not supported!\n", spec.channels);
2472             return -1;
2473         }
2474     }
2475
2476     audio_hw_params->fmt = AV_SAMPLE_FMT_S16;
2477     audio_hw_params->freq = spec.freq;
2478     audio_hw_params->channel_layout = wanted_channel_layout;
2479     audio_hw_params->channels =  spec.channels;
2480     audio_hw_params->frame_size = av_samples_get_buffer_size(NULL, audio_hw_params->channels, 1, audio_hw_params->fmt, 1);
2481     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);
2482     if (audio_hw_params->bytes_per_sec <= 0 || audio_hw_params->frame_size <= 0) {
2483         av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size failed\n");
2484         return -1;
2485     }
2486     return spec.size;
2487 }
2488
2489 /* open a given stream. Return 0 if OK */
2490 static int stream_component_open(VideoState *is, int stream_index)
2491 {
2492     AVFormatContext *ic = is->ic;
2493     AVCodecContext *avctx;
2494     AVCodec *codec;
2495     const char *forced_codec_name = NULL;
2496     AVDictionary *opts = NULL;
2497     AVDictionaryEntry *t = NULL;
2498     int sample_rate, nb_channels;
2499     int64_t channel_layout;
2500     int ret = 0;
2501     int stream_lowres = lowres;
2502
2503     if (stream_index < 0 || stream_index >= ic->nb_streams)
2504         return -1;
2505
2506     avctx = avcodec_alloc_context3(NULL);
2507     if (!avctx)
2508         return AVERROR(ENOMEM);
2509
2510     ret = avcodec_parameters_to_context(avctx, ic->streams[stream_index]->codecpar);
2511     if (ret < 0)
2512         goto fail;
2513     av_codec_set_pkt_timebase(avctx, ic->streams[stream_index]->time_base);
2514
2515     codec = avcodec_find_decoder(avctx->codec_id);
2516
2517     switch(avctx->codec_type){
2518         case AVMEDIA_TYPE_AUDIO   : is->last_audio_stream    = stream_index; forced_codec_name =    audio_codec_name; break;
2519         case AVMEDIA_TYPE_SUBTITLE: is->last_subtitle_stream = stream_index; forced_codec_name = subtitle_codec_name; break;
2520         case AVMEDIA_TYPE_VIDEO   : is->last_video_stream    = stream_index; forced_codec_name =    video_codec_name; break;
2521     }
2522     if (forced_codec_name)
2523         codec = avcodec_find_decoder_by_name(forced_codec_name);
2524     if (!codec) {
2525         if (forced_codec_name) av_log(NULL, AV_LOG_WARNING,
2526                                       "No codec could be found with name '%s'\n", forced_codec_name);
2527         else                   av_log(NULL, AV_LOG_WARNING,
2528                                       "No codec could be found with id %d\n", avctx->codec_id);
2529         ret = AVERROR(EINVAL);
2530         goto fail;
2531     }
2532
2533     avctx->codec_id = codec->id;
2534     if(stream_lowres > av_codec_get_max_lowres(codec)){
2535         av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2536                 av_codec_get_max_lowres(codec));
2537         stream_lowres = av_codec_get_max_lowres(codec);
2538     }
2539     av_codec_set_lowres(avctx, stream_lowres);
2540
2541 #if FF_API_EMU_EDGE
2542     if(stream_lowres) avctx->flags |= CODEC_FLAG_EMU_EDGE;
2543 #endif
2544     if (fast)
2545         avctx->flags2 |= AV_CODEC_FLAG2_FAST;
2546 #if FF_API_EMU_EDGE
2547     if(codec->capabilities & AV_CODEC_CAP_DR1)
2548         avctx->flags |= CODEC_FLAG_EMU_EDGE;
2549 #endif
2550
2551     opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
2552     if (!av_dict_get(opts, "threads", NULL, 0))
2553         av_dict_set(&opts, "threads", "auto", 0);
2554     if (stream_lowres)
2555         av_dict_set_int(&opts, "lowres", stream_lowres, 0);
2556     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
2557         av_dict_set(&opts, "refcounted_frames", "1", 0);
2558     if ((ret = avcodec_open2(avctx, codec, &opts)) < 0) {
2559         goto fail;
2560     }
2561     if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2562         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2563         ret =  AVERROR_OPTION_NOT_FOUND;
2564         goto fail;
2565     }
2566
2567     is->eof = 0;
2568     ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
2569     switch (avctx->codec_type) {
2570     case AVMEDIA_TYPE_AUDIO:
2571 #if CONFIG_AVFILTER
2572         {
2573             AVFilterContext *sink;
2574
2575             is->audio_filter_src.freq           = avctx->sample_rate;
2576             is->audio_filter_src.channels       = avctx->channels;
2577             is->audio_filter_src.channel_layout = get_valid_channel_layout(avctx->channel_layout, avctx->channels);
2578             is->audio_filter_src.fmt            = avctx->sample_fmt;
2579             if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
2580                 goto fail;
2581             sink = is->out_audio_filter;
2582             sample_rate    = av_buffersink_get_sample_rate(sink);
2583             nb_channels    = av_buffersink_get_channels(sink);
2584             channel_layout = av_buffersink_get_channel_layout(sink);
2585         }
2586 #else
2587         sample_rate    = avctx->sample_rate;
2588         nb_channels    = avctx->channels;
2589         channel_layout = avctx->channel_layout;
2590 #endif
2591
2592         /* prepare audio output */
2593         if ((ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)) < 0)
2594             goto fail;
2595         is->audio_hw_buf_size = ret;
2596         is->audio_src = is->audio_tgt;
2597         is->audio_buf_size  = 0;
2598         is->audio_buf_index = 0;
2599
2600         /* init averaging filter */
2601         is->audio_diff_avg_coef  = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
2602         is->audio_diff_avg_count = 0;
2603         /* since we do not have a precise anough audio FIFO fullness,
2604            we correct audio sync only if larger than this threshold */
2605         is->audio_diff_threshold = (double)(is->audio_hw_buf_size) / is->audio_tgt.bytes_per_sec;
2606
2607         is->audio_stream = stream_index;
2608         is->audio_st = ic->streams[stream_index];
2609
2610         decoder_init(&is->auddec, avctx, &is->audioq, is->continue_read_thread);
2611         if ((is->ic->iformat->flags & (AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH | AVFMT_NO_BYTE_SEEK)) && !is->ic->iformat->read_seek) {
2612             is->auddec.start_pts = is->audio_st->start_time;
2613             is->auddec.start_pts_tb = is->audio_st->time_base;
2614         }
2615         if ((ret = decoder_start(&is->auddec, audio_thread, is)) < 0)
2616             goto out;
2617         SDL_PauseAudio(0);
2618         break;
2619     case AVMEDIA_TYPE_VIDEO:
2620         is->video_stream = stream_index;
2621         is->video_st = ic->streams[stream_index];
2622
2623         decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread);
2624         if ((ret = decoder_start(&is->viddec, video_thread, is)) < 0)
2625             goto out;
2626         is->queue_attachments_req = 1;
2627         break;
2628     case AVMEDIA_TYPE_SUBTITLE:
2629         is->subtitle_stream = stream_index;
2630         is->subtitle_st = ic->streams[stream_index];
2631
2632         decoder_init(&is->subdec, avctx, &is->subtitleq, is->continue_read_thread);
2633         if ((ret = decoder_start(&is->subdec, subtitle_thread, is)) < 0)
2634             goto out;
2635         break;
2636     default:
2637         break;
2638     }
2639     goto out;
2640
2641 fail:
2642     avcodec_free_context(&avctx);
2643 out:
2644     av_dict_free(&opts);
2645
2646     return ret;
2647 }
2648
2649 static int decode_interrupt_cb(void *ctx)
2650 {
2651     VideoState *is = ctx;
2652     return is->abort_request;
2653 }
2654
2655 static int stream_has_enough_packets(AVStream *st, int stream_id, PacketQueue *queue) {
2656     return stream_id < 0 ||
2657            queue->abort_request ||
2658            (st->disposition & AV_DISPOSITION_ATTACHED_PIC) ||
2659            queue->nb_packets > MIN_FRAMES && (!queue->duration || av_q2d(st->time_base) * queue->duration > 1.0);
2660 }
2661
2662 static int is_realtime(AVFormatContext *s)
2663 {
2664     if(   !strcmp(s->iformat->name, "rtp")
2665        || !strcmp(s->iformat->name, "rtsp")
2666        || !strcmp(s->iformat->name, "sdp")
2667     )
2668         return 1;
2669
2670     if(s->pb && (   !strncmp(s->filename, "rtp:", 4)
2671                  || !strncmp(s->filename, "udp:", 4)
2672                 )
2673     )
2674         return 1;
2675     return 0;
2676 }
2677
2678 /* this thread gets the stream from the disk or the network */
2679 static int read_thread(void *arg)
2680 {
2681     VideoState *is = arg;
2682     AVFormatContext *ic = NULL;
2683     int err, i, ret;
2684     int st_index[AVMEDIA_TYPE_NB];
2685     AVPacket pkt1, *pkt = &pkt1;
2686     int64_t stream_start_time;
2687     int pkt_in_play_range = 0;
2688     AVDictionaryEntry *t;
2689     AVDictionary **opts;
2690     int orig_nb_streams;
2691     SDL_mutex *wait_mutex = SDL_CreateMutex();
2692     int scan_all_pmts_set = 0;
2693     int64_t pkt_ts;
2694
2695     if (!wait_mutex) {
2696         av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
2697         ret = AVERROR(ENOMEM);
2698         goto fail;
2699     }
2700
2701     memset(st_index, -1, sizeof(st_index));
2702     is->last_video_stream = is->video_stream = -1;
2703     is->last_audio_stream = is->audio_stream = -1;
2704     is->last_subtitle_stream = is->subtitle_stream = -1;
2705     is->eof = 0;
2706
2707     ic = avformat_alloc_context();
2708     if (!ic) {
2709         av_log(NULL, AV_LOG_FATAL, "Could not allocate context.\n");
2710         ret = AVERROR(ENOMEM);
2711         goto fail;
2712     }
2713     ic->interrupt_callback.callback = decode_interrupt_cb;
2714     ic->interrupt_callback.opaque = is;
2715     if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
2716         av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
2717         scan_all_pmts_set = 1;
2718     }
2719     err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
2720     if (err < 0) {
2721         print_error(is->filename, err);
2722         ret = -1;
2723         goto fail;
2724     }
2725     if (scan_all_pmts_set)
2726         av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
2727
2728     if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2729         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2730         ret = AVERROR_OPTION_NOT_FOUND;
2731         goto fail;
2732     }
2733     is->ic = ic;
2734
2735     if (genpts)
2736         ic->flags |= AVFMT_FLAG_GENPTS;
2737
2738     av_format_inject_global_side_data(ic);
2739
2740     opts = setup_find_stream_info_opts(ic, codec_opts);
2741     orig_nb_streams = ic->nb_streams;
2742
2743     err = avformat_find_stream_info(ic, opts);
2744
2745     for (i = 0; i < orig_nb_streams; i++)
2746         av_dict_free(&opts[i]);
2747     av_freep(&opts);
2748
2749     if (err < 0) {
2750         av_log(NULL, AV_LOG_WARNING,
2751                "%s: could not find codec parameters\n", is->filename);
2752         ret = -1;
2753         goto fail;
2754     }
2755
2756     if (ic->pb)
2757         ic->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use avio_feof() to test for the end
2758
2759     if (seek_by_bytes < 0)
2760         seek_by_bytes = !!(ic->iformat->flags & AVFMT_TS_DISCONT) && strcmp("ogg", ic->iformat->name);
2761
2762     is->max_frame_duration = (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;
2763
2764     if (!window_title && (t = av_dict_get(ic->metadata, "title", NULL, 0)))
2765         window_title = av_asprintf("%s - %s", t->value, input_filename);
2766
2767     /* if seeking requested, we execute it */
2768     if (start_time != AV_NOPTS_VALUE) {
2769         int64_t timestamp;
2770
2771         timestamp = start_time;
2772         /* add the stream start time */
2773         if (ic->start_time != AV_NOPTS_VALUE)
2774             timestamp += ic->start_time;
2775         ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
2776         if (ret < 0) {
2777             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2778                     is->filename, (double)timestamp / AV_TIME_BASE);
2779         }
2780     }
2781
2782     is->realtime = is_realtime(ic);
2783
2784     if (show_status)
2785         av_dump_format(ic, 0, is->filename, 0);
2786
2787     for (i = 0; i < ic->nb_streams; i++) {
2788         AVStream *st = ic->streams[i];
2789         enum AVMediaType type = st->codecpar->codec_type;
2790         st->discard = AVDISCARD_ALL;
2791         if (type >= 0 && wanted_stream_spec[type] && st_index[type] == -1)
2792             if (avformat_match_stream_specifier(ic, st, wanted_stream_spec[type]) > 0)
2793                 st_index[type] = i;
2794     }
2795     for (i = 0; i < AVMEDIA_TYPE_NB; i++) {
2796         if (wanted_stream_spec[i] && st_index[i] == -1) {
2797             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));
2798             st_index[i] = INT_MAX;
2799         }
2800     }
2801
2802     if (!video_disable)
2803         st_index[AVMEDIA_TYPE_VIDEO] =
2804             av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
2805                                 st_index[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
2806     if (!audio_disable)
2807         st_index[AVMEDIA_TYPE_AUDIO] =
2808             av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
2809                                 st_index[AVMEDIA_TYPE_AUDIO],
2810                                 st_index[AVMEDIA_TYPE_VIDEO],
2811                                 NULL, 0);
2812     if (!video_disable && !subtitle_disable)
2813         st_index[AVMEDIA_TYPE_SUBTITLE] =
2814             av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
2815                                 st_index[AVMEDIA_TYPE_SUBTITLE],
2816                                 (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
2817                                  st_index[AVMEDIA_TYPE_AUDIO] :
2818                                  st_index[AVMEDIA_TYPE_VIDEO]),
2819                                 NULL, 0);
2820
2821     is->show_mode = show_mode;
2822     if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2823         AVStream *st = ic->streams[st_index[AVMEDIA_TYPE_VIDEO]];
2824         AVCodecParameters *codecpar = st->codecpar;
2825         AVRational sar = av_guess_sample_aspect_ratio(ic, st, NULL);
2826         if (codecpar->width)
2827             set_default_window_size(codecpar->width, codecpar->height, sar);
2828     }
2829
2830     /* open the streams */
2831     if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
2832         stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
2833     }
2834
2835     ret = -1;
2836     if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2837         ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
2838     }
2839     if (is->show_mode == SHOW_MODE_NONE)
2840         is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
2841
2842     if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
2843         stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
2844     }
2845
2846     if (is->video_stream < 0 && is->audio_stream < 0) {
2847         av_log(NULL, AV_LOG_FATAL, "Failed to open file '%s' or configure filtergraph\n",
2848                is->filename);
2849         ret = -1;
2850         goto fail;
2851     }
2852
2853     if (infinite_buffer < 0 && is->realtime)
2854         infinite_buffer = 1;
2855
2856     for (;;) {
2857         if (is->abort_request)
2858             break;
2859         if (is->paused != is->last_paused) {
2860             is->last_paused = is->paused;
2861             if (is->paused)
2862                 is->read_pause_return = av_read_pause(ic);
2863             else
2864                 av_read_play(ic);
2865         }
2866 #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
2867         if (is->paused &&
2868                 (!strcmp(ic->iformat->name, "rtsp") ||
2869                  (ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
2870             /* wait 10 ms to avoid trying to get another packet */
2871             /* XXX: horrible */
2872             SDL_Delay(10);
2873             continue;
2874         }
2875 #endif
2876         if (is->seek_req) {
2877             int64_t seek_target = is->seek_pos;
2878             int64_t seek_min    = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
2879             int64_t seek_max    = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
2880 // FIXME the +-2 is due to rounding being not done in the correct direction in generation
2881 //      of the seek_pos/seek_rel variables
2882
2883             ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
2884             if (ret < 0) {
2885                 av_log(NULL, AV_LOG_ERROR,
2886                        "%s: error while seeking\n", is->ic->filename);
2887             } else {
2888                 if (is->audio_stream >= 0) {
2889                     packet_queue_flush(&is->audioq);
2890                     packet_queue_put(&is->audioq, &flush_pkt);
2891                 }
2892                 if (is->subtitle_stream >= 0) {
2893                     packet_queue_flush(&is->subtitleq);
2894                     packet_queue_put(&is->subtitleq, &flush_pkt);
2895                 }
2896                 if (is->video_stream >= 0) {
2897                     packet_queue_flush(&is->videoq);
2898                     packet_queue_put(&is->videoq, &flush_pkt);
2899                 }
2900                 if (is->seek_flags & AVSEEK_FLAG_BYTE) {
2901                    set_clock(&is->extclk, NAN, 0);
2902                 } else {
2903                    set_clock(&is->extclk, seek_target / (double)AV_TIME_BASE, 0);
2904                 }
2905             }
2906             is->seek_req = 0;
2907             is->queue_attachments_req = 1;
2908             is->eof = 0;
2909             if (is->paused)
2910                 step_to_next_frame(is);
2911         }
2912         if (is->queue_attachments_req) {
2913             if (is->video_st && is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC) {
2914                 AVPacket copy;
2915                 if ((ret = av_copy_packet(&copy, &is->video_st->attached_pic)) < 0)
2916                     goto fail;
2917                 packet_queue_put(&is->videoq, &copy);
2918                 packet_queue_put_nullpacket(&is->videoq, is->video_stream);
2919             }
2920             is->queue_attachments_req = 0;
2921         }
2922
2923         /* if the queue are full, no need to read more */
2924         if (infinite_buffer<1 &&
2925               (is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
2926             || (stream_has_enough_packets(is->audio_st, is->audio_stream, &is->audioq) &&
2927                 stream_has_enough_packets(is->video_st, is->video_stream, &is->videoq) &&
2928                 stream_has_enough_packets(is->subtitle_st, is->subtitle_stream, &is->subtitleq)))) {
2929             /* wait 10 ms */
2930             SDL_LockMutex(wait_mutex);
2931             SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
2932             SDL_UnlockMutex(wait_mutex);
2933             continue;
2934         }
2935         if (!is->paused &&
2936             (!is->audio_st || (is->auddec.finished == is->audioq.serial && frame_queue_nb_remaining(&is->sampq) == 0)) &&
2937             (!is->video_st || (is->viddec.finished == is->videoq.serial && frame_queue_nb_remaining(&is->pictq) == 0))) {
2938             if (loop != 1 && (!loop || --loop)) {
2939                 stream_seek(is, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
2940             } else if (autoexit) {
2941                 ret = AVERROR_EOF;
2942                 goto fail;
2943             }
2944         }
2945         ret = av_read_frame(ic, pkt);
2946         if (ret < 0) {
2947             if ((ret == AVERROR_EOF || avio_feof(ic->pb)) && !is->eof) {
2948                 if (is->video_stream >= 0)
2949                     packet_queue_put_nullpacket(&is->videoq, is->video_stream);
2950                 if (is->audio_stream >= 0)
2951                     packet_queue_put_nullpacket(&is->audioq, is->audio_stream);
2952                 if (is->subtitle_stream >= 0)
2953                     packet_queue_put_nullpacket(&is->subtitleq, is->subtitle_stream);
2954                 is->eof = 1;
2955             }
2956             if (ic->pb && ic->pb->error)
2957                 break;
2958             SDL_LockMutex(wait_mutex);
2959             SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
2960             SDL_UnlockMutex(wait_mutex);
2961             continue;
2962         } else {
2963             is->eof = 0;
2964         }
2965         /* check if packet is in play range specified by user, then queue, otherwise discard */
2966         stream_start_time = ic->streams[pkt->stream_index]->start_time;
2967         pkt_ts = pkt->pts == AV_NOPTS_VALUE ? pkt->dts : pkt->pts;
2968         pkt_in_play_range = duration == AV_NOPTS_VALUE ||
2969                 (pkt_ts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
2970                 av_q2d(ic->streams[pkt->stream_index]->time_base) -
2971                 (double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
2972                 <= ((double)duration / 1000000);
2973         if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
2974             packet_queue_put(&is->audioq, pkt);
2975         } else if (pkt->stream_index == is->video_stream && pkt_in_play_range
2976                    && !(is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
2977             packet_queue_put(&is->videoq, pkt);
2978         } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
2979             packet_queue_put(&is->subtitleq, pkt);
2980         } else {
2981             av_packet_unref(pkt);
2982         }
2983     }
2984
2985     ret = 0;
2986  fail:
2987     if (ic && !is->ic)
2988         avformat_close_input(&ic);
2989
2990     if (ret != 0) {
2991         SDL_Event event;
2992
2993         event.type = FF_QUIT_EVENT;
2994         event.user.data1 = is;
2995         SDL_PushEvent(&event);
2996     }
2997     SDL_DestroyMutex(wait_mutex);
2998     return 0;
2999 }
3000
3001 static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
3002 {
3003     VideoState *is;
3004
3005     is = av_mallocz(sizeof(VideoState));
3006     if (!is)
3007         return NULL;
3008     is->filename = av_strdup(filename);
3009     if (!is->filename)
3010         goto fail;
3011     is->iformat = iformat;
3012     is->ytop    = 0;
3013     is->xleft   = 0;
3014
3015     /* start video display */
3016     if (frame_queue_init(&is->pictq, &is->videoq, VIDEO_PICTURE_QUEUE_SIZE, 1) < 0)
3017         goto fail;
3018     if (frame_queue_init(&is->subpq, &is->subtitleq, SUBPICTURE_QUEUE_SIZE, 0) < 0)
3019         goto fail;
3020     if (frame_queue_init(&is->sampq, &is->audioq, SAMPLE_QUEUE_SIZE, 1) < 0)
3021         goto fail;
3022
3023     if (packet_queue_init(&is->videoq) < 0 ||
3024         packet_queue_init(&is->audioq) < 0 ||
3025         packet_queue_init(&is->subtitleq) < 0)
3026         goto fail;
3027
3028     if (!(is->continue_read_thread = SDL_CreateCond())) {
3029         av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
3030         goto fail;
3031     }
3032
3033     init_clock(&is->vidclk, &is->videoq.serial);
3034     init_clock(&is->audclk, &is->audioq.serial);
3035     init_clock(&is->extclk, &is->extclk.serial);
3036     is->audio_clock_serial = -1;
3037     if (startup_volume < 0)
3038         av_log(NULL, AV_LOG_WARNING, "-volume=%d < 0, setting to 0\n", startup_volume);
3039     if (startup_volume > 100)
3040         av_log(NULL, AV_LOG_WARNING, "-volume=%d > 100, setting to 100\n", startup_volume);
3041     startup_volume = av_clip(startup_volume, 0, 100);
3042     startup_volume = av_clip(SDL_MIX_MAXVOLUME * startup_volume / 100, 0, SDL_MIX_MAXVOLUME);
3043     is->audio_volume = startup_volume;
3044     is->muted = 0;
3045     is->av_sync_type = av_sync_type;
3046     is->read_tid     = SDL_CreateThread(read_thread, "read_thread", is);
3047     if (!is->read_tid) {
3048         av_log(NULL, AV_LOG_FATAL, "SDL_CreateThread(): %s\n", SDL_GetError());
3049 fail:
3050         stream_close(is);
3051         return NULL;
3052     }
3053     return is;
3054 }
3055
3056 static void stream_cycle_channel(VideoState *is, int codec_type)
3057 {
3058     AVFormatContext *ic = is->ic;
3059     int start_index, stream_index;
3060     int old_index;
3061     AVStream *st;
3062     AVProgram *p = NULL;
3063     int nb_streams = is->ic->nb_streams;
3064
3065     if (codec_type == AVMEDIA_TYPE_VIDEO) {
3066         start_index = is->last_video_stream;
3067         old_index = is->video_stream;
3068     } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
3069         start_index = is->last_audio_stream;
3070         old_index = is->audio_stream;
3071     } else {
3072         start_index = is->last_subtitle_stream;
3073         old_index = is->subtitle_stream;
3074     }
3075     stream_index = start_index;
3076
3077     if (codec_type != AVMEDIA_TYPE_VIDEO && is->video_stream != -1) {
3078         p = av_find_program_from_stream(ic, NULL, is->video_stream);
3079         if (p) {
3080             nb_streams = p->nb_stream_indexes;
3081             for (start_index = 0; start_index < nb_streams; start_index++)
3082                 if (p->stream_index[start_index] == stream_index)
3083                     break;
3084             if (start_index == nb_streams)
3085                 start_index = -1;
3086             stream_index = start_index;
3087         }
3088     }
3089
3090     for (;;) {
3091         if (++stream_index >= nb_streams)
3092         {
3093             if (codec_type == AVMEDIA_TYPE_SUBTITLE)
3094             {
3095                 stream_index = -1;
3096                 is->last_subtitle_stream = -1;
3097                 goto the_end;
3098             }
3099             if (start_index == -1)
3100                 return;
3101             stream_index = 0;
3102         }
3103         if (stream_index == start_index)
3104             return;
3105         st = is->ic->streams[p ? p->stream_index[stream_index] : stream_index];
3106         if (st->codecpar->codec_type == codec_type) {
3107             /* check that parameters are OK */
3108             switch (codec_type) {
3109             case AVMEDIA_TYPE_AUDIO:
3110                 if (st->codecpar->sample_rate != 0 &&
3111                     st->codecpar->channels != 0)
3112                     goto the_end;
3113                 break;
3114             case AVMEDIA_TYPE_VIDEO:
3115             case AVMEDIA_TYPE_SUBTITLE:
3116                 goto the_end;
3117             default:
3118                 break;
3119             }
3120         }
3121     }
3122  the_end:
3123     if (p && stream_index != -1)
3124         stream_index = p->stream_index[stream_index];
3125     av_log(NULL, AV_LOG_INFO, "Switch %s stream from #%d to #%d\n",
3126            av_get_media_type_string(codec_type),
3127            old_index,
3128            stream_index);
3129
3130     stream_component_close(is, old_index);
3131     stream_component_open(is, stream_index);
3132 }
3133
3134
3135 static void toggle_full_screen(VideoState *is)
3136 {
3137     is_full_screen = !is_full_screen;
3138     SDL_SetWindowFullscreen(window, is_full_screen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
3139 }
3140
3141 static void toggle_audio_display(VideoState *is)
3142 {
3143     int next = is->show_mode;
3144     do {
3145         next = (next + 1) % SHOW_MODE_NB;
3146     } while (next != is->show_mode && (next == SHOW_MODE_VIDEO && !is->video_st || next != SHOW_MODE_VIDEO && !is->audio_st));
3147     if (is->show_mode != next) {
3148         is->force_refresh = 1;
3149         is->show_mode = next;
3150     }
3151 }
3152
3153 static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
3154     double remaining_time = 0.0;
3155     SDL_PumpEvents();
3156     while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) {
3157         if (!cursor_hidden && av_gettime_relative() - cursor_last_shown > CURSOR_HIDE_DELAY) {
3158             SDL_ShowCursor(0);
3159             cursor_hidden = 1;
3160         }
3161         if (remaining_time > 0.0)
3162             av_usleep((int64_t)(remaining_time * 1000000.0));
3163         remaining_time = REFRESH_RATE;
3164         if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
3165             video_refresh(is, &remaining_time);
3166         SDL_PumpEvents();
3167     }
3168 }
3169
3170 static void seek_chapter(VideoState *is, int incr)
3171 {
3172     int64_t pos = get_master_clock(is) * AV_TIME_BASE;
3173     int i;
3174
3175     if (!is->ic->nb_chapters)
3176         return;
3177
3178     /* find the current chapter */
3179     for (i = 0; i < is->ic->nb_chapters; i++) {
3180         AVChapter *ch = is->ic->chapters[i];
3181         if (av_compare_ts(pos, AV_TIME_BASE_Q, ch->start, ch->time_base) < 0) {
3182             i--;
3183             break;
3184         }
3185     }
3186
3187     i += incr;
3188     i = FFMAX(i, 0);
3189     if (i >= is->ic->nb_chapters)
3190         return;
3191
3192     av_log(NULL, AV_LOG_VERBOSE, "Seeking to chapter %d.\n", i);
3193     stream_seek(is, av_rescale_q(is->ic->chapters[i]->start, is->ic->chapters[i]->time_base,
3194                                  AV_TIME_BASE_Q), 0, 0);
3195 }
3196
3197 /* handle an event sent by the GUI */
3198 static void event_loop(VideoState *cur_stream)
3199 {
3200     SDL_Event event;
3201     double incr, pos, frac;
3202
3203     for (;;) {
3204         double x;
3205         refresh_loop_wait_event(cur_stream, &event);
3206         switch (event.type) {
3207         case SDL_KEYDOWN:
3208             if (exit_on_keydown) {
3209                 do_exit(cur_stream);
3210                 break;
3211             }
3212             switch (event.key.keysym.sym) {
3213             case SDLK_ESCAPE:
3214             case SDLK_q:
3215                 do_exit(cur_stream);
3216                 break;
3217             case SDLK_f:
3218                 toggle_full_screen(cur_stream);
3219                 cur_stream->force_refresh = 1;
3220                 break;
3221             case SDLK_p:
3222             case SDLK_SPACE:
3223                 toggle_pause(cur_stream);
3224                 break;
3225             case SDLK_m:
3226                 toggle_mute(cur_stream);
3227                 break;
3228             case SDLK_KP_MULTIPLY:
3229             case SDLK_0:
3230                 update_volume(cur_stream, 1, SDL_VOLUME_STEP);
3231                 break;
3232             case SDLK_KP_DIVIDE:
3233             case SDLK_9:
3234                 update_volume(cur_stream, -1, SDL_VOLUME_STEP);
3235                 break;
3236             case SDLK_s: // S: Step to next frame
3237                 step_to_next_frame(cur_stream);
3238                 break;
3239             case SDLK_a:
3240                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3241                 break;
3242             case SDLK_v:
3243                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3244                 break;
3245             case SDLK_c:
3246                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3247                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3248                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3249                 break;
3250             case SDLK_t:
3251                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3252                 break;
3253             case SDLK_w:
3254 #if CONFIG_AVFILTER
3255                 if (cur_stream->show_mode == SHOW_MODE_VIDEO && cur_stream->vfilter_idx < nb_vfilters - 1) {
3256                     if (++cur_stream->vfilter_idx >= nb_vfilters)
3257                         cur_stream->vfilter_idx = 0;
3258                 } else {
3259                     cur_stream->vfilter_idx = 0;
3260                     toggle_audio_display(cur_stream);
3261                 }
3262 #else
3263                 toggle_audio_display(cur_stream);
3264 #endif
3265                 break;
3266             case SDLK_PAGEUP:
3267                 if (cur_stream->ic->nb_chapters <= 1) {
3268                     incr = 600.0;
3269                     goto do_seek;
3270                 }
3271                 seek_chapter(cur_stream, 1);
3272                 break;
3273             case SDLK_PAGEDOWN:
3274                 if (cur_stream->ic->nb_chapters <= 1) {
3275                     incr = -600.0;
3276                     goto do_seek;
3277                 }
3278                 seek_chapter(cur_stream, -1);
3279                 break;
3280             case SDLK_LEFT:
3281                 incr = -10.0;
3282                 goto do_seek;
3283             case SDLK_RIGHT:
3284                 incr = 10.0;
3285                 goto do_seek;
3286             case SDLK_UP:
3287                 incr = 60.0;
3288                 goto do_seek;
3289             case SDLK_DOWN:
3290                 incr = -60.0;
3291             do_seek:
3292                     if (seek_by_bytes) {
3293                         pos = -1;
3294                         if (pos < 0 && cur_stream->video_stream >= 0)
3295                             pos = frame_queue_last_pos(&cur_stream->pictq);
3296                         if (pos < 0 && cur_stream->audio_stream >= 0)
3297                             pos = frame_queue_last_pos(&cur_stream->sampq);
3298                         if (pos < 0)
3299                             pos = avio_tell(cur_stream->ic->pb);
3300                         if (cur_stream->ic->bit_rate)
3301                             incr *= cur_stream->ic->bit_rate / 8.0;
3302                         else
3303                             incr *= 180000.0;
3304                         pos += incr;
3305                         stream_seek(cur_stream, pos, incr, 1);
3306                     } else {
3307                         pos = get_master_clock(cur_stream);
3308                         if (isnan(pos))
3309                             pos = (double)cur_stream->seek_pos / AV_TIME_BASE;
3310                         pos += incr;
3311                         if (cur_stream->ic->start_time != AV_NOPTS_VALUE && pos < cur_stream->ic->start_time / (double)AV_TIME_BASE)
3312                             pos = cur_stream->ic->start_time / (double)AV_TIME_BASE;
3313                         stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE), 0);
3314                     }
3315                 break;
3316             default:
3317                 break;
3318             }
3319             break;
3320         case SDL_MOUSEBUTTONDOWN:
3321             if (exit_on_mousedown) {
3322                 do_exit(cur_stream);
3323                 break;
3324             }
3325             if (event.button.button == SDL_BUTTON_LEFT) {
3326                 static int64_t last_mouse_left_click = 0;
3327                 if (av_gettime_relative() - last_mouse_left_click <= 500000) {
3328                     toggle_full_screen(cur_stream);
3329                     cur_stream->force_refresh = 1;
3330                     last_mouse_left_click = 0;
3331                 } else {
3332                     last_mouse_left_click = av_gettime_relative();
3333                 }
3334             }
3335         case SDL_MOUSEMOTION:
3336             if (cursor_hidden) {
3337                 SDL_ShowCursor(1);
3338                 cursor_hidden = 0;
3339             }
3340             cursor_last_shown = av_gettime_relative();
3341             if (event.type == SDL_MOUSEBUTTONDOWN) {
3342                 if (event.button.button != SDL_BUTTON_RIGHT)
3343                     break;
3344                 x = event.button.x;
3345             } else {
3346                 if (!(event.motion.state & SDL_BUTTON_RMASK))
3347                     break;
3348                 x = event.motion.x;
3349             }
3350                 if (seek_by_bytes || cur_stream->ic->duration <= 0) {
3351                     uint64_t size =  avio_size(cur_stream->ic->pb);
3352                     stream_seek(cur_stream, size*x/cur_stream->width, 0, 1);
3353                 } else {
3354                     int64_t ts;
3355                     int ns, hh, mm, ss;
3356                     int tns, thh, tmm, tss;
3357                     tns  = cur_stream->ic->duration / 1000000LL;
3358                     thh  = tns / 3600;
3359                     tmm  = (tns % 3600) / 60;
3360                     tss  = (tns % 60);
3361                     frac = x / cur_stream->width;
3362                     ns   = frac * tns;
3363                     hh   = ns / 3600;
3364                     mm   = (ns % 3600) / 60;
3365                     ss   = (ns % 60);
3366                     av_log(NULL, AV_LOG_INFO,
3367                            "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d)       \n", frac*100,
3368                             hh, mm, ss, thh, tmm, tss);
3369                     ts = frac * cur_stream->ic->duration;
3370                     if (cur_stream->ic->start_time != AV_NOPTS_VALUE)
3371                         ts += cur_stream->ic->start_time;
3372                     stream_seek(cur_stream, ts, 0, 0);
3373                 }
3374             break;
3375         case SDL_WINDOWEVENT:
3376             switch (event.window.event) {
3377                 case SDL_WINDOWEVENT_RESIZED:
3378                     screen_width  = cur_stream->width  = event.window.data1;
3379                     screen_height = cur_stream->height = event.window.data2;
3380                     if (cur_stream->vis_texture) {
3381                         SDL_DestroyTexture(cur_stream->vis_texture);
3382                         cur_stream->vis_texture = NULL;
3383                     }
3384                 case SDL_WINDOWEVENT_EXPOSED:
3385                     cur_stream->force_refresh = 1;
3386             }
3387             break;
3388         case SDL_QUIT:
3389         case FF_QUIT_EVENT:
3390             do_exit(cur_stream);
3391             break;
3392         default:
3393             break;
3394         }
3395     }
3396 }
3397
3398 static int opt_frame_size(void *optctx, const char *opt, const char *arg)
3399 {
3400     av_log(NULL, AV_LOG_WARNING, "Option -s is deprecated, use -video_size.\n");
3401     return opt_default(NULL, "video_size", arg);
3402 }
3403
3404 static int opt_width(void *optctx, const char *opt, const char *arg)
3405 {
3406     screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3407     return 0;
3408 }
3409
3410 static int opt_height(void *optctx, const char *opt, const char *arg)
3411 {
3412     screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3413     return 0;
3414 }
3415
3416 static int opt_format(void *optctx, const char *opt, const char *arg)
3417 {
3418     file_iformat = av_find_input_format(arg);
3419     if (!file_iformat) {
3420         av_log(NULL, AV_LOG_FATAL, "Unknown input format: %s\n", arg);
3421         return AVERROR(EINVAL);
3422     }
3423     return 0;
3424 }
3425
3426 static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
3427 {
3428     av_log(NULL, AV_LOG_WARNING, "Option -pix_fmt is deprecated, use -pixel_format.\n");
3429     return opt_default(NULL, "pixel_format", arg);
3430 }
3431
3432 static int opt_sync(void *optctx, const char *opt, const char *arg)
3433 {
3434     if (!strcmp(arg, "audio"))
3435         av_sync_type = AV_SYNC_AUDIO_MASTER;
3436     else if (!strcmp(arg, "video"))
3437         av_sync_type = AV_SYNC_VIDEO_MASTER;
3438     else if (!strcmp(arg, "ext"))
3439         av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
3440     else {
3441         av_log(NULL, AV_LOG_ERROR, "Unknown value for %s: %s\n", opt, arg);
3442         exit(1);
3443     }
3444     return 0;
3445 }
3446
3447 static int opt_seek(void *optctx, const char *opt, const char *arg)
3448 {
3449     start_time = parse_time_or_die(opt, arg, 1);
3450     return 0;
3451 }
3452
3453 static int opt_duration(void *optctx, const char *opt, const char *arg)
3454 {
3455     duration = parse_time_or_die(opt, arg, 1);
3456     return 0;
3457 }
3458
3459 static int opt_show_mode(void *optctx, const char *opt, const char *arg)
3460 {
3461     show_mode = !strcmp(arg, "video") ? SHOW_MODE_VIDEO :
3462                 !strcmp(arg, "waves") ? SHOW_MODE_WAVES :
3463                 !strcmp(arg, "rdft" ) ? SHOW_MODE_RDFT  :
3464                 parse_number_or_die(opt, arg, OPT_INT, 0, SHOW_MODE_NB-1);
3465     return 0;
3466 }
3467
3468 static void opt_input_file(void *optctx, const char *filename)
3469 {
3470     if (input_filename) {
3471         av_log(NULL, AV_LOG_FATAL,
3472                "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3473                 filename, input_filename);
3474         exit(1);
3475     }
3476     if (!strcmp(filename, "-"))
3477         filename = "pipe:";
3478     input_filename = filename;
3479 }
3480
3481 static int opt_codec(void *optctx, const char *opt, const char *arg)
3482 {
3483    const char *spec = strchr(opt, ':');
3484    if (!spec) {
3485        av_log(NULL, AV_LOG_ERROR,
3486               "No media specifier was specified in '%s' in option '%s'\n",
3487                arg, opt);
3488        return AVERROR(EINVAL);
3489    }
3490    spec++;
3491    switch (spec[0]) {
3492    case 'a' :    audio_codec_name = arg; break;
3493    case 's' : subtitle_codec_name = arg; break;
3494    case 'v' :    video_codec_name = arg; break;
3495    default:
3496        av_log(NULL, AV_LOG_ERROR,
3497               "Invalid media specifier '%s' in option '%s'\n", spec, opt);
3498        return AVERROR(EINVAL);
3499    }
3500    return 0;
3501 }
3502
3503 static int dummy;
3504
3505 static const OptionDef options[] = {
3506 #include "cmdutils_common_opts.h"
3507     { "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
3508     { "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
3509     { "s", HAS_ARG | OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
3510     { "fs", OPT_BOOL, { &is_full_screen }, "force full screen" },
3511     { "an", OPT_BOOL, { &audio_disable }, "disable audio" },
3512     { "vn", OPT_BOOL, { &video_disable }, "disable video" },
3513     { "sn", OPT_BOOL, { &subtitle_disable }, "disable subtitling" },
3514     { "ast", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_specifier" },
3515     { "vst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_specifier" },
3516     { "sst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_specifier" },
3517     { "ss", HAS_ARG, { .func_arg = opt_seek }, "seek to a given position in seconds", "pos" },
3518     { "t", HAS_ARG, { .func_arg = opt_duration }, "play  \"duration\" seconds of audio/video", "duration" },
3519     { "bytes", OPT_INT | HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
3520     { "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
3521     { "noborder", OPT_BOOL, { &borderless }, "borderless window" },
3522     { "volume", OPT_INT | HAS_ARG, { &startup_volume}, "set startup volume 0=min 100=max", "volume" },
3523     { "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
3524     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
3525     { "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" },
3526     { "fast", OPT_BOOL | OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
3527     { "genpts", OPT_BOOL | OPT_EXPERT, { &genpts }, "generate pts", "" },
3528     { "drp", OPT_INT | HAS_ARG | OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
3529     { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, { &lowres }, "", "" },
3530     { "sync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
3531     { "autoexit", OPT_BOOL | OPT_EXPERT, { &autoexit }, "exit at the end", "" },
3532     { "exitonkeydown", OPT_BOOL | OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
3533     { "exitonmousedown", OPT_BOOL | OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
3534     { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
3535     { "framedrop", OPT_BOOL | OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
3536     { "infbuf", OPT_BOOL | OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
3537     { "window_title", OPT_STRING | HAS_ARG, { &window_title }, "set window title", "window title" },
3538 #if CONFIG_AVFILTER
3539     { "vf", OPT_EXPERT | HAS_ARG, { .func_arg = opt_add_vfilter }, "set video filters", "filter_graph" },
3540     { "af", OPT_STRING | HAS_ARG, { &afilters }, "set audio filters", "filter_graph" },
3541 #endif
3542     { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
3543     { "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
3544     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default }, "generic catch all option", "" },
3545     { "i", OPT_BOOL, { &dummy}, "read specified file", "input_file"},
3546     { "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
3547     { "acodec", HAS_ARG | OPT_STRING | OPT_EXPERT, {    &audio_codec_name }, "force audio decoder",    "decoder_name" },
3548     { "scodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
3549     { "vcodec", HAS_ARG | OPT_STRING | OPT_EXPERT, {    &video_codec_name }, "force video decoder",    "decoder_name" },
3550     { "autorotate", OPT_BOOL, { &autorotate }, "automatically rotate video", "" },
3551     { NULL, },
3552 };
3553
3554 static void show_usage(void)
3555 {
3556     av_log(NULL, AV_LOG_INFO, "Simple media player\n");
3557     av_log(NULL, AV_LOG_INFO, "usage: %s [options] input_file\n", program_name);
3558     av_log(NULL, AV_LOG_INFO, "\n");
3559 }
3560
3561 void show_help_default(const char *opt, const char *arg)
3562 {
3563     av_log_set_callback(log_callback_help);
3564     show_usage();
3565     show_help_options(options, "Main options:", 0, OPT_EXPERT, 0);
3566     show_help_options(options, "Advanced options:", OPT_EXPERT, 0, 0);
3567     printf("\n");
3568     show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3569     show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3570 #if !CONFIG_AVFILTER
3571     show_help_children(sws_get_class(), AV_OPT_FLAG_ENCODING_PARAM);
3572 #else
3573     show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
3574 #endif
3575     printf("\nWhile playing:\n"
3576            "q, ESC              quit\n"
3577            "f                   toggle full screen\n"
3578            "p, SPC              pause\n"
3579            "m                   toggle mute\n"
3580            "9, 0                decrease and increase volume respectively\n"
3581            "/, *                decrease and increase volume respectively\n"
3582            "a                   cycle audio channel in the current program\n"
3583            "v                   cycle video channel\n"
3584            "t                   cycle subtitle channel in the current program\n"
3585            "c                   cycle program\n"
3586            "w                   cycle video filters or show modes\n"
3587            "s                   activate frame-step mode\n"
3588            "left/right          seek backward/forward 10 seconds\n"
3589            "down/up             seek backward/forward 1 minute\n"
3590            "page down/page up   seek backward/forward 10 minutes\n"
3591            "right mouse click   seek to percentage in file corresponding to fraction of width\n"
3592            "left double-click   toggle full screen\n"
3593            );
3594 }
3595
3596 static int lockmgr(void **mtx, enum AVLockOp op)
3597 {
3598    switch(op) {
3599       case AV_LOCK_CREATE:
3600           *mtx = SDL_CreateMutex();
3601           if(!*mtx) {
3602               av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
3603               return 1;
3604           }
3605           return 0;
3606       case AV_LOCK_OBTAIN:
3607           return !!SDL_LockMutex(*mtx);
3608       case AV_LOCK_RELEASE:
3609           return !!SDL_UnlockMutex(*mtx);
3610       case AV_LOCK_DESTROY:
3611           SDL_DestroyMutex(*mtx);
3612           return 0;
3613    }
3614    return 1;
3615 }
3616
3617 /* Called from the main */
3618 int main(int argc, char **argv)
3619 {
3620     int flags;
3621     VideoState *is;
3622
3623     init_dynload();
3624
3625     av_log_set_flags(AV_LOG_SKIP_REPEATED);
3626     parse_loglevel(argc, argv, options);
3627
3628     /* register all codecs, demux and protocols */
3629 #if CONFIG_AVDEVICE
3630     avdevice_register_all();
3631 #endif
3632 #if CONFIG_AVFILTER
3633     avfilter_register_all();
3634 #endif
3635     av_register_all();
3636     avformat_network_init();
3637
3638     init_opts();
3639
3640     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
3641     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
3642
3643     show_banner(argc, argv, options);
3644
3645     parse_options(NULL, argc, argv, options, opt_input_file);
3646
3647     if (!input_filename) {
3648         show_usage();
3649         av_log(NULL, AV_LOG_FATAL, "An input file must be specified\n");
3650         av_log(NULL, AV_LOG_FATAL,
3651                "Use -h to get full help or, even better, run 'man %s'\n", program_name);
3652         exit(1);
3653     }
3654
3655     if (display_disable) {
3656         video_disable = 1;
3657     }
3658     flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
3659     if (audio_disable)
3660         flags &= ~SDL_INIT_AUDIO;
3661     else {
3662         /* Try to work around an occasional ALSA buffer underflow issue when the
3663          * period size is NPOT due to ALSA resampling by forcing the buffer size. */
3664         if (!SDL_getenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE"))
3665             SDL_setenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE","1", 1);
3666     }
3667     if (display_disable)
3668         flags &= ~SDL_INIT_VIDEO;
3669     if (SDL_Init (flags)) {
3670         av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n", SDL_GetError());
3671         av_log(NULL, AV_LOG_FATAL, "(Did you set the DISPLAY variable?)\n");
3672         exit(1);
3673     }
3674
3675     SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
3676     SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
3677
3678     if (av_lockmgr_register(lockmgr)) {
3679         av_log(NULL, AV_LOG_FATAL, "Could not initialize lock manager!\n");
3680         do_exit(NULL);
3681     }
3682
3683     av_init_packet(&flush_pkt);
3684     flush_pkt.data = (uint8_t *)&flush_pkt;
3685
3686     is = stream_open(input_filename, file_iformat);
3687     if (!is) {
3688         av_log(NULL, AV_LOG_FATAL, "Failed to initialize VideoState!\n");
3689         do_exit(NULL);
3690     }
3691
3692     event_loop(is);
3693
3694     /* never returns */
3695
3696     return 0;
3697 }