e1e853595683b1a465dd42303902bc4962609221
[ffmpeg.git] / ffplay.c
1 /*
2  * Copyright (c) 2003 Fabrice Bellard
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 /**
22  * @file
23  * simple media player based on the FFmpeg libraries
24  */
25
26 #include "config.h"
27 #include <inttypes.h>
28 #include <math.h>
29 #include <limits.h>
30 #include <signal.h>
31 #include <stdint.h>
32
33 #include "libavutil/avstring.h"
34 #include "libavutil/eval.h"
35 #include "libavutil/mathematics.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/imgutils.h"
38 #include "libavutil/dict.h"
39 #include "libavutil/parseutils.h"
40 #include "libavutil/samplefmt.h"
41 #include "libavutil/avassert.h"
42 #include "libavutil/time.h"
43 #include "libavformat/avformat.h"
44 #include "libavdevice/avdevice.h"
45 #include "libswscale/swscale.h"
46 #include "libavutil/opt.h"
47 #include "libavcodec/avfft.h"
48 #include "libswresample/swresample.h"
49
50 #if CONFIG_AVFILTER
51 # include "libavfilter/avfilter.h"
52 # include "libavfilter/buffersink.h"
53 # include "libavfilter/buffersrc.h"
54 #endif
55
56 #include <SDL.h>
57 #include <SDL_thread.h>
58
59 #include "cmdutils.h"
60
61 #include <assert.h>
62
63 const char program_name[] = "ffplay";
64 const int program_birth_year = 2003;
65
66 #define MAX_QUEUE_SIZE (15 * 1024 * 1024)
67 #define MIN_FRAMES 25
68 #define EXTERNAL_CLOCK_MIN_FRAMES 2
69 #define EXTERNAL_CLOCK_MAX_FRAMES 10
70
71 /* Minimum SDL audio buffer size, in samples. */
72 #define SDL_AUDIO_MIN_BUFFER_SIZE 512
73 /* Calculate actual buffer size keeping in mind not cause too frequent audio callbacks */
74 #define SDL_AUDIO_MAX_CALLBACKS_PER_SEC 30
75
76 /* Step size for volume control */
77 #define SDL_VOLUME_STEP (SDL_MIX_MAXVOLUME / 50)
78
79 /* no AV sync correction is done if below the minimum AV sync threshold */
80 #define AV_SYNC_THRESHOLD_MIN 0.04
81 /* AV sync correction is done if above the maximum AV sync threshold */
82 #define AV_SYNC_THRESHOLD_MAX 0.1
83 /* If a frame duration is longer than this, it will not be duplicated to compensate AV sync */
84 #define AV_SYNC_FRAMEDUP_THRESHOLD 0.1
85 /* no AV correction is done if too big error */
86 #define AV_NOSYNC_THRESHOLD 10.0
87
88 /* maximum audio speed change to get correct sync */
89 #define SAMPLE_CORRECTION_PERCENT_MAX 10
90
91 /* external clock speed adjustment constants for realtime sources based on buffer fullness */
92 #define EXTERNAL_CLOCK_SPEED_MIN  0.900
93 #define EXTERNAL_CLOCK_SPEED_MAX  1.010
94 #define EXTERNAL_CLOCK_SPEED_STEP 0.001
95
96 /* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
97 #define AUDIO_DIFF_AVG_NB   20
98
99 /* polls for possible required screen refresh at least this often, should be less than 1/fps */
100 #define REFRESH_RATE 0.01
101
102 /* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
103 /* TODO: We assume that a decoded and resampled frame fits into this buffer */
104 #define SAMPLE_ARRAY_SIZE (8 * 65536)
105
106 #define CURSOR_HIDE_DELAY 1000000
107
108 static unsigned sws_flags = SWS_BICUBIC;
109
110 typedef struct MyAVPacketList {
111     AVPacket pkt;
112     struct MyAVPacketList *next;
113     int serial;
114 } MyAVPacketList;
115
116 typedef struct PacketQueue {
117     MyAVPacketList *first_pkt, *last_pkt;
118     int nb_packets;
119     int size;
120     int abort_request;
121     int serial;
122     SDL_mutex *mutex;
123     SDL_cond *cond;
124 } PacketQueue;
125
126 #define VIDEO_PICTURE_QUEUE_SIZE 3
127 #define SUBPICTURE_QUEUE_SIZE 16
128 #define SAMPLE_QUEUE_SIZE 9
129 #define FRAME_QUEUE_SIZE FFMAX(SAMPLE_QUEUE_SIZE, FFMAX(VIDEO_PICTURE_QUEUE_SIZE, SUBPICTURE_QUEUE_SIZE))
130
131 typedef struct AudioParams {
132     int freq;
133     int channels;
134     int64_t channel_layout;
135     enum AVSampleFormat fmt;
136     int frame_size;
137     int bytes_per_sec;
138 } AudioParams;
139
140 typedef struct Clock {
141     double pts;           /* clock base */
142     double pts_drift;     /* clock base minus time at which we updated the clock */
143     double last_updated;
144     double speed;
145     int serial;           /* clock is based on a packet with this serial */
146     int paused;
147     int *queue_serial;    /* pointer to the current packet queue serial, used for obsolete clock detection */
148 } Clock;
149
150 /* Common struct for handling all types of decoded data and allocated render buffers. */
151 typedef struct Frame {
152     AVFrame *frame;
153     AVSubtitle sub;
154     AVSubtitleRect **subrects;  /* rescaled subtitle rectangles in yuva */
155     int serial;
156     double pts;           /* presentation timestamp for the frame */
157     double duration;      /* estimated duration of the frame */
158     int64_t pos;          /* byte position of the frame in the input file */
159     SDL_Overlay *bmp;
160     int allocated;
161     int reallocate;
162     int width;
163     int height;
164     AVRational sar;
165 } Frame;
166
167 typedef struct FrameQueue {
168     Frame queue[FRAME_QUEUE_SIZE];
169     int rindex;
170     int windex;
171     int size;
172     int max_size;
173     int keep_last;
174     int rindex_shown;
175     SDL_mutex *mutex;
176     SDL_cond *cond;
177     PacketQueue *pktq;
178 } FrameQueue;
179
180 enum {
181     AV_SYNC_AUDIO_MASTER, /* default choice */
182     AV_SYNC_VIDEO_MASTER,
183     AV_SYNC_EXTERNAL_CLOCK, /* synchronize to an external clock */
184 };
185
186 typedef struct Decoder {
187     AVPacket pkt;
188     AVPacket pkt_temp;
189     PacketQueue *queue;
190     AVCodecContext *avctx;
191     int pkt_serial;
192     int finished;
193     int packet_pending;
194     SDL_cond *empty_queue_cond;
195     int64_t start_pts;
196     AVRational start_pts_tb;
197     int64_t next_pts;
198     AVRational next_pts_tb;
199     SDL_Thread *decoder_tid;
200 } Decoder;
201
202 typedef struct VideoState {
203     SDL_Thread *read_tid;
204     AVInputFormat *iformat;
205     int abort_request;
206     int force_refresh;
207     int paused;
208     int last_paused;
209     int queue_attachments_req;
210     int seek_req;
211     int seek_flags;
212     int64_t seek_pos;
213     int64_t seek_rel;
214     int read_pause_return;
215     AVFormatContext *ic;
216     int realtime;
217
218     Clock audclk;
219     Clock vidclk;
220     Clock extclk;
221
222     FrameQueue pictq;
223     FrameQueue subpq;
224     FrameQueue sampq;
225
226     Decoder auddec;
227     Decoder viddec;
228     Decoder subdec;
229
230     int viddec_width;
231     int viddec_height;
232
233     int audio_stream;
234
235     int av_sync_type;
236
237     double audio_clock;
238     int audio_clock_serial;
239     double audio_diff_cum; /* used for AV difference average computation */
240     double audio_diff_avg_coef;
241     double audio_diff_threshold;
242     int audio_diff_avg_count;
243     AVStream *audio_st;
244     PacketQueue audioq;
245     int audio_hw_buf_size;
246     uint8_t silence_buf[SDL_AUDIO_MIN_BUFFER_SIZE];
247     uint8_t *audio_buf;
248     uint8_t *audio_buf1;
249     unsigned int audio_buf_size; /* in bytes */
250     unsigned int audio_buf1_size;
251     int audio_buf_index; /* in bytes */
252     int audio_write_buf_size;
253     int audio_volume;
254     int muted;
255     struct AudioParams audio_src;
256 #if CONFIG_AVFILTER
257     struct AudioParams audio_filter_src;
258 #endif
259     struct AudioParams audio_tgt;
260     struct SwrContext *swr_ctx;
261     int frame_drops_early;
262     int frame_drops_late;
263
264     enum ShowMode {
265         SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO = 0, SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB
266     } show_mode;
267     int16_t sample_array[SAMPLE_ARRAY_SIZE];
268     int sample_array_index;
269     int last_i_start;
270     RDFTContext *rdft;
271     int rdft_bits;
272     FFTSample *rdft_data;
273     int xpos;
274     double last_vis_time;
275
276     int subtitle_stream;
277     AVStream *subtitle_st;
278     PacketQueue subtitleq;
279
280     double frame_timer;
281     double frame_last_returned_time;
282     double frame_last_filter_delay;
283     int video_stream;
284     AVStream *video_st;
285     PacketQueue videoq;
286     double max_frame_duration;      // maximum duration of a frame - above this, we consider the jump a timestamp discontinuity
287 #if !CONFIG_AVFILTER
288     struct SwsContext *img_convert_ctx;
289 #endif
290     struct SwsContext *sub_convert_ctx;
291     SDL_Rect last_display_rect;
292     int eof;
293
294     char *filename;
295     int width, height, xleft, ytop;
296     int step;
297
298 #if CONFIG_AVFILTER
299     int vfilter_idx;
300     AVFilterContext *in_video_filter;   // the first filter in the video chain
301     AVFilterContext *out_video_filter;  // the last filter in the video chain
302     AVFilterContext *in_audio_filter;   // the first filter in the audio chain
303     AVFilterContext *out_audio_filter;  // the last filter in the audio chain
304     AVFilterGraph *agraph;              // audio filter graph
305 #endif
306
307     int last_video_stream, last_audio_stream, last_subtitle_stream;
308
309     SDL_cond *continue_read_thread;
310 } VideoState;
311
312 /* options specified by the user */
313 static AVInputFormat *file_iformat;
314 static const char *input_filename;
315 static const char *window_title;
316 static int fs_screen_width;
317 static int fs_screen_height;
318 static int default_width  = 640;
319 static int default_height = 480;
320 static int screen_width  = 0;
321 static int screen_height = 0;
322 static int audio_disable;
323 static int video_disable;
324 static int subtitle_disable;
325 static const char* wanted_stream_spec[AVMEDIA_TYPE_NB] = {0};
326 static int seek_by_bytes = -1;
327 static int display_disable;
328 static int show_status = 1;
329 static int av_sync_type = AV_SYNC_AUDIO_MASTER;
330 static int64_t start_time = AV_NOPTS_VALUE;
331 static int64_t duration = AV_NOPTS_VALUE;
332 static int fast = 0;
333 static int genpts = 0;
334 static int lowres = 0;
335 static int decoder_reorder_pts = -1;
336 static int autoexit;
337 static int exit_on_keydown;
338 static int exit_on_mousedown;
339 static int loop = 1;
340 static int framedrop = -1;
341 static int infinite_buffer = -1;
342 static enum ShowMode show_mode = SHOW_MODE_NONE;
343 static const char *audio_codec_name;
344 static const char *subtitle_codec_name;
345 static const char *video_codec_name;
346 double rdftspeed = 0.02;
347 static int64_t cursor_last_shown;
348 static int cursor_hidden = 0;
349 #if CONFIG_AVFILTER
350 static const char **vfilters_list = NULL;
351 static int nb_vfilters = 0;
352 static char *afilters = NULL;
353 #endif
354 static int autorotate = 1;
355
356 /* current context */
357 static int is_full_screen;
358 static int64_t audio_callback_time;
359
360 static AVPacket flush_pkt;
361
362 #define FF_ALLOC_EVENT   (SDL_USEREVENT)
363 #define FF_QUIT_EVENT    (SDL_USEREVENT + 2)
364
365 static SDL_Surface *screen;
366
367 #if CONFIG_AVFILTER
368 static int opt_add_vfilter(void *optctx, const char *opt, const char *arg)
369 {
370     GROW_ARRAY(vfilters_list, nb_vfilters);
371     vfilters_list[nb_vfilters - 1] = arg;
372     return 0;
373 }
374 #endif
375
376 static inline
377 int cmp_audio_fmts(enum AVSampleFormat fmt1, int64_t channel_count1,
378                    enum AVSampleFormat fmt2, int64_t channel_count2)
379 {
380     /* If channel count == 1, planar and non-planar formats are the same */
381     if (channel_count1 == 1 && channel_count2 == 1)
382         return av_get_packed_sample_fmt(fmt1) != av_get_packed_sample_fmt(fmt2);
383     else
384         return channel_count1 != channel_count2 || fmt1 != fmt2;
385 }
386
387 static inline
388 int64_t get_valid_channel_layout(int64_t channel_layout, int channels)
389 {
390     if (channel_layout && av_get_channel_layout_nb_channels(channel_layout) == channels)
391         return channel_layout;
392     else
393         return 0;
394 }
395
396 static void free_picture(Frame *vp);
397
398 static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
399 {
400     MyAVPacketList *pkt1;
401
402     if (q->abort_request)
403        return -1;
404
405     pkt1 = av_malloc(sizeof(MyAVPacketList));
406     if (!pkt1)
407         return -1;
408     pkt1->pkt = *pkt;
409     pkt1->next = NULL;
410     if (pkt == &flush_pkt)
411         q->serial++;
412     pkt1->serial = q->serial;
413
414     if (!q->last_pkt)
415         q->first_pkt = pkt1;
416     else
417         q->last_pkt->next = pkt1;
418     q->last_pkt = pkt1;
419     q->nb_packets++;
420     q->size += pkt1->pkt.size + sizeof(*pkt1);
421     /* XXX: should duplicate packet data in DV case */
422     SDL_CondSignal(q->cond);
423     return 0;
424 }
425
426 static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
427 {
428     int ret;
429
430     SDL_LockMutex(q->mutex);
431     ret = packet_queue_put_private(q, pkt);
432     SDL_UnlockMutex(q->mutex);
433
434     if (pkt != &flush_pkt && ret < 0)
435         av_packet_unref(pkt);
436
437     return ret;
438 }
439
440 static int packet_queue_put_nullpacket(PacketQueue *q, int stream_index)
441 {
442     AVPacket pkt1, *pkt = &pkt1;
443     av_init_packet(pkt);
444     pkt->data = NULL;
445     pkt->size = 0;
446     pkt->stream_index = stream_index;
447     return packet_queue_put(q, pkt);
448 }
449
450 /* packet queue handling */
451 static int packet_queue_init(PacketQueue *q)
452 {
453     memset(q, 0, sizeof(PacketQueue));
454     q->mutex = SDL_CreateMutex();
455     if (!q->mutex) {
456         av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
457         return AVERROR(ENOMEM);
458     }
459     q->cond = SDL_CreateCond();
460     if (!q->cond) {
461         av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
462         return AVERROR(ENOMEM);
463     }
464     q->abort_request = 1;
465     return 0;
466 }
467
468 static void packet_queue_flush(PacketQueue *q)
469 {
470     MyAVPacketList *pkt, *pkt1;
471
472     SDL_LockMutex(q->mutex);
473     for (pkt = q->first_pkt; pkt; pkt = pkt1) {
474         pkt1 = pkt->next;
475         av_packet_unref(&pkt->pkt);
476         av_freep(&pkt);
477     }
478     q->last_pkt = NULL;
479     q->first_pkt = NULL;
480     q->nb_packets = 0;
481     q->size = 0;
482     SDL_UnlockMutex(q->mutex);
483 }
484
485 static void packet_queue_destroy(PacketQueue *q)
486 {
487     packet_queue_flush(q);
488     SDL_DestroyMutex(q->mutex);
489     SDL_DestroyCond(q->cond);
490 }
491
492 static void packet_queue_abort(PacketQueue *q)
493 {
494     SDL_LockMutex(q->mutex);
495
496     q->abort_request = 1;
497
498     SDL_CondSignal(q->cond);
499
500     SDL_UnlockMutex(q->mutex);
501 }
502
503 static void packet_queue_start(PacketQueue *q)
504 {
505     SDL_LockMutex(q->mutex);
506     q->abort_request = 0;
507     packet_queue_put_private(q, &flush_pkt);
508     SDL_UnlockMutex(q->mutex);
509 }
510
511 /* return < 0 if aborted, 0 if no packet and > 0 if packet.  */
512 static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)
513 {
514     MyAVPacketList *pkt1;
515     int ret;
516
517     SDL_LockMutex(q->mutex);
518
519     for (;;) {
520         if (q->abort_request) {
521             ret = -1;
522             break;
523         }
524
525         pkt1 = q->first_pkt;
526         if (pkt1) {
527             q->first_pkt = pkt1->next;
528             if (!q->first_pkt)
529                 q->last_pkt = NULL;
530             q->nb_packets--;
531             q->size -= pkt1->pkt.size + sizeof(*pkt1);
532             *pkt = pkt1->pkt;
533             if (serial)
534                 *serial = pkt1->serial;
535             av_free(pkt1);
536             ret = 1;
537             break;
538         } else if (!block) {
539             ret = 0;
540             break;
541         } else {
542             SDL_CondWait(q->cond, q->mutex);
543         }
544     }
545     SDL_UnlockMutex(q->mutex);
546     return ret;
547 }
548
549 static void decoder_init(Decoder *d, AVCodecContext *avctx, PacketQueue *queue, SDL_cond *empty_queue_cond) {
550     memset(d, 0, sizeof(Decoder));
551     d->avctx = avctx;
552     d->queue = queue;
553     d->empty_queue_cond = empty_queue_cond;
554     d->start_pts = AV_NOPTS_VALUE;
555 }
556
557 static int decoder_decode_frame(Decoder *d, AVFrame *frame, AVSubtitle *sub) {
558     int got_frame = 0;
559
560     do {
561         int ret = -1;
562
563         if (d->queue->abort_request)
564             return -1;
565
566         if (!d->packet_pending || d->queue->serial != d->pkt_serial) {
567             AVPacket pkt;
568             do {
569                 if (d->queue->nb_packets == 0)
570                     SDL_CondSignal(d->empty_queue_cond);
571                 if (packet_queue_get(d->queue, &pkt, 1, &d->pkt_serial) < 0)
572                     return -1;
573                 if (pkt.data == flush_pkt.data) {
574                     avcodec_flush_buffers(d->avctx);
575                     d->finished = 0;
576                     d->next_pts = d->start_pts;
577                     d->next_pts_tb = d->start_pts_tb;
578                 }
579             } while (pkt.data == flush_pkt.data || d->queue->serial != d->pkt_serial);
580             av_packet_unref(&d->pkt);
581             d->pkt_temp = d->pkt = pkt;
582             d->packet_pending = 1;
583         }
584
585         switch (d->avctx->codec_type) {
586             case AVMEDIA_TYPE_VIDEO:
587                 ret = avcodec_decode_video2(d->avctx, frame, &got_frame, &d->pkt_temp);
588                 if (got_frame) {
589                     if (decoder_reorder_pts == -1) {
590                         frame->pts = av_frame_get_best_effort_timestamp(frame);
591                     } else if (decoder_reorder_pts) {
592                         frame->pts = frame->pkt_pts;
593                     } else {
594                         frame->pts = frame->pkt_dts;
595                     }
596                 }
597                 break;
598             case AVMEDIA_TYPE_AUDIO:
599                 ret = avcodec_decode_audio4(d->avctx, frame, &got_frame, &d->pkt_temp);
600                 if (got_frame) {
601                     AVRational tb = (AVRational){1, frame->sample_rate};
602                     if (frame->pts != AV_NOPTS_VALUE)
603                         frame->pts = av_rescale_q(frame->pts, d->avctx->time_base, tb);
604                     else if (frame->pkt_pts != AV_NOPTS_VALUE)
605                         frame->pts = av_rescale_q(frame->pkt_pts, av_codec_get_pkt_timebase(d->avctx), tb);
606                     else if (d->next_pts != AV_NOPTS_VALUE)
607                         frame->pts = av_rescale_q(d->next_pts, d->next_pts_tb, tb);
608                     if (frame->pts != AV_NOPTS_VALUE) {
609                         d->next_pts = frame->pts + frame->nb_samples;
610                         d->next_pts_tb = tb;
611                     }
612                 }
613                 break;
614             case AVMEDIA_TYPE_SUBTITLE:
615                 ret = avcodec_decode_subtitle2(d->avctx, sub, &got_frame, &d->pkt_temp);
616                 break;
617         }
618
619         if (ret < 0) {
620             d->packet_pending = 0;
621         } else {
622             d->pkt_temp.dts =
623             d->pkt_temp.pts = AV_NOPTS_VALUE;
624             if (d->pkt_temp.data) {
625                 if (d->avctx->codec_type != AVMEDIA_TYPE_AUDIO)
626                     ret = d->pkt_temp.size;
627                 d->pkt_temp.data += ret;
628                 d->pkt_temp.size -= ret;
629                 if (d->pkt_temp.size <= 0)
630                     d->packet_pending = 0;
631             } else {
632                 if (!got_frame) {
633                     d->packet_pending = 0;
634                     d->finished = d->pkt_serial;
635                 }
636             }
637         }
638     } while (!got_frame && !d->finished);
639
640     return got_frame;
641 }
642
643 static void decoder_destroy(Decoder *d) {
644     av_packet_unref(&d->pkt);
645 }
646
647 static void frame_queue_unref_item(Frame *vp)
648 {
649     int i;
650     for (i = 0; i < vp->sub.num_rects; i++) {
651         av_freep(&vp->subrects[i]->data[0]);
652         av_freep(&vp->subrects[i]);
653     }
654     av_freep(&vp->subrects);
655     av_frame_unref(vp->frame);
656     avsubtitle_free(&vp->sub);
657 }
658
659 static int frame_queue_init(FrameQueue *f, PacketQueue *pktq, int max_size, int keep_last)
660 {
661     int i;
662     memset(f, 0, sizeof(FrameQueue));
663     if (!(f->mutex = SDL_CreateMutex())) {
664         av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
665         return AVERROR(ENOMEM);
666     }
667     if (!(f->cond = SDL_CreateCond())) {
668         av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
669         return AVERROR(ENOMEM);
670     }
671     f->pktq = pktq;
672     f->max_size = FFMIN(max_size, FRAME_QUEUE_SIZE);
673     f->keep_last = !!keep_last;
674     for (i = 0; i < f->max_size; i++)
675         if (!(f->queue[i].frame = av_frame_alloc()))
676             return AVERROR(ENOMEM);
677     return 0;
678 }
679
680 static void frame_queue_destory(FrameQueue *f)
681 {
682     int i;
683     for (i = 0; i < f->max_size; i++) {
684         Frame *vp = &f->queue[i];
685         frame_queue_unref_item(vp);
686         av_frame_free(&vp->frame);
687         free_picture(vp);
688     }
689     SDL_DestroyMutex(f->mutex);
690     SDL_DestroyCond(f->cond);
691 }
692
693 static void frame_queue_signal(FrameQueue *f)
694 {
695     SDL_LockMutex(f->mutex);
696     SDL_CondSignal(f->cond);
697     SDL_UnlockMutex(f->mutex);
698 }
699
700 static Frame *frame_queue_peek(FrameQueue *f)
701 {
702     return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
703 }
704
705 static Frame *frame_queue_peek_next(FrameQueue *f)
706 {
707     return &f->queue[(f->rindex + f->rindex_shown + 1) % f->max_size];
708 }
709
710 static Frame *frame_queue_peek_last(FrameQueue *f)
711 {
712     return &f->queue[f->rindex];
713 }
714
715 static Frame *frame_queue_peek_writable(FrameQueue *f)
716 {
717     /* wait until we have space to put a new frame */
718     SDL_LockMutex(f->mutex);
719     while (f->size >= f->max_size &&
720            !f->pktq->abort_request) {
721         SDL_CondWait(f->cond, f->mutex);
722     }
723     SDL_UnlockMutex(f->mutex);
724
725     if (f->pktq->abort_request)
726         return NULL;
727
728     return &f->queue[f->windex];
729 }
730
731 static Frame *frame_queue_peek_readable(FrameQueue *f)
732 {
733     /* wait until we have a readable a new frame */
734     SDL_LockMutex(f->mutex);
735     while (f->size - f->rindex_shown <= 0 &&
736            !f->pktq->abort_request) {
737         SDL_CondWait(f->cond, f->mutex);
738     }
739     SDL_UnlockMutex(f->mutex);
740
741     if (f->pktq->abort_request)
742         return NULL;
743
744     return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
745 }
746
747 static void frame_queue_push(FrameQueue *f)
748 {
749     if (++f->windex == f->max_size)
750         f->windex = 0;
751     SDL_LockMutex(f->mutex);
752     f->size++;
753     SDL_CondSignal(f->cond);
754     SDL_UnlockMutex(f->mutex);
755 }
756
757 static void frame_queue_next(FrameQueue *f)
758 {
759     if (f->keep_last && !f->rindex_shown) {
760         f->rindex_shown = 1;
761         return;
762     }
763     frame_queue_unref_item(&f->queue[f->rindex]);
764     if (++f->rindex == f->max_size)
765         f->rindex = 0;
766     SDL_LockMutex(f->mutex);
767     f->size--;
768     SDL_CondSignal(f->cond);
769     SDL_UnlockMutex(f->mutex);
770 }
771
772 /* jump back to the previous frame if available by resetting rindex_shown */
773 static int frame_queue_prev(FrameQueue *f)
774 {
775     int ret = f->rindex_shown;
776     f->rindex_shown = 0;
777     return ret;
778 }
779
780 /* return the number of undisplayed frames in the queue */
781 static int frame_queue_nb_remaining(FrameQueue *f)
782 {
783     return f->size - f->rindex_shown;
784 }
785
786 /* return last shown position */
787 static int64_t frame_queue_last_pos(FrameQueue *f)
788 {
789     Frame *fp = &f->queue[f->rindex];
790     if (f->rindex_shown && fp->serial == f->pktq->serial)
791         return fp->pos;
792     else
793         return -1;
794 }
795
796 static void decoder_abort(Decoder *d, FrameQueue *fq)
797 {
798     packet_queue_abort(d->queue);
799     frame_queue_signal(fq);
800     SDL_WaitThread(d->decoder_tid, NULL);
801     d->decoder_tid = NULL;
802     packet_queue_flush(d->queue);
803 }
804
805 static inline void fill_rectangle(SDL_Surface *screen,
806                                   int x, int y, int w, int h, int color, int update)
807 {
808     SDL_Rect rect;
809     rect.x = x;
810     rect.y = y;
811     rect.w = w;
812     rect.h = h;
813     SDL_FillRect(screen, &rect, color);
814     if (update && w > 0 && h > 0)
815         SDL_UpdateRect(screen, x, y, w, h);
816 }
817
818 /* draw only the border of a rectangle */
819 static void fill_border(int xleft, int ytop, int width, int height, int x, int y, int w, int h, int color, int update)
820 {
821     int w1, w2, h1, h2;
822
823     /* fill the background */
824     w1 = x;
825     if (w1 < 0)
826         w1 = 0;
827     w2 = width - (x + w);
828     if (w2 < 0)
829         w2 = 0;
830     h1 = y;
831     if (h1 < 0)
832         h1 = 0;
833     h2 = height - (y + h);
834     if (h2 < 0)
835         h2 = 0;
836     fill_rectangle(screen,
837                    xleft, ytop,
838                    w1, height,
839                    color, update);
840     fill_rectangle(screen,
841                    xleft + width - w2, ytop,
842                    w2, height,
843                    color, update);
844     fill_rectangle(screen,
845                    xleft + w1, ytop,
846                    width - w1 - w2, h1,
847                    color, update);
848     fill_rectangle(screen,
849                    xleft + w1, ytop + height - h2,
850                    width - w1 - w2, h2,
851                    color, update);
852 }
853
854 #define ALPHA_BLEND(a, oldp, newp, s)\
855 ((((oldp << s) * (255 - (a))) + (newp * (a))) / (255 << s))
856
857
858
859 #define BPP 1
860
861 static void blend_subrect(uint8_t **data, int *linesize, const AVSubtitleRect *rect, int imgw, int imgh)
862 {
863     int x, y, Y, U, V, A;
864     uint8_t *lum, *cb, *cr;
865     int dstx, dsty, dstw, dsth;
866     const AVSubtitleRect *src = rect;
867
868     dstw = av_clip(rect->w, 0, imgw);
869     dsth = av_clip(rect->h, 0, imgh);
870     dstx = av_clip(rect->x, 0, imgw - dstw);
871     dsty = av_clip(rect->y, 0, imgh - dsth);
872     lum = data[0] + dstx + dsty * linesize[0];
873     cb  = data[1] + dstx/2 + (dsty >> 1) * linesize[1];
874     cr  = data[2] + dstx/2 + (dsty >> 1) * linesize[2];
875
876     for (y = 0; y<dsth; y++) {
877         for (x = 0; x<dstw; x++) {
878             Y = src->data[0][x + y*src->linesize[0]];
879             A = src->data[3][x + y*src->linesize[3]];
880             lum[0] = ALPHA_BLEND(A, lum[0], Y, 0);
881             lum++;
882         }
883         lum += linesize[0] - dstw;
884     }
885
886     for (y = 0; y<dsth/2; y++) {
887         for (x = 0; x<dstw/2; x++) {
888             U = src->data[1][x + y*src->linesize[1]];
889             V = src->data[2][x + y*src->linesize[2]];
890             A = src->data[3][2*x     +  2*y   *src->linesize[3]]
891               + src->data[3][2*x + 1 +  2*y   *src->linesize[3]]
892               + src->data[3][2*x + 1 + (2*y+1)*src->linesize[3]]
893               + src->data[3][2*x     + (2*y+1)*src->linesize[3]];
894             cb[0] = ALPHA_BLEND(A>>2, cb[0], U, 0);
895             cr[0] = ALPHA_BLEND(A>>2, cr[0], V, 0);
896             cb++;
897             cr++;
898         }
899         cb += linesize[1] - dstw/2;
900         cr += linesize[2] - dstw/2;
901     }
902 }
903
904 static void free_picture(Frame *vp)
905 {
906      if (vp->bmp) {
907          SDL_FreeYUVOverlay(vp->bmp);
908          vp->bmp = NULL;
909      }
910 }
911
912 static void calculate_display_rect(SDL_Rect *rect,
913                                    int scr_xleft, int scr_ytop, int scr_width, int scr_height,
914                                    int pic_width, int pic_height, AVRational pic_sar)
915 {
916     float aspect_ratio;
917     int width, height, x, y;
918
919     if (pic_sar.num == 0)
920         aspect_ratio = 0;
921     else
922         aspect_ratio = av_q2d(pic_sar);
923
924     if (aspect_ratio <= 0.0)
925         aspect_ratio = 1.0;
926     aspect_ratio *= (float)pic_width / (float)pic_height;
927
928     /* XXX: we suppose the screen has a 1.0 pixel ratio */
929     height = scr_height;
930     width = lrint(height * aspect_ratio) & ~1;
931     if (width > scr_width) {
932         width = scr_width;
933         height = lrint(width / aspect_ratio) & ~1;
934     }
935     x = (scr_width - width) / 2;
936     y = (scr_height - height) / 2;
937     rect->x = scr_xleft + x;
938     rect->y = scr_ytop  + y;
939     rect->w = FFMAX(width,  1);
940     rect->h = FFMAX(height, 1);
941 }
942
943 static void video_image_display(VideoState *is)
944 {
945     Frame *vp;
946     Frame *sp;
947     SDL_Rect rect;
948     int i;
949
950     vp = frame_queue_peek(&is->pictq);
951     if (vp->bmp) {
952         if (is->subtitle_st) {
953             if (frame_queue_nb_remaining(&is->subpq) > 0) {
954                 sp = frame_queue_peek(&is->subpq);
955
956                 if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {
957                     uint8_t *data[4];
958                     int linesize[4];
959
960                     SDL_LockYUVOverlay (vp->bmp);
961
962                     data[0] = vp->bmp->pixels[0];
963                     data[1] = vp->bmp->pixels[2];
964                     data[2] = vp->bmp->pixels[1];
965
966                     linesize[0] = vp->bmp->pitches[0];
967                     linesize[1] = vp->bmp->pitches[2];
968                     linesize[2] = vp->bmp->pitches[1];
969
970                     for (i = 0; i < sp->sub.num_rects; i++)
971                         blend_subrect(data, linesize, sp->subrects[i],
972                                       vp->bmp->w, vp->bmp->h);
973
974                     SDL_UnlockYUVOverlay (vp->bmp);
975                 }
976             }
977         }
978
979         calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp->width, vp->height, vp->sar);
980
981         SDL_DisplayYUVOverlay(vp->bmp, &rect);
982
983         if (rect.x != is->last_display_rect.x || rect.y != is->last_display_rect.y || rect.w != is->last_display_rect.w || rect.h != is->last_display_rect.h || is->force_refresh) {
984             int bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
985             fill_border(is->xleft, is->ytop, is->width, is->height, rect.x, rect.y, rect.w, rect.h, bgcolor, 1);
986             is->last_display_rect = rect;
987         }
988     }
989 }
990
991 static inline int compute_mod(int a, int b)
992 {
993     return a < 0 ? a%b + b : a%b;
994 }
995
996 static void video_audio_display(VideoState *s)
997 {
998     int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
999     int ch, channels, h, h2, bgcolor, fgcolor;
1000     int64_t time_diff;
1001     int rdft_bits, nb_freq;
1002
1003     for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++)
1004         ;
1005     nb_freq = 1 << (rdft_bits - 1);
1006
1007     /* compute display index : center on currently output samples */
1008     channels = s->audio_tgt.channels;
1009     nb_display_channels = channels;
1010     if (!s->paused) {
1011         int data_used= s->show_mode == SHOW_MODE_WAVES ? s->width : (2*nb_freq);
1012         n = 2 * channels;
1013         delay = s->audio_write_buf_size;
1014         delay /= n;
1015
1016         /* to be more precise, we take into account the time spent since
1017            the last buffer computation */
1018         if (audio_callback_time) {
1019             time_diff = av_gettime_relative() - audio_callback_time;
1020             delay -= (time_diff * s->audio_tgt.freq) / 1000000;
1021         }
1022
1023         delay += 2 * data_used;
1024         if (delay < data_used)
1025             delay = data_used;
1026
1027         i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
1028         if (s->show_mode == SHOW_MODE_WAVES) {
1029             h = INT_MIN;
1030             for (i = 0; i < 1000; i += channels) {
1031                 int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
1032                 int a = s->sample_array[idx];
1033                 int b = s->sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];
1034                 int c = s->sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];
1035                 int d = s->sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];
1036                 int score = a - d;
1037                 if (h < score && (b ^ c) < 0) {
1038                     h = score;
1039                     i_start = idx;
1040                 }
1041             }
1042         }
1043
1044         s->last_i_start = i_start;
1045     } else {
1046         i_start = s->last_i_start;
1047     }
1048
1049     bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
1050     if (s->show_mode == SHOW_MODE_WAVES) {
1051         fill_rectangle(screen,
1052                        s->xleft, s->ytop, s->width, s->height,
1053                        bgcolor, 0);
1054
1055         fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);
1056
1057         /* total height for one channel */
1058         h = s->height / nb_display_channels;
1059         /* graph height / 2 */
1060         h2 = (h * 9) / 20;
1061         for (ch = 0; ch < nb_display_channels; ch++) {
1062             i = i_start + ch;
1063             y1 = s->ytop + ch * h + (h / 2); /* position of center line */
1064             for (x = 0; x < s->width; x++) {
1065                 y = (s->sample_array[i] * h2) >> 15;
1066                 if (y < 0) {
1067                     y = -y;
1068                     ys = y1 - y;
1069                 } else {
1070                     ys = y1;
1071                 }
1072                 fill_rectangle(screen,
1073                                s->xleft + x, ys, 1, y,
1074                                fgcolor, 0);
1075                 i += channels;
1076                 if (i >= SAMPLE_ARRAY_SIZE)
1077                     i -= SAMPLE_ARRAY_SIZE;
1078             }
1079         }
1080
1081         fgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff);
1082
1083         for (ch = 1; ch < nb_display_channels; ch++) {
1084             y = s->ytop + ch * h;
1085             fill_rectangle(screen,
1086                            s->xleft, y, s->width, 1,
1087                            fgcolor, 0);
1088         }
1089         SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height);
1090     } else {
1091         nb_display_channels= FFMIN(nb_display_channels, 2);
1092         if (rdft_bits != s->rdft_bits) {
1093             av_rdft_end(s->rdft);
1094             av_free(s->rdft_data);
1095             s->rdft = av_rdft_init(rdft_bits, DFT_R2C);
1096             s->rdft_bits = rdft_bits;
1097             s->rdft_data = av_malloc_array(nb_freq, 4 *sizeof(*s->rdft_data));
1098         }
1099         if (!s->rdft || !s->rdft_data){
1100             av_log(NULL, AV_LOG_ERROR, "Failed to allocate buffers for RDFT, switching to waves display\n");
1101             s->show_mode = SHOW_MODE_WAVES;
1102         } else {
1103             FFTSample *data[2];
1104             for (ch = 0; ch < nb_display_channels; ch++) {
1105                 data[ch] = s->rdft_data + 2 * nb_freq * ch;
1106                 i = i_start + ch;
1107                 for (x = 0; x < 2 * nb_freq; x++) {
1108                     double w = (x-nb_freq) * (1.0 / nb_freq);
1109                     data[ch][x] = s->sample_array[i] * (1.0 - w * w);
1110                     i += channels;
1111                     if (i >= SAMPLE_ARRAY_SIZE)
1112                         i -= SAMPLE_ARRAY_SIZE;
1113                 }
1114                 av_rdft_calc(s->rdft, data[ch]);
1115             }
1116             /* Least efficient way to do this, we should of course
1117              * directly access it but it is more than fast enough. */
1118             for (y = 0; y < s->height; y++) {
1119                 double w = 1 / sqrt(nb_freq);
1120                 int a = sqrt(w * hypot(data[0][2 * y + 0], data[0][2 * y + 1]));
1121                 int b = (nb_display_channels == 2 ) ? sqrt(w * hypot(data[1][2 * y + 0], data[1][2 * y + 1]))
1122                                                     : a;
1123                 a = FFMIN(a, 255);
1124                 b = FFMIN(b, 255);
1125                 fgcolor = SDL_MapRGB(screen->format, a, b, (a + b) / 2);
1126
1127                 fill_rectangle(screen,
1128                             s->xpos, s->height-y, 1, 1,
1129                             fgcolor, 0);
1130             }
1131         }
1132         SDL_UpdateRect(screen, s->xpos, s->ytop, 1, s->height);
1133         if (!s->paused)
1134             s->xpos++;
1135         if (s->xpos >= s->width)
1136             s->xpos= s->xleft;
1137     }
1138 }
1139
1140 static void stream_component_close(VideoState *is, int stream_index)
1141 {
1142     AVFormatContext *ic = is->ic;
1143     AVCodecContext *avctx;
1144
1145     if (stream_index < 0 || stream_index >= ic->nb_streams)
1146         return;
1147     avctx = ic->streams[stream_index]->codec;
1148
1149     switch (avctx->codec_type) {
1150     case AVMEDIA_TYPE_AUDIO:
1151         decoder_abort(&is->auddec, &is->sampq);
1152         SDL_CloseAudio();
1153         decoder_destroy(&is->auddec);
1154         swr_free(&is->swr_ctx);
1155         av_freep(&is->audio_buf1);
1156         is->audio_buf1_size = 0;
1157         is->audio_buf = NULL;
1158
1159         if (is->rdft) {
1160             av_rdft_end(is->rdft);
1161             av_freep(&is->rdft_data);
1162             is->rdft = NULL;
1163             is->rdft_bits = 0;
1164         }
1165         break;
1166     case AVMEDIA_TYPE_VIDEO:
1167         decoder_abort(&is->viddec, &is->pictq);
1168         decoder_destroy(&is->viddec);
1169         break;
1170     case AVMEDIA_TYPE_SUBTITLE:
1171         decoder_abort(&is->subdec, &is->subpq);
1172         decoder_destroy(&is->subdec);
1173         break;
1174     default:
1175         break;
1176     }
1177
1178     ic->streams[stream_index]->discard = AVDISCARD_ALL;
1179     avcodec_close(avctx);
1180     switch (avctx->codec_type) {
1181     case AVMEDIA_TYPE_AUDIO:
1182         is->audio_st = NULL;
1183         is->audio_stream = -1;
1184         break;
1185     case AVMEDIA_TYPE_VIDEO:
1186         is->video_st = NULL;
1187         is->video_stream = -1;
1188         break;
1189     case AVMEDIA_TYPE_SUBTITLE:
1190         is->subtitle_st = NULL;
1191         is->subtitle_stream = -1;
1192         break;
1193     default:
1194         break;
1195     }
1196 }
1197
1198 static void stream_close(VideoState *is)
1199 {
1200     /* XXX: use a special url_shutdown call to abort parse cleanly */
1201     is->abort_request = 1;
1202     SDL_WaitThread(is->read_tid, NULL);
1203
1204     /* close each stream */
1205     if (is->audio_stream >= 0)
1206         stream_component_close(is, is->audio_stream);
1207     if (is->video_stream >= 0)
1208         stream_component_close(is, is->video_stream);
1209     if (is->subtitle_stream >= 0)
1210         stream_component_close(is, is->subtitle_stream);
1211
1212     avformat_close_input(&is->ic);
1213
1214     packet_queue_destroy(&is->videoq);
1215     packet_queue_destroy(&is->audioq);
1216     packet_queue_destroy(&is->subtitleq);
1217
1218     /* free all pictures */
1219     frame_queue_destory(&is->pictq);
1220     frame_queue_destory(&is->sampq);
1221     frame_queue_destory(&is->subpq);
1222     SDL_DestroyCond(is->continue_read_thread);
1223 #if !CONFIG_AVFILTER
1224     sws_freeContext(is->img_convert_ctx);
1225 #endif
1226     sws_freeContext(is->sub_convert_ctx);
1227     av_free(is->filename);
1228     av_free(is);
1229 }
1230
1231 static void do_exit(VideoState *is)
1232 {
1233     if (is) {
1234         stream_close(is);
1235     }
1236     av_lockmgr_register(NULL);
1237     uninit_opts();
1238 #if CONFIG_AVFILTER
1239     av_freep(&vfilters_list);
1240 #endif
1241     avformat_network_deinit();
1242     if (show_status)
1243         printf("\n");
1244     SDL_Quit();
1245     av_log(NULL, AV_LOG_QUIET, "%s", "");
1246     exit(0);
1247 }
1248
1249 static void sigterm_handler(int sig)
1250 {
1251     exit(123);
1252 }
1253
1254 static void set_default_window_size(int width, int height, AVRational sar)
1255 {
1256     SDL_Rect rect;
1257     calculate_display_rect(&rect, 0, 0, INT_MAX, height, width, height, sar);
1258     default_width  = rect.w;
1259     default_height = rect.h;
1260 }
1261
1262 static int video_open(VideoState *is, int force_set_video_mode, Frame *vp)
1263 {
1264     int flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL;
1265     int w,h;
1266
1267     if (is_full_screen) flags |= SDL_FULLSCREEN;
1268     else                flags |= SDL_RESIZABLE;
1269
1270     if (vp && vp->width)
1271         set_default_window_size(vp->width, vp->height, vp->sar);
1272
1273     if (is_full_screen && fs_screen_width) {
1274         w = fs_screen_width;
1275         h = fs_screen_height;
1276     } else if (!is_full_screen && screen_width) {
1277         w = screen_width;
1278         h = screen_height;
1279     } else {
1280         w = default_width;
1281         h = default_height;
1282     }
1283     w = FFMIN(16383, w);
1284     if (screen && is->width == screen->w && screen->w == w
1285        && is->height== screen->h && screen->h == h && !force_set_video_mode)
1286         return 0;
1287     screen = SDL_SetVideoMode(w, h, 0, flags);
1288     if (!screen) {
1289         av_log(NULL, AV_LOG_FATAL, "SDL: could not set video mode - exiting\n");
1290         do_exit(is);
1291     }
1292     if (!window_title)
1293         window_title = input_filename;
1294     SDL_WM_SetCaption(window_title, window_title);
1295
1296     is->width  = screen->w;
1297     is->height = screen->h;
1298
1299     return 0;
1300 }
1301
1302 /* display the current picture, if any */
1303 static void video_display(VideoState *is)
1304 {
1305     if (!screen)
1306         video_open(is, 0, NULL);
1307     if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
1308         video_audio_display(is);
1309     else if (is->video_st)
1310         video_image_display(is);
1311 }
1312
1313 static double get_clock(Clock *c)
1314 {
1315     if (*c->queue_serial != c->serial)
1316         return NAN;
1317     if (c->paused) {
1318         return c->pts;
1319     } else {
1320         double time = av_gettime_relative() / 1000000.0;
1321         return c->pts_drift + time - (time - c->last_updated) * (1.0 - c->speed);
1322     }
1323 }
1324
1325 static void set_clock_at(Clock *c, double pts, int serial, double time)
1326 {
1327     c->pts = pts;
1328     c->last_updated = time;
1329     c->pts_drift = c->pts - time;
1330     c->serial = serial;
1331 }
1332
1333 static void set_clock(Clock *c, double pts, int serial)
1334 {
1335     double time = av_gettime_relative() / 1000000.0;
1336     set_clock_at(c, pts, serial, time);
1337 }
1338
1339 static void set_clock_speed(Clock *c, double speed)
1340 {
1341     set_clock(c, get_clock(c), c->serial);
1342     c->speed = speed;
1343 }
1344
1345 static void init_clock(Clock *c, int *queue_serial)
1346 {
1347     c->speed = 1.0;
1348     c->paused = 0;
1349     c->queue_serial = queue_serial;
1350     set_clock(c, NAN, -1);
1351 }
1352
1353 static void sync_clock_to_slave(Clock *c, Clock *slave)
1354 {
1355     double clock = get_clock(c);
1356     double slave_clock = get_clock(slave);
1357     if (!isnan(slave_clock) && (isnan(clock) || fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))
1358         set_clock(c, slave_clock, slave->serial);
1359 }
1360
1361 static int get_master_sync_type(VideoState *is) {
1362     if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
1363         if (is->video_st)
1364             return AV_SYNC_VIDEO_MASTER;
1365         else
1366             return AV_SYNC_AUDIO_MASTER;
1367     } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
1368         if (is->audio_st)
1369             return AV_SYNC_AUDIO_MASTER;
1370         else
1371             return AV_SYNC_EXTERNAL_CLOCK;
1372     } else {
1373         return AV_SYNC_EXTERNAL_CLOCK;
1374     }
1375 }
1376
1377 /* get the current master clock value */
1378 static double get_master_clock(VideoState *is)
1379 {
1380     double val;
1381
1382     switch (get_master_sync_type(is)) {
1383         case AV_SYNC_VIDEO_MASTER:
1384             val = get_clock(&is->vidclk);
1385             break;
1386         case AV_SYNC_AUDIO_MASTER:
1387             val = get_clock(&is->audclk);
1388             break;
1389         default:
1390             val = get_clock(&is->extclk);
1391             break;
1392     }
1393     return val;
1394 }
1395
1396 static void check_external_clock_speed(VideoState *is) {
1397    if (is->video_stream >= 0 && is->videoq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES ||
1398        is->audio_stream >= 0 && is->audioq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES) {
1399        set_clock_speed(&is->extclk, FFMAX(EXTERNAL_CLOCK_SPEED_MIN, is->extclk.speed - EXTERNAL_CLOCK_SPEED_STEP));
1400    } else if ((is->video_stream < 0 || is->videoq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES) &&
1401               (is->audio_stream < 0 || is->audioq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES)) {
1402        set_clock_speed(&is->extclk, FFMIN(EXTERNAL_CLOCK_SPEED_MAX, is->extclk.speed + EXTERNAL_CLOCK_SPEED_STEP));
1403    } else {
1404        double speed = is->extclk.speed;
1405        if (speed != 1.0)
1406            set_clock_speed(&is->extclk, speed + EXTERNAL_CLOCK_SPEED_STEP * (1.0 - speed) / fabs(1.0 - speed));
1407    }
1408 }
1409
1410 /* seek in the stream */
1411 static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)
1412 {
1413     if (!is->seek_req) {
1414         is->seek_pos = pos;
1415         is->seek_rel = rel;
1416         is->seek_flags &= ~AVSEEK_FLAG_BYTE;
1417         if (seek_by_bytes)
1418             is->seek_flags |= AVSEEK_FLAG_BYTE;
1419         is->seek_req = 1;
1420         SDL_CondSignal(is->continue_read_thread);
1421     }
1422 }
1423
1424 /* pause or resume the video */
1425 static void stream_toggle_pause(VideoState *is)
1426 {
1427     if (is->paused) {
1428         is->frame_timer += av_gettime_relative() / 1000000.0 - is->vidclk.last_updated;
1429         if (is->read_pause_return != AVERROR(ENOSYS)) {
1430             is->vidclk.paused = 0;
1431         }
1432         set_clock(&is->vidclk, get_clock(&is->vidclk), is->vidclk.serial);
1433     }
1434     set_clock(&is->extclk, get_clock(&is->extclk), is->extclk.serial);
1435     is->paused = is->audclk.paused = is->vidclk.paused = is->extclk.paused = !is->paused;
1436 }
1437
1438 static void toggle_pause(VideoState *is)
1439 {
1440     stream_toggle_pause(is);
1441     is->step = 0;
1442 }
1443
1444 static void toggle_mute(VideoState *is)
1445 {
1446     is->muted = !is->muted;
1447 }
1448
1449 static void update_volume(VideoState *is, int sign, int step)
1450 {
1451     is->audio_volume = av_clip(is->audio_volume + sign * step, 0, SDL_MIX_MAXVOLUME);
1452 }
1453
1454 static void step_to_next_frame(VideoState *is)
1455 {
1456     /* if the stream is paused unpause it, then step */
1457     if (is->paused)
1458         stream_toggle_pause(is);
1459     is->step = 1;
1460 }
1461
1462 static double compute_target_delay(double delay, VideoState *is)
1463 {
1464     double sync_threshold, diff = 0;
1465
1466     /* update delay to follow master synchronisation source */
1467     if (get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER) {
1468         /* if video is slave, we try to correct big delays by
1469            duplicating or deleting a frame */
1470         diff = get_clock(&is->vidclk) - get_master_clock(is);
1471
1472         /* skip or repeat frame. We take into account the
1473            delay to compute the threshold. I still don't know
1474            if it is the best guess */
1475         sync_threshold = FFMAX(AV_SYNC_THRESHOLD_MIN, FFMIN(AV_SYNC_THRESHOLD_MAX, delay));
1476         if (!isnan(diff) && fabs(diff) < is->max_frame_duration) {
1477             if (diff <= -sync_threshold)
1478                 delay = FFMAX(0, delay + diff);
1479             else if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD)
1480                 delay = delay + diff;
1481             else if (diff >= sync_threshold)
1482                 delay = 2 * delay;
1483         }
1484     }
1485
1486     av_log(NULL, AV_LOG_TRACE, "video: delay=%0.3f A-V=%f\n",
1487             delay, -diff);
1488
1489     return delay;
1490 }
1491
1492 static double vp_duration(VideoState *is, Frame *vp, Frame *nextvp) {
1493     if (vp->serial == nextvp->serial) {
1494         double duration = nextvp->pts - vp->pts;
1495         if (isnan(duration) || duration <= 0 || duration > is->max_frame_duration)
1496             return vp->duration;
1497         else
1498             return duration;
1499     } else {
1500         return 0.0;
1501     }
1502 }
1503
1504 static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
1505     /* update current video pts */
1506     set_clock(&is->vidclk, pts, serial);
1507     sync_clock_to_slave(&is->extclk, &is->vidclk);
1508 }
1509
1510 /* called to display each frame */
1511 static void video_refresh(void *opaque, double *remaining_time)
1512 {
1513     VideoState *is = opaque;
1514     double time;
1515
1516     Frame *sp, *sp2;
1517
1518     if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
1519         check_external_clock_speed(is);
1520
1521     if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {
1522         time = av_gettime_relative() / 1000000.0;
1523         if (is->force_refresh || is->last_vis_time + rdftspeed < time) {
1524             video_display(is);
1525             is->last_vis_time = time;
1526         }
1527         *remaining_time = FFMIN(*remaining_time, is->last_vis_time + rdftspeed - time);
1528     }
1529
1530     if (is->video_st) {
1531         int redisplay = 0;
1532         if (is->force_refresh)
1533             redisplay = frame_queue_prev(&is->pictq);
1534 retry:
1535         if (frame_queue_nb_remaining(&is->pictq) == 0) {
1536             // nothing to do, no picture to display in the queue
1537         } else {
1538             double last_duration, duration, delay;
1539             Frame *vp, *lastvp;
1540
1541             /* dequeue the picture */
1542             lastvp = frame_queue_peek_last(&is->pictq);
1543             vp = frame_queue_peek(&is->pictq);
1544
1545             if (vp->serial != is->videoq.serial) {
1546                 frame_queue_next(&is->pictq);
1547                 redisplay = 0;
1548                 goto retry;
1549             }
1550
1551             if (lastvp->serial != vp->serial && !redisplay)
1552                 is->frame_timer = av_gettime_relative() / 1000000.0;
1553
1554             if (is->paused)
1555                 goto display;
1556
1557             /* compute nominal last_duration */
1558             last_duration = vp_duration(is, lastvp, vp);
1559             if (redisplay)
1560                 delay = 0.0;
1561             else
1562                 delay = compute_target_delay(last_duration, is);
1563
1564             time= av_gettime_relative()/1000000.0;
1565             if (time < is->frame_timer + delay && !redisplay) {
1566                 *remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);
1567                 return;
1568             }
1569
1570             is->frame_timer += delay;
1571             if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)
1572                 is->frame_timer = time;
1573
1574             SDL_LockMutex(is->pictq.mutex);
1575             if (!redisplay && !isnan(vp->pts))
1576                 update_video_pts(is, vp->pts, vp->pos, vp->serial);
1577             SDL_UnlockMutex(is->pictq.mutex);
1578
1579             if (frame_queue_nb_remaining(&is->pictq) > 1) {
1580                 Frame *nextvp = frame_queue_peek_next(&is->pictq);
1581                 duration = vp_duration(is, vp, nextvp);
1582                 if(!is->step && (redisplay || framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
1583                     if (!redisplay)
1584                         is->frame_drops_late++;
1585                     frame_queue_next(&is->pictq);
1586                     redisplay = 0;
1587                     goto retry;
1588                 }
1589             }
1590
1591             if (is->subtitle_st) {
1592                     while (frame_queue_nb_remaining(&is->subpq) > 0) {
1593                         sp = frame_queue_peek(&is->subpq);
1594
1595                         if (frame_queue_nb_remaining(&is->subpq) > 1)
1596                             sp2 = frame_queue_peek_next(&is->subpq);
1597                         else
1598                             sp2 = NULL;
1599
1600                         if (sp->serial != is->subtitleq.serial
1601                                 || (is->vidclk.pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1602                                 || (sp2 && is->vidclk.pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1603                         {
1604                             frame_queue_next(&is->subpq);
1605                         } else {
1606                             break;
1607                         }
1608                     }
1609             }
1610
1611 display:
1612             /* display picture */
1613             if (!display_disable && is->show_mode == SHOW_MODE_VIDEO)
1614                 video_display(is);
1615
1616             frame_queue_next(&is->pictq);
1617
1618             if (is->step && !is->paused)
1619                 stream_toggle_pause(is);
1620         }
1621     }
1622     is->force_refresh = 0;
1623     if (show_status) {
1624         static int64_t last_time;
1625         int64_t cur_time;
1626         int aqsize, vqsize, sqsize;
1627         double av_diff;
1628
1629         cur_time = av_gettime_relative();
1630         if (!last_time || (cur_time - last_time) >= 30000) {
1631             aqsize = 0;
1632             vqsize = 0;
1633             sqsize = 0;
1634             if (is->audio_st)
1635                 aqsize = is->audioq.size;
1636             if (is->video_st)
1637                 vqsize = is->videoq.size;
1638             if (is->subtitle_st)
1639                 sqsize = is->subtitleq.size;
1640             av_diff = 0;
1641             if (is->audio_st && is->video_st)
1642                 av_diff = get_clock(&is->audclk) - get_clock(&is->vidclk);
1643             else if (is->video_st)
1644                 av_diff = get_master_clock(is) - get_clock(&is->vidclk);
1645             else if (is->audio_st)
1646                 av_diff = get_master_clock(is) - get_clock(&is->audclk);
1647             av_log(NULL, AV_LOG_INFO,
1648                    "%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64"   \r",
1649                    get_master_clock(is),
1650                    (is->audio_st && is->video_st) ? "A-V" : (is->video_st ? "M-V" : (is->audio_st ? "M-A" : "   ")),
1651                    av_diff,
1652                    is->frame_drops_early + is->frame_drops_late,
1653                    aqsize / 1024,
1654                    vqsize / 1024,
1655                    sqsize,
1656                    is->video_st ? is->video_st->codec->pts_correction_num_faulty_dts : 0,
1657                    is->video_st ? is->video_st->codec->pts_correction_num_faulty_pts : 0);
1658             fflush(stdout);
1659             last_time = cur_time;
1660         }
1661     }
1662 }
1663
1664 /* allocate a picture (needs to do that in main thread to avoid
1665    potential locking problems */
1666 static void alloc_picture(VideoState *is)
1667 {
1668     Frame *vp;
1669     int64_t bufferdiff;
1670
1671     vp = &is->pictq.queue[is->pictq.windex];
1672
1673     free_picture(vp);
1674
1675     video_open(is, 0, vp);
1676
1677     vp->bmp = SDL_CreateYUVOverlay(vp->width, vp->height,
1678                                    SDL_YV12_OVERLAY,
1679                                    screen);
1680     bufferdiff = vp->bmp ? FFMAX(vp->bmp->pixels[0], vp->bmp->pixels[1]) - FFMIN(vp->bmp->pixels[0], vp->bmp->pixels[1]) : 0;
1681     if (!vp->bmp || vp->bmp->pitches[0] < vp->width || bufferdiff < (int64_t)vp->height * vp->bmp->pitches[0]) {
1682         /* SDL allocates a buffer smaller than requested if the video
1683          * overlay hardware is unable to support the requested size. */
1684         av_log(NULL, AV_LOG_FATAL,
1685                "Error: the video system does not support an image\n"
1686                         "size of %dx%d pixels. Try using -lowres or -vf \"scale=w:h\"\n"
1687                         "to reduce the image size.\n", vp->width, vp->height );
1688         do_exit(is);
1689     }
1690
1691     SDL_LockMutex(is->pictq.mutex);
1692     vp->allocated = 1;
1693     SDL_CondSignal(is->pictq.cond);
1694     SDL_UnlockMutex(is->pictq.mutex);
1695 }
1696
1697 static void duplicate_right_border_pixels(SDL_Overlay *bmp) {
1698     int i, width, height;
1699     Uint8 *p, *maxp;
1700     for (i = 0; i < 3; i++) {
1701         width  = bmp->w;
1702         height = bmp->h;
1703         if (i > 0) {
1704             width  >>= 1;
1705             height >>= 1;
1706         }
1707         if (bmp->pitches[i] > width) {
1708             maxp = bmp->pixels[i] + bmp->pitches[i] * height - 1;
1709             for (p = bmp->pixels[i] + width - 1; p < maxp; p += bmp->pitches[i])
1710                 *(p+1) = *p;
1711         }
1712     }
1713 }
1714
1715 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, double duration, int64_t pos, int serial)
1716 {
1717     Frame *vp;
1718
1719 #if defined(DEBUG_SYNC) && 0
1720     printf("frame_type=%c pts=%0.3f\n",
1721            av_get_picture_type_char(src_frame->pict_type), pts);
1722 #endif
1723
1724     if (!(vp = frame_queue_peek_writable(&is->pictq)))
1725         return -1;
1726
1727     vp->sar = src_frame->sample_aspect_ratio;
1728
1729     /* alloc or resize hardware picture buffer */
1730     if (!vp->bmp || vp->reallocate || !vp->allocated ||
1731         vp->width  != src_frame->width ||
1732         vp->height != src_frame->height) {
1733         SDL_Event event;
1734
1735         vp->allocated  = 0;
1736         vp->reallocate = 0;
1737         vp->width = src_frame->width;
1738         vp->height = src_frame->height;
1739
1740         /* the allocation must be done in the main thread to avoid
1741            locking problems. */
1742         event.type = FF_ALLOC_EVENT;
1743         event.user.data1 = is;
1744         SDL_PushEvent(&event);
1745
1746         /* wait until the picture is allocated */
1747         SDL_LockMutex(is->pictq.mutex);
1748         while (!vp->allocated && !is->videoq.abort_request) {
1749             SDL_CondWait(is->pictq.cond, is->pictq.mutex);
1750         }
1751         /* if the queue is aborted, we have to pop the pending ALLOC event or wait for the allocation to complete */
1752         if (is->videoq.abort_request && SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_EVENTMASK(FF_ALLOC_EVENT)) != 1) {
1753             while (!vp->allocated && !is->abort_request) {
1754                 SDL_CondWait(is->pictq.cond, is->pictq.mutex);
1755             }
1756         }
1757         SDL_UnlockMutex(is->pictq.mutex);
1758
1759         if (is->videoq.abort_request)
1760             return -1;
1761     }
1762
1763     /* if the frame is not skipped, then display it */
1764     if (vp->bmp) {
1765         uint8_t *data[4];
1766         int linesize[4];
1767
1768         /* get a pointer on the bitmap */
1769         SDL_LockYUVOverlay (vp->bmp);
1770
1771         data[0] = vp->bmp->pixels[0];
1772         data[1] = vp->bmp->pixels[2];
1773         data[2] = vp->bmp->pixels[1];
1774
1775         linesize[0] = vp->bmp->pitches[0];
1776         linesize[1] = vp->bmp->pitches[2];
1777         linesize[2] = vp->bmp->pitches[1];
1778
1779 #if CONFIG_AVFILTER
1780         // FIXME use direct rendering
1781         av_image_copy(data, linesize, (const uint8_t **)src_frame->data, src_frame->linesize,
1782                         src_frame->format, vp->width, vp->height);
1783 #else
1784         {
1785             AVDictionaryEntry *e = av_dict_get(sws_dict, "sws_flags", NULL, 0);
1786             if (e) {
1787                 const AVClass *class = sws_get_class();
1788                 const AVOption    *o = av_opt_find(&class, "sws_flags", NULL, 0,
1789                                                    AV_OPT_SEARCH_FAKE_OBJ);
1790                 int ret = av_opt_eval_flags(&class, o, e->value, &sws_flags);
1791                 if (ret < 0)
1792                     exit(1);
1793             }
1794         }
1795
1796         is->img_convert_ctx = sws_getCachedContext(is->img_convert_ctx,
1797             vp->width, vp->height, src_frame->format, vp->width, vp->height,
1798             AV_PIX_FMT_YUV420P, sws_flags, NULL, NULL, NULL);
1799         if (!is->img_convert_ctx) {
1800             av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
1801             exit(1);
1802         }
1803         sws_scale(is->img_convert_ctx, src_frame->data, src_frame->linesize,
1804                   0, vp->height, data, linesize);
1805 #endif
1806         /* workaround SDL PITCH_WORKAROUND */
1807         duplicate_right_border_pixels(vp->bmp);
1808         /* update the bitmap content */
1809         SDL_UnlockYUVOverlay(vp->bmp);
1810
1811         vp->pts = pts;
1812         vp->duration = duration;
1813         vp->pos = pos;
1814         vp->serial = serial;
1815
1816         /* now we can update the picture count */
1817         frame_queue_push(&is->pictq);
1818     }
1819     return 0;
1820 }
1821
1822 static int get_video_frame(VideoState *is, AVFrame *frame)
1823 {
1824     int got_picture;
1825
1826     if ((got_picture = decoder_decode_frame(&is->viddec, frame, NULL)) < 0)
1827         return -1;
1828
1829     if (got_picture) {
1830         double dpts = NAN;
1831
1832         if (frame->pts != AV_NOPTS_VALUE)
1833             dpts = av_q2d(is->video_st->time_base) * frame->pts;
1834
1835         frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
1836
1837         is->viddec_width  = frame->width;
1838         is->viddec_height = frame->height;
1839
1840         if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
1841             if (frame->pts != AV_NOPTS_VALUE) {
1842                 double diff = dpts - get_master_clock(is);
1843                 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD &&
1844                     diff - is->frame_last_filter_delay < 0 &&
1845                     is->viddec.pkt_serial == is->vidclk.serial &&
1846                     is->videoq.nb_packets) {
1847                     is->frame_drops_early++;
1848                     av_frame_unref(frame);
1849                     got_picture = 0;
1850                 }
1851             }
1852         }
1853     }
1854
1855     return got_picture;
1856 }
1857
1858 #if CONFIG_AVFILTER
1859 static int configure_filtergraph(AVFilterGraph *graph, const char *filtergraph,
1860                                  AVFilterContext *source_ctx, AVFilterContext *sink_ctx)
1861 {
1862     int ret, i;
1863     int nb_filters = graph->nb_filters;
1864     AVFilterInOut *outputs = NULL, *inputs = NULL;
1865
1866     if (filtergraph) {
1867         outputs = avfilter_inout_alloc();
1868         inputs  = avfilter_inout_alloc();
1869         if (!outputs || !inputs) {
1870             ret = AVERROR(ENOMEM);
1871             goto fail;
1872         }
1873
1874         outputs->name       = av_strdup("in");
1875         outputs->filter_ctx = source_ctx;
1876         outputs->pad_idx    = 0;
1877         outputs->next       = NULL;
1878
1879         inputs->name        = av_strdup("out");
1880         inputs->filter_ctx  = sink_ctx;
1881         inputs->pad_idx     = 0;
1882         inputs->next        = NULL;
1883
1884         if ((ret = avfilter_graph_parse_ptr(graph, filtergraph, &inputs, &outputs, NULL)) < 0)
1885             goto fail;
1886     } else {
1887         if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
1888             goto fail;
1889     }
1890
1891     /* Reorder the filters to ensure that inputs of the custom filters are merged first */
1892     for (i = 0; i < graph->nb_filters - nb_filters; i++)
1893         FFSWAP(AVFilterContext*, graph->filters[i], graph->filters[i + nb_filters]);
1894
1895     ret = avfilter_graph_config(graph, NULL);
1896 fail:
1897     avfilter_inout_free(&outputs);
1898     avfilter_inout_free(&inputs);
1899     return ret;
1900 }
1901
1902 static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const char *vfilters, AVFrame *frame)
1903 {
1904     static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
1905     char sws_flags_str[512] = "";
1906     char buffersrc_args[256];
1907     int ret;
1908     AVFilterContext *filt_src = NULL, *filt_out = NULL, *head_filter, *last_filter = NULL;
1909     AVCodecContext *codec = is->video_st->codec;
1910     AVRational fr = av_guess_frame_rate(is->ic, is->video_st, NULL);
1911     AVDictionaryEntry *e = NULL;
1912
1913     while ((e = av_dict_get(sws_dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
1914         if (!strcmp(e->key, "sws_flags")) {
1915             av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", "flags", e->value);
1916         } else
1917             av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", e->key, e->value);
1918     }
1919     if (strlen(sws_flags_str))
1920         sws_flags_str[strlen(sws_flags_str)-1] = '\0';
1921
1922     graph->scale_sws_opts = av_strdup(sws_flags_str);
1923
1924     snprintf(buffersrc_args, sizeof(buffersrc_args),
1925              "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
1926              frame->width, frame->height, frame->format,
1927              is->video_st->time_base.num, is->video_st->time_base.den,
1928              codec->sample_aspect_ratio.num, FFMAX(codec->sample_aspect_ratio.den, 1));
1929     if (fr.num && fr.den)
1930         av_strlcatf(buffersrc_args, sizeof(buffersrc_args), ":frame_rate=%d/%d", fr.num, fr.den);
1931
1932     if ((ret = avfilter_graph_create_filter(&filt_src,
1933                                             avfilter_get_by_name("buffer"),
1934                                             "ffplay_buffer", buffersrc_args, NULL,
1935                                             graph)) < 0)
1936         goto fail;
1937
1938     ret = avfilter_graph_create_filter(&filt_out,
1939                                        avfilter_get_by_name("buffersink"),
1940                                        "ffplay_buffersink", NULL, NULL, graph);
1941     if (ret < 0)
1942         goto fail;
1943
1944     if ((ret = av_opt_set_int_list(filt_out, "pix_fmts", pix_fmts,  AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1945         goto fail;
1946
1947     last_filter = filt_out;
1948     head_filter = filt_src;
1949
1950 /* Note: this macro adds a filter before the lastly added filter, so the
1951  * processing order of the filters is in reverse */
1952 #define INSERT_FILT(name, arg) do {                                          \
1953     AVFilterContext *filt_ctx;                                               \
1954                                                                              \
1955     ret = avfilter_graph_create_filter(&filt_ctx,                            \
1956                                        avfilter_get_by_name(name),           \
1957                                        "ffplay_" name, arg, NULL, graph);    \
1958     if (ret < 0)                                                             \
1959         goto fail;                                                           \
1960                                                                              \
1961     ret = avfilter_link(head_filter, 0, filt_ctx, 0);                        \
1962     if (ret < 0)                                                             \
1963         goto fail;                                                           \
1964                                                                              \
1965     head_filter = filt_ctx;                                                  \
1966 } while (0)
1967
1968     /* SDL YUV code is not handling odd width/height for some driver
1969      * combinations, therefore we crop the picture to an even width/height. */
1970     INSERT_FILT("crop", "floor(in_w/2)*2:floor(in_h/2)*2");
1971
1972     if (autorotate) {
1973         double theta  = get_rotation(is->video_st);
1974
1975         if (fabs(theta - 90) < 1.0) {
1976             INSERT_FILT("transpose", "clock");
1977         } else if (fabs(theta - 180) < 1.0) {
1978             INSERT_FILT("hflip", NULL);
1979             INSERT_FILT("vflip", NULL);
1980         } else if (fabs(theta - 270) < 1.0) {
1981             INSERT_FILT("transpose", "cclock");
1982         } else if (fabs(theta) > 1.0) {
1983             char rotate_buf[64];
1984             snprintf(rotate_buf, sizeof(rotate_buf), "%f*PI/180", theta);
1985             INSERT_FILT("rotate", rotate_buf);
1986         }
1987     }
1988
1989     if ((ret = configure_filtergraph(graph, vfilters, head_filter, last_filter)) < 0)
1990         goto fail;
1991
1992     is->in_video_filter  = filt_src;
1993     is->out_video_filter = filt_out;
1994
1995 fail:
1996     return ret;
1997 }
1998
1999 static int configure_audio_filters(VideoState *is, const char *afilters, int force_output_format)
2000 {
2001     static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
2002     int sample_rates[2] = { 0, -1 };
2003     int64_t channel_layouts[2] = { 0, -1 };
2004     int channels[2] = { 0, -1 };
2005     AVFilterContext *filt_asrc = NULL, *filt_asink = NULL;
2006     char aresample_swr_opts[512] = "";
2007     AVDictionaryEntry *e = NULL;
2008     char asrc_args[256];
2009     int ret;
2010
2011     avfilter_graph_free(&is->agraph);
2012     if (!(is->agraph = avfilter_graph_alloc()))
2013         return AVERROR(ENOMEM);
2014
2015     while ((e = av_dict_get(swr_opts, "", e, AV_DICT_IGNORE_SUFFIX)))
2016         av_strlcatf(aresample_swr_opts, sizeof(aresample_swr_opts), "%s=%s:", e->key, e->value);
2017     if (strlen(aresample_swr_opts))
2018         aresample_swr_opts[strlen(aresample_swr_opts)-1] = '\0';
2019     av_opt_set(is->agraph, "aresample_swr_opts", aresample_swr_opts, 0);
2020
2021     ret = snprintf(asrc_args, sizeof(asrc_args),
2022                    "sample_rate=%d:sample_fmt=%s:channels=%d:time_base=%d/%d",
2023                    is->audio_filter_src.freq, av_get_sample_fmt_name(is->audio_filter_src.fmt),
2024                    is->audio_filter_src.channels,
2025                    1, is->audio_filter_src.freq);
2026     if (is->audio_filter_src.channel_layout)
2027         snprintf(asrc_args + ret, sizeof(asrc_args) - ret,
2028                  ":channel_layout=0x%"PRIx64,  is->audio_filter_src.channel_layout);
2029
2030     ret = avfilter_graph_create_filter(&filt_asrc,
2031                                        avfilter_get_by_name("abuffer"), "ffplay_abuffer",
2032                                        asrc_args, NULL, is->agraph);
2033     if (ret < 0)
2034         goto end;
2035
2036
2037     ret = avfilter_graph_create_filter(&filt_asink,
2038                                        avfilter_get_by_name("abuffersink"), "ffplay_abuffersink",
2039                                        NULL, NULL, is->agraph);
2040     if (ret < 0)
2041         goto end;
2042
2043     if ((ret = av_opt_set_int_list(filt_asink, "sample_fmts", sample_fmts,  AV_SAMPLE_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
2044         goto end;
2045     if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 1, AV_OPT_SEARCH_CHILDREN)) < 0)
2046         goto end;
2047
2048     if (force_output_format) {
2049         channel_layouts[0] = is->audio_tgt.channel_layout;
2050         channels       [0] = is->audio_tgt.channels;
2051         sample_rates   [0] = is->audio_tgt.freq;
2052         if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 0, AV_OPT_SEARCH_CHILDREN)) < 0)
2053             goto end;
2054         if ((ret = av_opt_set_int_list(filt_asink, "channel_layouts", channel_layouts,  -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2055             goto end;
2056         if ((ret = av_opt_set_int_list(filt_asink, "channel_counts" , channels       ,  -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2057             goto end;
2058         if ((ret = av_opt_set_int_list(filt_asink, "sample_rates"   , sample_rates   ,  -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2059             goto end;
2060     }
2061
2062
2063     if ((ret = configure_filtergraph(is->agraph, afilters, filt_asrc, filt_asink)) < 0)
2064         goto end;
2065
2066     is->in_audio_filter  = filt_asrc;
2067     is->out_audio_filter = filt_asink;
2068
2069 end:
2070     if (ret < 0)
2071         avfilter_graph_free(&is->agraph);
2072     return ret;
2073 }
2074 #endif  /* CONFIG_AVFILTER */
2075
2076 static int audio_thread(void *arg)
2077 {
2078     VideoState *is = arg;
2079     AVFrame *frame = av_frame_alloc();
2080     Frame *af;
2081 #if CONFIG_AVFILTER
2082     int last_serial = -1;
2083     int64_t dec_channel_layout;
2084     int reconfigure;
2085 #endif
2086     int got_frame = 0;
2087     AVRational tb;
2088     int ret = 0;
2089
2090     if (!frame)
2091         return AVERROR(ENOMEM);
2092
2093     do {
2094         if ((got_frame = decoder_decode_frame(&is->auddec, frame, NULL)) < 0)
2095             goto the_end;
2096
2097         if (got_frame) {
2098                 tb = (AVRational){1, frame->sample_rate};
2099
2100 #if CONFIG_AVFILTER
2101                 dec_channel_layout = get_valid_channel_layout(frame->channel_layout, av_frame_get_channels(frame));
2102
2103                 reconfigure =
2104                     cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
2105                                    frame->format, av_frame_get_channels(frame))    ||
2106                     is->audio_filter_src.channel_layout != dec_channel_layout ||
2107                     is->audio_filter_src.freq           != frame->sample_rate ||
2108                     is->auddec.pkt_serial               != last_serial;
2109
2110                 if (reconfigure) {
2111                     char buf1[1024], buf2[1024];
2112                     av_get_channel_layout_string(buf1, sizeof(buf1), -1, is->audio_filter_src.channel_layout);
2113                     av_get_channel_layout_string(buf2, sizeof(buf2), -1, dec_channel_layout);
2114                     av_log(NULL, AV_LOG_DEBUG,
2115                            "Audio frame changed from rate:%d ch:%d fmt:%s layout:%s serial:%d to rate:%d ch:%d fmt:%s layout:%s serial:%d\n",
2116                            is->audio_filter_src.freq, is->audio_filter_src.channels, av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, last_serial,
2117                            frame->sample_rate, av_frame_get_channels(frame), av_get_sample_fmt_name(frame->format), buf2, is->auddec.pkt_serial);
2118
2119                     is->audio_filter_src.fmt            = frame->format;
2120                     is->audio_filter_src.channels       = av_frame_get_channels(frame);
2121                     is->audio_filter_src.channel_layout = dec_channel_layout;
2122                     is->audio_filter_src.freq           = frame->sample_rate;
2123                     last_serial                         = is->auddec.pkt_serial;
2124
2125                     if ((ret = configure_audio_filters(is, afilters, 1)) < 0)
2126                         goto the_end;
2127                 }
2128
2129             if ((ret = av_buffersrc_add_frame(is->in_audio_filter, frame)) < 0)
2130                 goto the_end;
2131
2132             while ((ret = av_buffersink_get_frame_flags(is->out_audio_filter, frame, 0)) >= 0) {
2133                 tb = is->out_audio_filter->inputs[0]->time_base;
2134 #endif
2135                 if (!(af = frame_queue_peek_writable(&is->sampq)))
2136                     goto the_end;
2137
2138                 af->pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2139                 af->pos = av_frame_get_pkt_pos(frame);
2140                 af->serial = is->auddec.pkt_serial;
2141                 af->duration = av_q2d((AVRational){frame->nb_samples, frame->sample_rate});
2142
2143                 av_frame_move_ref(af->frame, frame);
2144                 frame_queue_push(&is->sampq);
2145
2146 #if CONFIG_AVFILTER
2147                 if (is->audioq.serial != is->auddec.pkt_serial)
2148                     break;
2149             }
2150             if (ret == AVERROR_EOF)
2151                 is->auddec.finished = is->auddec.pkt_serial;
2152 #endif
2153         }
2154     } while (ret >= 0 || ret == AVERROR(EAGAIN) || ret == AVERROR_EOF);
2155  the_end:
2156 #if CONFIG_AVFILTER
2157     avfilter_graph_free(&is->agraph);
2158 #endif
2159     av_frame_free(&frame);
2160     return ret;
2161 }
2162
2163 static int decoder_start(Decoder *d, int (*fn)(void *), void *arg)
2164 {
2165     packet_queue_start(d->queue);
2166     d->decoder_tid = SDL_CreateThread(fn, arg);
2167     if (!d->decoder_tid) {
2168         av_log(NULL, AV_LOG_ERROR, "SDL_CreateThread(): %s\n", SDL_GetError());
2169         return AVERROR(ENOMEM);
2170     }
2171     return 0;
2172 }
2173
2174 static int video_thread(void *arg)
2175 {
2176     VideoState *is = arg;
2177     AVFrame *frame = av_frame_alloc();
2178     double pts;
2179     double duration;
2180     int ret;
2181     AVRational tb = is->video_st->time_base;
2182     AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);
2183
2184 #if CONFIG_AVFILTER
2185     AVFilterGraph *graph = avfilter_graph_alloc();
2186     AVFilterContext *filt_out = NULL, *filt_in = NULL;
2187     int last_w = 0;
2188     int last_h = 0;
2189     enum AVPixelFormat last_format = -2;
2190     int last_serial = -1;
2191     int last_vfilter_idx = 0;
2192     if (!graph) {
2193         av_frame_free(&frame);
2194         return AVERROR(ENOMEM);
2195     }
2196
2197 #endif
2198
2199     if (!frame) {
2200 #if CONFIG_AVFILTER
2201         avfilter_graph_free(&graph);
2202 #endif
2203         return AVERROR(ENOMEM);
2204     }
2205
2206     for (;;) {
2207         ret = get_video_frame(is, frame);
2208         if (ret < 0)
2209             goto the_end;
2210         if (!ret)
2211             continue;
2212
2213 #if CONFIG_AVFILTER
2214         if (   last_w != frame->width
2215             || last_h != frame->height
2216             || last_format != frame->format
2217             || last_serial != is->viddec.pkt_serial
2218             || last_vfilter_idx != is->vfilter_idx) {
2219             av_log(NULL, AV_LOG_DEBUG,
2220                    "Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
2221                    last_w, last_h,
2222                    (const char *)av_x_if_null(av_get_pix_fmt_name(last_format), "none"), last_serial,
2223                    frame->width, frame->height,
2224                    (const char *)av_x_if_null(av_get_pix_fmt_name(frame->format), "none"), is->viddec.pkt_serial);
2225             avfilter_graph_free(&graph);
2226             graph = avfilter_graph_alloc();
2227             if ((ret = configure_video_filters(graph, is, vfilters_list ? vfilters_list[is->vfilter_idx] : NULL, frame)) < 0) {
2228                 SDL_Event event;
2229                 event.type = FF_QUIT_EVENT;
2230                 event.user.data1 = is;
2231                 SDL_PushEvent(&event);
2232                 goto the_end;
2233             }
2234             filt_in  = is->in_video_filter;
2235             filt_out = is->out_video_filter;
2236             last_w = frame->width;
2237             last_h = frame->height;
2238             last_format = frame->format;
2239             last_serial = is->viddec.pkt_serial;
2240             last_vfilter_idx = is->vfilter_idx;
2241             frame_rate = filt_out->inputs[0]->frame_rate;
2242         }
2243
2244         ret = av_buffersrc_add_frame(filt_in, frame);
2245         if (ret < 0)
2246             goto the_end;
2247
2248         while (ret >= 0) {
2249             is->frame_last_returned_time = av_gettime_relative() / 1000000.0;
2250
2251             ret = av_buffersink_get_frame_flags(filt_out, frame, 0);
2252             if (ret < 0) {
2253                 if (ret == AVERROR_EOF)
2254                     is->viddec.finished = is->viddec.pkt_serial;
2255                 ret = 0;
2256                 break;
2257             }
2258
2259             is->frame_last_filter_delay = av_gettime_relative() / 1000000.0 - is->frame_last_returned_time;
2260             if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
2261                 is->frame_last_filter_delay = 0;
2262             tb = filt_out->inputs[0]->time_base;
2263 #endif
2264             duration = (frame_rate.num && frame_rate.den ? av_q2d((AVRational){frame_rate.den, frame_rate.num}) : 0);
2265             pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2266             ret = queue_picture(is, frame, pts, duration, av_frame_get_pkt_pos(frame), is->viddec.pkt_serial);
2267             av_frame_unref(frame);
2268 #if CONFIG_AVFILTER
2269         }
2270 #endif
2271
2272         if (ret < 0)
2273             goto the_end;
2274     }
2275  the_end:
2276 #if CONFIG_AVFILTER
2277     avfilter_graph_free(&graph);
2278 #endif
2279     av_frame_free(&frame);
2280     return 0;
2281 }
2282
2283 static int subtitle_thread(void *arg)
2284 {
2285     VideoState *is = arg;
2286     Frame *sp;
2287     int got_subtitle;
2288     double pts;
2289     int i;
2290
2291     for (;;) {
2292         if (!(sp = frame_queue_peek_writable(&is->subpq)))
2293             return 0;
2294
2295         if ((got_subtitle = decoder_decode_frame(&is->subdec, NULL, &sp->sub)) < 0)
2296             break;
2297
2298         pts = 0;
2299
2300         if (got_subtitle && sp->sub.format == 0) {
2301             if (sp->sub.pts != AV_NOPTS_VALUE)
2302                 pts = sp->sub.pts / (double)AV_TIME_BASE;
2303             sp->pts = pts;
2304             sp->serial = is->subdec.pkt_serial;
2305             if (!(sp->subrects = av_mallocz_array(sp->sub.num_rects, sizeof(AVSubtitleRect*)))) {
2306                 av_log(NULL, AV_LOG_FATAL, "Cannot allocate subrects\n");
2307                 exit(1);
2308             }
2309
2310             for (i = 0; i < sp->sub.num_rects; i++)
2311             {
2312                 int in_w = sp->sub.rects[i]->w;
2313                 int in_h = sp->sub.rects[i]->h;
2314                 int subw = is->subdec.avctx->width  ? is->subdec.avctx->width  : is->viddec_width;
2315                 int subh = is->subdec.avctx->height ? is->subdec.avctx->height : is->viddec_height;
2316                 int out_w = is->viddec_width  ? in_w * is->viddec_width  / subw : in_w;
2317                 int out_h = is->viddec_height ? in_h * is->viddec_height / subh : in_h;
2318
2319                 if (!(sp->subrects[i] = av_mallocz(sizeof(AVSubtitleRect))) ||
2320                     av_image_alloc(sp->subrects[i]->data, sp->subrects[i]->linesize, out_w, out_h, AV_PIX_FMT_YUVA420P, 16) < 0) {
2321                     av_log(NULL, AV_LOG_FATAL, "Cannot allocate subtitle data\n");
2322                     exit(1);
2323                 }
2324
2325                 is->sub_convert_ctx = sws_getCachedContext(is->sub_convert_ctx,
2326                     in_w, in_h, AV_PIX_FMT_PAL8, out_w, out_h,
2327                     AV_PIX_FMT_YUVA420P, sws_flags, NULL, NULL, NULL);
2328                 if (!is->sub_convert_ctx) {
2329                     av_log(NULL, AV_LOG_FATAL, "Cannot initialize the sub conversion context\n");
2330                     exit(1);
2331                 }
2332                 sws_scale(is->sub_convert_ctx,
2333                           (void*)sp->sub.rects[i]->data, sp->sub.rects[i]->linesize,
2334                           0, in_h, sp->subrects[i]->data, sp->subrects[i]->linesize);
2335
2336                 sp->subrects[i]->w = out_w;
2337                 sp->subrects[i]->h = out_h;
2338                 sp->subrects[i]->x = sp->sub.rects[i]->x * out_w / in_w;
2339                 sp->subrects[i]->y = sp->sub.rects[i]->y * out_h / in_h;
2340             }
2341
2342             /* now we can update the picture count */
2343             frame_queue_push(&is->subpq);
2344         } else if (got_subtitle) {
2345             avsubtitle_free(&sp->sub);
2346         }
2347     }
2348     return 0;
2349 }
2350
2351 /* copy samples for viewing in editor window */
2352 static void update_sample_display(VideoState *is, short *samples, int samples_size)
2353 {
2354     int size, len;
2355
2356     size = samples_size / sizeof(short);
2357     while (size > 0) {
2358         len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
2359         if (len > size)
2360             len = size;
2361         memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
2362         samples += len;
2363         is->sample_array_index += len;
2364         if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
2365             is->sample_array_index = 0;
2366         size -= len;
2367     }
2368 }
2369
2370 /* return the wanted number of samples to get better sync if sync_type is video
2371  * or external master clock */
2372 static int synchronize_audio(VideoState *is, int nb_samples)
2373 {
2374     int wanted_nb_samples = nb_samples;
2375
2376     /* if not master, then we try to remove or add samples to correct the clock */
2377     if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
2378         double diff, avg_diff;
2379         int min_nb_samples, max_nb_samples;
2380
2381         diff = get_clock(&is->audclk) - get_master_clock(is);
2382
2383         if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD) {
2384             is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
2385             if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
2386                 /* not enough measures to have a correct estimate */
2387                 is->audio_diff_avg_count++;
2388             } else {
2389                 /* estimate the A-V difference */
2390                 avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
2391
2392                 if (fabs(avg_diff) >= is->audio_diff_threshold) {
2393                     wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);
2394                     min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2395                     max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2396                     wanted_nb_samples = av_clip(wanted_nb_samples, min_nb_samples, max_nb_samples);
2397                 }
2398                 av_log(NULL, AV_LOG_TRACE, "diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
2399                         diff, avg_diff, wanted_nb_samples - nb_samples,
2400                         is->audio_clock, is->audio_diff_threshold);
2401             }
2402         } else {
2403             /* too big difference : may be initial PTS errors, so
2404                reset A-V filter */
2405             is->audio_diff_avg_count = 0;
2406             is->audio_diff_cum       = 0;
2407         }
2408     }
2409
2410     return wanted_nb_samples;
2411 }
2412
2413 /**
2414  * Decode one audio frame and return its uncompressed size.
2415  *
2416  * The processed audio frame is decoded, converted if required, and
2417  * stored in is->audio_buf, with size in bytes given by the return
2418  * value.
2419  */
2420 static int audio_decode_frame(VideoState *is)
2421 {
2422     int data_size, resampled_data_size;
2423     int64_t dec_channel_layout;
2424     av_unused double audio_clock0;
2425     int wanted_nb_samples;
2426     Frame *af;
2427
2428     if (is->paused)
2429         return -1;
2430
2431     do {
2432 #if defined(_WIN32)
2433         while (frame_queue_nb_remaining(&is->sampq) == 0) {
2434             if ((av_gettime_relative() - audio_callback_time) > 1000000LL * is->audio_hw_buf_size / is->audio_tgt.bytes_per_sec / 2)
2435                 return -1;
2436             av_usleep (1000);
2437         }
2438 #endif
2439         if (!(af = frame_queue_peek_readable(&is->sampq)))
2440             return -1;
2441         frame_queue_next(&is->sampq);
2442     } while (af->serial != is->audioq.serial);
2443
2444     data_size = av_samples_get_buffer_size(NULL, av_frame_get_channels(af->frame),
2445                                            af->frame->nb_samples,
2446                                            af->frame->format, 1);
2447
2448     dec_channel_layout =
2449         (af->frame->channel_layout && av_frame_get_channels(af->frame) == av_get_channel_layout_nb_channels(af->frame->channel_layout)) ?
2450         af->frame->channel_layout : av_get_default_channel_layout(av_frame_get_channels(af->frame));
2451     wanted_nb_samples = synchronize_audio(is, af->frame->nb_samples);
2452
2453     if (af->frame->format        != is->audio_src.fmt            ||
2454         dec_channel_layout       != is->audio_src.channel_layout ||
2455         af->frame->sample_rate   != is->audio_src.freq           ||
2456         (wanted_nb_samples       != af->frame->nb_samples && !is->swr_ctx)) {
2457         swr_free(&is->swr_ctx);
2458         is->swr_ctx = swr_alloc_set_opts(NULL,
2459                                          is->audio_tgt.channel_layout, is->audio_tgt.fmt, is->audio_tgt.freq,
2460                                          dec_channel_layout,           af->frame->format, af->frame->sample_rate,
2461                                          0, NULL);
2462         if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
2463             av_log(NULL, AV_LOG_ERROR,
2464                    "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
2465                     af->frame->sample_rate, av_get_sample_fmt_name(af->frame->format), av_frame_get_channels(af->frame),
2466                     is->audio_tgt.freq, av_get_sample_fmt_name(is->audio_tgt.fmt), is->audio_tgt.channels);
2467             swr_free(&is->swr_ctx);
2468             return -1;
2469         }
2470         is->audio_src.channel_layout = dec_channel_layout;
2471         is->audio_src.channels       = av_frame_get_channels(af->frame);
2472         is->audio_src.freq = af->frame->sample_rate;
2473         is->audio_src.fmt = af->frame->format;
2474     }
2475
2476     if (is->swr_ctx) {
2477         const uint8_t **in = (const uint8_t **)af->frame->extended_data;
2478         uint8_t **out = &is->audio_buf1;
2479         int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate + 256;
2480         int out_size  = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, out_count, is->audio_tgt.fmt, 0);
2481         int len2;
2482         if (out_size < 0) {
2483             av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size() failed\n");
2484             return -1;
2485         }
2486         if (wanted_nb_samples != af->frame->nb_samples) {
2487             if (swr_set_compensation(is->swr_ctx, (wanted_nb_samples - af->frame->nb_samples) * is->audio_tgt.freq / af->frame->sample_rate,
2488                                         wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate) < 0) {
2489                 av_log(NULL, AV_LOG_ERROR, "swr_set_compensation() failed\n");
2490                 return -1;
2491             }
2492         }
2493         av_fast_malloc(&is->audio_buf1, &is->audio_buf1_size, out_size);
2494         if (!is->audio_buf1)
2495             return AVERROR(ENOMEM);
2496         len2 = swr_convert(is->swr_ctx, out, out_count, in, af->frame->nb_samples);
2497         if (len2 < 0) {
2498             av_log(NULL, AV_LOG_ERROR, "swr_convert() failed\n");
2499             return -1;
2500         }
2501         if (len2 == out_count) {
2502             av_log(NULL, AV_LOG_WARNING, "audio buffer is probably too small\n");
2503             if (swr_init(is->swr_ctx) < 0)
2504                 swr_free(&is->swr_ctx);
2505         }
2506         is->audio_buf = is->audio_buf1;
2507         resampled_data_size = len2 * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2508     } else {
2509         is->audio_buf = af->frame->data[0];
2510         resampled_data_size = data_size;
2511     }
2512
2513     audio_clock0 = is->audio_clock;
2514     /* update the audio clock with the pts */
2515     if (!isnan(af->pts))
2516         is->audio_clock = af->pts + (double) af->frame->nb_samples / af->frame->sample_rate;
2517     else
2518         is->audio_clock = NAN;
2519     is->audio_clock_serial = af->serial;
2520 #ifdef DEBUG
2521     {
2522         static double last_clock;
2523         printf("audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
2524                is->audio_clock - last_clock,
2525                is->audio_clock, audio_clock0);
2526         last_clock = is->audio_clock;
2527     }
2528 #endif
2529     return resampled_data_size;
2530 }
2531
2532 /* prepare a new audio buffer */
2533 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
2534 {
2535     VideoState *is = opaque;
2536     int audio_size, len1;
2537
2538     audio_callback_time = av_gettime_relative();
2539
2540     while (len > 0) {
2541         if (is->audio_buf_index >= is->audio_buf_size) {
2542            audio_size = audio_decode_frame(is);
2543            if (audio_size < 0) {
2544                 /* if error, just output silence */
2545                is->audio_buf      = is->silence_buf;
2546                is->audio_buf_size = sizeof(is->silence_buf) / is->audio_tgt.frame_size * is->audio_tgt.frame_size;
2547            } else {
2548                if (is->show_mode != SHOW_MODE_VIDEO)
2549                    update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
2550                is->audio_buf_size = audio_size;
2551            }
2552            is->audio_buf_index = 0;
2553         }
2554         len1 = is->audio_buf_size - is->audio_buf_index;
2555         if (len1 > len)
2556             len1 = len;
2557         if (!is->muted && is->audio_volume == SDL_MIX_MAXVOLUME)
2558             memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
2559         else {
2560             memset(stream, is->silence_buf[0], len1);
2561             if (!is->muted)
2562                 SDL_MixAudio(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1, is->audio_volume);
2563         }
2564         len -= len1;
2565         stream += len1;
2566         is->audio_buf_index += len1;
2567     }
2568     is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
2569     /* Let's assume the audio driver that is used by SDL has two periods. */
2570     if (!isnan(is->audio_clock)) {
2571         set_clock_at(&is->audclk, is->audio_clock - (double)(2 * is->audio_hw_buf_size + is->audio_write_buf_size) / is->audio_tgt.bytes_per_sec, is->audio_clock_serial, audio_callback_time / 1000000.0);
2572         sync_clock_to_slave(&is->extclk, &is->audclk);
2573     }
2574 }
2575
2576 static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
2577 {
2578     SDL_AudioSpec wanted_spec, spec;
2579     const char *env;
2580     static const int next_nb_channels[] = {0, 0, 1, 6, 2, 6, 4, 6};
2581     static const int next_sample_rates[] = {0, 44100, 48000, 96000, 192000};
2582     int next_sample_rate_idx = FF_ARRAY_ELEMS(next_sample_rates) - 1;
2583
2584     env = SDL_getenv("SDL_AUDIO_CHANNELS");
2585     if (env) {
2586         wanted_nb_channels = atoi(env);
2587         wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2588     }
2589     if (!wanted_channel_layout || wanted_nb_channels != av_get_channel_layout_nb_channels(wanted_channel_layout)) {
2590         wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2591         wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
2592     }
2593     wanted_nb_channels = av_get_channel_layout_nb_channels(wanted_channel_layout);
2594     wanted_spec.channels = wanted_nb_channels;
2595     wanted_spec.freq = wanted_sample_rate;
2596     if (wanted_spec.freq <= 0 || wanted_spec.channels <= 0) {
2597         av_log(NULL, AV_LOG_ERROR, "Invalid sample rate or channel count!\n");
2598         return -1;
2599     }
2600     while (next_sample_rate_idx && next_sample_rates[next_sample_rate_idx] >= wanted_spec.freq)
2601         next_sample_rate_idx--;
2602     wanted_spec.format = AUDIO_S16SYS;
2603     wanted_spec.silence = 0;
2604     wanted_spec.samples = FFMAX(SDL_AUDIO_MIN_BUFFER_SIZE, 2 << av_log2(wanted_spec.freq / SDL_AUDIO_MAX_CALLBACKS_PER_SEC));
2605     wanted_spec.callback = sdl_audio_callback;
2606     wanted_spec.userdata = opaque;
2607     while (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
2608         av_log(NULL, AV_LOG_WARNING, "SDL_OpenAudio (%d channels, %d Hz): %s\n",
2609                wanted_spec.channels, wanted_spec.freq, SDL_GetError());
2610         wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
2611         if (!wanted_spec.channels) {
2612             wanted_spec.freq = next_sample_rates[next_sample_rate_idx--];
2613             wanted_spec.channels = wanted_nb_channels;
2614             if (!wanted_spec.freq) {
2615                 av_log(NULL, AV_LOG_ERROR,
2616                        "No more combinations to try, audio open failed\n");
2617                 return -1;
2618             }
2619         }
2620         wanted_channel_layout = av_get_default_channel_layout(wanted_spec.channels);
2621     }
2622     if (spec.format != AUDIO_S16SYS) {
2623         av_log(NULL, AV_LOG_ERROR,
2624                "SDL advised audio format %d is not supported!\n", spec.format);
2625         return -1;
2626     }
2627     if (spec.channels != wanted_spec.channels) {
2628         wanted_channel_layout = av_get_default_channel_layout(spec.channels);
2629         if (!wanted_channel_layout) {
2630             av_log(NULL, AV_LOG_ERROR,
2631                    "SDL advised channel count %d is not supported!\n", spec.channels);
2632             return -1;
2633         }
2634     }
2635
2636     audio_hw_params->fmt = AV_SAMPLE_FMT_S16;
2637     audio_hw_params->freq = spec.freq;
2638     audio_hw_params->channel_layout = wanted_channel_layout;
2639     audio_hw_params->channels =  spec.channels;
2640     audio_hw_params->frame_size = av_samples_get_buffer_size(NULL, audio_hw_params->channels, 1, audio_hw_params->fmt, 1);
2641     audio_hw_params->bytes_per_sec = av_samples_get_buffer_size(NULL, audio_hw_params->channels, audio_hw_params->freq, audio_hw_params->fmt, 1);
2642     if (audio_hw_params->bytes_per_sec <= 0 || audio_hw_params->frame_size <= 0) {
2643         av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size failed\n");
2644         return -1;
2645     }
2646     return spec.size;
2647 }
2648
2649 /* open a given stream. Return 0 if OK */
2650 static int stream_component_open(VideoState *is, int stream_index)
2651 {
2652     AVFormatContext *ic = is->ic;
2653     AVCodecContext *avctx;
2654     AVCodec *codec;
2655     const char *forced_codec_name = NULL;
2656     AVDictionary *opts;
2657     AVDictionaryEntry *t = NULL;
2658     int sample_rate, nb_channels;
2659     int64_t channel_layout;
2660     int ret = 0;
2661     int stream_lowres = lowres;
2662
2663     if (stream_index < 0 || stream_index >= ic->nb_streams)
2664         return -1;
2665     avctx = ic->streams[stream_index]->codec;
2666
2667     codec = avcodec_find_decoder(avctx->codec_id);
2668
2669     switch(avctx->codec_type){
2670         case AVMEDIA_TYPE_AUDIO   : is->last_audio_stream    = stream_index; forced_codec_name =    audio_codec_name; break;
2671         case AVMEDIA_TYPE_SUBTITLE: is->last_subtitle_stream = stream_index; forced_codec_name = subtitle_codec_name; break;
2672         case AVMEDIA_TYPE_VIDEO   : is->last_video_stream    = stream_index; forced_codec_name =    video_codec_name; break;
2673     }
2674     if (forced_codec_name)
2675         codec = avcodec_find_decoder_by_name(forced_codec_name);
2676     if (!codec) {
2677         if (forced_codec_name) av_log(NULL, AV_LOG_WARNING,
2678                                       "No codec could be found with name '%s'\n", forced_codec_name);
2679         else                   av_log(NULL, AV_LOG_WARNING,
2680                                       "No codec could be found with id %d\n", avctx->codec_id);
2681         return -1;
2682     }
2683
2684     avctx->codec_id = codec->id;
2685     if(stream_lowres > av_codec_get_max_lowres(codec)){
2686         av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2687                 av_codec_get_max_lowres(codec));
2688         stream_lowres = av_codec_get_max_lowres(codec);
2689     }
2690     av_codec_set_lowres(avctx, stream_lowres);
2691
2692 #if FF_API_EMU_EDGE
2693     if(stream_lowres) avctx->flags |= CODEC_FLAG_EMU_EDGE;
2694 #endif
2695     if (fast)
2696         avctx->flags2 |= AV_CODEC_FLAG2_FAST;
2697 #if FF_API_EMU_EDGE
2698     if(codec->capabilities & AV_CODEC_CAP_DR1)
2699         avctx->flags |= CODEC_FLAG_EMU_EDGE;
2700 #endif
2701
2702     opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
2703     if (!av_dict_get(opts, "threads", NULL, 0))
2704         av_dict_set(&opts, "threads", "auto", 0);
2705     if (stream_lowres)
2706         av_dict_set_int(&opts, "lowres", stream_lowres, 0);
2707     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
2708         av_dict_set(&opts, "refcounted_frames", "1", 0);
2709     if ((ret = avcodec_open2(avctx, codec, &opts)) < 0) {
2710         goto fail;
2711     }
2712     if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2713         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2714         ret =  AVERROR_OPTION_NOT_FOUND;
2715         goto fail;
2716     }
2717
2718     is->eof = 0;
2719     ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
2720     switch (avctx->codec_type) {
2721     case AVMEDIA_TYPE_AUDIO:
2722 #if CONFIG_AVFILTER
2723         {
2724             AVFilterLink *link;
2725
2726             is->audio_filter_src.freq           = avctx->sample_rate;
2727             is->audio_filter_src.channels       = avctx->channels;
2728             is->audio_filter_src.channel_layout = get_valid_channel_layout(avctx->channel_layout, avctx->channels);
2729             is->audio_filter_src.fmt            = avctx->sample_fmt;
2730             if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
2731                 goto fail;
2732             link = is->out_audio_filter->inputs[0];
2733             sample_rate    = link->sample_rate;
2734             nb_channels    = link->channels;
2735             channel_layout = link->channel_layout;
2736         }
2737 #else
2738         sample_rate    = avctx->sample_rate;
2739         nb_channels    = avctx->channels;
2740         channel_layout = avctx->channel_layout;
2741 #endif
2742
2743         /* prepare audio output */
2744         if ((ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)) < 0)
2745             goto fail;
2746         is->audio_hw_buf_size = ret;
2747         is->audio_src = is->audio_tgt;
2748         is->audio_buf_size  = 0;
2749         is->audio_buf_index = 0;
2750
2751         /* init averaging filter */
2752         is->audio_diff_avg_coef  = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
2753         is->audio_diff_avg_count = 0;
2754         /* since we do not have a precise anough audio fifo fullness,
2755            we correct audio sync only if larger than this threshold */
2756         is->audio_diff_threshold = (double)(is->audio_hw_buf_size) / is->audio_tgt.bytes_per_sec;
2757
2758         is->audio_stream = stream_index;
2759         is->audio_st = ic->streams[stream_index];
2760
2761         decoder_init(&is->auddec, avctx, &is->audioq, is->continue_read_thread);
2762         if ((is->ic->iformat->flags & (AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH | AVFMT_NO_BYTE_SEEK)) && !is->ic->iformat->read_seek) {
2763             is->auddec.start_pts = is->audio_st->start_time;
2764             is->auddec.start_pts_tb = is->audio_st->time_base;
2765         }
2766         if ((ret = decoder_start(&is->auddec, audio_thread, is)) < 0)
2767             goto fail;
2768         SDL_PauseAudio(0);
2769         break;
2770     case AVMEDIA_TYPE_VIDEO:
2771         is->video_stream = stream_index;
2772         is->video_st = ic->streams[stream_index];
2773
2774         is->viddec_width  = avctx->width;
2775         is->viddec_height = avctx->height;
2776
2777         decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread);
2778         if ((ret = decoder_start(&is->viddec, video_thread, is)) < 0)
2779             goto fail;
2780         is->queue_attachments_req = 1;
2781         break;
2782     case AVMEDIA_TYPE_SUBTITLE:
2783         is->subtitle_stream = stream_index;
2784         is->subtitle_st = ic->streams[stream_index];
2785
2786         decoder_init(&is->subdec, avctx, &is->subtitleq, is->continue_read_thread);
2787         if ((ret = decoder_start(&is->subdec, subtitle_thread, is)) < 0)
2788             goto fail;
2789         break;
2790     default:
2791         break;
2792     }
2793
2794 fail:
2795     av_dict_free(&opts);
2796
2797     return ret;
2798 }
2799
2800 static int decode_interrupt_cb(void *ctx)
2801 {
2802     VideoState *is = ctx;
2803     return is->abort_request;
2804 }
2805
2806 static int is_realtime(AVFormatContext *s)
2807 {
2808     if(   !strcmp(s->iformat->name, "rtp")
2809        || !strcmp(s->iformat->name, "rtsp")
2810        || !strcmp(s->iformat->name, "sdp")
2811     )
2812         return 1;
2813
2814     if(s->pb && (   !strncmp(s->filename, "rtp:", 4)
2815                  || !strncmp(s->filename, "udp:", 4)
2816                 )
2817     )
2818         return 1;
2819     return 0;
2820 }
2821
2822 /* this thread gets the stream from the disk or the network */
2823 static int read_thread(void *arg)
2824 {
2825     VideoState *is = arg;
2826     AVFormatContext *ic = NULL;
2827     int err, i, ret;
2828     int st_index[AVMEDIA_TYPE_NB];
2829     AVPacket pkt1, *pkt = &pkt1;
2830     int64_t stream_start_time;
2831     int pkt_in_play_range = 0;
2832     AVDictionaryEntry *t;
2833     AVDictionary **opts;
2834     int orig_nb_streams;
2835     SDL_mutex *wait_mutex = SDL_CreateMutex();
2836     int scan_all_pmts_set = 0;
2837     int64_t pkt_ts;
2838
2839     if (!wait_mutex) {
2840         av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
2841         ret = AVERROR(ENOMEM);
2842         goto fail;
2843     }
2844
2845     memset(st_index, -1, sizeof(st_index));
2846     is->last_video_stream = is->video_stream = -1;
2847     is->last_audio_stream = is->audio_stream = -1;
2848     is->last_subtitle_stream = is->subtitle_stream = -1;
2849     is->eof = 0;
2850
2851     ic = avformat_alloc_context();
2852     if (!ic) {
2853         av_log(NULL, AV_LOG_FATAL, "Could not allocate context.\n");
2854         ret = AVERROR(ENOMEM);
2855         goto fail;
2856     }
2857     ic->interrupt_callback.callback = decode_interrupt_cb;
2858     ic->interrupt_callback.opaque = is;
2859     if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
2860         av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
2861         scan_all_pmts_set = 1;
2862     }
2863     err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
2864     if (err < 0) {
2865         print_error(is->filename, err);
2866         ret = -1;
2867         goto fail;
2868     }
2869     if (scan_all_pmts_set)
2870         av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
2871
2872     if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2873         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2874         ret = AVERROR_OPTION_NOT_FOUND;
2875         goto fail;
2876     }
2877     is->ic = ic;
2878
2879     if (genpts)
2880         ic->flags |= AVFMT_FLAG_GENPTS;
2881
2882     av_format_inject_global_side_data(ic);
2883
2884     opts = setup_find_stream_info_opts(ic, codec_opts);
2885     orig_nb_streams = ic->nb_streams;
2886
2887     err = avformat_find_stream_info(ic, opts);
2888
2889     for (i = 0; i < orig_nb_streams; i++)
2890         av_dict_free(&opts[i]);
2891     av_freep(&opts);
2892
2893     if (err < 0) {
2894         av_log(NULL, AV_LOG_WARNING,
2895                "%s: could not find codec parameters\n", is->filename);
2896         ret = -1;
2897         goto fail;
2898     }
2899
2900     if (ic->pb)
2901         ic->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use avio_feof() to test for the end
2902
2903     if (seek_by_bytes < 0)
2904         seek_by_bytes = !!(ic->iformat->flags & AVFMT_TS_DISCONT) && strcmp("ogg", ic->iformat->name);
2905
2906     is->max_frame_duration = (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;
2907
2908     if (!window_title && (t = av_dict_get(ic->metadata, "title", NULL, 0)))
2909         window_title = av_asprintf("%s - %s", t->value, input_filename);
2910
2911     /* if seeking requested, we execute it */
2912     if (start_time != AV_NOPTS_VALUE) {
2913         int64_t timestamp;
2914
2915         timestamp = start_time;
2916         /* add the stream start time */
2917         if (ic->start_time != AV_NOPTS_VALUE)
2918             timestamp += ic->start_time;
2919         ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
2920         if (ret < 0) {
2921             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2922                     is->filename, (double)timestamp / AV_TIME_BASE);
2923         }
2924     }
2925
2926     is->realtime = is_realtime(ic);
2927
2928     if (show_status)
2929         av_dump_format(ic, 0, is->filename, 0);
2930
2931     for (i = 0; i < ic->nb_streams; i++) {
2932         AVStream *st = ic->streams[i];
2933         enum AVMediaType type = st->codec->codec_type;
2934         st->discard = AVDISCARD_ALL;
2935         if (wanted_stream_spec[type] && st_index[type] == -1)
2936             if (avformat_match_stream_specifier(ic, st, wanted_stream_spec[type]) > 0)
2937                 st_index[type] = i;
2938     }
2939     for (i = 0; i < AVMEDIA_TYPE_NB; i++) {
2940         if (wanted_stream_spec[i] && st_index[i] == -1) {
2941             av_log(NULL, AV_LOG_ERROR, "Stream specifier %s does not match any %s stream\n", wanted_stream_spec[i], av_get_media_type_string(i));
2942             st_index[i] = INT_MAX;
2943         }
2944     }
2945
2946     if (!video_disable)
2947         st_index[AVMEDIA_TYPE_VIDEO] =
2948             av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
2949                                 st_index[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
2950     if (!audio_disable)
2951         st_index[AVMEDIA_TYPE_AUDIO] =
2952             av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
2953                                 st_index[AVMEDIA_TYPE_AUDIO],
2954                                 st_index[AVMEDIA_TYPE_VIDEO],
2955                                 NULL, 0);
2956     if (!video_disable && !subtitle_disable)
2957         st_index[AVMEDIA_TYPE_SUBTITLE] =
2958             av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
2959                                 st_index[AVMEDIA_TYPE_SUBTITLE],
2960                                 (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
2961                                  st_index[AVMEDIA_TYPE_AUDIO] :
2962                                  st_index[AVMEDIA_TYPE_VIDEO]),
2963                                 NULL, 0);
2964
2965     is->show_mode = show_mode;
2966     if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2967         AVStream *st = ic->streams[st_index[AVMEDIA_TYPE_VIDEO]];
2968         AVCodecContext *avctx = st->codec;
2969         AVRational sar = av_guess_sample_aspect_ratio(ic, st, NULL);
2970         if (avctx->width)
2971             set_default_window_size(avctx->width, avctx->height, sar);
2972     }
2973
2974     /* open the streams */
2975     if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
2976         stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
2977     }
2978
2979     ret = -1;
2980     if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2981         ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
2982     }
2983     if (is->show_mode == SHOW_MODE_NONE)
2984         is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
2985
2986     if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
2987         stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
2988     }
2989
2990     if (is->video_stream < 0 && is->audio_stream < 0) {
2991         av_log(NULL, AV_LOG_FATAL, "Failed to open file '%s' or configure filtergraph\n",
2992                is->filename);
2993         ret = -1;
2994         goto fail;
2995     }
2996
2997     if (infinite_buffer < 0 && is->realtime)
2998         infinite_buffer = 1;
2999
3000     for (;;) {
3001         if (is->abort_request)
3002             break;
3003         if (is->paused != is->last_paused) {
3004             is->last_paused = is->paused;
3005             if (is->paused)
3006                 is->read_pause_return = av_read_pause(ic);
3007             else
3008                 av_read_play(ic);
3009         }
3010 #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
3011         if (is->paused &&
3012                 (!strcmp(ic->iformat->name, "rtsp") ||
3013                  (ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
3014             /* wait 10 ms to avoid trying to get another packet */
3015             /* XXX: horrible */
3016             SDL_Delay(10);
3017             continue;
3018         }
3019 #endif
3020         if (is->seek_req) {
3021             int64_t seek_target = is->seek_pos;
3022             int64_t seek_min    = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
3023             int64_t seek_max    = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
3024 // FIXME the +-2 is due to rounding being not done in the correct direction in generation
3025 //      of the seek_pos/seek_rel variables
3026
3027             ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
3028             if (ret < 0) {
3029                 av_log(NULL, AV_LOG_ERROR,
3030                        "%s: error while seeking\n", is->ic->filename);
3031             } else {
3032                 if (is->audio_stream >= 0) {
3033                     packet_queue_flush(&is->audioq);
3034                     packet_queue_put(&is->audioq, &flush_pkt);
3035                 }
3036                 if (is->subtitle_stream >= 0) {
3037                     packet_queue_flush(&is->subtitleq);
3038                     packet_queue_put(&is->subtitleq, &flush_pkt);
3039                 }
3040                 if (is->video_stream >= 0) {
3041                     packet_queue_flush(&is->videoq);
3042                     packet_queue_put(&is->videoq, &flush_pkt);
3043                 }
3044                 if (is->seek_flags & AVSEEK_FLAG_BYTE) {
3045                    set_clock(&is->extclk, NAN, 0);
3046                 } else {
3047                    set_clock(&is->extclk, seek_target / (double)AV_TIME_BASE, 0);
3048                 }
3049             }
3050             is->seek_req = 0;
3051             is->queue_attachments_req = 1;
3052             is->eof = 0;
3053             if (is->paused)
3054                 step_to_next_frame(is);
3055         }
3056         if (is->queue_attachments_req) {
3057             if (is->video_st && is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC) {
3058                 AVPacket copy;
3059                 if ((ret = av_copy_packet(&copy, &is->video_st->attached_pic)) < 0)
3060                     goto fail;
3061                 packet_queue_put(&is->videoq, &copy);
3062                 packet_queue_put_nullpacket(&is->videoq, is->video_stream);
3063             }
3064             is->queue_attachments_req = 0;
3065         }
3066
3067         /* if the queue are full, no need to read more */
3068         if (infinite_buffer<1 &&
3069               (is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
3070             || (   (is->audioq   .nb_packets > MIN_FRAMES || is->audio_stream < 0 || is->audioq.abort_request)
3071                 && (is->videoq   .nb_packets > MIN_FRAMES || is->video_stream < 0 || is->videoq.abort_request
3072                     || (is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3073                 && (is->subtitleq.nb_packets > MIN_FRAMES || is->subtitle_stream < 0 || is->subtitleq.abort_request)))) {
3074             /* wait 10 ms */
3075             SDL_LockMutex(wait_mutex);
3076             SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3077             SDL_UnlockMutex(wait_mutex);
3078             continue;
3079         }
3080         if (!is->paused &&
3081             (!is->audio_st || (is->auddec.finished == is->audioq.serial && frame_queue_nb_remaining(&is->sampq) == 0)) &&
3082             (!is->video_st || (is->viddec.finished == is->videoq.serial && frame_queue_nb_remaining(&is->pictq) == 0))) {
3083             if (loop != 1 && (!loop || --loop)) {
3084                 stream_seek(is, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
3085             } else if (autoexit) {
3086                 ret = AVERROR_EOF;
3087                 goto fail;
3088             }
3089         }
3090         ret = av_read_frame(ic, pkt);
3091         if (ret < 0) {
3092             if ((ret == AVERROR_EOF || avio_feof(ic->pb)) && !is->eof) {
3093                 if (is->video_stream >= 0)
3094                     packet_queue_put_nullpacket(&is->videoq, is->video_stream);
3095                 if (is->audio_stream >= 0)
3096                     packet_queue_put_nullpacket(&is->audioq, is->audio_stream);
3097                 if (is->subtitle_stream >= 0)
3098                     packet_queue_put_nullpacket(&is->subtitleq, is->subtitle_stream);
3099                 is->eof = 1;
3100             }
3101             if (ic->pb && ic->pb->error)
3102                 break;
3103             SDL_LockMutex(wait_mutex);
3104             SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3105             SDL_UnlockMutex(wait_mutex);
3106             continue;
3107         } else {
3108             is->eof = 0;
3109         }
3110         /* check if packet is in play range specified by user, then queue, otherwise discard */
3111         stream_start_time = ic->streams[pkt->stream_index]->start_time;
3112         pkt_ts = pkt->pts == AV_NOPTS_VALUE ? pkt->dts : pkt->pts;
3113         pkt_in_play_range = duration == AV_NOPTS_VALUE ||
3114                 (pkt_ts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
3115                 av_q2d(ic->streams[pkt->stream_index]->time_base) -
3116                 (double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
3117                 <= ((double)duration / 1000000);
3118         if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
3119             packet_queue_put(&is->audioq, pkt);
3120         } else if (pkt->stream_index == is->video_stream && pkt_in_play_range
3121                    && !(is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
3122             packet_queue_put(&is->videoq, pkt);
3123         } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
3124             packet_queue_put(&is->subtitleq, pkt);
3125         } else {
3126             av_packet_unref(pkt);
3127         }
3128     }
3129
3130     ret = 0;
3131  fail:
3132     if (ic && !is->ic)
3133         avformat_close_input(&ic);
3134
3135     if (ret != 0) {
3136         SDL_Event event;
3137
3138         event.type = FF_QUIT_EVENT;
3139         event.user.data1 = is;
3140         SDL_PushEvent(&event);
3141     }
3142     SDL_DestroyMutex(wait_mutex);
3143     return 0;
3144 }
3145
3146 static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
3147 {
3148     VideoState *is;
3149
3150     is = av_mallocz(sizeof(VideoState));
3151     if (!is)
3152         return NULL;
3153     is->filename = av_strdup(filename);
3154     if (!is->filename)
3155         goto fail;
3156     is->iformat = iformat;
3157     is->ytop    = 0;
3158     is->xleft   = 0;
3159
3160     /* start video display */
3161     if (frame_queue_init(&is->pictq, &is->videoq, VIDEO_PICTURE_QUEUE_SIZE, 1) < 0)
3162         goto fail;
3163     if (frame_queue_init(&is->subpq, &is->subtitleq, SUBPICTURE_QUEUE_SIZE, 0) < 0)
3164         goto fail;
3165     if (frame_queue_init(&is->sampq, &is->audioq, SAMPLE_QUEUE_SIZE, 1) < 0)
3166         goto fail;
3167
3168     if (packet_queue_init(&is->videoq) < 0 ||
3169         packet_queue_init(&is->audioq) < 0 ||
3170         packet_queue_init(&is->subtitleq) < 0)
3171         goto fail;
3172
3173     if (!(is->continue_read_thread = SDL_CreateCond())) {
3174         av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
3175         goto fail;
3176     }
3177
3178     init_clock(&is->vidclk, &is->videoq.serial);
3179     init_clock(&is->audclk, &is->audioq.serial);
3180     init_clock(&is->extclk, &is->extclk.serial);
3181     is->audio_clock_serial = -1;
3182     is->audio_volume = SDL_MIX_MAXVOLUME;
3183     is->muted = 0;
3184     is->av_sync_type = av_sync_type;
3185     is->read_tid     = SDL_CreateThread(read_thread, is);
3186     if (!is->read_tid) {
3187         av_log(NULL, AV_LOG_FATAL, "SDL_CreateThread(): %s\n", SDL_GetError());
3188 fail:
3189         stream_close(is);
3190         return NULL;
3191     }
3192     return is;
3193 }
3194
3195 static void stream_cycle_channel(VideoState *is, int codec_type)
3196 {
3197     AVFormatContext *ic = is->ic;
3198     int start_index, stream_index;
3199     int old_index;
3200     AVStream *st;
3201     AVProgram *p = NULL;
3202     int nb_streams = is->ic->nb_streams;
3203
3204     if (codec_type == AVMEDIA_TYPE_VIDEO) {
3205         start_index = is->last_video_stream;
3206         old_index = is->video_stream;
3207     } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
3208         start_index = is->last_audio_stream;
3209         old_index = is->audio_stream;
3210     } else {
3211         start_index = is->last_subtitle_stream;
3212         old_index = is->subtitle_stream;
3213     }
3214     stream_index = start_index;
3215
3216     if (codec_type != AVMEDIA_TYPE_VIDEO && is->video_stream != -1) {
3217         p = av_find_program_from_stream(ic, NULL, is->video_stream);
3218         if (p) {
3219             nb_streams = p->nb_stream_indexes;
3220             for (start_index = 0; start_index < nb_streams; start_index++)
3221                 if (p->stream_index[start_index] == stream_index)
3222                     break;
3223             if (start_index == nb_streams)
3224                 start_index = -1;
3225             stream_index = start_index;
3226         }
3227     }
3228
3229     for (;;) {
3230         if (++stream_index >= nb_streams)
3231         {
3232             if (codec_type == AVMEDIA_TYPE_SUBTITLE)
3233             {
3234                 stream_index = -1;
3235                 is->last_subtitle_stream = -1;
3236                 goto the_end;
3237             }
3238             if (start_index == -1)
3239                 return;
3240             stream_index = 0;
3241         }
3242         if (stream_index == start_index)
3243             return;
3244         st = is->ic->streams[p ? p->stream_index[stream_index] : stream_index];
3245         if (st->codec->codec_type == codec_type) {
3246             /* check that parameters are OK */
3247             switch (codec_type) {
3248             case AVMEDIA_TYPE_AUDIO:
3249                 if (st->codec->sample_rate != 0 &&
3250                     st->codec->channels != 0)
3251                     goto the_end;
3252                 break;
3253             case AVMEDIA_TYPE_VIDEO:
3254             case AVMEDIA_TYPE_SUBTITLE:
3255                 goto the_end;
3256             default:
3257                 break;
3258             }
3259         }
3260     }
3261  the_end:
3262     if (p && stream_index != -1)
3263         stream_index = p->stream_index[stream_index];
3264     av_log(NULL, AV_LOG_INFO, "Switch %s stream from #%d to #%d\n",
3265            av_get_media_type_string(codec_type),
3266            old_index,
3267            stream_index);
3268
3269     stream_component_close(is, old_index);
3270     stream_component_open(is, stream_index);
3271 }
3272
3273
3274 static void toggle_full_screen(VideoState *is)
3275 {
3276 #if defined(__APPLE__) && SDL_VERSION_ATLEAST(1, 2, 14)
3277     /* OS X needs to reallocate the SDL overlays */
3278     int i;
3279     for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++)
3280         is->pictq.queue[i].reallocate = 1;
3281 #endif
3282     is_full_screen = !is_full_screen;
3283     video_open(is, 1, NULL);
3284 }
3285
3286 static void toggle_audio_display(VideoState *is)
3287 {
3288     int bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
3289     int next = is->show_mode;
3290     do {
3291         next = (next + 1) % SHOW_MODE_NB;
3292     } while (next != is->show_mode && (next == SHOW_MODE_VIDEO && !is->video_st || next != SHOW_MODE_VIDEO && !is->audio_st));
3293     if (is->show_mode != next) {
3294         fill_rectangle(screen,
3295                     is->xleft, is->ytop, is->width, is->height,
3296                     bgcolor, 1);
3297         is->force_refresh = 1;
3298         is->show_mode = next;
3299     }
3300 }
3301
3302 static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
3303     double remaining_time = 0.0;
3304     SDL_PumpEvents();
3305     while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_ALLEVENTS)) {
3306         if (!cursor_hidden && av_gettime_relative() - cursor_last_shown > CURSOR_HIDE_DELAY) {
3307             SDL_ShowCursor(0);
3308             cursor_hidden = 1;
3309         }
3310         if (remaining_time > 0.0)
3311             av_usleep((int64_t)(remaining_time * 1000000.0));
3312         remaining_time = REFRESH_RATE;
3313         if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
3314             video_refresh(is, &remaining_time);
3315         SDL_PumpEvents();
3316     }
3317 }
3318
3319 static void seek_chapter(VideoState *is, int incr)
3320 {
3321     int64_t pos = get_master_clock(is) * AV_TIME_BASE;
3322     int i;
3323
3324     if (!is->ic->nb_chapters)
3325         return;
3326
3327     /* find the current chapter */
3328     for (i = 0; i < is->ic->nb_chapters; i++) {
3329         AVChapter *ch = is->ic->chapters[i];
3330         if (av_compare_ts(pos, AV_TIME_BASE_Q, ch->start, ch->time_base) < 0) {
3331             i--;
3332             break;
3333         }
3334     }
3335
3336     i += incr;
3337     i = FFMAX(i, 0);
3338     if (i >= is->ic->nb_chapters)
3339         return;
3340
3341     av_log(NULL, AV_LOG_VERBOSE, "Seeking to chapter %d.\n", i);
3342     stream_seek(is, av_rescale_q(is->ic->chapters[i]->start, is->ic->chapters[i]->time_base,
3343                                  AV_TIME_BASE_Q), 0, 0);
3344 }
3345
3346 /* handle an event sent by the GUI */
3347 static void event_loop(VideoState *cur_stream)
3348 {
3349     SDL_Event event;
3350     double incr, pos, frac;
3351
3352     for (;;) {
3353         double x;
3354         refresh_loop_wait_event(cur_stream, &event);
3355         switch (event.type) {
3356         case SDL_KEYDOWN:
3357             if (exit_on_keydown) {
3358                 do_exit(cur_stream);
3359                 break;
3360             }
3361             switch (event.key.keysym.sym) {
3362             case SDLK_ESCAPE:
3363             case SDLK_q:
3364                 do_exit(cur_stream);
3365                 break;
3366             case SDLK_f:
3367                 toggle_full_screen(cur_stream);
3368                 cur_stream->force_refresh = 1;
3369                 break;
3370             case SDLK_p:
3371             case SDLK_SPACE:
3372                 toggle_pause(cur_stream);
3373                 break;
3374             case SDLK_m:
3375                 toggle_mute(cur_stream);
3376                 break;
3377             case SDLK_KP_MULTIPLY:
3378             case SDLK_0:
3379                 update_volume(cur_stream, 1, SDL_VOLUME_STEP);
3380                 break;
3381             case SDLK_KP_DIVIDE:
3382             case SDLK_9:
3383                 update_volume(cur_stream, -1, SDL_VOLUME_STEP);
3384                 break;
3385             case SDLK_s: // S: Step to next frame
3386                 step_to_next_frame(cur_stream);
3387                 break;
3388             case SDLK_a:
3389                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3390                 break;
3391             case SDLK_v:
3392                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3393                 break;
3394             case SDLK_c:
3395                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3396                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3397                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3398                 break;
3399             case SDLK_t:
3400                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3401                 break;
3402             case SDLK_w:
3403 #if CONFIG_AVFILTER
3404                 if (cur_stream->show_mode == SHOW_MODE_VIDEO && cur_stream->vfilter_idx < nb_vfilters - 1) {
3405                     if (++cur_stream->vfilter_idx >= nb_vfilters)
3406                         cur_stream->vfilter_idx = 0;
3407                 } else {
3408                     cur_stream->vfilter_idx = 0;
3409                     toggle_audio_display(cur_stream);
3410                 }
3411 #else
3412                 toggle_audio_display(cur_stream);
3413 #endif
3414                 break;
3415             case SDLK_PAGEUP:
3416                 if (cur_stream->ic->nb_chapters <= 1) {
3417                     incr = 600.0;
3418                     goto do_seek;
3419                 }
3420                 seek_chapter(cur_stream, 1);
3421                 break;
3422             case SDLK_PAGEDOWN:
3423                 if (cur_stream->ic->nb_chapters <= 1) {
3424                     incr = -600.0;
3425                     goto do_seek;
3426                 }
3427                 seek_chapter(cur_stream, -1);
3428                 break;
3429             case SDLK_LEFT:
3430                 incr = -10.0;
3431                 goto do_seek;
3432             case SDLK_RIGHT:
3433                 incr = 10.0;
3434                 goto do_seek;
3435             case SDLK_UP:
3436                 incr = 60.0;
3437                 goto do_seek;
3438             case SDLK_DOWN:
3439                 incr = -60.0;
3440             do_seek:
3441                     if (seek_by_bytes) {
3442                         pos = -1;
3443                         if (pos < 0 && cur_stream->video_stream >= 0)
3444                             pos = frame_queue_last_pos(&cur_stream->pictq);
3445                         if (pos < 0 && cur_stream->audio_stream >= 0)
3446                             pos = frame_queue_last_pos(&cur_stream->sampq);
3447                         if (pos < 0)
3448                             pos = avio_tell(cur_stream->ic->pb);
3449                         if (cur_stream->ic->bit_rate)
3450                             incr *= cur_stream->ic->bit_rate / 8.0;
3451                         else
3452                             incr *= 180000.0;
3453                         pos += incr;
3454                         stream_seek(cur_stream, pos, incr, 1);
3455                     } else {
3456                         pos = get_master_clock(cur_stream);
3457                         if (isnan(pos))
3458                             pos = (double)cur_stream->seek_pos / AV_TIME_BASE;
3459                         pos += incr;
3460                         if (cur_stream->ic->start_time != AV_NOPTS_VALUE && pos < cur_stream->ic->start_time / (double)AV_TIME_BASE)
3461                             pos = cur_stream->ic->start_time / (double)AV_TIME_BASE;
3462                         stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE), 0);
3463                     }
3464                 break;
3465             default:
3466                 break;
3467             }
3468             break;
3469         case SDL_VIDEOEXPOSE:
3470             cur_stream->force_refresh = 1;
3471             break;
3472         case SDL_MOUSEBUTTONDOWN:
3473             if (exit_on_mousedown) {
3474                 do_exit(cur_stream);
3475                 break;
3476             }
3477         case SDL_MOUSEMOTION:
3478             if (cursor_hidden) {
3479                 SDL_ShowCursor(1);
3480                 cursor_hidden = 0;
3481             }
3482             cursor_last_shown = av_gettime_relative();
3483             if (event.type == SDL_MOUSEBUTTONDOWN) {
3484                 x = event.button.x;
3485             } else {
3486                 if (event.motion.state != SDL_PRESSED)
3487                     break;
3488                 x = event.motion.x;
3489             }
3490                 if (seek_by_bytes || cur_stream->ic->duration <= 0) {
3491                     uint64_t size =  avio_size(cur_stream->ic->pb);
3492                     stream_seek(cur_stream, size*x/cur_stream->width, 0, 1);
3493                 } else {
3494                     int64_t ts;
3495                     int ns, hh, mm, ss;
3496                     int tns, thh, tmm, tss;
3497                     tns  = cur_stream->ic->duration / 1000000LL;
3498                     thh  = tns / 3600;
3499                     tmm  = (tns % 3600) / 60;
3500                     tss  = (tns % 60);
3501                     frac = x / cur_stream->width;
3502                     ns   = frac * tns;
3503                     hh   = ns / 3600;
3504                     mm   = (ns % 3600) / 60;
3505                     ss   = (ns % 60);
3506                     av_log(NULL, AV_LOG_INFO,
3507                            "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d)       \n", frac*100,
3508                             hh, mm, ss, thh, tmm, tss);
3509                     ts = frac * cur_stream->ic->duration;
3510                     if (cur_stream->ic->start_time != AV_NOPTS_VALUE)
3511                         ts += cur_stream->ic->start_time;
3512                     stream_seek(cur_stream, ts, 0, 0);
3513                 }
3514             break;
3515         case SDL_VIDEORESIZE:
3516                 screen = SDL_SetVideoMode(FFMIN(16383, event.resize.w), event.resize.h, 0,
3517                                           SDL_HWSURFACE|(is_full_screen?SDL_FULLSCREEN:SDL_RESIZABLE)|SDL_ASYNCBLIT|SDL_HWACCEL);
3518                 if (!screen) {
3519                     av_log(NULL, AV_LOG_FATAL, "Failed to set video mode\n");
3520                     do_exit(cur_stream);
3521                 }
3522                 screen_width  = cur_stream->width  = screen->w;
3523                 screen_height = cur_stream->height = screen->h;
3524                 cur_stream->force_refresh = 1;
3525             break;
3526         case SDL_QUIT:
3527         case FF_QUIT_EVENT:
3528             do_exit(cur_stream);
3529             break;
3530         case FF_ALLOC_EVENT:
3531             alloc_picture(event.user.data1);
3532             break;
3533         default:
3534             break;
3535         }
3536     }
3537 }
3538
3539 static int opt_frame_size(void *optctx, const char *opt, const char *arg)
3540 {
3541     av_log(NULL, AV_LOG_WARNING, "Option -s is deprecated, use -video_size.\n");
3542     return opt_default(NULL, "video_size", arg);
3543 }
3544
3545 static int opt_width(void *optctx, const char *opt, const char *arg)
3546 {
3547     screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3548     return 0;
3549 }
3550
3551 static int opt_height(void *optctx, const char *opt, const char *arg)
3552 {
3553     screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3554     return 0;
3555 }
3556
3557 static int opt_format(void *optctx, const char *opt, const char *arg)
3558 {
3559     file_iformat = av_find_input_format(arg);
3560     if (!file_iformat) {
3561         av_log(NULL, AV_LOG_FATAL, "Unknown input format: %s\n", arg);
3562         return AVERROR(EINVAL);
3563     }
3564     return 0;
3565 }
3566
3567 static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
3568 {
3569     av_log(NULL, AV_LOG_WARNING, "Option -pix_fmt is deprecated, use -pixel_format.\n");
3570     return opt_default(NULL, "pixel_format", arg);
3571 }
3572
3573 static int opt_sync(void *optctx, const char *opt, const char *arg)
3574 {
3575     if (!strcmp(arg, "audio"))
3576         av_sync_type = AV_SYNC_AUDIO_MASTER;
3577     else if (!strcmp(arg, "video"))
3578         av_sync_type = AV_SYNC_VIDEO_MASTER;
3579     else if (!strcmp(arg, "ext"))
3580         av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
3581     else {
3582         av_log(NULL, AV_LOG_ERROR, "Unknown value for %s: %s\n", opt, arg);
3583         exit(1);
3584     }
3585     return 0;
3586 }
3587
3588 static int opt_seek(void *optctx, const char *opt, const char *arg)
3589 {
3590     start_time = parse_time_or_die(opt, arg, 1);
3591     return 0;
3592 }
3593
3594 static int opt_duration(void *optctx, const char *opt, const char *arg)
3595 {
3596     duration = parse_time_or_die(opt, arg, 1);
3597     return 0;
3598 }
3599
3600 static int opt_show_mode(void *optctx, const char *opt, const char *arg)
3601 {
3602     show_mode = !strcmp(arg, "video") ? SHOW_MODE_VIDEO :
3603                 !strcmp(arg, "waves") ? SHOW_MODE_WAVES :
3604                 !strcmp(arg, "rdft" ) ? SHOW_MODE_RDFT  :
3605                 parse_number_or_die(opt, arg, OPT_INT, 0, SHOW_MODE_NB-1);
3606     return 0;
3607 }
3608
3609 static void opt_input_file(void *optctx, const char *filename)
3610 {
3611     if (input_filename) {
3612         av_log(NULL, AV_LOG_FATAL,
3613                "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3614                 filename, input_filename);
3615         exit(1);
3616     }
3617     if (!strcmp(filename, "-"))
3618         filename = "pipe:";
3619     input_filename = filename;
3620 }
3621
3622 static int opt_codec(void *optctx, const char *opt, const char *arg)
3623 {
3624    const char *spec = strchr(opt, ':');
3625    if (!spec) {
3626        av_log(NULL, AV_LOG_ERROR,
3627               "No media specifier was specified in '%s' in option '%s'\n",
3628                arg, opt);
3629        return AVERROR(EINVAL);
3630    }
3631    spec++;
3632    switch (spec[0]) {
3633    case 'a' :    audio_codec_name = arg; break;
3634    case 's' : subtitle_codec_name = arg; break;
3635    case 'v' :    video_codec_name = arg; break;
3636    default:
3637        av_log(NULL, AV_LOG_ERROR,
3638               "Invalid media specifier '%s' in option '%s'\n", spec, opt);
3639        return AVERROR(EINVAL);
3640    }
3641    return 0;
3642 }
3643
3644 static int dummy;
3645
3646 static const OptionDef options[] = {
3647 #include "cmdutils_common_opts.h"
3648     { "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
3649     { "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
3650     { "s", HAS_ARG | OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
3651     { "fs", OPT_BOOL, { &is_full_screen }, "force full screen" },
3652     { "an", OPT_BOOL, { &audio_disable }, "disable audio" },
3653     { "vn", OPT_BOOL, { &video_disable }, "disable video" },
3654     { "sn", OPT_BOOL, { &subtitle_disable }, "disable subtitling" },
3655     { "ast", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_specifier" },
3656     { "vst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_specifier" },
3657     { "sst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_specifier" },
3658     { "ss", HAS_ARG, { .func_arg = opt_seek }, "seek to a given position in seconds", "pos" },
3659     { "t", HAS_ARG, { .func_arg = opt_duration }, "play  \"duration\" seconds of audio/video", "duration" },
3660     { "bytes", OPT_INT | HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
3661     { "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
3662     { "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
3663     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
3664     { "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" },
3665     { "fast", OPT_BOOL | OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
3666     { "genpts", OPT_BOOL | OPT_EXPERT, { &genpts }, "generate pts", "" },
3667     { "drp", OPT_INT | HAS_ARG | OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
3668     { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, { &lowres }, "", "" },
3669     { "sync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
3670     { "autoexit", OPT_BOOL | OPT_EXPERT, { &autoexit }, "exit at the end", "" },
3671     { "exitonkeydown", OPT_BOOL | OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
3672     { "exitonmousedown", OPT_BOOL | OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
3673     { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
3674     { "framedrop", OPT_BOOL | OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
3675     { "infbuf", OPT_BOOL | OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
3676     { "window_title", OPT_STRING | HAS_ARG, { &window_title }, "set window title", "window title" },
3677 #if CONFIG_AVFILTER
3678     { "vf", OPT_EXPERT | HAS_ARG, { .func_arg = opt_add_vfilter }, "set video filters", "filter_graph" },
3679     { "af", OPT_STRING | HAS_ARG, { &afilters }, "set audio filters", "filter_graph" },
3680 #endif
3681     { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
3682     { "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
3683     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default }, "generic catch all option", "" },
3684     { "i", OPT_BOOL, { &dummy}, "read specified file", "input_file"},
3685     { "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
3686     { "acodec", HAS_ARG | OPT_STRING | OPT_EXPERT, {    &audio_codec_name }, "force audio decoder",    "decoder_name" },
3687     { "scodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
3688     { "vcodec", HAS_ARG | OPT_STRING | OPT_EXPERT, {    &video_codec_name }, "force video decoder",    "decoder_name" },
3689     { "autorotate", OPT_BOOL, { &autorotate }, "automatically rotate video", "" },
3690     { NULL, },
3691 };
3692
3693 static void show_usage(void)
3694 {
3695     av_log(NULL, AV_LOG_INFO, "Simple media player\n");
3696     av_log(NULL, AV_LOG_INFO, "usage: %s [options] input_file\n", program_name);
3697     av_log(NULL, AV_LOG_INFO, "\n");
3698 }
3699
3700 void show_help_default(const char *opt, const char *arg)
3701 {
3702     av_log_set_callback(log_callback_help);
3703     show_usage();
3704     show_help_options(options, "Main options:", 0, OPT_EXPERT, 0);
3705     show_help_options(options, "Advanced options:", OPT_EXPERT, 0, 0);
3706     printf("\n");
3707     show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3708     show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3709 #if !CONFIG_AVFILTER
3710     show_help_children(sws_get_class(), AV_OPT_FLAG_ENCODING_PARAM);
3711 #else
3712     show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
3713 #endif
3714     printf("\nWhile playing:\n"
3715            "q, ESC              quit\n"
3716            "f                   toggle full screen\n"
3717            "p, SPC              pause\n"
3718            "m                   toggle mute\n"
3719            "9, 0                decrease and increase volume respectively\n"
3720            "/, *                decrease and increase volume respectively\n"
3721            "a                   cycle audio channel in the current program\n"
3722            "v                   cycle video channel\n"
3723            "t                   cycle subtitle channel in the current program\n"
3724            "c                   cycle program\n"
3725            "w                   cycle video filters or show modes\n"
3726            "s                   activate frame-step mode\n"
3727            "left/right          seek backward/forward 10 seconds\n"
3728            "down/up             seek backward/forward 1 minute\n"
3729            "page down/page up   seek backward/forward 10 minutes\n"
3730            "mouse click         seek to percentage in file corresponding to fraction of width\n"
3731            );
3732 }
3733