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

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