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