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/fifo.h"
  40 #include "libavutil/parseutils.h"
  41 #include "libavutil/samplefmt.h"
  42 #include "libavutil/avassert.h"
  43 #include "libavutil/time.h"
  44 #include "libavutil/bprint.h"
  45 #include "libavformat/avformat.h"
  46 #include "libavdevice/avdevice.h"
  47 #include "libswscale/swscale.h"
  48 #include "libavutil/opt.h"
  49 #include "libavcodec/avfft.h"
  50 #include "libswresample/swresample.h"
  51
  52 #if CONFIG_AVFILTER
  53 # include "libavfilter/avfilter.h"
  54 # include "libavfilter/buffersink.h"
  55 # include "libavfilter/buffersrc.h"
  56 #endif
  57
  58 #include <SDL.h>
  59 #include <SDL_thread.h>
  60
  61 #include "cmdutils.h"
  62
  63 #include <assert.h>
  64
  65 const char program_name[] = "ffplay";
  66 const int program_birth_year = 2003;
  67
  68 #define MAX_QUEUE_SIZE (15 * 1024 * 1024)
  69 #define MIN_FRAMES 25
  70 #define EXTERNAL_CLOCK_MIN_FRAMES 2
  71 #define EXTERNAL_CLOCK_MAX_FRAMES 10
  72
  73 /* Minimum SDL audio buffer size, in samples. */
  74 #define SDL_AUDIO_MIN_BUFFER_SIZE 512
  75 /* Calculate actual buffer size keeping in mind not cause too frequent audio callbacks */
  76 #define SDL_AUDIO_MAX_CALLBACKS_PER_SEC 30
  77
  78 /* Step size for volume control in dB */
  79 #define SDL_VOLUME_STEP (0.75)
  80
  81 /* no AV sync correction is done if below the minimum AV sync threshold */
  82 #define AV_SYNC_THRESHOLD_MIN 0.04
  83 /* AV sync correction is done if above the maximum AV sync threshold */
  84 #define AV_SYNC_THRESHOLD_MAX 0.1
  85 /* If a frame duration is longer than this, it will not be duplicated to compensate AV sync */
  86 #define AV_SYNC_FRAMEDUP_THRESHOLD 0.1
  87 /* no AV correction is done if too big error */
  88 #define AV_NOSYNC_THRESHOLD 10.0
  89
  90 /* maximum audio speed change to get correct sync */
  91 #define SAMPLE_CORRECTION_PERCENT_MAX 10
  92
  93 /* external clock speed adjustment constants for realtime sources based on buffer fullness */
  94 #define EXTERNAL_CLOCK_SPEED_MIN  0.900
  95 #define EXTERNAL_CLOCK_SPEED_MAX  1.010
  96 #define EXTERNAL_CLOCK_SPEED_STEP 0.001
  97
  98 /* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
  99 #define AUDIO_DIFF_AVG_NB   20
 100
 101 /* polls for possible required screen refresh at least this often, should be less than 1/fps */
 102 #define REFRESH_RATE 0.01
 103
 104 /* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
 105 /* TODO: We assume that a decoded and resampled frame fits into this buffer */
 106 #define SAMPLE_ARRAY_SIZE (8 * 65536)
 107
 108 #define CURSOR_HIDE_DELAY 1000000
 109
 110 #define USE_ONEPASS_SUBTITLE_RENDER 1
 111
 112 static unsigned sws_flags = SWS_BICUBIC;
 113
 114 typedef struct MyAVPacketList {
 115     AVPacket *pkt;
 116     int serial;
 117 } MyAVPacketList;
 118
 119 typedef struct PacketQueue {
 120     AVFifoBuffer *pkt_list;
 121     int nb_packets;
 122     int size;
 123     int64_t duration;
 124     int abort_request;
 125     int serial;
 126     SDL_mutex *mutex;
 127     SDL_cond *cond;
 128 } PacketQueue;
 129
 130 #define VIDEO_PICTURE_QUEUE_SIZE 3
 131 #define SUBPICTURE_QUEUE_SIZE 16
 132 #define SAMPLE_QUEUE_SIZE 9
 133 #define FRAME_QUEUE_SIZE FFMAX(SAMPLE_QUEUE_SIZE, FFMAX(VIDEO_PICTURE_QUEUE_SIZE, SUBPICTURE_QUEUE_SIZE))
 134
 135 typedef struct AudioParams {
 136     int freq;
 137     int channels;
 138     int64_t channel_layout;
 139     enum AVSampleFormat fmt;
 140     int frame_size;
 141     int bytes_per_sec;
 142 } AudioParams;
 143
 144 typedef struct Clock {
 145     double pts;           /* clock base */
 146     double pts_drift;     /* clock base minus time at which we updated the clock */
 147     double last_updated;
 148     double speed;
 149     int serial;           /* clock is based on a packet with this serial */
 150     int paused;
 151     int *queue_serial;    /* pointer to the current packet queue serial, used for obsolete clock detection */
 152 } Clock;
 153
 154 /* Common struct for handling all types of decoded data and allocated render buffers. */
 155 typedef struct Frame {
 156     AVFrame *frame;
 157     AVSubtitle sub;
 158     int serial;
 159     double pts;           /* presentation timestamp for the frame */
 160     double duration;      /* estimated duration of the frame */
 161     int64_t pos;          /* byte position of the frame in the input file */
 162     int width;
 163     int height;
 164     int format;
 165     AVRational sar;
 166     int uploaded;
 167     int flip_v;
 168 } Frame;
 169
 170 typedef struct FrameQueue {
 171     Frame queue[FRAME_QUEUE_SIZE];
 172     int rindex;
 173     int windex;
 174     int size;
 175     int max_size;
 176     int keep_last;
 177     int rindex_shown;
 178     SDL_mutex *mutex;
 179     SDL_cond *cond;
 180     PacketQueue *pktq;
 181 } FrameQueue;
 182
 183 enum {
 184     AV_SYNC_AUDIO_MASTER, /* default choice */
 185     AV_SYNC_VIDEO_MASTER,
 186     AV_SYNC_EXTERNAL_CLOCK, /* synchronize to an external clock */
 187 };
 188
 189 typedef struct Decoder {
 190     AVPacket *pkt;
 191     PacketQueue *queue;
 192     AVCodecContext *avctx;
 193     int pkt_serial;
 194     int finished;
 195     int packet_pending;
 196     SDL_cond *empty_queue_cond;
 197     int64_t start_pts;
 198     AVRational start_pts_tb;
 199     int64_t next_pts;
 200     AVRational next_pts_tb;
 201     SDL_Thread *decoder_tid;
 202 } Decoder;
 203
 204 typedef struct VideoState {
 205     SDL_Thread *read_tid;
 206     AVInputFormat *iformat;
 207     int abort_request;
 208     int force_refresh;
 209     int paused;
 210     int last_paused;
 211     int queue_attachments_req;
 212     int seek_req;
 213     int seek_flags;
 214     int64_t seek_pos;
 215     int64_t seek_rel;
 216     int read_pause_return;
 217     AVFormatContext *ic;
 218     int realtime;
 219
 220     Clock audclk;
 221     Clock vidclk;
 222     Clock extclk;
 223
 224     FrameQueue pictq;
 225     FrameQueue subpq;
 226     FrameQueue sampq;
 227
 228     Decoder auddec;
 229     Decoder viddec;
 230     Decoder subdec;
 231
 232     int audio_stream;
 233
 234     int av_sync_type;
 235
 236     double audio_clock;
 237     int audio_clock_serial;
 238     double audio_diff_cum; /* used for AV difference average computation */
 239     double audio_diff_avg_coef;
 240     double audio_diff_threshold;
 241     int audio_diff_avg_count;
 242     AVStream *audio_st;
 243     PacketQueue audioq;
 244     int audio_hw_buf_size;
 245     uint8_t *audio_buf;
 246     uint8_t *audio_buf1;
 247     unsigned int audio_buf_size; /* in bytes */
 248     unsigned int audio_buf1_size;
 249     int audio_buf_index; /* in bytes */
 250     int audio_write_buf_size;
 251     int audio_volume;
 252     int muted;
 253     struct AudioParams audio_src;
 254 #if CONFIG_AVFILTER
 255     struct AudioParams audio_filter_src;
 256 #endif
 257     struct AudioParams audio_tgt;
 258     struct SwrContext *swr_ctx;
 259     int frame_drops_early;
 260     int frame_drops_late;
 261
 262     enum ShowMode {
 263         SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO = 0, SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB
 264     } show_mode;
 265     int16_t sample_array[SAMPLE_ARRAY_SIZE];
 266     int sample_array_index;
 267     int last_i_start;
 268     RDFTContext *rdft;
 269     int rdft_bits;
 270     FFTSample *rdft_data;
 271     int xpos;
 272     double last_vis_time;
 273     SDL_Texture *vis_texture;
 274     SDL_Texture *sub_texture;
 275     SDL_Texture *vid_texture;
 276
 277     int subtitle_stream;
 278     AVStream *subtitle_st;
 279     PacketQueue subtitleq;
 280
 281     double frame_timer;
 282     double frame_last_returned_time;
 283     double frame_last_filter_delay;
 284     int video_stream;
 285     AVStream *video_st;
 286     PacketQueue videoq;
 287     double max_frame_duration;      // maximum duration of a frame - above this, we consider the jump a timestamp discontinuity
 288     struct SwsContext *img_convert_ctx;
 289     struct SwsContext *sub_convert_ctx;
 290     int eof;
 291
 292     char *filename;
 293     int width, height, xleft, ytop;
 294     int step;
 295
 296 #if CONFIG_AVFILTER
 297     int vfilter_idx;
 298     AVFilterContext *in_video_filter;   // the first filter in the video chain
 299     AVFilterContext *out_video_filter;  // the last filter in the video chain
 300     AVFilterContext *in_audio_filter;   // the first filter in the audio chain
 301     AVFilterContext *out_audio_filter;  // the last filter in the audio chain
 302     AVFilterGraph *agraph;              // audio filter graph
 303 #endif
 304
 305     int last_video_stream, last_audio_stream, last_subtitle_stream;
 306
 307     SDL_cond *continue_read_thread;
 308 } VideoState;
 309
 310 /* options specified by the user */
 311 static AVInputFormat *file_iformat;
 312 static const char *input_filename;
 313 static const char *window_title;
 314 static int default_width  = 640;
 315 static int default_height = 480;
 316 static int screen_width  = 0;
 317 static int screen_height = 0;
 318 static int screen_left = SDL_WINDOWPOS_CENTERED;
 319 static int screen_top = SDL_WINDOWPOS_CENTERED;
 320 static int audio_disable;
 321 static int video_disable;
 322 static int subtitle_disable;
 323 static const char* wanted_stream_spec[AVMEDIA_TYPE_NB] = {0};
 324 static int seek_by_bytes = -1;
 325 static float seek_interval = 10;
 326 static int display_disable;
 327 static int borderless;
 328 static int alwaysontop;
 329 static int startup_volume = 100;
 330 static int show_status = -1;
 331 static int av_sync_type = AV_SYNC_AUDIO_MASTER;
 332 static int64_t start_time = AV_NOPTS_VALUE;
 333 static int64_t duration = AV_NOPTS_VALUE;
 334 static int fast = 0;
 335 static int genpts = 0;
 336 static int lowres = 0;
 337 static int decoder_reorder_pts = -1;
 338 static int autoexit;
 339 static int exit_on_keydown;
 340 static int exit_on_mousedown;
 341 static int loop = 1;
 342 static int framedrop = -1;
 343 static int infinite_buffer = -1;
 344 static enum ShowMode show_mode = SHOW_MODE_NONE;
 345 static const char *audio_codec_name;
 346 static const char *subtitle_codec_name;
 347 static const char *video_codec_name;
 348 double rdftspeed = 0.02;
 349 static int64_t cursor_last_shown;
 350 static int cursor_hidden = 0;
 351 #if CONFIG_AVFILTER
 352 static const char **vfilters_list = NULL;
 353 static int nb_vfilters = 0;
 354 static char *afilters = NULL;
 355 #endif
 356 static int autorotate = 1;
 357 static int find_stream_info = 1;
 358 static int filter_nbthreads = 0;
 359
 360 /* current context */
 361 static int is_full_screen;
 362 static int64_t audio_callback_time;
 363
 364 #define FF_QUIT_EVENT    (SDL_USEREVENT + 2)
 365
 366 static SDL_Window *window;
 367 static SDL_Renderer *renderer;
 368 static SDL_RendererInfo renderer_info = {0};
 369 static SDL_AudioDeviceID audio_dev;
 370
 371 static const struct TextureFormatEntry {
 372     enum AVPixelFormat format;
 373     int texture_fmt;
 374 } sdl_texture_format_map[] = {
 375     { AV_PIX_FMT_RGB8,           SDL_PIXELFORMAT_RGB332 },
 376     { AV_PIX_FMT_RGB444,         SDL_PIXELFORMAT_RGB444 },
 377     { AV_PIX_FMT_RGB555,         SDL_PIXELFORMAT_RGB555 },
 378     { AV_PIX_FMT_BGR555,         SDL_PIXELFORMAT_BGR555 },
 379     { AV_PIX_FMT_RGB565,         SDL_PIXELFORMAT_RGB565 },
 380     { AV_PIX_FMT_BGR565,         SDL_PIXELFORMAT_BGR565 },
 381     { AV_PIX_FMT_RGB24,          SDL_PIXELFORMAT_RGB24 },
 382     { AV_PIX_FMT_BGR24,          SDL_PIXELFORMAT_BGR24 },
 383     { AV_PIX_FMT_0RGB32,         SDL_PIXELFORMAT_RGB888 },
 384     { AV_PIX_FMT_0BGR32,         SDL_PIXELFORMAT_BGR888 },
 385     { AV_PIX_FMT_NE(RGB0, 0BGR), SDL_PIXELFORMAT_RGBX8888 },
 386     { AV_PIX_FMT_NE(BGR0, 0RGB), SDL_PIXELFORMAT_BGRX8888 },
 387     { AV_PIX_FMT_RGB32,          SDL_PIXELFORMAT_ARGB8888 },
 388     { AV_PIX_FMT_RGB32_1,        SDL_PIXELFORMAT_RGBA8888 },
 389     { AV_PIX_FMT_BGR32,          SDL_PIXELFORMAT_ABGR8888 },
 390     { AV_PIX_FMT_BGR32_1,        SDL_PIXELFORMAT_BGRA8888 },
 391     { AV_PIX_FMT_YUV420P,        SDL_PIXELFORMAT_IYUV },
 392     { AV_PIX_FMT_YUYV422,        SDL_PIXELFORMAT_YUY2 },
 393     { AV_PIX_FMT_UYVY422,        SDL_PIXELFORMAT_UYVY },
 394     { AV_PIX_FMT_NONE,           SDL_PIXELFORMAT_UNKNOWN },
 395 };
 396
 397 #if CONFIG_AVFILTER
 398 static int opt_add_vfilter(void *optctx, const char *opt, const char *arg)
 399 {
 400     GROW_ARRAY(vfilters_list, nb_vfilters);
 401     vfilters_list[nb_vfilters - 1] = arg;
 402     return 0;
 403 }
 404 #endif
 405
 406 static inline
 407 int cmp_audio_fmts(enum AVSampleFormat fmt1, int64_t channel_count1,
 408                    enum AVSampleFormat fmt2, int64_t channel_count2)
 409 {
 410     /* If channel count == 1, planar and non-planar formats are the same */
 411     if (channel_count1 == 1 && channel_count2 == 1)
 412         return av_get_packed_sample_fmt(fmt1) != av_get_packed_sample_fmt(fmt2);
 413     else
 414         return channel_count1 != channel_count2 || fmt1 != fmt2;
 415 }
 416
 417 static inline
 418 int64_t get_valid_channel_layout(int64_t channel_layout, int channels)
 419 {
 420     if (channel_layout && av_get_channel_layout_nb_channels(channel_layout) == channels)
 421         return channel_layout;
 422     else
 423         return 0;
 424 }
 425
 426 static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
 427 {
 428     MyAVPacketList pkt1;
 429
 430     if (q->abort_request)
 431        return -1;
 432
 433     if (av_fifo_space(q->pkt_list) < sizeof(pkt1)) {
 434         if (av_fifo_grow(q->pkt_list, sizeof(pkt1)) < 0)
 435             return -1;
 436     }
 437
 438     pkt1.pkt = pkt;
 439     pkt1.serial = q->serial;
 440
 441     av_fifo_generic_write(q->pkt_list, &pkt1, sizeof(pkt1), NULL);
 442     q->nb_packets++;
 443     q->size += pkt1.pkt->size + sizeof(pkt1);
 444     q->duration += pkt1.pkt->duration;
 445     /* XXX: should duplicate packet data in DV case */
 446     SDL_CondSignal(q->cond);
 447     return 0;
 448 }
 449
 450 static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
 451 {
 452     AVPacket *pkt1;
 453     int ret;
 454
 455     pkt1 = av_packet_alloc();
 456     if (!pkt1) {
 457         av_packet_unref(pkt);
 458         return -1;
 459     }
 460     av_packet_move_ref(pkt1, pkt);
 461
 462     SDL_LockMutex(q->mutex);
 463     ret = packet_queue_put_private(q, pkt1);
 464     SDL_UnlockMutex(q->mutex);
 465
 466     if (ret < 0)
 467         av_packet_free(&pkt1);
 468
 469     return ret;
 470 }
 471
 472 static int packet_queue_put_nullpacket(PacketQueue *q, AVPacket *pkt, int stream_index)
 473 {
 474     pkt->stream_index = stream_index;
 475     return packet_queue_put(q, pkt);
 476 }
 477
 478 /* packet queue handling */
 479 static int packet_queue_init(PacketQueue *q)
 480 {
 481     memset(q, 0, sizeof(PacketQueue));
 482     q->pkt_list = av_fifo_alloc(sizeof(MyAVPacketList));
 483     if (!q->pkt_list)
 484         return AVERROR(ENOMEM);
 485     q->mutex = SDL_CreateMutex();
 486     if (!q->mutex) {
 487         av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
 488         return AVERROR(ENOMEM);
 489     }
 490     q->cond = SDL_CreateCond();
 491     if (!q->cond) {
 492         av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
 493         return AVERROR(ENOMEM);
 494     }
 495     q->abort_request = 1;
 496     return 0;
 497 }
 498
 499 static void packet_queue_flush(PacketQueue *q)
 500 {
 501     MyAVPacketList pkt1;
 502
 503     SDL_LockMutex(q->mutex);
 504     while (av_fifo_size(q->pkt_list) >= sizeof(pkt1)) {
 505         av_fifo_generic_read(q->pkt_list, &pkt1, sizeof(pkt1), NULL);
 506         av_packet_free(&pkt1.pkt);
 507     }
 508     q->nb_packets = 0;
 509     q->size = 0;
 510     q->duration = 0;
 511     q->serial++;
 512     SDL_UnlockMutex(q->mutex);
 513 }
 514
 515 static void packet_queue_destroy(PacketQueue *q)
 516 {
 517     packet_queue_flush(q);
 518     av_fifo_freep(&q->pkt_list);
 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     q->serial++;
 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         if (av_fifo_size(q->pkt_list) >= sizeof(pkt1)) {
 557             av_fifo_generic_read(q->pkt_list, &pkt1, sizeof(pkt1), NULL);
 558             q->nb_packets--;
 559             q->size -= pkt1.pkt->size + sizeof(pkt1);
 560             q->duration -= pkt1.pkt->duration;
 561             av_packet_move_ref(pkt, pkt1.pkt);
 562             if (serial)
 563                 *serial = pkt1.serial;
 564             av_packet_free(&pkt1.pkt);
 565             ret = 1;
 566             break;
 567         } else if (!block) {
 568             ret = 0;
 569             break;
 570         } else {
 571             SDL_CondWait(q->cond, q->mutex);
 572         }
 573     }
 574     SDL_UnlockMutex(q->mutex);
 575     return ret;
 576 }
 577
 578 static int decoder_init(Decoder *d, AVCodecContext *avctx, PacketQueue *queue, SDL_cond *empty_queue_cond) {
 579     memset(d, 0, sizeof(Decoder));
 580     d->pkt = av_packet_alloc();
 581     if (!d->pkt)
 582         return AVERROR(ENOMEM);
 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     return 0;
 589 }
 590
 591 static int decoder_decode_frame(Decoder *d, AVFrame *frame, AVSubtitle *sub) {
 592     int ret = AVERROR(EAGAIN);
 593
 594     for (;;) {
 595         if (d->queue->serial == d->pkt_serial) {
 596             do {
 597                 if (d->queue->abort_request)
 598                     return -1;
 599
 600                 switch (d->avctx->codec_type) {
 601                     case AVMEDIA_TYPE_VIDEO:
 602                         ret = avcodec_receive_frame(d->avctx, frame);
 603                         if (ret >= 0) {
 604                             if (decoder_reorder_pts == -1) {
 605                                 frame->pts = frame->best_effort_timestamp;
 606                             } else if (!decoder_reorder_pts) {
 607                                 frame->pts = frame->pkt_dts;
 608                             }
 609                         }
 610                         break;
 611                     case AVMEDIA_TYPE_AUDIO:
 612                         ret = avcodec_receive_frame(d->avctx, frame);
 613                         if (ret >= 0) {
 614                             AVRational tb = (AVRational){1, frame->sample_rate};
 615                             if (frame->pts != AV_NOPTS_VALUE)
 616                                 frame->pts = av_rescale_q(frame->pts, d->avctx->pkt_timebase, tb);
 617                             else if (d->next_pts != AV_NOPTS_VALUE)
 618                                 frame->pts = av_rescale_q(d->next_pts, d->next_pts_tb, tb);
 619                             if (frame->pts != AV_NOPTS_VALUE) {
 620                                 d->next_pts = frame->pts + frame->nb_samples;
 621                                 d->next_pts_tb = tb;
 622                             }
 623                         }
 624                         break;
 625                 }
 626                 if (ret == AVERROR_EOF) {
 627                     d->finished = d->pkt_serial;
 628                     avcodec_flush_buffers(d->avctx);
 629                     return 0;
 630                 }
 631                 if (ret >= 0)
 632                     return 1;
 633             } while (ret != AVERROR(EAGAIN));
 634         }
 635
 636         do {
 637             if (d->queue->nb_packets == 0)
 638                 SDL_CondSignal(d->empty_queue_cond);
 639             if (d->packet_pending) {
 640                 d->packet_pending = 0;
 641             } else {
 642                 int old_serial = d->pkt_serial;
 643                 if (packet_queue_get(d->queue, d->pkt, 1, &d->pkt_serial) < 0)
 644                     return -1;
 645                 if (old_serial != d->pkt_serial) {
 646                     avcodec_flush_buffers(d->avctx);
 647                     d->finished = 0;
 648                     d->next_pts = d->start_pts;
 649                     d->next_pts_tb = d->start_pts_tb;
 650                 }
 651             }
 652             if (d->queue->serial == d->pkt_serial)
 653                 break;
 654             av_packet_unref(d->pkt);
 655         } while (1);
 656
 657         {
 658             if (d->avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
 659                 int got_frame = 0;
 660                 ret = avcodec_decode_subtitle2(d->avctx, sub, &got_frame, d->pkt);
 661                 if (ret < 0) {
 662                     ret = AVERROR(EAGAIN);
 663                 } else {
 664                     if (got_frame && !d->pkt->data) {
 665                        d->packet_pending = 1;
 666                     }
 667                     ret = got_frame ? 0 : (d->pkt->data ? AVERROR(EAGAIN) : AVERROR_EOF);
 668                 }
 669                 av_packet_unref(d->pkt);
 670             } else {
 671                 if (avcodec_send_packet(d->avctx, d->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                 } else {
 675                     av_packet_unref(d->pkt);
 676                 }
 677             }
 678         }
 679     }
 680 }
 681
 682 static void decoder_destroy(Decoder *d) {
 683     av_packet_free(&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         AVBPrint buf;
1696         static int64_t last_time;
1697         int64_t cur_time;
1698         int aqsize, vqsize, sqsize;
1699         double av_diff;
1700
1701         cur_time = av_gettime_relative();
1702         if (!last_time || (cur_time - last_time) >= 30000) {
1703             aqsize = 0;
1704             vqsize = 0;
1705             sqsize = 0;
1706             if (is->audio_st)
1707                 aqsize = is->audioq.size;
1708             if (is->video_st)
1709                 vqsize = is->videoq.size;
1710             if (is->subtitle_st)
1711                 sqsize = is->subtitleq.size;
1712             av_diff = 0;
1713             if (is->audio_st && is->video_st)
1714                 av_diff = get_clock(&is->audclk) - get_clock(&is->vidclk);
1715             else if (is->video_st)
1716                 av_diff = get_master_clock(is) - get_clock(&is->vidclk);
1717             else if (is->audio_st)
1718                 av_diff = get_master_clock(is) - get_clock(&is->audclk);
1719
1720             av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
1721             av_bprintf(&buf,
1722                       "%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64"   \r",
1723                       get_master_clock(is),
1724                       (is->audio_st && is->video_st) ? "A-V" : (is->video_st ? "M-V" : (is->audio_st ? "M-A" : "   ")),
1725                       av_diff,
1726                       is->frame_drops_early + is->frame_drops_late,
1727                       aqsize / 1024,
1728                       vqsize / 1024,
1729                       sqsize,
1730                       is->video_st ? is->viddec.avctx->pts_correction_num_faulty_dts : 0,
1731                       is->video_st ? is->viddec.avctx->pts_correction_num_faulty_pts : 0);
1732
1733             if (show_status == 1 && AV_LOG_INFO > av_log_get_level())
1734                 fprintf(stderr, "%s", buf.str);
1735             else
1736                 av_log(NULL, AV_LOG_INFO, "%s", buf.str);
1737
1738             fflush(stderr);
1739             av_bprint_finalize(&buf, NULL);
1740
1741             last_time = cur_time;
1742         }
1743     }
1744 }
1745
1746 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, double duration, int64_t pos, int serial)
1747 {
1748     Frame *vp;
1749
1750 #if defined(DEBUG_SYNC)
1751     printf("frame_type=%c pts=%0.3f\n",
1752            av_get_picture_type_char(src_frame->pict_type), pts);
1753 #endif
1754
1755     if (!(vp = frame_queue_peek_writable(&is->pictq)))
1756         return -1;
1757
1758     vp->sar = src_frame->sample_aspect_ratio;
1759     vp->uploaded = 0;
1760
1761     vp->width = src_frame->width;
1762     vp->height = src_frame->height;
1763     vp->format = src_frame->format;
1764
1765     vp->pts = pts;
1766     vp->duration = duration;
1767     vp->pos = pos;
1768     vp->serial = serial;
1769
1770     set_default_window_size(vp->width, vp->height, vp->sar);
1771
1772     av_frame_move_ref(vp->frame, src_frame);
1773     frame_queue_push(&is->pictq);
1774     return 0;
1775 }
1776
1777 static int get_video_frame(VideoState *is, AVFrame *frame)
1778 {
1779     int got_picture;
1780
1781     if ((got_picture = decoder_decode_frame(&is->viddec, frame, NULL)) < 0)
1782         return -1;
1783
1784     if (got_picture) {
1785         double dpts = NAN;
1786
1787         if (frame->pts != AV_NOPTS_VALUE)
1788             dpts = av_q2d(is->video_st->time_base) * frame->pts;
1789
1790         frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
1791
1792         if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
1793             if (frame->pts != AV_NOPTS_VALUE) {
1794                 double diff = dpts - get_master_clock(is);
1795                 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD &&
1796                     diff - is->frame_last_filter_delay < 0 &&
1797                     is->viddec.pkt_serial == is->vidclk.serial &&
1798                     is->videoq.nb_packets) {
1799                     is->frame_drops_early++;
1800                     av_frame_unref(frame);
1801                     got_picture = 0;
1802                 }
1803             }
1804         }
1805     }
1806
1807     return got_picture;
1808 }
1809
1810 #if CONFIG_AVFILTER
1811 static int configure_filtergraph(AVFilterGraph *graph, const char *filtergraph,
1812                                  AVFilterContext *source_ctx, AVFilterContext *sink_ctx)
1813 {
1814     int ret, i;
1815     int nb_filters = graph->nb_filters;
1816     AVFilterInOut *outputs = NULL, *inputs = NULL;
1817
1818     if (filtergraph) {
1819         outputs = avfilter_inout_alloc();
1820         inputs  = avfilter_inout_alloc();
1821         if (!outputs || !inputs) {
1822             ret = AVERROR(ENOMEM);
1823             goto fail;
1824         }
1825
1826         outputs->name       = av_strdup("in");
1827         outputs->filter_ctx = source_ctx;
1828         outputs->pad_idx    = 0;
1829         outputs->next       = NULL;
1830
1831         inputs->name        = av_strdup("out");
1832         inputs->filter_ctx  = sink_ctx;
1833         inputs->pad_idx     = 0;
1834         inputs->next        = NULL;
1835
1836         if ((ret = avfilter_graph_parse_ptr(graph, filtergraph, &inputs, &outputs, NULL)) < 0)
1837             goto fail;
1838     } else {
1839         if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
1840             goto fail;
1841     }
1842
1843     /* Reorder the filters to ensure that inputs of the custom filters are merged first */
1844     for (i = 0; i < graph->nb_filters - nb_filters; i++)
1845         FFSWAP(AVFilterContext*, graph->filters[i], graph->filters[i + nb_filters]);
1846
1847     ret = avfilter_graph_config(graph, NULL);
1848 fail:
1849     avfilter_inout_free(&outputs);
1850     avfilter_inout_free(&inputs);
1851     return ret;
1852 }
1853
1854 static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const char *vfilters, AVFrame *frame)
1855 {
1856     enum AVPixelFormat pix_fmts[FF_ARRAY_ELEMS(sdl_texture_format_map)];
1857     char sws_flags_str[512] = "";
1858     char buffersrc_args[256];
1859     int ret;
1860     AVFilterContext *filt_src = NULL, *filt_out = NULL, *last_filter = NULL;
1861     AVCodecParameters *codecpar = is->video_st->codecpar;
1862     AVRational fr = av_guess_frame_rate(is->ic, is->video_st, NULL);
1863     AVDictionaryEntry *e = NULL;
1864     int nb_pix_fmts = 0;
1865     int i, j;
1866
1867     for (i = 0; i < renderer_info.num_texture_formats; i++) {
1868         for (j = 0; j < FF_ARRAY_ELEMS(sdl_texture_format_map) - 1; j++) {
1869             if (renderer_info.texture_formats[i] == sdl_texture_format_map[j].texture_fmt) {
1870                 pix_fmts[nb_pix_fmts++] = sdl_texture_format_map[j].format;
1871                 break;
1872             }
1873         }
1874     }
1875     pix_fmts[nb_pix_fmts] = AV_PIX_FMT_NONE;
1876
1877     while ((e = av_dict_get(sws_dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
1878         if (!strcmp(e->key, "sws_flags")) {
1879             av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", "flags", e->value);
1880         } else
1881             av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", e->key, e->value);
1882     }
1883     if (strlen(sws_flags_str))
1884         sws_flags_str[strlen(sws_flags_str)-1] = '\0';
1885
1886     graph->scale_sws_opts = av_strdup(sws_flags_str);
1887
1888     snprintf(buffersrc_args, sizeof(buffersrc_args),
1889              "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
1890              frame->width, frame->height, frame->format,
1891              is->video_st->time_base.num, is->video_st->time_base.den,
1892              codecpar->sample_aspect_ratio.num, FFMAX(codecpar->sample_aspect_ratio.den, 1));
1893     if (fr.num && fr.den)
1894         av_strlcatf(buffersrc_args, sizeof(buffersrc_args), ":frame_rate=%d/%d", fr.num, fr.den);
1895
1896     if ((ret = avfilter_graph_create_filter(&filt_src,
1897                                             avfilter_get_by_name("buffer"),
1898                                             "ffplay_buffer", buffersrc_args, NULL,
1899                                             graph)) < 0)
1900         goto fail;
1901
1902     ret = avfilter_graph_create_filter(&filt_out,
1903                                        avfilter_get_by_name("buffersink"),
1904                                        "ffplay_buffersink", NULL, NULL, graph);
1905     if (ret < 0)
1906         goto fail;
1907
1908     if ((ret = av_opt_set_int_list(filt_out, "pix_fmts", pix_fmts,  AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1909         goto fail;
1910
1911     last_filter = filt_out;
1912
1913 /* Note: this macro adds a filter before the lastly added filter, so the
1914  * processing order of the filters is in reverse */
1915 #define INSERT_FILT(name, arg) do {                                          \
1916     AVFilterContext *filt_ctx;                                               \
1917                                                                              \
1918     ret = avfilter_graph_create_filter(&filt_ctx,                            \
1919                                        avfilter_get_by_name(name),           \
1920                                        "ffplay_" name, arg, NULL, graph);    \
1921     if (ret < 0)                                                             \
1922         goto fail;                                                           \
1923                                                                              \
1924     ret = avfilter_link(filt_ctx, 0, last_filter, 0);                        \
1925     if (ret < 0)                                                             \
1926         goto fail;                                                           \
1927                                                                              \
1928     last_filter = filt_ctx;                                                  \
1929 } while (0)
1930
1931     if (autorotate) {
1932         double theta  = get_rotation(is->video_st);
1933
1934         if (fabs(theta - 90) < 1.0) {
1935             INSERT_FILT("transpose", "clock");
1936         } else if (fabs(theta - 180) < 1.0) {
1937             INSERT_FILT("hflip", NULL);
1938             INSERT_FILT("vflip", NULL);
1939         } else if (fabs(theta - 270) < 1.0) {
1940             INSERT_FILT("transpose", "cclock");
1941         } else if (fabs(theta) > 1.0) {
1942             char rotate_buf[64];
1943             snprintf(rotate_buf, sizeof(rotate_buf), "%f*PI/180", theta);
1944             INSERT_FILT("rotate", rotate_buf);
1945         }
1946     }
1947
1948     if ((ret = configure_filtergraph(graph, vfilters, filt_src, last_filter)) < 0)
1949         goto fail;
1950
1951     is->in_video_filter  = filt_src;
1952     is->out_video_filter = filt_out;
1953
1954 fail:
1955     return ret;
1956 }
1957
1958 static int configure_audio_filters(VideoState *is, const char *afilters, int force_output_format)
1959 {
1960     static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
1961     int sample_rates[2] = { 0, -1 };
1962     int64_t channel_layouts[2] = { 0, -1 };
1963     int channels[2] = { 0, -1 };
1964     AVFilterContext *filt_asrc = NULL, *filt_asink = NULL;
1965     char aresample_swr_opts[512] = "";
1966     AVDictionaryEntry *e = NULL;
1967     char asrc_args[256];
1968     int ret;
1969
1970     avfilter_graph_free(&is->agraph);
1971     if (!(is->agraph = avfilter_graph_alloc()))
1972         return AVERROR(ENOMEM);
1973     is->agraph->nb_threads = filter_nbthreads;
1974
1975     while ((e = av_dict_get(swr_opts, "", e, AV_DICT_IGNORE_SUFFIX)))
1976         av_strlcatf(aresample_swr_opts, sizeof(aresample_swr_opts), "%s=%s:", e->key, e->value);
1977     if (strlen(aresample_swr_opts))
1978         aresample_swr_opts[strlen(aresample_swr_opts)-1] = '\0';
1979     av_opt_set(is->agraph, "aresample_swr_opts", aresample_swr_opts, 0);
1980
1981     ret = snprintf(asrc_args, sizeof(asrc_args),
1982                    "sample_rate=%d:sample_fmt=%s:channels=%d:time_base=%d/%d",
1983                    is->audio_filter_src.freq, av_get_sample_fmt_name(is->audio_filter_src.fmt),
1984                    is->audio_filter_src.channels,
1985                    1, is->audio_filter_src.freq);
1986     if (is->audio_filter_src.channel_layout)
1987         snprintf(asrc_args + ret, sizeof(asrc_args) - ret,
1988                  ":channel_layout=0x%"PRIx64,  is->audio_filter_src.channel_layout);
1989
1990     ret = avfilter_graph_create_filter(&filt_asrc,
1991                                        avfilter_get_by_name("abuffer"), "ffplay_abuffer",
1992                                        asrc_args, NULL, is->agraph);
1993     if (ret < 0)
1994         goto end;
1995
1996
1997     ret = avfilter_graph_create_filter(&filt_asink,
1998                                        avfilter_get_by_name("abuffersink"), "ffplay_abuffersink",
1999                                        NULL, NULL, is->agraph);
2000     if (ret < 0)
2001         goto end;
2002
2003     if ((ret = av_opt_set_int_list(filt_asink, "sample_fmts", sample_fmts,  AV_SAMPLE_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
2004         goto end;
2005     if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 1, AV_OPT_SEARCH_CHILDREN)) < 0)
2006         goto end;
2007
2008     if (force_output_format) {
2009         channel_layouts[0] = is->audio_tgt.channel_layout;
2010         channels       [0] = is->audio_tgt.channel_layout ? -1 : is->audio_tgt.channels;
2011         sample_rates   [0] = is->audio_tgt.freq;
2012         if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 0, AV_OPT_SEARCH_CHILDREN)) < 0)
2013             goto end;
2014         if ((ret = av_opt_set_int_list(filt_asink, "channel_layouts", channel_layouts,  -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2015             goto end;
2016         if ((ret = av_opt_set_int_list(filt_asink, "channel_counts" , channels       ,  -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2017             goto end;
2018         if ((ret = av_opt_set_int_list(filt_asink, "sample_rates"   , sample_rates   ,  -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2019             goto end;
2020     }
2021
2022
2023     if ((ret = configure_filtergraph(is->agraph, afilters, filt_asrc, filt_asink)) < 0)
2024         goto end;
2025
2026     is->in_audio_filter  = filt_asrc;
2027     is->out_audio_filter = filt_asink;
2028
2029 end:
2030     if (ret < 0)
2031         avfilter_graph_free(&is->agraph);
2032     return ret;
2033 }
2034 #endif  /* CONFIG_AVFILTER */
2035
2036 static int audio_thread(void *arg)
2037 {
2038     VideoState *is = arg;
2039     AVFrame *frame = av_frame_alloc();
2040     Frame *af;
2041 #if CONFIG_AVFILTER
2042     int last_serial = -1;
2043     int64_t dec_channel_layout;
2044     int reconfigure;
2045 #endif
2046     int got_frame = 0;
2047     AVRational tb;
2048     int ret = 0;
2049
2050     if (!frame)
2051         return AVERROR(ENOMEM);
2052
2053     do {
2054         if ((got_frame = decoder_decode_frame(&is->auddec, frame, NULL)) < 0)
2055             goto the_end;
2056
2057         if (got_frame) {
2058                 tb = (AVRational){1, frame->sample_rate};
2059
2060 #if CONFIG_AVFILTER
2061                 dec_channel_layout = get_valid_channel_layout(frame->channel_layout, frame->channels);
2062
2063                 reconfigure =
2064                     cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
2065                                    frame->format, frame->channels)    ||
2066                     is->audio_filter_src.channel_layout != dec_channel_layout ||
2067                     is->audio_filter_src.freq           != frame->sample_rate ||
2068                     is->auddec.pkt_serial               != last_serial;
2069
2070                 if (reconfigure) {
2071                     char buf1[1024], buf2[1024];
2072                     av_get_channel_layout_string(buf1, sizeof(buf1), -1, is->audio_filter_src.channel_layout);
2073                     av_get_channel_layout_string(buf2, sizeof(buf2), -1, dec_channel_layout);
2074                     av_log(NULL, AV_LOG_DEBUG,
2075                            "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",
2076                            is->audio_filter_src.freq, is->audio_filter_src.channels, av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, last_serial,
2077                            frame->sample_rate, frame->channels, av_get_sample_fmt_name(frame->format), buf2, is->auddec.pkt_serial);
2078
2079                     is->audio_filter_src.fmt            = frame->format;
2080                     is->audio_filter_src.channels       = frame->channels;
2081                     is->audio_filter_src.channel_layout = dec_channel_layout;
2082                     is->audio_filter_src.freq           = frame->sample_rate;
2083                     last_serial                         = is->auddec.pkt_serial;
2084
2085                     if ((ret = configure_audio_filters(is, afilters, 1)) < 0)
2086                         goto the_end;
2087                 }
2088
2089             if ((ret = av_buffersrc_add_frame(is->in_audio_filter, frame)) < 0)
2090                 goto the_end;
2091
2092             while ((ret = av_buffersink_get_frame_flags(is->out_audio_filter, frame, 0)) >= 0) {
2093                 tb = av_buffersink_get_time_base(is->out_audio_filter);
2094 #endif
2095                 if (!(af = frame_queue_peek_writable(&is->sampq)))
2096                     goto the_end;
2097
2098                 af->pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2099                 af->pos = frame->pkt_pos;
2100                 af->serial = is->auddec.pkt_serial;
2101                 af->duration = av_q2d((AVRational){frame->nb_samples, frame->sample_rate});
2102
2103                 av_frame_move_ref(af->frame, frame);
2104                 frame_queue_push(&is->sampq);
2105
2106 #if CONFIG_AVFILTER
2107                 if (is->audioq.serial != is->auddec.pkt_serial)
2108                     break;
2109             }
2110             if (ret == AVERROR_EOF)
2111                 is->auddec.finished = is->auddec.pkt_serial;
2112 #endif
2113         }
2114     } while (ret >= 0 || ret == AVERROR(EAGAIN) || ret == AVERROR_EOF);
2115  the_end:
2116 #if CONFIG_AVFILTER
2117     avfilter_graph_free(&is->agraph);
2118 #endif
2119     av_frame_free(&frame);
2120     return ret;
2121 }
2122
2123 static int decoder_start(Decoder *d, int (*fn)(void *), const char *thread_name, void* arg)
2124 {
2125     packet_queue_start(d->queue);
2126     d->decoder_tid = SDL_CreateThread(fn, thread_name, arg);
2127     if (!d->decoder_tid) {
2128         av_log(NULL, AV_LOG_ERROR, "SDL_CreateThread(): %s\n", SDL_GetError());
2129         return AVERROR(ENOMEM);
2130     }
2131     return 0;
2132 }
2133
2134 static int video_thread(void *arg)
2135 {
2136     VideoState *is = arg;
2137     AVFrame *frame = av_frame_alloc();
2138     double pts;
2139     double duration;
2140     int ret;
2141     AVRational tb = is->video_st->time_base;
2142     AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);
2143
2144 #if CONFIG_AVFILTER
2145     AVFilterGraph *graph = NULL;
2146     AVFilterContext *filt_out = NULL, *filt_in = NULL;
2147     int last_w = 0;
2148     int last_h = 0;
2149     enum AVPixelFormat last_format = -2;
2150     int last_serial = -1;
2151     int last_vfilter_idx = 0;
2152 #endif
2153
2154     if (!frame)
2155         return AVERROR(ENOMEM);
2156
2157     for (;;) {
2158         ret = get_video_frame(is, frame);
2159         if (ret < 0)
2160             goto the_end;
2161         if (!ret)
2162             continue;
2163
2164 #if CONFIG_AVFILTER
2165         if (   last_w != frame->width
2166             || last_h != frame->height
2167             || last_format != frame->format
2168             || last_serial != is->viddec.pkt_serial
2169             || last_vfilter_idx != is->vfilter_idx) {
2170             av_log(NULL, AV_LOG_DEBUG,
2171                    "Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
2172                    last_w, last_h,
2173                    (const char *)av_x_if_null(av_get_pix_fmt_name(last_format), "none"), last_serial,
2174                    frame->width, frame->height,
2175                    (const char *)av_x_if_null(av_get_pix_fmt_name(frame->format), "none"), is->viddec.pkt_serial);
2176             avfilter_graph_free(&graph);
2177             graph = avfilter_graph_alloc();
2178             if (!graph) {
2179                 ret = AVERROR(ENOMEM);
2180                 goto the_end;
2181             }
2182             graph->nb_threads = filter_nbthreads;
2183             if ((ret = configure_video_filters(graph, is, vfilters_list ? vfilters_list[is->vfilter_idx] : NULL, frame)) < 0) {
2184                 SDL_Event event;
2185                 event.type = FF_QUIT_EVENT;
2186                 event.user.data1 = is;
2187                 SDL_PushEvent(&event);
2188                 goto the_end;
2189             }
2190             filt_in  = is->in_video_filter;
2191             filt_out = is->out_video_filter;
2192             last_w = frame->width;
2193             last_h = frame->height;
2194             last_format = frame->format;
2195             last_serial = is->viddec.pkt_serial;
2196             last_vfilter_idx = is->vfilter_idx;
2197             frame_rate = av_buffersink_get_frame_rate(filt_out);
2198         }
2199
2200         ret = av_buffersrc_add_frame(filt_in, frame);
2201         if (ret < 0)
2202             goto the_end;
2203
2204         while (ret >= 0) {
2205             is->frame_last_returned_time = av_gettime_relative() / 1000000.0;
2206
2207             ret = av_buffersink_get_frame_flags(filt_out, frame, 0);
2208             if (ret < 0) {
2209                 if (ret == AVERROR_EOF)
2210                     is->viddec.finished = is->viddec.pkt_serial;
2211                 ret = 0;
2212                 break;
2213             }
2214
2215             is->frame_last_filter_delay = av_gettime_relative() / 1000000.0 - is->frame_last_returned_time;
2216             if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
2217                 is->frame_last_filter_delay = 0;
2218             tb = av_buffersink_get_time_base(filt_out);
2219 #endif
2220             duration = (frame_rate.num && frame_rate.den ? av_q2d((AVRational){frame_rate.den, frame_rate.num}) : 0);
2221             pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2222             ret = queue_picture(is, frame, pts, duration, frame->pkt_pos, is->viddec.pkt_serial);
2223             av_frame_unref(frame);
2224 #if CONFIG_AVFILTER
2225             if (is->videoq.serial != is->viddec.pkt_serial)
2226                 break;
2227         }
2228 #endif
2229
2230         if (ret < 0)
2231             goto the_end;
2232     }
2233  the_end:
2234 #if CONFIG_AVFILTER
2235     avfilter_graph_free(&graph);
2236 #endif
2237     av_frame_free(&frame);
2238     return 0;
2239 }
2240
2241 static int subtitle_thread(void *arg)
2242 {
2243     VideoState *is = arg;
2244     Frame *sp;
2245     int got_subtitle;
2246     double pts;
2247
2248     for (;;) {
2249         if (!(sp = frame_queue_peek_writable(&is->subpq)))
2250             return 0;
2251
2252         if ((got_subtitle = decoder_decode_frame(&is->subdec, NULL, &sp->sub)) < 0)
2253             break;
2254
2255         pts = 0;
2256
2257         if (got_subtitle && sp->sub.format == 0) {
2258             if (sp->sub.pts != AV_NOPTS_VALUE)
2259                 pts = sp->sub.pts / (double)AV_TIME_BASE;
2260             sp->pts = pts;
2261             sp->serial = is->subdec.pkt_serial;
2262             sp->width = is->subdec.avctx->width;
2263             sp->height = is->subdec.avctx->height;
2264             sp->uploaded = 0;
2265
2266             /* now we can update the picture count */
2267             frame_queue_push(&is->subpq);
2268         } else if (got_subtitle) {
2269             avsubtitle_free(&sp->sub);
2270         }
2271     }
2272     return 0;
2273 }
2274
2275 /* copy samples for viewing in editor window */
2276 static void update_sample_display(VideoState *is, short *samples, int samples_size)
2277 {
2278     int size, len;
2279
2280     size = samples_size / sizeof(short);
2281     while (size > 0) {
2282         len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
2283         if (len > size)
2284             len = size;
2285         memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
2286         samples += len;
2287         is->sample_array_index += len;
2288         if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
2289             is->sample_array_index = 0;
2290         size -= len;
2291     }
2292 }
2293
2294 /* return the wanted number of samples to get better sync if sync_type is video
2295  * or external master clock */
2296 static int synchronize_audio(VideoState *is, int nb_samples)
2297 {
2298     int wanted_nb_samples = nb_samples;
2299
2300     /* if not master, then we try to remove or add samples to correct the clock */
2301     if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
2302         double diff, avg_diff;
2303         int min_nb_samples, max_nb_samples;
2304
2305         diff = get_clock(&is->audclk) - get_master_clock(is);
2306
2307         if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD) {
2308             is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
2309             if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
2310                 /* not enough measures to have a correct estimate */
2311                 is->audio_diff_avg_count++;
2312             } else {
2313                 /* estimate the A-V difference */
2314                 avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
2315
2316                 if (fabs(avg_diff) >= is->audio_diff_threshold) {
2317                     wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);
2318                     min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2319                     max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2320                     wanted_nb_samples = av_clip(wanted_nb_samples, min_nb_samples, max_nb_samples);
2321                 }
2322                 av_log(NULL, AV_LOG_TRACE, "diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
2323                         diff, avg_diff, wanted_nb_samples - nb_samples,
2324                         is->audio_clock, is->audio_diff_threshold);
2325             }
2326         } else {
2327             /* too big difference : may be initial PTS errors, so
2328                reset A-V filter */
2329             is->audio_diff_avg_count = 0;
2330             is->audio_diff_cum       = 0;
2331         }
2332     }
2333
2334     return wanted_nb_samples;
2335 }
2336
2337 /**
2338  * Decode one audio frame and return its uncompressed size.
2339  *
2340  * The processed audio frame is decoded, converted if required, and
2341  * stored in is->audio_buf, with size in bytes given by the return
2342  * value.
2343  */
2344 static int audio_decode_frame(VideoState *is)
2345 {
2346     int data_size, resampled_data_size;
2347     int64_t dec_channel_layout;
2348     av_unused double audio_clock0;
2349     int wanted_nb_samples;
2350     Frame *af;
2351
2352     if (is->paused)
2353         return -1;
2354
2355     do {
2356 #if defined(_WIN32)
2357         while (frame_queue_nb_remaining(&is->sampq) == 0) {
2358             if ((av_gettime_relative() - audio_callback_time) > 1000000LL * is->audio_hw_buf_size / is->audio_tgt.bytes_per_sec / 2)
2359                 return -1;
2360             av_usleep (1000);
2361         }
2362 #endif
2363         if (!(af = frame_queue_peek_readable(&is->sampq)))
2364             return -1;
2365         frame_queue_next(&is->sampq);
2366     } while (af->serial != is->audioq.serial);
2367
2368     data_size = av_samples_get_buffer_size(NULL, af->frame->channels,
2369                                            af->frame->nb_samples,
2370                                            af->frame->format, 1);
2371
2372     dec_channel_layout =
2373         (af->frame->channel_layout && af->frame->channels == av_get_channel_layout_nb_channels(af->frame->channel_layout)) ?
2374         af->frame->channel_layout : av_get_default_channel_layout(af->frame->channels);
2375     wanted_nb_samples = synchronize_audio(is, af->frame->nb_samples);
2376
2377     if (af->frame->format        != is->audio_src.fmt            ||
2378         dec_channel_layout       != is->audio_src.channel_layout ||
2379         af->frame->sample_rate   != is->audio_src.freq           ||
2380         (wanted_nb_samples       != af->frame->nb_samples && !is->swr_ctx)) {
2381         swr_free(&is->swr_ctx);
2382         is->swr_ctx = swr_alloc_set_opts(NULL,
2383                                          is->audio_tgt.channel_layout, is->audio_tgt.fmt, is->audio_tgt.freq,
2384                                          dec_channel_layout,           af->frame->format, af->frame->sample_rate,
2385                                          0, NULL);
2386         if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
2387             av_log(NULL, AV_LOG_ERROR,
2388                    "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
2389                     af->frame->sample_rate, av_get_sample_fmt_name(af->frame->format), af->frame->channels,
2390                     is->audio_tgt.freq, av_get_sample_fmt_name(is->audio_tgt.fmt), is->audio_tgt.channels);
2391             swr_free(&is->swr_ctx);
2392             return -1;
2393         }
2394         is->audio_src.channel_layout = dec_channel_layout;
2395         is->audio_src.channels       = af->frame->channels;
2396         is->audio_src.freq = af->frame->sample_rate;
2397         is->audio_src.fmt = af->frame->format;
2398     }
2399
2400     if (is->swr_ctx) {
2401         const uint8_t **in = (const uint8_t **)af->frame->extended_data;
2402         uint8_t **out = &is->audio_buf1;
2403         int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate + 256;
2404         int out_size  = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, out_count, is->audio_tgt.fmt, 0);
2405         int len2;
2406         if (out_size < 0) {
2407             av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size() failed\n");
2408             return -1;
2409         }
2410         if (wanted_nb_samples != af->frame->nb_samples) {
2411             if (swr_set_compensation(is->swr_ctx, (wanted_nb_samples - af->frame->nb_samples) * is->audio_tgt.freq / af->frame->sample_rate,
2412                                         wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate) < 0) {
2413                 av_log(NULL, AV_LOG_ERROR, "swr_set_compensation() failed\n");
2414                 return -1;
2415             }
2416         }
2417         av_fast_malloc(&is->audio_buf1, &is->audio_buf1_size, out_size);
2418         if (!is->audio_buf1)
2419             return AVERROR(ENOMEM);
2420         len2 = swr_convert(is->swr_ctx, out, out_count, in, af->frame->nb_samples);
2421         if (len2 < 0) {
2422             av_log(NULL, AV_LOG_ERROR, "swr_convert() failed\n");
2423             return -1;
2424         }
2425         if (len2 == out_count) {
2426             av_log(NULL, AV_LOG_WARNING, "audio buffer is probably too small\n");
2427             if (swr_init(is->swr_ctx) < 0)
2428                 swr_free(&is->swr_ctx);
2429         }
2430         is->audio_buf = is->audio_buf1;
2431         resampled_data_size = len2 * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2432     } else {
2433         is->audio_buf = af->frame->data[0];
2434         resampled_data_size = data_size;
2435     }
2436
2437     audio_clock0 = is->audio_clock;
2438     /* update the audio clock with the pts */
2439     if (!isnan(af->pts))
2440         is->audio_clock = af->pts + (double) af->frame->nb_samples / af->frame->sample_rate;
2441     else
2442         is->audio_clock = NAN;
2443     is->audio_clock_serial = af->serial;
2444 #ifdef DEBUG
2445     {
2446         static double last_clock;
2447         printf("audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
2448                is->audio_clock - last_clock,
2449                is->audio_clock, audio_clock0);
2450         last_clock = is->audio_clock;
2451     }
2452 #endif
2453     return resampled_data_size;
2454 }
2455
2456 /* prepare a new audio buffer */
2457 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
2458 {
2459     VideoState *is = opaque;
2460     int audio_size, len1;
2461
2462     audio_callback_time = av_gettime_relative();
2463
2464     while (len > 0) {
2465         if (is->audio_buf_index >= is->audio_buf_size) {
2466            audio_size = audio_decode_frame(is);
2467            if (audio_size < 0) {
2468                 /* if error, just output silence */
2469                is->audio_buf = NULL;
2470                is->audio_buf_size = SDL_AUDIO_MIN_BUFFER_SIZE / is->audio_tgt.frame_size * is->audio_tgt.frame_size;
2471            } else {
2472                if (is->show_mode != SHOW_MODE_VIDEO)
2473                    update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
2474                is->audio_buf_size = audio_size;
2475            }
2476            is->audio_buf_index = 0;
2477         }
2478         len1 = is->audio_buf_size - is->audio_buf_index;
2479         if (len1 > len)
2480             len1 = len;
2481         if (!is->muted && is->audio_buf && is->audio_volume == SDL_MIX_MAXVOLUME)
2482             memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
2483         else {
2484             memset(stream, 0, len1);
2485             if (!is->muted && is->audio_buf)
2486                 SDL_MixAudioFormat(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, AUDIO_S16SYS, len1, is->audio_volume);
2487         }
2488         len -= len1;
2489         stream += len1;
2490         is->audio_buf_index += len1;
2491     }
2492     is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
2493     /* Let's assume the audio driver that is used by SDL has two periods. */
2494     if (!isnan(is->audio_clock)) {
2495         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);
2496         sync_clock_to_slave(&is->extclk, &is->audclk);
2497     }
2498 }
2499
2500 static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
2501 {
2502     SDL_AudioSpec wanted_spec, spec;
2503     const char *env;
2504     static const int next_nb_channels[] = {0, 0, 1, 6, 2, 6, 4, 6};
2505     static const int next_sample_rates[] = {0, 44100, 48000, 96000, 192000};
2506     int next_sample_rate_idx = FF_ARRAY_ELEMS(next_sample_rates) - 1;
2507
2508     env = SDL_getenv("SDL_AUDIO_CHANNELS");
2509     if (env) {
2510         wanted_nb_channels = atoi(env);
2511         wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2512     }
2513     if (!wanted_channel_layout || wanted_nb_channels != av_get_channel_layout_nb_channels(wanted_channel_layout)) {
2514         wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2515         wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
2516     }
2517     wanted_nb_channels = av_get_channel_layout_nb_channels(wanted_channel_layout);
2518     wanted_spec.channels = wanted_nb_channels;
2519     wanted_spec.freq = wanted_sample_rate;
2520     if (wanted_spec.freq <= 0 || wanted_spec.channels <= 0) {
2521         av_log(NULL, AV_LOG_ERROR, "Invalid sample rate or channel count!\n");
2522         return -1;
2523     }
2524     while (next_sample_rate_idx && next_sample_rates[next_sample_rate_idx] >= wanted_spec.freq)
2525         next_sample_rate_idx--;
2526     wanted_spec.format = AUDIO_S16SYS;
2527     wanted_spec.silence = 0;
2528     wanted_spec.samples = FFMAX(SDL_AUDIO_MIN_BUFFER_SIZE, 2 << av_log2(wanted_spec.freq / SDL_AUDIO_MAX_CALLBACKS_PER_SEC));
2529     wanted_spec.callback = sdl_audio_callback;
2530     wanted_spec.userdata = opaque;
2531     while (!(audio_dev = SDL_OpenAudioDevice(NULL, 0, &wanted_spec, &spec, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE | SDL_AUDIO_ALLOW_CHANNELS_CHANGE))) {
2532         av_log(NULL, AV_LOG_WARNING, "SDL_OpenAudio (%d channels, %d Hz): %s\n",
2533                wanted_spec.channels, wanted_spec.freq, SDL_GetError());
2534         wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
2535         if (!wanted_spec.channels) {
2536             wanted_spec.freq = next_sample_rates[next_sample_rate_idx--];
2537             wanted_spec.channels = wanted_nb_channels;
2538             if (!wanted_spec.freq) {
2539                 av_log(NULL, AV_LOG_ERROR,
2540                        "No more combinations to try, audio open failed\n");
2541                 return -1;
2542             }
2543         }
2544         wanted_channel_layout = av_get_default_channel_layout(wanted_spec.channels);
2545     }
2546     if (spec.format != AUDIO_S16SYS) {
2547         av_log(NULL, AV_LOG_ERROR,
2548                "SDL advised audio format %d is not supported!\n", spec.format);
2549         return -1;
2550     }
2551     if (spec.channels != wanted_spec.channels) {
2552         wanted_channel_layout = av_get_default_channel_layout(spec.channels);
2553         if (!wanted_channel_layout) {
2554             av_log(NULL, AV_LOG_ERROR,
2555                    "SDL advised channel count %d is not supported!\n", spec.channels);
2556             return -1;
2557         }
2558     }
2559
2560     audio_hw_params->fmt = AV_SAMPLE_FMT_S16;
2561     audio_hw_params->freq = spec.freq;
2562     audio_hw_params->channel_layout = wanted_channel_layout;
2563     audio_hw_params->channels =  spec.channels;
2564     audio_hw_params->frame_size = av_samples_get_buffer_size(NULL, audio_hw_params->channels, 1, audio_hw_params->fmt, 1);
2565     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);
2566     if (audio_hw_params->bytes_per_sec <= 0 || audio_hw_params->frame_size <= 0) {
2567         av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size failed\n");
2568         return -1;
2569     }
2570     return spec.size;
2571 }
2572
2573 /* open a given stream. Return 0 if OK */
2574 static int stream_component_open(VideoState *is, int stream_index)
2575 {
2576     AVFormatContext *ic = is->ic;
2577     AVCodecContext *avctx;
2578     AVCodec *codec;
2579     const char *forced_codec_name = NULL;
2580     AVDictionary *opts = NULL;
2581     AVDictionaryEntry *t = NULL;
2582     int sample_rate, nb_channels;
2583     int64_t channel_layout;
2584     int ret = 0;
2585     int stream_lowres = lowres;
2586
2587     if (stream_index < 0 || stream_index >= ic->nb_streams)
2588         return -1;
2589
2590     avctx = avcodec_alloc_context3(NULL);
2591     if (!avctx)
2592         return AVERROR(ENOMEM);
2593
2594     ret = avcodec_parameters_to_context(avctx, ic->streams[stream_index]->codecpar);
2595     if (ret < 0)
2596         goto fail;
2597     avctx->pkt_timebase = ic->streams[stream_index]->time_base;
2598
2599     codec = avcodec_find_decoder(avctx->codec_id);
2600
2601     switch(avctx->codec_type){
2602         case AVMEDIA_TYPE_AUDIO   : is->last_audio_stream    = stream_index; forced_codec_name =    audio_codec_name; break;
2603         case AVMEDIA_TYPE_SUBTITLE: is->last_subtitle_stream = stream_index; forced_codec_name = subtitle_codec_name; break;
2604         case AVMEDIA_TYPE_VIDEO   : is->last_video_stream    = stream_index; forced_codec_name =    video_codec_name; break;
2605     }
2606     if (forced_codec_name)
2607         codec = avcodec_find_decoder_by_name(forced_codec_name);
2608     if (!codec) {
2609         if (forced_codec_name) av_log(NULL, AV_LOG_WARNING,
2610                                       "No codec could be found with name '%s'\n", forced_codec_name);
2611         else                   av_log(NULL, AV_LOG_WARNING,
2612                                       "No decoder could be found for codec %s\n", avcodec_get_name(avctx->codec_id));
2613         ret = AVERROR(EINVAL);
2614         goto fail;
2615     }
2616
2617     avctx->codec_id = codec->id;
2618     if (stream_lowres > codec->max_lowres) {
2619         av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2620                 codec->max_lowres);
2621         stream_lowres = codec->max_lowres;
2622     }
2623     avctx->lowres = stream_lowres;
2624
2625     if (fast)
2626         avctx->flags2 |= AV_CODEC_FLAG2_FAST;
2627
2628     opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
2629     if (!av_dict_get(opts, "threads", NULL, 0))
2630         av_dict_set(&opts, "threads", "auto", 0);
2631     if (stream_lowres)
2632         av_dict_set_int(&opts, "lowres", stream_lowres, 0);
2633     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
2634         av_dict_set(&opts, "refcounted_frames", "1", 0);
2635     if ((ret = avcodec_open2(avctx, codec, &opts)) < 0) {
2636         goto fail;
2637     }
2638     if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2639         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2640         ret =  AVERROR_OPTION_NOT_FOUND;
2641         goto fail;
2642     }
2643
2644     is->eof = 0;
2645     ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
2646     switch (avctx->codec_type) {
2647     case AVMEDIA_TYPE_AUDIO:
2648 #if CONFIG_AVFILTER
2649         {
2650             AVFilterContext *sink;
2651
2652             is->audio_filter_src.freq           = avctx->sample_rate;
2653             is->audio_filter_src.channels       = avctx->channels;
2654             is->audio_filter_src.channel_layout = get_valid_channel_layout(avctx->channel_layout, avctx->channels);
2655             is->audio_filter_src.fmt            = avctx->sample_fmt;
2656             if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
2657                 goto fail;
2658             sink = is->out_audio_filter;
2659             sample_rate    = av_buffersink_get_sample_rate(sink);
2660             nb_channels    = av_buffersink_get_channels(sink);
2661             channel_layout = av_buffersink_get_channel_layout(sink);
2662         }
2663 #else
2664         sample_rate    = avctx->sample_rate;
2665         nb_channels    = avctx->channels;
2666         channel_layout = avctx->channel_layout;
2667 #endif
2668
2669         /* prepare audio output */
2670         if ((ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)) < 0)
2671             goto fail;
2672         is->audio_hw_buf_size = ret;
2673         is->audio_src = is->audio_tgt;
2674         is->audio_buf_size  = 0;
2675         is->audio_buf_index = 0;
2676
2677         /* init averaging filter */
2678         is->audio_diff_avg_coef  = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
2679         is->audio_diff_avg_count = 0;
2680         /* since we do not have a precise anough audio FIFO fullness,
2681            we correct audio sync only if larger than this threshold */
2682         is->audio_diff_threshold = (double)(is->audio_hw_buf_size) / is->audio_tgt.bytes_per_sec;
2683
2684         is->audio_stream = stream_index;
2685         is->audio_st = ic->streams[stream_index];
2686
2687         if ((ret = decoder_init(&is->auddec, avctx, &is->audioq, is->continue_read_thread)) < 0)
2688             goto fail;
2689         if ((is->ic->iformat->flags & (AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH | AVFMT_NO_BYTE_SEEK)) && !is->ic->iformat->read_seek) {
2690             is->auddec.start_pts = is->audio_st->start_time;
2691             is->auddec.start_pts_tb = is->audio_st->time_base;
2692         }
2693         if ((ret = decoder_start(&is->auddec, audio_thread, "audio_decoder", is)) < 0)
2694             goto out;
2695         SDL_PauseAudioDevice(audio_dev, 0);
2696         break;
2697     case AVMEDIA_TYPE_VIDEO:
2698         is->video_stream = stream_index;
2699         is->video_st = ic->streams[stream_index];
2700
2701         if ((ret = decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread)) < 0)
2702             goto fail;
2703         if ((ret = decoder_start(&is->viddec, video_thread, "video_decoder", is)) < 0)
2704             goto out;
2705         is->queue_attachments_req = 1;
2706         break;
2707     case AVMEDIA_TYPE_SUBTITLE:
2708         is->subtitle_stream = stream_index;
2709         is->subtitle_st = ic->streams[stream_index];
2710
2711         if ((ret = decoder_init(&is->subdec, avctx, &is->subtitleq, is->continue_read_thread)) < 0)
2712             goto fail;
2713         if ((ret = decoder_start(&is->subdec, subtitle_thread, "subtitle_decoder", is)) < 0)
2714             goto out;
2715         break;
2716     default:
2717         break;
2718     }
2719     goto out;
2720
2721 fail:
2722     avcodec_free_context(&avctx);
2723 out:
2724     av_dict_free(&opts);
2725
2726     return ret;
2727 }
2728
2729 static int decode_interrupt_cb(void *ctx)
2730 {
2731     VideoState *is = ctx;
2732     return is->abort_request;
2733 }
2734
2735 static int stream_has_enough_packets(AVStream *st, int stream_id, PacketQueue *queue) {
2736     return stream_id < 0 ||
2737            queue->abort_request ||
2738            (st->disposition & AV_DISPOSITION_ATTACHED_PIC) ||
2739            queue->nb_packets > MIN_FRAMES && (!queue->duration || av_q2d(st->time_base) * queue->duration > 1.0);
2740 }
2741
2742 static int is_realtime(AVFormatContext *s)
2743 {
2744     if(   !strcmp(s->iformat->name, "rtp")
2745        || !strcmp(s->iformat->name, "rtsp")
2746        || !strcmp(s->iformat->name, "sdp")
2747     )
2748         return 1;
2749
2750     if(s->pb && (   !strncmp(s->url, "rtp:", 4)
2751                  || !strncmp(s->url, "udp:", 4)
2752                 )
2753     )
2754         return 1;
2755     return 0;
2756 }
2757
2758 /* this thread gets the stream from the disk or the network */
2759 static int read_thread(void *arg)
2760 {
2761     VideoState *is = arg;
2762     AVFormatContext *ic = NULL;
2763     int err, i, ret;
2764     int st_index[AVMEDIA_TYPE_NB];
2765     AVPacket *pkt = NULL;
2766     int64_t stream_start_time;
2767     int pkt_in_play_range = 0;
2768     AVDictionaryEntry *t;
2769     SDL_mutex *wait_mutex = SDL_CreateMutex();
2770     int scan_all_pmts_set = 0;
2771     int64_t pkt_ts;
2772
2773     if (!wait_mutex) {
2774         av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
2775         ret = AVERROR(ENOMEM);
2776         goto fail;
2777     }
2778
2779     memset(st_index, -1, sizeof(st_index));
2780     is->eof = 0;
2781
2782     pkt = av_packet_alloc();
2783     if (!pkt) {
2784         av_log(NULL, AV_LOG_FATAL, "Could not allocate packet.\n");
2785         ret = AVERROR(ENOMEM);
2786         goto fail;
2787     }
2788     ic = avformat_alloc_context();
2789     if (!ic) {
2790         av_log(NULL, AV_LOG_FATAL, "Could not allocate context.\n");
2791         ret = AVERROR(ENOMEM);
2792         goto fail;
2793     }
2794     ic->interrupt_callback.callback = decode_interrupt_cb;
2795     ic->interrupt_callback.opaque = is;
2796     if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
2797         av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
2798         scan_all_pmts_set = 1;
2799     }
2800     err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
2801     if (err < 0) {
2802         print_error(is->filename, err);
2803         ret = -1;
2804         goto fail;
2805     }
2806     if (scan_all_pmts_set)
2807         av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
2808
2809     if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2810         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2811         ret = AVERROR_OPTION_NOT_FOUND;
2812         goto fail;
2813     }
2814     is->ic = ic;
2815
2816     if (genpts)
2817         ic->flags |= AVFMT_FLAG_GENPTS;
2818
2819     av_format_inject_global_side_data(ic);
2820
2821     if (find_stream_info) {
2822         AVDictionary **opts = setup_find_stream_info_opts(ic, codec_opts);
2823         int orig_nb_streams = ic->nb_streams;
2824
2825         err = avformat_find_stream_info(ic, opts);
2826
2827         for (i = 0; i < orig_nb_streams; i++)
2828             av_dict_free(&opts[i]);
2829         av_freep(&opts);
2830
2831         if (err < 0) {
2832             av_log(NULL, AV_LOG_WARNING,
2833                    "%s: could not find codec parameters\n", is->filename);
2834             ret = -1;
2835             goto fail;
2836         }
2837     }
2838
2839     if (ic->pb)
2840         ic->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use avio_feof() to test for the end
2841
2842     if (seek_by_bytes < 0)
2843         seek_by_bytes = !!(ic->iformat->flags & AVFMT_TS_DISCONT) && strcmp("ogg", ic->iformat->name);
2844
2845     is->max_frame_duration = (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;
2846
2847     if (!window_title && (t = av_dict_get(ic->metadata, "title", NULL, 0)))
2848         window_title = av_asprintf("%s - %s", t->value, input_filename);
2849
2850     /* if seeking requested, we execute it */
2851     if (start_time != AV_NOPTS_VALUE) {
2852         int64_t timestamp;
2853
2854         timestamp = start_time;
2855         /* add the stream start time */
2856         if (ic->start_time != AV_NOPTS_VALUE)
2857             timestamp += ic->start_time;
2858         ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
2859         if (ret < 0) {
2860             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2861                     is->filename, (double)timestamp / AV_TIME_BASE);
2862         }
2863     }
2864
2865     is->realtime = is_realtime(ic);
2866
2867     if (show_status)
2868         av_dump_format(ic, 0, is->filename, 0);
2869
2870     for (i = 0; i < ic->nb_streams; i++) {
2871         AVStream *st = ic->streams[i];
2872         enum AVMediaType type = st->codecpar->codec_type;
2873         st->discard = AVDISCARD_ALL;
2874         if (type >= 0 && wanted_stream_spec[type] && st_index[type] == -1)
2875             if (avformat_match_stream_specifier(ic, st, wanted_stream_spec[type]) > 0)
2876                 st_index[type] = i;
2877     }
2878     for (i = 0; i < AVMEDIA_TYPE_NB; i++) {
2879         if (wanted_stream_spec[i] && st_index[i] == -1) {
2880             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));
2881             st_index[i] = INT_MAX;
2882         }
2883     }
2884
2885     if (!video_disable)
2886         st_index[AVMEDIA_TYPE_VIDEO] =
2887             av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
2888                                 st_index[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
2889     if (!audio_disable)
2890         st_index[AVMEDIA_TYPE_AUDIO] =
2891             av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
2892                                 st_index[AVMEDIA_TYPE_AUDIO],
2893                                 st_index[AVMEDIA_TYPE_VIDEO],
2894                                 NULL, 0);
2895     if (!video_disable && !subtitle_disable)
2896         st_index[AVMEDIA_TYPE_SUBTITLE] =
2897             av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
2898                                 st_index[AVMEDIA_TYPE_SUBTITLE],
2899                                 (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
2900                                  st_index[AVMEDIA_TYPE_AUDIO] :
2901                                  st_index[AVMEDIA_TYPE_VIDEO]),
2902                                 NULL, 0);
2903
2904     is->show_mode = show_mode;
2905     if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2906         AVStream *st = ic->streams[st_index[AVMEDIA_TYPE_VIDEO]];
2907         AVCodecParameters *codecpar = st->codecpar;
2908         AVRational sar = av_guess_sample_aspect_ratio(ic, st, NULL);
2909         if (codecpar->width)
2910             set_default_window_size(codecpar->width, codecpar->height, sar);
2911     }
2912
2913     /* open the streams */
2914     if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
2915         stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
2916     }
2917
2918     ret = -1;
2919     if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2920         ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
2921     }
2922     if (is->show_mode == SHOW_MODE_NONE)
2923         is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
2924
2925     if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
2926         stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
2927     }
2928
2929     if (is->video_stream < 0 && is->audio_stream < 0) {
2930         av_log(NULL, AV_LOG_FATAL, "Failed to open file '%s' or configure filtergraph\n",
2931                is->filename);
2932         ret = -1;
2933         goto fail;
2934     }
2935
2936     if (infinite_buffer < 0 && is->realtime)
2937         infinite_buffer = 1;
2938
2939     for (;;) {
2940         if (is->abort_request)
2941             break;
2942         if (is->paused != is->last_paused) {
2943             is->last_paused = is->paused;
2944             if (is->paused)
2945                 is->read_pause_return = av_read_pause(ic);
2946             else
2947                 av_read_play(ic);
2948         }
2949 #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
2950         if (is->paused &&
2951                 (!strcmp(ic->iformat->name, "rtsp") ||
2952                  (ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
2953             /* wait 10 ms to avoid trying to get another packet */
2954             /* XXX: horrible */
2955             SDL_Delay(10);
2956             continue;
2957         }
2958 #endif
2959         if (is->seek_req) {
2960             int64_t seek_target = is->seek_pos;
2961             int64_t seek_min    = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
2962             int64_t seek_max    = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
2963 // FIXME the +-2 is due to rounding being not done in the correct direction in generation
2964 //      of the seek_pos/seek_rel variables
2965
2966             ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
2967             if (ret < 0) {
2968                 av_log(NULL, AV_LOG_ERROR,
2969                        "%s: error while seeking\n", is->ic->url);
2970             } else {
2971                 if (is->audio_stream >= 0) {
2972                     packet_queue_flush(&is->audioq);
2973                 }
2974                 if (is->subtitle_stream >= 0) {
2975                     packet_queue_flush(&is->subtitleq);
2976                 }
2977                 if (is->video_stream >= 0) {
2978                     packet_queue_flush(&is->videoq);
2979                 }
2980                 if (is->seek_flags & AVSEEK_FLAG_BYTE) {
2981                    set_clock(&is->extclk, NAN, 0);
2982                 } else {
2983                    set_clock(&is->extclk, seek_target / (double)AV_TIME_BASE, 0);
2984                 }
2985             }
2986             is->seek_req = 0;
2987             is->queue_attachments_req = 1;
2988             is->eof = 0;
2989             if (is->paused)
2990                 step_to_next_frame(is);
2991         }
2992         if (is->queue_attachments_req) {
2993             if (is->video_st && is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC) {
2994                 if ((ret = av_packet_ref(pkt, &is->video_st->attached_pic)) < 0)
2995                     goto fail;
2996                 packet_queue_put(&is->videoq, pkt);
2997                 packet_queue_put_nullpacket(&is->videoq, pkt, is->video_stream);
2998             }
2999             is->queue_attachments_req = 0;
3000         }
3001
3002         /* if the queue are full, no need to read more */
3003         if (infinite_buffer<1 &&
3004               (is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
3005             || (stream_has_enough_packets(is->audio_st, is->audio_stream, &is->audioq) &&
3006                 stream_has_enough_packets(is->video_st, is->video_stream, &is->videoq) &&
3007                 stream_has_enough_packets(is->subtitle_st, is->subtitle_stream, &is->subtitleq)))) {
3008             /* wait 10 ms */
3009             SDL_LockMutex(wait_mutex);
3010             SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3011             SDL_UnlockMutex(wait_mutex);
3012             continue;
3013         }
3014         if (!is->paused &&
3015             (!is->audio_st || (is->auddec.finished == is->audioq.serial && frame_queue_nb_remaining(&is->sampq) == 0)) &&
3016             (!is->video_st || (is->viddec.finished == is->videoq.serial && frame_queue_nb_remaining(&is->pictq) == 0))) {
3017             if (loop != 1 && (!loop || --loop)) {
3018                 stream_seek(is, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
3019             } else if (autoexit) {
3020                 ret = AVERROR_EOF;
3021                 goto fail;
3022             }
3023         }
3024         ret = av_read_frame(ic, pkt);
3025         if (ret < 0) {
3026             if ((ret == AVERROR_EOF || avio_feof(ic->pb)) && !is->eof) {
3027                 if (is->video_stream >= 0)
3028                     packet_queue_put_nullpacket(&is->videoq, pkt, is->video_stream);
3029                 if (is->audio_stream >= 0)
3030                     packet_queue_put_nullpacket(&is->audioq, pkt, is->audio_stream);
3031                 if (is->subtitle_stream >= 0)
3032                     packet_queue_put_nullpacket(&is->subtitleq, pkt, is->subtitle_stream);
3033                 is->eof = 1;
3034             }
3035             if (ic->pb && ic->pb->error) {
3036                 if (autoexit)
3037                     goto fail;
3038                 else
3039                     break;
3040             }
3041             SDL_LockMutex(wait_mutex);
3042             SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3043             SDL_UnlockMutex(wait_mutex);
3044             continue;
3045         } else {
3046             is->eof = 0;
3047         }
3048         /* check if packet is in play range specified by user, then queue, otherwise discard */
3049         stream_start_time = ic->streams[pkt->stream_index]->start_time;
3050         pkt_ts = pkt->pts == AV_NOPTS_VALUE ? pkt->dts : pkt->pts;
3051         pkt_in_play_range = duration == AV_NOPTS_VALUE ||
3052                 (pkt_ts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
3053                 av_q2d(ic->streams[pkt->stream_index]->time_base) -
3054                 (double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
3055                 <= ((double)duration / 1000000);
3056         if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
3057             packet_queue_put(&is->audioq, pkt);
3058         } else if (pkt->stream_index == is->video_stream && pkt_in_play_range
3059                    && !(is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
3060             packet_queue_put(&is->videoq, pkt);
3061         } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
3062             packet_queue_put(&is->subtitleq, pkt);
3063         } else {
3064             av_packet_unref(pkt);
3065         }
3066     }
3067
3068     ret = 0;
3069  fail:
3070     if (ic && !is->ic)
3071         avformat_close_input(&ic);
3072
3073     av_packet_free(&pkt);
3074     if (ret != 0) {
3075         SDL_Event event;
3076
3077         event.type = FF_QUIT_EVENT;
3078         event.user.data1 = is;
3079         SDL_PushEvent(&event);
3080     }
3081     SDL_DestroyMutex(wait_mutex);
3082     return 0;
3083 }
3084
3085 static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
3086 {
3087     VideoState *is;
3088
3089     is = av_mallocz(sizeof(VideoState));
3090     if (!is)
3091         return NULL;
3092     is->last_video_stream = is->video_stream = -1;
3093     is->last_audio_stream = is->audio_stream = -1;
3094     is->last_subtitle_stream = is->subtitle_stream = -1;
3095     is->filename = av_strdup(filename);
3096     if (!is->filename)
3097         goto fail;
3098     is->iformat = iformat;
3099     is->ytop    = 0;
3100     is->xleft   = 0;
3101
3102     /* start video display */
3103     if (frame_queue_init(&is->pictq, &is->videoq, VIDEO_PICTURE_QUEUE_SIZE, 1) < 0)
3104         goto fail;
3105     if (frame_queue_init(&is->subpq, &is->subtitleq, SUBPICTURE_QUEUE_SIZE, 0) < 0)
3106         goto fail;
3107     if (frame_queue_init(&is->sampq, &is->audioq, SAMPLE_QUEUE_SIZE, 1) < 0)
3108         goto fail;
3109
3110     if (packet_queue_init(&is->videoq) < 0 ||
3111         packet_queue_init(&is->audioq) < 0 ||
3112         packet_queue_init(&is->subtitleq) < 0)
3113         goto fail;
3114
3115     if (!(is->continue_read_thread = SDL_CreateCond())) {
3116         av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
3117         goto fail;
3118     }
3119
3120     init_clock(&is->vidclk, &is->videoq.serial);
3121     init_clock(&is->audclk, &is->audioq.serial);
3122     init_clock(&is->extclk, &is->extclk.serial);
3123     is->audio_clock_serial = -1;
3124     if (startup_volume < 0)
3125         av_log(NULL, AV_LOG_WARNING, "-volume=%d < 0, setting to 0\n", startup_volume);
3126     if (startup_volume > 100)
3127         av_log(NULL, AV_LOG_WARNING, "-volume=%d > 100, setting to 100\n", startup_volume);
3128     startup_volume = av_clip(startup_volume, 0, 100);
3129     startup_volume = av_clip(SDL_MIX_MAXVOLUME * startup_volume / 100, 0, SDL_MIX_MAXVOLUME);
3130     is->audio_volume = startup_volume;
3131     is->muted = 0;
3132     is->av_sync_type = av_sync_type;
3133     is->read_tid     = SDL_CreateThread(read_thread, "read_thread", is);
3134     if (!is->read_tid) {
3135         av_log(NULL, AV_LOG_FATAL, "SDL_CreateThread(): %s\n", SDL_GetError());
3136 fail:
3137         stream_close(is);
3138         return NULL;
3139     }
3140     return is;
3141 }
3142
3143 static void stream_cycle_channel(VideoState *is, int codec_type)
3144 {
3145     AVFormatContext *ic = is->ic;
3146     int start_index, stream_index;
3147     int old_index;
3148     AVStream *st;
3149     AVProgram *p = NULL;
3150     int nb_streams = is->ic->nb_streams;
3151
3152     if (codec_type == AVMEDIA_TYPE_VIDEO) {
3153         start_index = is->last_video_stream;
3154         old_index = is->video_stream;
3155     } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
3156         start_index = is->last_audio_stream;
3157         old_index = is->audio_stream;
3158     } else {
3159         start_index = is->last_subtitle_stream;
3160         old_index = is->subtitle_stream;
3161     }
3162     stream_index = start_index;
3163
3164     if (codec_type != AVMEDIA_TYPE_VIDEO && is->video_stream != -1) {
3165         p = av_find_program_from_stream(ic, NULL, is->video_stream);
3166         if (p) {
3167             nb_streams = p->nb_stream_indexes;
3168             for (start_index = 0; start_index < nb_streams; start_index++)
3169                 if (p->stream_index[start_index] == stream_index)
3170                     break;
3171             if (start_index == nb_streams)
3172                 start_index = -1;
3173             stream_index = start_index;
3174         }
3175     }
3176
3177     for (;;) {
3178         if (++stream_index >= nb_streams)
3179         {
3180             if (codec_type == AVMEDIA_TYPE_SUBTITLE)
3181             {
3182                 stream_index = -1;
3183                 is->last_subtitle_stream = -1;
3184                 goto the_end;
3185             }
3186             if (start_index == -1)
3187                 return;
3188             stream_index = 0;
3189         }
3190         if (stream_index == start_index)
3191             return;
3192         st = is->ic->streams[p ? p->stream_index[stream_index] : stream_index];
3193         if (st->codecpar->codec_type == codec_type) {
3194             /* check that parameters are OK */
3195             switch (codec_type) {
3196             case AVMEDIA_TYPE_AUDIO:
3197                 if (st->codecpar->sample_rate != 0 &&
3198                     st->codecpar->channels != 0)
3199                     goto the_end;
3200                 break;
3201             case AVMEDIA_TYPE_VIDEO:
3202             case AVMEDIA_TYPE_SUBTITLE:
3203                 goto the_end;
3204             default:
3205                 break;
3206             }
3207         }
3208     }
3209  the_end:
3210     if (p && stream_index != -1)
3211         stream_index = p->stream_index[stream_index];
3212     av_log(NULL, AV_LOG_INFO, "Switch %s stream from #%d to #%d\n",
3213            av_get_media_type_string(codec_type),
3214            old_index,
3215            stream_index);
3216
3217     stream_component_close(is, old_index);
3218     stream_component_open(is, stream_index);
3219 }
3220
3221
3222 static void toggle_full_screen(VideoState *is)
3223 {
3224     is_full_screen = !is_full_screen;
3225     SDL_SetWindowFullscreen(window, is_full_screen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
3226 }
3227
3228 static void toggle_audio_display(VideoState *is)
3229 {
3230     int next = is->show_mode;
3231     do {
3232         next = (next + 1) % SHOW_MODE_NB;
3233     } while (next != is->show_mode && (next == SHOW_MODE_VIDEO && !is->video_st || next != SHOW_MODE_VIDEO && !is->audio_st));
3234     if (is->show_mode != next) {
3235         is->force_refresh = 1;
3236         is->show_mode = next;
3237     }
3238 }
3239
3240 static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
3241     double remaining_time = 0.0;
3242     SDL_PumpEvents();
3243     while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) {
3244         if (!cursor_hidden && av_gettime_relative() - cursor_last_shown > CURSOR_HIDE_DELAY) {
3245             SDL_ShowCursor(0);
3246             cursor_hidden = 1;
3247         }
3248         if (remaining_time > 0.0)
3249             av_usleep((int64_t)(remaining_time * 1000000.0));
3250         remaining_time = REFRESH_RATE;
3251         if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
3252             video_refresh(is, &remaining_time);
3253         SDL_PumpEvents();
3254     }
3255 }
3256
3257 static void seek_chapter(VideoState *is, int incr)
3258 {
3259     int64_t pos = get_master_clock(is) * AV_TIME_BASE;
3260     int i;
3261
3262     if (!is->ic->nb_chapters)
3263         return;
3264
3265     /* find the current chapter */
3266     for (i = 0; i < is->ic->nb_chapters; i++) {
3267         AVChapter *ch = is->ic->chapters[i];
3268         if (av_compare_ts(pos, AV_TIME_BASE_Q, ch->start, ch->time_base) < 0) {
3269             i--;
3270             break;
3271         }
3272     }
3273
3274     i += incr;
3275     i = FFMAX(i, 0);
3276     if (i >= is->ic->nb_chapters)
3277         return;
3278
3279     av_log(NULL, AV_LOG_VERBOSE, "Seeking to chapter %d.\n", i);
3280     stream_seek(is, av_rescale_q(is->ic->chapters[i]->start, is->ic->chapters[i]->time_base,
3281                                  AV_TIME_BASE_Q), 0, 0);
3282 }
3283
3284 /* handle an event sent by the GUI */
3285 static void event_loop(VideoState *cur_stream)
3286 {
3287     SDL_Event event;
3288     double incr, pos, frac;
3289
3290     for (;;) {
3291         double x;
3292         refresh_loop_wait_event(cur_stream, &event);
3293         switch (event.type) {
3294         case SDL_KEYDOWN:
3295             if (exit_on_keydown || event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_q) {
3296                 do_exit(cur_stream);
3297                 break;
3298             }
3299             // If we don't yet have a window, skip all key events, because read_thread might still be initializing...
3300             if (!cur_stream->width)
3301                 continue;
3302             switch (event.key.keysym.sym) {
3303             case SDLK_f:
3304                 toggle_full_screen(cur_stream);
3305                 cur_stream->force_refresh = 1;
3306                 break;
3307             case SDLK_p:
3308             case SDLK_SPACE:
3309                 toggle_pause(cur_stream);
3310                 break;
3311             case SDLK_m:
3312                 toggle_mute(cur_stream);
3313                 break;
3314             case SDLK_KP_MULTIPLY:
3315             case SDLK_0:
3316                 update_volume(cur_stream, 1, SDL_VOLUME_STEP);
3317                 break;
3318             case SDLK_KP_DIVIDE:
3319             case SDLK_9:
3320                 update_volume(cur_stream, -1, SDL_VOLUME_STEP);
3321                 break;
3322             case SDLK_s: // S: Step to next frame
3323                 step_to_next_frame(cur_stream);
3324                 break;
3325             case SDLK_a:
3326                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3327                 break;
3328             case SDLK_v:
3329                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3330                 break;
3331             case SDLK_c:
3332                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3333                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3334                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3335                 break;
3336             case SDLK_t:
3337                 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3338                 break;
3339             case SDLK_w:
3340 #if CONFIG_AVFILTER
3341                 if (cur_stream->show_mode == SHOW_MODE_VIDEO && cur_stream->vfilter_idx < nb_vfilters - 1) {
3342                     if (++cur_stream->vfilter_idx >= nb_vfilters)
3343                         cur_stream->vfilter_idx = 0;
3344                 } else {
3345                     cur_stream->vfilter_idx = 0;
3346                     toggle_audio_display(cur_stream);
3347                 }
3348 #else
3349                 toggle_audio_display(cur_stream);
3350 #endif
3351                 break;
3352             case SDLK_PAGEUP:
3353                 if (cur_stream->ic->nb_chapters <= 1) {
3354                     incr = 600.0;
3355                     goto do_seek;
3356                 }
3357                 seek_chapter(cur_stream, 1);
3358                 break;
3359             case SDLK_PAGEDOWN:
3360                 if (cur_stream->ic->nb_chapters <= 1) {
3361                     incr = -600.0;
3362                     goto do_seek;
3363                 }
3364                 seek_chapter(cur_stream, -1);
3365                 break;
3366             case SDLK_LEFT:
3367                 incr = seek_interval ? -seek_interval : -10.0;
3368                 goto do_seek;
3369             case SDLK_RIGHT:
3370                 incr = seek_interval ? seek_interval : 10.0;
3371                 goto do_seek;
3372             case SDLK_UP:
3373                 incr = 60.0;
3374                 goto do_seek;
3375             case SDLK_DOWN:
3376                 incr = -60.0;
3377             do_seek:
3378                     if (seek_by_bytes) {
3379                         pos = -1;
3380                         if (pos < 0 && cur_stream->video_stream >= 0)
3381                             pos = frame_queue_last_pos(&cur_stream->pictq);
3382                         if (pos < 0 && cur_stream->audio_stream >= 0)
3383                             pos = frame_queue_last_pos(&cur_stream->sampq);
3384                         if (pos < 0)
3385                             pos = avio_tell(cur_stream->ic->pb);
3386                         if (cur_stream->ic->bit_rate)
3387                             incr *= cur_stream->ic->bit_rate / 8.0;
3388                         else
3389                             incr *= 180000.0;
3390                         pos += incr;
3391                         stream_seek(cur_stream, pos, incr, 1);
3392                     } else {
3393                         pos = get_master_clock(cur_stream);
3394                         if (isnan(pos))
3395                             pos = (double)cur_stream->seek_pos / AV_TIME_BASE;
3396                         pos += incr;
3397                         if (cur_stream->ic->start_time != AV_NOPTS_VALUE && pos < cur_stream->ic->start_time / (double)AV_TIME_BASE)
3398                             pos = cur_stream->ic->start_time / (double)AV_TIME_BASE;
3399                         stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE), 0);
3400                     }
3401                 break;
3402             default:
3403                 break;
3404             }
3405             break;
3406         case SDL_MOUSEBUTTONDOWN:
3407             if (exit_on_mousedown) {
3408                 do_exit(cur_stream);
3409                 break;
3410             }
3411             if (event.button.button == SDL_BUTTON_LEFT) {
3412                 static int64_t last_mouse_left_click = 0;
3413                 if (av_gettime_relative() - last_mouse_left_click <= 500000) {
3414                     toggle_full_screen(cur_stream);
3415                     cur_stream->force_refresh = 1;
3416                     last_mouse_left_click = 0;
3417                 } else {
3418                     last_mouse_left_click = av_gettime_relative();
3419                 }
3420             }
3421         case SDL_MOUSEMOTION:
3422             if (cursor_hidden) {
3423                 SDL_ShowCursor(1);
3424                 cursor_hidden = 0;
3425             }
3426             cursor_last_shown = av_gettime_relative();
3427             if (event.type == SDL_MOUSEBUTTONDOWN) {
3428                 if (event.button.button != SDL_BUTTON_RIGHT)
3429                     break;
3430                 x = event.button.x;
3431             } else {
3432                 if (!(event.motion.state & SDL_BUTTON_RMASK))
3433                     break;
3434                 x = event.motion.x;
3435             }
3436                 if (seek_by_bytes || cur_stream->ic->duration <= 0) {
3437                     uint64_t size =  avio_size(cur_stream->ic->pb);
3438                     stream_seek(cur_stream, size*x/cur_stream->width, 0, 1);
3439                 } else {
3440                     int64_t ts;
3441                     int ns, hh, mm, ss;
3442                     int tns, thh, tmm, tss;
3443                     tns  = cur_stream->ic->duration / 1000000LL;
3444                     thh  = tns / 3600;
3445                     tmm  = (tns % 3600) / 60;
3446                     tss  = (tns % 60);
3447                     frac = x / cur_stream->width;
3448                     ns   = frac * tns;
3449                     hh   = ns / 3600;
3450                     mm   = (ns % 3600) / 60;
3451                     ss   = (ns % 60);
3452                     av_log(NULL, AV_LOG_INFO,
3453                            "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d)       \n", frac*100,
3454                             hh, mm, ss, thh, tmm, tss);
3455                     ts = frac * cur_stream->ic->duration;
3456                     if (cur_stream->ic->start_time != AV_NOPTS_VALUE)
3457                         ts += cur_stream->ic->start_time;
3458                     stream_seek(cur_stream, ts, 0, 0);
3459                 }
3460             break;
3461         case SDL_WINDOWEVENT:
3462             switch (event.window.event) {
3463                 case SDL_WINDOWEVENT_SIZE_CHANGED:
3464                     screen_width  = cur_stream->width  = event.window.data1;
3465                     screen_height = cur_stream->height = event.window.data2;
3466                     if (cur_stream->vis_texture) {
3467                         SDL_DestroyTexture(cur_stream->vis_texture);
3468                         cur_stream->vis_texture = NULL;
3469                     }
3470                 case SDL_WINDOWEVENT_EXPOSED:
3471                     cur_stream->force_refresh = 1;
3472             }
3473             break;
3474         case SDL_QUIT:
3475         case FF_QUIT_EVENT:
3476             do_exit(cur_stream);
3477             break;
3478         default:
3479             break;
3480         }
3481     }
3482 }
3483
3484 static int opt_frame_size(void *optctx, const char *opt, const char *arg)
3485 {
3486     av_log(NULL, AV_LOG_WARNING, "Option -s is deprecated, use -video_size.\n");
3487     return opt_default(NULL, "video_size", arg);
3488 }
3489
3490 static int opt_width(void *optctx, const char *opt, const char *arg)
3491 {
3492     screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3493     return 0;
3494 }
3495
3496 static int opt_height(void *optctx, const char *opt, const char *arg)
3497 {
3498     screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3499     return 0;
3500 }
3501
3502 static int opt_format(void *optctx, const char *opt, const char *arg)
3503 {
3504     file_iformat = av_find_input_format(arg);
3505     if (!file_iformat) {
3506         av_log(NULL, AV_LOG_FATAL, "Unknown input format: %s\n", arg);
3507         return AVERROR(EINVAL);
3508     }
3509     return 0;
3510 }
3511
3512 static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
3513 {
3514     av_log(NULL, AV_LOG_WARNING, "Option -pix_fmt is deprecated, use -pixel_format.\n");
3515     return opt_default(NULL, "pixel_format", arg);
3516 }
3517
3518 static int opt_sync(void *optctx, const char *opt, const char *arg)
3519 {
3520     if (!strcmp(arg, "audio"))
3521         av_sync_type = AV_SYNC_AUDIO_MASTER;
3522     else if (!strcmp(arg, "video"))
3523         av_sync_type = AV_SYNC_VIDEO_MASTER;
3524     else if (!strcmp(arg, "ext"))
3525         av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
3526     else {
3527         av_log(NULL, AV_LOG_ERROR, "Unknown value for %s: %s\n", opt, arg);
3528         exit(1);
3529     }
3530     return 0;
3531 }
3532
3533 static int opt_seek(void *optctx, const char *opt, const char *arg)
3534 {
3535     start_time = parse_time_or_die(opt, arg, 1);
3536     return 0;
3537 }
3538
3539 static int opt_duration(void *optctx, const char *opt, const char *arg)
3540 {
3541     duration = parse_time_or_die(opt, arg, 1);
3542     return 0;
3543 }
3544
3545 static int opt_show_mode(void *optctx, const char *opt, const char *arg)
3546 {
3547     show_mode = !strcmp(arg, "video") ? SHOW_MODE_VIDEO :
3548                 !strcmp(arg, "waves") ? SHOW_MODE_WAVES :
3549                 !strcmp(arg, "rdft" ) ? SHOW_MODE_RDFT  :
3550                 parse_number_or_die(opt, arg, OPT_INT, 0, SHOW_MODE_NB-1);
3551     return 0;
3552 }
3553
3554 static void opt_input_file(void *optctx, const char *filename)
3555 {
3556     if (input_filename) {
3557         av_log(NULL, AV_LOG_FATAL,
3558                "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3559                 filename, input_filename);
3560         exit(1);
3561     }
3562     if (!strcmp(filename, "-"))
3563         filename = "pipe:";
3564     input_filename = filename;
3565 }
3566
3567 static int opt_codec(void *optctx, const char *opt, const char *arg)
3568 {
3569    const char *spec = strchr(opt, ':');
3570    if (!spec) {
3571        av_log(NULL, AV_LOG_ERROR,
3572               "No media specifier was specified in '%s' in option '%s'\n",
3573                arg, opt);
3574        return AVERROR(EINVAL);
3575    }
3576    spec++;
3577    switch (spec[0]) {
3578    case 'a' :    audio_codec_name = arg; break;
3579    case 's' : subtitle_codec_name = arg; break;
3580    case 'v' :    video_codec_name = arg; break;
3581    default:
3582        av_log(NULL, AV_LOG_ERROR,
3583               "Invalid media specifier '%s' in option '%s'\n", spec, opt);
3584        return AVERROR(EINVAL);
3585    }
3586    return 0;
3587 }
3588
3589 static int dummy;
3590
3591 static const OptionDef options[] = {
3592     CMDUTILS_COMMON_OPTIONS
3593     { "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
3594     { "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
3595     { "s", HAS_ARG | OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
3596     { "fs", OPT_BOOL, { &is_full_screen }, "force full screen" },
3597     { "an", OPT_BOOL, { &audio_disable }, "disable audio" },
3598     { "vn", OPT_BOOL, { &video_disable }, "disable video" },
3599     { "sn", OPT_BOOL, { &subtitle_disable }, "disable subtitling" },
3600     { "ast", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_specifier" },
3601     { "vst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_specifier" },
3602     { "sst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_specifier" },
3603     { "ss", HAS_ARG, { .func_arg = opt_seek }, "seek to a given position in seconds", "pos" },
3604     { "t", HAS_ARG, { .func_arg = opt_duration }, "play  \"duration\" seconds of audio/video", "duration" },
3605     { "bytes", OPT_INT | HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
3606     { "seek_interval", OPT_FLOAT | HAS_ARG, { &seek_interval }, "set seek interval for left/right keys, in seconds", "seconds" },
3607     { "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
3608     { "noborder", OPT_BOOL, { &borderless }, "borderless window" },
3609     { "alwaysontop", OPT_BOOL, { &alwaysontop }, "window always on top" },
3610     { "volume", OPT_INT | HAS_ARG, { &startup_volume}, "set startup volume 0=min 100=max", "volume" },
3611     { "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
3612     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
3613     { "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" },
3614     { "fast", OPT_BOOL | OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
3615     { "genpts", OPT_BOOL | OPT_EXPERT, { &genpts }, "generate pts", "" },
3616     { "drp", OPT_INT | HAS_ARG | OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
3617     { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, { &lowres }, "", "" },
3618     { "sync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
3619     { "autoexit", OPT_BOOL | OPT_EXPERT, { &autoexit }, "exit at the end", "" },
3620     { "exitonkeydown", OPT_BOOL | OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
3621     { "exitonmousedown", OPT_BOOL | OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
3622     { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
3623     { "framedrop", OPT_BOOL | OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
3624     { "infbuf", OPT_BOOL | OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
3625     { "window_title", OPT_STRING | HAS_ARG, { &window_title }, "set window title", "window title" },
3626     { "left", OPT_INT | HAS_ARG | OPT_EXPERT, { &screen_left }, "set the x position for the left of the window", "x pos" },
3627     { "top", OPT_INT | HAS_ARG | OPT_EXPERT, { &screen_top }, "set the y position for the top of the window", "y pos" },
3628 #if CONFIG_AVFILTER
3629     { "vf", OPT_EXPERT | HAS_ARG, { .func_arg = opt_add_vfilter }, "set video filters", "filter_graph" },
3630     { "af", OPT_STRING | HAS_ARG, { &afilters }, "set audio filters", "filter_graph" },
3631 #endif
3632     { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
3633     { "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
3634     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default }, "generic catch all option", "" },
3635     { "i", OPT_BOOL, { &dummy}, "read specified file", "input_file"},
3636     { "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
3637     { "acodec", HAS_ARG | OPT_STRING | OPT_EXPERT, {    &audio_codec_name }, "force audio decoder",    "decoder_name" },
3638     { "scodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
3639     { "vcodec", HAS_ARG | OPT_STRING | OPT_EXPERT, {    &video_codec_name }, "force video decoder",    "decoder_name" },
3640     { "autorotate", OPT_BOOL, { &autorotate }, "automatically rotate video", "" },
3641     { "find_stream_info", OPT_BOOL | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3642         "read and decode the streams to fill missing information with heuristics" },
3643     { "filter_threads", HAS_ARG | OPT_INT | OPT_EXPERT, { &filter_nbthreads }, "number of filter threads per graph" },
3644     { NULL, },
3645 };
3646
3647 static void show_usage(void)
3648 {
3649     av_log(NULL, AV_LOG_INFO, "Simple media player\n");
3650     av_log(NULL, AV_LOG_INFO, "usage: %s [options] input_file\n", program_name);
3651     av_log(NULL, AV_LOG_INFO, "\n");
3652 }
3653
3654 void show_help_default(const char *opt, const char *arg)
3655 {
3656     av_log_set_callback(log_callback_help);
3657     show_usage();
3658     show_help_options(options, "Main options:", 0, OPT_EXPERT, 0);
3659     show_help_options(options, "Advanced options:", OPT_EXPERT, 0, 0);
3660     printf("\n");
3661     show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3662     show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3663 #if !CONFIG_AVFILTER
3664     show_help_children(sws_get_class(), AV_OPT_FLAG_ENCODING_PARAM);
3665 #else
3666     show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
3667 #endif
3668     printf("\nWhile playing:\n"
3669            "q, ESC              quit\n"
3670            "f                   toggle full screen\n"
3671            "p, SPC              pause\n"
3672            "m                   toggle mute\n"
3673            "9, 0                decrease and increase volume respectively\n"
3674            "/, *                decrease and increase volume respectively\n"
3675            "a                   cycle audio channel in the current program\n"
3676            "v                   cycle video channel\n"
3677            "t                   cycle subtitle channel in the current program\n"
3678            "c                   cycle program\n"
3679            "w                   cycle video filters or show modes\n"
3680            "s                   activate frame-step mode\n"
3681            "left/right          seek backward/forward 10 seconds or to custom interval if -seek_interval is set\n"
3682            "down/up             seek backward/forward 1 minute\n"
3683            "page down/page up   seek backward/forward 10 minutes\n"
3684            "right mouse click   seek to percentage in file corresponding to fraction of width\n"
3685            "left double-click   toggle full screen\n"
3686            );
3687 }
3688
3689 /* Called from the main */
3690 int main(int argc, char **argv)
3691 {
3692     int flags;
3693     VideoState *is;
3694
3695     init_dynload();
3696
3697     av_log_set_flags(AV_LOG_SKIP_REPEATED);
3698     parse_loglevel(argc, argv, options);
3699
3700     /* register all codecs, demux and protocols */
3701 #if CONFIG_AVDEVICE
3702     avdevice_register_all();
3703 #endif
3704     avformat_network_init();
3705
3706     init_opts();
3707
3708     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
3709     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
3710
3711     show_banner(argc, argv, options);
3712
3713     parse_options(NULL, argc, argv, options, opt_input_file);
3714
3715     if (!input_filename) {
3716         show_usage();
3717         av_log(NULL, AV_LOG_FATAL, "An input file must be specified\n");
3718         av_log(NULL, AV_LOG_FATAL,
3719                "Use -h to get full help or, even better, run 'man %s'\n", program_name);
3720         exit(1);
3721     }
3722
3723     if (display_disable) {
3724         video_disable = 1;
3725     }
3726     flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
3727     if (audio_disable)
3728         flags &= ~SDL_INIT_AUDIO;
3729     else {
3730         /* Try to work around an occasional ALSA buffer underflow issue when the
3731          * period size is NPOT due to ALSA resampling by forcing the buffer size. */
3732         if (!SDL_getenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE"))
3733             SDL_setenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE","1", 1);
3734     }
3735     if (display_disable)
3736         flags &= ~SDL_INIT_VIDEO;
3737     if (SDL_Init (flags)) {
3738         av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n", SDL_GetError());
3739         av_log(NULL, AV_LOG_FATAL, "(Did you set the DISPLAY variable?)\n");
3740         exit(1);
3741     }
3742
3743     SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
3744     SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
3745
3746     if (!display_disable) {
3747         int flags = SDL_WINDOW_HIDDEN;
3748         if (alwaysontop)
3749 #if SDL_VERSION_ATLEAST(2,0,5)
3750             flags |= SDL_WINDOW_ALWAYS_ON_TOP;
3751 #else
3752             av_log(NULL, AV_LOG_WARNING, "Your SDL version doesn't support SDL_WINDOW_ALWAYS_ON_TOP. Feature will be inactive.\n");
3753 #endif
3754         if (borderless)
3755             flags |= SDL_WINDOW_BORDERLESS;
3756         else
3757             flags |= SDL_WINDOW_RESIZABLE;
3758         window = SDL_CreateWindow(program_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, default_width, default_height, flags);
3759         SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
3760         if (window) {
3761             renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
3762             if (!renderer) {
3763                 av_log(NULL, AV_LOG_WARNING, "Failed to initialize a hardware accelerated renderer: %s\n", SDL_GetError());
3764                 renderer = SDL_CreateRenderer(window, -1, 0);
3765             }
3766             if (renderer) {
3767                 if (!SDL_GetRendererInfo(renderer, &renderer_info))
3768                     av_log(NULL, AV_LOG_VERBOSE, "Initialized %s renderer.\n", renderer_info.name);
3769             }
3770         }
3771         if (!window || !renderer || !renderer_info.num_texture_formats) {
3772             av_log(NULL, AV_LOG_FATAL, "Failed to create window or renderer: %s", SDL_GetError());
3773             do_exit(NULL);
3774         }
3775     }
3776
3777     is = stream_open(input_filename, file_iformat);
3778     if (!is) {
3779         av_log(NULL, AV_LOG_FATAL, "Failed to initialize VideoState!\n");
3780         do_exit(NULL);
3781     }
3782
3783     event_loop(is);
3784
3785     /* never returns */
3786
3787     return 0;
3788 }