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