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