git.sesse.net Git - ffmpeg/blob - fftools/ffplay.c

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