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