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