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