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

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