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

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