ffplay.c

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