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