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

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