projects / libav.git / blob
? search:


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