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