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