avplay.c

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