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