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

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