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 <math.h>
  23 #include <limits.h>
  24 #include "libavutil/avstring.h"
  25 #include "libavformat/avformat.h"
  26 #include "libavformat/rtsp.h"
  27 #include "libavdevice/avdevice.h"
  28 #include "libswscale/swscale.h"
  29 #include "libavcodec/audioconvert.h"
  30 #include "libavcodec/opt.h"
  31
  32 #include "cmdutils.h"
  33
  34 #include <SDL.h>
  35 #include <SDL_thread.h>
  36
  37 #ifdef __MINGW32__
  38 #undef main /* We don't want SDL to override our main() */
  39 #endif
  40
  41 #undef exit
  42
  43 const char program_name[] = "FFplay";
  44 const int program_birth_year = 2003;
  45
  46 //#define DEBUG_SYNC
  47
  48 #define MAX_VIDEOQ_SIZE (5 * 256 * 1024)
  49 #define MAX_AUDIOQ_SIZE (5 * 16 * 1024)
  50 #define MAX_SUBTITLEQ_SIZE (5 * 16 * 1024)
  51
  52 /* SDL audio buffer size, in samples. Should be small to have precise
  53    A/V sync as SDL does not have hardware buffer fullness info. */
  54 #define SDL_AUDIO_BUFFER_SIZE 1024
  55
  56 /* no AV sync correction is done if below the AV sync threshold */
  57 #define AV_SYNC_THRESHOLD 0.01
  58 /* no AV correction is done if too big error */
  59 #define AV_NOSYNC_THRESHOLD 10.0
  60
  61 /* maximum audio speed change to get correct sync */
  62 #define SAMPLE_CORRECTION_PERCENT_MAX 10
  63
  64 /* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
  65 #define AUDIO_DIFF_AVG_NB   20
  66
  67 /* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
  68 #define SAMPLE_ARRAY_SIZE (2*65536)
  69
  70 static int sws_flags = SWS_BICUBIC;
  71
  72 typedef struct PacketQueue {
  73     AVPacketList *first_pkt, *last_pkt;
  74     int nb_packets;
  75     int size;
  76     int abort_request;
  77     SDL_mutex *mutex;
  78     SDL_cond *cond;
  79 } PacketQueue;
  80
  81 #define VIDEO_PICTURE_QUEUE_SIZE 1
  82 #define SUBPICTURE_QUEUE_SIZE 4
  83
  84 typedef struct VideoPicture {
  85     double pts;                                  ///<presentation time stamp for this picture
  86     SDL_Overlay *bmp;
  87     int width, height; /* source height & width */
  88     int allocated;
  89 } VideoPicture;
  90
  91 typedef struct SubPicture {
  92     double pts; /* presentation time stamp for this picture */
  93     AVSubtitle sub;
  94 } SubPicture;
  95
  96 enum {
  97     AV_SYNC_AUDIO_MASTER, /* default choice */
  98     AV_SYNC_VIDEO_MASTER,
  99     AV_SYNC_EXTERNAL_CLOCK, /* synchronize to an external clock */
 100 };
 101
 102 typedef struct VideoState {
 103     SDL_Thread *parse_tid;
 104     SDL_Thread *video_tid;
 105     AVInputFormat *iformat;
 106     int no_background;
 107     int abort_request;
 108     int paused;
 109     int last_paused;
 110     int seek_req;
 111     int seek_flags;
 112     int64_t seek_pos;
 113     int64_t seek_rel;
 114     AVFormatContext *ic;
 115     int dtg_active_format;
 116
 117     int audio_stream;
 118
 119     int av_sync_type;
 120     double external_clock; /* external clock base */
 121     int64_t external_clock_time;
 122
 123     double audio_clock;
 124     double audio_diff_cum; /* used for AV difference average computation */
 125     double audio_diff_avg_coef;
 126     double audio_diff_threshold;
 127     int audio_diff_avg_count;
 128     AVStream *audio_st;
 129     PacketQueue audioq;
 130     int audio_hw_buf_size;
 131     /* samples output by the codec. we reserve more space for avsync
 132        compensation */
 133     DECLARE_ALIGNED(16,uint8_t,audio_buf1[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2]);
 134     DECLARE_ALIGNED(16,uint8_t,audio_buf2[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2]);
 135     uint8_t *audio_buf;
 136     unsigned int audio_buf_size; /* in bytes */
 137     int audio_buf_index; /* in bytes */
 138     AVPacket audio_pkt;
 139     uint8_t *audio_pkt_data;
 140     int audio_pkt_size;
 141     enum SampleFormat audio_src_fmt;
 142     AVAudioConvert *reformat_ctx;
 143
 144     int show_audio; /* if true, display audio samples */
 145     int16_t sample_array[SAMPLE_ARRAY_SIZE];
 146     int sample_array_index;
 147     int last_i_start;
 148
 149     SDL_Thread *subtitle_tid;
 150     int subtitle_stream;
 151     int subtitle_stream_changed;
 152     AVStream *subtitle_st;
 153     PacketQueue subtitleq;
 154     SubPicture subpq[SUBPICTURE_QUEUE_SIZE];
 155     int subpq_size, subpq_rindex, subpq_windex;
 156     SDL_mutex *subpq_mutex;
 157     SDL_cond *subpq_cond;
 158
 159     double frame_timer;
 160     double frame_last_pts;
 161     double frame_last_delay;
 162     double video_clock;                          ///<pts of last decoded frame / predicted pts of next decoded frame
 163     int video_stream;
 164     AVStream *video_st;
 165     PacketQueue videoq;
 166     double video_current_pts;                    ///<current displayed pts (different from video_clock if frame fifos are used)
 167     int64_t video_current_pts_time;              ///<time (av_gettime) at which we updated video_current_pts - used to have running video pts
 168     VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];
 169     int pictq_size, pictq_rindex, pictq_windex;
 170     SDL_mutex *pictq_mutex;
 171     SDL_cond *pictq_cond;
 172
 173     //    QETimer *video_timer;
 174     char filename[1024];
 175     int width, height, xleft, ytop;
 176 } VideoState;
 177
 178 static void show_help(void);
 179 static int audio_write_get_buf_size(VideoState *is);
 180
 181 /* options specified by the user */
 182 static AVInputFormat *file_iformat;
 183 static const char *input_filename;
 184 static int fs_screen_width;
 185 static int fs_screen_height;
 186 static int screen_width = 0;
 187 static int screen_height = 0;
 188 static int frame_width = 0;
 189 static int frame_height = 0;
 190 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
 191 static int audio_disable;
 192 static int video_disable;
 193 static int wanted_audio_stream= 0;
 194 static int wanted_video_stream= 0;
 195 static int wanted_subtitle_stream= -1;
 196 static int seek_by_bytes;
 197 static int display_disable;
 198 static int show_status;
 199 static int av_sync_type = AV_SYNC_AUDIO_MASTER;
 200 static int64_t start_time = AV_NOPTS_VALUE;
 201 static int debug = 0;
 202 static int debug_mv = 0;
 203 static int step = 0;
 204 static int thread_count = 1;
 205 static int workaround_bugs = 1;
 206 static int fast = 0;
 207 static int genpts = 0;
 208 static int lowres = 0;
 209 static int idct = FF_IDCT_AUTO;
 210 static enum AVDiscard skip_frame= AVDISCARD_DEFAULT;
 211 static enum AVDiscard skip_idct= AVDISCARD_DEFAULT;
 212 static enum AVDiscard skip_loop_filter= AVDISCARD_DEFAULT;
 213 static int error_recognition = FF_ER_CAREFUL;
 214 static int error_concealment = 3;
 215 static int decoder_reorder_pts= 0;
 216
 217 /* current context */
 218 static int is_full_screen;
 219 static VideoState *cur_stream;
 220 static int64_t audio_callback_time;
 221
 222 static AVPacket flush_pkt;
 223
 224 #define FF_ALLOC_EVENT   (SDL_USEREVENT)
 225 #define FF_REFRESH_EVENT (SDL_USEREVENT + 1)
 226 #define FF_QUIT_EVENT    (SDL_USEREVENT + 2)
 227
 228 static SDL_Surface *screen;
 229
 230 /* packet queue handling */
 231 static void packet_queue_init(PacketQueue *q)
 232 {
 233     memset(q, 0, sizeof(PacketQueue));
 234     q->mutex = SDL_CreateMutex();
 235     q->cond = SDL_CreateCond();
 236 }
 237
 238 static void packet_queue_flush(PacketQueue *q)
 239 {
 240     AVPacketList *pkt, *pkt1;
 241
 242     SDL_LockMutex(q->mutex);
 243     for(pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
 244         pkt1 = pkt->next;
 245         av_free_packet(&pkt->pkt);
 246         av_freep(&pkt);
 247     }
 248     q->last_pkt = NULL;
 249     q->first_pkt = NULL;
 250     q->nb_packets = 0;
 251     q->size = 0;
 252     SDL_UnlockMutex(q->mutex);
 253 }
 254
 255 static void packet_queue_end(PacketQueue *q)
 256 {
 257     packet_queue_flush(q);
 258     SDL_DestroyMutex(q->mutex);
 259     SDL_DestroyCond(q->cond);
 260 }
 261
 262 static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
 263 {
 264     AVPacketList *pkt1;
 265
 266     /* duplicate the packet */
 267     if (pkt!=&flush_pkt && av_dup_packet(pkt) < 0)
 268         return -1;
 269
 270     pkt1 = av_malloc(sizeof(AVPacketList));
 271     if (!pkt1)
 272         return -1;
 273     pkt1->pkt = *pkt;
 274     pkt1->next = NULL;
 275
 276
 277     SDL_LockMutex(q->mutex);
 278
 279     if (!q->last_pkt)
 280
 281         q->first_pkt = pkt1;
 282     else
 283         q->last_pkt->next = pkt1;
 284     q->last_pkt = pkt1;
 285     q->nb_packets++;
 286     q->size += pkt1->pkt.size + sizeof(*pkt1);
 287     /* XXX: should duplicate packet data in DV case */
 288     SDL_CondSignal(q->cond);
 289
 290     SDL_UnlockMutex(q->mutex);
 291     return 0;
 292 }
 293
 294 static void packet_queue_abort(PacketQueue *q)
 295 {
 296     SDL_LockMutex(q->mutex);
 297
 298     q->abort_request = 1;
 299
 300     SDL_CondSignal(q->cond);
 301
 302     SDL_UnlockMutex(q->mutex);
 303 }
 304
 305 /* return < 0 if aborted, 0 if no packet and > 0 if packet.  */
 306 static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block)
 307 {
 308     AVPacketList *pkt1;
 309     int ret;
 310
 311     SDL_LockMutex(q->mutex);
 312
 313     for(;;) {
 314         if (q->abort_request) {
 315             ret = -1;
 316             break;
 317         }
 318
 319         pkt1 = q->first_pkt;
 320         if (pkt1) {
 321             q->first_pkt = pkt1->next;
 322             if (!q->first_pkt)
 323                 q->last_pkt = NULL;
 324             q->nb_packets--;
 325             q->size -= pkt1->pkt.size + sizeof(*pkt1);
 326             *pkt = pkt1->pkt;
 327             av_free(pkt1);
 328             ret = 1;
 329             break;
 330         } else if (!block) {
 331             ret = 0;
 332             break;
 333         } else {
 334             SDL_CondWait(q->cond, q->mutex);
 335         }
 336     }
 337     SDL_UnlockMutex(q->mutex);
 338     return ret;
 339 }
 340
 341 static inline void fill_rectangle(SDL_Surface *screen,
 342                                   int x, int y, int w, int h, int color)
 343 {
 344     SDL_Rect rect;
 345     rect.x = x;
 346     rect.y = y;
 347     rect.w = w;
 348     rect.h = h;
 349     SDL_FillRect(screen, &rect, color);
 350 }
 351
 352 #if 0
 353 /* draw only the border of a rectangle */
 354 void fill_border(VideoState *s, int x, int y, int w, int h, int color)
 355 {
 356     int w1, w2, h1, h2;
 357
 358     /* fill the background */
 359     w1 = x;
 360     if (w1 < 0)
 361         w1 = 0;
 362     w2 = s->width - (x + w);
 363     if (w2 < 0)
 364         w2 = 0;
 365     h1 = y;
 366     if (h1 < 0)
 367         h1 = 0;
 368     h2 = s->height - (y + h);
 369     if (h2 < 0)
 370         h2 = 0;
 371     fill_rectangle(screen,
 372                    s->xleft, s->ytop,
 373                    w1, s->height,
 374                    color);
 375     fill_rectangle(screen,
 376                    s->xleft + s->width - w2, s->ytop,
 377                    w2, s->height,
 378                    color);
 379     fill_rectangle(screen,
 380                    s->xleft + w1, s->ytop,
 381                    s->width - w1 - w2, h1,
 382                    color);
 383     fill_rectangle(screen,
 384                    s->xleft + w1, s->ytop + s->height - h2,
 385                    s->width - w1 - w2, h2,
 386                    color);
 387 }
 388 #endif
 389
 390
 391
 392 #define SCALEBITS 10
 393 #define ONE_HALF  (1 << (SCALEBITS - 1))
 394 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
 395
 396 #define RGB_TO_Y_CCIR(r, g, b) \
 397 ((FIX(0.29900*219.0/255.0) * (r) + FIX(0.58700*219.0/255.0) * (g) + \
 398   FIX(0.11400*219.0/255.0) * (b) + (ONE_HALF + (16 << SCALEBITS))) >> SCALEBITS)
 399
 400 #define RGB_TO_U_CCIR(r1, g1, b1, shift)\
 401 (((- FIX(0.16874*224.0/255.0) * r1 - FIX(0.33126*224.0/255.0) * g1 +         \
 402      FIX(0.50000*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
 403
 404 #define RGB_TO_V_CCIR(r1, g1, b1, shift)\
 405 (((FIX(0.50000*224.0/255.0) * r1 - FIX(0.41869*224.0/255.0) * g1 -           \
 406    FIX(0.08131*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
 407
 408 #define ALPHA_BLEND(a, oldp, newp, s)\
 409 ((((oldp << s) * (255 - (a))) + (newp * (a))) / (255 << s))
 410
 411 #define RGBA_IN(r, g, b, a, s)\
 412 {\
 413     unsigned int v = ((const uint32_t *)(s))[0];\
 414     a = (v >> 24) & 0xff;\
 415     r = (v >> 16) & 0xff;\
 416     g = (v >> 8) & 0xff;\
 417     b = v & 0xff;\
 418 }
 419
 420 #define YUVA_IN(y, u, v, a, s, pal)\
 421 {\
 422     unsigned int val = ((const uint32_t *)(pal))[*(const uint8_t*)(s)];\
 423     a = (val >> 24) & 0xff;\
 424     y = (val >> 16) & 0xff;\
 425     u = (val >> 8) & 0xff;\
 426     v = val & 0xff;\
 427 }
 428
 429 #define YUVA_OUT(d, y, u, v, a)\
 430 {\
 431     ((uint32_t *)(d))[0] = (a << 24) | (y << 16) | (u << 8) | v;\
 432 }
 433
 434
 435 #define BPP 1
 436
 437 static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect, int imgw, int imgh)
 438 {
 439     int wrap, wrap3, width2, skip2;
 440     int y, u, v, a, u1, v1, a1, w, h;
 441     uint8_t *lum, *cb, *cr;
 442     const uint8_t *p;
 443     const uint32_t *pal;
 444     int dstx, dsty, dstw, dsth;
 445
 446     dstw = av_clip(rect->w, 0, imgw);
 447     dsth = av_clip(rect->h, 0, imgh);
 448     dstx = av_clip(rect->x, 0, imgw - dstw);
 449     dsty = av_clip(rect->y, 0, imgh - dsth);
 450     lum = dst->data[0] + dsty * dst->linesize[0];
 451     cb = dst->data[1] + (dsty >> 1) * dst->linesize[1];
 452     cr = dst->data[2] + (dsty >> 1) * dst->linesize[2];
 453
 454     width2 = ((dstw + 1) >> 1) + (dstx & ~dstw & 1);
 455     skip2 = dstx >> 1;
 456     wrap = dst->linesize[0];
 457     wrap3 = rect->pict.linesize[0];
 458     p = rect->pict.data[0];
 459     pal = (const uint32_t *)rect->pict.data[1];  /* Now in YCrCb! */
 460
 461     if (dsty & 1) {
 462         lum += dstx;
 463         cb += skip2;
 464         cr += skip2;
 465
 466         if (dstx & 1) {
 467             YUVA_IN(y, u, v, a, p, pal);
 468             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
 469             cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
 470             cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
 471             cb++;
 472             cr++;
 473             lum++;
 474             p += BPP;
 475         }
 476         for(w = dstw - (dstx & 1); w >= 2; w -= 2) {
 477             YUVA_IN(y, u, v, a, p, pal);
 478             u1 = u;
 479             v1 = v;
 480             a1 = a;
 481             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
 482
 483             YUVA_IN(y, u, v, a, p + BPP, pal);
 484             u1 += u;
 485             v1 += v;
 486             a1 += a;
 487             lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
 488             cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
 489             cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
 490             cb++;
 491             cr++;
 492             p += 2 * BPP;
 493             lum += 2;
 494         }
 495         if (w) {
 496             YUVA_IN(y, u, v, a, p, pal);
 497             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
 498             cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
 499             cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
 500             p++;
 501             lum++;
 502         }
 503         p += wrap3 - dstw * BPP;
 504         lum += wrap - dstw - dstx;
 505         cb += dst->linesize[1] - width2 - skip2;
 506         cr += dst->linesize[2] - width2 - skip2;
 507     }
 508     for(h = dsth - (dsty & 1); h >= 2; h -= 2) {
 509         lum += dstx;
 510         cb += skip2;
 511         cr += skip2;
 512
 513         if (dstx & 1) {
 514             YUVA_IN(y, u, v, a, p, pal);
 515             u1 = u;
 516             v1 = v;
 517             a1 = a;
 518             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
 519             p += wrap3;
 520             lum += wrap;
 521             YUVA_IN(y, u, v, a, p, pal);
 522             u1 += u;
 523             v1 += v;
 524             a1 += a;
 525             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
 526             cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
 527             cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
 528             cb++;
 529             cr++;
 530             p += -wrap3 + BPP;
 531             lum += -wrap + 1;
 532         }
 533         for(w = dstw - (dstx & 1); w >= 2; w -= 2) {
 534             YUVA_IN(y, u, v, a, p, pal);
 535             u1 = u;
 536             v1 = v;
 537             a1 = a;
 538             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
 539
 540             YUVA_IN(y, u, v, a, p + BPP, pal);
 541             u1 += u;
 542             v1 += v;
 543             a1 += a;
 544             lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
 545             p += wrap3;
 546             lum += wrap;
 547
 548             YUVA_IN(y, u, v, a, p, pal);
 549             u1 += u;
 550             v1 += v;
 551             a1 += a;
 552             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
 553
 554             YUVA_IN(y, u, v, a, p + BPP, pal);
 555             u1 += u;
 556             v1 += v;
 557             a1 += a;
 558             lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
 559
 560             cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 2);
 561             cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 2);
 562
 563             cb++;
 564             cr++;
 565             p += -wrap3 + 2 * BPP;
 566             lum += -wrap + 2;
 567         }
 568         if (w) {
 569             YUVA_IN(y, u, v, a, p, pal);
 570             u1 = u;
 571             v1 = v;
 572             a1 = a;
 573             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
 574             p += wrap3;
 575             lum += wrap;
 576             YUVA_IN(y, u, v, a, p, pal);
 577             u1 += u;
 578             v1 += v;
 579             a1 += a;
 580             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
 581             cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
 582             cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
 583             cb++;
 584             cr++;
 585             p += -wrap3 + BPP;
 586             lum += -wrap + 1;
 587         }
 588         p += wrap3 + (wrap3 - dstw * BPP);
 589         lum += wrap + (wrap - dstw - dstx);
 590         cb += dst->linesize[1] - width2 - skip2;
 591         cr += dst->linesize[2] - width2 - skip2;
 592     }
 593     /* handle odd height */
 594     if (h) {
 595         lum += dstx;
 596         cb += skip2;
 597         cr += skip2;
 598
 599         if (dstx & 1) {
 600             YUVA_IN(y, u, v, a, p, pal);
 601             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
 602             cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
 603             cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
 604             cb++;
 605             cr++;
 606             lum++;
 607             p += BPP;
 608         }
 609         for(w = dstw - (dstx & 1); w >= 2; w -= 2) {
 610             YUVA_IN(y, u, v, a, p, pal);
 611             u1 = u;
 612             v1 = v;
 613             a1 = a;
 614             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
 615
 616             YUVA_IN(y, u, v, a, p + BPP, pal);
 617             u1 += u;
 618             v1 += v;
 619             a1 += a;
 620             lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
 621             cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u, 1);
 622             cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v, 1);
 623             cb++;
 624             cr++;
 625             p += 2 * BPP;
 626             lum += 2;
 627         }
 628         if (w) {
 629             YUVA_IN(y, u, v, a, p, pal);
 630             lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
 631             cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
 632             cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
 633         }
 634     }
 635 }
 636
 637 static void free_subpicture(SubPicture *sp)
 638 {
 639     int i;
 640
 641     for (i = 0; i < sp->sub.num_rects; i++)
 642     {
 643         av_freep(&sp->sub.rects[i]->pict.data[0]);
 644         av_freep(&sp->sub.rects[i]->pict.data[1]);
 645         av_freep(&sp->sub.rects[i]);
 646     }
 647
 648     av_free(sp->sub.rects);
 649
 650     memset(&sp->sub, 0, sizeof(AVSubtitle));
 651 }
 652
 653 static void video_image_display(VideoState *is)
 654 {
 655     VideoPicture *vp;
 656     SubPicture *sp;
 657     AVPicture pict;
 658     float aspect_ratio;
 659     int width, height, x, y;
 660     SDL_Rect rect;
 661     int i;
 662
 663     vp = &is->pictq[is->pictq_rindex];
 664     if (vp->bmp) {
 665         /* XXX: use variable in the frame */
 666         if (is->video_st->sample_aspect_ratio.num)
 667             aspect_ratio = av_q2d(is->video_st->sample_aspect_ratio);
 668         else if (is->video_st->codec->sample_aspect_ratio.num)
 669             aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio);
 670         else
 671             aspect_ratio = 0;
 672         if (aspect_ratio <= 0.0)
 673             aspect_ratio = 1.0;
 674         aspect_ratio *= (float)is->video_st->codec->width / is->video_st->codec->height;
 675         /* if an active format is indicated, then it overrides the
 676            mpeg format */
 677 #if 0
 678         if (is->video_st->codec->dtg_active_format != is->dtg_active_format) {
 679             is->dtg_active_format = is->video_st->codec->dtg_active_format;
 680             printf("dtg_active_format=%d\n", is->dtg_active_format);
 681         }
 682 #endif
 683 #if 0
 684         switch(is->video_st->codec->dtg_active_format) {
 685         case FF_DTG_AFD_SAME:
 686         default:
 687             /* nothing to do */
 688             break;
 689         case FF_DTG_AFD_4_3:
 690             aspect_ratio = 4.0 / 3.0;
 691             break;
 692         case FF_DTG_AFD_16_9:
 693             aspect_ratio = 16.0 / 9.0;
 694             break;
 695         case FF_DTG_AFD_14_9:
 696             aspect_ratio = 14.0 / 9.0;
 697             break;
 698         case FF_DTG_AFD_4_3_SP_14_9:
 699             aspect_ratio = 14.0 / 9.0;
 700             break;
 701         case FF_DTG_AFD_16_9_SP_14_9:
 702             aspect_ratio = 14.0 / 9.0;
 703             break;
 704         case FF_DTG_AFD_SP_4_3:
 705             aspect_ratio = 4.0 / 3.0;
 706             break;
 707         }
 708 #endif
 709
 710         if (is->subtitle_st)
 711         {
 712             if (is->subpq_size > 0)
 713             {
 714                 sp = &is->subpq[is->subpq_rindex];
 715
 716                 if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000))
 717                 {
 718                     SDL_LockYUVOverlay (vp->bmp);
 719
 720                     pict.data[0] = vp->bmp->pixels[0];
 721                     pict.data[1] = vp->bmp->pixels[2];
 722                     pict.data[2] = vp->bmp->pixels[1];
 723
 724                     pict.linesize[0] = vp->bmp->pitches[0];
 725                     pict.linesize[1] = vp->bmp->pitches[2];
 726                     pict.linesize[2] = vp->bmp->pitches[1];
 727
 728                     for (i = 0; i < sp->sub.num_rects; i++)
 729                         blend_subrect(&pict, sp->sub.rects[i],
 730                                       vp->bmp->w, vp->bmp->h);
 731
 732                     SDL_UnlockYUVOverlay (vp->bmp);
 733                 }
 734             }
 735         }
 736
 737
 738         /* XXX: we suppose the screen has a 1.0 pixel ratio */
 739         height = is->height;
 740         width = ((int)rint(height * aspect_ratio)) & ~1;
 741         if (width > is->width) {
 742             width = is->width;
 743             height = ((int)rint(width / aspect_ratio)) & ~1;
 744         }
 745         x = (is->width - width) / 2;
 746         y = (is->height - height) / 2;
 747         if (!is->no_background) {
 748             /* fill the background */
 749             //            fill_border(is, x, y, width, height, QERGB(0x00, 0x00, 0x00));
 750         } else {
 751             is->no_background = 0;
 752         }
 753         rect.x = is->xleft + x;
 754         rect.y = is->ytop  + y;
 755         rect.w = width;
 756         rect.h = height;
 757         SDL_DisplayYUVOverlay(vp->bmp, &rect);
 758     } else {
 759 #if 0
 760         fill_rectangle(screen,
 761                        is->xleft, is->ytop, is->width, is->height,
 762                        QERGB(0x00, 0x00, 0x00));
 763 #endif
 764     }
 765 }
 766
 767 static inline int compute_mod(int a, int b)
 768 {
 769     a = a % b;
 770     if (a >= 0)
 771         return a;
 772     else
 773         return a + b;
 774 }
 775
 776 static void video_audio_display(VideoState *s)
 777 {
 778     int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
 779     int ch, channels, h, h2, bgcolor, fgcolor;
 780     int16_t time_diff;
 781
 782     /* compute display index : center on currently output samples */
 783     channels = s->audio_st->codec->channels;
 784     nb_display_channels = channels;
 785     if (!s->paused) {
 786         n = 2 * channels;
 787         delay = audio_write_get_buf_size(s);
 788         delay /= n;
 789
 790         /* to be more precise, we take into account the time spent since
 791            the last buffer computation */
 792         if (audio_callback_time) {
 793             time_diff = av_gettime() - audio_callback_time;
 794             delay += (time_diff * s->audio_st->codec->sample_rate) / 1000000;
 795         }
 796
 797         delay -= s->width / 2;
 798         if (delay < s->width)
 799             delay = s->width;
 800
 801         i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
 802
 803         h= INT_MIN;
 804         for(i=0; i<1000; i+=channels){
 805             int idx= (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
 806             int a= s->sample_array[idx];
 807             int b= s->sample_array[(idx + 4*channels)%SAMPLE_ARRAY_SIZE];
 808             int c= s->sample_array[(idx + 5*channels)%SAMPLE_ARRAY_SIZE];
 809             int d= s->sample_array[(idx + 9*channels)%SAMPLE_ARRAY_SIZE];
 810             int score= a-d;
 811             if(h<score && (b^c)<0){
 812                 h= score;
 813                 i_start= idx;
 814             }
 815         }
 816
 817         s->last_i_start = i_start;
 818     } else {
 819         i_start = s->last_i_start;
 820     }
 821
 822     bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
 823     fill_rectangle(screen,
 824                    s->xleft, s->ytop, s->width, s->height,
 825                    bgcolor);
 826
 827     fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);
 828
 829     /* total height for one channel */
 830     h = s->height / nb_display_channels;
 831     /* graph height / 2 */
 832     h2 = (h * 9) / 20;
 833     for(ch = 0;ch < nb_display_channels; ch++) {
 834         i = i_start + ch;
 835         y1 = s->ytop + ch * h + (h / 2); /* position of center line */
 836         for(x = 0; x < s->width; x++) {
 837             y = (s->sample_array[i] * h2) >> 15;
 838             if (y < 0) {
 839                 y = -y;
 840                 ys = y1 - y;
 841             } else {
 842                 ys = y1;
 843             }
 844             fill_rectangle(screen,
 845                            s->xleft + x, ys, 1, y,
 846                            fgcolor);
 847             i += channels;
 848             if (i >= SAMPLE_ARRAY_SIZE)
 849                 i -= SAMPLE_ARRAY_SIZE;
 850         }
 851     }
 852
 853     fgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff);
 854
 855     for(ch = 1;ch < nb_display_channels; ch++) {
 856         y = s->ytop + ch * h;
 857         fill_rectangle(screen,
 858                        s->xleft, y, s->width, 1,
 859                        fgcolor);
 860     }
 861     SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height);
 862 }
 863
 864 static int video_open(VideoState *is){
 865     int flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL;
 866     int w,h;
 867
 868     if(is_full_screen) flags |= SDL_FULLSCREEN;
 869     else               flags |= SDL_RESIZABLE;
 870
 871     if (is_full_screen && fs_screen_width) {
 872         w = fs_screen_width;
 873         h = fs_screen_height;
 874     } else if(!is_full_screen && screen_width){
 875         w = screen_width;
 876         h = screen_height;
 877     }else if (is->video_st && is->video_st->codec->width){
 878         w = is->video_st->codec->width;
 879         h = is->video_st->codec->height;
 880     } else {
 881         w = 640;
 882         h = 480;
 883     }
 884 #ifndef __APPLE__
 885     screen = SDL_SetVideoMode(w, h, 0, flags);
 886 #else
 887     /* setting bits_per_pixel = 0 or 32 causes blank video on OS X */
 888     screen = SDL_SetVideoMode(w, h, 24, flags);
 889 #endif
 890     if (!screen) {
 891         fprintf(stderr, "SDL: could not set video mode - exiting\n");
 892         return -1;
 893     }
 894     SDL_WM_SetCaption("FFplay", "FFplay");
 895
 896     is->width = screen->w;
 897     is->height = screen->h;
 898
 899     return 0;
 900 }
 901
 902 /* display the current picture, if any */
 903 static void video_display(VideoState *is)
 904 {
 905     if(!screen)
 906         video_open(cur_stream);
 907     if (is->audio_st && is->show_audio)
 908         video_audio_display(is);
 909     else if (is->video_st)
 910         video_image_display(is);
 911 }
 912
 913 static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque)
 914 {
 915     SDL_Event event;
 916     event.type = FF_REFRESH_EVENT;
 917     event.user.data1 = opaque;
 918     SDL_PushEvent(&event);
 919     return 0; /* 0 means stop timer */
 920 }
 921
 922 /* schedule a video refresh in 'delay' ms */
 923 static void schedule_refresh(VideoState *is, int delay)
 924 {
 925     if(!delay) delay=1; //SDL seems to be buggy when the delay is 0
 926     SDL_AddTimer(delay, sdl_refresh_timer_cb, is);
 927 }
 928
 929 /* get the current audio clock value */
 930 static double get_audio_clock(VideoState *is)
 931 {
 932     double pts;
 933     int hw_buf_size, bytes_per_sec;
 934     pts = is->audio_clock;
 935     hw_buf_size = audio_write_get_buf_size(is);
 936     bytes_per_sec = 0;
 937     if (is->audio_st) {
 938         bytes_per_sec = is->audio_st->codec->sample_rate *
 939             2 * is->audio_st->codec->channels;
 940     }
 941     if (bytes_per_sec)
 942         pts -= (double)hw_buf_size / bytes_per_sec;
 943     return pts;
 944 }
 945
 946 /* get the current video clock value */
 947 static double get_video_clock(VideoState *is)
 948 {
 949     double delta;
 950     if (is->paused) {
 951         delta = 0;
 952     } else {
 953         delta = (av_gettime() - is->video_current_pts_time) / 1000000.0;
 954     }
 955     return is->video_current_pts + delta;
 956 }
 957
 958 /* get the current external clock value */
 959 static double get_external_clock(VideoState *is)
 960 {
 961     int64_t ti;
 962     ti = av_gettime();
 963     return is->external_clock + ((ti - is->external_clock_time) * 1e-6);
 964 }
 965
 966 /* get the current master clock value */
 967 static double get_master_clock(VideoState *is)
 968 {
 969     double val;
 970
 971     if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
 972         if (is->video_st)
 973             val = get_video_clock(is);
 974         else
 975             val = get_audio_clock(is);
 976     } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
 977         if (is->audio_st)
 978             val = get_audio_clock(is);
 979         else
 980             val = get_video_clock(is);
 981     } else {
 982         val = get_external_clock(is);
 983     }
 984     return val;
 985 }
 986
 987 /* seek in the stream */
 988 static void stream_seek(VideoState *is, int64_t pos, int64_t rel)
 989 {
 990     if (!is->seek_req) {
 991         is->seek_pos = pos;
 992         is->seek_rel = rel;
 993         if (seek_by_bytes)
 994             is->seek_flags |= AVSEEK_FLAG_BYTE;
 995         is->seek_req = 1;
 996     }
 997 }
 998
 999 /* pause or resume the video */
