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