ffplay: log SDL error messages
[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(q, 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(q, 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_close(VideoState *is)
1136 {
1137     /* XXX: use a special url_shutdown call to abort parse cleanly */
1138     is->abort_request = 1;
1139     SDL_WaitThread(is->read_tid, NULL);
1140     packet_queue_destroy(&is->videoq);
1141     packet_queue_destroy(&is->audioq);
1142     packet_queue_destroy(&is->subtitleq);
1143
1144     /* free all pictures */
1145     frame_queue_destory(&is->pictq);
1146     frame_queue_destory(&is->sampq);
1147     frame_queue_destory(&is->subpq);
1148     SDL_DestroyCond(is->continue_read_thread);
1149 #if !CONFIG_AVFILTER
1150     sws_freeContext(is->img_convert_ctx);
1151 #endif
1152     sws_freeContext(is->sub_convert_ctx);
1153     av_free(is->filename);
1154     av_free(is);
1155 }
1156
1157 static void do_exit(VideoState *is)
1158 {
1159     if (is) {
1160         stream_close(is);
1161     }
1162     av_lockmgr_register(NULL);
1163     uninit_opts();
1164 #if CONFIG_AVFILTER
1165     av_freep(&vfilters_list);
1166 #endif
1167     avformat_network_deinit();
1168     if (show_status)
1169         printf("\n");
1170     SDL_Quit();
1171     av_log(NULL, AV_LOG_QUIET, "%s", "");
1172     exit(0);
1173 }
1174
1175 static void sigterm_handler(int sig)
1176 {
1177     exit(123);
1178 }
1179
1180 static void set_default_window_size(int width, int height, AVRational sar)
1181 {
1182     SDL_Rect rect;
1183     calculate_display_rect(&rect, 0, 0, INT_MAX, height, width, height, sar);
1184     default_width  = rect.w;
1185     default_height = rect.h;
1186 }
1187
1188 static int video_open(VideoState *is, int force_set_video_mode, Frame *vp)
1189 {
1190     int flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL;
1191     int w,h;
1192
1193     if (is_full_screen) flags |= SDL_FULLSCREEN;
1194     else                flags |= SDL_RESIZABLE;
1195
1196     if (vp && vp->width)
1197         set_default_window_size(vp->width, vp->height, vp->sar);
1198
1199     if (is_full_screen && fs_screen_width) {
1200         w = fs_screen_width;
1201         h = fs_screen_height;
1202     } else if (!is_full_screen && screen_width) {
1203         w = screen_width;
1204         h = screen_height;
1205     } else {
1206         w = default_width;
1207         h = default_height;
1208     }
1209     w = FFMIN(16383, w);
1210     if (screen && is->width == screen->w && screen->w == w
1211        && is->height== screen->h && screen->h == h && !force_set_video_mode)
1212         return 0;
1213     screen = SDL_SetVideoMode(w, h, 0, flags);
1214     if (!screen) {
1215         av_log(NULL, AV_LOG_FATAL, "SDL: could not set video mode - exiting\n");
1216         do_exit(is);
1217     }
1218     if (!window_title)
1219         window_title = input_filename;
1220     SDL_WM_SetCaption(window_title, window_title);
1221
1222     is->width  = screen->w;
1223     is->height = screen->h;
1224
1225     return 0;
1226 }
1227
1228 /* display the current picture, if any */
1229 static void video_display(VideoState *is)
1230 {
1231     if (!screen)
1232         video_open(is, 0, NULL);
1233     if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
1234         video_audio_display(is);
1235     else if (is->video_st)
1236         video_image_display(is);
1237 }
1238
1239 static double get_clock(Clock *c)
1240 {
1241     if (*c->queue_serial != c->serial)
1242         return NAN;
1243     if (c->paused) {
1244         return c->pts;
1245     } else {
1246         double time = av_gettime_relative() / 1000000.0;
1247         return c->pts_drift + time - (time - c->last_updated) * (1.0 - c->speed);
1248     }
1249 }
1250
1251 static void set_clock_at(Clock *c, double pts, int serial, double time)
1252 {
1253     c->pts = pts;
1254     c->last_updated = time;
1255     c->pts_drift = c->pts - time;
1256     c->serial = serial;
1257 }
1258
1259 static void set_clock(Clock *c, double pts, int serial)
1260 {
1261     double time = av_gettime_relative() / 1000000.0;
1262     set_clock_at(c, pts, serial, time);
1263 }
1264
1265 static void set_clock_speed(Clock *c, double speed)
1266 {
1267     set_clock(c, get_clock(c), c->serial);
1268     c->speed = speed;
1269 }
1270
1271 static void init_clock(Clock *c, int *queue_serial)
1272 {
1273     c->speed = 1.0;
1274     c->paused = 0;
1275     c->queue_serial = queue_serial;
1276     set_clock(c, NAN, -1);
1277 }
1278
1279 static void sync_clock_to_slave(Clock *c, Clock *slave)
1280 {
1281     double clock = get_clock(c);
1282     double slave_clock = get_clock(slave);
1283     if (!isnan(slave_clock) && (isnan(clock) || fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))
1284         set_clock(c, slave_clock, slave->serial);
1285 }
1286
1287 static int get_master_sync_type(VideoState *is) {
1288     if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
1289         if (is->video_st)
1290             return AV_SYNC_VIDEO_MASTER;
1291         else
1292             return AV_SYNC_AUDIO_MASTER;
1293     } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
1294         if (is->audio_st)
1295             return AV_SYNC_AUDIO_MASTER;
1296         else
1297             return AV_SYNC_EXTERNAL_CLOCK;
1298     } else {
1299         return AV_SYNC_EXTERNAL_CLOCK;
1300     }
1301 }
1302
1303 /* get the current master clock value */
1304 static double get_master_clock(VideoState *is)
1305 {
1306     double val;
1307
1308     switch (get_master_sync_type(is)) {
1309         case AV_SYNC_VIDEO_MASTER:
1310             val = get_clock(&is->vidclk);
1311             break;
1312         case AV_SYNC_AUDIO_MASTER:
1313             val = get_clock(&is->audclk);
1314             break;
1315         default:
1316             val = get_clock(&is->extclk);
1317             break;
1318     }
1319     return val;
1320 }
1321
1322 static void check_external_clock_speed(VideoState *is) {
1323    if (is->video_stream >= 0 && is->videoq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES ||
1324        is->audio_stream >= 0 && is->audioq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES) {
1325        set_clock_speed(&is->extclk, FFMAX(EXTERNAL_CLOCK_SPEED_MIN, is->extclk.speed - EXTERNAL_CLOCK_SPEED_STEP));
1326    } else if ((is->video_stream < 0 || is->videoq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES) &&
1327               (is->audio_stream < 0 || is->audioq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES)) {
1328        set_clock_speed(&is->extclk, FFMIN(EXTERNAL_CLOCK_SPEED_MAX, is->extclk.speed + EXTERNAL_CLOCK_SPEED_STEP));
1329    } else {
1330        double speed = is->extclk.speed;
1331        if (speed != 1.0)
1332            set_clock_speed(&is->extclk, speed + EXTERNAL_CLOCK_SPEED_STEP * (1.0 - speed) / fabs(1.0 - speed));
1333    }
1334 }
1335
1336 /* seek in the stream */
1337 static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)
1338 {
1339     if (!is->seek_req) {
1340         is->seek_pos = pos;
1341         is->seek_rel = rel;
1342         is->seek_flags &= ~AVSEEK_FLAG_BYTE;
1343         if (seek_by_bytes)
1344             is->seek_flags |= AVSEEK_FLAG_BYTE;
1345         is->seek_req = 1;
1346         SDL_CondSignal(is->continue_read_thread);
1347     }
1348 }
1349
1350 /* pause or resume the video */
1351 static void stream_toggle_pause(VideoState *is)
1352 {
1353     if (is->paused) {
1354         is->frame_timer += av_gettime_relative() / 1000000.0 - is->vidclk.last_updated;
1355         if (is->read_pause_return != AVERROR(ENOSYS)) {
1356             is->vidclk.paused = 0;
1357         }
1358         set_clock(&is->vidclk, get_clock(&is->vidclk), is->vidclk.serial);
1359     }
1360     set_clock(&is->extclk, get_clock(&is->extclk), is->extclk.serial);
1361     is->paused = is->audclk.paused = is->vidclk.paused = is->extclk.paused = !is->paused;
1362 }
1363
1364 static void toggle_pause(VideoState *is)
1365 {
1366     stream_toggle_pause(is);
1367     is->step = 0;
1368 }
1369
1370 static void toggle_mute(VideoState *is)
1371 {
1372     is->muted = !is->muted;
1373 }
1374
1375 static void update_volume(VideoState *is, int sign, int step)
1376 {
1377     is->audio_volume = av_clip(is->audio_volume + sign * step, 0, SDL_MIX_MAXVOLUME);
1378 }
1379
1380 static void step_to_next_frame(VideoState *is)
1381 {
1382     /* if the stream is paused unpause it, then step */
1383     if (is->paused)
1384         stream_toggle_pause(is);
1385     is->step = 1;
1386 }
1387
1388 static double compute_target_delay(double delay, VideoState *is)
1389 {
1390     double sync_threshold, diff = 0;
1391
1392     /* update delay to follow master synchronisation source */
1393     if (get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER) {
1394         /* if video is slave, we try to correct big delays by
1395            duplicating or deleting a frame */
1396         diff = get_clock(&is->vidclk) - get_master_clock(is);
1397
1398         /* skip or repeat frame. We take into account the
1399            delay to compute the threshold. I still don't know
1400            if it is the best guess */
1401         sync_threshold = FFMAX(AV_SYNC_THRESHOLD_MIN, FFMIN(AV_SYNC_THRESHOLD_MAX, delay));
1402         if (!isnan(diff) && fabs(diff) < is->max_frame_duration) {
1403             if (diff <= -sync_threshold)
1404                 delay = FFMAX(0, delay + diff);
1405             else if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD)
1406                 delay = delay + diff;
1407             else if (diff >= sync_threshold)
1408                 delay = 2 * delay;
1409         }
1410     }
1411
1412     av_log(NULL, AV_LOG_TRACE, "video: delay=%0.3f A-V=%f\n",
1413             delay, -diff);
1414
1415     return delay;
1416 }
1417
1418 static double vp_duration(VideoState *is, Frame *vp, Frame *nextvp) {
1419     if (vp->serial == nextvp->serial) {
1420         double duration = nextvp->pts - vp->pts;
1421         if (isnan(duration) || duration <= 0 || duration > is->max_frame_duration)
1422             return vp->duration;
1423         else
1424             return duration;
1425     } else {
1426         return 0.0;
1427     }
1428 }
1429
1430 static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
1431     /* update current video pts */
1432     set_clock(&is->vidclk, pts, serial);
1433     sync_clock_to_slave(&is->extclk, &is->vidclk);
1434 }
1435
1436 /* called to display each frame */
1437 static void video_refresh(void *opaque, double *remaining_time)
1438 {
1439     VideoState *is = opaque;
1440     double time;
1441
1442     Frame *sp, *sp2;
1443
1444     if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
1445         check_external_clock_speed(is);
1446
1447     if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {
1448         time = av_gettime_relative() / 1000000.0;
1449         if (is->force_refresh || is->last_vis_time + rdftspeed < time) {
1450             video_display(is);
1451             is->last_vis_time = time;
1452         }
1453         *remaining_time = FFMIN(*remaining_time, is->last_vis_time + rdftspeed - time);
1454     }
1455
1456     if (is->video_st) {
1457         int redisplay = 0;
1458         if (is->force_refresh)
1459             redisplay = frame_queue_prev(&is->pictq);
1460 retry:
1461         if (frame_queue_nb_remaining(&is->pictq) == 0) {
1462             // nothing to do, no picture to display in the queue
1463         } else {
1464             double last_duration, duration, delay;
1465             Frame *vp, *lastvp;
1466
1467             /* dequeue the picture */
1468             lastvp = frame_queue_peek_last(&is->pictq);
1469             vp = frame_queue_peek(&is->pictq);
1470
1471             if (vp->serial != is->videoq.serial) {
1472                 frame_queue_next(&is->pictq);
1473                 redisplay = 0;
1474                 goto retry;
1475             }
1476
1477             if (lastvp->serial != vp->serial && !redisplay)
1478                 is->frame_timer = av_gettime_relative() / 1000000.0;
1479
1480             if (is->paused)
1481                 goto display;
1482
1483             /* compute nominal last_duration */
1484             last_duration = vp_duration(is, lastvp, vp);
1485             if (redisplay)
1486                 delay = 0.0;
1487             else
1488                 delay = compute_target_delay(last_duration, is);
1489
1490             time= av_gettime_relative()/1000000.0;
1491             if (time < is->frame_timer + delay && !redisplay) {
1492                 *remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);
1493                 return;
1494             }
1495
1496             is->frame_timer += delay;
1497             if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)
1498                 is->frame_timer = time;
1499
1500             SDL_LockMutex(is->pictq.mutex);
1501             if (!redisplay && !isnan(vp->pts))
1502                 update_video_pts(is, vp->pts, vp->pos, vp->serial);
1503             SDL_UnlockMutex(is->pictq.mutex);
1504
1505             if (frame_queue_nb_remaining(&is->pictq) > 1) {
1506                 Frame *nextvp = frame_queue_peek_next(&is->pictq);
1507                 duration = vp_duration(is, vp, nextvp);
1508                 if(!is->step && (redisplay || framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
1509                     if (!redisplay)
1510                         is->frame_drops_late++;
1511                     frame_queue_next(&is->pictq);
1512                     redisplay = 0;
1513                     goto retry;
1514                 }
1515             }
1516
1517             if (is->subtitle_st) {
1518                     while (frame_queue_nb_remaining(&is->subpq) > 0) {
1519                         sp = frame_queue_peek(&is->subpq);
1520
1521                         if (frame_queue_nb_remaining(&is->subpq) > 1)
1522                             sp2 = frame_queue_peek_next(&is->subpq);
1523                         else
1524                             sp2 = NULL;
1525
1526                         if (sp->serial != is->subtitleq.serial
1527                                 || (is->vidclk.pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1528                                 || (sp2 && is->vidclk.pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1529                         {
1530                             frame_queue_next(&is->subpq);
1531                         } else {
1532                             break;
1533                         }
1534                     }
1535             }
1536
1537 display:
1538             /* display picture */
1539             if (!display_disable && is->show_mode == SHOW_MODE_VIDEO)
1540                 video_display(is);
1541
1542             frame_queue_next(&is->pictq);
1543
1544             if (is->step && !is->paused)
1545                 stream_toggle_pause(is);
1546         }
1547     }
1548     is->force_refresh = 0;
1549     if (show_status) {
1550         static int64_t last_time;
1551         int64_t cur_time;
1552         int aqsize, vqsize, sqsize;
1553         double av_diff;
1554
1555         cur_time = av_gettime_relative();
1556         if (!last_time || (cur_time - last_time) >= 30000) {
1557             aqsize = 0;
1558             vqsize = 0;
1559             sqsize = 0;
1560             if (is->audio_st)
1561                 aqsize = is->audioq.size;
1562             if (is->video_st)
1563                 vqsize = is->videoq.size;
1564             if (is->subtitle_st)
1565                 sqsize = is->subtitleq.size;
1566             av_diff = 0;
1567             if (is->audio_st && is->video_st)
1568                 av_diff = get_clock(&is->audclk) - get_clock(&is->vidclk);
1569             else if (is->video_st)
1570                 av_diff = get_master_clock(is) - get_clock(&is->vidclk);
1571             else if (is->audio_st)
1572                 av_diff = get_master_clock(is) - get_clock(&is->audclk);
1573             av_log(NULL, AV_LOG_INFO,
1574                    "%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64"   \r",
1575                    get_master_clock(is),
1576                    (is->audio_st && is->video_st) ? "A-V" : (is->video_st ? "M-V" : (is->audio_st ? "M-A" : "   ")),
1577                    av_diff,
1578                    is->frame_drops_early + is->frame_drops_late,
1579                    aqsize / 1024,
1580                    vqsize / 1024,
1581                    sqsize,
1582                    is->video_st ? is->video_st->codec->pts_correction_num_faulty_dts : 0,
1583                    is->video_st ? is->video_st->codec->pts_correction_num_faulty_pts : 0);
1584             fflush(stdout);
1585             last_time = cur_time;
1586         }
1587     }
1588 }
1589
1590 /* allocate a picture (needs to do that in main thread to avoid
1591    potential locking problems */
1592 static void alloc_picture(VideoState *is)
1593 {
1594     Frame *vp;
1595     int64_t bufferdiff;
1596
1597     vp = &is->pictq.queue[is->pictq.windex];
1598
1599     free_picture(vp);
1600
1601     video_open(is, 0, vp);
1602
1603     vp->bmp = SDL_CreateYUVOverlay(vp->width, vp->height,
1604                                    SDL_YV12_OVERLAY,
1605                                    screen);
1606     bufferdiff = vp->bmp ? FFMAX(vp->bmp->pixels[0], vp->bmp->pixels[1]) - FFMIN(vp->bmp->pixels[0], vp->bmp->pixels[1]) : 0;
1607     if (!vp->bmp || vp->bmp->pitches[0] < vp->width || bufferdiff < (int64_t)vp->height * vp->bmp->pitches[0]) {
1608         /* SDL allocates a buffer smaller than requested if the video
1609          * overlay hardware is unable to support the requested size. */
1610         av_log(NULL, AV_LOG_FATAL,
1611                "Error: the video system does not support an image\n"
1612                         "size of %dx%d pixels. Try using -lowres or -vf \"scale=w:h\"\n"
1613                         "to reduce the image size.\n", vp->width, vp->height );
1614         do_exit(is);
1615     }
1616
1617     SDL_LockMutex(is->pictq.mutex);
1618     vp->allocated = 1;
1619     SDL_CondSignal(is->pictq.cond);
1620     SDL_UnlockMutex(is->pictq.mutex);
1621 }
1622
1623 static void duplicate_right_border_pixels(SDL_Overlay *bmp) {
1624     int i, width, height;
1625     Uint8 *p, *maxp;
1626     for (i = 0; i < 3; i++) {
1627         width  = bmp->w;
1628         height = bmp->h;
1629         if (i > 0) {
1630             width  >>= 1;
1631             height >>= 1;
1632         }
1633         if (bmp->pitches[i] > width) {
1634             maxp = bmp->pixels[i] + bmp->pitches[i] * height - 1;
1635             for (p = bmp->pixels[i] + width - 1; p < maxp; p += bmp->pitches[i])
1636                 *(p+1) = *p;
1637         }
1638     }
1639 }
1640
1641 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, double duration, int64_t pos, int serial)
1642 {
1643     Frame *vp;
1644
1645 #if defined(DEBUG_SYNC) && 0
1646     printf("frame_type=%c pts=%0.3f\n",
1647            av_get_picture_type_char(src_frame->pict_type), pts);
1648 #endif
1649
1650     if (!(vp = frame_queue_peek_writable(&is->pictq)))
1651         return -1;
1652
1653     vp->sar = src_frame->sample_aspect_ratio;
1654
1655     /* alloc or resize hardware picture buffer */
1656     if (!vp->bmp || vp->reallocate || !vp->allocated ||
1657         vp->width  != src_frame->width ||
1658         vp->height != src_frame->height) {
1659         SDL_Event event;
1660
1661         vp->allocated  = 0;
1662         vp->reallocate = 0;
1663         vp->width = src_frame->width;
1664         vp->height = src_frame->height;
1665
1666         /* the allocation must be done in the main thread to avoid
1667            locking problems. */
1668         event.type = FF_ALLOC_EVENT;
1669         event.user.data1 = is;
1670         SDL_PushEvent(&event);
1671
1672         /* wait until the picture is allocated */
1673         SDL_LockMutex(is->pictq.mutex);
1674         while (!vp->allocated && !is->videoq.abort_request) {
1675             SDL_CondWait(is->pictq.cond, is->pictq.mutex);
1676         }
1677         /* if the queue is aborted, we have to pop the pending ALLOC event or wait for the allocation to complete */
1678         if (is->videoq.abort_request && SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_EVENTMASK(FF_ALLOC_EVENT)) != 1) {
1679             while (!vp->allocated && !is->abort_request) {
1680                 SDL_CondWait(is->pictq.cond, is->pictq.mutex);
1681             }
1682         }
1683         SDL_UnlockMutex(is->pictq.mutex);
1684
1685         if (is->videoq.abort_request)
1686             return -1;
1687     }
1688
1689     /* if the frame is not skipped, then display it */
1690     if (vp->bmp) {
1691         AVPicture pict = { { 0 } };
1692
1693         /* get a pointer on the bitmap */
1694         SDL_LockYUVOverlay (vp->bmp);
1695
1696         pict.data[0] = vp->bmp->pixels[0];
1697         pict.data[1] = vp->bmp->pixels[2];
1698         pict.data[2] = vp->bmp->pixels[1];
1699
1700         pict.linesize[0] = vp->bmp->pitches[0];
1701         pict.linesize[1] = vp->bmp->pitches[2];
1702         pict.linesize[2] = vp->bmp->pitches[1];
1703
1704 #if CONFIG_AVFILTER
1705         // FIXME use direct rendering
1706         av_picture_copy(&pict, (AVPicture *)src_frame,
1707                         src_frame->format, vp->width, vp->height);
1708 #else
1709         {
1710             AVDictionaryEntry *e = av_dict_get(sws_dict, "sws_flags", NULL, 0);
1711             if (e) {
1712                 const AVClass *class = sws_get_class();
1713                 const AVOption    *o = av_opt_find(&class, "sws_flags", NULL, 0,
1714                                                    AV_OPT_SEARCH_FAKE_OBJ);
1715                 int ret = av_opt_eval_flags(&class, o, e->value, &sws_flags);
1716                 if (ret < 0)
1717                     exit(1);
1718             }
1719         }
1720
1721         is->img_convert_ctx = sws_getCachedContext(is->img_convert_ctx,
1722             vp->width, vp->height, src_frame->format, vp->width, vp->height,
1723             AV_PIX_FMT_YUV420P, sws_flags, NULL, NULL, NULL);
1724         if (!is->img_convert_ctx) {
1725             av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
1726             exit(1);
1727         }
1728         sws_scale(is->img_convert_ctx, src_frame->data, src_frame->linesize,
1729                   0, vp->height, pict.data, pict.linesize);
1730 #endif
1731         /* workaround SDL PITCH_WORKAROUND */
1732         duplicate_right_border_pixels(vp->bmp);
1733         /* update the bitmap content */
1734         SDL_UnlockYUVOverlay(vp->bmp);
1735
1736         vp->pts = pts;
1737         vp->duration = duration;
1738         vp->pos = pos;
1739         vp->serial = serial;
1740
1741         /* now we can update the picture count */
1742         frame_queue_push(&is->pictq);
1743     }
1744     return 0;
1745 }
1746
1747 static int get_video_frame(VideoState *is, AVFrame *frame)
1748 {
1749     int got_picture;
1750
1751     if ((got_picture = decoder_decode_frame(&is->viddec, frame, NULL)) < 0)
1752         return -1;
1753
1754     if (got_picture) {
1755         double dpts = NAN;
1756
1757         if (frame->pts != AV_NOPTS_VALUE)
1758             dpts = av_q2d(is->video_st->time_base) * frame->pts;
1759
1760         frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
1761
1762         is->viddec_width  = frame->width;
1763         is->viddec_height = frame->height;
1764
1765         if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
1766             if (frame->pts != AV_NOPTS_VALUE) {
1767                 double diff = dpts - get_master_clock(is);
1768                 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD &&
1769                     diff - is->frame_last_filter_delay < 0 &&
1770                     is->viddec.pkt_serial == is->vidclk.serial &&
1771                     is->videoq.nb_packets) {
1772                     is->frame_drops_early++;
1773                     av_frame_unref(frame);
1774                     got_picture = 0;
1775                 }
1776             }
1777         }
1778     }
1779
1780     return got_picture;
1781 }
1782
1783 #if CONFIG_AVFILTER
1784 static int configure_filtergraph(AVFilterGraph *graph, const char *filtergraph,
1785                                  AVFilterContext *source_ctx, AVFilterContext *sink_ctx)
1786 {
1787     int ret, i;
1788     int nb_filters = graph->nb_filters;
1789     AVFilterInOut *outputs = NULL, *inputs = NULL;
1790
1791     if (filtergraph) {
1792         outputs = avfilter_inout_alloc();
1793         inputs  = avfilter_inout_alloc();
1794         if (!outputs || !inputs) {
1795             ret = AVERROR(ENOMEM);
1796             goto fail;
1797         }
1798
1799         outputs->name       = av_strdup("in");
1800         outputs->filter_ctx = source_ctx;
1801         outputs->pad_idx    = 0;
1802         outputs->next       = NULL;
1803
1804         inputs->name        = av_strdup("out");
1805         inputs->filter_ctx  = sink_ctx;
1806         inputs->pad_idx     = 0;
1807         inputs->next        = NULL;
1808
1809         if ((ret = avfilter_graph_parse_ptr(graph, filtergraph, &inputs, &outputs, NULL)) < 0)
1810             goto fail;
1811     } else {
1812         if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
1813             goto fail;
1814     }
1815
1816     /* Reorder the filters to ensure that inputs of the custom filters are merged first */
1817     for (i = 0; i < graph->nb_filters - nb_filters; i++)
1818         FFSWAP(AVFilterContext*, graph->filters[i], graph->filters[i + nb_filters]);
1819
1820     ret = avfilter_graph_config(graph, NULL);
1821 fail:
1822     avfilter_inout_free(&outputs);
1823     avfilter_inout_free(&inputs);
1824     return ret;
1825 }
1826
1827 static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const char *vfilters, AVFrame *frame)
1828 {
1829     static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
1830     char sws_flags_str[512] = "";
1831     char buffersrc_args[256];
1832     int ret;
1833     AVFilterContext *filt_src = NULL, *filt_out = NULL, *last_filter = NULL;
1834     AVCodecContext *codec = is->video_st->codec;
1835     AVRational fr = av_guess_frame_rate(is->ic, is->video_st, NULL);
1836     AVDictionaryEntry *e = NULL;
1837
1838     while ((e = av_dict_get(sws_dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
1839         if (!strcmp(e->key, "sws_flags")) {
1840             av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", "flags", e->value);
1841         } else
1842             av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", e->key, e->value);
1843     }
1844     if (strlen(sws_flags_str))
1845         sws_flags_str[strlen(sws_flags_str)-1] = '\0';
1846
1847     graph->scale_sws_opts = av_strdup(sws_flags_str);
1848
1849     snprintf(buffersrc_args, sizeof(buffersrc_args),
1850              "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
1851              frame->width, frame->height, frame->format,
1852              is->video_st->time_base.num, is->video_st->time_base.den,
1853              codec->sample_aspect_ratio.num, FFMAX(codec->sample_aspect_ratio.den, 1));
1854     if (fr.num && fr.den)
1855         av_strlcatf(buffersrc_args, sizeof(buffersrc_args), ":frame_rate=%d/%d", fr.num, fr.den);
1856
1857     if ((ret = avfilter_graph_create_filter(&filt_src,
1858                                             avfilter_get_by_name("buffer"),
1859                                             "ffplay_buffer", buffersrc_args, NULL,
1860                                             graph)) < 0)
1861         goto fail;
1862
1863     ret = avfilter_graph_create_filter(&filt_out,
1864                                        avfilter_get_by_name("buffersink"),
1865                                        "ffplay_buffersink", NULL, NULL, graph);
1866     if (ret < 0)
1867         goto fail;
1868
1869     if ((ret = av_opt_set_int_list(filt_out, "pix_fmts", pix_fmts,  AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1870         goto fail;
1871
1872     last_filter = filt_out;
1873
1874 /* Note: this macro adds a filter before the lastly added filter, so the
1875  * processing order of the filters is in reverse */
1876 #define INSERT_FILT(name, arg) do {                                          \
1877     AVFilterContext *filt_ctx;                                               \
1878                                                                              \
1879     ret = avfilter_graph_create_filter(&filt_ctx,                            \
1880                                        avfilter_get_by_name(name),           \
1881                                        "ffplay_" name, arg, NULL, graph);    \
1882     if (ret < 0)                                                             \
1883         goto fail;                                                           \
1884                                                                              \
1885     ret = avfilter_link(filt_ctx, 0, last_filter, 0);                        \
1886     if (ret < 0)                                                             \
1887         goto fail;                                                           \
1888                                                                              \
1889     last_filter = filt_ctx;                                                  \
1890 } while (0)
1891
1892     /* SDL YUV code is not handling odd width/height for some driver
1893      * combinations, therefore we crop the picture to an even width/height. */
1894     INSERT_FILT("crop", "floor(in_w/2)*2:floor(in_h/2)*2");
1895
1896     if (autorotate) {
1897         double theta  = get_rotation(is->video_st);
1898
1899         if (fabs(theta - 90) < 1.0) {
1900             INSERT_FILT("transpose", "clock");
1901         } else if (fabs(theta - 180) < 1.0) {
1902             INSERT_FILT("hflip", NULL);
1903             INSERT_FILT("vflip", NULL);
1904         } else if (fabs(theta - 270) < 1.0) {
1905             INSERT_FILT("transpose", "cclock");
1906         } else if (fabs(theta) > 1.0) {
1907             char rotate_buf[64];
1908             snprintf(rotate_buf, sizeof(rotate_buf), "%f*PI/180", theta);
1909             INSERT_FILT("rotate", rotate_buf);
1910         }
1911     }
1912
1913     if ((ret = configure_filtergraph(graph, vfilters, filt_src, last_filter)) < 0)
1914         goto fail;
1915
1916     is->in_video_filter  = filt_src;
1917     is->out_video_filter = filt_out;
1918
1919 fail:
1920     return ret;
1921 }
1922
1923 static int configure_audio_filters(VideoState *is, const char *afilters, int force_output_format)
1924 {
1925     static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
1926     int sample_rates[2] = { 0, -1 };
1927     int64_t channel_layouts[2] = { 0, -1 };
1928     int channels[2] = { 0, -1 };
1929     AVFilterContext *filt_asrc = NULL, *filt_asink = NULL;
1930     char aresample_swr_opts[512] = "";
1931     AVDictionaryEntry *e = NULL;
1932     char asrc_args[256];
1933     int ret;
1934
1935     avfilter_graph_free(&is->agraph);
1936     if (!(is->agraph = avfilter_graph_alloc()))
1937         return AVERROR(ENOMEM);
1938
1939     while ((e = av_dict_get(swr_opts, "", e, AV_DICT_IGNORE_SUFFIX)))
1940         av_strlcatf(aresample_swr_opts, sizeof(aresample_swr_opts), "%s=%s:", e->key, e->value);
1941     if (strlen(aresample_swr_opts))
1942         aresample_swr_opts[strlen(aresample_swr_opts)-1] = '\0';
1943     av_opt_set(is->agraph, "aresample_swr_opts", aresample_swr_opts, 0);
1944
1945     ret = snprintf(asrc_args, sizeof(asrc_args),
1946                    "sample_rate=%d:sample_fmt=%s:channels=%d:time_base=%d/%d",
1947                    is->audio_filter_src.freq, av_get_sample_fmt_name(is->audio_filter_src.fmt),
1948                    is->audio_filter_src.channels,
1949                    1, is->audio_filter_src.freq);
1950     if (is->audio_filter_src.channel_layout)
1951         snprintf(asrc_args + ret, sizeof(asrc_args) - ret,
1952                  ":channel_layout=0x%"PRIx64,  is->audio_filter_src.channel_layout);
1953
1954     ret = avfilter_graph_create_filter(&filt_asrc,
1955                                        avfilter_get_by_name("abuffer"), "ffplay_abuffer",
1956                                        asrc_args, NULL, is->agraph);
1957     if (ret < 0)
1958         goto end;
1959
1960
1961     ret = avfilter_graph_create_filter(&filt_asink,
1962                                        avfilter_get_by_name("abuffersink"), "ffplay_abuffersink",
1963                                        NULL, NULL, is->agraph);
1964     if (ret < 0)
1965         goto end;
1966
1967     if ((ret = av_opt_set_int_list(filt_asink, "sample_fmts", sample_fmts,  AV_SAMPLE_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1968         goto end;
1969     if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 1, AV_OPT_SEARCH_CHILDREN)) < 0)
1970         goto end;
1971
1972     if (force_output_format) {
1973         channel_layouts[0] = is->audio_tgt.channel_layout;
1974         channels       [0] = is->audio_tgt.channels;
1975         sample_rates   [0] = is->audio_tgt.freq;
1976         if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 0, AV_OPT_SEARCH_CHILDREN)) < 0)
1977             goto end;
1978         if ((ret = av_opt_set_int_list(filt_asink, "channel_layouts", channel_layouts,  -1, AV_OPT_SEARCH_CHILDREN)) < 0)
1979             goto end;
1980         if ((ret = av_opt_set_int_list(filt_asink, "channel_counts" , channels       ,  -1, AV_OPT_SEARCH_CHILDREN)) < 0)
1981             goto end;
1982         if ((ret = av_opt_set_int_list(filt_asink, "sample_rates"   , sample_rates   ,  -1, AV_OPT_SEARCH_CHILDREN)) < 0)
1983             goto end;
1984     }
1985
1986
1987     if ((ret = configure_filtergraph(is->agraph, afilters, filt_asrc, filt_asink)) < 0)
1988         goto end;
1989
1990     is->in_audio_filter  = filt_asrc;
1991     is->out_audio_filter = filt_asink;
1992
1993 end:
1994     if (ret < 0)
1995         avfilter_graph_free(&is->agraph);
1996     return ret;
1997 }
1998 #endif  /* CONFIG_AVFILTER */
1999
2000 static int audio_thread(void *arg)
2001 {
2002     VideoState *is = arg;
2003     AVFrame *frame = av_frame_alloc();
2004     Frame *af;
2005 #if CONFIG_AVFILTER
2006     int last_serial = -1;
2007     int64_t dec_channel_layout;
2008     int reconfigure;
2009 #endif
2010     int got_frame = 0;
2011     AVRational tb;
2012     int ret = 0;
2013
2014     if (!frame)
2015         return AVERROR(ENOMEM);
2016
2017     do {
2018         if ((got_frame = decoder_decode_frame(&is->auddec, frame, NULL)) < 0)
2019             goto the_end;
2020
2021         if (got_frame) {
2022                 tb = (AVRational){1, frame->sample_rate};
2023
2024 #if CONFIG_AVFILTER
2025                 dec_channel_layout = get_valid_channel_layout(frame->channel_layout, av_frame_get_channels(frame));
2026
2027                 reconfigure =
2028                     cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
2029                                    frame->format, av_frame_get_channels(frame))    ||
2030                     is->audio_filter_src.channel_layout != dec_channel_layout ||
2031                     is->audio_filter_src.freq           != frame->sample_rate ||
2032                     is->auddec.pkt_serial               != last_serial;
2033
2034                 if (reconfigure) {
2035                     char buf1[1024], buf2[1024];
2036                     av_get_channel_layout_string(buf1, sizeof(buf1), -1, is->audio_filter_src.channel_layout);
2037                     av_get_channel_layout_string(buf2, sizeof(buf2), -1, dec_channel_layout);
2038                     av_log(NULL, AV_LOG_DEBUG,
2039                            "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",
2040                            is->audio_filter_src.freq, is->audio_filter_src.channels, av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, last_serial,
2041                            frame->sample_rate, av_frame_get_channels(frame), av_get_sample_fmt_name(frame->format), buf2, is->auddec.pkt_serial);
2042
2043                     is->audio_filter_src.fmt            = frame->format;
2044                     is->audio_filter_src.channels       = av_frame_get_channels(frame);
2045                     is->audio_filter_src.channel_layout = dec_channel_layout;
2046                     is->audio_filter_src.freq           = frame->sample_rate;
2047                     last_serial                         = is->auddec.pkt_serial;
2048
2049                     if ((ret = configure_audio_filters(is, afilters, 1)) < 0)
2050                         goto the_end;
2051                 }
2052
2053             if ((ret = av_buffersrc_add_frame(is->in_audio_filter, frame)) < 0)
2054                 goto the_end;
2055
2056             while ((ret = av_buffersink_get_frame_flags(is->out_audio_filter, frame, 0)) >= 0) {
2057                 tb = is->out_audio_filter->inputs[0]->time_base;
2058 #endif
2059                 if (!(af = frame_queue_peek_writable(&is->sampq)))
2060                     goto the_end;
2061
2062                 af->pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2063                 af->pos = av_frame_get_pkt_pos(frame);
2064                 af->serial = is->auddec.pkt_serial;
2065                 af->duration = av_q2d((AVRational){frame->nb_samples, frame->sample_rate});
2066
2067                 av_frame_move_ref(af->frame, frame);
2068                 frame_queue_push(&is->sampq);
2069
2070 #if CONFIG_AVFILTER
2071                 if (is->audioq.serial != is->auddec.pkt_serial)
2072                     break;
2073             }
2074             if (ret == AVERROR_EOF)
2075                 is->auddec.finished = is->auddec.pkt_serial;
2076 #endif
2077         }
2078     } while (ret >= 0 || ret == AVERROR(EAGAIN) || ret == AVERROR_EOF);
2079  the_end:
2080 #if CONFIG_AVFILTER
2081     avfilter_graph_free(&is->agraph);
2082 #endif
2083     av_frame_free(&frame);
2084     return ret;
2085 }
2086
2087 static int decoder_start(Decoder *d, int (*fn)(void *), void *arg)
2088 {
2089     packet_queue_start(d->queue);
2090     d->decoder_tid = SDL_CreateThread(fn, arg);
2091     if (!d->decoder_tid) {
2092         av_log(d, AV_LOG_ERROR, "SDL_CreateThread(): %s\n", SDL_GetError());
2093         return AVERROR(ENOMEM);
2094     }
2095     return 0;
2096 }
2097
2098 static int video_thread(void *arg)
2099 {
2100     VideoState *is = arg;
2101     AVFrame *frame = av_frame_alloc();
2102     double pts;
2103     double duration;
2104     int ret;
2105     AVRational tb = is->video_st->time_base;
2106     AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);
2107
2108 #if CONFIG_AVFILTER
2109     AVFilterGraph *graph = avfilter_graph_alloc();
2110     AVFilterContext *filt_out = NULL, *filt_in = NULL;
2111     int last_w = 0;
2112     int last_h = 0;
2113     enum AVPixelFormat last_format = -2;
2114     int last_serial = -1;
2115     int last_vfilter_idx = 0;
2116     if (!graph) {
2117         av_frame_free(&frame);
2118         return AVERROR(ENOMEM);
2119     }
2120
2121 #endif
2122
2123     if (!frame) {
2124 #if CONFIG_AVFILTER
2125         avfilter_graph_free(&graph);
2126 #endif
2127         return AVERROR(ENOMEM);
2128     }
2129
2130     for (;;) {
2131         ret = get_video_frame(is, frame);
2132         if (ret < 0)
2133             goto the_end;
2134         if (!ret)
2135             continue;
2136
2137 #if CONFIG_AVFILTER
2138         if (   last_w != frame->width
2139             || last_h != frame->height
2140             || last_format != frame->format
2141             || last_serial != is->viddec.pkt_serial
2142             || last_vfilter_idx != is->vfilter_idx) {
2143             av_log(NULL, AV_LOG_DEBUG,
2144                    "Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
2145                    last_w, last_h,
2146                    (const char *)av_x_if_null(av_get_pix_fmt_name(last_format), "none"), last_serial,
2147                    frame->width, frame->height,
2148                    (const char *)av_x_if_null(av_get_pix_fmt_name(frame->format), "none"), is->viddec.pkt_serial);
2149             avfilter_graph_free(&graph);
2150             graph = avfilter_graph_alloc();
2151             if ((ret = configure_video_filters(graph, is, vfilters_list ? vfilters_list[is->vfilter_idx] : NULL, frame)) < 0) {
2152                 SDL_Event event;
2153                 event.type = FF_QUIT_EVENT;
2154                 event.user.data1 = is;
2155                 SDL_PushEvent(&event);
2156                 goto the_end;
2157             }
2158             filt_in  = is->in_video_filter;
2159             filt_out = is->out_video_filter;
2160             last_w = frame->width;
2161             last_h = frame->height;
2162             last_format = frame->format;
2163             last_serial = is->viddec.pkt_serial;
2164             last_vfilter_idx = is->vfilter_idx;
2165             frame_rate = filt_out->inputs[0]->frame_rate;
2166         }
2167
2168         ret = av_buffersrc_add_frame(filt_in, frame);
2169         if (ret < 0)
2170             goto the_end;
2171
2172         while (ret >= 0) {
2173             is->frame_last_returned_time = av_gettime_relative() / 1000000.0;
2174
2175             ret = av_buffersink_get_frame_flags(filt_out, frame, 0);
2176             if (ret < 0) {
2177                 if (ret == AVERROR_EOF)
2178                     is->viddec.finished = is->viddec.pkt_serial;
2179                 ret = 0;
2180                 break;
2181             }
2182
2183             is->frame_last_filter_delay = av_gettime_relative() / 1000000.0 - is->frame_last_returned_time;
2184             if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
2185                 is->frame_last_filter_delay = 0;
2186             tb = filt_out->inputs[0]->time_base;
2187 #endif
2188             duration = (frame_rate.num && frame_rate.den ? av_q2d((AVRational){frame_rate.den, frame_rate.num}) : 0);
2189             pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2190             ret = queue_picture(is, frame, pts, duration, av_frame_get_pkt_pos(frame), is->viddec.pkt_serial);
2191             av_frame_unref(frame);
2192 #if CONFIG_AVFILTER
2193         }
2194 #endif
2195
2196         if (ret < 0)
2197             goto the_end;
2198     }
2199  the_end:
2200 #if CONFIG_AVFILTER
2201     avfilter_graph_free(&graph);
2202 #endif
2203     av_frame_free(&frame);
2204     return 0;
2205 }
2206
2207 static int subtitle_thread(void *arg)
2208 {
2209     VideoState *is = arg;
2210     Frame *sp;
2211     int got_subtitle;
2212     double pts;
2213     int i;
2214
2215     for (;;) {
2216         if (!(sp = frame_queue_peek_writable(&is->subpq)))
2217             return 0;
2218
2219         if ((got_subtitle = decoder_decode_frame(&is->subdec, NULL, &sp->sub)) < 0)
2220             break;
2221
2222         pts = 0;
2223
2224         if (got_subtitle && sp->sub.format == 0) {
2225             if (sp->sub.pts != AV_NOPTS_VALUE)
2226                 pts = sp->sub.pts / (double)AV_TIME_BASE;
2227             sp->pts = pts;
2228             sp->serial = is->subdec.pkt_serial;
2229
2230             for (i = 0; i < sp->sub.num_rects; i++)
2231             {
2232                 int in_w = sp->sub.rects[i]->w;
2233                 int in_h = sp->sub.rects[i]->h;
2234                 int subw = is->subdec.avctx->width  ? is->subdec.avctx->width  : is->viddec_width;
2235                 int subh = is->subdec.avctx->height ? is->subdec.avctx->height : is->viddec_height;
2236                 int out_w = is->viddec_width  ? in_w * is->viddec_width  / subw : in_w;
2237                 int out_h = is->viddec_height ? in_h * is->viddec_height / subh : in_h;
2238                 AVPicture newpic;
2239
2240                 //can not use avpicture_alloc as it is not compatible with avsubtitle_free()
2241                 av_image_fill_linesizes(newpic.linesize, AV_PIX_FMT_YUVA420P, out_w);
2242                 newpic.data[0] = av_malloc(newpic.linesize[0] * out_h);
2243                 newpic.data[3] = av_malloc(newpic.linesize[3] * out_h);
2244                 newpic.data[1] = av_malloc(newpic.linesize[1] * ((out_h+1)/2));
2245                 newpic.data[2] = av_malloc(newpic.linesize[2] * ((out_h+1)/2));
2246
2247                 is->sub_convert_ctx = sws_getCachedContext(is->sub_convert_ctx,
2248                     in_w, in_h, AV_PIX_FMT_PAL8, out_w, out_h,
2249                     AV_PIX_FMT_YUVA420P, sws_flags, NULL, NULL, NULL);
2250                 if (!is->sub_convert_ctx || !newpic.data[0] || !newpic.data[3] ||
2251                     !newpic.data[1] || !newpic.data[2]
2252                 ) {
2253                     av_log(NULL, AV_LOG_FATAL, "Cannot initialize the sub conversion context\n");
2254                     exit(1);
2255                 }
2256                 sws_scale(is->sub_convert_ctx,
2257                           (void*)sp->sub.rects[i]->pict.data, sp->sub.rects[i]->pict.linesize,
2258                           0, in_h, newpic.data, newpic.linesize);
2259
2260                 av_free(sp->sub.rects[i]->pict.data[0]);
2261                 av_free(sp->sub.rects[i]->pict.data[1]);
2262                 sp->sub.rects[i]->pict = newpic;
2263                 sp->sub.rects[i]->w = out_w;
2264                 sp->sub.rects[i]->h = out_h;
2265                 sp->sub.rects[i]->x = sp->sub.rects[i]->x * out_w / in_w;
2266                 sp->sub.rects[i]->y = sp->sub.rects[i]->y * out_h / in_h;
2267             }
2268
2269             /* now we can update the picture count */
2270             frame_queue_push(&is->subpq);
2271         } else if (got_subtitle) {
2272             avsubtitle_free(&sp->sub);
2273         }
2274     }
2275     return 0;
2276 }
2277
2278 /* copy samples for viewing in editor window */
2279 static void update_sample_display(VideoState *is, short *samples, int samples_size)
2280 {
2281     int size, len;
2282
2283     size = samples_size / sizeof(short);
2284     while (size > 0) {
2285         len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
2286         if (len > size)
2287             len = size;
2288         memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
2289         samples += len;
2290         is->sample_array_index += len;
2291         if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
2292             is->sample_array_index = 0;
2293         size -= len;
2294     }
2295 }
2296
2297 /* return the wanted number of samples to get better sync if sync_type is video
2298  * or external master clock */
2299 static int synchronize_audio(VideoState *is, int nb_samples)
2300 {
2301     int wanted_nb_samples = nb_samples;
2302
2303     /* if not master, then we try to remove or add samples to correct the clock */
2304     if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
2305         double diff, avg_diff;
2306         int min_nb_samples, max_nb_samples;
2307
2308         diff = get_clock(&is->audclk) - get_master_clock(is);
2309
2310         if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD) {
2311             is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
2312             if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
2313                 /* not enough measures to have a correct estimate */
2314                 is->audio_diff_avg_count++;
2315             } else {
2316                 /* estimate the A-V difference */
2317                 avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
2318
2319                 if (fabs(avg_diff) >= is->audio_diff_threshold) {
2320                     wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);
2321                     min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2322                     max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2323                     wanted_nb_samples = av_clip(wanted_nb_samples, min_nb_samples, max_nb_samples);
2324                 }
2325                 av_log(NULL, AV_LOG_TRACE, "diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
2326                         diff, avg_diff, wanted_nb_samples - nb_samples,
2327                         is->audio_clock, is->audio_diff_threshold);
2328             }
2329         } else {
2330             /* too big difference : may be initial PTS errors, so
2331                reset A-V filter */
2332             is->audio_diff_avg_count = 0;
2333             is->audio_diff_cum       = 0;
2334         }
2335     }
2336
2337     return wanted_nb_samples;
2338 }
2339
2340 /**
2341  * Decode one audio frame and return its uncompressed size.
2342  *
2343  * The processed audio frame is decoded, converted if required, and
2344  * stored in is->audio_buf, with size in bytes given by the return
2345  * value.
2346  */
2347 static int audio_decode_frame(VideoState *is)
2348 {
2349     int data_size, resampled_data_size;
2350     int64_t dec_channel_layout;
2351     av_unused double audio_clock0;
2352     int wanted_nb_samples;
2353     Frame *af;
2354
2355     if (is->paused)
2356         return -1;
2357
2358     do {
2359 #if defined(_WIN32)
2360         while (frame_queue_nb_remaining(&is->sampq) == 0) {
2361             if ((av_gettime_relative() - audio_callback_time) > 1000000LL * is->audio_hw_buf_size / is->audio_tgt.bytes_per_sec / 2)
2362                 return -1;
2363             av_usleep (1000);
2364         }
2365 #endif
2366         if (!(af = frame_queue_peek_readable(&is->sampq)))
2367             return -1;
2368         frame_queue_next(&is->sampq);
2369     } while (af->serial != is->audioq.serial);
2370
2371     data_size = av_samples_get_buffer_size(NULL, av_frame_get_channels(af->frame),
2372                                            af->frame->nb_samples,
2373                                            af->frame->format, 1);
2374
2375     dec_channel_layout =
2376         (af->frame->channel_layout && av_frame_get_channels(af->frame) == av_get_channel_layout_nb_channels(af->frame->channel_layout)) ?
2377         af->frame->channel_layout : av_get_default_channel_layout(av_frame_get_channels(af->frame));
2378     wanted_nb_samples = synchronize_audio(is, af->frame->nb_samples);
2379
2380     if (af->frame->format        != is->audio_src.fmt            ||
2381         dec_channel_layout       != is->audio_src.channel_layout ||
2382         af->frame->sample_rate   != is->audio_src.freq           ||
2383         (wanted_nb_samples       != af->frame->nb_samples && !is->swr_ctx)) {
2384         swr_free(&is->swr_ctx);
2385         is->swr_ctx = swr_alloc_set_opts(NULL,
2386                                          is->audio_tgt.channel_layout, is->audio_tgt.fmt, is->audio_tgt.freq,
2387                                          dec_channel_layout,           af->frame->format, af->frame->sample_rate,
2388                                          0, NULL);
2389         if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
2390             av_log(NULL, AV_LOG_ERROR,
2391                    "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
2392                     af->frame->sample_rate, av_get_sample_fmt_name(af->frame->format), av_frame_get_channels(af->frame),
2393                     is->audio_tgt.freq, av_get_sample_fmt_name(is->audio_tgt.fmt), is->audio_tgt.channels);
2394             swr_free(&is->swr_ctx);
2395             return -1;
2396         }
2397         is->audio_src.channel_layout = dec_channel_layout;
2398         is->audio_src.channels       = av_frame_get_channels(af->frame);
2399         is->audio_src.freq = af->frame->sample_rate;
2400         is->audio_src.fmt = af->frame->format;
2401     }
2402
2403     if (is->swr_ctx) {
2404         const uint8_t **in = (const uint8_t **)af->frame->extended_data;
2405         uint8_t **out = &is->audio_buf1;
2406         int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate + 256;
2407         int out_size  = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, out_count, is->audio_tgt.fmt, 0);
2408         int len2;
2409         if (out_size < 0) {
2410             av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size() failed\n");
2411             return -1;
2412         }
2413         if (wanted_nb_samples != af->frame->nb_samples) {
2414             if (swr_set_compensation(is->swr_ctx, (wanted_nb_samples - af->frame->nb_samples) * is->audio_tgt.freq / af->frame->sample_rate,
2415                                         wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate) < 0) {
2416                 av_log(NULL, AV_LOG_ERROR, "swr_set_compensation() failed\n");
2417                 return -1;
2418             }
2419         }
2420         av_fast_malloc(&is->audio_buf1, &is->audio_buf1_size, out_size);
2421         if (!is->audio_buf1)
2422             return AVERROR(ENOMEM);
2423         len2 = swr_convert(is->swr_ctx, out, out_count, in, af->frame->nb_samples);
2424         if (len2 < 0) {
2425             av_log(NULL, AV_LOG_ERROR, "swr_convert() failed\n");
2426             return -1;
2427         }
2428         if (len2 == out_count) {
2429             av_log(NULL, AV_LOG_WARNING, "audio buffer is probably too small\n");
2430             if (swr_init(is->swr_ctx) < 0)
2431                 swr_free(&is->swr_ctx);
2432         }
2433         is->audio_buf = is->audio_buf1;
2434         resampled_data_size = len2 * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2435     } else {
2436         is->audio_buf = af->frame->data[0];
2437         resampled_data_size = data_size;
2438     }
2439
2440     audio_clock0 = is->audio_clock;
2441     /* update the audio clock with the pts */
2442     if (!isnan(af->pts))
2443         is->audio_clock = af->pts + (double) af->frame->nb_samples / af->frame->sample_rate;
2444     else
2445         is->audio_clock = NAN;
2446     is->audio_clock_serial = af->serial;
2447 #ifdef DEBUG
2448     {
2449         static double last_clock;
2450         printf("audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
2451                is->audio_clock - last_clock,
2452                is->audio_clock, audio_clock0);
2453         last_clock = is->audio_clock;
2454     }
2455 #endif
2456     return resampled_data_size;
2457 }
2458
2459 /* prepare a new audio buffer */
2460 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
2461 {
2462     VideoState *is = opaque;
2463     int audio_size, len1;
2464
2465     audio_callback_time = av_gettime_relative();
2466
2467     while (len > 0) {
2468         if (is->audio_buf_index >= is->audio_buf_size) {
2469            audio_size = audio_decode_frame(is);
2470            if (audio_size < 0) {
2471                 /* if error, just output silence */
2472                is->audio_buf      = is->silence_buf;
2473                is->audio_buf_size = sizeof(is->silence_buf) / is->audio_tgt.frame_size * is->audio_tgt.frame_size;
2474            } else {
2475                if (is->show_mode != SHOW_MODE_VIDEO)
2476                    update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
2477                is->audio_buf_size = audio_size;
2478            }
2479            is->audio_buf_index = 0;
2480         }
2481         len1 = is->audio_buf_size - is->audio_buf_index;
2482         if (len1 > len)
2483             len1 = len;
2484         if (!is->muted && is->audio_volume == SDL_MIX_MAXVOLUME)
2485             memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
2486         else {
2487             memset(stream, is->silence_buf[0], len1);
2488             if (!is->muted)
2489                 SDL_MixAudio(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1, is->audio_volume);
2490         }
2491         len -= len1;
2492         stream += len1;
2493         is->audio_buf_index += len1;
2494     }
2495     is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
2496     /* Let's assume the audio driver that is used by SDL has two periods. */
2497     if (!isnan(is->audio_clock)) {
2498         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);
2499         sync_clock_to_slave(&is->extclk, &is->audclk);
2500     }
2501 }
2502
2503 static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
2504 {
2505     SDL_AudioSpec wanted_spec, spec;
2506     const char *env;
2507     static const int next_nb_channels[] = {0, 0, 1, 6, 2, 6, 4, 6};
2508     static const int next_sample_rates[] = {0, 44100, 48000, 96000, 192000};
2509     int next_sample_rate_idx = FF_ARRAY_ELEMS(next_sample_rates) - 1;
2510
2511     env = SDL_getenv("SDL_AUDIO_CHANNELS");
2512     if (env) {
2513         wanted_nb_channels = atoi(env);
2514         wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2515     }
2516     if (!wanted_channel_layout || wanted_nb_channels != av_get_channel_layout_nb_channels(wanted_channel_layout)) {
2517         wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2518         wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
2519     }
2520     wanted_nb_channels = av_get_channel_layout_nb_channels(wanted_channel_layout);
2521     wanted_spec.channels = wanted_nb_channels;
2522     wanted_spec.freq = wanted_sample_rate;
2523     if (wanted_spec.freq <= 0 || wanted_spec.channels <= 0) {
2524         av_log(NULL, AV_LOG_ERROR, "Invalid sample rate or channel count!\n");
2525         return -1;
2526     }
2527     while (next_sample_rate_idx && next_sample_rates[next_sample_rate_idx] >= wanted_spec.freq)
2528         next_sample_rate_idx--;
2529     wanted_spec.format = AUDIO_S16SYS;
2530     wanted_spec.silence = 0;
2531     wanted_spec.samples = FFMAX(SDL_AUDIO_MIN_BUFFER_SIZE, 2 << av_log2(wanted_spec.freq / SDL_AUDIO_MAX_CALLBACKS_PER_SEC));
2532     wanted_spec.callback = sdl_audio_callback;
2533     wanted_spec.userdata = opaque;
2534     while (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
2535         av_log(NULL, AV_LOG_WARNING, "SDL_OpenAudio (%d channels, %d Hz): %s\n",
2536                wanted_spec.channels, wanted_spec.freq, SDL_GetError());
2537         wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
2538         if (!wanted_spec.channels) {
2539             wanted_spec.freq = next_sample_rates[next_sample_rate_idx--];
2540             wanted_spec.channels = wanted_nb_channels;
2541             if (!wanted_spec.freq) {
2542                 av_log(NULL, AV_LOG_ERROR,
2543                        "No more combinations to try, audio open failed\n");
2544                 return -1;
2545             }
2546         }
2547         wanted_channel_layout = av_get_default_channel_layout(wanted_spec.channels);
2548     }
2549     if (spec.format != AUDIO_S16SYS) {
2550         av_log(NULL, AV_LOG_ERROR,
2551                "SDL advised audio format %d is not supported!\n", spec.format);
2552         return -1;
2553     }
2554     if (spec.channels != wanted_spec.channels) {
2555         wanted_channel_layout = av_get_default_channel_layout(spec.channels);
2556         if (!wanted_channel_layout) {
2557             av_log(NULL, AV_LOG_ERROR,
2558                    "SDL advised channel count %d is not supported!\n", spec.channels);
2559             return -1;
2560         }
2561     }
2562
2563     audio_hw_params->fmt = AV_SAMPLE_FMT_S16;
2564     audio_hw_params->freq = spec.freq;
2565     audio_hw_params->channel_layout = wanted_channel_layout;
2566     audio_hw_params->channels =  spec.channels;
2567     audio_hw_params->frame_size = av_samples_get_buffer_size(NULL, audio_hw_params->channels, 1, audio_hw_params->fmt, 1);
2568     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);
2569     if (audio_hw_params->bytes_per_sec <= 0 || audio_hw_params->frame_size <= 0) {
2570         av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size failed\n");
2571         return -1;
2572     }
2573     return spec.size;
2574 }
2575
2576 /* open a given stream. Return 0 if OK */
2577 static int stream_component_open(VideoState *is, int stream_index)
2578 {
2579     AVFormatContext *ic = is->ic;
2580     AVCodecContext *avctx;
2581     AVCodec *codec;
2582     const char *forced_codec_name = NULL;
2583     AVDictionary *opts;
2584     AVDictionaryEntry *t = NULL;
2585     int sample_rate, nb_channels;
2586     int64_t channel_layout;
2587     int ret = 0;
2588     int stream_lowres = lowres;
2589
2590     if (stream_index < 0 || stream_index >= ic->nb_streams)
2591         return -1;
2592     avctx = ic->streams[stream_index]->codec;
2593
2594     codec = avcodec_find_decoder(avctx->codec_id);
2595
2596     switch(avctx->codec_type){
2597         case AVMEDIA_TYPE_AUDIO   : is->last_audio_stream    = stream_index; forced_codec_name =    audio_codec_name; break;
2598         case AVMEDIA_TYPE_SUBTITLE: is->last_subtitle_stream = stream_index; forced_codec_name = subtitle_codec_name; break;
2599         case AVMEDIA_TYPE_VIDEO   : is->last_video_stream    = stream_index; forced_codec_name =    video_codec_name; break;
2600     }
2601     if (forced_codec_name)
2602         codec = avcodec_find_decoder_by_name(forced_codec_name);
2603     if (!codec) {
2604         if (forced_codec_name) av_log(NULL, AV_LOG_WARNING,
2605                                       "No codec could be found with name '%s'\n", forced_codec_name);
2606         else                   av_log(NULL, AV_LOG_WARNING,
2607                                       "No codec could be found with id %d\n", avctx->codec_id);
2608         return -1;
2609     }
2610
2611     avctx->codec_id = codec->id;
2612     if(stream_lowres > av_codec_get_max_lowres(codec)){
2613         av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2614                 av_codec_get_max_lowres(codec));
2615         stream_lowres = av_codec_get_max_lowres(codec);
2616     }
2617     av_codec_set_lowres(avctx, stream_lowres);
2618
2619 #if FF_API_EMU_EDGE
2620     if(stream_lowres) avctx->flags |= CODEC_FLAG_EMU_EDGE;
2621 #endif
2622     if (fast)
2623         avctx->flags2 |= AV_CODEC_FLAG2_FAST;
2624 #if FF_API_EMU_EDGE
2625     if(codec->capabilities & AV_CODEC_CAP_DR1)
2626         avctx->flags |= CODEC_FLAG_EMU_EDGE;
2627 #endif
2628
2629     opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
2630     if (!av_dict_get(opts, "threads", NULL, 0))
2631         av_dict_set(&opts, "threads", "auto", 0);
2632     if (stream_lowres)
2633         av_dict_set_int(&opts, "lowres", stream_lowres, 0);
2634     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
2635         av_dict_set(&opts, "refcounted_frames", "1", 0);
2636     if ((ret = avcodec_open2(avctx, codec, &opts)) < 0) {
2637         goto fail;
2638     }
2639     if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2640         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2641         ret =  AVERROR_OPTION_NOT_FOUND;
2642         goto fail;
2643     }
2644
2645     is->eof = 0;
2646     ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
2647     switch (avctx->codec_type) {
2648     case AVMEDIA_TYPE_AUDIO:
2649 #if CONFIG_AVFILTER
2650         {
2651             AVFilterLink *link;
2652
2653             is->audio_filter_src.freq           = avctx->sample_rate;
2654             is->audio_filter_src.channels       = avctx->channels;
2655             is->audio_filter_src.channel_layout = get_valid_channel_layout(avctx->channel_layout, avctx->channels);
2656             is->audio_filter_src.fmt            = avctx->sample_fmt;
2657             if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
2658                 goto fail;
2659             link = is->out_audio_filter->inputs[0];
2660             sample_rate    = link->sample_rate;
2661             nb_channels    = link->channels;
2662             channel_layout = link->channel_layout;
2663         }
2664 #else
2665         sample_rate    = avctx->sample_rate;
2666         nb_channels    = avctx->channels;
2667         channel_layout = avctx->channel_layout;
2668 #endif
2669
2670         /* prepare audio output */
2671         if ((ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)) < 0)
2672             goto fail;
2673         is->audio_hw_buf_size = ret;
2674         is->audio_src = is->audio_tgt;
2675         is->audio_buf_size  = 0;
2676         is->audio_buf_index = 0;
2677
2678         /* init averaging filter */
2679         is->audio_diff_avg_coef  = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
2680         is->audio_diff_avg_count = 0;
2681         /* since we do not have a precise anough audio fifo fullness,
2682            we correct audio sync only if larger than this threshold */
2683         is->audio_diff_threshold = (double)(is->audio_hw_buf_size) / is->audio_tgt.bytes_per_sec;
2684
2685         is->audio_stream = stream_index;
2686         is->audio_st = ic->streams[stream_index];
2687
2688         decoder_init(&is->auddec, avctx, &is->audioq, is->continue_read_thread);
2689         if ((is->ic->iformat->flags & (AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH | AVFMT_NO_BYTE_SEEK)) && !is->ic->iformat->read_seek) {
2690             is->auddec.start_pts = is->audio_st->start_time;
2691             is->auddec.start_pts_tb = is->audio_st->time_base;
2692         }
2693         if ((ret = decoder_start(&is->auddec, audio_thread, is)) < 0)
2694             goto fail;
2695         SDL_PauseAudio(0);
2696         break;
2697     case AVMEDIA_TYPE_VIDEO:
2698         is->video_stream = stream_index;
2699         is->video_st = ic->streams[stream_index];
2700
2701         is->viddec_width  = avctx->width;
2702         is->viddec_height = avctx->height;
2703
2704         decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread);
2705         if ((ret = decoder_start(&is->viddec, video_thread, is)) < 0)
2706             goto fail;
2707         is->queue_attachments_req = 1;
2708         break;
2709     case AVMEDIA_TYPE_SUBTITLE:
2710         is->subtitle_stream = stream_index;
2711         is->subtitle_st = ic->streams[stream_index];
2712
2713         decoder_init(&is->subdec, avctx, &is->subtitleq, is->continue_read_thread);
2714         if ((ret = decoder_start(&is->subdec, subtitle_thread, is)) < 0)
2715             goto fail;
2716         break;
2717     default:
2718         break;
2719     }
2720
2721 fail:
2722     av_dict_free(&opts);
2723
2724     return ret;
2725 }
2726
2727 static void stream_component_close(VideoState *is, int stream_index)
2728 {
2729     AVFormatContext *ic = is->ic;
2730     AVCodecContext *avctx;
2731
2732     if (stream_index < 0 || stream_index >= ic->nb_streams)
2733         return;
2734     avctx = ic->streams[stream_index]->codec;
2735
2736     switch (avctx->codec_type) {
2737     case AVMEDIA_TYPE_AUDIO:
2738         decoder_abort(&is->auddec, &is->sampq);
2739         SDL_CloseAudio();
2740         decoder_destroy(&is->auddec);
2741         swr_free(&is->swr_ctx);
2742         av_freep(&is->audio_buf1);
2743         is->audio_buf1_size = 0;
2744         is->audio_buf = NULL;
2745
2746         if (is->rdft) {
2747             av_rdft_end(is->rdft);
2748             av_freep(&is->rdft_data);
2749             is->rdft = NULL;
2750             is->rdft_bits = 0;
2751         }
2752         break;
2753     case AVMEDIA_TYPE_VIDEO:
2754         decoder_abort(&is->viddec, &is->pictq);
2755         decoder_destroy(&is->viddec);
2756         break;
2757     case AVMEDIA_TYPE_SUBTITLE:
2758         decoder_abort(&is->subdec, &is->subpq);
2759         decoder_destroy(&is->subdec);
2760         break;
2761     default:
2762         break;
2763     }
2764
2765     ic->streams[stream_index]->discard = AVDISCARD_ALL;
2766     avcodec_close(avctx);
2767     switch (avctx->codec_type) {
2768     case AVMEDIA_TYPE_AUDIO:
2769         is->audio_st = NULL;
2770         is->audio_stream = -1;
2771         break;
2772     case AVMEDIA_TYPE_VIDEO:
2773         is->video_st = NULL;
2774         is->video_stream = -1;
2775         break;
2776     case AVMEDIA_TYPE_SUBTITLE:
2777         is->subtitle_st = NULL;
2778         is->subtitle_stream = -1;
2779         break;
2780     default:
2781         break;
2782     }
2783 }
2784
2785 static int decode_interrupt_cb(void *ctx)
2786 {
2787     VideoState *is = ctx;
2788     return is->abort_request;
2789 }
2790
2791 static int is_realtime(AVFormatContext *s)
2792 {
2793     if(   !strcmp(s->iformat->name, "rtp")
2794        || !strcmp(s->iformat->name, "rtsp")
2795        || !strcmp(s->iformat->name, "sdp")
2796     )
2797         return 1;
2798
2799     if(s->pb && (   !strncmp(s->filename, "rtp:", 4)
2800                  || !strncmp(s->filename, "udp:", 4)
2801                 )
2802     )
2803         return 1;
2804     return 0;
2805 }
2806
2807 /* this thread gets the stream from the disk or the network */
2808 static int read_thread(void *arg)
2809 {
2810     VideoState *is = arg;
2811     AVFormatContext *ic = NULL;
2812     int err, i, ret;
2813     int st_index[AVMEDIA_TYPE_NB];
2814     AVPacket pkt1, *pkt = &pkt1;
2815     int64_t stream_start_time;
2816     int pkt_in_play_range = 0;
2817     AVDictionaryEntry *t;
2818     AVDictionary **opts;
2819     int orig_nb_streams;
2820     SDL_mutex *wait_mutex = SDL_CreateMutex();
2821     int scan_all_pmts_set = 0;
2822     int64_t pkt_ts;
2823
2824     if (!wait_mutex) {
2825         av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
2826         ret = AVERROR(ENOMEM);
2827         goto fail;
2828     }
2829
2830     memset(st_index, -1, sizeof(st_index));
2831     is->last_video_stream = is->video_stream = -1;
2832     is->last_audio_stream = is->audio_stream = -1;
2833     is->last_subtitle_stream = is->subtitle_stream = -1;
2834     is->eof = 0;
2835
2836     ic = avformat_alloc_context();
2837     if (!ic) {
2838         av_log(NULL, AV_LOG_FATAL, "Could not allocate context.\n");
2839         ret = AVERROR(ENOMEM);
2840         goto fail;
2841     }
2842     ic->interrupt_callback.callback = decode_interrupt_cb;
2843     ic->interrupt_callback.opaque = is;
2844     if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
2845         av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
2846         scan_all_pmts_set = 1;
2847     }
2848     err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
2849     if (err < 0) {
2850         print_error(is->filename, err);
2851         ret = -1;
2852         goto fail;
2853     }
2854     if (scan_all_pmts_set)
2855         av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
2856
2857     if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2858         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2859         ret = AVERROR_OPTION_NOT_FOUND;
2860         goto fail;
2861     }
2862     is->ic = ic;
2863
2864     if (genpts)
2865         ic->flags |= AVFMT_FLAG_GENPTS;
2866
2867     av_format_inject_global_side_data(ic);
2868
2869     opts = setup_find_stream_info_opts(ic, codec_opts);
2870     orig_nb_streams = ic->nb_streams;
2871
2872     err = avformat_find_stream_info(ic, opts);
2873
2874     for (i = 0; i < orig_nb_streams; i++)
2875         av_dict_free(&opts[i]);
2876     av_freep(&opts);
2877
2878     if (err < 0) {
2879         av_log(NULL, AV_LOG_WARNING,
2880                "%s: could not find codec parameters\n", is->filename);
2881         ret = -1;
2882         goto fail;
2883     }
2884
2885     if (ic->pb)
2886         ic->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use avio_feof() to test for the end
2887
2888     if (seek_by_bytes < 0)
2889         seek_by_bytes = !!(ic->iformat->flags & AVFMT_TS_DISCONT) && strcmp("ogg", ic->iformat->name);
2890
2891     is->max_frame_duration = (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;
2892
2893     if (!window_title && (t = av_dict_get(ic->metadata, "title", NULL, 0)))
2894         window_title = av_asprintf("%s - %s", t->value, input_filename);
2895
2896     /* if seeking requested, we execute it */
2897     if (start_time != AV_NOPTS_VALUE) {
2898         int64_t timestamp;
2899
2900         timestamp = start_time;
2901         /* add the stream start time */
2902         if (ic->start_time != AV_NOPTS_VALUE)
2903             timestamp += ic->start_time;
2904         ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
2905         if (ret < 0) {
2906             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2907                     is->filename, (double)timestamp / AV_TIME_BASE);
2908         }
2909     }
2910
2911     is->realtime = is_realtime(ic);
2912
2913     if (show_status)
2914         av_dump_format(ic, 0, is->filename, 0);
2915
2916     for (i = 0; i < ic->nb_streams; i++) {
2917         AVStream *st = ic->streams[i];
2918         enum AVMediaType type = st->codec->codec_type;
2919         st->discard = AVDISCARD_ALL;
2920         if (wanted_stream_spec[type] && st_index[type] == -1)
2921             if (avformat_match_stream_specifier(ic, st, wanted_stream_spec[type]) > 0)
2922                 st_index[type] = i;
2923     }
2924     for (i = 0; i < AVMEDIA_TYPE_NB; i++) {
2925         if (wanted_stream_spec[i] && st_index[i] == -1) {
2926             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));
2927             st_index[i] = INT_MAX;
2928         }
2929     }
2930
2931     if (!video_disable)
2932         st_index[AVMEDIA_TYPE_VIDEO] =
2933             av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
2934                                 st_index[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
2935     if (!audio_disable)
2936         st_index[AVMEDIA_TYPE_AUDIO] =
2937             av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
2938                                 st_index[AVMEDIA_TYPE_AUDIO],
2939                                 st_index[AVMEDIA_TYPE_VIDEO],
2940                                 NULL, 0);
2941     if (!video_disable && !subtitle_disable)
2942         st_index[AVMEDIA_TYPE_SUBTITLE] =
2943             av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
2944                                 st_index[AVMEDIA_TYPE_SUBTITLE],
2945                                 (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
2946                                  st_index[AVMEDIA_TYPE_AUDIO] :
2947                                  st_index[AVMEDIA_TYPE_VIDEO]),
2948                                 NULL, 0);
2949
2950     is->show_mode = show_mode;
2951     if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2952         AVStream *st = ic->streams[st_index[AVMEDIA_TYPE_VIDEO]];
2953         AVCodecContext *avctx = st->codec;
2954         AVRational sar = av_guess_sample_aspect_ratio(ic, st, NULL);
2955         if (avctx->width)
2956             set_default_window_size(avctx->width, avctx->height, sar);
2957     }
2958
2959     /* open the streams */
2960     if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
2961         stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
2962     }
2963
2964     ret = -1;
2965     if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2966         ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
2967     }
2968     if (is->show_mode == SHOW_MODE_NONE)
2969         is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
2970
2971     if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
2972         stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
2973     }
2974
2975     if (is->video_stream < 0 && is->audio_stream < 0) {
2976         av_log(NULL, AV_LOG_FATAL, "Failed to open file '%s' or configure filtergraph\n",
2977                is->filename);
2978         ret = -1;
2979         goto fail;
2980     }
2981
2982     if (infinite_buffer < 0 && is->realtime)
2983         infinite_buffer = 1;
2984
2985     for (;;) {
2986         if (is->abort_request)
2987             break;
2988         if (is->paused != is->last_paused) {
2989             is->last_paused = is->paused;
2990             if (is->paused)
2991                 is->read_pause_return = av_read_pause(ic);
2992             else
2993                 av_read_play(ic);
2994         }
2995 #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
2996         if (is->paused &&
2997                 (!strcmp(ic->iformat->name, "rtsp") ||
2998                  (ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
2999             /* wait 10 ms to avoid trying to get another packet */
3000             /* XXX: horrible */
3001             SDL_Delay(10);
3002             continue;
3003         }
3004 #endif
3005         if (is->seek_req) {
3006             int64_t seek_target = is->seek_pos;
3007             int64_t seek_min    = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
3008             int64_t seek_max    = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
3009 // FIXME the +-2 is due to rounding being not done in the correct direction in generation
3010 //      of the seek_pos/seek_rel variables
3011
3012             ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
3013             if (ret < 0) {
3014                 av_log(NULL, AV_LOG_ERROR,
3015                        "%s: error while seeking\n", is->ic->filename);
3016             } else {
3017                 if (is->audio_stream >= 0) {
3018                     packet_queue_flush(&is->audioq);
3019                     packet_queue_put(&is->audioq, &flush_pkt);
3020                 }
3021                 if (is->subtitle_stream >= 0) {
3022                     packet_queue_flush(&is->subtitleq);
3023                     packet_queue_put(&is->subtitleq, &flush_pkt);
3024                 }
3025                 if (is->video_stream >= 0) {
3026                     packet_queue_flush(&is->videoq);
3027                     packet_queue_put(&is->videoq, &flush_pkt);
3028                 }
3029                 if (is->seek_flags & AVSEEK_FLAG_BYTE) {
3030                    set_clock(&is->extclk, NAN, 0);
3031                 } else {
3032                    set_clock(&is->extclk, seek_target / (double)AV_TIME_BASE, 0);
3033                 }
3034             }
3035             is->seek_req = 0;
3036             is->queue_attachments_req = 1;
3037             is->eof = 0;
3038             if (is->paused)
3039                 step_to_next_frame(is);
3040         }
3041         if (is->queue_attachments_req) {
3042             if (is->video_st && is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC) {
3043                 AVPacket copy;
3044                 if ((ret = av_copy_packet(&copy, &is->video_st->attached_pic)) < 0)
3045                     goto fail;
3046                 packet_queue_put(&is->videoq, &copy);
3047                 packet_queue_put_nullpacket(&is->videoq, is->video_stream);
3048             }
3049             is->queue_attachments_req = 0;
3050         }
3051
3052         /* if the queue are full, no need to read more */
3053         if (infinite_buffer<1 &&
3054               (is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
3055             || (   (is->audioq   .nb_packets > MIN_FRAMES || is->audio_stream < 0 || is->audioq.abort_request)
3056                 && (is->videoq   .nb_packets > MIN_FRAMES || is->video_stream < 0 || is->videoq.abort_request
3057                     || (is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3058                 && (is->subtitleq.nb_packets > MIN_FRAMES || is->subtitle_stream < 0 || is->subtitleq.abort_request)))) {
3059             /* wait 10 ms */
3060             SDL_LockMutex(wait_mutex);
3061             SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3062             SDL_UnlockMutex(wait_mutex);
3063             continue;
3064         }
3065         if (!is->paused &&
3066             (!is->audio_st || (is->auddec.finished == is->audioq.serial && frame_queue_nb_remaining(&is->sampq) == 0)) &&
3067             (!is->video_st || (is->viddec.finished == is->videoq.serial && frame_queue_nb_remaining(&is->pictq) == 0))) {
3068             if (loop != 1 && (!loop || --loop)) {
3069                 stream_seek(is, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
3070             } else if (autoexit) {
3071                 ret = AVERROR_EOF;
3072                 goto fail;
3073             }
3074         }
3075         ret = av_read_frame(ic, pkt);
3076         if (ret < 0) {
3077             if ((ret == AVERROR_EOF || avio_feof(ic->pb)) && !is->eof) {
3078                 if (is->video_stream >= 0)
3079                     packet_queue_put_nullpacket(&is->videoq, is->video_stream);
3080                 if (is->audio_stream >= 0)
3081                     packet_queue_put_nullpacket(&is->audioq, is->audio_stream);
3082                 if (is->subtitle_stream >= 0)
3083                     packet_queue_put_nullpacket(&is->subtitleq, is->subtitle_stream);
3084                 is->eof = 1;
3085             }
3086             if (ic->pb && ic->pb->error)
3087                 break;
3088             SDL_LockMutex(wait_mutex);
3089             SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3090             SDL_UnlockMutex(wait_mutex);
3091             continue;
3092         } else {
3093             is->eof = 0;
3094         }
3095         /* check if packet is in play range specified by user, then queue, otherwise discard */
3096         stream_start_time = ic->streams[pkt->stream_index]->start_time;
3097         pkt_ts = pkt->pts == AV_NOPTS_VALUE ? pkt->dts : pkt->pts;
3098         pkt_in_play_range = duration == AV_NOPTS_VALUE ||
3099                 (pkt_ts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
3100                 av_q2d(ic->streams[pkt->stream_index]->time_base) -
3101                 (double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
3102                 <= ((double)duration / 1000000);
3103         if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
3104             packet_queue_put(&is->audioq, pkt);
3105         } else if (pkt->stream_index == is->video_stream && pkt_in_play_range
3106                    && !(is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
3107             packet_queue_put(&is->videoq, pkt);
3108         } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
3109             packet_queue_put(&is->subtitleq, pkt);
3110         } else {
3111             av_free_packet(pkt);
3112         }
3113     }
3114     /* wait until the end */
3115     while (!is->abort_request) {
3116         SDL_Delay(100);
3117     }
3118
3119     ret = 0;
3120  fail:
3121     /* close each stream */
3122     if (is->audio_stream >= 0)
3123         stream_component_close(is, is->audio_stream);
3124     if (is->video_stream >= 0)
3125         stream_component_close(is, is->video_stream);
3126     if (is->subtitle_stream >= 0)
3127         stream_component_close(is, is->subtitle_stream);
3128     if (ic) {
3129         avformat_close_input(&ic);
3130         is->ic = NULL;
3131     }
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     is->continue_read_thread = SDL_CreateCond();
3172
3173     init_clock(&is->vidclk, &is->videoq.serial);
3174     init_clock(&is->audclk, &is->audioq.serial);
3175     init_clock(&is->extclk, &is->extclk.serial);
3176     is->audio_clock_serial = -1;
3177     is->audio_volume = SDL_MIX_MAXVOLUME;
3178     is->muted = 0;
3179     is->av_sync_type = av_sync_type;
3180     is->read_tid     = SDL_CreateThread(read_thread, is);
3181     if (!is->read_tid) {
3182         av_log(NULL, AV_LOG_FATAL, "SDL_CreateThread(): %s\n", SDL_GetError());
3183 fail:
3184         stream_close(is);
3185         return NULL;
3186     }
3187     return is;
3188 }
3189
3190 static void stream_cycle_channel(VideoState *is, int codec_type)
3191 {
3192     AVFormatContext *ic = is->ic;
3193     int start_index, stream_index;
3194     int old_index;
3195     AVStream *st;
3196     AVProgram *p = NULL;
3197     int nb_streams = is->ic->nb_streams;
3198
3199     if (codec_type == AVMEDIA_TYPE_VIDEO) {
3200         start_index = is->last_video_stream;
3201         old_index = is->video_stream;
3202     } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
3203         start_index = is->last_audio_stream;
3204         old_index = is->audio_stream;
3205     } else {
3206         start_index = is->last_subtitle_stream;
3207         old_index = is->subtitle_stream;
3208     }
3209     stream_index = start_index;
3210
3211     if (codec_type != AVMEDIA_TYPE_VIDEO && is->video_stream != -1) {
3212         p = av_find_program_from_stream(ic, NULL, is->video_stream);
3213         if (p) {
3214             nb_streams = p->nb_stream_indexes;
3215             for (start_index = 0; start_index < nb_streams; start_index++)
3216                 if (p->stream_index[start_index] == stream_index)
3217                     break;
3218             if (start_index == nb_streams)
3219                 start_index = -1;
3220             stream_index = start_index;
3221         }
3222     }
3223
3224     for (;;) {
3225         if (++stream_index >= nb_streams)
3226         {
3227             if (codec_type == AVMEDIA_TYPE_SUBTITLE)
3228             {
3229                 stream_index = -1;
3230                 is->last_subtitle_stream = -1;
3231                 goto the_end;
3232             }
3233             if (start_index == -1)
3234                 return;
3235             stream_index = 0;
3236         }
3237         if (stream_index == start_index)
3238             return;
3239         st = is->ic->streams[p ? p->stream_index[stream_index] : stream_index];
3240         if (st->codec->codec_type == codec_type) {
3241             /* check that parameters are OK */
3242             switch (codec_type) {
3243             case AVMEDIA_TYPE_AUDIO:
3244                 if (st->codec->sample_rate != 0 &&
3245                     st->codec->channels != 0)
3246                     goto the_end;
3247                 break;
3248             case AVMEDIA_TYPE_VIDEO:
3249             case AVMEDIA_TYPE_SUBTITLE:
3250                 goto the_end;
3251             default:
3252                 break;
3253             }
3254         }
3255     }
3256  the_end:
3257     if (p && stream_index != -1)
3258         stream_index = p->stream_index[stream_index];
3259     av_log(NULL, AV_LOG_INFO, "Switch %s stream from #%d to #%d\n",
3260            av_get_media_type_string(codec_type),
3261            old_index,
3262            stream_index);
3263
3264     stream_component_close(is, old_index);
3265     stream_component_open(is, stream_index);
3266 }
3267
3268
3269 static void toggle_full_screen(VideoState *is)
3270 {
3271 #if defined(__APPLE__) && SDL_VERSION_ATLEAST(1, 2, 14)
3272     /* OS X needs to reallocate the SDL overlays */
3273     int i;
3274     for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++)
3275         is->pictq.queue[i].reallocate = 1;
3276 #endif
3277     is_full_screen = !is_full_screen;
3278     video_open(is, 1, NULL);
3279 }
3280
3281 static void toggle_audio_display(VideoState *is)
3282 {
3283     int bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
3284     int next = is->show_mode;
3285     do {
3286         next = (next + 1) % SHOW_MODE_NB;
3287     } while (next != is->show_mode && (next == SHOW_MODE_VIDEO && !is->video_st || next != SHOW_MODE_VIDEO && !is->audio_st));
3288     if (is->show_mode != next) {
3289         fill_rectangle(screen,
3290                     is->xleft, is->ytop, is->width, is->height,
3291                     bgcolor, 1);
3292         is->force_refresh = 1;
3293         is->show_mode = next;
3294     }
3295 }
3296
3297 static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
3298     double remaining_time = 0.0;
3299     SDL_PumpEvents();
3300     while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_ALLEVENTS)) {
3301         if (!cursor_hidden && av_gettime_relative() - cursor_last_shown > CURSOR_HIDE_DELAY) {
3302             SDL_ShowCursor(0);
3303             cursor_hidden = 1;
3304         }
3305         if (remaining_time > 0.0)
3306             av_usleep((int64_t)(remaining_time * 1000000.0));
3307         remaining_time = REFRESH_RATE;
3308         if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
3309             video_refresh(is, &remaining_time);
3310         SDL_PumpEvents();
3311     }
3312 }
3313
3314 static void seek_chapter(VideoState *is, int incr)
3315 {
3316     int64_t pos = get_master_clock(is) * AV_TIME_BASE;
3317     int i;
3318
3319     if (!is->ic->nb_chapters)
3320         return;
3321
3322     /* find the current chapter */
3323     for (i = 0; i < is->ic->nb_chapters; i++) {
3324         AVChapter *ch = is->ic->chapters[i];
3325         if (av_compare_ts(pos, AV_TIME_BASE_Q, ch->start, ch->time_base) < 0) {
3326             i--;
3327             break;
3328         }
3329     }
3330
3331     i += incr;
3332     i = FFMAX(i, 0);
3333     if (i >= is->ic->nb_chapters)
3334         return;
3335
3336     av_log(NULL, AV_LOG_VERBOSE, "Seeking to chapter %d.\n", i);
3337     stream_seek(is, av_rescale_q(is->ic->chapters[i]->start, is->ic->chapters[i]->time_base,
3338                                  AV_TIME_BASE_Q), 0, 0);
3339 }
3340
3341 /* handle an event sent by the GUI */
3342 static void event_loop(VideoState *cur_stream)
3343 {
3344     SDL_Event event;
3345     double incr, pos, frac;
3346
3347     for (;;) {
3348         double x;
3349         refresh_loop_wait_event(cur_stream, &event);
3350         switch (event.type) {
3351         case SDL_KEYDOWN:
3352             if (exit_on_keydown) {
3353                 do_exit(cur_stream);
3354                 break;
3355             }
3356             switch (event.key.keysym.sym) {
3357             case SDLK_ESCAPE:
3358             case SDLK_q:
3359                 do_exit(cur_stream);
3360                 break;
3361             case SDLK_f:
3362                 toggle_full_screen(cur_stream);
3363                 cur_stream->force_refresh = 1;
3364                 break;
3365             case SDLK_p:
3366             case SDLK_SPACE:
3367                 toggle_pause(cur_stream);
3368                 break;
3369             case SDLK_m:
3370                 toggle_mute(cur_stream);
3371                 break;
3372             case SDLK_KP_MULTIPLY:
3373             case SDLK_0:
3374                 update_volume(cur_stream, 1, SDL_VOLUME_STEP);
3375                 break;
3376             case SDLK_KP_DIVIDE:
3377             case SDLK_9:
3378                 update_volume(cur_stream, -1, SDL_VOLUME_STEP);
3379                 break;
3380             case SDLK_s: // S: Step to next frame
3381                 step_to_next_frame(cur_stream);
3382                 break;
3383             case SDLK_a:
3384                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3385                 break;
3386             case SDLK_v:
3387                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3388                 break;
3389             case SDLK_c:
3390                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3391                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3392                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3393                 break;
3394             case SDLK_t:
3395                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3396                 break;
3397             case SDLK_w:
3398 #if CONFIG_AVFILTER
3399                 if (cur_stream->show_mode == SHOW_MODE_VIDEO && cur_stream->vfilter_idx < nb_vfilters - 1) {
3400                     if (++cur_stream->vfilter_idx >= nb_vfilters)
3401                         cur_stream->vfilter_idx = 0;
3402                 } else {
3403                     cur_stream->vfilter_idx = 0;
3404                     toggle_audio_display(cur_stream);
3405                 }
3406 #else
3407                 toggle_audio_display(cur_stream);
3408 #endif
3409                 break;
3410             case SDLK_PAGEUP:
3411                 if (cur_stream->ic->nb_chapters <= 1) {
3412                     incr = 600.0;
3413                     goto do_seek;
3414                 }
3415                 seek_chapter(cur_stream, 1);
3416                 break;
3417             case SDLK_PAGEDOWN:
3418                 if (cur_stream->ic->nb_chapters <= 1) {
3419                     incr = -600.0;
3420                     goto do_seek;
3421                 }
3422                 seek_chapter(cur_stream, -1);
3423                 break;
3424             case SDLK_LEFT:
3425                 incr = -10.0;
3426                 goto do_seek;
3427             case SDLK_RIGHT:
3428                 incr = 10.0;
3429                 goto do_seek;
3430             case SDLK_UP:
3431                 incr = 60.0;
3432                 goto do_seek;
3433             case SDLK_DOWN:
3434                 incr = -60.0;
3435             do_seek:
3436                     if (seek_by_bytes) {
3437                         pos = -1;
3438                         if (pos < 0 && cur_stream->video_stream >= 0)
3439                             pos = frame_queue_last_pos(&cur_stream->pictq);
3440                         if (pos < 0 && cur_stream->audio_stream >= 0)
3441                             pos = frame_queue_last_pos(&cur_stream->sampq);
3442                         if (pos < 0)
3443                             pos = avio_tell(cur_stream->ic->pb);
3444                         if (cur_stream->ic->bit_rate)
3445                             incr *= cur_stream->ic->bit_rate / 8.0;
3446                         else
3447                             incr *= 180000.0;
3448                         pos += incr;
3449                         stream_seek(cur_stream, pos, incr, 1);
3450                     } else {
3451                         pos = get_master_clock(cur_stream);
3452                         if (isnan(pos))
3453                             pos = (double)cur_stream->seek_pos / AV_TIME_BASE;
3454                         pos += incr;
3455                         if (cur_stream->ic->start_time != AV_NOPTS_VALUE && pos < cur_stream->ic->start_time / (double)AV_TIME_BASE)
3456                             pos = cur_stream->ic->start_time / (double)AV_TIME_BASE;
3457                         stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE), 0);
3458                     }
3459                 break;
3460             default:
3461                 break;
3462             }
3463             break;
3464         case SDL_VIDEOEXPOSE:
3465             cur_stream->force_refresh = 1;
3466             break;
3467         case SDL_MOUSEBUTTONDOWN:
3468             if (exit_on_mousedown) {
3469                 do_exit(cur_stream);
3470                 break;
3471             }
3472         case SDL_MOUSEMOTION:
3473             if (cursor_hidden) {
3474                 SDL_ShowCursor(1);
3475                 cursor_hidden = 0;
3476             }
3477             cursor_last_shown = av_gettime_relative();
3478             if (event.type == SDL_MOUSEBUTTONDOWN) {
3479                 x = event.button.x;
3480             } else {
3481                 if (event.motion.state != SDL_PRESSED)
3482                     break;
3483                 x = event.motion.x;
3484             }
3485                 if (seek_by_bytes || cur_stream->ic->duration <= 0) {
3486                     uint64_t size =  avio_size(cur_stream->ic->pb);
3487                     stream_seek(cur_stream, size*x/cur_stream->width, 0, 1);
3488                 } else {
3489                     int64_t ts;
3490                     int ns, hh, mm, ss;
3491                     int tns, thh, tmm, tss;
3492                     tns  = cur_stream->ic->duration / 1000000LL;
3493                     thh  = tns / 3600;
3494                     tmm  = (tns % 3600) / 60;
3495                     tss  = (tns % 60);
3496                     frac = x / cur_stream->width;
3497                     ns   = frac * tns;
3498                     hh   = ns / 3600;
3499                     mm   = (ns % 3600) / 60;
3500                     ss   = (ns % 60);
3501                     av_log(NULL, AV_LOG_INFO,
3502                            "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d)       \n", frac*100,
3503                             hh, mm, ss, thh, tmm, tss);
3504                     ts = frac * cur_stream->ic->duration;
3505                     if (cur_stream->ic->start_time != AV_NOPTS_VALUE)
3506                         ts += cur_stream->ic->start_time;
3507                     stream_seek(cur_stream, ts, 0, 0);
3508                 }
3509             break;
3510         case SDL_VIDEORESIZE:
3511                 screen = SDL_SetVideoMode(FFMIN(16383, event.resize.w), event.resize.h, 0,
3512                                           SDL_HWSURFACE|(is_full_screen?SDL_FULLSCREEN:SDL_RESIZABLE)|SDL_ASYNCBLIT|SDL_HWACCEL);
3513                 if (!screen) {
3514                     av_log(NULL, AV_LOG_FATAL, "Failed to set video mode\n");
3515                     do_exit(cur_stream);
3516                 }
3517                 screen_width  = cur_stream->width  = screen->w;
3518                 screen_height = cur_stream->height = screen->h;
3519                 cur_stream->force_refresh = 1;
3520             break;
3521         case SDL_QUIT:
3522         case FF_QUIT_EVENT:
3523             do_exit(cur_stream);
3524             break;
3525         case FF_ALLOC_EVENT:
3526             alloc_picture(event.user.data1);
3527             break;
3528         default:
3529             break;
3530         }
3531     }
3532 }
3533
3534 static int opt_frame_size(void *optctx, const char *opt, const char *arg)
3535 {
3536     av_log(NULL, AV_LOG_WARNING, "Option -s is deprecated, use -video_size.\n");
3537     return opt_default(NULL, "video_size", arg);
3538 }
3539
3540 static int opt_width(void *optctx, const char *opt, const char *arg)
3541 {
3542     screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3543     return 0;
3544 }
3545
3546 static int opt_height(void *optctx, const char *opt, const char *arg)
3547 {
3548     screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3549     return 0;
3550 }
3551
3552 static int opt_format(void *optctx, const char *opt, const char *arg)
3553 {
3554     file_iformat = av_find_input_format(arg);
3555     if (!file_iformat) {
3556         av_log(NULL, AV_LOG_FATAL, "Unknown input format: %s\n", arg);
3557         return AVERROR(EINVAL);
3558     }
3559     return 0;
3560 }
3561
3562 static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
3563 {
3564     av_log(NULL, AV_LOG_WARNING, "Option -pix_fmt is deprecated, use -pixel_format.\n");
3565     return opt_default(NULL, "pixel_format", arg);
3566 }
3567
3568 static int opt_sync(void *optctx, const char *opt, const char *arg)
3569 {
3570     if (!strcmp(arg, "audio"))
3571         av_sync_type = AV_SYNC_AUDIO_MASTER;
3572     else if (!strcmp(arg, "video"))
3573         av_sync_type = AV_SYNC_VIDEO_MASTER;
3574     else if (!strcmp(arg, "ext"))
3575         av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
3576     else {
3577         av_log(NULL, AV_LOG_ERROR, "Unknown value for %s: %s\n", opt, arg);
3578         exit(1);
3579     }
3580     return 0;
3581 }
3582
3583 static int opt_seek(void *optctx, const char *opt, const char *arg)
3584 {
3585     start_time = parse_time_or_die(opt, arg, 1);
3586     return 0;
3587 }
3588
3589 static int opt_duration(void *optctx, const char *opt, const char *arg)
3590 {
3591     duration = parse_time_or_die(opt, arg, 1);
3592     return 0;
3593 }
3594
3595 static int opt_show_mode(void *optctx, const char *opt, const char *arg)
3596 {
3597     show_mode = !strcmp(arg, "video") ? SHOW_MODE_VIDEO :
3598                 !strcmp(arg, "waves") ? SHOW_MODE_WAVES :
3599                 !strcmp(arg, "rdft" ) ? SHOW_MODE_RDFT  :
3600                 parse_number_or_die(opt, arg, OPT_INT, 0, SHOW_MODE_NB-1);
3601     return 0;
3602 }
3603
3604 static void opt_input_file(void *optctx, const char *filename)
3605 {
3606     if (input_filename) {
3607         av_log(NULL, AV_LOG_FATAL,
3608                "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3609                 filename, input_filename);
3610         exit(1);
3611     }
3612     if (!strcmp(filename, "-"))
3613         filename = "pipe:";
3614     input_filename = filename;
3615 }
3616
3617 static int opt_codec(void *optctx, const char *opt, const char *arg)
3618 {
3619    const char *spec = strchr(opt, ':');
3620    if (!spec) {
3621        av_log(NULL, AV_LOG_ERROR,
3622               "No media specifier was specified in '%s' in option '%s'\n",
3623                arg, opt);
3624        return AVERROR(EINVAL);
3625    }
3626    spec++;
3627    switch (spec[0]) {
3628    case 'a' :    audio_codec_name = arg; break;
3629    case 's' : subtitle_codec_name = arg; break;
3630    case 'v' :    video_codec_name = arg; break;
3631    default:
3632        av_log(NULL, AV_LOG_ERROR,
3633               "Invalid media specifier '%s' in option '%s'\n", spec, opt);
3634        return AVERROR(EINVAL);
3635    }
3636    return 0;
3637 }
3638
3639 static int dummy;
3640
3641 static const OptionDef options[] = {
3642 #include "cmdutils_common_opts.h"
3643     { "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
3644     { "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
3645     { "s", HAS_ARG | OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
3646     { "fs", OPT_BOOL, { &is_full_screen }, "force full screen" },
3647     { "an", OPT_BOOL, { &audio_disable }, "disable audio" },
3648     { "vn", OPT_BOOL, { &video_disable }, "disable video" },
3649     { "sn", OPT_BOOL, { &subtitle_disable }, "disable subtitling" },
3650     { "ast", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_specifier" },
3651     { "vst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_specifier" },
3652     { "sst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_specifier" },
3653     { "ss", HAS_ARG, { .func_arg = opt_seek }, "seek to a given position in seconds", "pos" },
3654     { "t", HAS_ARG, { .func_arg = opt_duration }, "play  \"duration\" seconds of audio/video", "duration" },
3655     { "bytes", OPT_INT | HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
3656     { "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
3657     { "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
3658     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
3659     { "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" },
3660     { "fast", OPT_BOOL | OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
3661     { "genpts", OPT_BOOL | OPT_EXPERT, { &genpts }, "generate pts", "" },
3662     { "drp", OPT_INT | HAS_ARG | OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
3663     { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, { &lowres }, "", "" },
3664     { "sync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
3665     { "autoexit", OPT_BOOL | OPT_EXPERT, { &autoexit }, "exit at the end", "" },
3666     { "exitonkeydown", OPT_BOOL | OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
3667     { "exitonmousedown", OPT_BOOL | OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
3668     { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
3669     { "framedrop", OPT_BOOL | OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
3670     { "infbuf", OPT_BOOL | OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
3671     { "window_title", OPT_STRING | HAS_ARG, { &window_title }, "set window title", "window title" },
3672 #if CONFIG_AVFILTER
3673     { "vf", OPT_EXPERT | HAS_ARG, { .func_arg = opt_add_vfilter }, "set video filters", "filter_graph" },
3674     { "af", OPT_STRING | HAS_ARG, { &afilters }, "set audio filters", "filter_graph" },
3675 #endif
3676     { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
3677     { "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
3678     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default }, "generic catch all option", "" },
3679     { "i", OPT_BOOL, { &dummy}, "read specified file", "input_file"},
3680     { "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
3681     { "acodec", HAS_ARG | OPT_STRING | OPT_EXPERT, {    &audio_codec_name }, "force audio decoder",    "decoder_name" },
3682     { "scodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
3683     { "vcodec", HAS_ARG | OPT_STRING | OPT_EXPERT, {    &video_codec_name }, "force video decoder",    "decoder_name" },
3684     { "autorotate", OPT_BOOL, { &autorotate }, "automatically rotate video", "" },
3685     { NULL, },
3686 };
3687
3688 static void show_usage(void)
3689 {
3690     av_log(NULL, AV_LOG_INFO, "Simple media player\n");
3691     av_log(NULL, AV_LOG_INFO, "usage: %s [options] input_file\n", program_name);
3692     av_log(NULL, AV_LOG_INFO, "\n");
3693 }
3694
3695 void show_help_default(const char *opt, const char *arg)
3696 {
3697     av_log_set_callback(log_callback_help);
3698     show_usage();
3699     show_help_options(options, "Main options:", 0, OPT_EXPERT, 0);
3700     show_help_options(options, "Advanced options:", OPT_EXPERT, 0, 0);
3701     printf("\n");
3702     show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3703     show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3704 #if !CONFIG_AVFILTER
3705     show_help_children(sws_get_class(), AV_OPT_FLAG_ENCODING_PARAM);
3706 #else
3707     show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
3708 #endif
3709     printf("\nWhile playing:\n"
3710            "q, ESC              quit\n"
3711            "f                   toggle full screen\n"
3712            "p, SPC              pause\n"
3713            "m                   toggle mute\n"
3714            "9, 0                decrease and increase volume respectively\n"
3715            "/, *                decrease and increase volume respectively\n"
3716            "a                   cycle audio channel in the current program\n"
3717            "v                   cycle video channel\n"
3718            "t                   cycle subtitle channel in the current program\n"
3719            "c                   cycle program\n"
3720            "w                   cycle video filters or show modes\n"
3721            "s                   activate frame-step mode\n"
3722            "left/right          seek backward/forward 10 seconds\n"
3723            "down/up             seek backward/forward 1 minute\n"
3724            "page down/page up   seek backward/forward 10 minutes\n"
3725            "mouse click         seek to percentage in file corresponding to fraction of width\n"
3726            );
3727 }
3728
3729 static int lockmgr(void **mtx, enum AVLockOp op)
3730 {
3731    switch(op) {
3732       case AV_LOCK_CREATE:
3733           *mtx = SDL_CreateMutex();
3734           if(!*mtx) {
3735               av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
3736               return 1;
3737           }
3738           return 0;
3739       case AV_LOCK_OBTAIN:
3740           return !!SDL_LockMutex(*mtx);
3741       case AV_LOCK_RELEASE:
3742           return !!SDL_UnlockMutex(*mtx);
3743       case AV_LOCK_DESTROY:
3744           SDL_DestroyMutex(*mtx);
3745           return 0;
3746    }
3747    return 1;
3748 }
3749
3750 /* Called from the main */
3751 int main(int argc, char **argv)
3752 {
3753     int flags;
3754     VideoState *is;
3755     char dummy_videodriver[] = "SDL_VIDEODRIVER=dummy";
3756
3757     av_log_set_flags(AV_LOG_SKIP_REPEATED);
3758     parse_loglevel(argc, argv, options);
3759
3760     /* register all codecs, demux and protocols */
3761 #if CONFIG_AVDEVICE
3762     avdevice_register_all();
3763 #endif
3764 #if CONFIG_AVFILTER
3765     avfilter_register_all();
3766 #endif
3767     av_register_all();
3768     avformat_network_init();
3769
3770     init_opts();
3771
3772     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
3773     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
3774
3775     show_banner(argc, argv, options);
3776
3777     parse_options(NULL, argc, argv, options, opt_input_file);
3778
3779     if (!input_filename) {
3780         show_usage();
3781         av_log(NULL, AV_LOG_FATAL, "An input file must be specified\n");
3782         av_log(NULL, AV_LOG_FATAL,
3783                "Use -h to get full help or, even better, run 'man %s'\n", program_name);
3784         exit(1);
3785     }
3786
3787     if (display_disable) {
3788         video_disable = 1;
3789     }
3790     flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
3791     if (audio_disable)
3792         flags &= ~SDL_INIT_AUDIO;
3793     if (display_disable)
3794         SDL_putenv(dummy_videodriver); /* For the event queue, we always need a video driver. */
3795 #if !defined(_WIN32) && !defined(__APPLE__)
3796     flags |= SDL_INIT_EVENTTHREAD; /* Not supported on Windows or Mac OS X */
3797 #endif
3798     if (SDL_Init (flags)) {
3799         av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n", SDL_GetError());
3800         av_log(NULL, AV_LOG_FATAL, "(Did you set the DISPLAY variable?)\n");
3801         exit(1);
3802     }
3803
3804     if (!display_disable) {
3805         const SDL_VideoInfo *vi = SDL_GetVideoInfo();
3806         fs_screen_width = vi->current_w;
3807         fs_screen_height = vi->current_h;
3808     }
3809
3810     SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
3811     SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
3812     SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
3813
3814     SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
3815
3816     if (av_lockmgr_register(lockmgr)) {
3817         av_log(NULL, AV_LOG_FATAL, "Could not initialize lock manager!\n");
3818         do_exit(NULL);
3819     }
3820
3821     av_init_packet(&flush_pkt);
3822     flush_pkt.data = (uint8_t *)&flush_pkt;
3823
3824     is = stream_open(input_filename, file_iformat);
3825     if (!is) {
3826         av_log(NULL, AV_LOG_FATAL, "Failed to initialize VideoState!\n");
3827         do_exit(NULL);
3828     }
3829
3830     event_loop(is);
3831
3832     /* never returns */
3833
3834     return 0;
3835 }