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