projects / libav.git / blob
? search:


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