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