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

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