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