ffplay.c

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