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