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