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