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