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

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