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