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