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