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