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