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