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