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