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