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