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