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

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