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