Switch regression test to the new seeking API.
[libav.git] / ffplay.c
CommitLineData
01310af2
FB
1/*
2 * FFplay : Simple Media Player based on the ffmpeg libraries
3 * Copyright (c) 2003 Fabrice Bellard
4 *
b78e7197
DB
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
01310af2
FB
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
01310af2 11 *
b78e7197 12 * FFmpeg is distributed in the hope that it will be useful,
01310af2
FB
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
b78e7197 18 * License along with FFmpeg; if not, write to the Free Software
5509bffa 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
01310af2 20 */
364a9607 21
0f4e8165
RB
22#include <math.h>
23#include <limits.h>
245976da
DB
24#include "libavutil/avstring.h"
25#include "libavformat/avformat.h"
26#include "libavformat/rtsp.h"
27#include "libavdevice/avdevice.h"
28#include "libswscale/swscale.h"
5a4476e2 29#include "libavcodec/audioconvert.h"
e43d7a18 30#include "libavcodec/opt.h"
01310af2
FB
31
32#include "cmdutils.h"
33
34#include <SDL.h>
35#include <SDL_thread.h>
36
2f30a81d 37#ifdef __MINGW32__
31319a8c
FB
38#undef main /* We don't want SDL to override our main() */
39#endif
40
c367d067
MN
41#undef exit
42
64555bd9 43const char program_name[] = "FFplay";
ea9c581f 44const int program_birth_year = 2003;
4cfac5bc 45
638c9d91
FB
46//#define DEBUG_SYNC
47
01310af2
FB
48#define MAX_VIDEOQ_SIZE (5 * 256 * 1024)
49#define MAX_AUDIOQ_SIZE (5 * 16 * 1024)
72ce053b 50#define MAX_SUBTITLEQ_SIZE (5 * 16 * 1024)
01310af2 51
638c9d91
FB
52/* SDL audio buffer size, in samples. Should be small to have precise
53 A/V sync as SDL does not have hardware buffer fullness info. */
54#define SDL_AUDIO_BUFFER_SIZE 1024
55
56/* no AV sync correction is done if below the AV sync threshold */
7e0140cb 57#define AV_SYNC_THRESHOLD 0.01
638c9d91
FB
58/* no AV correction is done if too big error */
59#define AV_NOSYNC_THRESHOLD 10.0
60
61/* maximum audio speed change to get correct sync */
62#define SAMPLE_CORRECTION_PERCENT_MAX 10
63
64/* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
65#define AUDIO_DIFF_AVG_NB 20
66
01310af2
FB
67/* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
68#define SAMPLE_ARRAY_SIZE (2*65536)
69
03ae87a3
LA
70static int sws_flags = SWS_BICUBIC;
71
01310af2
FB
72typedef struct PacketQueue {
73 AVPacketList *first_pkt, *last_pkt;
74 int nb_packets;
75 int size;
76 int abort_request;
77 SDL_mutex *mutex;
78 SDL_cond *cond;
79} PacketQueue;
80
81#define VIDEO_PICTURE_QUEUE_SIZE 1
72ce053b 82#define SUBPICTURE_QUEUE_SIZE 4
01310af2
FB
83
84typedef struct VideoPicture {
267e9dfa 85 double pts; ///<presentation time stamp for this picture
01310af2
FB
86 SDL_Overlay *bmp;
87 int width, height; /* source height & width */
88 int allocated;
89} VideoPicture;
90
72ce053b
IC
91typedef struct SubPicture {
92 double pts; /* presentation time stamp for this picture */
93 AVSubtitle sub;
94} SubPicture;
95
01310af2
FB
96enum {
97 AV_SYNC_AUDIO_MASTER, /* default choice */
98 AV_SYNC_VIDEO_MASTER,
638c9d91 99 AV_SYNC_EXTERNAL_CLOCK, /* synchronize to an external clock */
01310af2
FB
100};
101
102typedef struct VideoState {
103 SDL_Thread *parse_tid;
104 SDL_Thread *video_tid;
638c9d91 105 AVInputFormat *iformat;
01310af2
FB
106 int no_background;
107 int abort_request;
108 int paused;
416e3508 109 int last_paused;
72ea344b 110 int seek_req;
3ba1438d 111 int seek_flags;
72ea344b 112 int64_t seek_pos;
01310af2
FB
113 AVFormatContext *ic;
114 int dtg_active_format;
115
116 int audio_stream;
115329f1 117
01310af2 118 int av_sync_type;
638c9d91
FB
119 double external_clock; /* external clock base */
120 int64_t external_clock_time;
115329f1 121
638c9d91
FB
122 double audio_clock;
123 double audio_diff_cum; /* used for AV difference average computation */
124 double audio_diff_avg_coef;
125 double audio_diff_threshold;
126 int audio_diff_avg_count;
01310af2
FB
127 AVStream *audio_st;
128 PacketQueue audioq;
129 int audio_hw_buf_size;
130 /* samples output by the codec. we reserve more space for avsync
131 compensation */
5a4476e2
PR
132 DECLARE_ALIGNED(16,uint8_t,audio_buf1[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2]);
133 DECLARE_ALIGNED(16,uint8_t,audio_buf2[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2]);
134 uint8_t *audio_buf;
7fea94ce 135 unsigned int audio_buf_size; /* in bytes */
01310af2
FB
136 int audio_buf_index; /* in bytes */
137 AVPacket audio_pkt;
138 uint8_t *audio_pkt_data;
139 int audio_pkt_size;
5a4476e2
PR
140 enum SampleFormat audio_src_fmt;
141 AVAudioConvert *reformat_ctx;
115329f1 142
01310af2
FB
143 int show_audio; /* if true, display audio samples */
144 int16_t sample_array[SAMPLE_ARRAY_SIZE];
145 int sample_array_index;
5e0257e3 146 int last_i_start;
115329f1 147
72ce053b
IC
148 SDL_Thread *subtitle_tid;
149 int subtitle_stream;
150 int subtitle_stream_changed;
151 AVStream *subtitle_st;
152 PacketQueue subtitleq;
153 SubPicture subpq[SUBPICTURE_QUEUE_SIZE];
154 int subpq_size, subpq_rindex, subpq_windex;
155 SDL_mutex *subpq_mutex;
156 SDL_cond *subpq_cond;
115329f1 157
638c9d91
FB
158 double frame_timer;
159 double frame_last_pts;
160 double frame_last_delay;
115329f1 161 double video_clock; ///<pts of last decoded frame / predicted pts of next decoded frame
01310af2
FB
162 int video_stream;
163 AVStream *video_st;
164 PacketQueue videoq;
267e9dfa
MN
165 double video_current_pts; ///<current displayed pts (different from video_clock if frame fifos are used)
166 int64_t video_current_pts_time; ///<time (av_gettime) at which we updated video_current_pts - used to have running video pts
01310af2
FB
167 VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];
168 int pictq_size, pictq_rindex, pictq_windex;
169 SDL_mutex *pictq_mutex;
170 SDL_cond *pictq_cond;
115329f1 171
01310af2
FB
172 // QETimer *video_timer;
173 char filename[1024];
174 int width, height, xleft, ytop;
175} VideoState;
176
358061f6 177static void show_help(void);
638c9d91 178static int audio_write_get_buf_size(VideoState *is);
01310af2
FB
179
180/* options specified by the user */
181static AVInputFormat *file_iformat;
182static const char *input_filename;
183static int fs_screen_width;
184static int fs_screen_height;
fccb19e3
MN
185static int screen_width = 0;
186static int screen_height = 0;
e4b89522
LW
187static int frame_width = 0;
188static int frame_height = 0;
189static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
01310af2
FB
190static int audio_disable;
191static int video_disable;
a8062103 192static int wanted_audio_stream= 0;
4d8243d3 193static int wanted_video_stream= 0;
16a59a7b 194static int wanted_subtitle_stream= -1;
94b594c6 195static int seek_by_bytes;
01310af2
FB
196static int display_disable;
197static int show_status;
638c9d91 198static int av_sync_type = AV_SYNC_AUDIO_MASTER;
72ea344b 199static int64_t start_time = AV_NOPTS_VALUE;
e26a8335 200static int debug = 0;
0c9bbaec 201static int debug_mv = 0;
bba04f1e 202static int step = 0;
c62c07d3 203static int thread_count = 1;
6387c3e6 204static int workaround_bugs = 1;
6fc5b059 205static int fast = 0;
30bc6613 206static int genpts = 0;
178fcca8
MN
207static int lowres = 0;
208static int idct = FF_IDCT_AUTO;
8c3eba7c
MN
209static enum AVDiscard skip_frame= AVDISCARD_DEFAULT;
210static enum AVDiscard skip_idct= AVDISCARD_DEFAULT;
211static enum AVDiscard skip_loop_filter= AVDISCARD_DEFAULT;
047599a4 212static int error_recognition = FF_ER_CAREFUL;
1b51e051 213static int error_concealment = 3;
5039185a 214static int decoder_reorder_pts= 0;
01310af2
FB
215
216/* current context */
217static int is_full_screen;
218static VideoState *cur_stream;
5e0257e3 219static int64_t audio_callback_time;
01310af2 220
2c676c33 221static AVPacket flush_pkt;
39c6a118 222
01310af2
FB
223#define FF_ALLOC_EVENT (SDL_USEREVENT)
224#define FF_REFRESH_EVENT (SDL_USEREVENT + 1)
638c9d91 225#define FF_QUIT_EVENT (SDL_USEREVENT + 2)
01310af2 226
2c676c33 227static SDL_Surface *screen;
01310af2
FB
228
229/* packet queue handling */
230static void packet_queue_init(PacketQueue *q)
231{
232 memset(q, 0, sizeof(PacketQueue));
233 q->mutex = SDL_CreateMutex();
234 q->cond = SDL_CreateCond();
235}
236
72ea344b 237static void packet_queue_flush(PacketQueue *q)
01310af2
FB
238{
239 AVPacketList *pkt, *pkt1;
240
687fae2b 241 SDL_LockMutex(q->mutex);
01310af2
FB
242 for(pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
243 pkt1 = pkt->next;
244 av_free_packet(&pkt->pkt);
da6c4573 245 av_freep(&pkt);
01310af2 246 }
72ea344b
FB
247 q->last_pkt = NULL;
248 q->first_pkt = NULL;
249 q->nb_packets = 0;
250 q->size = 0;
687fae2b 251 SDL_UnlockMutex(q->mutex);
72ea344b
FB
252}
253
254static void packet_queue_end(PacketQueue *q)
255{
256 packet_queue_flush(q);
01310af2
FB
257 SDL_DestroyMutex(q->mutex);
258 SDL_DestroyCond(q->cond);
259}
260
261static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
262{
263 AVPacketList *pkt1;
264
72ea344b 265 /* duplicate the packet */
39c6a118 266 if (pkt!=&flush_pkt && av_dup_packet(pkt) < 0)
72ea344b 267 return -1;
115329f1 268
01310af2
FB
269 pkt1 = av_malloc(sizeof(AVPacketList));
270 if (!pkt1)
271 return -1;
272 pkt1->pkt = *pkt;
273 pkt1->next = NULL;
274
72ea344b 275
01310af2
FB
276 SDL_LockMutex(q->mutex);
277
278 if (!q->last_pkt)
279
280 q->first_pkt = pkt1;
281 else
282 q->last_pkt->next = pkt1;
283 q->last_pkt = pkt1;
284 q->nb_packets++;
7b776589 285 q->size += pkt1->pkt.size + sizeof(*pkt1);
01310af2
FB
286 /* XXX: should duplicate packet data in DV case */
287 SDL_CondSignal(q->cond);
288
289 SDL_UnlockMutex(q->mutex);
290 return 0;
291}
292
293static void packet_queue_abort(PacketQueue *q)
294{
295 SDL_LockMutex(q->mutex);
296
297 q->abort_request = 1;
115329f1 298
01310af2
FB
299 SDL_CondSignal(q->cond);
300
301 SDL_UnlockMutex(q->mutex);
302}
303
304/* return < 0 if aborted, 0 if no packet and > 0 if packet. */
305static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block)
306{
307 AVPacketList *pkt1;
308 int ret;
309
310 SDL_LockMutex(q->mutex);
311
312 for(;;) {
313 if (q->abort_request) {
314 ret = -1;
315 break;
316 }
115329f1 317
01310af2
FB
318 pkt1 = q->first_pkt;
319 if (pkt1) {
320 q->first_pkt = pkt1->next;
321 if (!q->first_pkt)
322 q->last_pkt = NULL;
323 q->nb_packets--;
7b776589 324 q->size -= pkt1->pkt.size + sizeof(*pkt1);
01310af2
FB
325 *pkt = pkt1->pkt;
326 av_free(pkt1);
327 ret = 1;
328 break;
329 } else if (!block) {
330 ret = 0;
331 break;
332 } else {
333 SDL_CondWait(q->cond, q->mutex);
334 }
335 }
336 SDL_UnlockMutex(q->mutex);
337 return ret;
338}
339
115329f1 340static inline void fill_rectangle(SDL_Surface *screen,
01310af2
FB
341 int x, int y, int w, int h, int color)
342{
343 SDL_Rect rect;
344 rect.x = x;
345 rect.y = y;
346 rect.w = w;
347 rect.h = h;
348 SDL_FillRect(screen, &rect, color);
349}
350
351#if 0
352/* draw only the border of a rectangle */
353void fill_border(VideoState *s, int x, int y, int w, int h, int color)
354{
355 int w1, w2, h1, h2;
356
357 /* fill the background */
358 w1 = x;
359 if (w1 < 0)
360 w1 = 0;
361 w2 = s->width - (x + w);
362 if (w2 < 0)
363 w2 = 0;
364 h1 = y;
365 if (h1 < 0)
366 h1 = 0;
367 h2 = s->height - (y + h);
368 if (h2 < 0)
369 h2 = 0;
115329f1
DB
370 fill_rectangle(screen,
371 s->xleft, s->ytop,
372 w1, s->height,
01310af2 373 color);
115329f1
DB
374 fill_rectangle(screen,
375 s->xleft + s->width - w2, s->ytop,
376 w2, s->height,
01310af2 377 color);
115329f1
DB
378 fill_rectangle(screen,
379 s->xleft + w1, s->ytop,
380 s->width - w1 - w2, h1,
01310af2 381 color);
115329f1 382 fill_rectangle(screen,
01310af2
FB
383 s->xleft + w1, s->ytop + s->height - h2,
384 s->width - w1 - w2, h2,
385 color);
386}
387#endif
388
72ce053b
IC
389
390
391#define SCALEBITS 10
392#define ONE_HALF (1 << (SCALEBITS - 1))
393#define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
394
395#define RGB_TO_Y_CCIR(r, g, b) \
396((FIX(0.29900*219.0/255.0) * (r) + FIX(0.58700*219.0/255.0) * (g) + \
397 FIX(0.11400*219.0/255.0) * (b) + (ONE_HALF + (16 << SCALEBITS))) >> SCALEBITS)
398
399#define RGB_TO_U_CCIR(r1, g1, b1, shift)\
400(((- FIX(0.16874*224.0/255.0) * r1 - FIX(0.33126*224.0/255.0) * g1 + \
401 FIX(0.50000*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
402
403#define RGB_TO_V_CCIR(r1, g1, b1, shift)\
404(((FIX(0.50000*224.0/255.0) * r1 - FIX(0.41869*224.0/255.0) * g1 - \
405 FIX(0.08131*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
406
407#define ALPHA_BLEND(a, oldp, newp, s)\
408((((oldp << s) * (255 - (a))) + (newp * (a))) / (255 << s))
409
410#define RGBA_IN(r, g, b, a, s)\
411{\
412 unsigned int v = ((const uint32_t *)(s))[0];\
413 a = (v >> 24) & 0xff;\
414 r = (v >> 16) & 0xff;\
415 g = (v >> 8) & 0xff;\
416 b = v & 0xff;\
417}
418
419#define YUVA_IN(y, u, v, a, s, pal)\
420{\
57cf99f2 421 unsigned int val = ((const uint32_t *)(pal))[*(const uint8_t*)(s)];\
72ce053b
IC
422 a = (val >> 24) & 0xff;\
423 y = (val >> 16) & 0xff;\
424 u = (val >> 8) & 0xff;\
425 v = val & 0xff;\
426}
427
428#define YUVA_OUT(d, y, u, v, a)\
429{\
430 ((uint32_t *)(d))[0] = (a << 24) | (y << 16) | (u << 8) | v;\
431}
432
433
434#define BPP 1
435
0a8cd696 436static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect, int imgw, int imgh)
72ce053b
IC
437{
438 int wrap, wrap3, width2, skip2;
439 int y, u, v, a, u1, v1, a1, w, h;
440 uint8_t *lum, *cb, *cr;
441 const uint8_t *p;
442 const uint32_t *pal;
9cb5a11e
RD
443 int dstx, dsty, dstw, dsth;
444
7cf9c6ae
MN
445 dstw = av_clip(rect->w, 0, imgw);
446 dsth = av_clip(rect->h, 0, imgh);
447 dstx = av_clip(rect->x, 0, imgw - dstw);
448 dsty = av_clip(rect->y, 0, imgh - dsth);
9cb5a11e
RD
449 lum = dst->data[0] + dsty * dst->linesize[0];
450 cb = dst->data[1] + (dsty >> 1) * dst->linesize[1];
451 cr = dst->data[2] + (dsty >> 1) * dst->linesize[2];
452
f54b31b9 453 width2 = ((dstw + 1) >> 1) + (dstx & ~dstw & 1);
9cb5a11e 454 skip2 = dstx >> 1;
72ce053b 455 wrap = dst->linesize[0];
25b4c651
MN
456 wrap3 = rect->pict.linesize[0];
457 p = rect->pict.data[0];
458 pal = (const uint32_t *)rect->pict.data[1]; /* Now in YCrCb! */
115329f1 459
9cb5a11e
RD
460 if (dsty & 1) {
461 lum += dstx;
72ce053b
IC
462 cb += skip2;
463 cr += skip2;
115329f1 464
9cb5a11e 465 if (dstx & 1) {
72ce053b
IC
466 YUVA_IN(y, u, v, a, p, pal);
467 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
468 cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
469 cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
470 cb++;
471 cr++;
472 lum++;
473 p += BPP;
474 }
9cb5a11e 475 for(w = dstw - (dstx & 1); w >= 2; w -= 2) {
72ce053b
IC
476 YUVA_IN(y, u, v, a, p, pal);
477 u1 = u;
478 v1 = v;
479 a1 = a;
480 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
481
482 YUVA_IN(y, u, v, a, p + BPP, pal);
483 u1 += u;
484 v1 += v;
485 a1 += a;
486 lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
487 cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
488 cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
489 cb++;
490 cr++;
491 p += 2 * BPP;
492 lum += 2;
493 }
494 if (w) {
495 YUVA_IN(y, u, v, a, p, pal);
496 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
497 cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
498 cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
676ef505
BA
499 p++;
500 lum++;
72ce053b 501 }
4606a059
BA
502 p += wrap3 - dstw * BPP;
503 lum += wrap - dstw - dstx;
72ce053b
IC
504 cb += dst->linesize[1] - width2 - skip2;
505 cr += dst->linesize[2] - width2 - skip2;
506 }
9cb5a11e
RD
507 for(h = dsth - (dsty & 1); h >= 2; h -= 2) {
508 lum += dstx;
72ce053b
IC
509 cb += skip2;
510 cr += skip2;
115329f1 511
9cb5a11e 512 if (dstx & 1) {
72ce053b
IC
513 YUVA_IN(y, u, v, a, p, pal);
514 u1 = u;
515 v1 = v;
516 a1 = a;
517 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
518 p += wrap3;
519 lum += wrap;
520 YUVA_IN(y, u, v, a, p, pal);
521 u1 += u;
522 v1 += v;
523 a1 += a;
524 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
525 cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
526 cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
527 cb++;
528 cr++;
529 p += -wrap3 + BPP;
530 lum += -wrap + 1;
531 }
9cb5a11e 532 for(w = dstw - (dstx & 1); w >= 2; w -= 2) {
72ce053b
IC
533 YUVA_IN(y, u, v, a, p, pal);
534 u1 = u;
535 v1 = v;
536 a1 = a;
537 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
538
f8ca63e8 539 YUVA_IN(y, u, v, a, p + BPP, pal);
72ce053b
IC
540 u1 += u;
541 v1 += v;
542 a1 += a;
543 lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
544 p += wrap3;
545 lum += wrap;
546
547 YUVA_IN(y, u, v, a, p, pal);
548 u1 += u;
549 v1 += v;
550 a1 += a;
551 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
552
f8ca63e8 553 YUVA_IN(y, u, v, a, p + BPP, pal);
72ce053b
IC
554 u1 += u;
555 v1 += v;
556 a1 += a;
557 lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
558
559 cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 2);
560 cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 2);
561
562 cb++;
563 cr++;
564 p += -wrap3 + 2 * BPP;
565 lum += -wrap + 2;
566 }
567 if (w) {
568 YUVA_IN(y, u, v, a, p, pal);
569 u1 = u;
570 v1 = v;
571 a1 = a;
572 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
573 p += wrap3;
574 lum += wrap;
575 YUVA_IN(y, u, v, a, p, pal);
576 u1 += u;
577 v1 += v;
578 a1 += a;
579 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
580 cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
581 cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
582 cb++;
583 cr++;
584 p += -wrap3 + BPP;
585 lum += -wrap + 1;
586 }
9cb5a11e
RD
587 p += wrap3 + (wrap3 - dstw * BPP);
588 lum += wrap + (wrap - dstw - dstx);
72ce053b
IC
589 cb += dst->linesize[1] - width2 - skip2;
590 cr += dst->linesize[2] - width2 - skip2;
591 }
592 /* handle odd height */
593 if (h) {
9cb5a11e 594 lum += dstx;
72ce053b
IC
595 cb += skip2;
596 cr += skip2;
115329f1 597
9cb5a11e 598 if (dstx & 1) {
72ce053b
IC
599 YUVA_IN(y, u, v, a, p, pal);
600 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
601 cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
602 cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
603 cb++;
604 cr++;
605 lum++;
606 p += BPP;
607 }
9cb5a11e 608 for(w = dstw - (dstx & 1); w >= 2; w -= 2) {
72ce053b
IC
609 YUVA_IN(y, u, v, a, p, pal);
610 u1 = u;
611 v1 = v;
612 a1 = a;
613 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
614
615 YUVA_IN(y, u, v, a, p + BPP, pal);
616 u1 += u;
617 v1 += v;
618 a1 += a;
619 lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
620 cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u, 1);
621 cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v, 1);
622 cb++;
623 cr++;
624 p += 2 * BPP;
625 lum += 2;
626 }
627 if (w) {
628 YUVA_IN(y, u, v, a, p, pal);
629 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
630 cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
631 cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
632 }
633 }
634}
635
636static void free_subpicture(SubPicture *sp)
637{
638 int i;
115329f1 639
72ce053b
IC
640 for (i = 0; i < sp->sub.num_rects; i++)
641 {
25b4c651
MN
642 av_freep(&sp->sub.rects[i]->pict.data[0]);
643 av_freep(&sp->sub.rects[i]->pict.data[1]);
db4fac64 644 av_freep(&sp->sub.rects[i]);
72ce053b 645 }
115329f1 646
72ce053b 647 av_free(sp->sub.rects);
115329f1 648
72ce053b
IC
649 memset(&sp->sub, 0, sizeof(AVSubtitle));
650}
651
01310af2
FB
652static void video_image_display(VideoState *is)
653{
654 VideoPicture *vp;
72ce053b
IC
655 SubPicture *sp;
656 AVPicture pict;
01310af2
FB
657 float aspect_ratio;
658 int width, height, x, y;
659 SDL_Rect rect;
72ce053b 660 int i;
01310af2
FB
661
662 vp = &is->pictq[is->pictq_rindex];
663 if (vp->bmp) {
664 /* XXX: use variable in the frame */
c30a4489
AJ
665 if (is->video_st->sample_aspect_ratio.num)
666 aspect_ratio = av_q2d(is->video_st->sample_aspect_ratio);
667 else if (is->video_st->codec->sample_aspect_ratio.num)
668 aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio);
72ea344b 669 else
c30a4489 670 aspect_ratio = 0;
01310af2 671 if (aspect_ratio <= 0.0)
c30a4489
AJ
672 aspect_ratio = 1.0;
673 aspect_ratio *= (float)is->video_st->codec->width / is->video_st->codec->height;
01310af2
FB
674 /* if an active format is indicated, then it overrides the
675 mpeg format */
676#if 0
01f4895c
MN
677 if (is->video_st->codec->dtg_active_format != is->dtg_active_format) {
678 is->dtg_active_format = is->video_st->codec->dtg_active_format;
01310af2
FB
679 printf("dtg_active_format=%d\n", is->dtg_active_format);
680 }
681#endif
682#if 0
01f4895c 683 switch(is->video_st->codec->dtg_active_format) {
01310af2
FB
684 case FF_DTG_AFD_SAME:
685 default:
686 /* nothing to do */
687 break;
688 case FF_DTG_AFD_4_3:
689 aspect_ratio = 4.0 / 3.0;
690 break;
691 case FF_DTG_AFD_16_9:
692 aspect_ratio = 16.0 / 9.0;
693 break;
694 case FF_DTG_AFD_14_9:
695 aspect_ratio = 14.0 / 9.0;
696 break;
697 case FF_DTG_AFD_4_3_SP_14_9:
698 aspect_ratio = 14.0 / 9.0;
699 break;
700 case FF_DTG_AFD_16_9_SP_14_9:
701 aspect_ratio = 14.0 / 9.0;
702 break;
703 case FF_DTG_AFD_SP_4_3:
704 aspect_ratio = 4.0 / 3.0;
705 break;
706 }
707#endif
708
72ce053b
IC
709 if (is->subtitle_st)
710 {
711 if (is->subpq_size > 0)
712 {
713 sp = &is->subpq[is->subpq_rindex];
714
715 if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000))
716 {
717 SDL_LockYUVOverlay (vp->bmp);
718
719 pict.data[0] = vp->bmp->pixels[0];
720 pict.data[1] = vp->bmp->pixels[2];
721 pict.data[2] = vp->bmp->pixels[1];
722
723 pict.linesize[0] = vp->bmp->pitches[0];
724 pict.linesize[1] = vp->bmp->pitches[2];
725 pict.linesize[2] = vp->bmp->pitches[1];
726
727 for (i = 0; i < sp->sub.num_rects; i++)
db4fac64 728 blend_subrect(&pict, sp->sub.rects[i],
0a8cd696 729 vp->bmp->w, vp->bmp->h);
72ce053b
IC
730
731 SDL_UnlockYUVOverlay (vp->bmp);
732 }
733 }
734 }
735
736
01310af2
FB
737 /* XXX: we suppose the screen has a 1.0 pixel ratio */
738 height = is->height;
bb6c34e5 739 width = ((int)rint(height * aspect_ratio)) & ~1;
01310af2
FB
740 if (width > is->width) {
741 width = is->width;
bb6c34e5 742 height = ((int)rint(width / aspect_ratio)) & ~1;
01310af2
FB
743 }
744 x = (is->width - width) / 2;
745 y = (is->height - height) / 2;
746 if (!is->no_background) {
747 /* fill the background */
748 // fill_border(is, x, y, width, height, QERGB(0x00, 0x00, 0x00));
749 } else {
750 is->no_background = 0;
751 }
752 rect.x = is->xleft + x;
2f6547fb 753 rect.y = is->ytop + y;
01310af2
FB
754 rect.w = width;
755 rect.h = height;
756 SDL_DisplayYUVOverlay(vp->bmp, &rect);
757 } else {
758#if 0
115329f1
DB
759 fill_rectangle(screen,
760 is->xleft, is->ytop, is->width, is->height,
01310af2
FB
761 QERGB(0x00, 0x00, 0x00));
762#endif
763 }
764}
765
766static inline int compute_mod(int a, int b)
767{
768 a = a % b;
115329f1 769 if (a >= 0)
01310af2
FB
770 return a;
771 else
772 return a + b;
773}
774
775static void video_audio_display(VideoState *s)
776{
777 int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
778 int ch, channels, h, h2, bgcolor, fgcolor;
779 int16_t time_diff;
115329f1 780
01310af2 781 /* compute display index : center on currently output samples */
01f4895c 782 channels = s->audio_st->codec->channels;
01310af2 783 nb_display_channels = channels;
5e0257e3
FB
784 if (!s->paused) {
785 n = 2 * channels;
786 delay = audio_write_get_buf_size(s);
787 delay /= n;
115329f1 788
5e0257e3
FB
789 /* to be more precise, we take into account the time spent since
790 the last buffer computation */
791 if (audio_callback_time) {
792 time_diff = av_gettime() - audio_callback_time;
01f4895c 793 delay += (time_diff * s->audio_st->codec->sample_rate) / 1000000;
5e0257e3 794 }
115329f1 795
5e0257e3
FB
796 delay -= s->width / 2;
797 if (delay < s->width)
798 delay = s->width;
ac50bcc8
MN
799
800 i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
801
802 h= INT_MIN;
803 for(i=0; i<1000; i+=channels){
804 int idx= (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
805 int a= s->sample_array[idx];
806 int b= s->sample_array[(idx + 4*channels)%SAMPLE_ARRAY_SIZE];
807 int c= s->sample_array[(idx + 5*channels)%SAMPLE_ARRAY_SIZE];
808 int d= s->sample_array[(idx + 9*channels)%SAMPLE_ARRAY_SIZE];
809 int score= a-d;
810 if(h<score && (b^c)<0){
811 h= score;
812 i_start= idx;
813 }
814 }
815
5e0257e3
FB
816 s->last_i_start = i_start;
817 } else {
818 i_start = s->last_i_start;
01310af2
FB
819 }
820
01310af2 821 bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
115329f1
DB
822 fill_rectangle(screen,
823 s->xleft, s->ytop, s->width, s->height,
01310af2
FB
824 bgcolor);
825
826 fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);
827
828 /* total height for one channel */
829 h = s->height / nb_display_channels;
830 /* graph height / 2 */
831 h2 = (h * 9) / 20;
832 for(ch = 0;ch < nb_display_channels; ch++) {
833 i = i_start + ch;
834 y1 = s->ytop + ch * h + (h / 2); /* position of center line */
835 for(x = 0; x < s->width; x++) {
836 y = (s->sample_array[i] * h2) >> 15;
837 if (y < 0) {
838 y = -y;
839 ys = y1 - y;
840 } else {
841 ys = y1;
842 }
115329f1
DB
843 fill_rectangle(screen,
844 s->xleft + x, ys, 1, y,
01310af2
FB
845 fgcolor);
846 i += channels;
847 if (i >= SAMPLE_ARRAY_SIZE)
848 i -= SAMPLE_ARRAY_SIZE;
849 }
850 }
851
852 fgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff);
853
854 for(ch = 1;ch < nb_display_channels; ch++) {
855 y = s->ytop + ch * h;
115329f1
DB
856 fill_rectangle(screen,
857 s->xleft, y, s->width, 1,
01310af2
FB
858 fgcolor);
859 }
860 SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height);
861}
862
990c8438
MN
863static int video_open(VideoState *is){
864 int flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL;
865 int w,h;
866
fb84155b
MN
867 if(is_full_screen) flags |= SDL_FULLSCREEN;
868 else flags |= SDL_RESIZABLE;
869
990c8438
MN
870 if (is_full_screen && fs_screen_width) {
871 w = fs_screen_width;
872 h = fs_screen_height;
fb84155b
MN
873 } else if(!is_full_screen && screen_width){
874 w = screen_width;
875 h = screen_height;
876 }else if (is->video_st && is->video_st->codec->width){
877 w = is->video_st->codec->width;
878 h = is->video_st->codec->height;
990c8438 879 } else {
fb84155b
MN
880 w = 640;
881 h = 480;
990c8438 882 }
c97f5402 883#ifndef __APPLE__
990c8438
MN
884 screen = SDL_SetVideoMode(w, h, 0, flags);
885#else
886 /* setting bits_per_pixel = 0 or 32 causes blank video on OS X */
887 screen = SDL_SetVideoMode(w, h, 24, flags);
888#endif
889 if (!screen) {
890 fprintf(stderr, "SDL: could not set video mode - exiting\n");
891 return -1;
892 }
893 SDL_WM_SetCaption("FFplay", "FFplay");
894
895 is->width = screen->w;
896 is->height = screen->h;
897
898 return 0;
899}
8c982c5d 900
01310af2
FB
901/* display the current picture, if any */
902static void video_display(VideoState *is)
903{
8c982c5d
MN
904 if(!screen)
905 video_open(cur_stream);
115329f1 906 if (is->audio_st && is->show_audio)
01310af2
FB
907 video_audio_display(is);
908 else if (is->video_st)
909 video_image_display(is);
910}
911
912static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque)
913{
914 SDL_Event event;
915 event.type = FF_REFRESH_EVENT;
916 event.user.data1 = opaque;
917 SDL_PushEvent(&event);
918 return 0; /* 0 means stop timer */
919}
920
921/* schedule a video refresh in 'delay' ms */
922static void schedule_refresh(VideoState *is, int delay)
923{
cc1f91d7 924 if(!delay) delay=1; //SDL seems to be buggy when the delay is 0
01310af2
FB
925 SDL_AddTimer(delay, sdl_refresh_timer_cb, is);
926}
927
638c9d91
FB
928/* get the current audio clock value */
929static double get_audio_clock(VideoState *is)
930{
931 double pts;
932 int hw_buf_size, bytes_per_sec;
933 pts = is->audio_clock;
934 hw_buf_size = audio_write_get_buf_size(is);
935 bytes_per_sec = 0;
936 if (is->audio_st) {
115329f1 937 bytes_per_sec = is->audio_st->codec->sample_rate *
01f4895c 938 2 * is->audio_st->codec->channels;
638c9d91
FB
939 }
940 if (bytes_per_sec)
941 pts -= (double)hw_buf_size / bytes_per_sec;
942 return pts;
943}
944
945/* get the current video clock value */
946static double get_video_clock(VideoState *is)
947{
948 double delta;
04108619 949 if (is->paused) {
72ea344b
FB
950 delta = 0;
951 } else {
952 delta = (av_gettime() - is->video_current_pts_time) / 1000000.0;
953 }
638c9d91
FB
954 return is->video_current_pts + delta;
955}
956
957/* get the current external clock value */
958static double get_external_clock(VideoState *is)
959{
960 int64_t ti;
961 ti = av_gettime();
962 return is->external_clock + ((ti - is->external_clock_time) * 1e-6);
963}
964
965/* get the current master clock value */
966static double get_master_clock(VideoState *is)
967{
968 double val;
969
72ea344b
FB
970 if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
971 if (is->video_st)
972 val = get_video_clock(is);
973 else
974 val = get_audio_clock(is);
975 } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
976 if (is->audio_st)
977 val = get_audio_clock(is);
978 else
979 val = get_video_clock(is);
980 } else {
638c9d91 981 val = get_external_clock(is);
72ea344b 982 }
638c9d91
FB
983 return val;
984}
985
72ea344b 986/* seek in the stream */
3ba1438d 987static void stream_seek(VideoState *is, int64_t pos, int rel)
72ea344b 988{
687fae2b
IW
989 if (!is->seek_req) {
990 is->seek_pos = pos;
991 is->seek_flags = rel < 0 ? AVSEEK_FLAG_BACKWARD : 0;
94b594c6
SH
992 if (seek_by_bytes)
993 is->seek_flags |= AVSEEK_FLAG_BYTE;
687fae2b
IW
994 is->seek_req = 1;
995 }
72ea344b
FB
996}
997
998/* pause or resume the video */
999static void stream_pause(VideoState *is)
1000{
1001 is->paused = !is->paused;
917fa192 1002 if (!is->paused) {
72ea344b 1003 is->video_current_pts = get_video_clock(is);
917fa192 1004 is->frame_timer += (av_gettime() - is->video_current_pts_time) / 1000000.0;
72ea344b
FB
1005 }
1006}
1007
49410784
TB
1008static double compute_frame_delay(double frame_current_pts, VideoState *is)
1009{
1010 double actual_delay, delay, sync_threshold, ref_clock, diff;
1011
1012 /* compute nominal delay */
1013 delay = frame_current_pts - is->frame_last_pts;
1014 if (delay <= 0 || delay >= 10.0) {
1015 /* if incorrect delay, use previous one */
1016 delay = is->frame_last_delay;
443658fd 1017 } else {
712de377 1018 is->frame_last_delay = delay;
443658fd 1019 }
49410784
TB
1020 is->frame_last_pts = frame_current_pts;
1021
1022 /* update delay to follow master synchronisation source */
1023 if (((is->av_sync_type == AV_SYNC_AUDIO_MASTER && is->audio_st) ||
1024 is->av_sync_type == AV_SYNC_EXTERNAL_CLOCK)) {
1025 /* if video is slave, we try to correct big delays by
1026 duplicating or deleting a frame */
1027 ref_clock = get_master_clock(is);
1028 diff = frame_current_pts - ref_clock;
1029
1030 /* skip or repeat frame. We take into account the
1031 delay to compute the threshold. I still don't know
1032 if it is the best guess */
1033 sync_threshold = FFMAX(AV_SYNC_THRESHOLD, delay);
1034 if (fabs(diff) < AV_NOSYNC_THRESHOLD) {
1035 if (diff <= -sync_threshold)
1036 delay = 0;
1037 else if (diff >= sync_threshold)
1038 delay = 2 * delay;
1039 }
1040 }
1041
1042 is->frame_timer += delay;
1043 /* compute the REAL delay (we need to do that to avoid
1044 long term errors */
1045 actual_delay = is->frame_timer - (av_gettime() / 1000000.0);
1046 if (actual_delay < 0.010) {
1047 /* XXX: should skip picture */
1048 actual_delay = 0.010;
1049 }
1050
eecc17a7
TB
1051#if defined(DEBUG_SYNC)
1052 printf("video: delay=%0.3f actual_delay=%0.3f pts=%0.3f A-V=%f\n",
1053 delay, actual_delay, frame_current_pts, -diff);
1054#endif
1055
49410784
TB
1056 return actual_delay;
1057}
1058
01310af2
FB
1059/* called to display each frame */
1060static void video_refresh_timer(void *opaque)
1061{
1062 VideoState *is = opaque;
1063 VideoPicture *vp;
638c9d91 1064
72ce053b 1065 SubPicture *sp, *sp2;
01310af2
FB
1066
1067 if (is->video_st) {
1068 if (is->pictq_size == 0) {
1069 /* if no picture, need to wait */
7e0140cb 1070 schedule_refresh(is, 1);
01310af2 1071 } else {
638c9d91 1072 /* dequeue the picture */
01310af2 1073 vp = &is->pictq[is->pictq_rindex];
638c9d91
FB
1074
1075 /* update current video pts */
1076 is->video_current_pts = vp->pts;
1077 is->video_current_pts_time = av_gettime();
1078
01310af2 1079 /* launch timer for next picture */
49410784 1080 schedule_refresh(is, (int)(compute_frame_delay(vp->pts, is) * 1000 + 0.5));
638c9d91 1081
72ce053b
IC
1082 if(is->subtitle_st) {
1083 if (is->subtitle_stream_changed) {
1084 SDL_LockMutex(is->subpq_mutex);
115329f1 1085
72ce053b
IC
1086 while (is->subpq_size) {
1087 free_subpicture(&is->subpq[is->subpq_rindex]);
115329f1 1088
72ce053b
IC
1089 /* update queue size and signal for next picture */
1090 if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
1091 is->subpq_rindex = 0;
115329f1 1092
72ce053b
IC
1093 is->subpq_size--;
1094 }
1095 is->subtitle_stream_changed = 0;
1096
1097 SDL_CondSignal(is->subpq_cond);
1098 SDL_UnlockMutex(is->subpq_mutex);
1099 } else {
1100 if (is->subpq_size > 0) {
1101 sp = &is->subpq[is->subpq_rindex];
1102
1103 if (is->subpq_size > 1)
1104 sp2 = &is->subpq[(is->subpq_rindex + 1) % SUBPICTURE_QUEUE_SIZE];
1105 else
1106 sp2 = NULL;
1107
1108 if ((is->video_current_pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1109 || (sp2 && is->video_current_pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1110 {
1111 free_subpicture(sp);
1112
1113 /* update queue size and signal for next picture */
1114 if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
1115 is->subpq_rindex = 0;
1116
1117 SDL_LockMutex(is->subpq_mutex);
1118 is->subpq_size--;
1119 SDL_CondSignal(is->subpq_cond);
1120 SDL_UnlockMutex(is->subpq_mutex);
1121 }
1122 }
1123 }
1124 }
1125
01310af2
FB
1126 /* display picture */
1127 video_display(is);
115329f1 1128
01310af2
FB
1129 /* update queue size and signal for next picture */
1130 if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE)
1131 is->pictq_rindex = 0;
115329f1 1132
01310af2
FB
1133 SDL_LockMutex(is->pictq_mutex);
1134 is->pictq_size--;
1135 SDL_CondSignal(is->pictq_cond);
1136 SDL_UnlockMutex(is->pictq_mutex);
1137 }
1138 } else if (is->audio_st) {
1139 /* draw the next audio frame */
1140
1141 schedule_refresh(is, 40);
1142
1143 /* if only audio stream, then display the audio bars (better
1144 than nothing, just to test the implementation */
115329f1 1145
01310af2
FB
1146 /* display picture */
1147 video_display(is);
1148 } else {
1149 schedule_refresh(is, 100);
1150 }
1151 if (show_status) {
1152 static int64_t last_time;
1153 int64_t cur_time;
72ce053b 1154 int aqsize, vqsize, sqsize;
638c9d91 1155 double av_diff;
115329f1 1156
01310af2
FB
1157 cur_time = av_gettime();
1158 if (!last_time || (cur_time - last_time) >= 500 * 1000) {
1159 aqsize = 0;
1160 vqsize = 0;
72ce053b 1161 sqsize = 0;
01310af2
FB
1162 if (is->audio_st)
1163 aqsize = is->audioq.size;
1164 if (is->video_st)
1165 vqsize = is->videoq.size;
72ce053b
IC
1166 if (is->subtitle_st)
1167 sqsize = is->subtitleq.size;
638c9d91
FB
1168 av_diff = 0;
1169 if (is->audio_st && is->video_st)
1170 av_diff = get_audio_clock(is) - get_video_clock(is);
115329f1 1171 printf("%7.2f A-V:%7.3f aq=%5dKB vq=%5dKB sq=%5dB \r",
72ce053b 1172 get_master_clock(is), av_diff, aqsize / 1024, vqsize / 1024, sqsize);
01310af2
FB
1173 fflush(stdout);
1174 last_time = cur_time;
1175 }
1176 }
1177}
1178
1179/* allocate a picture (needs to do that in main thread to avoid
1180 potential locking problems */
1181static void alloc_picture(void *opaque)
1182{
1183 VideoState *is = opaque;
1184 VideoPicture *vp;
01310af2
FB
1185
1186 vp = &is->pictq[is->pictq_windex];
1187
1188 if (vp->bmp)
1189 SDL_FreeYUVOverlay(vp->bmp);
1190
61890b02 1191#if 0
01310af2 1192 /* XXX: use generic function */
61890b02 1193 /* XXX: disable overlay if no hardware acceleration or if RGB format */
01f4895c 1194 switch(is->video_st->codec->pix_fmt) {
01310af2
FB
1195 case PIX_FMT_YUV420P:
1196 case PIX_FMT_YUV422P:
1197 case PIX_FMT_YUV444P:
71e445fc 1198 case PIX_FMT_YUYV422:
01310af2
FB
1199 case PIX_FMT_YUV410P:
1200 case PIX_FMT_YUV411P:
1201 is_yuv = 1;
1202 break;
1203 default:
1204 is_yuv = 0;
1205 break;
1206 }
01310af2 1207#endif
01f4895c
MN
1208 vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec->width,
1209 is->video_st->codec->height,
115329f1 1210 SDL_YV12_OVERLAY,
61890b02 1211 screen);
01f4895c
MN
1212 vp->width = is->video_st->codec->width;
1213 vp->height = is->video_st->codec->height;
01310af2
FB
1214
1215 SDL_LockMutex(is->pictq_mutex);
1216 vp->allocated = 1;
1217 SDL_CondSignal(is->pictq_cond);
1218 SDL_UnlockMutex(is->pictq_mutex);
1219}
1220
267e9dfa
MN
1221/**
1222 *
1223 * @param pts the dts of the pkt / pts of the frame and guessed if not known
1224 */
638c9d91 1225static int queue_picture(VideoState *is, AVFrame *src_frame, double pts)
01310af2
FB
1226{
1227 VideoPicture *vp;
1228 int dst_pix_fmt;
1229 AVPicture pict;
03ae87a3 1230 static struct SwsContext *img_convert_ctx;
115329f1 1231
01310af2
FB
1232 /* wait until we have space to put a new picture */
1233 SDL_LockMutex(is->pictq_mutex);
1234 while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE &&
1235 !is->videoq.abort_request) {
1236 SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1237 }
1238 SDL_UnlockMutex(is->pictq_mutex);
115329f1 1239
01310af2
FB
1240 if (is->videoq.abort_request)
1241 return -1;
1242
1243 vp = &is->pictq[is->pictq_windex];
1244
1245 /* alloc or resize hardware picture buffer */
115329f1 1246 if (!vp->bmp ||
01f4895c
MN
1247 vp->width != is->video_st->codec->width ||
1248 vp->height != is->video_st->codec->height) {
01310af2
FB
1249 SDL_Event event;
1250
1251 vp->allocated = 0;
1252
1253 /* the allocation must be done in the main thread to avoid
1254 locking problems */
1255 event.type = FF_ALLOC_EVENT;
1256 event.user.data1 = is;
1257 SDL_PushEvent(&event);
115329f1 1258
01310af2
FB
1259 /* wait until the picture is allocated */
1260 SDL_LockMutex(is->pictq_mutex);
1261 while (!vp->allocated && !is->videoq.abort_request) {
1262 SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1263 }
1264 SDL_UnlockMutex(is->pictq_mutex);
1265
1266 if (is->videoq.abort_request)
1267 return -1;
1268 }
1269
638c9d91 1270 /* if the frame is not skipped, then display it */
01310af2
FB
1271 if (vp->bmp) {
1272 /* get a pointer on the bitmap */
1273 SDL_LockYUVOverlay (vp->bmp);
1274
1275 dst_pix_fmt = PIX_FMT_YUV420P;
1276 pict.data[0] = vp->bmp->pixels[0];
1277 pict.data[1] = vp->bmp->pixels[2];
1278 pict.data[2] = vp->bmp->pixels[1];
1279
1280 pict.linesize[0] = vp->bmp->pitches[0];
1281 pict.linesize[1] = vp->bmp->pitches[2];
1282 pict.linesize[2] = vp->bmp->pitches[1];
e43d7a18 1283 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
feb7bc67
AB
1284 img_convert_ctx = sws_getCachedContext(img_convert_ctx,
1285 is->video_st->codec->width, is->video_st->codec->height,
1286 is->video_st->codec->pix_fmt,
1287 is->video_st->codec->width, is->video_st->codec->height,
1288 dst_pix_fmt, sws_flags, NULL, NULL, NULL);
26ba8235
AB
1289 if (img_convert_ctx == NULL) {
1290 fprintf(stderr, "Cannot initialize the conversion context\n");
1291 exit(1);
1292 }
03ae87a3
LA
1293 sws_scale(img_convert_ctx, src_frame->data, src_frame->linesize,
1294 0, is->video_st->codec->height, pict.data, pict.linesize);
01310af2
FB
1295 /* update the bitmap content */
1296 SDL_UnlockYUVOverlay(vp->bmp);
1297
638c9d91 1298 vp->pts = pts;
01310af2
FB
1299
1300 /* now we can update the picture count */
1301 if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE)
1302 is->pictq_windex = 0;
1303 SDL_LockMutex(is->pictq_mutex);
1304 is->pictq_size++;
1305 SDL_UnlockMutex(is->pictq_mutex);
1306 }
638c9d91
FB
1307 return 0;
1308}
1309
115329f1
DB
1310/**
1311 * compute the exact PTS for the picture if it is omitted in the stream
267e9dfa
MN
1312 * @param pts1 the dts of the pkt / pts of the frame
1313 */
638c9d91
FB
1314static int output_picture2(VideoState *is, AVFrame *src_frame, double pts1)
1315{
1316 double frame_delay, pts;
115329f1 1317
638c9d91
FB
1318 pts = pts1;
1319
01310af2 1320 if (pts != 0) {
638c9d91 1321 /* update video clock with pts, if present */
01310af2
FB
1322 is->video_clock = pts;
1323 } else {
72ea344b
FB
1324 pts = is->video_clock;
1325 }
1326 /* update video clock for next frame */
01f4895c 1327 frame_delay = av_q2d(is->video_st->codec->time_base);
72ea344b
FB
1328 /* for MPEG2, the frame can be repeated, so we update the
1329 clock accordingly */
267e9dfa 1330 frame_delay += src_frame->repeat_pict * (frame_delay * 0.5);
72ea344b 1331 is->video_clock += frame_delay;
638c9d91
FB
1332
1333#if defined(DEBUG_SYNC) && 0
1334 {
1335 int ftype;
1336 if (src_frame->pict_type == FF_B_TYPE)
1337 ftype = 'B';
1338 else if (src_frame->pict_type == FF_I_TYPE)
1339 ftype = 'I';
1340 else
1341 ftype = 'P';
115329f1 1342 printf("frame_type=%c clock=%0.3f pts=%0.3f\n",
72ea344b 1343 ftype, pts, pts1);
638c9d91
FB
1344 }
1345#endif
72ea344b 1346 return queue_picture(is, src_frame, pts);
01310af2
FB
1347}
1348
1349static int video_thread(void *arg)
1350{
1351 VideoState *is = arg;
1352 AVPacket pkt1, *pkt = &pkt1;
72ea344b 1353 int len1, got_picture;
c6b1edc9 1354 AVFrame *frame= avcodec_alloc_frame();
01310af2
FB
1355 double pts;
1356
1357 for(;;) {
1358 while (is->paused && !is->videoq.abort_request) {
1359 SDL_Delay(10);
1360 }
1361 if (packet_queue_get(&is->videoq, pkt, 1) < 0)
1362 break;
39c6a118
MN
1363
1364 if(pkt->data == flush_pkt.data){
1365 avcodec_flush_buffers(is->video_st->codec);
1366 continue;
1367 }
1368
638c9d91
FB
1369 /* NOTE: ipts is the PTS of the _first_ picture beginning in
1370 this packet, if any */
7fb262b5 1371 is->video_st->codec->reordered_opaque= pkt->pts;
620e8baf
MN
1372 len1 = avcodec_decode_video(is->video_st->codec,
1373 frame, &got_picture,
1374 pkt->data, pkt->size);
1375
1376 if( (decoder_reorder_pts || pkt->dts == AV_NOPTS_VALUE)
7fb262b5
MN
1377 && frame->reordered_opaque != AV_NOPTS_VALUE)
1378 pts= frame->reordered_opaque;
620e8baf
MN
1379 else if(pkt->dts != AV_NOPTS_VALUE)
1380 pts= pkt->dts;
1381 else
1382 pts= 0;
1383 pts *= av_q2d(is->video_st->time_base);
5039185a 1384
fb966f99
MN
1385// if (len1 < 0)
1386// break;
620e8baf
MN
1387 if (got_picture) {
1388 if (output_picture2(is, frame, pts) < 0)
1389 goto the_end;
1390 }
01310af2 1391 av_free_packet(pkt);
115329f1 1392 if (step)
bba04f1e
WH
1393 if (cur_stream)
1394 stream_pause(cur_stream);
01310af2
FB
1395 }
1396 the_end:
c6b1edc9 1397 av_free(frame);
01310af2
FB
1398 return 0;
1399}
1400
72ce053b
IC
1401static int subtitle_thread(void *arg)
1402{
1403 VideoState *is = arg;
1404 SubPicture *sp;
1405 AVPacket pkt1, *pkt = &pkt1;
1406 int len1, got_subtitle;
1407 double pts;
1408 int i, j;
1409 int r, g, b, y, u, v, a;
1410
1411 for(;;) {
1412 while (is->paused && !is->subtitleq.abort_request) {
1413 SDL_Delay(10);
1414 }
1415 if (packet_queue_get(&is->subtitleq, pkt, 1) < 0)
1416 break;
115329f1 1417
39c6a118
MN
1418 if(pkt->data == flush_pkt.data){
1419 avcodec_flush_buffers(is->subtitle_st->codec);
1420 continue;
1421 }
72ce053b
IC
1422 SDL_LockMutex(is->subpq_mutex);
1423 while (is->subpq_size >= SUBPICTURE_QUEUE_SIZE &&
1424 !is->subtitleq.abort_request) {
1425 SDL_CondWait(is->subpq_cond, is->subpq_mutex);
1426 }
1427 SDL_UnlockMutex(is->subpq_mutex);
115329f1 1428
72ce053b
IC
1429 if (is->subtitleq.abort_request)
1430 goto the_end;
115329f1 1431
72ce053b
IC
1432 sp = &is->subpq[is->subpq_windex];
1433
1434 /* NOTE: ipts is the PTS of the _first_ picture beginning in
1435 this packet, if any */
1436 pts = 0;
1437 if (pkt->pts != AV_NOPTS_VALUE)
1438 pts = av_q2d(is->subtitle_st->time_base)*pkt->pts;
1439
115329f1
DB
1440 len1 = avcodec_decode_subtitle(is->subtitle_st->codec,
1441 &sp->sub, &got_subtitle,
72ce053b 1442 pkt->data, pkt->size);
72ce053b
IC
1443// if (len1 < 0)
1444// break;
1445 if (got_subtitle && sp->sub.format == 0) {
1446 sp->pts = pts;
115329f1 1447
72ce053b
IC
1448 for (i = 0; i < sp->sub.num_rects; i++)
1449 {
db4fac64 1450 for (j = 0; j < sp->sub.rects[i]->nb_colors; j++)
72ce053b 1451 {
25b4c651 1452 RGBA_IN(r, g, b, a, (uint32_t*)sp->sub.rects[i]->pict.data[1] + j);
72ce053b
IC
1453 y = RGB_TO_Y_CCIR(r, g, b);
1454 u = RGB_TO_U_CCIR(r, g, b, 0);
1455 v = RGB_TO_V_CCIR(r, g, b, 0);
25b4c651 1456 YUVA_OUT((uint32_t*)sp->sub.rects[i]->pict.data[1] + j, y, u, v, a);
72ce053b
IC
1457 }
1458 }
1459
1460 /* now we can update the picture count */
1461 if (++is->subpq_windex == SUBPICTURE_QUEUE_SIZE)
1462 is->subpq_windex = 0;
1463 SDL_LockMutex(is->subpq_mutex);
1464 is->subpq_size++;
1465 SDL_UnlockMutex(is->subpq_mutex);
1466 }
1467 av_free_packet(pkt);
115329f1 1468// if (step)
72ce053b
IC
1469// if (cur_stream)
1470// stream_pause(cur_stream);
1471 }
1472 the_end:
1473 return 0;
1474}
1475
01310af2
FB
1476/* copy samples for viewing in editor window */
1477static void update_sample_display(VideoState *is, short *samples, int samples_size)
1478{
1479 int size, len, channels;
1480
01f4895c 1481 channels = is->audio_st->codec->channels;
01310af2
FB
1482
1483 size = samples_size / sizeof(short);
1484 while (size > 0) {
1485 len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
1486 if (len > size)
1487 len = size;
1488 memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
1489 samples += len;
1490 is->sample_array_index += len;
1491 if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
1492 is->sample_array_index = 0;
1493 size -= len;
1494 }
1495}
1496
01310af2
FB
1497/* return the new audio buffer size (samples can be added or deleted
1498 to get better sync if video or external master clock) */
115329f1 1499static int synchronize_audio(VideoState *is, short *samples,
638c9d91 1500 int samples_size1, double pts)
01310af2 1501{
638c9d91 1502 int n, samples_size;
01310af2 1503 double ref_clock;
115329f1 1504
01f4895c 1505 n = 2 * is->audio_st->codec->channels;
638c9d91 1506 samples_size = samples_size1;
01310af2 1507
01310af2 1508 /* if not master, then we try to remove or add samples to correct the clock */
01310af2 1509 if (((is->av_sync_type == AV_SYNC_VIDEO_MASTER && is->video_st) ||
638c9d91
FB
1510 is->av_sync_type == AV_SYNC_EXTERNAL_CLOCK)) {
1511 double diff, avg_diff;
01310af2 1512 int wanted_size, min_size, max_size, nb_samples;
115329f1 1513
638c9d91
FB
1514 ref_clock = get_master_clock(is);
1515 diff = get_audio_clock(is) - ref_clock;
115329f1 1516
638c9d91
FB
1517 if (diff < AV_NOSYNC_THRESHOLD) {
1518 is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
1519 if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
1520 /* not enough measures to have a correct estimate */
1521 is->audio_diff_avg_count++;
1522 } else {
1523 /* estimate the A-V difference */
1524 avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
1525
1526 if (fabs(avg_diff) >= is->audio_diff_threshold) {
01f4895c 1527 wanted_size = samples_size + ((int)(diff * is->audio_st->codec->sample_rate) * n);
638c9d91 1528 nb_samples = samples_size / n;
115329f1 1529
638c9d91
FB
1530 min_size = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX)) / 100) * n;
1531 max_size = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX)) / 100) * n;
1532 if (wanted_size < min_size)
1533 wanted_size = min_size;
1534 else if (wanted_size > max_size)
1535 wanted_size = max_size;
115329f1 1536
638c9d91
FB
1537 /* add or remove samples to correction the synchro */
1538 if (wanted_size < samples_size) {
1539 /* remove samples */
1540 samples_size = wanted_size;
1541 } else if (wanted_size > samples_size) {
1542 uint8_t *samples_end, *q;
1543 int nb;
115329f1 1544
638c9d91
FB
1545 /* add samples */
1546 nb = (samples_size - wanted_size);
1547 samples_end = (uint8_t *)samples + samples_size - n;
1548 q = samples_end + n;
1549 while (nb > 0) {
1550 memcpy(q, samples_end, n);
1551 q += n;
1552 nb -= n;
1553 }
1554 samples_size = wanted_size;
1555 }
1556 }
1557#if 0
115329f1
DB
1558 printf("diff=%f adiff=%f sample_diff=%d apts=%0.3f vpts=%0.3f %f\n",
1559 diff, avg_diff, samples_size - samples_size1,
638c9d91
FB
1560 is->audio_clock, is->video_clock, is->audio_diff_threshold);
1561#endif
01310af2 1562 }
638c9d91
FB
1563 } else {
1564 /* too big difference : may be initial PTS errors, so
1565 reset A-V filter */
1566 is->audio_diff_avg_count = 0;
1567 is->audio_diff_cum = 0;
01310af2
FB
1568 }
1569 }
1570
01310af2
FB
1571 return samples_size;
1572}
1573
1574/* decode one audio frame and returns its uncompressed size */
5a4476e2 1575static int audio_decode_frame(VideoState *is, double *pts_ptr)
01310af2
FB
1576{
1577 AVPacket *pkt = &is->audio_pkt;
abdff646 1578 AVCodecContext *dec= is->audio_st->codec;
72ea344b 1579 int n, len1, data_size;
01310af2
FB
1580 double pts;
1581
1582 for(;;) {
72ea344b 1583 /* NOTE: the audio packet can contain several frames */
01310af2 1584 while (is->audio_pkt_size > 0) {
5a4476e2 1585 data_size = sizeof(is->audio_buf1);
abdff646 1586 len1 = avcodec_decode_audio2(dec,
5a4476e2 1587 (int16_t *)is->audio_buf1, &data_size,
01310af2 1588 is->audio_pkt_data, is->audio_pkt_size);
72ea344b
FB
1589 if (len1 < 0) {
1590 /* if error, we skip the frame */
1591 is->audio_pkt_size = 0;
01310af2 1592 break;
72ea344b 1593 }
115329f1 1594
01310af2
FB
1595 is->audio_pkt_data += len1;
1596 is->audio_pkt_size -= len1;
72ea344b
FB
1597 if (data_size <= 0)
1598 continue;
5a4476e2
PR
1599
1600 if (dec->sample_fmt != is->audio_src_fmt) {
1601 if (is->reformat_ctx)
1602 av_audio_convert_free(is->reformat_ctx);
1603 is->reformat_ctx= av_audio_convert_alloc(SAMPLE_FMT_S16, 1,
1604 dec->sample_fmt, 1, NULL, 0);
1605 if (!is->reformat_ctx) {
1606 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
1607 avcodec_get_sample_fmt_name(dec->sample_fmt),
1608 avcodec_get_sample_fmt_name(SAMPLE_FMT_S16));
1609 break;
1610 }
1611 is->audio_src_fmt= dec->sample_fmt;
1612 }
1613
1614 if (is->reformat_ctx) {
1615 const void *ibuf[6]= {is->audio_buf1};
1616 void *obuf[6]= {is->audio_buf2};
1617 int istride[6]= {av_get_bits_per_sample_format(dec->sample_fmt)/8};
1618 int ostride[6]= {2};
1619 int len= data_size/istride[0];
1620 if (av_audio_convert(is->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
1621 printf("av_audio_convert() failed\n");
1622 break;
1623 }
1624 is->audio_buf= is->audio_buf2;
1625 /* FIXME: existing code assume that data_size equals framesize*channels*2
1626 remove this legacy cruft */
1627 data_size= len*2;
1628 }else{
1629 is->audio_buf= is->audio_buf1;
1630 }
1631
72ea344b
FB
1632 /* if no pts, then compute it */
1633 pts = is->audio_clock;
1634 *pts_ptr = pts;
abdff646 1635 n = 2 * dec->channels;
115329f1 1636 is->audio_clock += (double)data_size /
abdff646 1637 (double)(n * dec->sample_rate);
638c9d91 1638#if defined(DEBUG_SYNC)
72ea344b
FB
1639 {
1640 static double last_clock;
1641 printf("audio: delay=%0.3f clock=%0.3f pts=%0.3f\n",
1642 is->audio_clock - last_clock,
1643 is->audio_clock, pts);
1644 last_clock = is->audio_clock;
01310af2 1645 }
72ea344b
FB
1646#endif
1647 return data_size;
01310af2
FB
1648 }
1649
72ea344b
FB
1650 /* free the current packet */
1651 if (pkt->data)
01310af2 1652 av_free_packet(pkt);
115329f1 1653
72ea344b
FB
1654 if (is->paused || is->audioq.abort_request) {
1655 return -1;
1656 }
115329f1 1657
01310af2
FB
1658 /* read next packet */
1659 if (packet_queue_get(&is->audioq, pkt, 1) < 0)
1660 return -1;
39c6a118 1661 if(pkt->data == flush_pkt.data){
abdff646 1662 avcodec_flush_buffers(dec);
39c6a118
MN
1663 continue;
1664 }
1665
01310af2
FB
1666 is->audio_pkt_data = pkt->data;
1667 is->audio_pkt_size = pkt->size;
115329f1 1668
72ea344b
FB
1669 /* if update the audio clock with the pts */
1670 if (pkt->pts != AV_NOPTS_VALUE) {
c0df9d75 1671 is->audio_clock = av_q2d(is->audio_st->time_base)*pkt->pts;
72ea344b 1672 }
01310af2
FB
1673 }
1674}
1675
638c9d91
FB
1676/* get the current audio output buffer size, in samples. With SDL, we
1677 cannot have a precise information */
1678static int audio_write_get_buf_size(VideoState *is)
01310af2 1679{
b09b580b 1680 return is->audio_buf_size - is->audio_buf_index;
01310af2
FB
1681}
1682
1683
1684/* prepare a new audio buffer */
358061f6 1685static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
01310af2
FB
1686{
1687 VideoState *is = opaque;
1688 int audio_size, len1;
1689 double pts;
1690
1691 audio_callback_time = av_gettime();
115329f1 1692
01310af2
FB
1693 while (len > 0) {
1694 if (is->audio_buf_index >= is->audio_buf_size) {
5a4476e2 1695 audio_size = audio_decode_frame(is, &pts);
01310af2
FB
1696 if (audio_size < 0) {
1697 /* if error, just output silence */
1a1078fa 1698 is->audio_buf = is->audio_buf1;
01310af2
FB
1699 is->audio_buf_size = 1024;
1700 memset(is->audio_buf, 0, is->audio_buf_size);
1701 } else {
1702 if (is->show_audio)
1703 update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
115329f1 1704 audio_size = synchronize_audio(is, (int16_t *)is->audio_buf, audio_size,
01310af2
FB
1705 pts);
1706 is->audio_buf_size = audio_size;
1707 }
1708 is->audio_buf_index = 0;
1709 }
1710 len1 = is->audio_buf_size - is->audio_buf_index;
1711 if (len1 > len)
1712 len1 = len;
1713 memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
1714 len -= len1;
1715 stream += len1;
1716 is->audio_buf_index += len1;
1717 }
1718}
1719
01310af2
FB
1720/* open a given stream. Return 0 if OK */
1721static int stream_component_open(VideoState *is, int stream_index)
1722{
1723 AVFormatContext *ic = is->ic;
1724 AVCodecContext *enc;
1725 AVCodec *codec;
1726 SDL_AudioSpec wanted_spec, spec;
1727
1728 if (stream_index < 0 || stream_index >= ic->nb_streams)
1729 return -1;
01f4895c 1730 enc = ic->streams[stream_index]->codec;
115329f1 1731
01310af2
FB
1732 /* prepare audio output */
1733 if (enc->codec_type == CODEC_TYPE_AUDIO) {
51b73087
JR
1734 if (enc->channels > 0) {
1735 enc->request_channels = FFMIN(2, enc->channels);
94eadc8b 1736 } else {
51b73087 1737 enc->request_channels = 2;
638c9d91 1738 }
01310af2
FB
1739 }
1740
1741 codec = avcodec_find_decoder(enc->codec_id);
13d1512c
MN
1742 enc->debug_mv = debug_mv;
1743 enc->debug = debug;
6387c3e6 1744 enc->workaround_bugs = workaround_bugs;
178fcca8 1745 enc->lowres = lowres;
61846e9a 1746 if(lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
178fcca8 1747 enc->idct_algo= idct;
6fc5b059 1748 if(fast) enc->flags2 |= CODEC_FLAG2_FAST;
8c3eba7c
MN
1749 enc->skip_frame= skip_frame;
1750 enc->skip_idct= skip_idct;
1751 enc->skip_loop_filter= skip_loop_filter;
047599a4 1752 enc->error_recognition= error_recognition;
1b51e051 1753 enc->error_concealment= error_concealment;
e43d7a18 1754
636f1c4c 1755 set_context_opts(enc, avcodec_opts[enc->codec_type], 0);
e43d7a18 1756
01310af2
FB
1757 if (!codec ||
1758 avcodec_open(enc, codec) < 0)
1759 return -1;
51b73087
JR
1760
1761 /* prepare audio output */
1762 if (enc->codec_type == CODEC_TYPE_AUDIO) {
1763 wanted_spec.freq = enc->sample_rate;
1764 wanted_spec.format = AUDIO_S16SYS;
1765 wanted_spec.channels = enc->channels;
1766 wanted_spec.silence = 0;
1767 wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
1768 wanted_spec.callback = sdl_audio_callback;
1769 wanted_spec.userdata = is;
1770 if (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
1771 fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
1772 return -1;
1773 }
1774 is->audio_hw_buf_size = spec.size;
5a4476e2 1775 is->audio_src_fmt= SAMPLE_FMT_S16;
51b73087
JR
1776 }
1777
c62c07d3
MN
1778 if(thread_count>1)
1779 avcodec_thread_init(enc, thread_count);
c62c07d3 1780 enc->thread_count= thread_count;
3f3fe38d 1781 ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
638c9d91 1782 switch(enc->codec_type) {
01310af2
FB
1783 case CODEC_TYPE_AUDIO:
1784 is->audio_stream = stream_index;
1785 is->audio_st = ic->streams[stream_index];
1786 is->audio_buf_size = 0;
1787 is->audio_buf_index = 0;
638c9d91
FB
1788
1789 /* init averaging filter */
1790 is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
1791 is->audio_diff_avg_count = 0;
1792 /* since we do not have a precise anough audio fifo fullness,
1793 we correct audio sync only if larger than this threshold */
1794 is->audio_diff_threshold = 2.0 * SDL_AUDIO_BUFFER_SIZE / enc->sample_rate;
1795
01310af2
FB
1796 memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
1797 packet_queue_init(&is->audioq);
bb270c08 1798 SDL_PauseAudio(0);
01310af2
FB
1799 break;
1800 case CODEC_TYPE_VIDEO:
1801 is->video_stream = stream_index;
1802 is->video_st = ic->streams[stream_index];
1803
638c9d91
FB
1804 is->frame_last_delay = 40e-3;
1805 is->frame_timer = (double)av_gettime() / 1000000.0;
638c9d91
FB
1806 is->video_current_pts_time = av_gettime();
1807
01310af2
FB
1808 packet_queue_init(&is->videoq);
1809 is->video_tid = SDL_CreateThread(video_thread, is);
1810 break;
72ce053b
IC
1811 case CODEC_TYPE_SUBTITLE:
1812 is->subtitle_stream = stream_index;
1813 is->subtitle_st = ic->streams[stream_index];
1814 packet_queue_init(&is->subtitleq);
115329f1 1815
72ce053b
IC
1816 is->subtitle_tid = SDL_CreateThread(subtitle_thread, is);
1817 break;
01310af2
FB
1818 default:
1819 break;
1820 }
1821 return 0;
1822}
1823
1824static void stream_component_close(VideoState *is, int stream_index)
1825{
1826 AVFormatContext *ic = is->ic;
1827 AVCodecContext *enc;
115329f1 1828
72ce053b
IC
1829 if (stream_index < 0 || stream_index >= ic->nb_streams)
1830 return;
01f4895c 1831 enc = ic->streams[stream_index]->codec;
01310af2
FB
1832
1833 switch(enc->codec_type) {
1834 case CODEC_TYPE_AUDIO:
1835 packet_queue_abort(&is->audioq);
1836
1837 SDL_CloseAudio();
1838
1839 packet_queue_end(&is->audioq);
5a4476e2
PR
1840 if (is->reformat_ctx)
1841 av_audio_convert_free(is->reformat_ctx);
01310af2
FB
1842 break;
1843 case CODEC_TYPE_VIDEO:
1844 packet_queue_abort(&is->videoq);
1845
1846 /* note: we also signal this mutex to make sure we deblock the
1847 video thread in all cases */
1848 SDL_LockMutex(is->pictq_mutex);
1849 SDL_CondSignal(is->pictq_cond);
1850 SDL_UnlockMutex(is->pictq_mutex);
1851
1852 SDL_WaitThread(is->video_tid, NULL);
1853
1854 packet_queue_end(&is->videoq);
1855 break;
72ce053b
IC
1856 case CODEC_TYPE_SUBTITLE:
1857 packet_queue_abort(&is->subtitleq);
115329f1 1858
72ce053b
IC
1859 /* note: we also signal this mutex to make sure we deblock the
1860 video thread in all cases */
1861 SDL_LockMutex(is->subpq_mutex);
1862 is->subtitle_stream_changed = 1;
115329f1 1863
72ce053b
IC
1864 SDL_CondSignal(is->subpq_cond);
1865 SDL_UnlockMutex(is->subpq_mutex);
1866
1867 SDL_WaitThread(is->subtitle_tid, NULL);
1868
1869 packet_queue_end(&is->subtitleq);
1870 break;
01310af2
FB
1871 default:
1872 break;
1873 }
1874
3f3fe38d 1875 ic->streams[stream_index]->discard = AVDISCARD_ALL;
01310af2
FB
1876 avcodec_close(enc);
1877 switch(enc->codec_type) {
1878 case CODEC_TYPE_AUDIO:
1879 is->audio_st = NULL;
1880 is->audio_stream = -1;
1881 break;
1882 case CODEC_TYPE_VIDEO:
1883 is->video_st = NULL;
1884 is->video_stream = -1;
1885 break;
72ce053b
IC
1886 case CODEC_TYPE_SUBTITLE:
1887 is->subtitle_st = NULL;
1888 is->subtitle_stream = -1;
1889 break;
01310af2
FB
1890 default:
1891 break;
1892 }
1893}
1894
7b49ce2e 1895static void dump_stream_info(const AVFormatContext *s)
d0526ecf 1896{
f7554a99
AJ
1897 AVMetadataTag *tag = NULL;
1898 while ((tag=av_metadata_get(s->metadata,"",tag,AV_METADATA_IGNORE_SUFFIX)))
1899 fprintf(stderr, "%s: %s\n", tag->key, tag->value);
d0526ecf
FB
1900}
1901
416e3508
FB
1902/* since we have only one decoding thread, we can use a global
1903 variable instead of a thread local variable */
1904static VideoState *global_video_state;
1905
1906static int decode_interrupt_cb(void)
1907{
1908 return (global_video_state && global_video_state->abort_request);
1909}
01310af2
FB
1910
1911/* this thread gets the stream from the disk or the network */
1912static int decode_thread(void *arg)
1913{
1914 VideoState *is = arg;
1915 AVFormatContext *ic;
16a59a7b 1916 int err, i, ret, video_index, audio_index, subtitle_index;
01310af2 1917 AVPacket pkt1, *pkt = &pkt1;
61890b02 1918 AVFormatParameters params, *ap = &params;
01310af2
FB
1919
1920 video_index = -1;
1921 audio_index = -1;
16a59a7b 1922 subtitle_index = -1;
01310af2
FB
1923 is->video_stream = -1;
1924 is->audio_stream = -1;
72ce053b 1925 is->subtitle_stream = -1;
01310af2 1926
416e3508
FB
1927 global_video_state = is;
1928 url_set_interrupt_cb(decode_interrupt_cb);
1929
61890b02 1930 memset(ap, 0, sizeof(*ap));
115329f1 1931
e4b89522
LW
1932 ap->width = frame_width;
1933 ap->height= frame_height;
7e042912 1934 ap->time_base= (AVRational){1, 25};
e4b89522 1935 ap->pix_fmt = frame_pix_fmt;
7e042912 1936
61890b02 1937 err = av_open_input_file(&ic, is->filename, is->iformat, 0, ap);
638c9d91
FB
1938 if (err < 0) {
1939 print_error(is->filename, err);
1940 ret = -1;
1941 goto fail;
1942 }
01310af2 1943 is->ic = ic;
30bc6613
MN
1944
1945 if(genpts)
1946 ic->flags |= AVFMT_FLAG_GENPTS;
1947
24c07998
LA
1948 err = av_find_stream_info(ic);
1949 if (err < 0) {
1950 fprintf(stderr, "%s: could not find codec parameters\n", is->filename);
1951 ret = -1;
1952 goto fail;
1953 }
899681cd
BA
1954 if(ic->pb)
1955 ic->pb->eof_reached= 0; //FIXME hack, ffplay maybe should not use url_feof() to test for the end
72ea344b
FB
1956
1957 /* if seeking requested, we execute it */
1958 if (start_time != AV_NOPTS_VALUE) {
1959 int64_t timestamp;
1960
1961 timestamp = start_time;
1962 /* add the stream start time */
1963 if (ic->start_time != AV_NOPTS_VALUE)
1964 timestamp += ic->start_time;
3ba1438d 1965 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
72ea344b 1966 if (ret < 0) {
115329f1 1967 fprintf(stderr, "%s: could not seek to position %0.3f\n",
72ea344b
FB
1968 is->filename, (double)timestamp / AV_TIME_BASE);
1969 }
1970 }
72ea344b 1971
01310af2 1972 for(i = 0; i < ic->nb_streams; i++) {
01f4895c 1973 AVCodecContext *enc = ic->streams[i]->codec;
3f3fe38d 1974 ic->streams[i]->discard = AVDISCARD_ALL;
01310af2
FB
1975 switch(enc->codec_type) {
1976 case CODEC_TYPE_AUDIO:
5dbb63fe 1977 if (wanted_audio_stream-- >= 0 && !audio_disable)
01310af2
FB
1978 audio_index = i;
1979 break;
1980 case CODEC_TYPE_VIDEO:
5dbb63fe 1981 if (wanted_video_stream-- >= 0 && !video_disable)
01310af2
FB
1982 video_index = i;
1983 break;
16a59a7b 1984 case CODEC_TYPE_SUBTITLE:
5ad4f0d4 1985 if (wanted_subtitle_stream-- >= 0 && !video_disable)
16a59a7b
BA
1986 subtitle_index = i;
1987 break;
01310af2
FB
1988 default:
1989 break;
1990 }
1991 }
1992 if (show_status) {
1993 dump_format(ic, 0, is->filename, 0);
d0526ecf 1994 dump_stream_info(ic);
01310af2
FB
1995 }
1996
1997 /* open the streams */
1998 if (audio_index >= 0) {
1999 stream_component_open(is, audio_index);
2000 }
2001
2002 if (video_index >= 0) {
2003 stream_component_open(is, video_index);
2004 } else {
2005 if (!display_disable)
2006 is->show_audio = 1;
2007 }
2008
16a59a7b
BA
2009 if (subtitle_index >= 0) {
2010 stream_component_open(is, subtitle_index);
2011 }
2012
01310af2 2013 if (is->video_stream < 0 && is->audio_stream < 0) {
638c9d91
FB
2014 fprintf(stderr, "%s: could not open codecs\n", is->filename);
2015 ret = -1;
01310af2
FB
2016 goto fail;
2017 }
2018
2019 for(;;) {
2020 if (is->abort_request)
2021 break;
416e3508
FB
2022 if (is->paused != is->last_paused) {
2023 is->last_paused = is->paused;
72ea344b
FB
2024 if (is->paused)
2025 av_read_pause(ic);
2026 else
2027 av_read_play(ic);
416e3508 2028 }
2f642393
AJ
2029#if CONFIG_RTSP_DEMUXER
2030 if (is->paused && !strcmp(ic->iformat->name, "rtsp")) {
416e3508
FB
2031 /* wait 10 ms to avoid trying to get another packet */
2032 /* XXX: horrible */
2033 SDL_Delay(10);
2034 continue;
2035 }
400738b1 2036#endif
72ea344b 2037 if (is->seek_req) {
8e606cc8
MN
2038 int stream_index= -1;
2039 int64_t seek_target= is->seek_pos;
2040
2041 if (is-> video_stream >= 0) stream_index= is-> video_stream;
2042 else if(is-> audio_stream >= 0) stream_index= is-> audio_stream;
2043 else if(is->subtitle_stream >= 0) stream_index= is->subtitle_stream;
2044
2045 if(stream_index>=0){
2046 seek_target= av_rescale_q(seek_target, AV_TIME_BASE_Q, ic->streams[stream_index]->time_base);
2047 }
2048
2049 ret = av_seek_frame(is->ic, stream_index, seek_target, is->seek_flags);
72ea344b
FB
2050 if (ret < 0) {
2051 fprintf(stderr, "%s: error while seeking\n", is->ic->filename);
e6c0297f
MN
2052 }else{
2053 if (is->audio_stream >= 0) {
2054 packet_queue_flush(&is->audioq);
39c6a118 2055 packet_queue_put(&is->audioq, &flush_pkt);
e6c0297f 2056 }
72ce053b
IC
2057 if (is->subtitle_stream >= 0) {
2058 packet_queue_flush(&is->subtitleq);
39c6a118 2059 packet_queue_put(&is->subtitleq, &flush_pkt);
72ce053b 2060 }
e6c0297f
MN
2061 if (is->video_stream >= 0) {
2062 packet_queue_flush(&is->videoq);
39c6a118 2063 packet_queue_put(&is->videoq, &flush_pkt);
e6c0297f 2064 }
72ea344b
FB
2065 }
2066 is->seek_req = 0;
2067 }
416e3508 2068
01310af2
FB
2069 /* if the queue are full, no need to read more */
2070 if (is->audioq.size > MAX_AUDIOQ_SIZE ||
115329f1 2071 is->videoq.size > MAX_VIDEOQ_SIZE ||
600a331c 2072 is->subtitleq.size > MAX_SUBTITLEQ_SIZE) {
01310af2
FB
2073 /* wait 10 ms */
2074 SDL_Delay(10);
2075 continue;
2076 }
600a331c
MN
2077 if(url_feof(ic->pb)) {
2078 av_init_packet(pkt);
973c68cb 2079 pkt->data=NULL;
600a331c
MN
2080 pkt->size=0;
2081 pkt->stream_index= is->video_stream;
2082 packet_queue_put(&is->videoq, pkt);
2083 continue;
2084 }
72ea344b 2085 ret = av_read_frame(ic, pkt);
01310af2 2086 if (ret < 0) {
edf9b2f0 2087 if (ret != AVERROR_EOF && url_ferror(ic->pb) == 0) {
6e1f8725 2088 SDL_Delay(100); /* wait for user event */
bb270c08
DB
2089 continue;
2090 } else
2091 break;
01310af2
FB
2092 }
2093 if (pkt->stream_index == is->audio_stream) {
2094 packet_queue_put(&is->audioq, pkt);
2095 } else if (pkt->stream_index == is->video_stream) {
2096 packet_queue_put(&is->videoq, pkt);
72ce053b
IC
2097 } else if (pkt->stream_index == is->subtitle_stream) {
2098 packet_queue_put(&is->subtitleq, pkt);
01310af2
FB
2099 } else {
2100 av_free_packet(pkt);
2101 }
2102 }
2103 /* wait until the end */
2104 while (!is->abort_request) {
2105 SDL_Delay(100);
2106 }
2107
638c9d91 2108 ret = 0;
01310af2 2109 fail:
416e3508
FB
2110 /* disable interrupting */
2111 global_video_state = NULL;
2112
01310af2
FB
2113 /* close each stream */
2114 if (is->audio_stream >= 0)
2115 stream_component_close(is, is->audio_stream);
2116 if (is->video_stream >= 0)
2117 stream_component_close(is, is->video_stream);
72ce053b
IC
2118 if (is->subtitle_stream >= 0)
2119 stream_component_close(is, is->subtitle_stream);
638c9d91
FB
2120 if (is->ic) {
2121 av_close_input_file(is->ic);
2122 is->ic = NULL; /* safety */
2123 }
416e3508
FB
2124 url_set_interrupt_cb(NULL);
2125
638c9d91
FB
2126 if (ret != 0) {
2127 SDL_Event event;
115329f1 2128
638c9d91
FB
2129 event.type = FF_QUIT_EVENT;
2130 event.user.data1 = is;
2131 SDL_PushEvent(&event);
2132 }
01310af2
FB
2133 return 0;
2134}
2135
638c9d91 2136static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
01310af2
FB
2137{
2138 VideoState *is;
2139
2140 is = av_mallocz(sizeof(VideoState));
2141 if (!is)
2142 return NULL;
f7d78f36 2143 av_strlcpy(is->filename, filename, sizeof(is->filename));
638c9d91 2144 is->iformat = iformat;
01310af2
FB
2145 is->ytop = 0;
2146 is->xleft = 0;
2147
2148 /* start video display */
2149 is->pictq_mutex = SDL_CreateMutex();
2150 is->pictq_cond = SDL_CreateCond();
115329f1 2151
72ce053b
IC
2152 is->subpq_mutex = SDL_CreateMutex();
2153 is->subpq_cond = SDL_CreateCond();
115329f1 2154
01310af2
FB
2155 /* add the refresh timer to draw the picture */
2156 schedule_refresh(is, 40);
2157
638c9d91 2158 is->av_sync_type = av_sync_type;
01310af2
FB
2159 is->parse_tid = SDL_CreateThread(decode_thread, is);
2160 if (!is->parse_tid) {
2161 av_free(is);
2162 return NULL;
2163 }
2164 return is;
2165}
2166
2167static void stream_close(VideoState *is)
2168{
2169 VideoPicture *vp;
2170 int i;
2171 /* XXX: use a special url_shutdown call to abort parse cleanly */
2172 is->abort_request = 1;
2173 SDL_WaitThread(is->parse_tid, NULL);
2174
2175 /* free all pictures */
2176 for(i=0;i<VIDEO_PICTURE_QUEUE_SIZE; i++) {
2177 vp = &is->pictq[i];
2178 if (vp->bmp) {
2179 SDL_FreeYUVOverlay(vp->bmp);
2180 vp->bmp = NULL;
2181 }
2182 }
2183 SDL_DestroyMutex(is->pictq_mutex);
2184 SDL_DestroyCond(is->pictq_cond);
72ce053b
IC
2185 SDL_DestroyMutex(is->subpq_mutex);
2186 SDL_DestroyCond(is->subpq_cond);
01310af2
FB
2187}
2188
7b49ce2e 2189static void stream_cycle_channel(VideoState *is, int codec_type)
638c9d91
FB
2190{
2191 AVFormatContext *ic = is->ic;
2192 int start_index, stream_index;
2193 AVStream *st;
2194
2195 if (codec_type == CODEC_TYPE_VIDEO)
2196 start_index = is->video_stream;
72ce053b 2197 else if (codec_type == CODEC_TYPE_AUDIO)
638c9d91 2198 start_index = is->audio_stream;
72ce053b
IC
2199 else
2200 start_index = is->subtitle_stream;
2201 if (start_index < (codec_type == CODEC_TYPE_SUBTITLE ? -1 : 0))
638c9d91
FB
2202 return;
2203 stream_index = start_index;
2204 for(;;) {
2205 if (++stream_index >= is->ic->nb_streams)
72ce053b
IC
2206 {
2207 if (codec_type == CODEC_TYPE_SUBTITLE)
2208 {
2209 stream_index = -1;
2210 goto the_end;
2211 } else
2212 stream_index = 0;
2213 }
638c9d91
FB
2214 if (stream_index == start_index)
2215 return;
2216 st = ic->streams[stream_index];
01f4895c 2217 if (st->codec->codec_type == codec_type) {
638c9d91
FB
2218 /* check that parameters are OK */
2219 switch(codec_type) {
2220 case CODEC_TYPE_AUDIO:
01f4895c
MN
2221 if (st->codec->sample_rate != 0 &&
2222 st->codec->channels != 0)
638c9d91
FB
2223 goto the_end;
2224 break;
2225 case CODEC_TYPE_VIDEO:
72ce053b 2226 case CODEC_TYPE_SUBTITLE:
638c9d91
FB
2227 goto the_end;
2228 default:
2229 break;
2230 }
2231 }
2232 }
2233 the_end:
2234 stream_component_close(is, start_index);
2235 stream_component_open(is, stream_index);
2236}
2237
2238
7b49ce2e 2239static void toggle_full_screen(void)
01310af2 2240{
01310af2 2241 is_full_screen = !is_full_screen;
29f3b38a
MR
2242 if (!fs_screen_width) {
2243 /* use default SDL method */
fb84155b 2244// SDL_WM_ToggleFullScreen(screen);
01310af2 2245 }
fb84155b 2246 video_open(cur_stream);
01310af2
FB
2247}
2248
7b49ce2e 2249static void toggle_pause(void)
01310af2
FB
2250{
2251 if (cur_stream)
2252 stream_pause(cur_stream);
bba04f1e
WH
2253 step = 0;
2254}
2255
7b49ce2e 2256static void step_to_next_frame(void)
bba04f1e
WH
2257{
2258 if (cur_stream) {
19cc524a 2259 /* if the stream is paused unpause it, then step */
bba04f1e 2260 if (cur_stream->paused)
19cc524a 2261 stream_pause(cur_stream);
bba04f1e
WH
2262 }
2263 step = 1;
01310af2
FB
2264}
2265
7b49ce2e 2266static void do_exit(void)
01310af2
FB
2267{
2268 if (cur_stream) {
2269 stream_close(cur_stream);
2270 cur_stream = NULL;
2271 }
2272 if (show_status)
2273 printf("\n");
2274 SDL_Quit();
2275 exit(0);
2276}
2277
7b49ce2e 2278static void toggle_audio_display(void)
01310af2
FB
2279{
2280 if (cur_stream) {
2281 cur_stream->show_audio = !cur_stream->show_audio;
2282 }
2283}
2284
2285/* handle an event sent by the GUI */
7b49ce2e 2286static void event_loop(void)
01310af2
FB
2287{
2288 SDL_Event event;
a11d11aa 2289 double incr, pos, frac;
01310af2
FB
2290
2291 for(;;) {
2292 SDL_WaitEvent(&event);
2293 switch(event.type) {
2294 case SDL_KEYDOWN:
2295 switch(event.key.keysym.sym) {
2296 case SDLK_ESCAPE:
2297 case SDLK_q:
2298 do_exit();
2299 break;
2300 case SDLK_f:
2301 toggle_full_screen();
2302 break;
2303 case SDLK_p:
2304 case SDLK_SPACE:
2305 toggle_pause();
2306 break;
bba04f1e
WH
2307 case SDLK_s: //S: Step to next frame
2308 step_to_next_frame();
2309 break;
01310af2 2310 case SDLK_a:
115329f1 2311 if (cur_stream)
638c9d91
FB
2312 stream_cycle_channel(cur_stream, CODEC_TYPE_AUDIO);
2313 break;
2314 case SDLK_v:
115329f1 2315 if (cur_stream)
638c9d91
FB
2316 stream_cycle_channel(cur_stream, CODEC_TYPE_VIDEO);
2317 break;
72ce053b 2318 case SDLK_t:
115329f1 2319 if (cur_stream)
72ce053b
IC
2320 stream_cycle_channel(cur_stream, CODEC_TYPE_SUBTITLE);
2321 break;
638c9d91 2322 case SDLK_w:
01310af2
FB
2323 toggle_audio_display();
2324 break;
72ea344b
FB
2325 case SDLK_LEFT:
2326 incr = -10.0;
2327 goto do_seek;
2328 case SDLK_RIGHT:
2329 incr = 10.0;
2330 goto do_seek;
2331 case SDLK_UP:
2332 incr = 60.0;
2333 goto do_seek;
2334 case SDLK_DOWN:
2335 incr = -60.0;
2336 do_seek:
2337 if (cur_stream) {
94b594c6 2338 if (seek_by_bytes) {
899681cd 2339 pos = url_ftell(cur_stream->ic->pb);
94b594c6
SH
2340 if (cur_stream->ic->bit_rate)
2341 incr *= cur_stream->ic->bit_rate / 60.0;
2342 else
2343 incr *= 180000.0;
2344 pos += incr;
2345 stream_seek(cur_stream, pos, incr);
2346 } else {
2347 pos = get_master_clock(cur_stream);
2348 pos += incr;
2349 stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), incr);
2350 }
72ea344b
FB
2351 }
2352 break;
01310af2
FB
2353 default:
2354 break;
2355 }
2356 break;
a11d11aa 2357 case SDL_MOUSEBUTTONDOWN:
bb270c08
DB
2358 if (cur_stream) {
2359 int ns, hh, mm, ss;
2360 int tns, thh, tmm, tss;
2361 tns = cur_stream->ic->duration/1000000LL;
2362 thh = tns/3600;
2363 tmm = (tns%3600)/60;
2364 tss = (tns%60);
2365 frac = (double)event.button.x/(double)cur_stream->width;
2366 ns = frac*tns;
2367 hh = ns/3600;
2368 mm = (ns%3600)/60;
2369 ss = (ns%60);
2370 fprintf(stderr, "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d) \n", frac*100,
2371 hh, mm, ss, thh, tmm, tss);
2372 stream_seek(cur_stream, (int64_t)(cur_stream->ic->start_time+frac*cur_stream->ic->duration), 0);
2373 }
2374 break;
01310af2
FB
2375 case SDL_VIDEORESIZE:
2376 if (cur_stream) {
115329f1 2377 screen = SDL_SetVideoMode(event.resize.w, event.resize.h, 0,
01310af2 2378 SDL_HWSURFACE|SDL_RESIZABLE|SDL_ASYNCBLIT|SDL_HWACCEL);
c57d3469
MN
2379 screen_width = cur_stream->width = event.resize.w;
2380 screen_height= cur_stream->height= event.resize.h;
01310af2
FB
2381 }
2382 break;
2383 case SDL_QUIT:
638c9d91 2384 case FF_QUIT_EVENT:
01310af2
FB
2385 do_exit();
2386 break;
2387 case FF_ALLOC_EVENT:
fccb19e3 2388 video_open(event.user.data1);
01310af2
FB
2389 alloc_picture(event.user.data1);
2390 break;
2391 case FF_REFRESH_EVENT:
2392 video_refresh_timer(event.user.data1);
2393 break;
2394 default:
2395 break;
2396 }
2397 }
2398}
2399
e4b89522
LW
2400static void opt_frame_size(const char *arg)
2401{
b33ece16 2402 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
e4b89522
LW
2403 fprintf(stderr, "Incorrect frame size\n");
2404 exit(1);
2405 }
2406 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2407 fprintf(stderr, "Frame size must be a multiple of 2\n");
2408 exit(1);
2409 }
2410}
2411
a5b3b5f6 2412static int opt_width(const char *opt, const char *arg)
01310af2 2413{
a5b3b5f6
SS
2414 screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
2415 return 0;
01310af2
FB
2416}
2417
a5b3b5f6 2418static int opt_height(const char *opt, const char *arg)
01310af2 2419{
a5b3b5f6
SS
2420 screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
2421 return 0;
01310af2
FB
2422}
2423
2424static void opt_format(const char *arg)
2425{
2426 file_iformat = av_find_input_format(arg);
2427 if (!file_iformat) {
2428 fprintf(stderr, "Unknown input format: %s\n", arg);
2429 exit(1);
2430 }
2431}
61890b02 2432
e4b89522
LW
2433static void opt_frame_pix_fmt(const char *arg)
2434{
2435 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2436}
2437
b81d6235 2438static int opt_sync(const char *opt, const char *arg)
638c9d91
FB
2439{
2440 if (!strcmp(arg, "audio"))
2441 av_sync_type = AV_SYNC_AUDIO_MASTER;
2442 else if (!strcmp(arg, "video"))
2443 av_sync_type = AV_SYNC_VIDEO_MASTER;
2444 else if (!strcmp(arg, "ext"))
2445 av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
aab1b7e5 2446 else {
b81d6235 2447 fprintf(stderr, "Unknown value for %s: %s\n", opt, arg);
aab1b7e5
SS
2448 exit(1);
2449 }
b81d6235 2450 return 0;
638c9d91
FB
2451}
2452
e11bc2c6 2453static int opt_seek(const char *opt, const char *arg)
72ea344b 2454{
e11bc2c6
SS
2455 start_time = parse_time_or_die(opt, arg, 1);
2456 return 0;
72ea344b
FB
2457}
2458
a5b3b5f6 2459static int opt_debug(const char *opt, const char *arg)
e26a8335 2460{
a309073b 2461 av_log_set_level(99);
a5b3b5f6
SS
2462 debug = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2463 return 0;
e26a8335 2464}
115329f1 2465
a5b3b5f6 2466static int opt_vismv(const char *opt, const char *arg)
0c9bbaec 2467{
a5b3b5f6
SS
2468 debug_mv = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2469 return 0;
0c9bbaec 2470}
c62c07d3 2471
a5b3b5f6 2472static int opt_thread_count(const char *opt, const char *arg)
c62c07d3 2473{
a5b3b5f6 2474 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
b250f9c6 2475#if !HAVE_THREADS
c62c07d3
MN
2476 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2477#endif
a5b3b5f6 2478 return 0;
c62c07d3 2479}
115329f1 2480
358061f6 2481static const OptionDef options[] = {
20176cbc
MN
2482 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
2483 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
8fdea204 2484 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
a28b7ed4 2485 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
a5b3b5f6
SS
2486 { "x", HAS_ARG | OPT_FUNC2, {(void*)opt_width}, "force displayed width", "width" },
2487 { "y", HAS_ARG | OPT_FUNC2, {(void*)opt_height}, "force displayed height", "height" },
e4b89522 2488 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
638c9d91 2489 { "fs", OPT_BOOL, {(void*)&is_full_screen}, "force full screen" },
01310af2
FB
2490 { "an", OPT_BOOL, {(void*)&audio_disable}, "disable audio" },
2491 { "vn", OPT_BOOL, {(void*)&video_disable}, "disable video" },
4b037567
SS
2492 { "ast", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_audio_stream}, "select desired audio stream", "stream_number" },
2493 { "vst", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_video_stream}, "select desired video stream", "stream_number" },
2494 { "sst", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_subtitle_stream}, "select desired subtitle stream", "stream_number" },
e11bc2c6 2495 { "ss", HAS_ARG | OPT_FUNC2, {(void*)&opt_seek}, "seek to a given position in seconds", "pos" },
94b594c6 2496 { "bytes", OPT_BOOL, {(void*)&seek_by_bytes}, "seek by bytes" },
01310af2
FB
2497 { "nodisp", OPT_BOOL, {(void*)&display_disable}, "disable graphical display" },
2498 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
e4b89522 2499 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
01310af2 2500 { "stats", OPT_BOOL | OPT_EXPERT, {(void*)&show_status}, "show status", "" },
a5b3b5f6 2501 { "debug", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
6387c3e6 2502 { "bug", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&workaround_bugs}, "workaround bugs", "" },
a5b3b5f6 2503 { "vismv", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
6fc5b059 2504 { "fast", OPT_BOOL | OPT_EXPERT, {(void*)&fast}, "non spec compliant optimizations", "" },
30bc6613 2505 { "genpts", OPT_BOOL | OPT_EXPERT, {(void*)&genpts}, "generate pts", "" },
5039185a 2506 { "drp", OPT_BOOL |OPT_EXPERT, {(void*)&decoder_reorder_pts}, "let decoder reorder pts", ""},
178fcca8 2507 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&lowres}, "", "" },
8c3eba7c
MN
2508 { "skiploop", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&skip_loop_filter}, "", "" },
2509 { "skipframe", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&skip_frame}, "", "" },
2510 { "skipidct", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&skip_idct}, "", "" },
178fcca8 2511 { "idct", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&idct}, "set idct algo", "algo" },
047599a4 2512 { "er", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&error_recognition}, "set error detection threshold (0-4)", "threshold" },
1b51e051 2513 { "ec", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&error_concealment}, "set error concealment options", "bit_mask" },
b81d6235 2514 { "sync", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_sync}, "set audio-video sync. type (type=audio/video/ext)", "type" },
a5b3b5f6 2515 { "threads", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
e43d7a18 2516 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
01310af2
FB
2517 { NULL, },
2518};
2519
358061f6 2520static void show_help(void)
01310af2 2521{
9c5755ee 2522 printf("usage: ffplay [options] input_file\n"
01310af2
FB
2523 "Simple media player\n");
2524 printf("\n");
02d504a7
FB
2525 show_help_options(options, "Main options:\n",
2526 OPT_EXPERT, 0);
2527 show_help_options(options, "\nAdvanced options:\n",
2528 OPT_EXPERT, OPT_EXPERT);
01310af2
FB
2529 printf("\nWhile playing:\n"
2530 "q, ESC quit\n"
2531 "f toggle full screen\n"
2532 "p, SPC pause\n"
638c9d91
FB
2533 "a cycle audio channel\n"
2534 "v cycle video channel\n"
72ce053b 2535 "t cycle subtitle channel\n"
638c9d91 2536 "w show audio waves\n"
72ea344b
FB
2537 "left/right seek backward/forward 10 seconds\n"
2538 "down/up seek backward/forward 1 minute\n"
a11d11aa 2539 "mouse click seek to percentage in file corresponding to fraction of width\n"
01310af2 2540 );
01310af2
FB
2541}
2542
358061f6 2543static void opt_input_file(const char *filename)
01310af2 2544{
e8d83e1c 2545 if (!strcmp(filename, "-"))
9fcfc0b7 2546 filename = "pipe:";
01310af2
FB
2547 input_filename = filename;
2548}
2549
2550/* Called from the main */
2551int main(int argc, char **argv)
2552{
e43d7a18 2553 int flags, i;
115329f1 2554
01310af2 2555 /* register all codecs, demux and protocols */
c721d803
LA
2556 avcodec_register_all();
2557 avdevice_register_all();
01310af2
FB
2558 av_register_all();
2559
e43d7a18 2560 for(i=0; i<CODEC_TYPE_NB; i++){
636f1c4c 2561 avcodec_opts[i]= avcodec_alloc_context2(i);
e43d7a18 2562 }
8e2fd8e1 2563 avformat_opts = avformat_alloc_context();
e43d7a18
MN
2564 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
2565
ea9c581f 2566 show_banner();
4cfac5bc 2567
f5da5c93 2568 parse_options(argc, argv, options, opt_input_file);
01310af2 2569
aab1b7e5 2570 if (!input_filename) {
7a7da6b4 2571 fprintf(stderr, "An input file must be specified\n");
aab1b7e5
SS
2572 exit(1);
2573 }
01310af2
FB
2574
2575 if (display_disable) {
2576 video_disable = 1;
2577 }
31319a8c 2578 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
c97f5402
DB
2579#if !defined(__MINGW32__) && !defined(__APPLE__)
2580 flags |= SDL_INIT_EVENTTHREAD; /* Not supported on Windows or Mac OS X */
31319a8c 2581#endif
01310af2 2582 if (SDL_Init (flags)) {
05ab0b76 2583 fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
01310af2
FB
2584 exit(1);
2585 }
2586
2587 if (!display_disable) {
b250f9c6 2588#if HAVE_SDL_VIDEO_SIZE
3ef17d62
MR
2589 const SDL_VideoInfo *vi = SDL_GetVideoInfo();
2590 fs_screen_width = vi->current_w;
2591 fs_screen_height = vi->current_h;
29f3b38a 2592#endif
01310af2
FB
2593 }
2594
2595 SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
2596 SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE);
2597 SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
2598 SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
2599
39c6a118
MN
2600 av_init_packet(&flush_pkt);
2601 flush_pkt.data= "FLUSH";
2602
638c9d91 2603 cur_stream = stream_open(input_filename, file_iformat);
01310af2
FB
2604
2605 event_loop();
2606
2607 /* never returns */
2608
2609 return 0;
2610}