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