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

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