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