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

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