1000 static void stream_pause(VideoState *is)
1001 {
1002     is->paused = !is->paused;
1003     if (!is->paused) {
1004         is->video_current_pts = get_video_clock(is);
1005         is->frame_timer += (av_gettime() - is->video_current_pts_time) / 1000000.0;
1006     }
1007 }
1008
1009 static double compute_frame_delay(double frame_current_pts, VideoState *is)
1010 {
1011     double actual_delay, delay, sync_threshold, ref_clock, diff;
1012
1013     /* compute nominal delay */
1014     delay = frame_current_pts - is->frame_last_pts;
1015     if (delay <= 0 || delay >= 10.0) {
1016         /* if incorrect delay, use previous one */
1017         delay = is->frame_last_delay;
1018     } else {
1019         is->frame_last_delay = delay;
1020     }
1021     is->frame_last_pts = frame_current_pts;
1022
1023     /* update delay to follow master synchronisation source */
1024     if (((is->av_sync_type == AV_SYNC_AUDIO_MASTER && is->audio_st) ||
1025          is->av_sync_type == AV_SYNC_EXTERNAL_CLOCK)) {
1026         /* if video is slave, we try to correct big delays by
1027            duplicating or deleting a frame */
1028         ref_clock = get_master_clock(is);
1029         diff = frame_current_pts - ref_clock;
1030
1031         /* skip or repeat frame. We take into account the
1032            delay to compute the threshold. I still don't know
1033            if it is the best guess */
1034         sync_threshold = FFMAX(AV_SYNC_THRESHOLD, delay);
1035         if (fabs(diff) < AV_NOSYNC_THRESHOLD) {
1036             if (diff <= -sync_threshold)
1037                 delay = 0;
1038             else if (diff >= sync_threshold)
1039                 delay = 2 * delay;
1040         }
1041     }
1042
1043     is->frame_timer += delay;
1044     /* compute the REAL delay (we need to do that to avoid
1045        long term errors */
1046     actual_delay = is->frame_timer - (av_gettime() / 1000000.0);
1047     if (actual_delay < 0.010) {
1048         /* XXX: should skip picture */
1049         actual_delay = 0.010;
1050     }
1051
1052 #if defined(DEBUG_SYNC)
1053     printf("video: delay=%0.3f actual_delay=%0.3f pts=%0.3f A-V=%f\n",
1054             delay, actual_delay, frame_current_pts, -diff);
1055 #endif
1056
1057     return actual_delay;
1058 }
1059
1060 /* called to display each frame */
1061 static void video_refresh_timer(void *opaque)
1062 {
1063     VideoState *is = opaque;
1064     VideoPicture *vp;
1065
1066     SubPicture *sp, *sp2;
1067
1068     if (is->video_st) {
1069         if (is->pictq_size == 0) {
1070             /* if no picture, need to wait */
1071             schedule_refresh(is, 1);
1072         } else {
1073             /* dequeue the picture */
1074             vp = &is->pictq[is->pictq_rindex];
1075
1076             /* update current video pts */
1077             is->video_current_pts = vp->pts;
1078             is->video_current_pts_time = av_gettime();
1079
1080             /* launch timer for next picture */
1081             schedule_refresh(is, (int)(compute_frame_delay(vp->pts, is) * 1000 + 0.5));
1082
1083             if(is->subtitle_st) {
1084                 if (is->subtitle_stream_changed) {
1085                     SDL_LockMutex(is->subpq_mutex);
1086
1087                     while (is->subpq_size) {
1088                         free_subpicture(&is->subpq[is->subpq_rindex]);
1089
1090                         /* update queue size and signal for next picture */
1091                         if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
1092                             is->subpq_rindex = 0;
1093
1094                         is->subpq_size--;
1095                     }
1096                     is->subtitle_stream_changed = 0;
1097
1098                     SDL_CondSignal(is->subpq_cond);
1099                     SDL_UnlockMutex(is->subpq_mutex);
1100                 } else {
1101                     if (is->subpq_size > 0) {
1102                         sp = &is->subpq[is->subpq_rindex];
1103
1104                         if (is->subpq_size > 1)
1105                             sp2 = &is->subpq[(is->subpq_rindex + 1) % SUBPICTURE_QUEUE_SIZE];
1106                         else
1107                             sp2 = NULL;
1108
1109                         if ((is->video_current_pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1110                                 || (sp2 && is->video_current_pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1111                         {
1112                             free_subpicture(sp);
1113
1114                             /* update queue size and signal for next picture */
1115                             if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
1116                                 is->subpq_rindex = 0;
1117
1118                             SDL_LockMutex(is->subpq_mutex);
1119                             is->subpq_size--;
1120                             SDL_CondSignal(is->subpq_cond);
1121                             SDL_UnlockMutex(is->subpq_mutex);
1122                         }
1123                     }
1124                 }
1125             }
1126
1127             /* display picture */
1128             video_display(is);
1129
1130             /* update queue size and signal for next picture */
1131             if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE)
1132                 is->pictq_rindex = 0;
1133
1134             SDL_LockMutex(is->pictq_mutex);
1135             is->pictq_size--;
1136             SDL_CondSignal(is->pictq_cond);
1137             SDL_UnlockMutex(is->pictq_mutex);
1138         }
1139     } else if (is->audio_st) {
1140         /* draw the next audio frame */
1141
1142         schedule_refresh(is, 40);
1143
1144         /* if only audio stream, then display the audio bars (better
1145            than nothing, just to test the implementation */
1146
1147         /* display picture */
1148         video_display(is);
1149     } else {
1150         schedule_refresh(is, 100);
1151     }
1152     if (show_status) {
1153         static int64_t last_time;
1154         int64_t cur_time;
1155         int aqsize, vqsize, sqsize;
1156         double av_diff;
1157
1158         cur_time = av_gettime();
1159         if (!last_time || (cur_time - last_time) >= 500 * 1000) {
1160             aqsize = 0;
1161             vqsize = 0;
1162             sqsize = 0;
1163             if (is->audio_st)
1164                 aqsize = is->audioq.size;
1165             if (is->video_st)
1166                 vqsize = is->videoq.size;
1167             if (is->subtitle_st)
1168                 sqsize = is->subtitleq.size;
1169             av_diff = 0;
1170             if (is->audio_st && is->video_st)
1171                 av_diff = get_audio_clock(is) - get_video_clock(is);
1172             printf("%7.2f A-V:%7.3f aq=%5dKB vq=%5dKB sq=%5dB    \r",
1173                    get_master_clock(is), av_diff, aqsize / 1024, vqsize / 1024, sqsize);
1174             fflush(stdout);
1175             last_time = cur_time;
1176         }
1177     }
1178 }
1179
1180 /* allocate a picture (needs to do that in main thread to avoid
1181    potential locking problems */
1182 static void alloc_picture(void *opaque)
1183 {
1184     VideoState *is = opaque;
1185     VideoPicture *vp;
1186
1187     vp = &is->pictq[is->pictq_windex];
1188
1189     if (vp->bmp)
1190         SDL_FreeYUVOverlay(vp->bmp);
1191
1192 #if 0
1193     /* XXX: use generic function */
1194     /* XXX: disable overlay if no hardware acceleration or if RGB format */
1195     switch(is->video_st->codec->pix_fmt) {
1196     case PIX_FMT_YUV420P:
1197     case PIX_FMT_YUV422P:
1198     case PIX_FMT_YUV444P:
1199     case PIX_FMT_YUYV422:
1200     case PIX_FMT_YUV410P:
1201     case PIX_FMT_YUV411P:
1202         is_yuv = 1;
1203         break;
1204     default:
1205         is_yuv = 0;
1206         break;
1207     }
1208 #endif
1209     vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec->width,
1210                                    is->video_st->codec->height,
1211                                    SDL_YV12_OVERLAY,
1212                                    screen);
1213     vp->width = is->video_st->codec->width;
1214     vp->height = is->video_st->codec->height;
1215
1216     SDL_LockMutex(is->pictq_mutex);
1217     vp->allocated = 1;
1218     SDL_CondSignal(is->pictq_cond);
1219     SDL_UnlockMutex(is->pictq_mutex);
1220 }
1221
1222 /**
1223  *
1224  * @param pts the dts of the pkt / pts of the frame and guessed if not known
1225  */
1226 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts)
1227 {
1228     VideoPicture *vp;
1229     int dst_pix_fmt;
1230     AVPicture pict;
1231     static struct SwsContext *img_convert_ctx;
1232
1233     /* wait until we have space to put a new picture */
1234     SDL_LockMutex(is->pictq_mutex);
1235     while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE &&
1236            !is->videoq.abort_request) {
1237         SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1238     }
1239     SDL_UnlockMutex(is->pictq_mutex);
1240
1241     if (is->videoq.abort_request)
1242         return -1;
1243
1244     vp = &is->pictq[is->pictq_windex];
1245
1246     /* alloc or resize hardware picture buffer */
1247     if (!vp->bmp ||
1248         vp->width != is->video_st->codec->width ||
1249         vp->height != is->video_st->codec->height) {
1250         SDL_Event event;
1251
1252         vp->allocated = 0;
1253
1254         /* the allocation must be done in the main thread to avoid
1255            locking problems */
1256         event.type = FF_ALLOC_EVENT;
1257         event.user.data1 = is;
1258         SDL_PushEvent(&event);
1259
1260         /* wait until the picture is allocated */
1261         SDL_LockMutex(is->pictq_mutex);
1262         while (!vp->allocated && !is->videoq.abort_request) {
1263             SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1264         }
1265         SDL_UnlockMutex(is->pictq_mutex);
1266
1267         if (is->videoq.abort_request)
1268             return -1;
1269     }
1270
1271     /* if the frame is not skipped, then display it */
1272     if (vp->bmp) {
1273         /* get a pointer on the bitmap */
1274         SDL_LockYUVOverlay (vp->bmp);
1275
1276         dst_pix_fmt = PIX_FMT_YUV420P;
1277         pict.data[0] = vp->bmp->pixels[0];
1278         pict.data[1] = vp->bmp->pixels[2];
1279         pict.data[2] = vp->bmp->pixels[1];
1280
1281         pict.linesize[0] = vp->bmp->pitches[0];
1282         pict.linesize[1] = vp->bmp->pitches[2];
1283         pict.linesize[2] = vp->bmp->pitches[1];
1284         sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1285         img_convert_ctx = sws_getCachedContext(img_convert_ctx,
1286             is->video_st->codec->width, is->video_st->codec->height,
1287             is->video_st->codec->pix_fmt,
1288             is->video_st->codec->width, is->video_st->codec->height,
1289             dst_pix_fmt, sws_flags, NULL, NULL, NULL);
1290         if (img_convert_ctx == NULL) {
1291             fprintf(stderr, "Cannot initialize the conversion context\n");
1292             exit(1);
1293         }
1294         sws_scale(img_convert_ctx, src_frame->data, src_frame->linesize,
1295                   0, is->video_st->codec->height, pict.data, pict.linesize);
1296         /* update the bitmap content */
1297         SDL_UnlockYUVOverlay(vp->bmp);
1298
1299         vp->pts = pts;
1300
1301         /* now we can update the picture count */
1302         if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE)
1303             is->pictq_windex = 0;
1304         SDL_LockMutex(is->pictq_mutex);
1305         is->pictq_size++;
1306         SDL_UnlockMutex(is->pictq_mutex);
1307     }
1308     return 0;
1309 }
1310
1311 /**
1312  * compute the exact PTS for the picture if it is omitted in the stream
1313  * @param pts1 the dts of the pkt / pts of the frame
1314  */
1315 static int output_picture2(VideoState *is, AVFrame *src_frame, double pts1)
1316 {
1317     double frame_delay, pts;
1318
1319     pts = pts1;
1320
1321     if (pts != 0) {
1322         /* update video clock with pts, if present */
1323         is->video_clock = pts;
1324     } else {
1325         pts = is->video_clock;
1326     }
1327     /* update video clock for next frame */
1328     frame_delay = av_q2d(is->video_st->codec->time_base);
1329     /* for MPEG2, the frame can be repeated, so we update the
1330        clock accordingly */
1331     frame_delay += src_frame->repeat_pict * (frame_delay * 0.5);
1332     is->video_clock += frame_delay;
1333
1334 #if defined(DEBUG_SYNC) && 0
1335     {
1336         int ftype;
1337         if (src_frame->pict_type == FF_B_TYPE)
1338             ftype = 'B';
1339         else if (src_frame->pict_type == FF_I_TYPE)
1340             ftype = 'I';
1341         else
1342             ftype = 'P';
1343         printf("frame_type=%c clock=%0.3f pts=%0.3f\n",
1344                ftype, pts, pts1);
1345     }
1346 #endif
1347     return queue_picture(is, src_frame, pts);
1348 }
1349
1350 static int video_thread(void *arg)
1351 {
1352     VideoState *is = arg;
1353     AVPacket pkt1, *pkt = &pkt1;
1354     int len1, got_picture;
1355     AVFrame *frame= avcodec_alloc_frame();
1356     double pts;
1357
1358     for(;;) {
1359         while (is->paused && !is->videoq.abort_request) {
1360             SDL_Delay(10);
1361         }
1362         if (packet_queue_get(&is->videoq, pkt, 1) < 0)
1363             break;
1364
1365         if(pkt->data == flush_pkt.data){
1366             avcodec_flush_buffers(is->video_st->codec);
1367             continue;
1368         }
1369
1370         /* NOTE: ipts is the PTS of the _first_ picture beginning in
1371            this packet, if any */
1372         is->video_st->codec->reordered_opaque= pkt->pts;
1373         len1 = avcodec_decode_video(is->video_st->codec,
1374                                     frame, &got_picture,
1375                                     pkt->data, pkt->size);
1376
1377         if(   (decoder_reorder_pts || pkt->dts == AV_NOPTS_VALUE)
1378            && frame->reordered_opaque != AV_NOPTS_VALUE)
1379             pts= frame->reordered_opaque;
1380         else if(pkt->dts != AV_NOPTS_VALUE)
1381             pts= pkt->dts;
1382         else
1383             pts= 0;
1384         pts *= av_q2d(is->video_st->time_base);
1385
1386 //            if (len1 < 0)
1387 //                break;
1388         if (got_picture) {
1389             if (output_picture2(is, frame, pts) < 0)
1390                 goto the_end;
1391         }
1392         av_free_packet(pkt);
1393         if (step)
1394             if (cur_stream)
1395                 stream_pause(cur_stream);
1396     }
1397  the_end:
1398     av_free(frame);
1399     return 0;
1400 }
1401
1402 static int subtitle_thread(void *arg)
1403 {
1404     VideoState *is = arg;
1405     SubPicture *sp;
1406     AVPacket pkt1, *pkt = &pkt1;
1407     int len1, got_subtitle;
1408     double pts;
1409     int i, j;
1410     int r, g, b, y, u, v, a;
1411
1412     for(;;) {
1413         while (is->paused && !is->subtitleq.abort_request) {
1414             SDL_Delay(10);
1415         }
1416         if (packet_queue_get(&is->subtitleq, pkt, 1) < 0)
1417             break;
1418
1419         if(pkt->data == flush_pkt.data){
1420             avcodec_flush_buffers(is->subtitle_st->codec);
1421             continue;
1422         }
1423         SDL_LockMutex(is->subpq_mutex);
1424         while (is->subpq_size >= SUBPICTURE_QUEUE_SIZE &&
1425                !is->subtitleq.abort_request) {
1426             SDL_CondWait(is->subpq_cond, is->subpq_mutex);
1427         }
1428         SDL_UnlockMutex(is->subpq_mutex);
1429
1430         if (is->subtitleq.abort_request)
1431             goto the_end;
1432
1433         sp = &is->subpq[is->subpq_windex];
1434
1435        /* NOTE: ipts is the PTS of the _first_ picture beginning in
1436            this packet, if any */
1437         pts = 0;
1438         if (pkt->pts != AV_NOPTS_VALUE)
1439             pts = av_q2d(is->subtitle_st->time_base)*pkt->pts;
1440
1441         len1 = avcodec_decode_subtitle(is->subtitle_st->codec,
1442                                     &sp->sub, &got_subtitle,
1443                                     pkt->data, pkt->size);
1444 //            if (len1 < 0)
1445 //                break;
1446         if (got_subtitle && sp->sub.format == 0) {
1447             sp->pts = pts;
1448
1449             for (i = 0; i < sp->sub.num_rects; i++)
1450             {
1451                 for (j = 0; j < sp->sub.rects[i]->nb_colors; j++)
1452                 {
1453                     RGBA_IN(r, g, b, a, (uint32_t*)sp->sub.rects[i]->pict.data[1] + j);
1454                     y = RGB_TO_Y_CCIR(r, g, b);
1455                     u = RGB_TO_U_CCIR(r, g, b, 0);
1456                     v = RGB_TO_V_CCIR(r, g, b, 0);
1457                     YUVA_OUT((uint32_t*)sp->sub.rects[i]->pict.data[1] + j, y, u, v, a);
1458                 }
1459             }
1460
1461             /* now we can update the picture count */
1462             if (++is->subpq_windex == SUBPICTURE_QUEUE_SIZE)
1463                 is->subpq_windex = 0;
1464             SDL_LockMutex(is->subpq_mutex);
1465             is->subpq_size++;
1466             SDL_UnlockMutex(is->subpq_mutex);
1467         }
1468         av_free_packet(pkt);
1469 //        if (step)
1470 //            if (cur_stream)
1471 //                stream_pause(cur_stream);
1472     }
1473  the_end:
1474     return 0;
1475 }
1476
1477 /* copy samples for viewing in editor window */
1478 static void update_sample_display(VideoState *is, short *samples, int samples_size)
1479 {
1480     int size, len, channels;
1481
1482     channels = is->audio_st->codec->channels;
1483
1484     size = samples_size / sizeof(short);
1485     while (size > 0) {
1486         len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
1487         if (len > size)
1488             len = size;
1489         memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
1490         samples += len;
1491         is->sample_array_index += len;
1492         if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
1493             is->sample_array_index = 0;
1494         size -= len;
1495     }
1496 }
1497
1498 /* return the new audio buffer size (samples can be added or deleted
1499    to get better sync if video or external master clock) */
1500 static int synchronize_audio(VideoState *is, short *samples,
1501                              int samples_size1, double pts)
1502 {
1503     int n, samples_size;
1504     double ref_clock;
1505
1506     n = 2 * is->audio_st->codec->channels;
1507     samples_size = samples_size1;
1508
1509     /* if not master, then we try to remove or add samples to correct the clock */
1510     if (((is->av_sync_type == AV_SYNC_VIDEO_MASTER && is->video_st) ||
1511          is->av_sync_type == AV_SYNC_EXTERNAL_CLOCK)) {
1512         double diff, avg_diff;
1513         int wanted_size, min_size, max_size, nb_samples;
1514
1515         ref_clock = get_master_clock(is);
1516         diff = get_audio_clock(is) - ref_clock;
1517
1518         if (diff < AV_NOSYNC_THRESHOLD) {
1519             is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
1520             if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
1521                 /* not enough measures to have a correct estimate */
1522                 is->audio_diff_avg_count++;
1523             } else {
1524                 /* estimate the A-V difference */
1525                 avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
1526
1527                 if (fabs(avg_diff) >= is->audio_diff_threshold) {
1528                     wanted_size = samples_size + ((int)(diff * is->audio_st->codec->sample_rate) * n);
1529                     nb_samples = samples_size / n;
1530
1531                     min_size = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX)) / 100) * n;
1532                     max_size = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX)) / 100) * n;
1533                     if (wanted_size < min_size)
1534                         wanted_size = min_size;
1535                     else if (wanted_size > max_size)
1536                         wanted_size = max_size;
1537
1538                     /* add or remove samples to correction the synchro */
1539                     if (wanted_size < samples_size) {
1540                         /* remove samples */
1541                         samples_size = wanted_size;
1542                     } else if (wanted_size > samples_size) {
1543                         uint8_t *samples_end, *q;
1544                         int nb;
1545
1546                         /* add samples */
1547                         nb = (samples_size - wanted_size);
1548                         samples_end = (uint8_t *)samples + samples_size - n;
1549                         q = samples_end + n;
1550                         while (nb > 0) {
1551                             memcpy(q, samples_end, n);
1552                             q += n;
1553                             nb -= n;
1554                         }
1555                         samples_size = wanted_size;
1556                     }
1557                 }
1558 #if 0
1559                 printf("diff=%f adiff=%f sample_diff=%d apts=%0.3f vpts=%0.3f %f\n",
1560                        diff, avg_diff, samples_size - samples_size1,
1561                        is->audio_clock, is->video_clock, is->audio_diff_threshold);
1562 #endif
1563             }
1564         } else {
1565             /* too big difference : may be initial PTS errors, so
1566                reset A-V filter */
1567             is->audio_diff_avg_count = 0;
1568             is->audio_diff_cum = 0;
1569         }
1570     }
1571
1572     return samples_size;
1573 }
1574
1575 /* decode one audio frame and returns its uncompressed size */
1576 static int audio_decode_frame(VideoState *is, double *pts_ptr)
1577 {
1578     AVPacket *pkt = &is->audio_pkt;
1579     AVCodecContext *dec= is->audio_st->codec;
1580     int n, len1, data_size;
1581     double pts;
1582
1583     for(;;) {
1584         /* NOTE: the audio packet can contain several frames */
1585         while (is->audio_pkt_size > 0) {
1586             data_size = sizeof(is->audio_buf1);
1587             len1 = avcodec_decode_audio2(dec,
1588                                         (int16_t *)is->audio_buf1, &data_size,
1589                                         is->audio_pkt_data, is->audio_pkt_size);
1590             if (len1 < 0) {
1591                 /* if error, we skip the frame */
1592                 is->audio_pkt_size = 0;
1593                 break;
1594             }
1595
1596             is->audio_pkt_data += len1;
1597             is->audio_pkt_size -= len1;
1598             if (data_size <= 0)
1599                 continue;
1600
1601             if (dec->sample_fmt != is->audio_src_fmt) {
1602                 if (is->reformat_ctx)
1603                     av_audio_convert_free(is->reformat_ctx);
1604                 is->reformat_ctx= av_audio_convert_alloc(SAMPLE_FMT_S16, 1,
1605                                                          dec->sample_fmt, 1, NULL, 0);
1606                 if (!is->reformat_ctx) {
1607                     fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
1608                         avcodec_get_sample_fmt_name(dec->sample_fmt),
1609                         avcodec_get_sample_fmt_name(SAMPLE_FMT_S16));
1610                         break;
1611                 }
1612                 is->audio_src_fmt= dec->sample_fmt;
1613             }
1614
1615             if (is->reformat_ctx) {
1616                 const void *ibuf[6]= {is->audio_buf1};
1617                 void *obuf[6]= {is->audio_buf2};
1618                 int istride[6]= {av_get_bits_per_sample_format(dec->sample_fmt)/8};
1619                 int ostride[6]= {2};
1620                 int len= data_size/istride[0];
1621                 if (av_audio_convert(is->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
1622                     printf("av_audio_convert() failed\n");
1623                     break;
1624                 }
1625                 is->audio_buf= is->audio_buf2;
1626                 /* FIXME: existing code assume that data_size equals framesize*channels*2
1627                           remove this legacy cruft */
1628                 data_size= len*2;
1629             }else{
1630                 is->audio_buf= is->audio_buf1;
1631             }
1632
1633             /* if no pts, then compute it */
1634             pts = is->audio_clock;
1635             *pts_ptr = pts;
1636             n = 2 * dec->channels;
1637             is->audio_clock += (double)data_size /
1638                 (double)(n * dec->sample_rate);
1639 #if defined(DEBUG_SYNC)
1640             {
1641                 static double last_clock;
1642                 printf("audio: delay=%0.3f clock=%0.3f pts=%0.3f\n",
1643                        is->audio_clock - last_clock,
1644                        is->audio_clock, pts);
1645                 last_clock = is->audio_clock;
1646             }
1647 #endif
1648             return data_size;
1649         }
1650
1651         /* free the current packet */
1652         if (pkt->data)
1653             av_free_packet(pkt);
1654
1655         if (is->paused || is->audioq.abort_request) {
1656             return -1;
1657         }
1658
1659         /* read next packet */
1660         if (packet_queue_get(&is->audioq, pkt, 1) < 0)
1661             return -1;
1662         if(pkt->data == flush_pkt.data){
1663             avcodec_flush_buffers(dec);
1664             continue;
1665         }
1666
1667         is->audio_pkt_data = pkt->data;
1668         is->audio_pkt_size = pkt->size;
1669
1670         /* if update the audio clock with the pts */
1671         if (pkt->pts != AV_NOPTS_VALUE) {
1672             is->audio_clock = av_q2d(is->audio_st->time_base)*pkt->pts;
1673         }
1674     }
1675 }
1676
1677 /* get the current audio output buffer size, in samples. With SDL, we
1678    cannot have a precise information */
1679 static int audio_write_get_buf_size(VideoState *is)
1680 {
1681     return is->audio_buf_size - is->audio_buf_index;
1682 }
1683
1684
1685 /* prepare a new audio buffer */
1686 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
1687 {
1688     VideoState *is = opaque;
1689     int audio_size, len1;
1690     double pts;
1691
1692     audio_callback_time = av_gettime();
1693
1694     while (len > 0) {
1695         if (is->audio_buf_index >= is->audio_buf_size) {
1696            audio_size = audio_decode_frame(is, &pts);
1697            if (audio_size < 0) {
1698                 /* if error, just output silence */
1699                is->audio_buf = is->audio_buf1;
1700                is->audio_buf_size = 1024;
1701                memset(is->audio_buf, 0, is->audio_buf_size);
1702            } else {
1703                if (is->show_audio)
1704                    update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
1705                audio_size = synchronize_audio(is, (int16_t *)is->audio_buf, audio_size,
1706                                               pts);
1707                is->audio_buf_size = audio_size;
1708            }
1709            is->audio_buf_index = 0;
1710         }
1711         len1 = is->audio_buf_size - is->audio_buf_index;
1712         if (len1 > len)
1713             len1 = len;
1714         memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
1715         len -= len1;
1716         stream += len1;
1717         is->audio_buf_index += len1;
1718     }
1719 }
1720
1721 /* open a given stream. Return 0 if OK */
1722 static int stream_component_open(VideoState *is, int stream_index)
1723 {
1724     AVFormatContext *ic = is->ic;
1725     AVCodecContext *enc;
1726     AVCodec *codec;
1727     SDL_AudioSpec wanted_spec, spec;
1728
1729     if (stream_index < 0 || stream_index >= ic->nb_streams)
1730         return -1;
1731     enc = ic->streams[stream_index]->codec;
1732
1733     /* prepare audio output */
1734     if (enc->codec_type == CODEC_TYPE_AUDIO) {
1735         if (enc->channels > 0) {
1736             enc->request_channels = FFMIN(2, enc->channels);
1737         } else {
1738             enc->request_channels = 2;
1739         }
1740     }
1741
1742     codec = avcodec_find_decoder(enc->codec_id);
1743     enc->debug_mv = debug_mv;
1744     enc->debug = debug;
1745     enc->workaround_bugs = workaround_bugs;
1746     enc->lowres = lowres;
1747     if(lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
1748     enc->idct_algo= idct;
1749     if(fast) enc->flags2 |= CODEC_FLAG2_FAST;
1750     enc->skip_frame= skip_frame;
1751     enc->skip_idct= skip_idct;
1752     enc->skip_loop_filter= skip_loop_filter;
1753     enc->error_recognition= error_recognition;
1754     enc->error_concealment= error_concealment;
1755
1756     set_context_opts(enc, avcodec_opts[enc->codec_type], 0);
1757
1758     if (!codec ||
1759         avcodec_open(enc, codec) < 0)
1760         return -1;
1761
1762     /* prepare audio output */
1763     if (enc->codec_type == CODEC_TYPE_AUDIO) {
1764         wanted_spec.freq = enc->sample_rate;
1765         wanted_spec.format = AUDIO_S16SYS;
1766         wanted_spec.channels = enc->channels;
1767         wanted_spec.silence = 0;
1768         wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
1769         wanted_spec.callback = sdl_audio_callback;
1770         wanted_spec.userdata = is;
1771         if (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
1772             fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
1773             return -1;
1774         }
1775         is->audio_hw_buf_size = spec.size;
1776         is->audio_src_fmt= SAMPLE_FMT_S16;
1777     }
1778
1779     if(thread_count>1)
1780         avcodec_thread_init(enc, thread_count);
1781     enc->thread_count= thread_count;
1782     ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
1783     switch(enc->codec_type) {
1784     case CODEC_TYPE_AUDIO:
1785         is->audio_stream = stream_index;
1786         is->audio_st = ic->streams[stream_index];
1787         is->audio_buf_size = 0;
1788         is->audio_buf_index = 0;
1789
1790         /* init averaging filter */
1791         is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
1792         is->audio_diff_avg_count = 0;
1793         /* since we do not have a precise anough audio fifo fullness,
1794            we correct audio sync only if larger than this threshold */
1795         is->audio_diff_threshold = 2.0 * SDL_AUDIO_BUFFER_SIZE / enc->sample_rate;
1796
1797         memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
1798         packet_queue_init(&is->audioq);
1799         SDL_PauseAudio(0);
1800         break;
1801     case CODEC_TYPE_VIDEO:
1802         is->video_stream = stream_index;
1803         is->video_st = ic->streams[stream_index];
1804
1805         is->frame_last_delay = 40e-3;
1806         is->frame_timer = (double)av_gettime() / 1000000.0;
1807         is->video_current_pts_time = av_gettime();
1808
1809         packet_queue_init(&is->videoq);
1810         is->video_tid = SDL_CreateThread(video_thread, is);
1811         break;
1812     case CODEC_TYPE_SUBTITLE:
1813         is->subtitle_stream = stream_index;
1814         is->subtitle_st = ic->streams[stream_index];
1815         packet_queue_init(&is->subtitleq);
1816
1817         is->subtitle_tid = SDL_CreateThread(subtitle_thread, is);
1818         break;
1819     default:
1820         break;
1821     }
1822     return 0;
1823 }
1824
1825 static void stream_component_close(VideoState *is, int stream_index)
1826 {
1827     AVFormatContext *ic = is->ic;
1828     AVCodecContext *enc;
1829
1830     if (stream_index < 0 || stream_index >= ic->nb_streams)
1831         return;
1832     enc = ic->streams[stream_index]->codec;
1833
1834     switch(enc->codec_type) {
1835     case CODEC_TYPE_AUDIO:
1836         packet_queue_abort(&is->audioq);
1837
1838         SDL_CloseAudio();
1839
1840         packet_queue_end(&is->audioq);
1841         if (is->reformat_ctx)
1842             av_audio_convert_free(is->reformat_ctx);
1843         break;
1844     case CODEC_TYPE_VIDEO:
1845         packet_queue_abort(&is->videoq);
1846
1847         /* note: we also signal this mutex to make sure we deblock the
1848            video thread in all cases */
1849         SDL_LockMutex(is->pictq_mutex);
1850         SDL_CondSignal(is->pictq_cond);
1851         SDL_UnlockMutex(is->pictq_mutex);
1852
1853         SDL_WaitThread(is->video_tid, NULL);
1854
1855         packet_queue_end(&is->videoq);
1856         break;
1857     case CODEC_TYPE_SUBTITLE:
1858         packet_queue_abort(&is->subtitleq);
1859
1860         /* note: we also signal this mutex to make sure we deblock the
1861            video thread in all cases */
1862         SDL_LockMutex(is->subpq_mutex);
1863         is->subtitle_stream_changed = 1;
1864
1865         SDL_CondSignal(is->subpq_cond);
1866         SDL_UnlockMutex(is->subpq_mutex);
1867
1868         SDL_WaitThread(is->subtitle_tid, NULL);
1869
1870         packet_queue_end(&is->subtitleq);
1871         break;
1872     default:
1873         break;
1874     }
1875
1876     ic->streams[stream_index]->discard = AVDISCARD_ALL;
1877     avcodec_close(enc);
1878     switch(enc->codec_type) {
1879     case CODEC_TYPE_AUDIO:
1880         is->audio_st = NULL;
1881         is->audio_stream = -1;
1882         break;
1883     case CODEC_TYPE_VIDEO:
1884         is->video_st = NULL;
1885         is->video_stream = -1;
1886         break;
1887     case CODEC_TYPE_SUBTITLE:
1888         is->subtitle_st = NULL;
1889         is->subtitle_stream = -1;
1890         break;
1891     default:
1892         break;
1893     }
1894 }
1895
1896 static void dump_stream_info(const AVFormatContext *s)
1897 {
1898     AVMetadataTag *tag = NULL;
1899     while ((tag=av_metadata_get(s->metadata,"",tag,AV_METADATA_IGNORE_SUFFIX)))
1900         fprintf(stderr, "%s: %s\n", tag->key, tag->value);
1901 }
1902
1903 /* since we have only one decoding thread, we can use a global
1904    variable instead of a thread local variable */
1905 static VideoState *global_video_state;
1906
1907 static int decode_interrupt_cb(void)
1908 {
1909     return (global_video_state && global_video_state->abort_request);
1910 }
1911
1912 /* this thread gets the stream from the disk or the network */
1913 static int decode_thread(void *arg)
1914 {
1915     VideoState *is = arg;
1916     AVFormatContext *ic;
1917     int err, i, ret, video_index, audio_index, subtitle_index;
1918     AVPacket pkt1, *pkt = &pkt1;
1919     AVFormatParameters params, *ap = &params;
1920
1921     video_index = -1;
1922     audio_index = -1;
1923     subtitle_index = -1;
1924     is->video_stream = -1;
1925     is->audio_stream = -1;
1926     is->subtitle_stream = -1;
1927
1928     global_video_state = is;
1929     url_set_interrupt_cb(decode_interrupt_cb);
1930
1931     memset(ap, 0, sizeof(*ap));
1932
1933     ap->width = frame_width;
1934     ap->height= frame_height;
1935     ap->time_base= (AVRational){1, 25};
1936     ap->pix_fmt = frame_pix_fmt;
1937
1938     err = av_open_input_file(&ic, is->filename, is->iformat, 0, ap);
1939     if (err < 0) {
1940         print_error(is->filename, err);
1941         ret = -1;
1942         goto fail;
1943     }
1944     is->ic = ic;
1945
1946     if(genpts)
1947         ic->flags |= AVFMT_FLAG_GENPTS;
1948
1949     err = av_find_stream_info(ic);
1950     if (err < 0) {
1951         fprintf(stderr, "%s: could not find codec parameters\n", is->filename);
1952         ret = -1;
1953         goto fail;
1954     }
1955     if(ic->pb)
1956         ic->pb->eof_reached= 0; //FIXME hack, ffplay maybe should not use url_feof() to test for the end
1957
1958     /* if seeking requested, we execute it */
1959     if (start_time != AV_NOPTS_VALUE) {
1960         int64_t timestamp;
1961
1962         timestamp = start_time;
1963         /* add the stream start time */
1964         if (ic->start_time != AV_NOPTS_VALUE)
1965             timestamp += ic->start_time;
1966         ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
1967         if (ret < 0) {
1968             fprintf(stderr, "%s: could not seek to position %0.3f\n",
1969                     is->filename, (double)timestamp / AV_TIME_BASE);
1970         }
1971     }
1972
1973     for(i = 0; i < ic->nb_streams; i++) {
1974         AVCodecContext *enc = ic->streams[i]->codec;
1975         ic->streams[i]->discard = AVDISCARD_ALL;
1976         switch(enc->codec_type) {
1977         case CODEC_TYPE_AUDIO:
1978             if (wanted_audio_stream-- >= 0 && !audio_disable)
1979                 audio_index = i;
1980             break;
1981         case CODEC_TYPE_VIDEO:
1982             if (wanted_video_stream-- >= 0 && !video_disable)
1983                 video_index = i;
1984             break;
1985         case CODEC_TYPE_SUBTITLE:
1986             if (wanted_subtitle_stream-- >= 0 && !video_disable)
1987                 subtitle_index = i;
1988             break;
1989         default:
1990             break;
1991         }
1992     }
1993     if (show_status) {
1994         dump_format(ic, 0, is->filename, 0);
1995         dump_stream_info(ic);
1996     }
1997
1998     /* open the streams */
1999     if (audio_index >= 0) {
2000         stream_component_open(is, audio_index);
2001     }
2002
2003     if (video_index >= 0) {
2004         stream_component_open(is, video_index);
2005     } else {
2006         if (!display_disable)
2007             is->show_audio = 1;
2008     }
2009
2010     if (subtitle_index >= 0) {
2011         stream_component_open(is, subtitle_index);
2012     }
2013
2014     if (is->video_stream < 0 && is->audio_stream < 0) {
2015         fprintf(stderr, "%s: could not open codecs\n", is->filename);
2016         ret = -1;
2017         goto fail;
2018     }
2019
2020     for(;;) {
2021         if (is->abort_request)
2022             break;
2023         if (is->paused != is->last_paused) {
2024             is->last_paused = is->paused;
2025             if (is->paused)
2026                 av_read_pause(ic);
2027             else
2028                 av_read_play(ic);
2029         }
2030 #if CONFIG_RTSP_DEMUXER
2031         if (is->paused && !strcmp(ic->iformat->name, "rtsp")) {
2032             /* wait 10 ms to avoid trying to get another packet */
2033             /* XXX: horrible */
2034             SDL_Delay(10);
2035             continue;
2036         }
2037 #endif
2038         if (is->seek_req) {
2039             int64_t seek_target= is->seek_pos;
2040             int64_t seek_min= is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
2041             int64_t seek_max= is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
2042 //FIXME the +-2 is due to rounding being not done in the correct direction in generation
2043 //      of the seek_pos/seek_rel variables
2044
2045             ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
2046             if (ret < 0) {
2047                 fprintf(stderr, "%s: error while seeking\n", is->ic->filename);
2048             }else{
2049                 if (is->audio_stream >= 0) {
2050                     packet_queue_flush(&is->audioq);
2051                     packet_queue_put(&is->audioq, &flush_pkt);
2052                 }
2053                 if (is->subtitle_stream >= 0) {
2054                     packet_queue_flush(&is->subtitleq);
2055                     packet_queue_put(&is->subtitleq, &flush_pkt);
2056                 }
2057                 if (is->video_stream >= 0) {
2058                     packet_queue_flush(&is->videoq);
2059                     packet_queue_put(&is->videoq, &flush_pkt);
2060                 }
2061             }
2062             is->seek_req = 0;
2063         }
2064
2065         /* if the queue are full, no need to read more */
2066         if (is->audioq.size > MAX_AUDIOQ_SIZE ||
2067             is->videoq.size > MAX_VIDEOQ_SIZE ||
2068             is->subtitleq.size > MAX_SUBTITLEQ_SIZE) {
2069             /* wait 10 ms */
2070             SDL_Delay(10);
2071             continue;
2072         }
2073         if(url_feof(ic->pb)) {
2074             av_init_packet(pkt);
2075             pkt->data=NULL;
2076             pkt->size=0;
2077             pkt->stream_index= is->video_stream;
2078             packet_queue_put(&is->videoq, pkt);
2079             continue;
2080         }
2081         ret = av_read_frame(ic, pkt);
2082         if (ret < 0) {
2083             if (ret != AVERROR_EOF && url_ferror(ic->pb) == 0) {
2084                 SDL_Delay(100); /* wait for user event */
2085                 continue;
2086             } else
2087                 break;
2088         }
2089         if (pkt->stream_index == is->audio_stream) {
2090             packet_queue_put(&is->audioq, pkt);
2091         } else if (pkt->stream_index == is->video_stream) {
2092             packet_queue_put(&is->videoq, pkt);
2093         } else if (pkt->stream_index == is->subtitle_stream) {
2094             packet_queue_put(&is->subtitleq, pkt);
2095         } else {
2096             av_free_packet(pkt);
2097         }
2098     }
2099     /* wait until the end */
2100     while (!is->abort_request) {
2101         SDL_Delay(100);
2102     }
2103
2104     ret = 0;
2105  fail:
2106     /* disable interrupting */
2107     global_video_state = NULL;
2108
2109     /* close each stream */
2110     if (is->audio_stream >= 0)
2111         stream_component_close(is, is->audio_stream);
2112     if (is->video_stream >= 0)
2113         stream_component_close(is, is->video_stream);
2114     if (is->subtitle_stream >= 0)
2115         stream_component_close(is, is->subtitle_stream);
2116     if (is->ic) {
2117         av_close_input_file(is->ic);
2118         is->ic = NULL; /* safety */
2119     }
2120     url_set_interrupt_cb(NULL);
2121
2122     if (ret != 0) {
2123         SDL_Event event;
2124
2125         event.type = FF_QUIT_EVENT;
2126         event.user.data1 = is;
2127         SDL_PushEvent(&event);
2128     }
2129     return 0;
2130 }
2131
2132 static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
2133 {
2134     VideoState *is;
2135
2136     is = av_mallocz(sizeof(VideoState));
2137     if (!is)
2138         return NULL;
2139     av_strlcpy(is->filename, filename, sizeof(is->filename));
2140     is->iformat = iformat;
2141     is->ytop = 0;
2142     is->xleft = 0;
2143
2144     /* start video display */
2145     is->pictq_mutex = SDL_CreateMutex();
2146     is->pictq_cond = SDL_CreateCond();
2147
2148     is->subpq_mutex = SDL_CreateMutex();
2149     is->subpq_cond = SDL_CreateCond();
2150
2151     /* add the refresh timer to draw the picture */
2152     schedule_refresh(is, 40);
2153
2154     is->av_sync_type = av_sync_type;
2155     is->parse_tid = SDL_CreateThread(decode_thread, is);
2156     if (!is->parse_tid) {
2157         av_free(is);
2158         return NULL;
2159     }
2160     return is;
2161 }
2162
2163 static void stream_close(VideoState *is)
2164 {
2165     VideoPicture *vp;
2166     int i;
2167     /* XXX: use a special url_shutdown call to abort parse cleanly */
2168     is->abort_request = 1;
2169     SDL_WaitThread(is->parse_tid, NULL);
2170
2171     /* free all pictures */
2172     for(i=0;i<VIDEO_PICTURE_QUEUE_SIZE; i++) {
2173         vp = &is->pictq[i];
2174         if (vp->bmp) {
2175             SDL_FreeYUVOverlay(vp->bmp);
2176             vp->bmp = NULL;
2177         }
2178     }
2179     SDL_DestroyMutex(is->pictq_mutex);
2180     SDL_DestroyCond(is->pictq_cond);
2181     SDL_DestroyMutex(is->subpq_mutex);
2182     SDL_DestroyCond(is->subpq_cond);
2183 }
2184
2185 static void stream_cycle_channel(VideoState *is, int codec_type)
2186 {
2187     AVFormatContext *ic = is->ic;
2188     int start_index, stream_index;
2189     AVStream *st;
2190
2191     if (codec_type == CODEC_TYPE_VIDEO)
2192         start_index = is->video_stream;
2193     else if (codec_type == CODEC_TYPE_AUDIO)
2194         start_index = is->audio_stream;
2195     else
2196         start_index = is->subtitle_stream;
2197     if (start_index < (codec_type == CODEC_TYPE_SUBTITLE ? -1 : 0))
2198         return;
2199     stream_index = start_index;
2200     for(;;) {
2201         if (++stream_index >= is->ic->nb_streams)
2202         {
2203             if (codec_type == CODEC_TYPE_SUBTITLE)
2204             {
2205                 stream_index = -1;
2206                 goto the_end;
2207             } else
2208                 stream_index = 0;
2209         }
2210         if (stream_index == start_index)
2211             return;
2212         st = ic->streams[stream_index];
2213         if (st->codec->codec_type == codec_type) {
2214             /* check that parameters are OK */
2215             switch(codec_type) {
2216             case CODEC_TYPE_AUDIO:
2217                 if (st->codec->sample_rate != 0 &&
2218                     st->codec->channels != 0)
2219                     goto the_end;
2220                 break;
2221             case CODEC_TYPE_VIDEO:
2222             case CODEC_TYPE_SUBTITLE:
2223                 goto the_end;
2224             default:
2225                 break;
2226             }
2227         }
2228     }
2229  the_end:
2230     stream_component_close(is, start_index);
2231     stream_component_open(is, stream_index);
2232 }
2233
2234
2235 static void toggle_full_screen(void)
2236 {
2237     is_full_screen = !is_full_screen;
2238     if (!fs_screen_width) {
2239         /* use default SDL method */
2240 //        SDL_WM_ToggleFullScreen(screen);
2241     }
2242     video_open(cur_stream);
2243 }
2244
2245 static void toggle_pause(void)
2246 {
2247     if (cur_stream)
2248         stream_pause(cur_stream);
2249     step = 0;
2250 }
2251
2252 static void step_to_next_frame(void)
2253 {
2254     if (cur_stream) {
2255         /* if the stream is paused unpause it, then step */
2256         if (cur_stream->paused)
2257             stream_pause(cur_stream);
2258     }
2259     step = 1;
2260 }
2261
2262 static void do_exit(void)
2263 {
2264     if (cur_stream) {
2265         stream_close(cur_stream);
2266         cur_stream = NULL;
2267     }
2268     if (show_status)
2269         printf("\n");
2270     SDL_Quit();
2271     exit(0);
2272 }
2273
2274 static void toggle_audio_display(void)
2275 {
2276     if (cur_stream) {
2277         cur_stream->show_audio = !cur_stream->show_audio;
2278     }
2279 }
2280
2281 /* handle an event sent by the GUI */
2282 static void event_loop(void)
2283 {
2284     SDL_Event event;
2285     double incr, pos, frac;
2286
2287     for(;;) {
2288         SDL_WaitEvent(&event);
2289         switch(event.type) {
2290         case SDL_KEYDOWN:
2291             switch(event.key.keysym.sym) {
2292             case SDLK_ESCAPE:
2293             case SDLK_q:
2294                 do_exit();
2295                 break;
2296             case SDLK_f:
2297                 toggle_full_screen();
2298                 break;
2299             case SDLK_p:
2300             case SDLK_SPACE:
2301                 toggle_pause();
2302                 break;
2303             case SDLK_s: //S: Step to next frame
2304                 step_to_next_frame();
2305                 break;
2306             case SDLK_a:
2307                 if (cur_stream)
2308                     stream_cycle_channel(cur_stream, CODEC_TYPE_AUDIO);
2309                 break;
2310             case SDLK_v:
2311                 if (cur_stream)
2312                     stream_cycle_channel(cur_stream, CODEC_TYPE_VIDEO);
2313                 break;
2314             case SDLK_t:
2315                 if (cur_stream)
2316                     stream_cycle_channel(cur_stream, CODEC_TYPE_SUBTITLE);
2317                 break;
2318             case SDLK_w:
2319                 toggle_audio_display();
2320                 break;
2321             case SDLK_LEFT:
2322                 incr = -10.0;
2323                 goto do_seek;
2324             case SDLK_RIGHT:
2325                 incr = 10.0;
2326                 goto do_seek;
2327             case SDLK_UP:
2328                 incr = 60.0;
2329                 goto do_seek;
2330             case SDLK_DOWN:
2331                 incr = -60.0;
2332             do_seek:
2333                 if (cur_stream) {
2334                     if (seek_by_bytes) {
2335                         pos = url_ftell(cur_stream->ic->pb);
2336                         if (cur_stream->ic->bit_rate)
2337                             incr *= cur_stream->ic->bit_rate / 60.0;
2338                         else
2339                             incr *= 180000.0;
2340                         pos += incr;
2341                         stream_seek(cur_stream, pos, incr);
2342                     } else {
2343                         pos = get_master_clock(cur_stream);
2344                         pos += incr;
2345                         stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE));
2346                     }
2347                 }
2348                 break;
2349             default:
2350                 break;
2351             }
2352             break;
2353         case SDL_MOUSEBUTTONDOWN:
2354             if (cur_stream) {
2355                 int ns, hh, mm, ss;
2356                 int tns, thh, tmm, tss;
2357                 tns = cur_stream->ic->duration/1000000LL;
2358                 thh = tns/3600;
2359                 tmm = (tns%3600)/60;
2360                 tss = (tns%60);
2361                 frac = (double)event.button.x/(double)cur_stream->width;
2362                 ns = frac*tns;
2363                 hh = ns/3600;
2364                 mm = (ns%3600)/60;
2365                 ss = (ns%60);
2366                 fprintf(stderr, "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d)       \n", frac*100,
2367                         hh, mm, ss, thh, tmm, tss);
2368                 stream_seek(cur_stream, (int64_t)(cur_stream->ic->start_time+frac*cur_stream->ic->duration), 0);
2369             }
2370             break;
2371         case SDL_VIDEORESIZE:
2372             if (cur_stream) {
2373                 screen = SDL_SetVideoMode(event.resize.w, event.resize.h, 0,
2374                                           SDL_HWSURFACE|SDL_RESIZABLE|SDL_ASYNCBLIT|SDL_HWACCEL);
2375                 screen_width = cur_stream->width = event.resize.w;
2376                 screen_height= cur_stream->height= event.resize.h;
2377             }
2378             break;
2379         case SDL_QUIT:
2380         case FF_QUIT_EVENT:
2381             do_exit();
2382             break;
2383         case FF_ALLOC_EVENT:
2384             video_open(event.user.data1);
2385             alloc_picture(event.user.data1);
2386             break;
2387         case FF_REFRESH_EVENT:
2388             video_refresh_timer(event.user.data1);
2389             break;
2390         default:
2391             break;
2392         }
2393     }
2394 }
2395
2396 static void opt_frame_size(const char *arg)
2397 {
2398     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2399         fprintf(stderr, "Incorrect frame size\n");
2400         exit(1);
2401     }
2402     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2403         fprintf(stderr, "Frame size must be a multiple of 2\n");
2404         exit(1);
2405     }
2406 }
2407
2408 static int opt_width(const char *opt, const char *arg)
2409 {
2410     screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
2411     return 0;
2412 }
2413
2414 static int opt_height(const char *opt, const char *arg)
2415 {
2416     screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
2417     return 0;
2418 }
2419
2420 static void opt_format(const char *arg)
2421 {
2422     file_iformat = av_find_input_format(arg);
2423     if (!file_iformat) {
2424         fprintf(stderr, "Unknown input format: %s\n", arg);
2425         exit(1);
2426     }
2427 }
2428
2429 static void opt_frame_pix_fmt(const char *arg)
2430 {
2431     frame_pix_fmt = avcodec_get_pix_fmt(arg);
2432 }
2433
2434 static int opt_sync(const char *opt, const char *arg)
2435 {
2436     if (!strcmp(arg, "audio"))
2437         av_sync_type = AV_SYNC_AUDIO_MASTER;
2438     else if (!strcmp(arg, "video"))
2439         av_sync_type = AV_SYNC_VIDEO_MASTER;
2440     else if (!strcmp(arg, "ext"))
2441         av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
2442     else {
2443         fprintf(stderr, "Unknown value for %s: %s\n", opt, arg);
2444         exit(1);
2445     }
2446     return 0;
2447 }
2448
2449 static int opt_seek(const char *opt, const char *arg)
2450 {
2451     start_time = parse_time_or_die(opt, arg, 1);
2452     return 0;
2453 }
2454
2455 static int opt_debug(const char *opt, const char *arg)
2456 {
2457     av_log_set_level(99);
2458     debug = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2459     return 0;
2460 }
2461
2462 static int opt_vismv(const char *opt, const char *arg)
2463 {
2464     debug_mv = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2465     return 0;
2466 }
2467
2468 static int opt_thread_count(const char *opt, const char *arg)
2469 {
2470     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2471 #if !HAVE_THREADS
2472     fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2473 #endif
2474     return 0;
2475 }
2476
2477 static const OptionDef options[] = {
2478     { "h", OPT_EXIT, {(void*)show_help}, "show help" },
2479     { "version", OPT_EXIT, {(void*)show_version}, "show version" },
2480     { "L", OPT_EXIT, {(void*)show_license}, "show license" },
2481     { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
2482     { "x", HAS_ARG | OPT_FUNC2, {(void*)opt_width}, "force displayed width", "width" },
2483     { "y", HAS_ARG | OPT_FUNC2, {(void*)opt_height}, "force displayed height", "height" },
2484     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
2485     { "fs", OPT_BOOL, {(void*)&is_full_screen}, "force full screen" },
2486     { "an", OPT_BOOL, {(void*)&audio_disable}, "disable audio" },
2487     { "vn", OPT_BOOL, {(void*)&video_disable}, "disable video" },
2488     { "ast", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_audio_stream}, "select desired audio stream", "stream_number" },
2489     { "vst", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_video_stream}, "select desired video stream", "stream_number" },
2490     { "sst", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_subtitle_stream}, "select desired subtitle stream", "stream_number" },
2491     { "ss", HAS_ARG | OPT_FUNC2, {(void*)&opt_seek}, "seek to a given position in seconds", "pos" },
2492     { "bytes", OPT_BOOL, {(void*)&seek_by_bytes}, "seek by bytes" },
2493     { "nodisp", OPT_BOOL, {(void*)&display_disable}, "disable graphical display" },
2494     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
2495     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
2496     { "stats", OPT_BOOL | OPT_EXPERT, {(void*)&show_status}, "show status", "" },
2497     { "debug", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
2498     { "bug", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&workaround_bugs}, "workaround bugs", "" },
2499     { "vismv", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
2500     { "fast", OPT_BOOL | OPT_EXPERT, {(void*)&fast}, "non spec compliant optimizations", "" },
2501     { "genpts", OPT_BOOL | OPT_EXPERT, {(void*)&genpts}, "generate pts", "" },
2502     { "drp", OPT_BOOL |OPT_EXPERT, {(void*)&decoder_reorder_pts}, "let decoder reorder pts", ""},
2503     { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&lowres}, "", "" },
2504     { "skiploop", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&skip_loop_filter}, "", "" },
2505     { "skipframe", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&skip_frame}, "", "" },
2506     { "skipidct", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&skip_idct}, "", "" },
2507     { "idct", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&idct}, "set idct algo",  "algo" },
2508     { "er", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&error_recognition}, "set error detection threshold (0-4)",  "threshold" },
2509     { "ec", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&error_concealment}, "set error concealment options",  "bit_mask" },
2510     { "sync", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_sync}, "set audio-video sync. type (type=audio/video/ext)", "type" },
2511     { "threads", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
2512     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
2513     { NULL, },
2514 };
2515
2516 static void show_help(void)
2517 {
2518     printf("usage: ffplay [options] input_file\n"
2519            "Simple media player\n");
2520     printf("\n");
2521     show_help_options(options, "Main options:\n",
2522                       OPT_EXPERT, 0);
2523     show_help_options(options, "\nAdvanced options:\n",
2524                       OPT_EXPERT, OPT_EXPERT);
2525     printf("\nWhile playing:\n"
2526            "q, ESC              quit\n"
2527            "f                   toggle full screen\n"
2528            "p, SPC              pause\n"
2529            "a                   cycle audio channel\n"
2530            "v                   cycle video channel\n"
2531            "t                   cycle subtitle channel\n"
2532            "w                   show audio waves\n"
2533            "left/right          seek backward/forward 10 seconds\n"
2534            "down/up             seek backward/forward 1 minute\n"
2535            "mouse click         seek to percentage in file corresponding to fraction of width\n"
2536            );
2537 }
2538
2539 static void opt_input_file(const char *filename)
2540 {
2541     if (!strcmp(filename, "-"))
2542         filename = "pipe:";
2543     input_filename = filename;
2544 }
2545
2546 /* Called from the main */
2547 int main(int argc, char **argv)
2548 {
2549     int flags, i;
2550
2551     /* register all codecs, demux and protocols */
2552     avcodec_register_all();
2553     avdevice_register_all();
2554     av_register_all();
2555
2556     for(i=0; i<CODEC_TYPE_NB; i++){
2557         avcodec_opts[i]= avcodec_alloc_context2(i);
2558     }
2559     avformat_opts = avformat_alloc_context();
2560     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
2561
2562     show_banner();
2563
2564     parse_options(argc, argv, options, opt_input_file);
2565
2566     if (!input_filename) {
2567         fprintf(stderr, "An input file must be specified\n");
2568         exit(1);
2569     }
2570
2571     if (display_disable) {
2572         video_disable = 1;
2573     }
2574     flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
2575 #if !defined(__MINGW32__) && !defined(__APPLE__)
2576     flags |= SDL_INIT_EVENTTHREAD; /* Not supported on Windows or Mac OS X */
2577 #endif
2578     if (SDL_Init (flags)) {
2579         fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
2580         exit(1);
2581     }
2582
2583     if (!display_disable) {
2584 #if HAVE_SDL_VIDEO_SIZE
2585         const SDL_VideoInfo *vi = SDL_GetVideoInfo();
2586         fs_screen_width = vi->current_w;
2587         fs_screen_height = vi->current_h;
2588 #endif
2589     }
2590
2591     SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
2592     SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE);
2593     SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
2594     SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
2595
2596     av_init_packet(&flush_pkt);
2597     flush_pkt.data= "FLUSH";
2598
2599     cur_stream = stream_open(input_filename, file_iformat);
2600
2601     event_loop();
2602
2603     /* never returns */
2604
2605     return 0;
2606 }