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