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