export sample_aspect_ratio read by the demuxer in a separate field
[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 <math.h>
23 #include <limits.h>
24 #include "libavutil/avstring.h"
25 #include "libavformat/avformat.h"
26 #include "libavformat/rtsp.h"
27 #include "libavdevice/avdevice.h"
28 #include "libswscale/swscale.h"
29 #include "libavcodec/audioconvert.h"
30
31 #include "cmdutils.h"
32
33 #include <SDL.h>
34 #include <SDL_thread.h>
35
36 #ifdef __MINGW32__
37 #undef main /* We don't want SDL to override our main() */
38 #endif
39
40 #undef exit
41
42 const char program_name[] = "FFplay";
43 const int program_birth_year = 2003;
44
45 //#define DEBUG_SYNC
46
47 #define MAX_VIDEOQ_SIZE (5 * 256 * 1024)
48 #define MAX_AUDIOQ_SIZE (5 * 16 * 1024)
49 #define MAX_SUBTITLEQ_SIZE (5 * 16 * 1024)
50
51 /* SDL audio buffer size, in samples. Should be small to have precise
52    A/V sync as SDL does not have hardware buffer fullness info. */
53 #define SDL_AUDIO_BUFFER_SIZE 1024
54
55 /* no AV sync correction is done if below the AV sync threshold */
56 #define AV_SYNC_THRESHOLD 0.01
57 /* no AV correction is done if too big error */
58 #define AV_NOSYNC_THRESHOLD 10.0
59
60 /* maximum audio speed change to get correct sync */
61 #define SAMPLE_CORRECTION_PERCENT_MAX 10
62
63 /* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
64 #define AUDIO_DIFF_AVG_NB   20
65
66 /* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
67 #define SAMPLE_ARRAY_SIZE (2*65536)
68
69 static int sws_flags = SWS_BICUBIC;
70
71 typedef struct PacketQueue {
72     AVPacketList *first_pkt, *last_pkt;
73     int nb_packets;
74     int size;
75     int abort_request;
76     SDL_mutex *mutex;
77     SDL_cond *cond;
78 } PacketQueue;
79
80 #define VIDEO_PICTURE_QUEUE_SIZE 1
81 #define SUBPICTURE_QUEUE_SIZE 4
82
83 typedef struct VideoPicture {
84     double pts;                                  ///<presentation time stamp for this picture
85     SDL_Overlay *bmp;
86     int width, height; /* source height & width */
87     int allocated;
88 } VideoPicture;
89
90 typedef struct SubPicture {
91     double pts; /* presentation time stamp for this picture */
92     AVSubtitle sub;
93 } SubPicture;
94
95 enum {
96     AV_SYNC_AUDIO_MASTER, /* default choice */
97     AV_SYNC_VIDEO_MASTER,
98     AV_SYNC_EXTERNAL_CLOCK, /* synchronize to an external clock */
99 };
100
101 typedef struct VideoState {
102     SDL_Thread *parse_tid;
103     SDL_Thread *video_tid;
104     AVInputFormat *iformat;
105     int no_background;
106     int abort_request;
107     int paused;
108     int last_paused;
109     int seek_req;
110     int seek_flags;
111     int64_t seek_pos;
112     AVFormatContext *ic;
113     int dtg_active_format;
114
115     int audio_stream;
116
117     int av_sync_type;
118     double external_clock; /* external clock base */
119     int64_t external_clock_time;
120
121     double audio_clock;
122     double audio_diff_cum; /* used for AV difference average computation */
123     double audio_diff_avg_coef;
124     double audio_diff_threshold;
125     int audio_diff_avg_count;
126     AVStream *audio_st;
127     PacketQueue audioq;
128     int audio_hw_buf_size;
129     /* samples output by the codec. we reserve more space for avsync
130        compensation */
131     DECLARE_ALIGNED(16,uint8_t,audio_buf1[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2]);
132     DECLARE_ALIGNED(16,uint8_t,audio_buf2[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2]);
133     uint8_t *audio_buf;
134     unsigned int audio_buf_size; /* in bytes */
135     int audio_buf_index; /* in bytes */
136     AVPacket audio_pkt;
137     uint8_t *audio_pkt_data;
138     int audio_pkt_size;
139     enum SampleFormat audio_src_fmt;
140     AVAudioConvert *reformat_ctx;
141
142     int show_audio; /* if true, display audio samples */
143     int16_t sample_array[SAMPLE_ARRAY_SIZE];
144     int sample_array_index;
145     int last_i_start;
146
147     SDL_Thread *subtitle_tid;
148     int subtitle_stream;
149     int subtitle_stream_changed;
150     AVStream *subtitle_st;
151     PacketQueue subtitleq;
152     SubPicture subpq[SUBPICTURE_QUEUE_SIZE];
153     int subpq_size, subpq_rindex, subpq_windex;
154     SDL_mutex *subpq_mutex;
155     SDL_cond *subpq_cond;
156
157     double frame_timer;
158     double frame_last_pts;
159     double frame_last_delay;
160     double video_clock;                          ///<pts of last decoded frame / predicted pts of next decoded frame
161     int video_stream;
162     AVStream *video_st;
163     PacketQueue videoq;
164     double video_current_pts;                    ///<current displayed pts (different from video_clock if frame fifos are used)
165     int64_t video_current_pts_time;              ///<time (av_gettime) at which we updated video_current_pts - used to have running video pts
166     VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];
167     int pictq_size, pictq_rindex, pictq_windex;
168     SDL_mutex *pictq_mutex;
169     SDL_cond *pictq_cond;
170
171     //    QETimer *video_timer;
172     char filename[1024];
173     int width, height, xleft, ytop;
174 } VideoState;
175
176 static void show_help(void);
177 static int audio_write_get_buf_size(VideoState *is);
178
179 /* options specified by the user */
180 static AVInputFormat *file_iformat;
181 static const char *input_filename;
182 static int fs_screen_width;
183 static int fs_screen_height;
184 static int screen_width = 0;
185 static int screen_height = 0;
186 static int frame_width = 0;
187 static int frame_height = 0;
188 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
189 static int audio_disable;
190 static int video_disable;
191 static int wanted_audio_stream= 0;
192 static int wanted_video_stream= 0;
193 static int seek_by_bytes;
194 static int display_disable;
195 static int show_status;
196 static int av_sync_type = AV_SYNC_AUDIO_MASTER;
197 static int64_t start_time = AV_NOPTS_VALUE;
198 static int debug = 0;
199 static int debug_mv = 0;
200 static int step = 0;
201 static int thread_count = 1;
202 static int workaround_bugs = 1;
203 static int fast = 0;
204 static int genpts = 0;
205 static int lowres = 0;
206 static int idct = FF_IDCT_AUTO;
207 static enum AVDiscard skip_frame= AVDISCARD_DEFAULT;
208 static enum AVDiscard skip_idct= AVDISCARD_DEFAULT;
209 static enum AVDiscard skip_loop_filter= AVDISCARD_DEFAULT;
210 static int error_resilience = FF_ER_CAREFUL;
211 static int error_concealment = 3;
212 static int decoder_reorder_pts= 0;
213
214 /* current context */
215 static int is_full_screen;
216 static VideoState *cur_stream;
217 static int64_t audio_callback_time;
218
219 AVPacket flush_pkt;
220
221 #define FF_ALLOC_EVENT   (SDL_USEREVENT)
222 #define FF_REFRESH_EVENT (SDL_USEREVENT + 1)
223 #define FF_QUIT_EVENT    (SDL_USEREVENT + 2)
224
225 SDL_Surface *screen;
226
227 /* packet queue handling */
228 static void packet_queue_init(PacketQueue *q)
229 {
230     memset(q, 0, sizeof(PacketQueue));
231     q->mutex = SDL_CreateMutex();
232     q->cond = SDL_CreateCond();
233 }
234
235 static void packet_queue_flush(PacketQueue *q)
236 {
237     AVPacketList *pkt, *pkt1;
238
239     SDL_LockMutex(q->mutex);
240     for(pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
241         pkt1 = pkt->next;
242         av_free_packet(&pkt->pkt);
243         av_freep(&pkt);
244     }
245     q->last_pkt = NULL;
246     q->first_pkt = NULL;
247     q->nb_packets = 0;
248     q->size = 0;
249     SDL_UnlockMutex(q->mutex);
250 }
251
252 static void packet_queue_end(PacketQueue *q)
253 {
254     packet_queue_flush(q);
255     SDL_DestroyMutex(q->mutex);
256     SDL_DestroyCond(q->cond);
257 }
258
259 static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
260 {
261     AVPacketList *pkt1;
262
263     /* duplicate the packet */
264     if (pkt!=&flush_pkt && av_dup_packet(pkt) < 0)
265         return -1;
266
267     pkt1 = av_malloc(sizeof(AVPacketList));
268     if (!pkt1)
269         return -1;
270     pkt1->pkt = *pkt;
271     pkt1->next = NULL;
272
273
274     SDL_LockMutex(q->mutex);
275
276     if (!q->last_pkt)
277
278         q->first_pkt = pkt1;
279     else
280         q->last_pkt->next = pkt1;
281     q->last_pkt = pkt1;
282     q->nb_packets++;
283     q->size += pkt1->pkt.size;
284     /* XXX: should duplicate packet data in DV case */
285     SDL_CondSignal(q->cond);
286
287     SDL_UnlockMutex(q->mutex);
288     return 0;
289 }
290
291 static void packet_queue_abort(PacketQueue *q)
292 {
293     SDL_LockMutex(q->mutex);
294
295     q->abort_request = 1;
296
297     SDL_CondSignal(q->cond);
298
299     SDL_UnlockMutex(q->mutex);
300 }
301
302 /* return < 0 if aborted, 0 if no packet and > 0 if packet.  */
303 static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block)
304 {
305     AVPacketList *pkt1;
306     int ret;
307
308     SDL_LockMutex(q->mutex);
309
310     for(;;) {
311         if (q->abort_request) {
312             ret = -1;
313             break;
314         }
315
316         pkt1 = q->first_pkt;
317         if (pkt1) {
318             q->first_pkt = pkt1->next;
319             if (!q->first_pkt)
320                 q->last_pkt = NULL;
321             q->nb_packets--;
322             q->size -= pkt1->pkt.size;
323             *pkt = pkt1->pkt;
324             av_free(pkt1);
325             ret = 1;
326             break;
327         } else if (!block) {
328             ret = 0;
329             break;
330         } else {
331             SDL_CondWait(q->cond, q->mutex);
332         }
333     }
334     SDL_UnlockMutex(q->mutex);
335     return ret;
336 }
337
338 static inline void fill_rectangle(SDL_Surface *screen,
339                                   int x, int y, int w, int h, int color)
340 {
341     SDL_Rect rect;
342     rect.x = x;
343     rect.y = y;
344     rect.w = w;
345     rect.h = h;
346     SDL_FillRect(screen, &rect, color);
347 }
348
349 #if 0
350 /* draw only the border of a rectangle */
351 void fill_border(VideoState *s, int x, int y, int w, int h, int color)
352 {
353     int w1, w2, h1, h2;
354
355     /* fill the background */
356     w1 = x;
357     if (w1 < 0)
358         w1 = 0;
359     w2 = s->width - (x + w);
360     if (w2 < 0)
361         w2 = 0;
362     h1 = y;
363     if (h1 < 0)
364         h1 = 0;
365     h2 = s->height - (y + h);
366     if (h2 < 0)
367         h2 = 0;
368     fill_rectangle(screen,
369                    s->xleft, s->ytop,
370                    w1, s->height,
371                    color);
372     fill_rectangle(screen,
373                    s->xleft + s->width - w2, s->ytop,
374                    w2, s->height,
375                    color);
376     fill_rectangle(screen,
377                    s->xleft + w1, s->ytop,
378                    s->width - w1 - w2, h1,
379                    color);
380     fill_rectangle(screen,
381                    s->xleft + w1, s->ytop + s->height - h2,
382                    s->width - w1 - w2, h2,
383                    color);
384 }
385 #endif
386
387
388
389 #define SCALEBITS 10
390 #define ONE_HALF  (1 << (SCALEBITS - 1))
391 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
392
393 #define RGB_TO_Y_CCIR(r, g, b) \
394 ((FIX(0.29900*219.0/255.0) * (r) + FIX(0.58700*219.0/255.0) * (g) + \
395   FIX(0.11400*219.0/255.0) * (b) + (ONE_HALF + (16 << SCALEBITS))) >> SCALEBITS)
396
397 #define RGB_TO_U_CCIR(r1, g1, b1, shift)\
398 (((- FIX(0.16874*224.0/255.0) * r1 - FIX(0.33126*224.0/255.0) * g1 +         \
399      FIX(0.50000*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
400
401 #define RGB_TO_V_CCIR(r1, g1, b1, shift)\
402 (((FIX(0.50000*224.0/255.0) * r1 - FIX(0.41869*224.0/255.0) * g1 -           \
403    FIX(0.08131*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
404
405 #define ALPHA_BLEND(a, oldp, newp, s)\
406 ((((oldp << s) * (255 - (a))) + (newp * (a))) / (255 << s))
407
408 #define RGBA_IN(r, g, b, a, s)\
409 {\
410     unsigned int v = ((const uint32_t *)(s))[0];\
411     a = (v >> 24) & 0xff;\
412     r = (v >> 16) & 0xff;\
413     g = (v >> 8) & 0xff;\
414     b = v & 0xff;\
415 }
416
417 #define YUVA_IN(y, u, v, a, s, pal)\
418 {\
419     unsigned int val = ((const uint32_t *)(pal))[*(const uint8_t*)(s)];\
420     a = (val >> 24) & 0xff;\
421     y = (val >> 16) & 0xff;\
422     u = (val >> 8) & 0xff;\
423     v = val & 0xff;\
424 }
425
426 #define YUVA_OUT(d, y, u, v, a)\
427 {\
428     ((uint32_t *)(d))[0] = (a << 24) | (y << 16) | (u << 8) | v;\
429 }
430
431
432 #define BPP 1
433
434 static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect, int imgw, int imgh)
435 {
436     int wrap, wrap3, width2, skip2;
437     int y, u, v, a, u1, v1, a1, w, h;
438     uint8_t *lum, *cb, *cr;
439     const uint8_t *p;
440     const uint32_t *pal;
441     int dstx, dsty, dstw, dsth;
442
443     dstx = FFMIN(FFMAX(rect->x, 0), imgw);
444     dstw = FFMIN(FFMAX(rect->w, 0), imgw - dstx);
445     dsty = FFMIN(FFMAX(rect->y, 0), imgh);
446     dsth = FFMIN(FFMAX(rect->h, 0), imgh - dsty);
447     lum = dst->data[0] + dsty * dst->linesize[0];
448     cb = dst->data[1] + (dsty >> 1) * dst->linesize[1];
449     cr = dst->data[2] + (dsty >> 1) * dst->linesize[2];
450
451     width2 = (dstw + 1) >> 1;
452     skip2 = dstx >> 1;
453     wrap = dst->linesize[0];
454     wrap3 = rect->linesize;
455     p = rect->bitmap;
456     pal = rect->rgba_palette;  /* Now in YCrCb! */
457
458     if (dsty & 1) {
459         lum += dstx;
460         cb += skip2;
461         cr += skip2;
462
463         if (dstx & 1) {
464             YUVA_IN(y, u, v, a, p, pal);
465             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
466             cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
467             cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
468             cb++;
469             cr++;
470             lum++;
471             p += BPP;
472         }
473         for(w = dstw - (dstx & 1); w >= 2; w -= 2) {
474             YUVA_IN(y, u, v, a, p, pal);
475             u1 = u;
476             v1 = v;
477             a1 = a;
478             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
479
480             YUVA_IN(y, u, v, a, p + BPP, pal);
481             u1 += u;
482             v1 += v;
483             a1 += a;
484             lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
485             cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
486             cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
487             cb++;
488             cr++;
489             p += 2 * BPP;
490             lum += 2;
491         }
492         if (w) {
493             YUVA_IN(y, u, v, a, p, pal);
494             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
495             cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
496             cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
497         }
498         p += wrap3 + (wrap3 - dstw * BPP);
499         lum += wrap + (wrap - dstw - dstx);
500         cb += dst->linesize[1] - width2 - skip2;
501         cr += dst->linesize[2] - width2 - skip2;
502     }
503     for(h = dsth - (dsty & 1); h >= 2; h -= 2) {
504         lum += dstx;
505         cb += skip2;
506         cr += skip2;
507
508         if (dstx & 1) {
509             YUVA_IN(y, u, v, a, p, pal);
510             u1 = u;
511             v1 = v;
512             a1 = a;
513             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
514             p += wrap3;
515             lum += wrap;
516             YUVA_IN(y, u, v, a, p, pal);
517             u1 += u;
518             v1 += v;
519             a1 += a;
520             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
521             cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
522             cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
523             cb++;
524             cr++;
525             p += -wrap3 + BPP;
526             lum += -wrap + 1;
527         }
528         for(w = dstw - (dstx & 1); w >= 2; w -= 2) {
529             YUVA_IN(y, u, v, a, p, pal);
530             u1 = u;
531             v1 = v;
532             a1 = a;
533             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
534
535             YUVA_IN(y, u, v, a, p, pal);
536             u1 += u;
537             v1 += v;
538             a1 += a;
539             lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
540             p += wrap3;
541             lum += wrap;
542
543             YUVA_IN(y, u, v, a, p, pal);
544             u1 += u;
545             v1 += v;
546             a1 += a;
547             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
548
549             YUVA_IN(y, u, v, a, p, pal);
550             u1 += u;
551             v1 += v;
552             a1 += a;
553             lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
554
555             cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 2);
556             cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 2);
557
558             cb++;
559             cr++;
560             p += -wrap3 + 2 * BPP;
561             lum += -wrap + 2;
562         }
563         if (w) {
564             YUVA_IN(y, u, v, a, p, pal);
565             u1 = u;
566             v1 = v;
567             a1 = a;
568             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
569             p += wrap3;
570             lum += wrap;
571             YUVA_IN(y, u, v, a, p, pal);
572             u1 += u;
573             v1 += v;
574             a1 += a;
575             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
576             cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
577             cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
578             cb++;
579             cr++;
580             p += -wrap3 + BPP;
581             lum += -wrap + 1;
582         }
583         p += wrap3 + (wrap3 - dstw * BPP);
584         lum += wrap + (wrap - dstw - dstx);
585         cb += dst->linesize[1] - width2 - skip2;
586         cr += dst->linesize[2] - width2 - skip2;
587     }
588     /* handle odd height */
589     if (h) {
590         lum += dstx;
591         cb += skip2;
592         cr += skip2;
593
594         if (dstx & 1) {
595             YUVA_IN(y, u, v, a, p, pal);
596             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
597             cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
598             cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
599             cb++;
600             cr++;
601             lum++;
602             p += BPP;
603         }
604         for(w = dstw - (dstx & 1); w >= 2; w -= 2) {
605             YUVA_IN(y, u, v, a, p, pal);
606             u1 = u;
607             v1 = v;
608             a1 = a;
609             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
610
611             YUVA_IN(y, u, v, a, p + BPP, pal);
612             u1 += u;
613             v1 += v;
614             a1 += a;
615             lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
616             cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u, 1);
617             cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v, 1);
618             cb++;
619             cr++;
620             p += 2 * BPP;
621             lum += 2;
622         }
623         if (w) {
624             YUVA_IN(y, u, v, a, p, pal);
625             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
626             cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
627             cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
628         }
629     }
630 }
631
632 static void free_subpicture(SubPicture *sp)
633 {
634     int i;
635
636     for (i = 0; i < sp->sub.num_rects; i++)
637     {
638         av_free(sp->sub.rects[i].bitmap);
639         av_free(sp->sub.rects[i].rgba_palette);
640     }
641
642     av_free(sp->sub.rects);
643
644     memset(&sp->sub, 0, sizeof(AVSubtitle));
645 }
646
647 static void video_image_display(VideoState *is)
648 {
649     VideoPicture *vp;
650     SubPicture *sp;
651     AVPicture pict;
652     float aspect_ratio;
653     int width, height, x, y;
654     SDL_Rect rect;
655     int i;
656
657     vp = &is->pictq[is->pictq_rindex];
658     if (vp->bmp) {
659         /* XXX: use variable in the frame */
660         if (is->video_st->sample_aspect_ratio.num)
661             aspect_ratio = av_q2d(is->video_st->sample_aspect_ratio);
662         else if (is->video_st->codec->sample_aspect_ratio.num)
663             aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio);
664         else
665             aspect_ratio = 0;
666         if (aspect_ratio <= 0.0)
667             aspect_ratio = 1.0;
668         aspect_ratio *= (float)is->video_st->codec->width / is->video_st->codec->height;
669         /* if an active format is indicated, then it overrides the
670            mpeg format */
671 #if 0
672         if (is->video_st->codec->dtg_active_format != is->dtg_active_format) {
673             is->dtg_active_format = is->video_st->codec->dtg_active_format;
674             printf("dtg_active_format=%d\n", is->dtg_active_format);
675         }
676 #endif
677 #if 0
678         switch(is->video_st->codec->dtg_active_format) {
679         case FF_DTG_AFD_SAME:
680         default:
681             /* nothing to do */
682             break;
683         case FF_DTG_AFD_4_3:
684             aspect_ratio = 4.0 / 3.0;
685             break;
686         case FF_DTG_AFD_16_9:
687             aspect_ratio = 16.0 / 9.0;
688             break;
689         case FF_DTG_AFD_14_9:
690             aspect_ratio = 14.0 / 9.0;
691             break;
692         case FF_DTG_AFD_4_3_SP_14_9:
693             aspect_ratio = 14.0 / 9.0;
694             break;
695         case FF_DTG_AFD_16_9_SP_14_9:
696             aspect_ratio = 14.0 / 9.0;
697             break;
698         case FF_DTG_AFD_SP_4_3:
699             aspect_ratio = 4.0 / 3.0;
700             break;
701         }
702 #endif
703
704         if (is->subtitle_st)
705         {
706             if (is->subpq_size > 0)
707             {
708                 sp = &is->subpq[is->subpq_rindex];
709
710                 if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000))
711                 {
712                     SDL_LockYUVOverlay (vp->bmp);
713
714                     pict.data[0] = vp->bmp->pixels[0];
715                     pict.data[1] = vp->bmp->pixels[2];
716                     pict.data[2] = vp->bmp->pixels[1];
717
718                     pict.linesize[0] = vp->bmp->pitches[0];
719                     pict.linesize[1] = vp->bmp->pitches[2];
720                     pict.linesize[2] = vp->bmp->pitches[1];
721
722                     for (i = 0; i < sp->sub.num_rects; i++)
723                         blend_subrect(&pict, &sp->sub.rects[i],
724                                       vp->bmp->w, vp->bmp->h);
725
726                     SDL_UnlockYUVOverlay (vp->bmp);
727                 }
728             }
729         }
730
731
732         /* XXX: we suppose the screen has a 1.0 pixel ratio */
733         height = is->height;
734         width = ((int)rint(height * aspect_ratio)) & -3;
735         if (width > is->width) {
736             width = is->width;
737             height = ((int)rint(width / aspect_ratio)) & -3;
738         }
739         x = (is->width - width) / 2;
740         y = (is->height - height) / 2;
741         if (!is->no_background) {
742             /* fill the background */
743             //            fill_border(is, x, y, width, height, QERGB(0x00, 0x00, 0x00));
744         } else {
745             is->no_background = 0;
746         }
747         rect.x = is->xleft + x;
748         rect.y = is->ytop  + y;
749         rect.w = width;
750         rect.h = height;
751         SDL_DisplayYUVOverlay(vp->bmp, &rect);
752     } else {
753 #if 0
754         fill_rectangle(screen,
755                        is->xleft, is->ytop, is->width, is->height,
756                        QERGB(0x00, 0x00, 0x00));
757 #endif
758     }
759 }
760
761 static inline int compute_mod(int a, int b)
762 {
763     a = a % b;
764     if (a >= 0)
765         return a;
766     else
767         return a + b;
768 }
769
770 static void video_audio_display(VideoState *s)
771 {
772     int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
773     int ch, channels, h, h2, bgcolor, fgcolor;
774     int16_t time_diff;
775
776     /* compute display index : center on currently output samples */
777     channels = s->audio_st->codec->channels;
778     nb_display_channels = channels;
779     if (!s->paused) {
780         n = 2 * channels;
781         delay = audio_write_get_buf_size(s);
782         delay /= n;
783
784         /* to be more precise, we take into account the time spent since
785            the last buffer computation */
786         if (audio_callback_time) {
787             time_diff = av_gettime() - audio_callback_time;
788             delay += (time_diff * s->audio_st->codec->sample_rate) / 1000000;
789         }
790
791         delay -= s->width / 2;
792         if (delay < s->width)
793             delay = s->width;
794
795         i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
796
797         h= INT_MIN;
798         for(i=0; i<1000; i+=channels){
799             int idx= (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
800             int a= s->sample_array[idx];
801             int b= s->sample_array[(idx + 4*channels)%SAMPLE_ARRAY_SIZE];
802             int c= s->sample_array[(idx + 5*channels)%SAMPLE_ARRAY_SIZE];
803             int d= s->sample_array[(idx + 9*channels)%SAMPLE_ARRAY_SIZE];
804             int score= a-d;
805             if(h<score && (b^c)<0){
806                 h= score;
807                 i_start= idx;
808             }
809         }
810
811         s->last_i_start = i_start;
812     } else {
813         i_start = s->last_i_start;
814     }
815
816     bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
817     fill_rectangle(screen,
818                    s->xleft, s->ytop, s->width, s->height,
819                    bgcolor);
820
821     fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);
822
823     /* total height for one channel */
824     h = s->height / nb_display_channels;
825     /* graph height / 2 */
826     h2 = (h * 9) / 20;
827     for(ch = 0;ch < nb_display_channels; ch++) {
828         i = i_start + ch;
829         y1 = s->ytop + ch * h + (h / 2); /* position of center line */
830         for(x = 0; x < s->width; x++) {
831             y = (s->sample_array[i] * h2) >> 15;
832             if (y < 0) {
833                 y = -y;
834                 ys = y1 - y;
835             } else {
836                 ys = y1;
837             }
838             fill_rectangle(screen,
839                            s->xleft + x, ys, 1, y,
840                            fgcolor);
841             i += channels;
842             if (i >= SAMPLE_ARRAY_SIZE)
843                 i -= SAMPLE_ARRAY_SIZE;
844         }
845     }
846
847     fgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff);
848
849     for(ch = 1;ch < nb_display_channels; ch++) {
850         y = s->ytop + ch * h;
851         fill_rectangle(screen,
852                        s->xleft, y, s->width, 1,
853                        fgcolor);
854     }
855     SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height);
856 }
857
858 static int video_open(VideoState *is){
859     int flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL;
860     int w,h;
861
862     if(is_full_screen) flags |= SDL_FULLSCREEN;
863     else               flags |= SDL_RESIZABLE;
864
865     if (is_full_screen && fs_screen_width) {
866         w = fs_screen_width;
867         h = fs_screen_height;
868     } else if(!is_full_screen && screen_width){
869         w = screen_width;
870         h = screen_height;
871     }else if (is->video_st && is->video_st->codec->width){
872         w = is->video_st->codec->width;
873         h = is->video_st->codec->height;
874     } else {
875         w = 640;
876         h = 480;
877     }
878 #ifndef __APPLE__
879     screen = SDL_SetVideoMode(w, h, 0, flags);
880 #else
881     /* setting bits_per_pixel = 0 or 32 causes blank video on OS X */
882     screen = SDL_SetVideoMode(w, h, 24, flags);
883 #endif
884     if (!screen) {
885         fprintf(stderr, "SDL: could not set video mode - exiting\n");
886         return -1;
887     }
888     SDL_WM_SetCaption("FFplay", "FFplay");
889
890     is->width = screen->w;
891     is->height = screen->h;
892
893     return 0;
894 }
895
896 /* display the current picture, if any */
897 static void video_display(VideoState *is)
898 {
899     if(!screen)
900         video_open(cur_stream);
901     if (is->audio_st && is->show_audio)
902         video_audio_display(is);
903     else if (is->video_st)
904         video_image_display(is);
905 }
906
907 static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque)
908 {
909     SDL_Event event;
910     event.type = FF_REFRESH_EVENT;
911     event.user.data1 = opaque;
912     SDL_PushEvent(&event);
913     return 0; /* 0 means stop timer */
914 }
915
916 /* schedule a video refresh in 'delay' ms */
917 static void schedule_refresh(VideoState *is, int delay)
918 {
919     SDL_AddTimer(delay, sdl_refresh_timer_cb, is);
920 }
921
922 /* get the current audio clock value */
923 static double get_audio_clock(VideoState *is)
924 {
925     double pts;
926     int hw_buf_size, bytes_per_sec;
927     pts = is->audio_clock;
928     hw_buf_size = audio_write_get_buf_size(is);
929     bytes_per_sec = 0;
930     if (is->audio_st) {
931         bytes_per_sec = is->audio_st->codec->sample_rate *
932             2 * is->audio_st->codec->channels;
933     }
934     if (bytes_per_sec)
935         pts -= (double)hw_buf_size / bytes_per_sec;
936     return pts;
937 }
938
939 /* get the current video clock value */
940 static double get_video_clock(VideoState *is)
941 {
942     double delta;
943     if (is->paused) {
944         delta = 0;
945     } else {
946         delta = (av_gettime() - is->video_current_pts_time) / 1000000.0;
947     }
948     return is->video_current_pts + delta;
949 }
950
951 /* get the current external clock value */
952 static double get_external_clock(VideoState *is)
953 {
954     int64_t ti;
955     ti = av_gettime();
956     return is->external_clock + ((ti - is->external_clock_time) * 1e-6);
957 }
958
959 /* get the current master clock value */
960 static double get_master_clock(VideoState *is)
961 {
962     double val;
963
964     if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
965         if (is->video_st)
966             val = get_video_clock(is);
967         else
968             val = get_audio_clock(is);
969     } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
970         if (is->audio_st)
971             val = get_audio_clock(is);
972         else
973             val = get_video_clock(is);
974     } else {
975         val = get_external_clock(is);
976     }
977     return val;
978 }
979
980 /* seek in the stream */
981 static void stream_seek(VideoState *is, int64_t pos, int rel)
982 {
983     if (!is->seek_req) {
984         is->seek_pos = pos;
985         is->seek_flags = rel < 0 ? AVSEEK_FLAG_BACKWARD : 0;
986         if (seek_by_bytes)
987             is->seek_flags |= AVSEEK_FLAG_BYTE;
988         is->seek_req = 1;
989     }
990 }
991
992 /* pause or resume the video */
993 static void stream_pause(VideoState *is)
994 {
995     is->paused = !is->paused;
996     if (!is->paused) {
997         is->video_current_pts = get_video_clock(is);
998         is->frame_timer += (av_gettime() - is->video_current_pts_time) / 1000000.0;
999     }
1000 }
1001
1002 /* called to display each frame */
1003 static void video_refresh_timer(void *opaque)
1004 {
1005     VideoState *is = opaque;
1006     VideoPicture *vp;
1007     double actual_delay, delay, sync_threshold, ref_clock, diff;
1008
1009     SubPicture *sp, *sp2;
1010
1011     if (is->video_st) {
1012         if (is->pictq_size == 0) {
1013             /* if no picture, need to wait */
1014             schedule_refresh(is, 1);
1015         } else {
1016             /* dequeue the picture */
1017             vp = &is->pictq[is->pictq_rindex];
1018
1019             /* update current video pts */
1020             is->video_current_pts = vp->pts;
1021             is->video_current_pts_time = av_gettime();
1022
1023             /* compute nominal delay */
1024             delay = vp->pts - is->frame_last_pts;
1025             if (delay <= 0 || delay >= 2.0) {
1026                 /* if incorrect delay, use previous one */
1027                 delay = is->frame_last_delay;
1028             }
1029             is->frame_last_delay = delay;
1030             is->frame_last_pts = vp->pts;
1031
1032             /* update delay to follow master synchronisation source */
1033             if (((is->av_sync_type == AV_SYNC_AUDIO_MASTER && is->audio_st) ||
1034                  is->av_sync_type == AV_SYNC_EXTERNAL_CLOCK)) {
1035                 /* if video is slave, we try to correct big delays by
1036                    duplicating or deleting a frame */
1037                 ref_clock = get_master_clock(is);
1038                 diff = vp->pts - ref_clock;
1039
1040                 /* skip or repeat frame. We take into account the
1041                    delay to compute the threshold. I still don't know
1042                    if it is the best guess */
1043                 sync_threshold = FFMAX(AV_SYNC_THRESHOLD, delay);
1044                 if (fabs(diff) < AV_NOSYNC_THRESHOLD) {
1045                     if (diff <= -sync_threshold)
1046                         delay = 0;
1047                     else if (diff >= sync_threshold)
1048                         delay = 2 * delay;
1049                 }
1050             }
1051
1052             is->frame_timer += delay;
1053             /* compute the REAL delay (we need to do that to avoid
1054                long term errors */
1055             actual_delay = is->frame_timer - (av_gettime() / 1000000.0);
1056             if (actual_delay < 0.010) {
1057                 /* XXX: should skip picture */
1058                 actual_delay = 0.010;
1059             }
1060             /* launch timer for next picture */
1061             schedule_refresh(is, (int)(actual_delay * 1000 + 0.5));
1062
1063 #if defined(DEBUG_SYNC)
1064             printf("video: delay=%0.3f actual_delay=%0.3f pts=%0.3f A-V=%f\n",
1065                    delay, actual_delay, vp->pts, -diff);
1066 #endif
1067
1068             if(is->subtitle_st) {
1069                 if (is->subtitle_stream_changed) {
1070                     SDL_LockMutex(is->subpq_mutex);
1071
1072                     while (is->subpq_size) {
1073                         free_subpicture(&is->subpq[is->subpq_rindex]);
1074
1075                         /* update queue size and signal for next picture */
1076                         if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
1077                             is->subpq_rindex = 0;
1078
1079                         is->subpq_size--;
1080                     }
1081                     is->subtitle_stream_changed = 0;
1082
1083                     SDL_CondSignal(is->subpq_cond);
1084                     SDL_UnlockMutex(is->subpq_mutex);
1085                 } else {
1086                     if (is->subpq_size > 0) {
1087                         sp = &is->subpq[is->subpq_rindex];
1088
1089                         if (is->subpq_size > 1)
1090                             sp2 = &is->subpq[(is->subpq_rindex + 1) % SUBPICTURE_QUEUE_SIZE];
1091                         else
1092                             sp2 = NULL;
1093
1094                         if ((is->video_current_pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1095                                 || (sp2 && is->video_current_pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1096                         {
1097                             free_subpicture(sp);
1098
1099                             /* update queue size and signal for next picture */
1100                             if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
1101                                 is->subpq_rindex = 0;
1102
1103                             SDL_LockMutex(is->subpq_mutex);
1104                             is->subpq_size--;
1105                             SDL_CondSignal(is->subpq_cond);
1106                             SDL_UnlockMutex(is->subpq_mutex);
1107                         }
1108                     }
1109                 }
1110             }
1111
1112             /* display picture */
1113             video_display(is);
1114
1115             /* update queue size and signal for next picture */
1116             if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE)
1117                 is->pictq_rindex = 0;
1118
1119             SDL_LockMutex(is->pictq_mutex);
1120             is->pictq_size--;
1121             SDL_CondSignal(is->pictq_cond);
1122             SDL_UnlockMutex(is->pictq_mutex);
1123         }
1124     } else if (is->audio_st) {
1125         /* draw the next audio frame */
1126
1127         schedule_refresh(is, 40);
1128
1129         /* if only audio stream, then display the audio bars (better
1130            than nothing, just to test the implementation */
1131
1132         /* display picture */
1133         video_display(is);
1134     } else {
1135         schedule_refresh(is, 100);
1136     }
1137     if (show_status) {
1138         static int64_t last_time;
1139         int64_t cur_time;
1140         int aqsize, vqsize, sqsize;
1141         double av_diff;
1142
1143         cur_time = av_gettime();
1144         if (!last_time || (cur_time - last_time) >= 500 * 1000) {
1145             aqsize = 0;
1146             vqsize = 0;
1147             sqsize = 0;
1148             if (is->audio_st)
1149                 aqsize = is->audioq.size;
1150             if (is->video_st)
1151                 vqsize = is->videoq.size;
1152             if (is->subtitle_st)
1153                 sqsize = is->subtitleq.size;
1154             av_diff = 0;
1155             if (is->audio_st && is->video_st)
1156                 av_diff = get_audio_clock(is) - get_video_clock(is);
1157             printf("%7.2f A-V:%7.3f aq=%5dKB vq=%5dKB sq=%5dB    \r",
1158                    get_master_clock(is), av_diff, aqsize / 1024, vqsize / 1024, sqsize);
1159             fflush(stdout);
1160             last_time = cur_time;
1161         }
1162     }
1163 }
1164
1165 /* allocate a picture (needs to do that in main thread to avoid
1166    potential locking problems */
1167 static void alloc_picture(void *opaque)
1168 {
1169     VideoState *is = opaque;
1170     VideoPicture *vp;
1171
1172     vp = &is->pictq[is->pictq_windex];
1173
1174     if (vp->bmp)
1175         SDL_FreeYUVOverlay(vp->bmp);
1176
1177 #if 0
1178     /* XXX: use generic function */
1179     /* XXX: disable overlay if no hardware acceleration or if RGB format */
1180     switch(is->video_st->codec->pix_fmt) {
1181     case PIX_FMT_YUV420P:
1182     case PIX_FMT_YUV422P:
1183     case PIX_FMT_YUV444P:
1184     case PIX_FMT_YUYV422:
1185     case PIX_FMT_YUV410P:
1186     case PIX_FMT_YUV411P:
1187         is_yuv = 1;
1188         break;
1189     default:
1190         is_yuv = 0;
1191         break;
1192     }
1193 #endif
1194     vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec->width,
1195                                    is->video_st->codec->height,
1196                                    SDL_YV12_OVERLAY,
1197                                    screen);
1198     vp->width = is->video_st->codec->width;
1199     vp->height = is->video_st->codec->height;
1200
1201     SDL_LockMutex(is->pictq_mutex);
1202     vp->allocated = 1;
1203     SDL_CondSignal(is->pictq_cond);
1204     SDL_UnlockMutex(is->pictq_mutex);
1205 }
1206
1207 /**
1208  *
1209  * @param pts the dts of the pkt / pts of the frame and guessed if not known
1210  */
1211 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts)
1212 {
1213     VideoPicture *vp;
1214     int dst_pix_fmt;
1215     AVPicture pict;
1216     static struct SwsContext *img_convert_ctx;
1217
1218     /* wait until we have space to put a new picture */
1219     SDL_LockMutex(is->pictq_mutex);
1220     while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE &&
1221            !is->videoq.abort_request) {
1222         SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1223     }
1224     SDL_UnlockMutex(is->pictq_mutex);
1225
1226     if (is->videoq.abort_request)
1227         return -1;
1228
1229     vp = &is->pictq[is->pictq_windex];
1230
1231     /* alloc or resize hardware picture buffer */
1232     if (!vp->bmp ||
1233         vp->width != is->video_st->codec->width ||
1234         vp->height != is->video_st->codec->height) {
1235         SDL_Event event;
1236
1237         vp->allocated = 0;
1238
1239         /* the allocation must be done in the main thread to avoid
1240            locking problems */
1241         event.type = FF_ALLOC_EVENT;
1242         event.user.data1 = is;
1243         SDL_PushEvent(&event);
1244
1245         /* wait until the picture is allocated */
1246         SDL_LockMutex(is->pictq_mutex);
1247         while (!vp->allocated && !is->videoq.abort_request) {
1248             SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1249         }
1250         SDL_UnlockMutex(is->pictq_mutex);
1251
1252         if (is->videoq.abort_request)
1253             return -1;
1254     }
1255
1256     /* if the frame is not skipped, then display it */
1257     if (vp->bmp) {
1258         /* get a pointer on the bitmap */
1259         SDL_LockYUVOverlay (vp->bmp);
1260
1261         dst_pix_fmt = PIX_FMT_YUV420P;
1262         pict.data[0] = vp->bmp->pixels[0];
1263         pict.data[1] = vp->bmp->pixels[2];
1264         pict.data[2] = vp->bmp->pixels[1];
1265
1266         pict.linesize[0] = vp->bmp->pitches[0];
1267         pict.linesize[1] = vp->bmp->pitches[2];
1268         pict.linesize[2] = vp->bmp->pitches[1];
1269         img_convert_ctx = sws_getCachedContext(img_convert_ctx,
1270             is->video_st->codec->width, is->video_st->codec->height,
1271             is->video_st->codec->pix_fmt,
1272             is->video_st->codec->width, is->video_st->codec->height,
1273             dst_pix_fmt, sws_flags, NULL, NULL, NULL);
1274         if (img_convert_ctx == NULL) {
1275             fprintf(stderr, "Cannot initialize the conversion context\n");
1276             exit(1);
1277         }
1278         sws_scale(img_convert_ctx, src_frame->data, src_frame->linesize,
1279                   0, is->video_st->codec->height, pict.data, pict.linesize);
1280         /* update the bitmap content */
1281         SDL_UnlockYUVOverlay(vp->bmp);
1282
1283         vp->pts = pts;
1284
1285         /* now we can update the picture count */
1286         if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE)
1287             is->pictq_windex = 0;
1288         SDL_LockMutex(is->pictq_mutex);
1289         is->pictq_size++;
1290         SDL_UnlockMutex(is->pictq_mutex);
1291     }
1292     return 0;
1293 }
1294
1295 /**
1296  * compute the exact PTS for the picture if it is omitted in the stream
1297  * @param pts1 the dts of the pkt / pts of the frame
1298  */
1299 static int output_picture2(VideoState *is, AVFrame *src_frame, double pts1)
1300 {
1301     double frame_delay, pts;
1302
1303     pts = pts1;
1304
1305     if (pts != 0) {
1306         /* update video clock with pts, if present */
1307         is->video_clock = pts;
1308     } else {
1309         pts = is->video_clock;
1310     }
1311     /* update video clock for next frame */
1312     frame_delay = av_q2d(is->video_st->codec->time_base);
1313     /* for MPEG2, the frame can be repeated, so we update the
1314        clock accordingly */
1315     frame_delay += src_frame->repeat_pict * (frame_delay * 0.5);
1316     is->video_clock += frame_delay;
1317
1318 #if defined(DEBUG_SYNC) && 0
1319     {
1320         int ftype;
1321         if (src_frame->pict_type == FF_B_TYPE)
1322             ftype = 'B';
1323         else if (src_frame->pict_type == FF_I_TYPE)
1324             ftype = 'I';
1325         else
1326             ftype = 'P';
1327         printf("frame_type=%c clock=%0.3f pts=%0.3f\n",
1328                ftype, pts, pts1);
1329     }
1330 #endif
1331     return queue_picture(is, src_frame, pts);
1332 }
1333
1334 static int video_thread(void *arg)
1335 {
1336     VideoState *is = arg;
1337     AVPacket pkt1, *pkt = &pkt1;
1338     int len1, got_picture;
1339     AVFrame *frame= avcodec_alloc_frame();
1340     double pts;
1341
1342     for(;;) {
1343         while (is->paused && !is->videoq.abort_request) {
1344             SDL_Delay(10);
1345         }
1346         if (packet_queue_get(&is->videoq, pkt, 1) < 0)
1347             break;
1348
1349         if(pkt->data == flush_pkt.data){
1350             avcodec_flush_buffers(is->video_st->codec);
1351             continue;
1352         }
1353
1354         /* NOTE: ipts is the PTS of the _first_ picture beginning in
1355            this packet, if any */
1356         is->video_st->codec->reordered_opaque= pkt->pts;
1357         len1 = avcodec_decode_video(is->video_st->codec,
1358                                     frame, &got_picture,
1359                                     pkt->data, pkt->size);
1360
1361         if(   (decoder_reorder_pts || pkt->dts == AV_NOPTS_VALUE)
1362            && frame->reordered_opaque != AV_NOPTS_VALUE)
1363             pts= frame->reordered_opaque;
1364         else if(pkt->dts != AV_NOPTS_VALUE)
1365             pts= pkt->dts;
1366         else
1367             pts= 0;
1368         pts *= av_q2d(is->video_st->time_base);
1369
1370 //            if (len1 < 0)
1371 //                break;
1372         if (got_picture) {
1373             if (output_picture2(is, frame, pts) < 0)
1374                 goto the_end;
1375         }
1376         av_free_packet(pkt);
1377         if (step)
1378             if (cur_stream)
1379                 stream_pause(cur_stream);
1380     }
1381  the_end:
1382     av_free(frame);
1383     return 0;
1384 }
1385
1386 static int subtitle_thread(void *arg)
1387 {
1388     VideoState *is = arg;
1389     SubPicture *sp;
1390     AVPacket pkt1, *pkt = &pkt1;
1391     int len1, got_subtitle;
1392     double pts;
1393     int i, j;
1394     int r, g, b, y, u, v, a;
1395
1396     for(;;) {
1397         while (is->paused && !is->subtitleq.abort_request) {
1398             SDL_Delay(10);
1399         }
1400         if (packet_queue_get(&is->subtitleq, pkt, 1) < 0)
1401             break;
1402
1403         if(pkt->data == flush_pkt.data){
1404             avcodec_flush_buffers(is->subtitle_st->codec);
1405             continue;
1406         }
1407         SDL_LockMutex(is->subpq_mutex);
1408         while (is->subpq_size >= SUBPICTURE_QUEUE_SIZE &&
1409                !is->subtitleq.abort_request) {
1410             SDL_CondWait(is->subpq_cond, is->subpq_mutex);
1411         }
1412         SDL_UnlockMutex(is->subpq_mutex);
1413
1414         if (is->subtitleq.abort_request)
1415             goto the_end;
1416
1417         sp = &is->subpq[is->subpq_windex];
1418
1419        /* NOTE: ipts is the PTS of the _first_ picture beginning in
1420            this packet, if any */
1421         pts = 0;
1422         if (pkt->pts != AV_NOPTS_VALUE)
1423             pts = av_q2d(is->subtitle_st->time_base)*pkt->pts;
1424
1425         len1 = avcodec_decode_subtitle(is->subtitle_st->codec,
1426                                     &sp->sub, &got_subtitle,
1427                                     pkt->data, pkt->size);
1428 //            if (len1 < 0)
1429 //                break;
1430         if (got_subtitle && sp->sub.format == 0) {
1431             sp->pts = pts;
1432
1433             for (i = 0; i < sp->sub.num_rects; i++)
1434             {
1435                 for (j = 0; j < sp->sub.rects[i].nb_colors; j++)
1436                 {
1437                     RGBA_IN(r, g, b, a, sp->sub.rects[i].rgba_palette + j);
1438                     y = RGB_TO_Y_CCIR(r, g, b);
1439                     u = RGB_TO_U_CCIR(r, g, b, 0);
1440                     v = RGB_TO_V_CCIR(r, g, b, 0);
1441                     YUVA_OUT(sp->sub.rects[i].rgba_palette + j, y, u, v, a);
1442                 }
1443             }
1444
1445             /* now we can update the picture count */
1446             if (++is->subpq_windex == SUBPICTURE_QUEUE_SIZE)
1447                 is->subpq_windex = 0;
1448             SDL_LockMutex(is->subpq_mutex);
1449             is->subpq_size++;
1450             SDL_UnlockMutex(is->subpq_mutex);
1451         }
1452         av_free_packet(pkt);
1453 //        if (step)
1454 //            if (cur_stream)
1455 //                stream_pause(cur_stream);
1456     }
1457  the_end:
1458     return 0;
1459 }
1460
1461 /* copy samples for viewing in editor window */
1462 static void update_sample_display(VideoState *is, short *samples, int samples_size)
1463 {
1464     int size, len, channels;
1465
1466     channels = is->audio_st->codec->channels;
1467
1468     size = samples_size / sizeof(short);
1469     while (size > 0) {
1470         len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
1471         if (len > size)
1472             len = size;
1473         memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
1474         samples += len;
1475         is->sample_array_index += len;
1476         if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
1477             is->sample_array_index = 0;
1478         size -= len;
1479     }
1480 }
1481
1482 /* return the new audio buffer size (samples can be added or deleted
1483    to get better sync if video or external master clock) */
1484 static int synchronize_audio(VideoState *is, short *samples,
1485                              int samples_size1, double pts)
1486 {
1487     int n, samples_size;
1488     double ref_clock;
1489
1490     n = 2 * is->audio_st->codec->channels;
1491     samples_size = samples_size1;
1492
1493     /* if not master, then we try to remove or add samples to correct the clock */
1494     if (((is->av_sync_type == AV_SYNC_VIDEO_MASTER && is->video_st) ||
1495          is->av_sync_type == AV_SYNC_EXTERNAL_CLOCK)) {
1496         double diff, avg_diff;
1497         int wanted_size, min_size, max_size, nb_samples;
1498
1499         ref_clock = get_master_clock(is);
1500         diff = get_audio_clock(is) - ref_clock;
1501
1502         if (diff < AV_NOSYNC_THRESHOLD) {
1503             is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
1504             if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
1505                 /* not enough measures to have a correct estimate */
1506                 is->audio_diff_avg_count++;
1507             } else {
1508                 /* estimate the A-V difference */
1509                 avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
1510
1511                 if (fabs(avg_diff) >= is->audio_diff_threshold) {
1512                     wanted_size = samples_size + ((int)(diff * is->audio_st->codec->sample_rate) * n);
1513                     nb_samples = samples_size / n;
1514
1515                     min_size = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX)) / 100) * n;
1516                     max_size = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX)) / 100) * n;
1517                     if (wanted_size < min_size)
1518                         wanted_size = min_size;
1519                     else if (wanted_size > max_size)
1520                         wanted_size = max_size;
1521
1522                     /* add or remove samples to correction the synchro */
1523                     if (wanted_size < samples_size) {
1524                         /* remove samples */
1525                         samples_size = wanted_size;
1526                     } else if (wanted_size > samples_size) {
1527                         uint8_t *samples_end, *q;
1528                         int nb;
1529
1530                         /* add samples */
1531                         nb = (samples_size - wanted_size);
1532                         samples_end = (uint8_t *)samples + samples_size - n;
1533                         q = samples_end + n;
1534                         while (nb > 0) {
1535                             memcpy(q, samples_end, n);
1536                             q += n;
1537                             nb -= n;
1538                         }
1539                         samples_size = wanted_size;
1540                     }
1541                 }
1542 #if 0
1543                 printf("diff=%f adiff=%f sample_diff=%d apts=%0.3f vpts=%0.3f %f\n",
1544                        diff, avg_diff, samples_size - samples_size1,
1545                        is->audio_clock, is->video_clock, is->audio_diff_threshold);
1546 #endif
1547             }
1548         } else {
1549             /* too big difference : may be initial PTS errors, so
1550                reset A-V filter */
1551             is->audio_diff_avg_count = 0;
1552             is->audio_diff_cum = 0;
1553         }
1554     }
1555
1556     return samples_size;
1557 }
1558
1559 /* decode one audio frame and returns its uncompressed size */
1560 static int audio_decode_frame(VideoState *is, double *pts_ptr)
1561 {
1562     AVPacket *pkt = &is->audio_pkt;
1563     AVCodecContext *dec= is->audio_st->codec;
1564     int n, len1, data_size;
1565     double pts;
1566
1567     for(;;) {
1568         /* NOTE: the audio packet can contain several frames */
1569         while (is->audio_pkt_size > 0) {
1570             data_size = sizeof(is->audio_buf1);
1571             len1 = avcodec_decode_audio2(dec,
1572                                         (int16_t *)is->audio_buf1, &data_size,
1573                                         is->audio_pkt_data, is->audio_pkt_size);
1574             if (len1 < 0) {
1575                 /* if error, we skip the frame */
1576                 is->audio_pkt_size = 0;
1577                 break;
1578             }
1579
1580             is->audio_pkt_data += len1;
1581             is->audio_pkt_size -= len1;
1582             if (data_size <= 0)
1583                 continue;
1584
1585             if (dec->sample_fmt != is->audio_src_fmt) {
1586                 if (is->reformat_ctx)
1587                     av_audio_convert_free(is->reformat_ctx);
1588                 is->reformat_ctx= av_audio_convert_alloc(SAMPLE_FMT_S16, 1,
1589                                                          dec->sample_fmt, 1, NULL, 0);
1590                 if (!is->reformat_ctx) {
1591                     fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
1592                         avcodec_get_sample_fmt_name(dec->sample_fmt),
1593                         avcodec_get_sample_fmt_name(SAMPLE_FMT_S16));
1594                         break;
1595                 }
1596                 is->audio_src_fmt= dec->sample_fmt;
1597             }
1598
1599             if (is->reformat_ctx) {
1600                 const void *ibuf[6]= {is->audio_buf1};
1601                 void *obuf[6]= {is->audio_buf2};
1602                 int istride[6]= {av_get_bits_per_sample_format(dec->sample_fmt)/8};
1603                 int ostride[6]= {2};
1604                 int len= data_size/istride[0];
1605                 if (av_audio_convert(is->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
1606                     printf("av_audio_convert() failed\n");
1607                     break;
1608                 }
1609                 is->audio_buf= is->audio_buf2;
1610                 /* FIXME: existing code assume that data_size equals framesize*channels*2
1611                           remove this legacy cruft */
1612                 data_size= len*2;
1613             }else{
1614                 is->audio_buf= is->audio_buf1;
1615             }
1616
1617             /* if no pts, then compute it */
1618             pts = is->audio_clock;
1619             *pts_ptr = pts;
1620             n = 2 * dec->channels;
1621             is->audio_clock += (double)data_size /
1622                 (double)(n * dec->sample_rate);
1623 #if defined(DEBUG_SYNC)
1624             {
1625                 static double last_clock;
1626                 printf("audio: delay=%0.3f clock=%0.3f pts=%0.3f\n",
1627                        is->audio_clock - last_clock,
1628                        is->audio_clock, pts);
1629                 last_clock = is->audio_clock;
1630             }
1631 #endif
1632             return data_size;
1633         }
1634
1635         /* free the current packet */
1636         if (pkt->data)
1637             av_free_packet(pkt);
1638
1639         if (is->paused || is->audioq.abort_request) {
1640             return -1;
1641         }
1642
1643         /* read next packet */
1644         if (packet_queue_get(&is->audioq, pkt, 1) < 0)
1645             return -1;
1646         if(pkt->data == flush_pkt.data){
1647             avcodec_flush_buffers(dec);
1648             continue;
1649         }
1650
1651         is->audio_pkt_data = pkt->data;
1652         is->audio_pkt_size = pkt->size;
1653
1654         /* if update the audio clock with the pts */
1655         if (pkt->pts != AV_NOPTS_VALUE) {
1656             is->audio_clock = av_q2d(is->audio_st->time_base)*pkt->pts;
1657         }
1658     }
1659 }
1660
1661 /* get the current audio output buffer size, in samples. With SDL, we
1662    cannot have a precise information */
1663 static int audio_write_get_buf_size(VideoState *is)
1664 {
1665     return is->audio_buf_size - is->audio_buf_index;
1666 }
1667
1668
1669 /* prepare a new audio buffer */
1670 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
1671 {
1672     VideoState *is = opaque;
1673     int audio_size, len1;
1674     double pts;
1675
1676     audio_callback_time = av_gettime();
1677
1678     while (len > 0) {
1679         if (is->audio_buf_index >= is->audio_buf_size) {
1680            audio_size = audio_decode_frame(is, &pts);
1681            if (audio_size < 0) {
1682                 /* if error, just output silence */
1683                is->audio_buf_size = 1024;
1684                memset(is->audio_buf, 0, is->audio_buf_size);
1685            } else {
1686                if (is->show_audio)
1687                    update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
1688                audio_size = synchronize_audio(is, (int16_t *)is->audio_buf, audio_size,
1689                                               pts);
1690                is->audio_buf_size = audio_size;
1691            }
1692            is->audio_buf_index = 0;
1693         }
1694         len1 = is->audio_buf_size - is->audio_buf_index;
1695         if (len1 > len)
1696             len1 = len;
1697         memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
1698         len -= len1;
1699         stream += len1;
1700         is->audio_buf_index += len1;
1701     }
1702 }
1703
1704 /* open a given stream. Return 0 if OK */
1705 static int stream_component_open(VideoState *is, int stream_index)
1706 {
1707     AVFormatContext *ic = is->ic;
1708     AVCodecContext *enc;
1709     AVCodec *codec;
1710     SDL_AudioSpec wanted_spec, spec;
1711
1712     if (stream_index < 0 || stream_index >= ic->nb_streams)
1713         return -1;
1714     enc = ic->streams[stream_index]->codec;
1715
1716     /* prepare audio output */
1717     if (enc->codec_type == CODEC_TYPE_AUDIO) {
1718         if (enc->channels > 0) {
1719             enc->request_channels = FFMIN(2, enc->channels);
1720         } else {
1721             enc->request_channels = 2;
1722         }
1723     }
1724
1725     codec = avcodec_find_decoder(enc->codec_id);
1726     enc->debug_mv = debug_mv;
1727     enc->debug = debug;
1728     enc->workaround_bugs = workaround_bugs;
1729     enc->lowres = lowres;
1730     if(lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
1731     enc->idct_algo= idct;
1732     if(fast) enc->flags2 |= CODEC_FLAG2_FAST;
1733     enc->skip_frame= skip_frame;
1734     enc->skip_idct= skip_idct;
1735     enc->skip_loop_filter= skip_loop_filter;
1736     enc->error_resilience= error_resilience;
1737     enc->error_concealment= error_concealment;
1738     if (!codec ||
1739         avcodec_open(enc, codec) < 0)
1740         return -1;
1741
1742     /* prepare audio output */
1743     if (enc->codec_type == CODEC_TYPE_AUDIO) {
1744         wanted_spec.freq = enc->sample_rate;
1745         wanted_spec.format = AUDIO_S16SYS;
1746         wanted_spec.channels = enc->channels;
1747         wanted_spec.silence = 0;
1748         wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
1749         wanted_spec.callback = sdl_audio_callback;
1750         wanted_spec.userdata = is;
1751         if (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
1752             fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
1753             return -1;
1754         }
1755         is->audio_hw_buf_size = spec.size;
1756         is->audio_src_fmt= SAMPLE_FMT_S16;
1757     }
1758
1759     if(thread_count>1)
1760         avcodec_thread_init(enc, thread_count);
1761     enc->thread_count= thread_count;
1762     ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
1763     switch(enc->codec_type) {
1764     case CODEC_TYPE_AUDIO:
1765         is->audio_stream = stream_index;
1766         is->audio_st = ic->streams[stream_index];
1767         is->audio_buf_size = 0;
1768         is->audio_buf_index = 0;
1769
1770         /* init averaging filter */
1771         is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
1772         is->audio_diff_avg_count = 0;
1773         /* since we do not have a precise anough audio fifo fullness,
1774            we correct audio sync only if larger than this threshold */
1775         is->audio_diff_threshold = 2.0 * SDL_AUDIO_BUFFER_SIZE / enc->sample_rate;
1776
1777         memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
1778         packet_queue_init(&is->audioq);
1779         SDL_PauseAudio(0);
1780         break;
1781     case CODEC_TYPE_VIDEO:
1782         is->video_stream = stream_index;
1783         is->video_st = ic->streams[stream_index];
1784
1785         is->frame_last_delay = 40e-3;
1786         is->frame_timer = (double)av_gettime() / 1000000.0;
1787         is->video_current_pts_time = av_gettime();
1788
1789         packet_queue_init(&is->videoq);
1790         is->video_tid = SDL_CreateThread(video_thread, is);
1791         break;
1792     case CODEC_TYPE_SUBTITLE:
1793         is->subtitle_stream = stream_index;
1794         is->subtitle_st = ic->streams[stream_index];
1795         packet_queue_init(&is->subtitleq);
1796
1797         is->subtitle_tid = SDL_CreateThread(subtitle_thread, is);
1798         break;
1799     default:
1800         break;
1801     }
1802     return 0;
1803 }
1804
1805 static void stream_component_close(VideoState *is, int stream_index)
1806 {
1807     AVFormatContext *ic = is->ic;
1808     AVCodecContext *enc;
1809
1810     if (stream_index < 0 || stream_index >= ic->nb_streams)
1811         return;
1812     enc = ic->streams[stream_index]->codec;
1813
1814     switch(enc->codec_type) {
1815     case CODEC_TYPE_AUDIO:
1816         packet_queue_abort(&is->audioq);
1817
1818         SDL_CloseAudio();
1819
1820         packet_queue_end(&is->audioq);
1821         if (is->reformat_ctx)
1822             av_audio_convert_free(is->reformat_ctx);
1823         break;
1824     case CODEC_TYPE_VIDEO:
1825         packet_queue_abort(&is->videoq);
1826
1827         /* note: we also signal this mutex to make sure we deblock the
1828            video thread in all cases */
1829         SDL_LockMutex(is->pictq_mutex);
1830         SDL_CondSignal(is->pictq_cond);
1831         SDL_UnlockMutex(is->pictq_mutex);
1832
1833         SDL_WaitThread(is->video_tid, NULL);
1834
1835         packet_queue_end(&is->videoq);
1836         break;
1837     case CODEC_TYPE_SUBTITLE:
1838         packet_queue_abort(&is->subtitleq);
1839
1840         /* note: we also signal this mutex to make sure we deblock the
1841            video thread in all cases */
1842         SDL_LockMutex(is->subpq_mutex);
1843         is->subtitle_stream_changed = 1;
1844
1845         SDL_CondSignal(is->subpq_cond);
1846         SDL_UnlockMutex(is->subpq_mutex);
1847
1848         SDL_WaitThread(is->subtitle_tid, NULL);
1849
1850         packet_queue_end(&is->subtitleq);
1851         break;
1852     default:
1853         break;
1854     }
1855
1856     ic->streams[stream_index]->discard = AVDISCARD_ALL;
1857     avcodec_close(enc);
1858     switch(enc->codec_type) {
1859     case CODEC_TYPE_AUDIO:
1860         is->audio_st = NULL;
1861         is->audio_stream = -1;
1862         break;
1863     case CODEC_TYPE_VIDEO:
1864         is->video_st = NULL;
1865         is->video_stream = -1;
1866         break;
1867     case CODEC_TYPE_SUBTITLE:
1868         is->subtitle_st = NULL;
1869         is->subtitle_stream = -1;
1870         break;
1871     default:
1872         break;
1873     }
1874 }
1875
1876 static void dump_stream_info(const AVFormatContext *s)
1877 {
1878     if (s->track != 0)
1879         fprintf(stderr, "Track: %d\n", s->track);
1880     if (s->title[0] != '\0')
1881         fprintf(stderr, "Title: %s\n", s->title);
1882     if (s->author[0] != '\0')
1883         fprintf(stderr, "Author: %s\n", s->author);
1884     if (s->copyright[0] != '\0')
1885         fprintf(stderr, "Copyright: %s\n", s->copyright);
1886     if (s->comment[0] != '\0')
1887         fprintf(stderr, "Comment: %s\n", s->comment);
1888     if (s->album[0] != '\0')
1889         fprintf(stderr, "Album: %s\n", s->album);
1890     if (s->year != 0)
1891         fprintf(stderr, "Year: %d\n", s->year);
1892     if (s->genre[0] != '\0')
1893         fprintf(stderr, "Genre: %s\n", s->genre);
1894 }
1895
1896 /* since we have only one decoding thread, we can use a global
1897    variable instead of a thread local variable */
1898 static VideoState *global_video_state;
1899
1900 static int decode_interrupt_cb(void)
1901 {
1902     return (global_video_state && global_video_state->abort_request);
1903 }
1904
1905 /* this thread gets the stream from the disk or the network */
1906 static int decode_thread(void *arg)
1907 {
1908     VideoState *is = arg;
1909     AVFormatContext *ic;
1910     int err, i, ret, video_index, audio_index;
1911     AVPacket pkt1, *pkt = &pkt1;
1912     AVFormatParameters params, *ap = &params;
1913
1914     video_index = -1;
1915     audio_index = -1;
1916     is->video_stream = -1;
1917     is->audio_stream = -1;
1918     is->subtitle_stream = -1;
1919
1920     global_video_state = is;
1921     url_set_interrupt_cb(decode_interrupt_cb);
1922
1923     memset(ap, 0, sizeof(*ap));
1924
1925     ap->width = frame_width;
1926     ap->height= frame_height;
1927     ap->time_base= (AVRational){1, 25};
1928     ap->pix_fmt = frame_pix_fmt;
1929
1930     err = av_open_input_file(&ic, is->filename, is->iformat, 0, ap);
1931     if (err < 0) {
1932         print_error(is->filename, err);
1933         ret = -1;
1934         goto fail;
1935     }
1936     is->ic = ic;
1937
1938     if(genpts)
1939         ic->flags |= AVFMT_FLAG_GENPTS;
1940
1941     err = av_find_stream_info(ic);
1942     if (err < 0) {
1943         fprintf(stderr, "%s: could not find codec parameters\n", is->filename);
1944         ret = -1;
1945         goto fail;
1946     }
1947     if(ic->pb)
1948         ic->pb->eof_reached= 0; //FIXME hack, ffplay maybe should not use url_feof() to test for the end
1949
1950     /* if seeking requested, we execute it */
1951     if (start_time != AV_NOPTS_VALUE) {
1952         int64_t timestamp;
1953
1954         timestamp = start_time;
1955         /* add the stream start time */
1956         if (ic->start_time != AV_NOPTS_VALUE)
1957             timestamp += ic->start_time;
1958         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
1959         if (ret < 0) {
1960             fprintf(stderr, "%s: could not seek to position %0.3f\n",
1961                     is->filename, (double)timestamp / AV_TIME_BASE);
1962         }
1963     }
1964
1965     for(i = 0; i < ic->nb_streams; i++) {
1966         AVCodecContext *enc = ic->streams[i]->codec;
1967         ic->streams[i]->discard = AVDISCARD_ALL;
1968         switch(enc->codec_type) {
1969         case CODEC_TYPE_AUDIO:
1970             if ((audio_index < 0 || wanted_audio_stream-- > 0) && !audio_disable)
1971                 audio_index = i;
1972             break;
1973         case CODEC_TYPE_VIDEO:
1974             if ((video_index < 0 || wanted_video_stream-- > 0) && !video_disable)
1975                 video_index = i;
1976             break;
1977         default:
1978             break;
1979         }
1980     }
1981     if (show_status) {
1982         dump_format(ic, 0, is->filename, 0);
1983         dump_stream_info(ic);
1984     }
1985
1986     /* open the streams */
1987     if (audio_index >= 0) {
1988         stream_component_open(is, audio_index);
1989     }
1990
1991     if (video_index >= 0) {
1992         stream_component_open(is, video_index);
1993     } else {
1994         if (!display_disable)
1995             is->show_audio = 1;
1996     }
1997
1998     if (is->video_stream < 0 && is->audio_stream < 0) {
1999         fprintf(stderr, "%s: could not open codecs\n", is->filename);
2000         ret = -1;
2001         goto fail;
2002     }
2003
2004     for(;;) {
2005         if (is->abort_request)
2006             break;
2007         if (is->paused != is->last_paused) {
2008             is->last_paused = is->paused;
2009             if (is->paused)
2010                 av_read_pause(ic);
2011             else
2012                 av_read_play(ic);
2013         }
2014 #if defined(CONFIG_RTSP_DEMUXER) || defined(CONFIG_MMSH_PROTOCOL)
2015         if (is->paused &&
2016                 (!strcmp(ic->iformat->name, "rtsp") ||
2017                  (ic->pb && !strcmp(url_fileno(ic->pb)->prot->name, "mmsh")))) {
2018             /* wait 10 ms to avoid trying to get another packet */
2019             /* XXX: horrible */
2020             SDL_Delay(10);
2021             continue;
2022         }
2023 #endif
2024         if (is->seek_req) {
2025             int stream_index= -1;
2026             int64_t seek_target= is->seek_pos;
2027
2028             if     (is->   video_stream >= 0) stream_index= is->   video_stream;
2029             else if(is->   audio_stream >= 0) stream_index= is->   audio_stream;
2030             else if(is->subtitle_stream >= 0) stream_index= is->subtitle_stream;
2031
2032             if(stream_index>=0){
2033                 seek_target= av_rescale_q(seek_target, AV_TIME_BASE_Q, ic->streams[stream_index]->time_base);
2034             }
2035
2036             ret = av_seek_frame(is->ic, stream_index, seek_target, is->seek_flags);
2037             if (ret < 0) {
2038                 fprintf(stderr, "%s: error while seeking\n", is->ic->filename);
2039             }else{
2040                 if (is->audio_stream >= 0) {
2041                     packet_queue_flush(&is->audioq);
2042                     packet_queue_put(&is->audioq, &flush_pkt);
2043                 }
2044                 if (is->subtitle_stream >= 0) {
2045                     packet_queue_flush(&is->subtitleq);
2046                     packet_queue_put(&is->subtitleq, &flush_pkt);
2047                 }
2048                 if (is->video_stream >= 0) {
2049                     packet_queue_flush(&is->videoq);
2050                     packet_queue_put(&is->videoq, &flush_pkt);
2051                 }
2052             }
2053             is->seek_req = 0;
2054         }
2055
2056         /* if the queue are full, no need to read more */
2057         if (is->audioq.size > MAX_AUDIOQ_SIZE ||
2058             is->videoq.size > MAX_VIDEOQ_SIZE ||
2059             is->subtitleq.size > MAX_SUBTITLEQ_SIZE ||
2060             url_feof(ic->pb)) {
2061             /* wait 10 ms */
2062             SDL_Delay(10);
2063             continue;
2064         }
2065         ret = av_read_frame(ic, pkt);
2066         if (ret < 0) {
2067             if (url_ferror(ic->pb) == 0) {
2068                 SDL_Delay(100); /* wait for user event */
2069                 continue;
2070             } else
2071                 break;
2072         }
2073         if (pkt->stream_index == is->audio_stream) {
2074             packet_queue_put(&is->audioq, pkt);
2075         } else if (pkt->stream_index == is->video_stream) {
2076             packet_queue_put(&is->videoq, pkt);
2077         } else if (pkt->stream_index == is->subtitle_stream) {
2078             packet_queue_put(&is->subtitleq, pkt);
2079         } else {
2080             av_free_packet(pkt);
2081         }
2082     }
2083     /* wait until the end */
2084     while (!is->abort_request) {
2085         SDL_Delay(100);
2086     }
2087
2088     ret = 0;
2089  fail:
2090     /* disable interrupting */
2091     global_video_state = NULL;
2092
2093     /* close each stream */
2094     if (is->audio_stream >= 0)
2095         stream_component_close(is, is->audio_stream);
2096     if (is->video_stream >= 0)
2097         stream_component_close(is, is->video_stream);
2098     if (is->subtitle_stream >= 0)
2099         stream_component_close(is, is->subtitle_stream);
2100     if (is->ic) {
2101         av_close_input_file(is->ic);
2102         is->ic = NULL; /* safety */
2103     }
2104     url_set_interrupt_cb(NULL);
2105
2106     if (ret != 0) {
2107         SDL_Event event;
2108
2109         event.type = FF_QUIT_EVENT;
2110         event.user.data1 = is;
2111         SDL_PushEvent(&event);
2112     }
2113     return 0;
2114 }
2115
2116 static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
2117 {
2118     VideoState *is;
2119
2120     is = av_mallocz(sizeof(VideoState));
2121     if (!is)
2122         return NULL;
2123     av_strlcpy(is->filename, filename, sizeof(is->filename));
2124     is->iformat = iformat;
2125     is->ytop = 0;
2126     is->xleft = 0;
2127
2128     /* start video display */
2129     is->pictq_mutex = SDL_CreateMutex();
2130     is->pictq_cond = SDL_CreateCond();
2131
2132     is->subpq_mutex = SDL_CreateMutex();
2133     is->subpq_cond = SDL_CreateCond();
2134
2135     /* add the refresh timer to draw the picture */
2136     schedule_refresh(is, 40);
2137
2138     is->av_sync_type = av_sync_type;
2139     is->parse_tid = SDL_CreateThread(decode_thread, is);
2140     if (!is->parse_tid) {
2141         av_free(is);
2142         return NULL;
2143     }
2144     return is;
2145 }
2146
2147 static void stream_close(VideoState *is)
2148 {
2149     VideoPicture *vp;
2150     int i;
2151     /* XXX: use a special url_shutdown call to abort parse cleanly */
2152     is->abort_request = 1;
2153     SDL_WaitThread(is->parse_tid, NULL);
2154
2155     /* free all pictures */
2156     for(i=0;i<VIDEO_PICTURE_QUEUE_SIZE; i++) {
2157         vp = &is->pictq[i];
2158         if (vp->bmp) {
2159             SDL_FreeYUVOverlay(vp->bmp);
2160             vp->bmp = NULL;
2161         }
2162     }
2163     SDL_DestroyMutex(is->pictq_mutex);
2164     SDL_DestroyCond(is->pictq_cond);
2165     SDL_DestroyMutex(is->subpq_mutex);
2166     SDL_DestroyCond(is->subpq_cond);
2167 }
2168
2169 static void stream_cycle_channel(VideoState *is, int codec_type)
2170 {
2171     AVFormatContext *ic = is->ic;
2172     int start_index, stream_index;
2173     AVStream *st;
2174
2175     if (codec_type == CODEC_TYPE_VIDEO)
2176         start_index = is->video_stream;
2177     else if (codec_type == CODEC_TYPE_AUDIO)
2178         start_index = is->audio_stream;
2179     else
2180         start_index = is->subtitle_stream;
2181     if (start_index < (codec_type == CODEC_TYPE_SUBTITLE ? -1 : 0))
2182         return;
2183     stream_index = start_index;
2184     for(;;) {
2185         if (++stream_index >= is->ic->nb_streams)
2186         {
2187             if (codec_type == CODEC_TYPE_SUBTITLE)
2188             {
2189                 stream_index = -1;
2190                 goto the_end;
2191             } else
2192                 stream_index = 0;
2193         }
2194         if (stream_index == start_index)
2195             return;
2196         st = ic->streams[stream_index];
2197         if (st->codec->codec_type == codec_type) {
2198             /* check that parameters are OK */
2199             switch(codec_type) {
2200             case CODEC_TYPE_AUDIO:
2201                 if (st->codec->sample_rate != 0 &&
2202                     st->codec->channels != 0)
2203                     goto the_end;
2204                 break;
2205             case CODEC_TYPE_VIDEO:
2206             case CODEC_TYPE_SUBTITLE:
2207                 goto the_end;
2208             default:
2209                 break;
2210             }
2211         }
2212     }
2213  the_end:
2214     stream_component_close(is, start_index);
2215     stream_component_open(is, stream_index);
2216 }
2217
2218
2219 static void toggle_full_screen(void)
2220 {
2221     is_full_screen = !is_full_screen;
2222     if (!fs_screen_width) {
2223         /* use default SDL method */
2224 //        SDL_WM_ToggleFullScreen(screen);
2225     }
2226     video_open(cur_stream);
2227 }
2228
2229 static void toggle_pause(void)
2230 {
2231     if (cur_stream)
2232         stream_pause(cur_stream);
2233     step = 0;
2234 }
2235
2236 static void step_to_next_frame(void)
2237 {
2238     if (cur_stream) {
2239         /* if the stream is paused unpause it, then step */
2240         if (cur_stream->paused)
2241             stream_pause(cur_stream);
2242     }
2243     step = 1;
2244 }
2245
2246 static void do_exit(void)
2247 {
2248     if (cur_stream) {
2249         stream_close(cur_stream);
2250         cur_stream = NULL;
2251     }
2252     if (show_status)
2253         printf("\n");
2254     SDL_Quit();
2255     exit(0);
2256 }
2257
2258 static void toggle_audio_display(void)
2259 {
2260     if (cur_stream) {
2261         cur_stream->show_audio = !cur_stream->show_audio;
2262     }
2263 }
2264
2265 /* handle an event sent by the GUI */
2266 static void event_loop(void)
2267 {
2268     SDL_Event event;
2269     double incr, pos, frac;
2270
2271     for(;;) {
2272         SDL_WaitEvent(&event);
2273         switch(event.type) {
2274         case SDL_KEYDOWN:
2275             switch(event.key.keysym.sym) {
2276             case SDLK_ESCAPE:
2277             case SDLK_q:
2278                 do_exit();
2279                 break;
2280             case SDLK_f:
2281                 toggle_full_screen();
2282                 break;
2283             case SDLK_p:
2284             case SDLK_SPACE:
2285                 toggle_pause();
2286                 break;
2287             case SDLK_s: //S: Step to next frame
2288                 step_to_next_frame();
2289                 break;
2290             case SDLK_a:
2291                 if (cur_stream)
2292                     stream_cycle_channel(cur_stream, CODEC_TYPE_AUDIO);
2293                 break;
2294             case SDLK_v:
2295                 if (cur_stream)
2296                     stream_cycle_channel(cur_stream, CODEC_TYPE_VIDEO);
2297                 break;
2298             case SDLK_t:
2299                 if (cur_stream)
2300                     stream_cycle_channel(cur_stream, CODEC_TYPE_SUBTITLE);
2301                 break;
2302             case SDLK_w:
2303                 toggle_audio_display();
2304                 break;
2305             case SDLK_LEFT:
2306                 incr = -10.0;
2307                 goto do_seek;
2308             case SDLK_RIGHT:
2309                 incr = 10.0;
2310                 goto do_seek;
2311             case SDLK_UP:
2312                 incr = 60.0;
2313                 goto do_seek;
2314             case SDLK_DOWN:
2315                 incr = -60.0;
2316             do_seek:
2317                 if (cur_stream) {
2318                     if (seek_by_bytes) {
2319                         pos = url_ftell(cur_stream->ic->pb);
2320                         if (cur_stream->ic->bit_rate)
2321                             incr *= cur_stream->ic->bit_rate / 60.0;
2322                         else
2323                             incr *= 180000.0;
2324                         pos += incr;
2325                         stream_seek(cur_stream, pos, incr);
2326                     } else {
2327                         pos = get_master_clock(cur_stream);
2328                         pos += incr;
2329                         stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), incr);
2330                     }
2331                 }
2332                 break;
2333             default:
2334                 break;
2335             }
2336             break;
2337         case SDL_MOUSEBUTTONDOWN:
2338             if (cur_stream) {
2339                 int ns, hh, mm, ss;
2340                 int tns, thh, tmm, tss;
2341                 tns = cur_stream->ic->duration/1000000LL;
2342                 thh = tns/3600;
2343                 tmm = (tns%3600)/60;
2344                 tss = (tns%60);
2345                 frac = (double)event.button.x/(double)cur_stream->width;
2346                 ns = frac*tns;
2347                 hh = ns/3600;
2348                 mm = (ns%3600)/60;
2349                 ss = (ns%60);
2350                 fprintf(stderr, "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d)       \n", frac*100,
2351                         hh, mm, ss, thh, tmm, tss);
2352                 stream_seek(cur_stream, (int64_t)(cur_stream->ic->start_time+frac*cur_stream->ic->duration), 0);
2353             }
2354             break;
2355         case SDL_VIDEORESIZE:
2356             if (cur_stream) {
2357                 screen = SDL_SetVideoMode(event.resize.w, event.resize.h, 0,
2358                                           SDL_HWSURFACE|SDL_RESIZABLE|SDL_ASYNCBLIT|SDL_HWACCEL);
2359                 screen_width = cur_stream->width = event.resize.w;
2360                 screen_height= cur_stream->height= event.resize.h;
2361             }
2362             break;
2363         case SDL_QUIT:
2364         case FF_QUIT_EVENT:
2365             do_exit();
2366             break;
2367         case FF_ALLOC_EVENT:
2368             video_open(event.user.data1);
2369             alloc_picture(event.user.data1);
2370             break;
2371         case FF_REFRESH_EVENT:
2372             video_refresh_timer(event.user.data1);
2373             break;
2374         default:
2375             break;
2376         }
2377     }
2378 }
2379
2380 static void opt_frame_size(const char *arg)
2381 {
2382     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2383         fprintf(stderr, "Incorrect frame size\n");
2384         exit(1);
2385     }
2386     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2387         fprintf(stderr, "Frame size must be a multiple of 2\n");
2388         exit(1);
2389     }
2390 }
2391
2392 static int opt_width(const char *opt, const char *arg)
2393 {
2394     screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
2395     return 0;
2396 }
2397
2398 static int opt_height(const char *opt, const char *arg)
2399 {
2400     screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
2401     return 0;
2402 }
2403
2404 static void opt_format(const char *arg)
2405 {
2406     file_iformat = av_find_input_format(arg);
2407     if (!file_iformat) {
2408         fprintf(stderr, "Unknown input format: %s\n", arg);
2409         exit(1);
2410     }
2411 }
2412
2413 static void opt_frame_pix_fmt(const char *arg)
2414 {
2415     frame_pix_fmt = avcodec_get_pix_fmt(arg);
2416 }
2417
2418 static int opt_sync(const char *opt, const char *arg)
2419 {
2420     if (!strcmp(arg, "audio"))
2421         av_sync_type = AV_SYNC_AUDIO_MASTER;
2422     else if (!strcmp(arg, "video"))
2423         av_sync_type = AV_SYNC_VIDEO_MASTER;
2424     else if (!strcmp(arg, "ext"))
2425         av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
2426     else {
2427         fprintf(stderr, "Unknown value for %s: %s\n", opt, arg);
2428         exit(1);
2429     }
2430     return 0;
2431 }
2432
2433 static int opt_seek(const char *opt, const char *arg)
2434 {
2435     start_time = parse_time_or_die(opt, arg, 1);
2436     return 0;
2437 }
2438
2439 static int opt_debug(const char *opt, const char *arg)
2440 {
2441     av_log_set_level(99);
2442     debug = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2443     return 0;
2444 }
2445
2446 static int opt_vismv(const char *opt, const char *arg)
2447 {
2448     debug_mv = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2449     return 0;
2450 }
2451
2452 static int opt_thread_count(const char *opt, const char *arg)
2453 {
2454     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2455 #if !defined(HAVE_THREADS)
2456     fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2457 #endif
2458     return 0;
2459 }
2460
2461 static const OptionDef options[] = {
2462     { "h", OPT_EXIT, {(void*)show_help}, "show help" },
2463     { "version", OPT_EXIT, {(void*)show_version}, "show version" },
2464     { "L", OPT_EXIT, {(void*)show_license}, "show license" },
2465     { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
2466     { "x", HAS_ARG | OPT_FUNC2, {(void*)opt_width}, "force displayed width", "width" },
2467     { "y", HAS_ARG | OPT_FUNC2, {(void*)opt_height}, "force displayed height", "height" },
2468     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
2469     { "fs", OPT_BOOL, {(void*)&is_full_screen}, "force full screen" },
2470     { "an", OPT_BOOL, {(void*)&audio_disable}, "disable audio" },
2471     { "vn", OPT_BOOL, {(void*)&video_disable}, "disable video" },
2472     { "ast", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_audio_stream}, "", "" },
2473     { "vst", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_video_stream}, "", "" },
2474     { "ss", HAS_ARG | OPT_FUNC2, {(void*)&opt_seek}, "seek to a given position in seconds", "pos" },
2475     { "bytes", OPT_BOOL, {(void*)&seek_by_bytes}, "seek by bytes" },
2476     { "nodisp", OPT_BOOL, {(void*)&display_disable}, "disable graphical display" },
2477     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
2478     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
2479     { "stats", OPT_BOOL | OPT_EXPERT, {(void*)&show_status}, "show status", "" },
2480     { "debug", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
2481     { "bug", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&workaround_bugs}, "workaround bugs", "" },
2482     { "vismv", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
2483     { "fast", OPT_BOOL | OPT_EXPERT, {(void*)&fast}, "non spec compliant optimizations", "" },
2484     { "genpts", OPT_BOOL | OPT_EXPERT, {(void*)&genpts}, "generate pts", "" },
2485     { "drp", OPT_BOOL |OPT_EXPERT, {(void*)&decoder_reorder_pts}, "let decoder reorder pts", ""},
2486     { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&lowres}, "", "" },
2487     { "skiploop", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&skip_loop_filter}, "", "" },
2488     { "skipframe", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&skip_frame}, "", "" },
2489     { "skipidct", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&skip_idct}, "", "" },
2490     { "idct", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&idct}, "set idct algo",  "algo" },
2491     { "er", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&error_resilience}, "set error detection threshold (0-4)",  "threshold" },
2492     { "ec", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&error_concealment}, "set error concealment options",  "bit_mask" },
2493     { "sync", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_sync}, "set audio-video sync. type (type=audio/video/ext)", "type" },
2494     { "threads", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
2495     { NULL, },
2496 };
2497
2498 static void show_help(void)
2499 {
2500     printf("usage: ffplay [options] input_file\n"
2501            "Simple media player\n");
2502     printf("\n");
2503     show_help_options(options, "Main options:\n",
2504                       OPT_EXPERT, 0);
2505     show_help_options(options, "\nAdvanced options:\n",
2506                       OPT_EXPERT, OPT_EXPERT);
2507     printf("\nWhile playing:\n"
2508            "q, ESC              quit\n"
2509            "f                   toggle full screen\n"
2510            "p, SPC              pause\n"
2511            "a                   cycle audio channel\n"
2512            "v                   cycle video channel\n"
2513            "t                   cycle subtitle channel\n"
2514            "w                   show audio waves\n"
2515            "left/right          seek backward/forward 10 seconds\n"
2516            "down/up             seek backward/forward 1 minute\n"
2517            "mouse click         seek to percentage in file corresponding to fraction of width\n"
2518            );
2519 }
2520
2521 static void opt_input_file(const char *filename)
2522 {
2523     if (!strcmp(filename, "-"))
2524         filename = "pipe:";
2525     input_filename = filename;
2526 }
2527
2528 /* Called from the main */
2529 int main(int argc, char **argv)
2530 {
2531     int flags;
2532
2533     /* register all codecs, demux and protocols */
2534     avcodec_register_all();
2535     avdevice_register_all();
2536     av_register_all();
2537
2538     show_banner();
2539
2540     parse_options(argc, argv, options, opt_input_file);
2541
2542     if (!input_filename) {
2543         show_help();
2544         exit(1);
2545     }
2546
2547     if (display_disable) {
2548         video_disable = 1;
2549     }
2550     flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
2551 #if !defined(__MINGW32__) && !defined(__APPLE__)
2552     flags |= SDL_INIT_EVENTTHREAD; /* Not supported on Windows or Mac OS X */
2553 #endif
2554     if (SDL_Init (flags)) {
2555         fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
2556         exit(1);
2557     }
2558
2559     if (!display_disable) {
2560 #ifdef HAVE_SDL_VIDEO_SIZE
2561         const SDL_VideoInfo *vi = SDL_GetVideoInfo();
2562         fs_screen_width = vi->current_w;
2563         fs_screen_height = vi->current_h;
2564 #endif
2565     }
2566
2567     SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
2568     SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE);
2569     SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
2570     SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
2571
2572     av_init_packet(&flush_pkt);
2573     flush_pkt.data= "FLUSH";
2574
2575     cur_stream = stream_open(input_filename, file_iformat);
2576
2577     event_loop();
2578
2579     /* never returns */
2580
2581     return 0;
2582 }