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