ffplay: drop remaining frames in current audio avpacket when seeking
[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         SDL_CondSignal(is->continue_read_thread);
1188     }
1189 }
1190
1191 /* pause or resume the video */
1192 static void stream_toggle_pause(VideoState *is)
1193 {
1194     if (is->paused) {
1195         is->frame_timer += av_gettime() / 1000000.0 + is->video_current_pts_drift - is->video_current_pts;
1196         if (is->read_pause_return != AVERROR(ENOSYS)) {
1197             is->video_current_pts = is->video_current_pts_drift + av_gettime() / 1000000.0;
1198         }
1199         is->video_current_pts_drift = is->video_current_pts - av_gettime() / 1000000.0;
1200     }
1201     update_external_clock_pts(is, get_external_clock(is));
1202     is->paused = !is->paused;
1203 }
1204
1205 static void toggle_pause(VideoState *is)
1206 {
1207     stream_toggle_pause(is);
1208     is->step = 0;
1209 }
1210
1211 static void step_to_next_frame(VideoState *is)
1212 {
1213     /* if the stream is paused unpause it, then step */
1214     if (is->paused)
1215         stream_toggle_pause(is);
1216     is->step = 1;
1217 }
1218
1219 static double compute_target_delay(double delay, VideoState *is)
1220 {
1221     double sync_threshold, diff;
1222
1223     /* update delay to follow master synchronisation source */
1224     if (get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER) {
1225         /* if video is slave, we try to correct big delays by
1226            duplicating or deleting a frame */
1227         diff = get_video_clock(is) - get_master_clock(is);
1228
1229         /* skip or repeat frame. We take into account the
1230            delay to compute the threshold. I still don't know
1231            if it is the best guess */
1232         sync_threshold = FFMAX(AV_SYNC_THRESHOLD, delay);
1233         if (fabs(diff) < AV_NOSYNC_THRESHOLD) {
1234             if (diff <= -sync_threshold)
1235                 delay = 0;
1236             else if (diff >= sync_threshold)
1237                 delay = 2 * delay;
1238         }
1239     }
1240
1241     av_dlog(NULL, "video: delay=%0.3f A-V=%f\n",
1242             delay, -diff);
1243
1244     return delay;
1245 }
1246
1247 static void pictq_next_picture(VideoState *is) {
1248     /* update queue size and signal for next picture */
1249     if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE)
1250         is->pictq_rindex = 0;
1251
1252     SDL_LockMutex(is->pictq_mutex);
1253     is->pictq_size--;
1254     SDL_CondSignal(is->pictq_cond);
1255     SDL_UnlockMutex(is->pictq_mutex);
1256 }
1257
1258 static void pictq_prev_picture(VideoState *is) {
1259     VideoPicture *prevvp;
1260     /* update queue size and signal for the previous picture */
1261     prevvp = &is->pictq[(is->pictq_rindex + VIDEO_PICTURE_QUEUE_SIZE - 1) % VIDEO_PICTURE_QUEUE_SIZE];
1262     if (prevvp->allocated && prevvp->serial == is->videoq.serial) {
1263         SDL_LockMutex(is->pictq_mutex);
1264         if (is->pictq_size < VIDEO_PICTURE_QUEUE_SIZE - 1) {
1265             if (--is->pictq_rindex == -1)
1266                 is->pictq_rindex = VIDEO_PICTURE_QUEUE_SIZE - 1;
1267             is->pictq_size++;
1268         }
1269         SDL_CondSignal(is->pictq_cond);
1270         SDL_UnlockMutex(is->pictq_mutex);
1271     }
1272 }
1273
1274 static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
1275     double time = av_gettime() / 1000000.0;
1276     /* update current video pts */
1277     is->video_current_pts = pts;
1278     is->video_current_pts_drift = is->video_current_pts - time;
1279     is->video_current_pos = pos;
1280     is->frame_last_pts = pts;
1281     if (is->videoq.serial == serial)
1282         check_external_clock_sync(is, is->video_current_pts);
1283 }
1284
1285 /* called to display each frame */
1286 static void video_refresh(void *opaque, double *remaining_time)
1287 {
1288     VideoState *is = opaque;
1289     VideoPicture *vp;
1290     double time;
1291
1292     SubPicture *sp, *sp2;
1293
1294     if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
1295         check_external_clock_speed(is);
1296
1297     if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {
1298         time = av_gettime() / 1000000.0;
1299         if (is->force_refresh || is->last_vis_time + rdftspeed < time) {
1300             video_display(is);
1301             is->last_vis_time = time;
1302         }
1303         *remaining_time = FFMIN(*remaining_time, is->last_vis_time + rdftspeed - time);
1304     }
1305
1306     if (is->video_st) {
1307         if (is->force_refresh)
1308             pictq_prev_picture(is);
1309 retry:
1310         if (is->pictq_size == 0) {
1311             SDL_LockMutex(is->pictq_mutex);
1312             if (is->frame_last_dropped_pts != AV_NOPTS_VALUE && is->frame_last_dropped_pts > is->frame_last_pts) {
1313                 update_video_pts(is, is->frame_last_dropped_pts, is->frame_last_dropped_pos, 0);
1314                 is->frame_last_dropped_pts = AV_NOPTS_VALUE;
1315             }
1316             SDL_UnlockMutex(is->pictq_mutex);
1317             // nothing to do, no picture to display in the queue
1318         } else {
1319             double last_duration, duration, delay;
1320             /* dequeue the picture */
1321             vp = &is->pictq[is->pictq_rindex];
1322
1323             if (vp->serial != is->videoq.serial) {
1324                 pictq_next_picture(is);
1325                 goto retry;
1326             }
1327
1328             if (is->paused)
1329                 goto display;
1330
1331             /* compute nominal last_duration */
1332             last_duration = vp->pts - is->frame_last_pts;
1333             if (last_duration > 0 && last_duration < is->max_frame_duration) {
1334                 /* if duration of the last frame was sane, update last_duration in video state */
1335                 is->frame_last_duration = last_duration;
1336             }
1337             delay = compute_target_delay(is->frame_last_duration, is);
1338
1339             time= av_gettime()/1000000.0;
1340             if (time < is->frame_timer + delay) {
1341                 *remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);
1342                 return;
1343             }
1344
1345             if (delay > 0)
1346                 is->frame_timer += delay * FFMAX(1, floor((time-is->frame_timer) / delay));
1347
1348             SDL_LockMutex(is->pictq_mutex);
1349             update_video_pts(is, vp->pts, vp->pos, vp->serial);
1350             SDL_UnlockMutex(is->pictq_mutex);
1351
1352             if (is->pictq_size > 1) {
1353                 VideoPicture *nextvp = &is->pictq[(is->pictq_rindex + 1) % VIDEO_PICTURE_QUEUE_SIZE];
1354                 duration = nextvp->pts - vp->pts;
1355                 if(!is->step && (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
1356                     is->frame_drops_late++;
1357                     pictq_next_picture(is);
1358                     goto retry;
1359                 }
1360             }
1361
1362             if (is->subtitle_st) {
1363                 if (is->subtitle_stream_changed) {
1364                     SDL_LockMutex(is->subpq_mutex);
1365
1366                     while (is->subpq_size) {
1367                         free_subpicture(&is->subpq[is->subpq_rindex]);
1368
1369                         /* update queue size and signal for next picture */
1370                         if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
1371                             is->subpq_rindex = 0;
1372
1373                         is->subpq_size--;
1374                     }
1375                     is->subtitle_stream_changed = 0;
1376
1377                     SDL_CondSignal(is->subpq_cond);
1378                     SDL_UnlockMutex(is->subpq_mutex);
1379                 } else {
1380                     if (is->subpq_size > 0) {
1381                         sp = &is->subpq[is->subpq_rindex];
1382
1383                         if (is->subpq_size > 1)
1384                             sp2 = &is->subpq[(is->subpq_rindex + 1) % SUBPICTURE_QUEUE_SIZE];
1385                         else
1386                             sp2 = NULL;
1387
1388                         if ((is->video_current_pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1389                                 || (sp2 && is->video_current_pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1390                         {
1391                             free_subpicture(sp);
1392
1393                             /* update queue size and signal for next picture */
1394                             if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
1395                                 is->subpq_rindex = 0;
1396
1397                             SDL_LockMutex(is->subpq_mutex);
1398                             is->subpq_size--;
1399                             SDL_CondSignal(is->subpq_cond);
1400                             SDL_UnlockMutex(is->subpq_mutex);
1401                         }
1402                     }
1403                 }
1404             }
1405
1406 display:
1407             /* display picture */
1408             if (!display_disable && is->show_mode == SHOW_MODE_VIDEO)
1409                 video_display(is);
1410
1411             pictq_next_picture(is);
1412
1413             if (is->step && !is->paused)
1414                 stream_toggle_pause(is);
1415         }
1416     }
1417     is->force_refresh = 0;
1418     if (show_status) {
1419         static int64_t last_time;
1420         int64_t cur_time;
1421         int aqsize, vqsize, sqsize;
1422         double av_diff;
1423
1424         cur_time = av_gettime();
1425         if (!last_time || (cur_time - last_time) >= 30000) {
1426             aqsize = 0;
1427             vqsize = 0;
1428             sqsize = 0;
1429             if (is->audio_st)
1430                 aqsize = is->audioq.size;
1431             if (is->video_st)
1432                 vqsize = is->videoq.size;
1433             if (is->subtitle_st)
1434                 sqsize = is->subtitleq.size;
1435             av_diff = 0;
1436             if (is->audio_st && is->video_st)
1437                 av_diff = get_audio_clock(is) - get_video_clock(is);
1438             printf("%7.2f A-V:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64"   \r",
1439                    get_master_clock(is),
1440                    av_diff,
1441                    is->frame_drops_early + is->frame_drops_late,
1442                    aqsize / 1024,
1443                    vqsize / 1024,
1444                    sqsize,
1445                    is->video_st ? is->video_st->codec->pts_correction_num_faulty_dts : 0,
1446                    is->video_st ? is->video_st->codec->pts_correction_num_faulty_pts : 0);
1447             fflush(stdout);
1448             last_time = cur_time;
1449         }
1450     }
1451 }
1452
1453 /* allocate a picture (needs to do that in main thread to avoid
1454    potential locking problems */
1455 static void alloc_picture(VideoState *is)
1456 {
1457     VideoPicture *vp;
1458
1459     vp = &is->pictq[is->pictq_windex];
1460
1461     if (vp->bmp)
1462         SDL_FreeYUVOverlay(vp->bmp);
1463
1464 #if CONFIG_AVFILTER
1465     avfilter_unref_bufferp(&vp->picref);
1466 #endif
1467
1468     video_open(is, 0, vp);
1469
1470     vp->bmp = SDL_CreateYUVOverlay(vp->width, vp->height,
1471                                    SDL_YV12_OVERLAY,
1472                                    screen);
1473     if (!vp->bmp || vp->bmp->pitches[0] < vp->width) {
1474         /* SDL allocates a buffer smaller than requested if the video
1475          * overlay hardware is unable to support the requested size. */
1476         fprintf(stderr, "Error: the video system does not support an image\n"
1477                         "size of %dx%d pixels. Try using -lowres or -vf \"scale=w:h\"\n"
1478                         "to reduce the image size.\n", vp->width, vp->height );
1479         do_exit(is);
1480     }
1481
1482     SDL_LockMutex(is->pictq_mutex);
1483     vp->allocated = 1;
1484     SDL_CondSignal(is->pictq_cond);
1485     SDL_UnlockMutex(is->pictq_mutex);
1486 }
1487
1488 static void duplicate_right_border_pixels(SDL_Overlay *bmp) {
1489     int i, width, height;
1490     Uint8 *p, *maxp;
1491     for (i = 0; i < 3; i++) {
1492         width  = bmp->w;
1493         height = bmp->h;
1494         if (i > 0) {
1495             width  >>= 1;
1496             height >>= 1;
1497         }
1498         if (bmp->pitches[i] > width) {
1499             maxp = bmp->pixels[i] + bmp->pitches[i] * height - 1;
1500             for (p = bmp->pixels[i] + width - 1; p < maxp; p += bmp->pitches[i])
1501                 *(p+1) = *p;
1502         }
1503     }
1504 }
1505
1506 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, int64_t pos, int serial)
1507 {
1508     VideoPicture *vp;
1509
1510 #if defined(DEBUG_SYNC) && 0
1511     printf("frame_type=%c pts=%0.3f\n",
1512            av_get_picture_type_char(src_frame->pict_type), pts);
1513 #endif
1514
1515     /* wait until we have space to put a new picture */
1516     SDL_LockMutex(is->pictq_mutex);
1517
1518     /* keep the last already displayed picture in the queue */
1519     while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE - 2 &&
1520            !is->videoq.abort_request) {
1521         SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1522     }
1523     SDL_UnlockMutex(is->pictq_mutex);
1524
1525     if (is->videoq.abort_request)
1526         return -1;
1527
1528     vp = &is->pictq[is->pictq_windex];
1529
1530 #if CONFIG_AVFILTER
1531     vp->sample_aspect_ratio = ((AVFilterBufferRef *)src_frame->opaque)->video->sample_aspect_ratio;
1532 #else
1533     vp->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, src_frame);
1534 #endif
1535
1536     /* alloc or resize hardware picture buffer */
1537     if (!vp->bmp || vp->reallocate || !vp->allocated ||
1538         vp->width  != src_frame->width ||
1539         vp->height != src_frame->height) {
1540         SDL_Event event;
1541
1542         vp->allocated  = 0;
1543         vp->reallocate = 0;
1544         vp->width = src_frame->width;
1545         vp->height = src_frame->height;
1546
1547         /* the allocation must be done in the main thread to avoid
1548            locking problems. */
1549         event.type = FF_ALLOC_EVENT;
1550         event.user.data1 = is;
1551         SDL_PushEvent(&event);
1552
1553         /* wait until the picture is allocated */
1554         SDL_LockMutex(is->pictq_mutex);
1555         while (!vp->allocated && !is->videoq.abort_request) {
1556             SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1557         }
1558         /* if the queue is aborted, we have to pop the pending ALLOC event or wait for the allocation to complete */
1559         if (is->videoq.abort_request && SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_EVENTMASK(FF_ALLOC_EVENT)) != 1) {
1560             while (!vp->allocated) {
1561                 SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1562             }
1563         }
1564         SDL_UnlockMutex(is->pictq_mutex);
1565
1566         if (is->videoq.abort_request)
1567             return -1;
1568     }
1569
1570     /* if the frame is not skipped, then display it */
1571     if (vp->bmp) {
1572         AVPicture pict = { { 0 } };
1573 #if CONFIG_AVFILTER
1574         avfilter_unref_bufferp(&vp->picref);
1575         vp->picref = src_frame->opaque;
1576 #endif
1577
1578         /* get a pointer on the bitmap */
1579         SDL_LockYUVOverlay (vp->bmp);
1580
1581         pict.data[0] = vp->bmp->pixels[0];
1582         pict.data[1] = vp->bmp->pixels[2];
1583         pict.data[2] = vp->bmp->pixels[1];
1584
1585         pict.linesize[0] = vp->bmp->pitches[0];
1586         pict.linesize[1] = vp->bmp->pitches[2];
1587         pict.linesize[2] = vp->bmp->pitches[1];
1588
1589 #if CONFIG_AVFILTER
1590         // FIXME use direct rendering
1591         av_picture_copy(&pict, (AVPicture *)src_frame,
1592                         src_frame->format, vp->width, vp->height);
1593 #else
1594         av_opt_get_int(sws_opts, "sws_flags", 0, &sws_flags);
1595         is->img_convert_ctx = sws_getCachedContext(is->img_convert_ctx,
1596             vp->width, vp->height, src_frame->format, vp->width, vp->height,
1597             AV_PIX_FMT_YUV420P, sws_flags, NULL, NULL, NULL);
1598         if (is->img_convert_ctx == NULL) {
1599             fprintf(stderr, "Cannot initialize the conversion context\n");
1600             exit(1);
1601         }
1602         sws_scale(is->img_convert_ctx, src_frame->data, src_frame->linesize,
1603                   0, vp->height, pict.data, pict.linesize);
1604 #endif
1605         /* workaround SDL PITCH_WORKAROUND */
1606         duplicate_right_border_pixels(vp->bmp);
1607         /* update the bitmap content */
1608         SDL_UnlockYUVOverlay(vp->bmp);
1609
1610         vp->pts = pts;
1611         vp->pos = pos;
1612         vp->serial = serial;
1613
1614         /* now we can update the picture count */
1615         if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE)
1616             is->pictq_windex = 0;
1617         SDL_LockMutex(is->pictq_mutex);
1618         is->pictq_size++;
1619         SDL_UnlockMutex(is->pictq_mutex);
1620     }
1621     return 0;
1622 }
1623
1624 static int get_video_frame(VideoState *is, AVFrame *frame, int64_t *pts, AVPacket *pkt, int *serial)
1625 {
1626     int got_picture;
1627
1628     if (packet_queue_get(&is->videoq, pkt, 1, serial) < 0)
1629         return -1;
1630
1631     if (pkt->data == flush_pkt.data) {
1632         avcodec_flush_buffers(is->video_st->codec);
1633
1634         SDL_LockMutex(is->pictq_mutex);
1635         // Make sure there are no long delay timers (ideally we should just flush the queue but that's harder)
1636         while (is->pictq_size && !is->videoq.abort_request) {
1637             SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1638         }
1639         is->video_current_pos = -1;
1640         is->frame_last_pts = AV_NOPTS_VALUE;
1641         is->frame_last_duration = 0;
1642         is->frame_timer = (double)av_gettime() / 1000000.0;
1643         is->frame_last_dropped_pts = AV_NOPTS_VALUE;
1644         SDL_UnlockMutex(is->pictq_mutex);
1645
1646         return 0;
1647     }
1648
1649     if(avcodec_decode_video2(is->video_st->codec, frame, &got_picture, pkt) < 0)
1650         return 0;
1651
1652     if (got_picture) {
1653         int ret = 1;
1654
1655         if (decoder_reorder_pts == -1) {
1656             *pts = av_frame_get_best_effort_timestamp(frame);
1657         } else if (decoder_reorder_pts) {
1658             *pts = frame->pkt_pts;
1659         } else {
1660             *pts = frame->pkt_dts;
1661         }
1662
1663         if (*pts == AV_NOPTS_VALUE) {
1664             *pts = 0;
1665         }
1666
1667         if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
1668             SDL_LockMutex(is->pictq_mutex);
1669             if (is->frame_last_pts != AV_NOPTS_VALUE && *pts) {
1670                 double clockdiff = get_video_clock(is) - get_master_clock(is);
1671                 double dpts = av_q2d(is->video_st->time_base) * *pts;
1672                 double ptsdiff = dpts - is->frame_last_pts;
1673                 if (fabs(clockdiff) < AV_NOSYNC_THRESHOLD &&
1674                      ptsdiff > 0 && ptsdiff < AV_NOSYNC_THRESHOLD &&
1675                      clockdiff + ptsdiff - is->frame_last_filter_delay < 0) {
1676                     is->frame_last_dropped_pos = pkt->pos;
1677                     is->frame_last_dropped_pts = dpts;
1678                     is->frame_drops_early++;
1679                     ret = 0;
1680                 }
1681             }
1682             SDL_UnlockMutex(is->pictq_mutex);
1683         }
1684
1685         return ret;
1686     }
1687     return 0;
1688 }
1689
1690 #if CONFIG_AVFILTER
1691 static int configure_filtergraph(AVFilterGraph *graph, const char *filtergraph,
1692                                  AVFilterContext *source_ctx, AVFilterContext *sink_ctx)
1693 {
1694     int ret;
1695     AVFilterInOut *outputs = NULL, *inputs = NULL;
1696
1697     if (filtergraph) {
1698         outputs = avfilter_inout_alloc();
1699         inputs  = avfilter_inout_alloc();
1700         if (!outputs || !inputs) {
1701             ret = AVERROR(ENOMEM);
1702             goto fail;
1703         }
1704
1705         outputs->name       = av_strdup("in");
1706         outputs->filter_ctx = source_ctx;
1707         outputs->pad_idx    = 0;
1708         outputs->next       = NULL;
1709
1710         inputs->name        = av_strdup("out");
1711         inputs->filter_ctx  = sink_ctx;
1712         inputs->pad_idx     = 0;
1713         inputs->next        = NULL;
1714
1715         if ((ret = avfilter_graph_parse(graph, filtergraph, &inputs, &outputs, NULL)) < 0)
1716             goto fail;
1717     } else {
1718         if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
1719             goto fail;
1720     }
1721
1722     ret = avfilter_graph_config(graph, NULL);
1723 fail:
1724     avfilter_inout_free(&outputs);
1725     avfilter_inout_free(&inputs);
1726     return ret;
1727 }
1728
1729 static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const char *vfilters, AVFrame *frame)
1730 {
1731     static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
1732     char sws_flags_str[128];
1733     char buffersrc_args[256];
1734     int ret;
1735     AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
1736     AVFilterContext *filt_src = NULL, *filt_out = NULL, *filt_crop;
1737     AVCodecContext *codec = is->video_st->codec;
1738
1739     if (!buffersink_params)
1740         return AVERROR(ENOMEM);
1741
1742     av_opt_get_int(sws_opts, "sws_flags", 0, &sws_flags);
1743     snprintf(sws_flags_str, sizeof(sws_flags_str), "flags=%"PRId64, sws_flags);
1744     graph->scale_sws_opts = av_strdup(sws_flags_str);
1745
1746     snprintf(buffersrc_args, sizeof(buffersrc_args),
1747              "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
1748              frame->width, frame->height, frame->format,
1749              is->video_st->time_base.num, is->video_st->time_base.den,
1750              codec->sample_aspect_ratio.num, FFMAX(codec->sample_aspect_ratio.den, 1));
1751
1752     if ((ret = avfilter_graph_create_filter(&filt_src,
1753                                             avfilter_get_by_name("buffer"),
1754                                             "ffplay_buffer", buffersrc_args, NULL,
1755                                             graph)) < 0)
1756         goto fail;
1757
1758     buffersink_params->pixel_fmts = pix_fmts;
1759     ret = avfilter_graph_create_filter(&filt_out,
1760                                        avfilter_get_by_name("ffbuffersink"),
1761                                        "ffplay_buffersink", NULL, buffersink_params, graph);
1762     if (ret < 0)
1763         goto fail;
1764
1765     /* SDL YUV code is not handling odd width/height for some driver
1766      * combinations, therefore we crop the picture to an even width/height. */
1767     if ((ret = avfilter_graph_create_filter(&filt_crop,
1768                                             avfilter_get_by_name("crop"),
1769                                             "ffplay_crop", "floor(in_w/2)*2:floor(in_h/2)*2", NULL, graph)) < 0)
1770         goto fail;
1771     if ((ret = avfilter_link(filt_crop, 0, filt_out, 0)) < 0)
1772         goto fail;
1773
1774     if ((ret = configure_filtergraph(graph, vfilters, filt_src, filt_crop)) < 0)
1775         goto fail;
1776
1777     is->in_video_filter  = filt_src;
1778     is->out_video_filter = filt_out;
1779
1780 fail:
1781     av_freep(&buffersink_params);
1782     return ret;
1783 }
1784
1785 #endif  /* CONFIG_AVFILTER */
1786
1787 static int video_thread(void *arg)
1788 {
1789     AVPacket pkt = { 0 };
1790     VideoState *is = arg;
1791     AVFrame *frame = avcodec_alloc_frame();
1792     int64_t pts_int = AV_NOPTS_VALUE, pos = -1;
1793     double pts;
1794     int ret;
1795     int serial = 0;
1796
1797 #if CONFIG_AVFILTER
1798     AVCodecContext *codec = is->video_st->codec;
1799     AVFilterGraph *graph = avfilter_graph_alloc();
1800     AVFilterContext *filt_out = NULL, *filt_in = NULL;
1801     int last_w = 0;
1802     int last_h = 0;
1803     enum AVPixelFormat last_format = -2;
1804     int last_serial = -1;
1805
1806     if (codec->codec->capabilities & CODEC_CAP_DR1) {
1807         is->use_dr1 = 1;
1808         codec->get_buffer     = codec_get_buffer;
1809         codec->release_buffer = codec_release_buffer;
1810         codec->opaque         = &is->buffer_pool;
1811     }
1812 #endif
1813
1814     for (;;) {
1815 #if CONFIG_AVFILTER
1816         AVFilterBufferRef *picref;
1817         AVRational tb;
1818 #endif
1819         while (is->paused && !is->videoq.abort_request)
1820             SDL_Delay(10);
1821
1822         avcodec_get_frame_defaults(frame);
1823         av_free_packet(&pkt);
1824
1825         ret = get_video_frame(is, frame, &pts_int, &pkt, &serial);
1826         if (ret < 0)
1827             goto the_end;
1828
1829         if (!ret)
1830             continue;
1831
1832 #if CONFIG_AVFILTER
1833         if (   last_w != frame->width
1834             || last_h != frame->height
1835             || last_format != frame->format
1836             || last_serial != serial) {
1837             av_log(NULL, AV_LOG_DEBUG,
1838                    "Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
1839                    last_w, last_h,
1840                    (const char *)av_x_if_null(av_get_pix_fmt_name(last_format), "none"), last_serial,
1841                    frame->width, frame->height,
1842                    (const char *)av_x_if_null(av_get_pix_fmt_name(frame->format), "none"), serial);
1843             avfilter_graph_free(&graph);
1844             graph = avfilter_graph_alloc();
1845             if ((ret = configure_video_filters(graph, is, vfilters, frame)) < 0) {
1846                 SDL_Event event;
1847                 event.type = FF_QUIT_EVENT;
1848                 event.user.data1 = is;
1849                 SDL_PushEvent(&event);
1850                 av_free_packet(&pkt);
1851                 goto the_end;
1852             }
1853             filt_in  = is->in_video_filter;
1854             filt_out = is->out_video_filter;
1855             last_w = frame->width;
1856             last_h = frame->height;
1857             last_format = frame->format;
1858             last_serial = serial;
1859         }
1860
1861         frame->pts = pts_int;
1862         frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
1863         if (is->use_dr1 && frame->opaque) {
1864             FrameBuffer      *buf = frame->opaque;
1865             AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
1866                                         frame->data, frame->linesize,
1867                                         AV_PERM_READ | AV_PERM_PRESERVE,
1868                                         frame->width, frame->height,
1869                                         frame->format);
1870
1871             avfilter_copy_frame_props(fb, frame);
1872             fb->buf->priv           = buf;
1873             fb->buf->free           = filter_release_buffer;
1874
1875             buf->refcount++;
1876             av_buffersrc_add_ref(filt_in, fb, AV_BUFFERSRC_FLAG_NO_COPY);
1877
1878         } else
1879             av_buffersrc_write_frame(filt_in, frame);
1880
1881         av_free_packet(&pkt);
1882
1883         while (ret >= 0) {
1884             is->frame_last_returned_time = av_gettime() / 1000000.0;
1885
1886             ret = av_buffersink_get_buffer_ref(filt_out, &picref, 0);
1887             if (ret < 0) {
1888                 ret = 0;
1889                 break;
1890             }
1891
1892             is->frame_last_filter_delay = av_gettime() / 1000000.0 - is->frame_last_returned_time;
1893             if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
1894                 is->frame_last_filter_delay = 0;
1895
1896             avfilter_copy_buf_props(frame, picref);
1897
1898             pts_int = picref->pts;
1899             tb      = filt_out->inputs[0]->time_base;
1900             pos     = picref->pos;
1901             frame->opaque = picref;
1902
1903             if (av_cmp_q(tb, is->video_st->time_base)) {
1904                 av_unused int64_t pts1 = pts_int;
1905                 pts_int = av_rescale_q(pts_int, tb, is->video_st->time_base);
1906                 av_dlog(NULL, "video_thread(): "
1907                         "tb:%d/%d pts:%"PRId64" -> tb:%d/%d pts:%"PRId64"\n",
1908                         tb.num, tb.den, pts1,
1909                         is->video_st->time_base.num, is->video_st->time_base.den, pts_int);
1910             }
1911             pts = pts_int * av_q2d(is->video_st->time_base);
1912             ret = queue_picture(is, frame, pts, pos, serial);
1913         }
1914 #else
1915         pts = pts_int * av_q2d(is->video_st->time_base);
1916         ret = queue_picture(is, frame, pts, pkt.pos, serial);
1917 #endif
1918
1919         if (ret < 0)
1920             goto the_end;
1921     }
1922  the_end:
1923     avcodec_flush_buffers(is->video_st->codec);
1924 #if CONFIG_AVFILTER
1925     avfilter_graph_free(&graph);
1926 #endif
1927     av_free_packet(&pkt);
1928     avcodec_free_frame(&frame);
1929     return 0;
1930 }
1931
1932 static int subtitle_thread(void *arg)
1933 {
1934     VideoState *is = arg;
1935     SubPicture *sp;
1936     AVPacket pkt1, *pkt = &pkt1;
1937     int got_subtitle;
1938     double pts;
1939     int i, j;
1940     int r, g, b, y, u, v, a;
1941
1942     for (;;) {
1943         while (is->paused && !is->subtitleq.abort_request) {
1944             SDL_Delay(10);
1945         }
1946         if (packet_queue_get(&is->subtitleq, pkt, 1, NULL) < 0)
1947             break;
1948
1949         if (pkt->data == flush_pkt.data) {
1950             avcodec_flush_buffers(is->subtitle_st->codec);
1951             continue;
1952         }
1953         SDL_LockMutex(is->subpq_mutex);
1954         while (is->subpq_size >= SUBPICTURE_QUEUE_SIZE &&
1955                !is->subtitleq.abort_request) {
1956             SDL_CondWait(is->subpq_cond, is->subpq_mutex);
1957         }
1958         SDL_UnlockMutex(is->subpq_mutex);
1959
1960         if (is->subtitleq.abort_request)
1961             return 0;
1962
1963         sp = &is->subpq[is->subpq_windex];
1964
1965        /* NOTE: ipts is the PTS of the _first_ picture beginning in
1966            this packet, if any */
1967         pts = 0;
1968         if (pkt->pts != AV_NOPTS_VALUE)
1969             pts = av_q2d(is->subtitle_st->time_base) * pkt->pts;
1970
1971         avcodec_decode_subtitle2(is->subtitle_st->codec, &sp->sub,
1972                                  &got_subtitle, pkt);
1973         if (got_subtitle && sp->sub.format == 0) {
1974             if (sp->sub.pts != AV_NOPTS_VALUE)
1975                 pts = sp->sub.pts / (double)AV_TIME_BASE;
1976             sp->pts = pts;
1977
1978             for (i = 0; i < sp->sub.num_rects; i++)
1979             {
1980                 for (j = 0; j < sp->sub.rects[i]->nb_colors; j++)
1981                 {
1982                     RGBA_IN(r, g, b, a, (uint32_t*)sp->sub.rects[i]->pict.data[1] + j);
1983                     y = RGB_TO_Y_CCIR(r, g, b);
1984                     u = RGB_TO_U_CCIR(r, g, b, 0);
1985                     v = RGB_TO_V_CCIR(r, g, b, 0);
1986                     YUVA_OUT((uint32_t*)sp->sub.rects[i]->pict.data[1] + j, y, u, v, a);
1987                 }
1988             }
1989
1990             /* now we can update the picture count */
1991             if (++is->subpq_windex == SUBPICTURE_QUEUE_SIZE)
1992                 is->subpq_windex = 0;
1993             SDL_LockMutex(is->subpq_mutex);
1994             is->subpq_size++;
1995             SDL_UnlockMutex(is->subpq_mutex);
1996         }
1997         av_free_packet(pkt);
1998     }
1999     return 0;
2000 }
2001
2002 /* copy samples for viewing in editor window */
2003 static void update_sample_display(VideoState *is, short *samples, int samples_size)
2004 {
2005     int size, len;
2006
2007     size = samples_size / sizeof(short);
2008     while (size > 0) {
2009         len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
2010         if (len > size)
2011             len = size;
2012         memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
2013         samples += len;
2014         is->sample_array_index += len;
2015         if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
2016             is->sample_array_index = 0;
2017         size -= len;
2018     }
2019 }
2020
2021 /* return the wanted number of samples to get better sync if sync_type is video
2022  * or external master clock */
2023 static int synchronize_audio(VideoState *is, int nb_samples)
2024 {
2025     int wanted_nb_samples = nb_samples;
2026
2027     /* if not master, then we try to remove or add samples to correct the clock */
2028     if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
2029         double diff, avg_diff;
2030         int min_nb_samples, max_nb_samples;
2031
2032         diff = get_audio_clock(is) - get_master_clock(is);
2033
2034         if (fabs(diff) < AV_NOSYNC_THRESHOLD) {
2035             is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
2036             if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
2037                 /* not enough measures to have a correct estimate */
2038                 is->audio_diff_avg_count++;
2039             } else {
2040                 /* estimate the A-V difference */
2041                 avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
2042
2043                 if (fabs(avg_diff) >= is->audio_diff_threshold) {
2044                     wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);
2045                     min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2046                     max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2047                     wanted_nb_samples = FFMIN(FFMAX(wanted_nb_samples, min_nb_samples), max_nb_samples);
2048                 }
2049                 av_dlog(NULL, "diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
2050                         diff, avg_diff, wanted_nb_samples - nb_samples,
2051                         is->audio_clock, is->audio_diff_threshold);
2052             }
2053         } else {
2054             /* too big difference : may be initial PTS errors, so
2055                reset A-V filter */
2056             is->audio_diff_avg_count = 0;
2057             is->audio_diff_cum       = 0;
2058         }
2059     }
2060
2061     return wanted_nb_samples;
2062 }
2063
2064 /**
2065  * Decode one audio frame and return its uncompressed size.
2066  *
2067  * The processed audio frame is decoded, converted if required, and
2068  * stored in is->audio_buf, with size in bytes given by the return
2069  * value.
2070  */
2071 static int audio_decode_frame(VideoState *is)
2072 {
2073     AVPacket *pkt_temp = &is->audio_pkt_temp;
2074     AVPacket *pkt = &is->audio_pkt;
2075     AVCodecContext *dec = is->audio_st->codec;
2076     int len1, len2, data_size, resampled_data_size;
2077     int64_t dec_channel_layout;
2078     int got_frame;
2079     av_unused double audio_clock0;
2080     int new_packet = 0;
2081     int flush_complete = 0;
2082     int wanted_nb_samples;
2083
2084     for (;;) {
2085         /* NOTE: the audio packet can contain several frames */
2086         while (pkt_temp->size > 0 || (!pkt_temp->data && new_packet)) {
2087             if (!is->frame) {
2088                 if (!(is->frame = avcodec_alloc_frame()))
2089                     return AVERROR(ENOMEM);
2090             } else
2091                 avcodec_get_frame_defaults(is->frame);
2092
2093             if (is->audioq.serial != is->audio_pkt_temp_serial)
2094                 break;
2095
2096             if (is->paused)
2097                 return -1;
2098
2099             if (flush_complete)
2100                 break;
2101             new_packet = 0;
2102             len1 = avcodec_decode_audio4(dec, is->frame, &got_frame, pkt_temp);
2103             if (len1 < 0) {
2104                 /* if error, we skip the frame */
2105                 pkt_temp->size = 0;
2106                 break;
2107             }
2108
2109             pkt_temp->data += len1;
2110             pkt_temp->size -= len1;
2111
2112             if (!got_frame) {
2113                 /* stop sending empty packets if the decoder is finished */
2114                 if (!pkt_temp->data && dec->codec->capabilities & CODEC_CAP_DELAY)
2115                     flush_complete = 1;
2116                 continue;
2117             }
2118             data_size = av_samples_get_buffer_size(NULL, is->frame->channels,
2119                                                    is->frame->nb_samples,
2120                                                    is->frame->format, 1);
2121
2122             dec_channel_layout =
2123                 (is->frame->channel_layout && is->frame->channels == av_get_channel_layout_nb_channels(is->frame->channel_layout)) ?
2124                 is->frame->channel_layout : av_get_default_channel_layout(is->frame->channels);
2125             wanted_nb_samples = synchronize_audio(is, is->frame->nb_samples);
2126
2127             if (is->frame->format        != is->audio_src.fmt            ||
2128                 dec_channel_layout       != is->audio_src.channel_layout ||
2129                 is->frame->sample_rate   != is->audio_src.freq           ||
2130                 (wanted_nb_samples       != is->frame->nb_samples && !is->swr_ctx)) {
2131                 swr_free(&is->swr_ctx);
2132                 is->swr_ctx = swr_alloc_set_opts(NULL,
2133                                                  is->audio_tgt.channel_layout, is->audio_tgt.fmt, is->audio_tgt.freq,
2134                                                  dec_channel_layout,           is->frame->format, is->frame->sample_rate,
2135                                                  0, NULL);
2136                 if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
2137                     fprintf(stderr, "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
2138                             is->frame->sample_rate, av_get_sample_fmt_name(is->frame->format), is->frame->channels,
2139                             is->audio_tgt.freq, av_get_sample_fmt_name(is->audio_tgt.fmt), is->audio_tgt.channels);
2140                     break;
2141                 }
2142                 is->audio_src.channel_layout = dec_channel_layout;
2143                 is->audio_src.channels = is->frame->channels;
2144                 is->audio_src.freq = is->frame->sample_rate;
2145                 is->audio_src.fmt = is->frame->format;
2146             }
2147
2148             if (is->swr_ctx) {
2149                 const uint8_t **in = (const uint8_t **)is->frame->extended_data;
2150                 uint8_t **out = &is->audio_buf1;
2151                 int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / is->frame->sample_rate + 256;
2152                 int out_size  = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, out_count, is->audio_tgt.fmt, 0);
2153                 if (wanted_nb_samples != is->frame->nb_samples) {
2154                     if (swr_set_compensation(is->swr_ctx, (wanted_nb_samples - is->frame->nb_samples) * is->audio_tgt.freq / is->frame->sample_rate,
2155                                                 wanted_nb_samples * is->audio_tgt.freq / is->frame->sample_rate) < 0) {
2156                         fprintf(stderr, "swr_set_compensation() failed\n");
2157                         break;
2158                     }
2159                 }
2160                 av_fast_malloc(&is->audio_buf1, &is->audio_buf1_size, out_size);
2161                 if (!is->audio_buf1)
2162                     return AVERROR(ENOMEM);
2163                 len2 = swr_convert(is->swr_ctx, out, out_count, in, is->frame->nb_samples);
2164                 if (len2 < 0) {
2165                     fprintf(stderr, "swr_convert() failed\n");
2166                     break;
2167                 }
2168                 if (len2 == out_count) {
2169                     fprintf(stderr, "warning: audio buffer is probably too small\n");
2170                     swr_init(is->swr_ctx);
2171                 }
2172                 is->audio_buf = is->audio_buf1;
2173                 resampled_data_size = len2 * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2174             } else {
2175                 is->audio_buf = is->frame->data[0];
2176                 resampled_data_size = data_size;
2177             }
2178
2179             audio_clock0 = is->audio_clock;
2180             is->audio_clock += (double)data_size /
2181                 (is->frame->channels * is->frame->sample_rate * av_get_bytes_per_sample(is->frame->format));
2182 #ifdef DEBUG
2183             {
2184                 static double last_clock;
2185                 printf("audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
2186                        is->audio_clock - last_clock,
2187                        is->audio_clock, audio_clock0);
2188                 last_clock = is->audio_clock;
2189             }
2190 #endif
2191             return resampled_data_size;
2192         }
2193
2194         /* free the current packet */
2195         if (pkt->data)
2196             av_free_packet(pkt);
2197         memset(pkt_temp, 0, sizeof(*pkt_temp));
2198
2199         if (is->paused || is->audioq.abort_request) {
2200             return -1;
2201         }
2202
2203         if (is->audioq.nb_packets == 0)
2204             SDL_CondSignal(is->continue_read_thread);
2205
2206         /* read next packet */
2207         if ((new_packet = packet_queue_get(&is->audioq, pkt, 1, &is->audio_pkt_temp_serial)) < 0)
2208             return -1;
2209
2210         if (pkt->data == flush_pkt.data) {
2211             avcodec_flush_buffers(dec);
2212             flush_complete = 0;
2213         }
2214
2215         *pkt_temp = *pkt;
2216
2217         /* if update the audio clock with the pts */
2218         if (pkt->pts != AV_NOPTS_VALUE) {
2219             is->audio_clock = av_q2d(is->audio_st->time_base)*pkt->pts;
2220         }
2221     }
2222 }
2223
2224 /* prepare a new audio buffer */
2225 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
2226 {
2227     VideoState *is = opaque;
2228     int audio_size, len1;
2229     int bytes_per_sec;
2230     int frame_size = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, 1, is->audio_tgt.fmt, 1);
2231
2232     audio_callback_time = av_gettime();
2233
2234     while (len > 0) {
2235         if (is->audio_buf_index >= is->audio_buf_size) {
2236            audio_size = audio_decode_frame(is);
2237            if (audio_size < 0) {
2238                 /* if error, just output silence */
2239                is->audio_buf      = is->silence_buf;
2240                is->audio_buf_size = sizeof(is->silence_buf) / frame_size * frame_size;
2241            } else {
2242                if (is->show_mode != SHOW_MODE_VIDEO)
2243                    update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
2244                is->audio_buf_size = audio_size;
2245            }
2246            is->audio_buf_index = 0;
2247         }
2248         len1 = is->audio_buf_size - is->audio_buf_index;
2249         if (len1 > len)
2250             len1 = len;
2251         memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
2252         len -= len1;
2253         stream += len1;
2254         is->audio_buf_index += len1;
2255     }
2256     bytes_per_sec = is->audio_tgt.freq * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2257     is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
2258     /* Let's assume the audio driver that is used by SDL has two periods. */
2259     is->audio_current_pts = is->audio_clock - (double)(2 * is->audio_hw_buf_size + is->audio_write_buf_size) / bytes_per_sec;
2260     is->audio_current_pts_drift = is->audio_current_pts - audio_callback_time / 1000000.0;
2261     if (is->audioq.serial == is->audio_pkt_temp_serial)
2262         check_external_clock_sync(is, is->audio_current_pts);
2263 }
2264
2265 static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
2266 {
2267     SDL_AudioSpec wanted_spec, spec;
2268     const char *env;
2269     const int next_nb_channels[] = {0, 0, 1, 6, 2, 6, 4, 6};
2270
2271     env = SDL_getenv("SDL_AUDIO_CHANNELS");
2272     if (env) {
2273         wanted_nb_channels = atoi(env);
2274         wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2275     }
2276     if (!wanted_channel_layout || wanted_nb_channels != av_get_channel_layout_nb_channels(wanted_channel_layout)) {
2277         wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2278         wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
2279     }
2280     wanted_spec.channels = av_get_channel_layout_nb_channels(wanted_channel_layout);
2281     wanted_spec.freq = wanted_sample_rate;
2282     if (wanted_spec.freq <= 0 || wanted_spec.channels <= 0) {
2283         fprintf(stderr, "Invalid sample rate or channel count!\n");
2284         return -1;
2285     }
2286     wanted_spec.format = AUDIO_S16SYS;
2287     wanted_spec.silence = 0;
2288     wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
2289     wanted_spec.callback = sdl_audio_callback;
2290     wanted_spec.userdata = opaque;
2291     while (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
2292         fprintf(stderr, "SDL_OpenAudio (%d channels): %s\n", wanted_spec.channels, SDL_GetError());
2293         wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
2294         if (!wanted_spec.channels) {
2295             fprintf(stderr, "No more channel combinations to try, audio open failed\n");
2296             return -1;
2297         }
2298         wanted_channel_layout = av_get_default_channel_layout(wanted_spec.channels);
2299     }
2300     if (spec.format != AUDIO_S16SYS) {
2301         fprintf(stderr, "SDL advised audio format %d is not supported!\n", spec.format);
2302         return -1;
2303     }
2304     if (spec.channels != wanted_spec.channels) {
2305         wanted_channel_layout = av_get_default_channel_layout(spec.channels);
2306         if (!wanted_channel_layout) {
2307             fprintf(stderr, "SDL advised channel count %d is not supported!\n", spec.channels);
2308             return -1;
2309         }
2310     }
2311
2312     audio_hw_params->fmt = AV_SAMPLE_FMT_S16;
2313     audio_hw_params->freq = spec.freq;
2314     audio_hw_params->channel_layout = wanted_channel_layout;
2315     audio_hw_params->channels =  spec.channels;
2316     return spec.size;
2317 }
2318
2319 /* open a given stream. Return 0 if OK */
2320 static int stream_component_open(VideoState *is, int stream_index)
2321 {
2322     AVFormatContext *ic = is->ic;
2323     AVCodecContext *avctx;
2324     AVCodec *codec;
2325     const char *forced_codec_name = NULL;
2326     AVDictionary *opts;
2327     AVDictionaryEntry *t = NULL;
2328
2329     if (stream_index < 0 || stream_index >= ic->nb_streams)
2330         return -1;
2331     avctx = ic->streams[stream_index]->codec;
2332
2333     codec = avcodec_find_decoder(avctx->codec_id);
2334
2335     switch(avctx->codec_type){
2336         case AVMEDIA_TYPE_AUDIO   : is->last_audio_stream    = stream_index; forced_codec_name =    audio_codec_name; break;
2337         case AVMEDIA_TYPE_SUBTITLE: is->last_subtitle_stream = stream_index; forced_codec_name = subtitle_codec_name; break;
2338         case AVMEDIA_TYPE_VIDEO   : is->last_video_stream    = stream_index; forced_codec_name =    video_codec_name; break;
2339     }
2340     if (forced_codec_name)
2341         codec = avcodec_find_decoder_by_name(forced_codec_name);
2342     if (!codec) {
2343         if (forced_codec_name) fprintf(stderr, "No codec could be found with name '%s'\n", forced_codec_name);
2344         else                   fprintf(stderr, "No codec could be found with id %d\n", avctx->codec_id);
2345         return -1;
2346     }
2347
2348     avctx->codec_id = codec->id;
2349     avctx->workaround_bugs   = workaround_bugs;
2350     avctx->lowres            = lowres;
2351     if(avctx->lowres > codec->max_lowres){
2352         av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2353                 codec->max_lowres);
2354         avctx->lowres= codec->max_lowres;
2355     }
2356     avctx->idct_algo         = idct;
2357     avctx->skip_frame        = skip_frame;
2358     avctx->skip_idct         = skip_idct;
2359     avctx->skip_loop_filter  = skip_loop_filter;
2360     avctx->error_concealment = error_concealment;
2361
2362     if(avctx->lowres) avctx->flags |= CODEC_FLAG_EMU_EDGE;
2363     if (fast)   avctx->flags2 |= CODEC_FLAG2_FAST;
2364     if(codec->capabilities & CODEC_CAP_DR1)
2365         avctx->flags |= CODEC_FLAG_EMU_EDGE;
2366
2367     opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
2368     if (!av_dict_get(opts, "threads", NULL, 0))
2369         av_dict_set(&opts, "threads", "auto", 0);
2370     if (avcodec_open2(avctx, codec, &opts) < 0)
2371         return -1;
2372     if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2373         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2374         return AVERROR_OPTION_NOT_FOUND;
2375     }
2376
2377     /* prepare audio output */
2378     if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2379         int audio_hw_buf_size = audio_open(is, avctx->channel_layout, avctx->channels, avctx->sample_rate, &is->audio_src);
2380         if (audio_hw_buf_size < 0)
2381             return -1;
2382         is->audio_hw_buf_size = audio_hw_buf_size;
2383         is->audio_tgt = is->audio_src;
2384     }
2385
2386     ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
2387     switch (avctx->codec_type) {
2388     case AVMEDIA_TYPE_AUDIO:
2389         is->audio_stream = stream_index;
2390         is->audio_st = ic->streams[stream_index];
2391         is->audio_buf_size  = 0;
2392         is->audio_buf_index = 0;
2393
2394         /* init averaging filter */
2395         is->audio_diff_avg_coef  = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
2396         is->audio_diff_avg_count = 0;
2397         /* since we do not have a precise anough audio fifo fullness,
2398            we correct audio sync only if larger than this threshold */
2399         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);
2400
2401         memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
2402         memset(&is->audio_pkt_temp, 0, sizeof(is->audio_pkt_temp));
2403         packet_queue_start(&is->audioq);
2404         SDL_PauseAudio(0);
2405         break;
2406     case AVMEDIA_TYPE_VIDEO:
2407         is->video_stream = stream_index;
2408         is->video_st = ic->streams[stream_index];
2409
2410         packet_queue_start(&is->videoq);
2411         is->video_tid = SDL_CreateThread(video_thread, is);
2412         break;
2413     case AVMEDIA_TYPE_SUBTITLE:
2414         is->subtitle_stream = stream_index;
2415         is->subtitle_st = ic->streams[stream_index];
2416         packet_queue_start(&is->subtitleq);
2417
2418         is->subtitle_tid = SDL_CreateThread(subtitle_thread, is);
2419         break;
2420     default:
2421         break;
2422     }
2423     return 0;
2424 }
2425
2426 static void stream_component_close(VideoState *is, int stream_index)
2427 {
2428     AVFormatContext *ic = is->ic;
2429     AVCodecContext *avctx;
2430
2431     if (stream_index < 0 || stream_index >= ic->nb_streams)
2432         return;
2433     avctx = ic->streams[stream_index]->codec;
2434
2435     switch (avctx->codec_type) {
2436     case AVMEDIA_TYPE_AUDIO:
2437         packet_queue_abort(&is->audioq);
2438
2439         SDL_CloseAudio();
2440
2441         packet_queue_flush(&is->audioq);
2442         av_free_packet(&is->audio_pkt);
2443         swr_free(&is->swr_ctx);
2444         av_freep(&is->audio_buf1);
2445         is->audio_buf1_size = 0;
2446         is->audio_buf = NULL;
2447         avcodec_free_frame(&is->frame);
2448
2449         if (is->rdft) {
2450             av_rdft_end(is->rdft);
2451             av_freep(&is->rdft_data);
2452             is->rdft = NULL;
2453             is->rdft_bits = 0;
2454         }
2455         break;
2456     case AVMEDIA_TYPE_VIDEO:
2457         packet_queue_abort(&is->videoq);
2458
2459         /* note: we also signal this mutex to make sure we deblock the
2460            video thread in all cases */
2461         SDL_LockMutex(is->pictq_mutex);
2462         SDL_CondSignal(is->pictq_cond);
2463         SDL_UnlockMutex(is->pictq_mutex);
2464
2465         SDL_WaitThread(is->video_tid, NULL);
2466
2467         packet_queue_flush(&is->videoq);
2468         break;
2469     case AVMEDIA_TYPE_SUBTITLE:
2470         packet_queue_abort(&is->subtitleq);
2471
2472         /* note: we also signal this mutex to make sure we deblock the
2473            video thread in all cases */
2474         SDL_LockMutex(is->subpq_mutex);
2475         is->subtitle_stream_changed = 1;
2476
2477         SDL_CondSignal(is->subpq_cond);
2478         SDL_UnlockMutex(is->subpq_mutex);
2479
2480         SDL_WaitThread(is->subtitle_tid, NULL);
2481
2482         packet_queue_flush(&is->subtitleq);
2483         break;
2484     default:
2485         break;
2486     }
2487
2488     ic->streams[stream_index]->discard = AVDISCARD_ALL;
2489     avcodec_close(avctx);
2490 #if CONFIG_AVFILTER
2491     free_buffer_pool(&is->buffer_pool);
2492 #endif
2493     switch (avctx->codec_type) {
2494     case AVMEDIA_TYPE_AUDIO:
2495         is->audio_st = NULL;
2496         is->audio_stream = -1;
2497         break;
2498     case AVMEDIA_TYPE_VIDEO:
2499         is->video_st = NULL;
2500         is->video_stream = -1;
2501         break;
2502     case AVMEDIA_TYPE_SUBTITLE:
2503         is->subtitle_st = NULL;
2504         is->subtitle_stream = -1;
2505         break;
2506     default:
2507         break;
2508     }
2509 }
2510
2511 static int decode_interrupt_cb(void *ctx)
2512 {
2513     VideoState *is = ctx;
2514     return is->abort_request;
2515 }
2516
2517 static int is_realtime(AVFormatContext *s)
2518 {
2519     if(   !strcmp(s->iformat->name, "rtp")
2520        || !strcmp(s->iformat->name, "rtsp")
2521        || !strcmp(s->iformat->name, "sdp")
2522     )
2523         return 1;
2524
2525     if(s->pb && (   !strncmp(s->filename, "rtp:", 4)
2526                  || !strncmp(s->filename, "udp:", 4)
2527                 )
2528     )
2529         return 1;
2530     return 0;
2531 }
2532
2533 /* this thread gets the stream from the disk or the network */
2534 static int read_thread(void *arg)
2535 {
2536     VideoState *is = arg;
2537     AVFormatContext *ic = NULL;
2538     int err, i, ret;
2539     int st_index[AVMEDIA_TYPE_NB];
2540     AVPacket pkt1, *pkt = &pkt1;
2541     int eof = 0;
2542     int pkt_in_play_range = 0;
2543     AVDictionaryEntry *t;
2544     AVDictionary **opts;
2545     int orig_nb_streams;
2546     SDL_mutex *wait_mutex = SDL_CreateMutex();
2547
2548     memset(st_index, -1, sizeof(st_index));
2549     is->last_video_stream = is->video_stream = -1;
2550     is->last_audio_stream = is->audio_stream = -1;
2551     is->last_subtitle_stream = is->subtitle_stream = -1;
2552
2553     ic = avformat_alloc_context();
2554     ic->interrupt_callback.callback = decode_interrupt_cb;
2555     ic->interrupt_callback.opaque = is;
2556     err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
2557     if (err < 0) {
2558         print_error(is->filename, err);
2559         ret = -1;
2560         goto fail;
2561     }
2562     if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2563         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2564         ret = AVERROR_OPTION_NOT_FOUND;
2565         goto fail;
2566     }
2567     is->ic = ic;
2568
2569     if (genpts)
2570         ic->flags |= AVFMT_FLAG_GENPTS;
2571
2572     opts = setup_find_stream_info_opts(ic, codec_opts);
2573     orig_nb_streams = ic->nb_streams;
2574
2575     err = avformat_find_stream_info(ic, opts);
2576     if (err < 0) {
2577         fprintf(stderr, "%s: could not find codec parameters\n", is->filename);
2578         ret = -1;
2579         goto fail;
2580     }
2581     for (i = 0; i < orig_nb_streams; i++)
2582         av_dict_free(&opts[i]);
2583     av_freep(&opts);
2584
2585     if (ic->pb)
2586         ic->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use url_feof() to test for the end
2587
2588     if (seek_by_bytes < 0)
2589         seek_by_bytes = !!(ic->iformat->flags & AVFMT_TS_DISCONT);
2590
2591     is->max_frame_duration = (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;
2592
2593     /* if seeking requested, we execute it */
2594     if (start_time != AV_NOPTS_VALUE) {
2595         int64_t timestamp;
2596
2597         timestamp = start_time;
2598         /* add the stream start time */
2599         if (ic->start_time != AV_NOPTS_VALUE)
2600             timestamp += ic->start_time;
2601         ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
2602         if (ret < 0) {
2603             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2604                     is->filename, (double)timestamp / AV_TIME_BASE);
2605         }
2606     }
2607
2608     is->realtime = is_realtime(ic);
2609
2610     for (i = 0; i < ic->nb_streams; i++)
2611         ic->streams[i]->discard = AVDISCARD_ALL;
2612     if (!video_disable)
2613         st_index[AVMEDIA_TYPE_VIDEO] =
2614             av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
2615                                 wanted_stream[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
2616     if (!audio_disable)
2617         st_index[AVMEDIA_TYPE_AUDIO] =
2618             av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
2619                                 wanted_stream[AVMEDIA_TYPE_AUDIO],
2620                                 st_index[AVMEDIA_TYPE_VIDEO],
2621                                 NULL, 0);
2622     if (!video_disable)
2623         st_index[AVMEDIA_TYPE_SUBTITLE] =
2624             av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
2625                                 wanted_stream[AVMEDIA_TYPE_SUBTITLE],
2626                                 (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
2627                                  st_index[AVMEDIA_TYPE_AUDIO] :
2628                                  st_index[AVMEDIA_TYPE_VIDEO]),
2629                                 NULL, 0);
2630     if (show_status) {
2631         av_dump_format(ic, 0, is->filename, 0);
2632     }
2633
2634     is->show_mode = show_mode;
2635
2636     /* open the streams */
2637     if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
2638         stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
2639     }
2640
2641     ret = -1;
2642     if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2643         ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
2644     }
2645     if (is->show_mode == SHOW_MODE_NONE)
2646         is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
2647
2648     if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
2649         stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
2650     }
2651
2652     if (is->video_stream < 0 && is->audio_stream < 0) {
2653         fprintf(stderr, "%s: could not open codecs\n", is->filename);
2654         ret = -1;
2655         goto fail;
2656     }
2657
2658     if (infinite_buffer < 0 && is->realtime)
2659         infinite_buffer = 1;
2660
2661     for (;;) {
2662         if (is->abort_request)
2663             break;
2664         if (is->paused != is->last_paused) {
2665             is->last_paused = is->paused;
2666             if (is->paused)
2667                 is->read_pause_return = av_read_pause(ic);
2668             else
2669                 av_read_play(ic);
2670         }
2671 #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
2672         if (is->paused &&
2673                 (!strcmp(ic->iformat->name, "rtsp") ||
2674                  (ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
2675             /* wait 10 ms to avoid trying to get another packet */
2676             /* XXX: horrible */
2677             SDL_Delay(10);
2678             continue;
2679         }
2680 #endif
2681         if (is->seek_req) {
2682             int64_t seek_target = is->seek_pos;
2683             int64_t seek_min    = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
2684             int64_t seek_max    = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
2685 // FIXME the +-2 is due to rounding being not done in the correct direction in generation
2686 //      of the seek_pos/seek_rel variables
2687
2688             ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
2689             if (ret < 0) {
2690                 fprintf(stderr, "%s: error while seeking\n", is->ic->filename);
2691             } else {
2692                 if (is->audio_stream >= 0) {
2693                     packet_queue_flush(&is->audioq);
2694                     packet_queue_put(&is->audioq, &flush_pkt);
2695                 }
2696                 if (is->subtitle_stream >= 0) {
2697                     packet_queue_flush(&is->subtitleq);
2698                     packet_queue_put(&is->subtitleq, &flush_pkt);
2699                 }
2700                 if (is->video_stream >= 0) {
2701                     packet_queue_flush(&is->videoq);
2702                     packet_queue_put(&is->videoq, &flush_pkt);
2703                 }
2704                 if (is->seek_flags & AVSEEK_FLAG_BYTE) {
2705                    //FIXME: use a cleaner way to signal obsolete external clock...
2706                    update_external_clock_pts(is, (double)AV_NOPTS_VALUE);
2707                 } else {
2708                    update_external_clock_pts(is, seek_target / (double)AV_TIME_BASE);
2709                 }
2710             }
2711             is->seek_req = 0;
2712             eof = 0;
2713             if (is->paused)
2714                 step_to_next_frame(is);
2715         }
2716         if (is->queue_attachments_req) {
2717             avformat_queue_attached_pictures(ic);
2718             is->queue_attachments_req = 0;
2719         }
2720
2721         /* if the queue are full, no need to read more */
2722         if (infinite_buffer<1 &&
2723               (is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
2724             || (   (is->audioq   .nb_packets > MIN_FRAMES || is->audio_stream < 0 || is->audioq.abort_request)
2725                 && (is->videoq   .nb_packets > MIN_FRAMES || is->video_stream < 0 || is->videoq.abort_request)
2726                 && (is->subtitleq.nb_packets > MIN_FRAMES || is->subtitle_stream < 0 || is->subtitleq.abort_request)))) {
2727             /* wait 10 ms */
2728             SDL_LockMutex(wait_mutex);
2729             SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
2730             SDL_UnlockMutex(wait_mutex);
2731             continue;
2732         }
2733         if (eof) {
2734             if (is->video_stream >= 0) {
2735                 av_init_packet(pkt);
2736                 pkt->data = NULL;
2737                 pkt->size = 0;
2738                 pkt->stream_index = is->video_stream;
2739                 packet_queue_put(&is->videoq, pkt);
2740             }
2741             if (is->audio_stream >= 0 &&
2742                 is->audio_st->codec->codec->capabilities & CODEC_CAP_DELAY) {
2743                 av_init_packet(pkt);
2744                 pkt->data = NULL;
2745                 pkt->size = 0;
2746                 pkt->stream_index = is->audio_stream;
2747                 packet_queue_put(&is->audioq, pkt);
2748             }
2749             SDL_Delay(10);
2750             if (is->audioq.size + is->videoq.size + is->subtitleq.size == 0) {
2751                 if (loop != 1 && (!loop || --loop)) {
2752                     stream_seek(is, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
2753                 } else if (autoexit) {
2754                     ret = AVERROR_EOF;
2755                     goto fail;
2756                 }
2757             }
2758             eof=0;
2759             continue;
2760         }
2761         ret = av_read_frame(ic, pkt);
2762         if (ret < 0) {
2763             if (ret == AVERROR_EOF || url_feof(ic->pb))
2764                 eof = 1;
2765             if (ic->pb && ic->pb->error)
2766                 break;
2767             SDL_LockMutex(wait_mutex);
2768             SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
2769             SDL_UnlockMutex(wait_mutex);
2770             continue;
2771         }
2772         /* check if packet is in play range specified by user, then queue, otherwise discard */
2773         pkt_in_play_range = duration == AV_NOPTS_VALUE ||
2774                 (pkt->pts - ic->streams[pkt->stream_index]->start_time) *
2775                 av_q2d(ic->streams[pkt->stream_index]->time_base) -
2776                 (double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
2777                 <= ((double)duration / 1000000);
2778         if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
2779             packet_queue_put(&is->audioq, pkt);
2780         } else if (pkt->stream_index == is->video_stream && pkt_in_play_range) {
2781             packet_queue_put(&is->videoq, pkt);
2782         } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
2783             packet_queue_put(&is->subtitleq, pkt);
2784         } else {
2785             av_free_packet(pkt);
2786         }
2787     }
2788     /* wait until the end */
2789     while (!is->abort_request) {
2790         SDL_Delay(100);
2791     }
2792
2793     ret = 0;
2794  fail:
2795     /* close each stream */
2796     if (is->audio_stream >= 0)
2797         stream_component_close(is, is->audio_stream);
2798     if (is->video_stream >= 0)
2799         stream_component_close(is, is->video_stream);
2800     if (is->subtitle_stream >= 0)
2801         stream_component_close(is, is->subtitle_stream);
2802     if (is->ic) {
2803         avformat_close_input(&is->ic);
2804     }
2805
2806     if (ret != 0) {
2807         SDL_Event event;
2808
2809         event.type = FF_QUIT_EVENT;
2810         event.user.data1 = is;
2811         SDL_PushEvent(&event);
2812     }
2813     SDL_DestroyMutex(wait_mutex);
2814     return 0;
2815 }
2816
2817 static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
2818 {
2819     VideoState *is;
2820
2821     is = av_mallocz(sizeof(VideoState));
2822     if (!is)
2823         return NULL;
2824     av_strlcpy(is->filename, filename, sizeof(is->filename));
2825     is->iformat = iformat;
2826     is->ytop    = 0;
2827     is->xleft   = 0;
2828
2829     /* start video display */
2830     is->pictq_mutex = SDL_CreateMutex();
2831     is->pictq_cond  = SDL_CreateCond();
2832
2833     is->subpq_mutex = SDL_CreateMutex();
2834     is->subpq_cond  = SDL_CreateCond();
2835
2836     packet_queue_init(&is->videoq);
2837     packet_queue_init(&is->audioq);
2838     packet_queue_init(&is->subtitleq);
2839
2840     is->continue_read_thread = SDL_CreateCond();
2841
2842     //FIXME: use a cleaner way to signal obsolete external clock...
2843     update_external_clock_pts(is, (double)AV_NOPTS_VALUE);
2844     update_external_clock_speed(is, 1.0);
2845     is->audio_current_pts_drift = -av_gettime() / 1000000.0;
2846     is->video_current_pts_drift = is->audio_current_pts_drift;
2847     is->av_sync_type = av_sync_type;
2848     is->read_tid     = SDL_CreateThread(read_thread, is);
2849     if (!is->read_tid) {
2850         av_free(is);
2851         return NULL;
2852     }
2853     return is;
2854 }
2855
2856 static void stream_cycle_channel(VideoState *is, int codec_type)
2857 {
2858     AVFormatContext *ic = is->ic;
2859     int start_index, stream_index;
2860     int old_index;
2861     AVStream *st;
2862
2863     if (codec_type == AVMEDIA_TYPE_VIDEO) {
2864         start_index = is->last_video_stream;
2865         old_index = is->video_stream;
2866     } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
2867         start_index = is->last_audio_stream;
2868         old_index = is->audio_stream;
2869     } else {
2870         start_index = is->last_subtitle_stream;
2871         old_index = is->subtitle_stream;
2872     }
2873     stream_index = start_index;
2874     for (;;) {
2875         if (++stream_index >= is->ic->nb_streams)
2876         {
2877             if (codec_type == AVMEDIA_TYPE_SUBTITLE)
2878             {
2879                 stream_index = -1;
2880                 is->last_subtitle_stream = -1;
2881                 goto the_end;
2882             }
2883             if (start_index == -1)
2884                 return;
2885             stream_index = 0;
2886         }
2887         if (stream_index == start_index)
2888             return;
2889         st = ic->streams[stream_index];
2890         if (st->codec->codec_type == codec_type) {
2891             /* check that parameters are OK */
2892             switch (codec_type) {
2893             case AVMEDIA_TYPE_AUDIO:
2894                 if (st->codec->sample_rate != 0 &&
2895                     st->codec->channels != 0)
2896                     goto the_end;
2897                 break;
2898             case AVMEDIA_TYPE_VIDEO:
2899             case AVMEDIA_TYPE_SUBTITLE:
2900                 goto the_end;
2901             default:
2902                 break;
2903             }
2904         }
2905     }
2906  the_end:
2907     stream_component_close(is, old_index);
2908     stream_component_open(is, stream_index);
2909     if (codec_type == AVMEDIA_TYPE_VIDEO)
2910         is->queue_attachments_req = 1;
2911 }
2912
2913
2914 static void toggle_full_screen(VideoState *is)
2915 {
2916 #if defined(__APPLE__) && SDL_VERSION_ATLEAST(1, 2, 14)
2917     /* OS X needs to reallocate the SDL overlays */
2918     int i;
2919     for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++)
2920         is->pictq[i].reallocate = 1;
2921 #endif
2922     is_full_screen = !is_full_screen;
2923     video_open(is, 1, NULL);
2924 }
2925
2926 static void toggle_audio_display(VideoState *is)
2927 {
2928     int bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
2929     is->show_mode = (is->show_mode + 1) % SHOW_MODE_NB;
2930     fill_rectangle(screen,
2931                 is->xleft, is->ytop, is->width, is->height,
2932                 bgcolor, 1);
2933 }
2934
2935 static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
2936     double remaining_time = 0.0;
2937     SDL_PumpEvents();
2938     while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_ALLEVENTS)) {
2939         if (!cursor_hidden && av_gettime() - cursor_last_shown > CURSOR_HIDE_DELAY) {
2940             SDL_ShowCursor(0);
2941             cursor_hidden = 1;
2942         }
2943         if (remaining_time > 0.0)
2944             av_usleep((int64_t)(remaining_time * 1000000.0));
2945         remaining_time = REFRESH_RATE;
2946         if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
2947             video_refresh(is, &remaining_time);
2948         SDL_PumpEvents();
2949     }
2950 }
2951
2952 /* handle an event sent by the GUI */
2953 static void event_loop(VideoState *cur_stream)
2954 {
2955     SDL_Event event;
2956     double incr, pos, frac;
2957
2958     for (;;) {
2959         double x;
2960         refresh_loop_wait_event(cur_stream, &event);
2961         switch (event.type) {
2962         case SDL_KEYDOWN:
2963             if (exit_on_keydown) {
2964                 do_exit(cur_stream);
2965                 break;
2966             }
2967             switch (event.key.keysym.sym) {
2968             case SDLK_ESCAPE:
2969             case SDLK_q:
2970                 do_exit(cur_stream);
2971                 break;
2972             case SDLK_f:
2973                 toggle_full_screen(cur_stream);
2974                 cur_stream->force_refresh = 1;
2975                 break;
2976             case SDLK_p:
2977             case SDLK_SPACE:
2978                 toggle_pause(cur_stream);
2979                 break;
2980             case SDLK_s: // S: Step to next frame
2981                 step_to_next_frame(cur_stream);
2982                 break;
2983             case SDLK_a:
2984                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
2985                 break;
2986             case SDLK_v:
2987                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
2988                 break;
2989             case SDLK_t:
2990                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
2991                 break;
2992             case SDLK_w:
2993                 toggle_audio_display(cur_stream);
2994                 cur_stream->force_refresh = 1;
2995                 break;
2996             case SDLK_PAGEUP:
2997                 incr = 600.0;
2998                 goto do_seek;
2999             case SDLK_PAGEDOWN:
3000                 incr = -600.0;
3001                 goto do_seek;
3002             case SDLK_LEFT:
3003                 incr = -10.0;
3004                 goto do_seek;
3005             case SDLK_RIGHT:
3006                 incr = 10.0;
3007                 goto do_seek;
3008             case SDLK_UP:
3009                 incr = 60.0;
3010                 goto do_seek;
3011             case SDLK_DOWN:
3012                 incr = -60.0;
3013             do_seek:
3014                     if (seek_by_bytes) {
3015                         if (cur_stream->video_stream >= 0 && cur_stream->video_current_pos >= 0) {
3016                             pos = cur_stream->video_current_pos;
3017                         } else if (cur_stream->audio_stream >= 0 && cur_stream->audio_pkt.pos >= 0) {
3018                             pos = cur_stream->audio_pkt.pos;
3019                         } else
3020                             pos = avio_tell(cur_stream->ic->pb);
3021                         if (cur_stream->ic->bit_rate)
3022                             incr *= cur_stream->ic->bit_rate / 8.0;
3023                         else
3024                             incr *= 180000.0;
3025                         pos += incr;
3026                         stream_seek(cur_stream, pos, incr, 1);
3027                     } else {
3028                         pos = get_master_clock(cur_stream);
3029                         pos += incr;
3030                         if (cur_stream->ic->start_time != AV_NOPTS_VALUE && pos < cur_stream->ic->start_time / (double)AV_TIME_BASE)
3031                             pos = cur_stream->ic->start_time / (double)AV_TIME_BASE;
3032                         stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE), 0);
3033                     }
3034                 break;
3035             default:
3036                 break;
3037             }
3038             break;
3039         case SDL_VIDEOEXPOSE:
3040             cur_stream->force_refresh = 1;
3041             break;
3042         case SDL_MOUSEBUTTONDOWN:
3043             if (exit_on_mousedown) {
3044                 do_exit(cur_stream);
3045                 break;
3046             }
3047         case SDL_MOUSEMOTION:
3048             if (cursor_hidden) {
3049                 SDL_ShowCursor(1);
3050                 cursor_hidden = 0;
3051             }
3052             cursor_last_shown = av_gettime();
3053             if (event.type == SDL_MOUSEBUTTONDOWN) {
3054                 x = event.button.x;
3055             } else {
3056                 if (event.motion.state != SDL_PRESSED)
3057                     break;
3058                 x = event.motion.x;
3059             }
3060                 if (seek_by_bytes || cur_stream->ic->duration <= 0) {
3061                     uint64_t size =  avio_size(cur_stream->ic->pb);
3062                     stream_seek(cur_stream, size*x/cur_stream->width, 0, 1);
3063                 } else {
3064                     int64_t ts;
3065                     int ns, hh, mm, ss;
3066                     int tns, thh, tmm, tss;
3067                     tns  = cur_stream->ic->duration / 1000000LL;
3068                     thh  = tns / 3600;
3069                     tmm  = (tns % 3600) / 60;
3070                     tss  = (tns % 60);
3071                     frac = x / cur_stream->width;
3072                     ns   = frac * tns;
3073                     hh   = ns / 3600;
3074                     mm   = (ns % 3600) / 60;
3075                     ss   = (ns % 60);
3076                     fprintf(stderr, "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d)       \n", frac*100,
3077                             hh, mm, ss, thh, tmm, tss);
3078                     ts = frac * cur_stream->ic->duration;
3079                     if (cur_stream->ic->start_time != AV_NOPTS_VALUE)
3080                         ts += cur_stream->ic->start_time;
3081                     stream_seek(cur_stream, ts, 0, 0);
3082                 }
3083             break;
3084         case SDL_VIDEORESIZE:
3085                 screen = SDL_SetVideoMode(event.resize.w, event.resize.h, 0,
3086                                           SDL_HWSURFACE|SDL_RESIZABLE|SDL_ASYNCBLIT|SDL_HWACCEL);
3087                 screen_width  = cur_stream->width  = event.resize.w;
3088                 screen_height = cur_stream->height = event.resize.h;
3089                 cur_stream->force_refresh = 1;
3090             break;
3091         case SDL_QUIT:
3092         case FF_QUIT_EVENT:
3093             do_exit(cur_stream);
3094             break;
3095         case FF_ALLOC_EVENT:
3096             alloc_picture(event.user.data1);
3097             break;
3098         default:
3099             break;
3100         }
3101     }
3102 }
3103
3104 static int opt_frame_size(void *optctx, const char *opt, const char *arg)
3105 {
3106     av_log(NULL, AV_LOG_WARNING, "Option -s is deprecated, use -video_size.\n");
3107     return opt_default(NULL, "video_size", arg);
3108 }
3109
3110 static int opt_width(void *optctx, const char *opt, const char *arg)
3111 {
3112     screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3113     return 0;
3114 }
3115
3116 static int opt_height(void *optctx, const char *opt, const char *arg)
3117 {
3118     screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3119     return 0;
3120 }
3121
3122 static int opt_format(void *optctx, const char *opt, const char *arg)
3123 {
3124     file_iformat = av_find_input_format(arg);
3125     if (!file_iformat) {
3126         fprintf(stderr, "Unknown input format: %s\n", arg);
3127         return AVERROR(EINVAL);
3128     }
3129     return 0;
3130 }
3131
3132 static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
3133 {
3134     av_log(NULL, AV_LOG_WARNING, "Option -pix_fmt is deprecated, use -pixel_format.\n");
3135     return opt_default(NULL, "pixel_format", arg);
3136 }
3137
3138 static int opt_sync(void *optctx, const char *opt, const char *arg)
3139 {
3140     if (!strcmp(arg, "audio"))
3141         av_sync_type = AV_SYNC_AUDIO_MASTER;
3142     else if (!strcmp(arg, "video"))
3143         av_sync_type = AV_SYNC_VIDEO_MASTER;
3144     else if (!strcmp(arg, "ext"))
3145         av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
3146     else {
3147         fprintf(stderr, "Unknown value for %s: %s\n", opt, arg);
3148         exit(1);
3149     }
3150     return 0;
3151 }
3152
3153 static int opt_seek(void *optctx, const char *opt, const char *arg)
3154 {
3155     start_time = parse_time_or_die(opt, arg, 1);
3156     return 0;
3157 }
3158
3159 static int opt_duration(void *optctx, const char *opt, const char *arg)
3160 {
3161     duration = parse_time_or_die(opt, arg, 1);
3162     return 0;
3163 }
3164
3165 static int opt_show_mode(void *optctx, const char *opt, const char *arg)
3166 {
3167     show_mode = !strcmp(arg, "video") ? SHOW_MODE_VIDEO :
3168                 !strcmp(arg, "waves") ? SHOW_MODE_WAVES :
3169                 !strcmp(arg, "rdft" ) ? SHOW_MODE_RDFT  :
3170                 parse_number_or_die(opt, arg, OPT_INT, 0, SHOW_MODE_NB-1);
3171     return 0;
3172 }
3173
3174 static void opt_input_file(void *optctx, const char *filename)
3175 {
3176     if (input_filename) {
3177         fprintf(stderr, "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3178                 filename, input_filename);
3179         exit(1);
3180     }
3181     if (!strcmp(filename, "-"))
3182         filename = "pipe:";
3183     input_filename = filename;
3184 }
3185
3186 static int opt_codec(void *optctx, const char *opt, const char *arg)
3187 {
3188    const char *spec = strchr(opt, ':');
3189    if (!spec) {
3190        fprintf(stderr, "No media specifier was specified in '%s' in option '%s'\n",
3191                arg, opt);
3192        return AVERROR(EINVAL);
3193    }
3194    spec++;
3195    switch (spec[0]) {
3196    case 'a' :    audio_codec_name = arg; break;
3197    case 's' : subtitle_codec_name = arg; break;
3198    case 'v' :    video_codec_name = arg; break;
3199    default:
3200        fprintf(stderr, "Invalid media specifier '%s' in option '%s'\n", spec, opt);
3201        return AVERROR(EINVAL);
3202    }
3203    return 0;
3204 }
3205
3206 static int dummy;
3207
3208 static const OptionDef options[] = {
3209 #include "cmdutils_common_opts.h"
3210     { "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
3211     { "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
3212     { "s", HAS_ARG | OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
3213     { "fs", OPT_BOOL, { &is_full_screen }, "force full screen" },
3214     { "an", OPT_BOOL, { &audio_disable }, "disable audio" },
3215     { "vn", OPT_BOOL, { &video_disable }, "disable video" },
3216     { "ast", OPT_INT | HAS_ARG | OPT_EXPERT, { &wanted_stream[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_number" },
3217     { "vst", OPT_INT | HAS_ARG | OPT_EXPERT, { &wanted_stream[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_number" },
3218     { "sst", OPT_INT | HAS_ARG | OPT_EXPERT, { &wanted_stream[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_number" },
3219     { "ss", HAS_ARG, { .func_arg = opt_seek }, "seek to a given position in seconds", "pos" },
3220     { "t", HAS_ARG, { .func_arg = opt_duration }, "play  \"duration\" seconds of audio/video", "duration" },
3221     { "bytes", OPT_INT | HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
3222     { "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
3223     { "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
3224     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
3225     { "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" },
3226     { "bug", OPT_INT | HAS_ARG | OPT_EXPERT, { &workaround_bugs }, "workaround bugs", "" },
3227     { "fast", OPT_BOOL | OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
3228     { "genpts", OPT_BOOL | OPT_EXPERT, { &genpts }, "generate pts", "" },
3229     { "drp", OPT_INT | HAS_ARG | OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
3230     { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, { &lowres }, "", "" },
3231     { "skiploop", OPT_INT | HAS_ARG | OPT_EXPERT, { &skip_loop_filter }, "", "" },
3232     { "skipframe", OPT_INT | HAS_ARG | OPT_EXPERT, { &skip_frame }, "", "" },
3233     { "skipidct", OPT_INT | HAS_ARG | OPT_EXPERT, { &skip_idct }, "", "" },
3234     { "idct", OPT_INT | HAS_ARG | OPT_EXPERT, { &idct }, "set idct algo",  "algo" },
3235     { "ec", OPT_INT | HAS_ARG | OPT_EXPERT, { &error_concealment }, "set error concealment options",  "bit_mask" },
3236     { "sync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
3237     { "autoexit", OPT_BOOL | OPT_EXPERT, { &autoexit }, "exit at the end", "" },
3238     { "exitonkeydown", OPT_BOOL | OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
3239     { "exitonmousedown", OPT_BOOL | OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
3240     { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
3241     { "framedrop", OPT_BOOL | OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
3242     { "infbuf", OPT_BOOL | OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
3243     { "window_title", OPT_STRING | HAS_ARG, { &window_title }, "set window title", "window title" },
3244 #if CONFIG_AVFILTER
3245     { "vf", OPT_STRING | HAS_ARG, { &vfilters }, "set video filters", "filter_graph" },
3246 #endif
3247     { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
3248     { "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
3249     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default }, "generic catch all option", "" },
3250     { "i", OPT_BOOL, { &dummy}, "read specified file", "input_file"},
3251     { "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
3252     { "acodec", HAS_ARG | OPT_STRING | OPT_EXPERT, {    &audio_codec_name }, "force audio decoder",    "decoder_name" },
3253     { "scodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
3254     { "vcodec", HAS_ARG | OPT_STRING | OPT_EXPERT, {    &video_codec_name }, "force video decoder",    "decoder_name" },
3255     { NULL, },
3256 };
3257
3258 static void show_usage(void)
3259 {
3260     av_log(NULL, AV_LOG_INFO, "Simple media player\n");
3261     av_log(NULL, AV_LOG_INFO, "usage: %s [options] input_file\n", program_name);
3262     av_log(NULL, AV_LOG_INFO, "\n");
3263 }
3264
3265 void show_help_default(const char *opt, const char *arg)
3266 {
3267     av_log_set_callback(log_callback_help);
3268     show_usage();
3269     show_help_options(options, "Main options:", 0, OPT_EXPERT, 0);
3270     show_help_options(options, "Advanced options:", OPT_EXPERT, 0, 0);
3271     printf("\n");
3272     show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3273     show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3274 #if !CONFIG_AVFILTER
3275     show_help_children(sws_get_class(), AV_OPT_FLAG_ENCODING_PARAM);
3276 #else
3277     show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
3278 #endif
3279     printf("\nWhile playing:\n"
3280            "q, ESC              quit\n"
3281            "f                   toggle full screen\n"
3282            "p, SPC              pause\n"
3283            "a                   cycle audio channel\n"
3284            "v                   cycle video channel\n"
3285            "t                   cycle subtitle channel\n"
3286            "w                   show audio waves\n"
3287            "s                   activate frame-step mode\n"
3288            "left/right          seek backward/forward 10 seconds\n"
3289            "down/up             seek backward/forward 1 minute\n"
3290            "page down/page up   seek backward/forward 10 minutes\n"
3291            "mouse click         seek to percentage in file corresponding to fraction of width\n"
3292            );
3293 }
3294
3295 static int lockmgr(void **mtx, enum AVLockOp op)
3296 {
3297    switch(op) {
3298       case AV_LOCK_CREATE:
3299           *mtx = SDL_CreateMutex();
3300           if(!*mtx)
3301               return 1;
3302           return 0;
3303       case AV_LOCK_OBTAIN:
3304           return !!SDL_LockMutex(*mtx);
3305       case AV_LOCK_RELEASE:
3306           return !!SDL_UnlockMutex(*mtx);
3307       case AV_LOCK_DESTROY:
3308           SDL_DestroyMutex(*mtx);
3309           return 0;
3310    }
3311    return 1;
3312 }
3313
3314 /* Called from the main */
3315 int main(int argc, char **argv)
3316 {
3317     int flags;
3318     VideoState *is;
3319     char dummy_videodriver[] = "SDL_VIDEODRIVER=dummy";
3320
3321     av_log_set_flags(AV_LOG_SKIP_REPEATED);
3322     parse_loglevel(argc, argv, options);
3323
3324     /* register all codecs, demux and protocols */
3325     avcodec_register_all();
3326 #if CONFIG_AVDEVICE
3327     avdevice_register_all();
3328 #endif
3329 #if CONFIG_AVFILTER
3330     avfilter_register_all();
3331 #endif
3332     av_register_all();
3333     avformat_network_init();
3334
3335     init_opts();
3336
3337     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
3338     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
3339
3340     show_banner(argc, argv, options);
3341
3342     parse_options(NULL, argc, argv, options, opt_input_file);
3343
3344     if (!input_filename) {
3345         show_usage();
3346         fprintf(stderr, "An input file must be specified\n");
3347         fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
3348         exit(1);
3349     }
3350
3351     if (display_disable) {
3352         video_disable = 1;
3353     }
3354     flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
3355     if (audio_disable)
3356         flags &= ~SDL_INIT_AUDIO;
3357     if (display_disable)
3358         SDL_putenv(dummy_videodriver); /* For the event queue, we always need a video driver. */
3359 #if !defined(__MINGW32__) && !defined(__APPLE__)
3360     flags |= SDL_INIT_EVENTTHREAD; /* Not supported on Windows or Mac OS X */
3361 #endif
3362     if (SDL_Init (flags)) {
3363         fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
3364         fprintf(stderr, "(Did you set the DISPLAY variable?)\n");
3365         exit(1);
3366     }
3367
3368     if (!display_disable) {
3369 #if HAVE_SDL_VIDEO_SIZE
3370         const SDL_VideoInfo *vi = SDL_GetVideoInfo();
3371         fs_screen_width = vi->current_w;
3372         fs_screen_height = vi->current_h;
3373 #endif
3374     }
3375
3376     SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
3377     SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
3378     SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
3379
3380     if (av_lockmgr_register(lockmgr)) {
3381         fprintf(stderr, "Could not initialize lock manager!\n");
3382         do_exit(NULL);
3383     }
3384
3385     av_init_packet(&flush_pkt);
3386     flush_pkt.data = (char *)(intptr_t)"FLUSH";
3387
3388     is = stream_open(input_filename, file_iformat);
3389     if (!is) {
3390         fprintf(stderr, "Failed to initialize VideoState!\n");
3391         do_exit(NULL);
3392     }
3393
3394     event_loop(is);
3395
3396     /* never returns */
3397
3398     return 0;
3399 }