ffplay.c

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