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