1 /*
2 * Copyright (c) 2003 Fabrice Bellard
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 /**
22 * @file
23 * simple media player based on the FFmpeg libraries
24 */
25
26 #include "config.h"
27 #include <inttypes.h>
28 #include <math.h>
29 #include <limits.h>
30 #include <signal.h>
31 #include <stdint.h>
32
33 #include "libavutil/avstring.h"
34 #include "libavutil/eval.h"
35 #include "libavutil/mathematics.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/imgutils.h"
38 #include "libavutil/dict.h"
39 #include "libavutil/parseutils.h"
40 #include "libavutil/samplefmt.h"
41 #include "libavutil/avassert.h"
42 #include "libavutil/time.h"
43 #include "libavutil/bprint.h"
44 #include "libavformat/avformat.h"
45 #include "libavdevice/avdevice.h"
46 #include "libswscale/swscale.h"
47 #include "libavutil/opt.h"
48 #include "libavcodec/avfft.h"
49 #include "libswresample/swresample.h"
50
51 #if CONFIG_AVFILTER
52 # include "libavfilter/avfilter.h"
53 # include "libavfilter/buffersink.h"
54 # include "libavfilter/buffersrc.h"
55 #endif
56
57 #include <SDL.h>
58 #include <SDL_thread.h>
59
60 #include "cmdutils.h"
61
62 #include <assert.h>
63
64 const char program_name[] = "ffplay";
65 const int program_birth_year = 2003;
66
67 #define MAX_QUEUE_SIZE (15 * 1024 * 1024)
68 #define MIN_FRAMES 25
69 #define EXTERNAL_CLOCK_MIN_FRAMES 2
70 #define EXTERNAL_CLOCK_MAX_FRAMES 10
71
72 /* Minimum SDL audio buffer size, in samples. */
73 #define SDL_AUDIO_MIN_BUFFER_SIZE 512
74 /* Calculate actual buffer size keeping in mind not cause too frequent audio callbacks */
75 #define SDL_AUDIO_MAX_CALLBACKS_PER_SEC 30
76
77 /* Step size for volume control in dB */
78 #define SDL_VOLUME_STEP (0.75)
79
80 /* no AV sync correction is done if below the minimum AV sync threshold */
81 #define AV_SYNC_THRESHOLD_MIN 0.04
82 /* AV sync correction is done if above the maximum AV sync threshold */
83 #define AV_SYNC_THRESHOLD_MAX 0.1
84 /* If a frame duration is longer than this, it will not be duplicated to compensate AV sync */
85 #define AV_SYNC_FRAMEDUP_THRESHOLD 0.1
86 /* no AV correction is done if too big error */
87 #define AV_NOSYNC_THRESHOLD 10.0
88
89 /* maximum audio speed change to get correct sync */
90 #define SAMPLE_CORRECTION_PERCENT_MAX 10
91
92 /* external clock speed adjustment constants for realtime sources based on buffer fullness */
93 #define EXTERNAL_CLOCK_SPEED_MIN 0.900
94 #define EXTERNAL_CLOCK_SPEED_MAX 1.010
95 #define EXTERNAL_CLOCK_SPEED_STEP 0.001
96
97 /* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
98 #define AUDIO_DIFF_AVG_NB 20
99
100 /* polls for possible required screen refresh at least this often, should be less than 1/fps */
101 #define REFRESH_RATE 0.01
102
103 /* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
104 /* TODO: We assume that a decoded and resampled frame fits into this buffer */
105 #define SAMPLE_ARRAY_SIZE (8 * 65536)
106
107 #define CURSOR_HIDE_DELAY 1000000
108
109 #define USE_ONEPASS_SUBTITLE_RENDER 1
110
111 static unsigned sws_flags = SWS_BICUBIC;
112
113 typedef struct MyAVPacketList {
114 AVPacket pkt;
115 struct MyAVPacketList *next;
116 int serial;
117 } MyAVPacketList;
118
119 typedef struct PacketQueue {
120 MyAVPacketList *first_pkt, *last_pkt;
121 int nb_packets;
122 int size;
123 int64_t duration;
124 int abort_request;
125 int serial;
126 SDL_mutex *mutex;
127 SDL_cond *cond;
128 } PacketQueue;
129
130 #define VIDEO_PICTURE_QUEUE_SIZE 3
131 #define SUBPICTURE_QUEUE_SIZE 16
132 #define SAMPLE_QUEUE_SIZE 9
133 #define FRAME_QUEUE_SIZE FFMAX(SAMPLE_QUEUE_SIZE, FFMAX(VIDEO_PICTURE_QUEUE_SIZE, SUBPICTURE_QUEUE_SIZE))
134
135 typedef struct AudioParams {
136 int freq;
137 int channels;
138 int64_t channel_layout;
139 enum AVSampleFormat fmt;
140 int frame_size;
141 int bytes_per_sec;
142 } AudioParams;
143
144 typedef struct Clock {
145 double pts; /* clock base */
146 double pts_drift; /* clock base minus time at which we updated the clock */
147 double last_updated;
148 double speed;
149 int serial; /* clock is based on a packet with this serial */
150 int paused;
151 int *queue_serial; /* pointer to the current packet queue serial, used for obsolete clock detection */
152 } Clock;
153
154 /* Common struct for handling all types of decoded data and allocated render buffers. */
155 typedef struct Frame {
156 AVFrame *frame;
157 AVSubtitle sub;
158 int serial;
159 double pts; /* presentation timestamp for the frame */
160 double duration; /* estimated duration of the frame */
161 int64_t pos; /* byte position of the frame in the input file */
162 int width;
163 int height;
164 int format;
165 AVRational sar;
166 int uploaded;
167 int flip_v;
168 } Frame;
169
170 typedef struct FrameQueue {
171 Frame queue[FRAME_QUEUE_SIZE];
172 int rindex;
173 int windex;
174 int size;
175 int max_size;
176 int keep_last;
177 int rindex_shown;
178 SDL_mutex *mutex;
179 SDL_cond *cond;
180 PacketQueue *pktq;
181 } FrameQueue;
182
183 enum {
184 AV_SYNC_AUDIO_MASTER, /* default choice */
185 AV_SYNC_VIDEO_MASTER,
186 AV_SYNC_EXTERNAL_CLOCK, /* synchronize to an external clock */
187 };
188
189 typedef struct Decoder {
190 AVPacket pkt;
191 PacketQueue *queue;
192 AVCodecContext *avctx;
193 int pkt_serial;
194 int finished;
195 int packet_pending;
196 SDL_cond *empty_queue_cond;
197 int64_t start_pts;
198 AVRational start_pts_tb;
199 int64_t next_pts;
200 AVRational next_pts_tb;
201 SDL_Thread *decoder_tid;
202 } Decoder;
203
204 typedef struct VideoState {
205 SDL_Thread *read_tid;
206 AVInputFormat *iformat;
207 int abort_request;
208 int force_refresh;
209 int paused;
210 int last_paused;
211 int queue_attachments_req;
212 int seek_req;
213 int seek_flags;
214 int64_t seek_pos;
215 int64_t seek_rel;
216 int read_pause_return;
217 AVFormatContext *ic;
218 int realtime;
219
220 Clock audclk;
221 Clock vidclk;
222 Clock extclk;
223
224 FrameQueue pictq;
225 FrameQueue subpq;
226 FrameQueue sampq;
227
228 Decoder auddec;
229 Decoder viddec;
230 Decoder subdec;
231
232 int audio_stream;
233
234 int av_sync_type;
235
236 double audio_clock;
237 int audio_clock_serial;
238 double audio_diff_cum; /* used for AV difference average computation */
239 double audio_diff_avg_coef;
240 double audio_diff_threshold;
241 int audio_diff_avg_count;
242 AVStream *audio_st;
243 PacketQueue audioq;
244 int audio_hw_buf_size;
245 uint8_t *audio_buf;
246 uint8_t *audio_buf1;
247 unsigned int audio_buf_size; /* in bytes */
248 unsigned int audio_buf1_size;
249 int audio_buf_index; /* in bytes */
250 int audio_write_buf_size;
251 int audio_volume;
252 int muted;
253 struct AudioParams audio_src;
254 #if CONFIG_AVFILTER
255 struct AudioParams audio_filter_src;
256 #endif
257 struct AudioParams audio_tgt;
258 struct SwrContext *swr_ctx;
259 int frame_drops_early;
260 int frame_drops_late;
261
262 enum ShowMode {
263 SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO = 0, SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB
264 } show_mode;
265 int16_t sample_array[SAMPLE_ARRAY_SIZE];
266 int sample_array_index;
267 int last_i_start;
268 RDFTContext *rdft;
269 int rdft_bits;
270 FFTSample *rdft_data;
271 int xpos;
272 double last_vis_time;
273 SDL_Texture *vis_texture;
274 SDL_Texture *sub_texture;
275 SDL_Texture *vid_texture;
276
277 int subtitle_stream;
278 AVStream *subtitle_st;
279 PacketQueue subtitleq;
280
281 double frame_timer;
282 double frame_last_returned_time;
283 double frame_last_filter_delay;
284 int video_stream;
285 AVStream *video_st;
286 PacketQueue videoq;
287 double max_frame_duration; // maximum duration of a frame - above this, we consider the jump a timestamp discontinuity
288 struct SwsContext *img_convert_ctx;
289 struct SwsContext *sub_convert_ctx;
290 int eof;
291
292 char *filename;
293 int width, height, xleft, ytop;
294 int step;
295
296 #if CONFIG_AVFILTER
297 int vfilter_idx;
298 AVFilterContext *in_video_filter; // the first filter in the video chain
299 AVFilterContext *out_video_filter; // the last filter in the video chain
300 AVFilterContext *in_audio_filter; // the first filter in the audio chain
301 AVFilterContext *out_audio_filter; // the last filter in the audio chain
302 AVFilterGraph *agraph; // audio filter graph
303 #endif
304
305 int last_video_stream, last_audio_stream, last_subtitle_stream;
306
307 SDL_cond *continue_read_thread;
308 } VideoState;
309
310 /* options specified by the user */
311 static AVInputFormat *file_iformat;
312 static const char *input_filename;
313 static const char *window_title;
314 static int default_width = 640;
315 static int default_height = 480;
316 static int screen_width = 0;
317 static int screen_height = 0;
318 static int screen_left = SDL_WINDOWPOS_CENTERED;
319 static int screen_top = SDL_WINDOWPOS_CENTERED;
320 static int audio_disable;
321 static int video_disable;
322 static int subtitle_disable;
323 static const char* wanted_stream_spec[AVMEDIA_TYPE_NB] = {0};
324 static int seek_by_bytes = -1;
325 static float seek_interval = 10;
326 static int display_disable;
327 static int borderless;
328 static int alwaysontop;
329 static int startup_volume = 100;
330 static int show_status = -1;
331 static int av_sync_type = AV_SYNC_AUDIO_MASTER;
332 static int64_t start_time = AV_NOPTS_VALUE;
333 static int64_t duration = AV_NOPTS_VALUE;
334 static int fast = 0;
335 static int genpts = 0;
336 static int lowres = 0;
337 static int decoder_reorder_pts = -1;
338 static int autoexit;
339 static int exit_on_keydown;
340 static int exit_on_mousedown;
341 static int loop = 1;
342 static int framedrop = -1;
343 static int infinite_buffer = -1;
344 static enum ShowMode show_mode = SHOW_MODE_NONE;
345 static const char *audio_codec_name;
346 static const char *subtitle_codec_name;
347 static const char *video_codec_name;
348 double rdftspeed = 0.02;
349 static int64_t cursor_last_shown;
350 static int cursor_hidden = 0;
351 #if CONFIG_AVFILTER
352 static const char **vfilters_list = NULL;
353 static int nb_vfilters = 0;
354 static char *afilters = NULL;
355 #endif
356 static int autorotate = 1;
357 static int find_stream_info = 1;
358 static int filter_nbthreads = 0;
359
360 /* current context */
361 static int is_full_screen;
362 static int64_t audio_callback_time;
363
364 static AVPacket flush_pkt;
365
366 #define FF_QUIT_EVENT (SDL_USEREVENT + 2)
367
368 static SDL_Window *window;
369 static SDL_Renderer *renderer;
370 static SDL_RendererInfo renderer_info = {0};
371 static SDL_AudioDeviceID audio_dev;
372
373 static const struct TextureFormatEntry {
374 enum AVPixelFormat format;
375 int texture_fmt;
376 } sdl_texture_format_map[] = {
377 { AV_PIX_FMT_RGB8, SDL_PIXELFORMAT_RGB332 },
378 { AV_PIX_FMT_RGB444, SDL_PIXELFORMAT_RGB444 },
379 { AV_PIX_FMT_RGB555, SDL_PIXELFORMAT_RGB555 },
380 { AV_PIX_FMT_BGR555, SDL_PIXELFORMAT_BGR555 },
381 { AV_PIX_FMT_RGB565, SDL_PIXELFORMAT_RGB565 },
382 { AV_PIX_FMT_BGR565, SDL_PIXELFORMAT_BGR565 },
383 { AV_PIX_FMT_RGB24, SDL_PIXELFORMAT_RGB24 },
384 { AV_PIX_FMT_BGR24, SDL_PIXELFORMAT_BGR24 },
385 { AV_PIX_FMT_0RGB32, SDL_PIXELFORMAT_RGB888 },
386 { AV_PIX_FMT_0BGR32, SDL_PIXELFORMAT_BGR888 },
387 { AV_PIX_FMT_NE(RGB0, 0BGR), SDL_PIXELFORMAT_RGBX8888 },
388 { AV_PIX_FMT_NE(BGR0, 0RGB), SDL_PIXELFORMAT_BGRX8888 },
389 { AV_PIX_FMT_RGB32, SDL_PIXELFORMAT_ARGB8888 },
390 { AV_PIX_FMT_RGB32_1, SDL_PIXELFORMAT_RGBA8888 },
391 { AV_PIX_FMT_BGR32, SDL_PIXELFORMAT_ABGR8888 },
392 { AV_PIX_FMT_BGR32_1, SDL_PIXELFORMAT_BGRA8888 },
393 { AV_PIX_FMT_YUV420P, SDL_PIXELFORMAT_IYUV },
394 { AV_PIX_FMT_YUYV422, SDL_PIXELFORMAT_YUY2 },
395 { AV_PIX_FMT_UYVY422, SDL_PIXELFORMAT_UYVY },
396 { AV_PIX_FMT_NONE, SDL_PIXELFORMAT_UNKNOWN },
397 };
398
399 #if CONFIG_AVFILTER
opt_add_vfilter(void * optctx,const char * opt,const char * arg)400 static int opt_add_vfilter(void *optctx, const char *opt, const char *arg)
401 {
402 GROW_ARRAY(vfilters_list, nb_vfilters);
403 vfilters_list[nb_vfilters - 1] = arg;
404 return 0;
405 }
406 #endif
407
408 static inline
cmp_audio_fmts(enum AVSampleFormat fmt1,int64_t channel_count1,enum AVSampleFormat fmt2,int64_t channel_count2)409 int cmp_audio_fmts(enum AVSampleFormat fmt1, int64_t channel_count1,
410 enum AVSampleFormat fmt2, int64_t channel_count2)
411 {
412 /* If channel count == 1, planar and non-planar formats are the same */
413 if (channel_count1 == 1 && channel_count2 == 1)
414 return av_get_packed_sample_fmt(fmt1) != av_get_packed_sample_fmt(fmt2);
415 else
416 return channel_count1 != channel_count2 || fmt1 != fmt2;
417 }
418
419 static inline
get_valid_channel_layout(int64_t channel_layout,int channels)420 int64_t get_valid_channel_layout(int64_t channel_layout, int channels)
421 {
422 if (channel_layout && av_get_channel_layout_nb_channels(channel_layout) == channels)
423 return channel_layout;
424 else
425 return 0;
426 }
427
packet_queue_put_private(PacketQueue * q,AVPacket * pkt)428 static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
429 {
430 MyAVPacketList *pkt1;
431
432 if (q->abort_request)
433 return -1;
434
435 pkt1 = av_malloc(sizeof(MyAVPacketList));
436 if (!pkt1)
437 return -1;
438 pkt1->pkt = *pkt;
439 pkt1->next = NULL;
440 if (pkt == &flush_pkt)
441 q->serial++;
442 pkt1->serial = q->serial;
443
444 if (!q->last_pkt)
445 q->first_pkt = pkt1;
446 else
447 q->last_pkt->next = pkt1;
448 q->last_pkt = pkt1;
449 q->nb_packets++;
450 q->size += pkt1->pkt.size + sizeof(*pkt1);
451 q->duration += pkt1->pkt.duration;
452 /* XXX: should duplicate packet data in DV case */
453 SDL_CondSignal(q->cond);
454 return 0;
455 }
456
packet_queue_put(PacketQueue * q,AVPacket * pkt)457 static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
458 {
459 int ret;
460
461 SDL_LockMutex(q->mutex);
462 ret = packet_queue_put_private(q, pkt);
463 SDL_UnlockMutex(q->mutex);
464
465 if (pkt != &flush_pkt && ret < 0)
466 av_packet_unref(pkt);
467
468 return ret;
469 }
470
packet_queue_put_nullpacket(PacketQueue * q,int stream_index)471 static int packet_queue_put_nullpacket(PacketQueue *q, int stream_index)
472 {
473 AVPacket pkt1, *pkt = &pkt1;
474 av_init_packet(pkt);
475 pkt->data = NULL;
476 pkt->size = 0;
477 pkt->stream_index = stream_index;
478 return packet_queue_put(q, pkt);
479 }
480
481 /* packet queue handling */
packet_queue_init(PacketQueue * q)482 static int packet_queue_init(PacketQueue *q)
483 {
484 memset(q, 0, sizeof(PacketQueue));
485 q->mutex = SDL_CreateMutex();
486 if (!q->mutex) {
487 av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
488 return AVERROR(ENOMEM);
489 }
490 q->cond = SDL_CreateCond();
491 if (!q->cond) {
492 av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
493 return AVERROR(ENOMEM);
494 }
495 q->abort_request = 1;
496 return 0;
497 }
498
packet_queue_flush(PacketQueue * q)499 static void packet_queue_flush(PacketQueue *q)
500 {
501 MyAVPacketList *pkt, *pkt1;
502
503 SDL_LockMutex(q->mutex);
504 for (pkt = q->first_pkt; pkt; pkt = pkt1) {
505 pkt1 = pkt->next;
506 av_packet_unref(&pkt->pkt);
507 av_freep(&pkt);
508 }
509 q->last_pkt = NULL;
510 q->first_pkt = NULL;
511 q->nb_packets = 0;
512 q->size = 0;
513 q->duration = 0;
514 SDL_UnlockMutex(q->mutex);
515 }
516
packet_queue_destroy(PacketQueue * q)517 static void packet_queue_destroy(PacketQueue *q)
518 {
519 packet_queue_flush(q);
520 SDL_DestroyMutex(q->mutex);
521 SDL_DestroyCond(q->cond);
522 }
523
packet_queue_abort(PacketQueue * q)524 static void packet_queue_abort(PacketQueue *q)
525 {
526 SDL_LockMutex(q->mutex);
527
528 q->abort_request = 1;
529
530 SDL_CondSignal(q->cond);
531
532 SDL_UnlockMutex(q->mutex);
533 }
534
packet_queue_start(PacketQueue * q)535 static void packet_queue_start(PacketQueue *q)
536 {
537 SDL_LockMutex(q->mutex);
538 q->abort_request = 0;
539 packet_queue_put_private(q, &flush_pkt);
540 SDL_UnlockMutex(q->mutex);
541 }
542
543 /* return < 0 if aborted, 0 if no packet and > 0 if packet. */
packet_queue_get(PacketQueue * q,AVPacket * pkt,int block,int * serial)544 static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)
545 {
546 MyAVPacketList *pkt1;
547 int ret;
548
549 SDL_LockMutex(q->mutex);
550
551 for (;;) {
552 if (q->abort_request) {
553 ret = -1;
554 break;
555 }
556
557 pkt1 = q->first_pkt;
558 if (pkt1) {
559 q->first_pkt = pkt1->next;
560 if (!q->first_pkt)
561 q->last_pkt = NULL;
562 q->nb_packets--;
563 q->size -= pkt1->pkt.size + sizeof(*pkt1);
564 q->duration -= pkt1->pkt.duration;
565 *pkt = pkt1->pkt;
566 if (serial)
567 *serial = pkt1->serial;
568 av_free(pkt1);
569 ret = 1;
570 break;
571 } else if (!block) {
572 ret = 0;
573 break;
574 } else {
575 SDL_CondWait(q->cond, q->mutex);
576 }
577 }
578 SDL_UnlockMutex(q->mutex);
579 return ret;
580 }
581
decoder_init(Decoder * d,AVCodecContext * avctx,PacketQueue * queue,SDL_cond * empty_queue_cond)582 static void decoder_init(Decoder *d, AVCodecContext *avctx, PacketQueue *queue, SDL_cond *empty_queue_cond) {
583 memset(d, 0, sizeof(Decoder));
584 d->avctx = avctx;
585 d->queue = queue;
586 d->empty_queue_cond = empty_queue_cond;
587 d->start_pts = AV_NOPTS_VALUE;
588 d->pkt_serial = -1;
589 }
590
decoder_decode_frame(Decoder * d,AVFrame * frame,AVSubtitle * sub)591 static int decoder_decode_frame(Decoder *d, AVFrame *frame, AVSubtitle *sub) {
592 int ret = AVERROR(EAGAIN);
593
594 for (;;) {
595 AVPacket pkt;
596
597 if (d->queue->serial == d->pkt_serial) {
598 do {
599 if (d->queue->abort_request)
600 return -1;
601
602 switch (d->avctx->codec_type) {
603 case AVMEDIA_TYPE_VIDEO:
604 ret = avcodec_receive_frame(d->avctx, frame);
605 if (ret >= 0) {
606 if (decoder_reorder_pts == -1) {
607 frame->pts = frame->best_effort_timestamp;
608 } else if (!decoder_reorder_pts) {
609 frame->pts = frame->pkt_dts;
610 }
611 }
612 break;
613 case AVMEDIA_TYPE_AUDIO:
614 ret = avcodec_receive_frame(d->avctx, frame);
615 if (ret >= 0) {
616 AVRational tb = (AVRational){1, frame->sample_rate};
617 if (frame->pts != AV_NOPTS_VALUE)
618 frame->pts = av_rescale_q(frame->pts, d->avctx->pkt_timebase, tb);
619 else if (d->next_pts != AV_NOPTS_VALUE)
620 frame->pts = av_rescale_q(d->next_pts, d->next_pts_tb, tb);
621 if (frame->pts != AV_NOPTS_VALUE) {
622 d->next_pts = frame->pts + frame->nb_samples;
623 d->next_pts_tb = tb;
624 }
625 }
626 break;
627 }
628 if (ret == AVERROR_EOF) {
629 d->finished = d->pkt_serial;
630 avcodec_flush_buffers(d->avctx);
631 return 0;
632 }
633 if (ret >= 0)
634 return 1;
635 } while (ret != AVERROR(EAGAIN));
636 }
637
638 do {
639 if (d->queue->nb_packets == 0)
640 SDL_CondSignal(d->empty_queue_cond);
641 if (d->packet_pending) {
642 av_packet_move_ref(&pkt, &d->pkt);
643 d->packet_pending = 0;
644 } else {
645 if (packet_queue_get(d->queue, &pkt, 1, &d->pkt_serial) < 0)
646 return -1;
647 }
648 if (d->queue->serial == d->pkt_serial)
649 break;
650 av_packet_unref(&pkt);
651 } while (1);
652
653 if (pkt.data == flush_pkt.data) {
654 avcodec_flush_buffers(d->avctx);
655 d->finished = 0;
656 d->next_pts = d->start_pts;
657 d->next_pts_tb = d->start_pts_tb;
658 } else {
659 if (d->avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
660 int got_frame = 0;
661 ret = avcodec_decode_subtitle2(d->avctx, sub, &got_frame, &pkt);
662 if (ret < 0) {
663 ret = AVERROR(EAGAIN);
664 } else {
665 if (got_frame && !pkt.data) {
666 d->packet_pending = 1;
667 av_packet_move_ref(&d->pkt, &pkt);
668 }
669 ret = got_frame ? 0 : (pkt.data ? AVERROR(EAGAIN) : AVERROR_EOF);
670 }
671 } else {
672 if (avcodec_send_packet(d->avctx, &pkt) == AVERROR(EAGAIN)) {
673 av_log(d->avctx, AV_LOG_ERROR, "Receive_frame and send_packet both returned EAGAIN, which is an API violation.\n");
674 d->packet_pending = 1;
675 av_packet_move_ref(&d->pkt, &pkt);
676 }
677 }
678 av_packet_unref(&pkt);
679 }
680 }
681 }
682
decoder_destroy(Decoder * d)683 static void decoder_destroy(Decoder *d) {
684 av_packet_unref(&d->pkt);
685 avcodec_free_context(&d->avctx);
686 }
687
frame_queue_unref_item(Frame * vp)688 static void frame_queue_unref_item(Frame *vp)
689 {
690 av_frame_unref(vp->frame);
691 avsubtitle_free(&vp->sub);
692 }
693
frame_queue_init(FrameQueue * f,PacketQueue * pktq,int max_size,int keep_last)694 static int frame_queue_init(FrameQueue *f, PacketQueue *pktq, int max_size, int keep_last)
695 {
696 int i;
697 memset(f, 0, sizeof(FrameQueue));
698 if (!(f->mutex = SDL_CreateMutex())) {
699 av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
700 return AVERROR(ENOMEM);
701 }
702 if (!(f->cond = SDL_CreateCond())) {
703 av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
704 return AVERROR(ENOMEM);
705 }
706 f->pktq = pktq;
707 f->max_size = FFMIN(max_size, FRAME_QUEUE_SIZE);
708 f->keep_last = !!keep_last;
709 for (i = 0; i < f->max_size; i++)
710 if (!(f->queue[i].frame = av_frame_alloc()))
711 return AVERROR(ENOMEM);
712 return 0;
713 }
714
frame_queue_destory(FrameQueue * f)715 static void frame_queue_destory(FrameQueue *f)
716 {
717 int i;
718 for (i = 0; i < f->max_size; i++) {
719 Frame *vp = &f->queue[i];
720 frame_queue_unref_item(vp);
721 av_frame_free(&vp->frame);
722 }
723 SDL_DestroyMutex(f->mutex);
724 SDL_DestroyCond(f->cond);
725 }
726
frame_queue_signal(FrameQueue * f)727 static void frame_queue_signal(FrameQueue *f)
728 {
729 SDL_LockMutex(f->mutex);
730 SDL_CondSignal(f->cond);
731 SDL_UnlockMutex(f->mutex);
732 }
733
frame_queue_peek(FrameQueue * f)734 static Frame *frame_queue_peek(FrameQueue *f)
735 {
736 return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
737 }
738
frame_queue_peek_next(FrameQueue * f)739 static Frame *frame_queue_peek_next(FrameQueue *f)
740 {
741 return &f->queue[(f->rindex + f->rindex_shown + 1) % f->max_size];
742 }
743
frame_queue_peek_last(FrameQueue * f)744 static Frame *frame_queue_peek_last(FrameQueue *f)
745 {
746 return &f->queue[f->rindex];
747 }
748
frame_queue_peek_writable(FrameQueue * f)749 static Frame *frame_queue_peek_writable(FrameQueue *f)
750 {
751 /* wait until we have space to put a new frame */
752 SDL_LockMutex(f->mutex);
753 while (f->size >= f->max_size &&
754 !f->pktq->abort_request) {
755 SDL_CondWait(f->cond, f->mutex);
756 }
757 SDL_UnlockMutex(f->mutex);
758
759 if (f->pktq->abort_request)
760 return NULL;
761
762 return &f->queue[f->windex];
763 }
764
frame_queue_peek_readable(FrameQueue * f)765 static Frame *frame_queue_peek_readable(FrameQueue *f)
766 {
767 /* wait until we have a readable a new frame */
768 SDL_LockMutex(f->mutex);
769 while (f->size - f->rindex_shown <= 0 &&
770 !f->pktq->abort_request) {
771 SDL_CondWait(f->cond, f->mutex);
772 }
773 SDL_UnlockMutex(f->mutex);
774
775 if (f->pktq->abort_request)
776 return NULL;
777
778 return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
779 }
780
frame_queue_push(FrameQueue * f)781 static void frame_queue_push(FrameQueue *f)
782 {
783 if (++f->windex == f->max_size)
784 f->windex = 0;
785 SDL_LockMutex(f->mutex);
786 f->size++;
787 SDL_CondSignal(f->cond);
788 SDL_UnlockMutex(f->mutex);
789 }
790
frame_queue_next(FrameQueue * f)791 static void frame_queue_next(FrameQueue *f)
792 {
793 if (f->keep_last && !f->rindex_shown) {
794 f->rindex_shown = 1;
795 return;
796 }
797 frame_queue_unref_item(&f->queue[f->rindex]);
798 if (++f->rindex == f->max_size)
799 f->rindex = 0;
800 SDL_LockMutex(f->mutex);
801 f->size--;
802 SDL_CondSignal(f->cond);
803 SDL_UnlockMutex(f->mutex);
804 }
805
806 /* return the number of undisplayed frames in the queue */
frame_queue_nb_remaining(FrameQueue * f)807 static int frame_queue_nb_remaining(FrameQueue *f)
808 {
809 return f->size - f->rindex_shown;
810 }
811
812 /* return last shown position */
frame_queue_last_pos(FrameQueue * f)813 static int64_t frame_queue_last_pos(FrameQueue *f)
814 {
815 Frame *fp = &f->queue[f->rindex];
816 if (f->rindex_shown && fp->serial == f->pktq->serial)
817 return fp->pos;
818 else
819 return -1;
820 }
821
decoder_abort(Decoder * d,FrameQueue * fq)822 static void decoder_abort(Decoder *d, FrameQueue *fq)
823 {
824 packet_queue_abort(d->queue);
825 frame_queue_signal(fq);
826 SDL_WaitThread(d->decoder_tid, NULL);
827 d->decoder_tid = NULL;
828 packet_queue_flush(d->queue);
829 }
830
fill_rectangle(int x,int y,int w,int h)831 static inline void fill_rectangle(int x, int y, int w, int h)
832 {
833 SDL_Rect rect;
834 rect.x = x;
835 rect.y = y;
836 rect.w = w;
837 rect.h = h;
838 if (w && h)
839 SDL_RenderFillRect(renderer, &rect);
840 }
841
realloc_texture(SDL_Texture ** texture,Uint32 new_format,int new_width,int new_height,SDL_BlendMode blendmode,int init_texture)842 static int realloc_texture(SDL_Texture **texture, Uint32 new_format, int new_width, int new_height, SDL_BlendMode blendmode, int init_texture)
843 {
844 Uint32 format;
845 int access, w, h;
846 if (!*texture || SDL_QueryTexture(*texture, &format, &access, &w, &h) < 0 || new_width != w || new_height != h || new_format != format) {
847 void *pixels;
848 int pitch;
849 if (*texture)
850 SDL_DestroyTexture(*texture);
851 if (!(*texture = SDL_CreateTexture(renderer, new_format, SDL_TEXTUREACCESS_STREAMING, new_width, new_height)))
852 return -1;
853 if (SDL_SetTextureBlendMode(*texture, blendmode) < 0)
854 return -1;
855 if (init_texture) {
856 if (SDL_LockTexture(*texture, NULL, &pixels, &pitch) < 0)
857 return -1;
858 memset(pixels, 0, pitch * new_height);
859 SDL_UnlockTexture(*texture);
860 }
861 av_log(NULL, AV_LOG_VERBOSE, "Created %dx%d texture with %s.\n", new_width, new_height, SDL_GetPixelFormatName(new_format));
862 }
863 return 0;
864 }
865
calculate_display_rect(SDL_Rect * rect,int scr_xleft,int scr_ytop,int scr_width,int scr_height,int pic_width,int pic_height,AVRational pic_sar)866 static void calculate_display_rect(SDL_Rect *rect,
867 int scr_xleft, int scr_ytop, int scr_width, int scr_height,
868 int pic_width, int pic_height, AVRational pic_sar)
869 {
870 AVRational aspect_ratio = pic_sar;
871 int64_t width, height, x, y;
872
873 if (av_cmp_q(aspect_ratio, av_make_q(0, 1)) <= 0)
874 aspect_ratio = av_make_q(1, 1);
875
876 aspect_ratio = av_mul_q(aspect_ratio, av_make_q(pic_width, pic_height));
877
878 /* XXX: we suppose the screen has a 1.0 pixel ratio */
879 height = scr_height;
880 width = av_rescale(height, aspect_ratio.num, aspect_ratio.den) & ~1;
881 if (width > scr_width) {
882 width = scr_width;
883 height = av_rescale(width, aspect_ratio.den, aspect_ratio.num) & ~1;
884 }
885 x = (scr_width - width) / 2;
886 y = (scr_height - height) / 2;
887 rect->x = scr_xleft + x;
888 rect->y = scr_ytop + y;
889 rect->w = FFMAX((int)width, 1);
890 rect->h = FFMAX((int)height, 1);
891 }
892
get_sdl_pix_fmt_and_blendmode(int format,Uint32 * sdl_pix_fmt,SDL_BlendMode * sdl_blendmode)893 static void get_sdl_pix_fmt_and_blendmode(int format, Uint32 *sdl_pix_fmt, SDL_BlendMode *sdl_blendmode)
894 {
895 int i;
896 *sdl_blendmode = SDL_BLENDMODE_NONE;
897 *sdl_pix_fmt = SDL_PIXELFORMAT_UNKNOWN;
898 if (format == AV_PIX_FMT_RGB32 ||
899 format == AV_PIX_FMT_RGB32_1 ||
900 format == AV_PIX_FMT_BGR32 ||
901 format == AV_PIX_FMT_BGR32_1)
902 *sdl_blendmode = SDL_BLENDMODE_BLEND;
903 for (i = 0; i < FF_ARRAY_ELEMS(sdl_texture_format_map) - 1; i++) {
904 if (format == sdl_texture_format_map[i].format) {
905 *sdl_pix_fmt = sdl_texture_format_map[i].texture_fmt;
906 return;
907 }
908 }
909 }
910
upload_texture(SDL_Texture ** tex,AVFrame * frame,struct SwsContext ** img_convert_ctx)911 static int upload_texture(SDL_Texture **tex, AVFrame *frame, struct SwsContext **img_convert_ctx) {
912 int ret = 0;
913 Uint32 sdl_pix_fmt;
914 SDL_BlendMode sdl_blendmode;
915 get_sdl_pix_fmt_and_blendmode(frame->format, &sdl_pix_fmt, &sdl_blendmode);
916 if (realloc_texture(tex, sdl_pix_fmt == SDL_PIXELFORMAT_UNKNOWN ? SDL_PIXELFORMAT_ARGB8888 : sdl_pix_fmt, frame->width, frame->height, sdl_blendmode, 0) < 0)
917 return -1;
918 switch (sdl_pix_fmt) {
919 case SDL_PIXELFORMAT_UNKNOWN:
920 /* This should only happen if we are not using avfilter... */
921 *img_convert_ctx = sws_getCachedContext(*img_convert_ctx,
922 frame->width, frame->height, frame->format, frame->width, frame->height,
923 AV_PIX_FMT_BGRA, sws_flags, NULL, NULL, NULL);
924 if (*img_convert_ctx != NULL) {
925 uint8_t *pixels[4];
926 int pitch[4];
927 if (!SDL_LockTexture(*tex, NULL, (void **)pixels, pitch)) {
928 sws_scale(*img_convert_ctx, (const uint8_t * const *)frame->data, frame->linesize,
929 0, frame->height, pixels, pitch);
930 SDL_UnlockTexture(*tex);
931 }
932 } else {
933 av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
934 ret = -1;
935 }
936 break;
937 case SDL_PIXELFORMAT_IYUV:
938 if (frame->linesize[0] > 0 && frame->linesize[1] > 0 && frame->linesize[2] > 0) {
939 ret = SDL_UpdateYUVTexture(*tex, NULL, frame->data[0], frame->linesize[0],
940 frame->data[1], frame->linesize[1],
941 frame->data[2], frame->linesize[2]);
942 } else if (frame->linesize[0] < 0 && frame->linesize[1] < 0 && frame->linesize[2] < 0) {
943 ret = SDL_UpdateYUVTexture(*tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height - 1), -frame->linesize[0],
944 frame->data[1] + frame->linesize[1] * (AV_CEIL_RSHIFT(frame->height, 1) - 1), -frame->linesize[1],
945 frame->data[2] + frame->linesize[2] * (AV_CEIL_RSHIFT(frame->height, 1) - 1), -frame->linesize[2]);
946 } else {
947 av_log(NULL, AV_LOG_ERROR, "Mixed negative and positive linesizes are not supported.\n");
948 return -1;
949 }
950 break;
951 default:
952 if (frame->linesize[0] < 0) {
953 ret = SDL_UpdateTexture(*tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height - 1), -frame->linesize[0]);
954 } else {
955 ret = SDL_UpdateTexture(*tex, NULL, frame->data[0], frame->linesize[0]);
956 }
957 break;
958 }
959 return ret;
960 }
961
set_sdl_yuv_conversion_mode(AVFrame * frame)962 static void set_sdl_yuv_conversion_mode(AVFrame *frame)
963 {
964 #if SDL_VERSION_ATLEAST(2,0,8)
965 SDL_YUV_CONVERSION_MODE mode = SDL_YUV_CONVERSION_AUTOMATIC;
966 if (frame && (frame->format == AV_PIX_FMT_YUV420P || frame->format == AV_PIX_FMT_YUYV422 || frame->format == AV_PIX_FMT_UYVY422)) {
967 if (frame->color_range == AVCOL_RANGE_JPEG)
968 mode = SDL_YUV_CONVERSION_JPEG;
969 else if (frame->colorspace == AVCOL_SPC_BT709)
970 mode = SDL_YUV_CONVERSION_BT709;
971 else if (frame->colorspace == AVCOL_SPC_BT470BG || frame->colorspace == AVCOL_SPC_SMPTE170M || frame->colorspace == AVCOL_SPC_SMPTE240M)
972 mode = SDL_YUV_CONVERSION_BT601;
973 }
974 SDL_SetYUVConversionMode(mode);
975 #endif
976 }
977
video_image_display(VideoState * is)978 static void video_image_display(VideoState *is)
979 {
980 Frame *vp;
981 Frame *sp = NULL;
982 SDL_Rect rect;
983
984 vp = frame_queue_peek_last(&is->pictq);
985 if (is->subtitle_st) {
986 if (frame_queue_nb_remaining(&is->subpq) > 0) {
987 sp = frame_queue_peek(&is->subpq);
988
989 if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {
990 if (!sp->uploaded) {
991 uint8_t* pixels[4];
992 int pitch[4];
993 int i;
994 if (!sp->width || !sp->height) {
995 sp->width = vp->width;
996 sp->height = vp->height;
997 }
998 if (realloc_texture(&is->sub_texture, SDL_PIXELFORMAT_ARGB8888, sp->width, sp->height, SDL_BLENDMODE_BLEND, 1) < 0)
999 return;
1000
1001 for (i = 0; i < sp->sub.num_rects; i++) {
1002 AVSubtitleRect *sub_rect = sp->sub.rects[i];
1003
1004 sub_rect->x = av_clip(sub_rect->x, 0, sp->width );
1005 sub_rect->y = av_clip(sub_rect->y, 0, sp->height);
1006 sub_rect->w = av_clip(sub_rect->w, 0, sp->width - sub_rect->x);
1007 sub_rect->h = av_clip(sub_rect->h, 0, sp->height - sub_rect->y);
1008
1009 is->sub_convert_ctx = sws_getCachedContext(is->sub_convert_ctx,
1010 sub_rect->w, sub_rect->h, AV_PIX_FMT_PAL8,
1011 sub_rect->w, sub_rect->h, AV_PIX_FMT_BGRA,
1012 0, NULL, NULL, NULL);
1013 if (!is->sub_convert_ctx) {
1014 av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
1015 return;
1016 }
1017 if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)pixels, pitch)) {
1018 sws_scale(is->sub_convert_ctx, (const uint8_t * const *)sub_rect->data, sub_rect->linesize,
1019 0, sub_rect->h, pixels, pitch);
1020 SDL_UnlockTexture(is->sub_texture);
1021 }
1022 }
1023 sp->uploaded = 1;
1024 }
1025 } else
1026 sp = NULL;
1027 }
1028 }
1029
1030 calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp->width, vp->height, vp->sar);
1031
1032 if (!vp->uploaded) {
1033 if (upload_texture(&is->vid_texture, vp->frame, &is->img_convert_ctx) < 0)
1034 return;
1035 vp->uploaded = 1;
1036 vp->flip_v = vp->frame->linesize[0] < 0;
1037 }
1038
1039 set_sdl_yuv_conversion_mode(vp->frame);
1040 SDL_RenderCopyEx(renderer, is->vid_texture, NULL, &rect, 0, NULL, vp->flip_v ? SDL_FLIP_VERTICAL : 0);
1041 set_sdl_yuv_conversion_mode(NULL);
1042 if (sp) {
1043 #if USE_ONEPASS_SUBTITLE_RENDER
1044 SDL_RenderCopy(renderer, is->sub_texture, NULL, &rect);
1045 #else
1046 int i;
1047 double xratio = (double)rect.w / (double)sp->width;
1048 double yratio = (double)rect.h / (double)sp->height;
1049 for (i = 0; i < sp->sub.num_rects; i++) {
1050 SDL_Rect *sub_rect = (SDL_Rect*)sp->sub.rects[i];
1051 SDL_Rect target = {.x = rect.x + sub_rect->x * xratio,
1052 .y = rect.y + sub_rect->y * yratio,
1053 .w = sub_rect->w * xratio,
1054 .h = sub_rect->h * yratio};
1055 SDL_RenderCopy(renderer, is->sub_texture, sub_rect, &target);
1056 }
1057 #endif
1058 }
1059 }
1060
compute_mod(int a,int b)1061 static inline int compute_mod(int a, int b)
1062 {
1063 return a < 0 ? a%b + b : a%b;
1064 }
1065
video_audio_display(VideoState * s)1066 static void video_audio_display(VideoState *s)
1067 {
1068 int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
1069 int ch, channels, h, h2;
1070 int64_t time_diff;
1071 int rdft_bits, nb_freq;
1072
1073 for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++)
1074 ;
1075 nb_freq = 1 << (rdft_bits - 1);
1076
1077 /* compute display index : center on currently output samples */
1078 channels = s->audio_tgt.channels;
1079 nb_display_channels = channels;
1080 if (!s->paused) {
1081 int data_used= s->show_mode == SHOW_MODE_WAVES ? s->width : (2*nb_freq);
1082 n = 2 * channels;
1083 delay = s->audio_write_buf_size;
1084 delay /= n;
1085
1086 /* to be more precise, we take into account the time spent since
1087 the last buffer computation */
1088 if (audio_callback_time) {
1089 time_diff = av_gettime_relative() - audio_callback_time;
1090 delay -= (time_diff * s->audio_tgt.freq) / 1000000;
1091 }
1092
1093 delay += 2 * data_used;
1094 if (delay < data_used)
1095 delay = data_used;
1096
1097 i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
1098 if (s->show_mode == SHOW_MODE_WAVES) {
1099 h = INT_MIN;
1100 for (i = 0; i < 1000; i += channels) {
1101 int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
1102 int a = s->sample_array[idx];
1103 int b = s->sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];
1104 int c = s->sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];
1105 int d = s->sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];
1106 int score = a - d;
1107 if (h < score && (b ^ c) < 0) {
1108 h = score;
1109 i_start = idx;
1110 }
1111 }
1112 }
1113
1114 s->last_i_start = i_start;
1115 } else {
1116 i_start = s->last_i_start;
1117 }
1118
1119 if (s->show_mode == SHOW_MODE_WAVES) {
1120 SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
1121
1122 /* total height for one channel */
1123 h = s->height / nb_display_channels;
1124 /* graph height / 2 */
1125 h2 = (h * 9) / 20;
1126 for (ch = 0; ch < nb_display_channels; ch++) {
1127 i = i_start + ch;
1128 y1 = s->ytop + ch * h + (h / 2); /* position of center line */
1129 for (x = 0; x < s->width; x++) {
1130 y = (s->sample_array[i] * h2) >> 15;
1131 if (y < 0) {
1132 y = -y;
1133 ys = y1 - y;
1134 } else {
1135 ys = y1;
1136 }
1137 fill_rectangle(s->xleft + x, ys, 1, y);
1138 i += channels;
1139 if (i >= SAMPLE_ARRAY_SIZE)
1140 i -= SAMPLE_ARRAY_SIZE;
1141 }
1142 }
1143
1144 SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255);
1145
1146 for (ch = 1; ch < nb_display_channels; ch++) {
1147 y = s->ytop + ch * h;
1148 fill_rectangle(s->xleft, y, s->width, 1);
1149 }
1150 } else {
1151 if (realloc_texture(&s->vis_texture, SDL_PIXELFORMAT_ARGB8888, s->width, s->height, SDL_BLENDMODE_NONE, 1) < 0)
1152 return;
1153
1154 nb_display_channels= FFMIN(nb_display_channels, 2);
1155 if (rdft_bits != s->rdft_bits) {
1156 av_rdft_end(s->rdft);
1157 av_free(s->rdft_data);
1158 s->rdft = av_rdft_init(rdft_bits, DFT_R2C);
1159 s->rdft_bits = rdft_bits;
1160 s->rdft_data = av_malloc_array(nb_freq, 4 *sizeof(*s->rdft_data));
1161 }
1162 if (!s->rdft || !s->rdft_data){
1163 av_log(NULL, AV_LOG_ERROR, "Failed to allocate buffers for RDFT, switching to waves display\n");
1164 s->show_mode = SHOW_MODE_WAVES;
1165 } else {
1166 FFTSample *data[2];
1167 SDL_Rect rect = {.x = s->xpos, .y = 0, .w = 1, .h = s->height};
1168 uint32_t *pixels;
1169 int pitch;
1170 for (ch = 0; ch < nb_display_channels; ch++) {
1171 data[ch] = s->rdft_data + 2 * nb_freq * ch;
1172 i = i_start + ch;
1173 for (x = 0; x < 2 * nb_freq; x++) {
1174 double w = (x-nb_freq) * (1.0 / nb_freq);
1175 data[ch][x] = s->sample_array[i] * (1.0 - w * w);
1176 i += channels;
1177 if (i >= SAMPLE_ARRAY_SIZE)
1178 i -= SAMPLE_ARRAY_SIZE;
1179 }
1180 av_rdft_calc(s->rdft, data[ch]);
1181 }
1182 /* Least efficient way to do this, we should of course
1183 * directly access it but it is more than fast enough. */
1184 if (!SDL_LockTexture(s->vis_texture, &rect, (void **)&pixels, &pitch)) {
1185 pitch >>= 2;
1186 pixels += pitch * s->height;
1187 for (y = 0; y < s->height; y++) {
1188 double w = 1 / sqrt(nb_freq);
1189 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]));
1190 int b = (nb_display_channels == 2 ) ? sqrt(w * hypot(data[1][2 * y + 0], data[1][2 * y + 1]))
1191 : a;
1192 a = FFMIN(a, 255);
1193 b = FFMIN(b, 255);
1194 pixels -= pitch;
1195 *pixels = (a << 16) + (b << 8) + ((a+b) >> 1);
1196 }
1197 SDL_UnlockTexture(s->vis_texture);
1198 }
1199 SDL_RenderCopy(renderer, s->vis_texture, NULL, NULL);
1200 }
1201 if (!s->paused)
1202 s->xpos++;
1203 if (s->xpos >= s->width)
1204 s->xpos= s->xleft;
1205 }
1206 }
1207
stream_component_close(VideoState * is,int stream_index)1208 static void stream_component_close(VideoState *is, int stream_index)
1209 {
1210 AVFormatContext *ic = is->ic;
1211 AVCodecParameters *codecpar;
1212
1213 if (stream_index < 0 || stream_index >= ic->nb_streams)
1214 return;
1215 codecpar = ic->streams[stream_index]->codecpar;
1216
1217 switch (codecpar->codec_type) {
1218 case AVMEDIA_TYPE_AUDIO:
1219 decoder_abort(&is->auddec, &is->sampq);
1220 SDL_CloseAudioDevice(audio_dev);
1221 decoder_destroy(&is->auddec);
1222 swr_free(&is->swr_ctx);
1223 av_freep(&is->audio_buf1);
1224 is->audio_buf1_size = 0;
1225 is->audio_buf = NULL;
1226
1227 if (is->rdft) {
1228 av_rdft_end(is->rdft);
1229 av_freep(&is->rdft_data);
1230 is->rdft = NULL;
1231 is->rdft_bits = 0;
1232 }
1233 break;
1234 case AVMEDIA_TYPE_VIDEO:
1235 decoder_abort(&is->viddec, &is->pictq);
1236 decoder_destroy(&is->viddec);
1237 break;
1238 case AVMEDIA_TYPE_SUBTITLE:
1239 decoder_abort(&is->subdec, &is->subpq);
1240 decoder_destroy(&is->subdec);
1241 break;
1242 default:
1243 break;
1244 }
1245
1246 ic->streams[stream_index]->discard = AVDISCARD_ALL;
1247 switch (codecpar->codec_type) {
1248 case AVMEDIA_TYPE_AUDIO:
1249 is->audio_st = NULL;
1250 is->audio_stream = -1;
1251 break;
1252 case AVMEDIA_TYPE_VIDEO:
1253 is->video_st = NULL;
1254 is->video_stream = -1;
1255 break;
1256 case AVMEDIA_TYPE_SUBTITLE:
1257 is->subtitle_st = NULL;
1258 is->subtitle_stream = -1;
1259 break;
1260 default:
1261 break;
1262 }
1263 }
1264
stream_close(VideoState * is)1265 static void stream_close(VideoState *is)
1266 {
1267 /* XXX: use a special url_shutdown call to abort parse cleanly */
1268 is->abort_request = 1;
1269 SDL_WaitThread(is->read_tid, NULL);
1270
1271 /* close each stream */
1272 if (is->audio_stream >= 0)
1273 stream_component_close(is, is->audio_stream);
1274 if (is->video_stream >= 0)
1275 stream_component_close(is, is->video_stream);
1276 if (is->subtitle_stream >= 0)
1277 stream_component_close(is, is->subtitle_stream);
1278
1279 avformat_close_input(&is->ic);
1280
1281 packet_queue_destroy(&is->videoq);
1282 packet_queue_destroy(&is->audioq);
1283 packet_queue_destroy(&is->subtitleq);
1284
1285 /* free all pictures */
1286 frame_queue_destory(&is->pictq);
1287 frame_queue_destory(&is->sampq);
1288 frame_queue_destory(&is->subpq);
1289 SDL_DestroyCond(is->continue_read_thread);
1290 sws_freeContext(is->img_convert_ctx);
1291 sws_freeContext(is->sub_convert_ctx);
1292 av_free(is->filename);
1293 if (is->vis_texture)
1294 SDL_DestroyTexture(is->vis_texture);
1295 if (is->vid_texture)
1296 SDL_DestroyTexture(is->vid_texture);
1297 if (is->sub_texture)
1298 SDL_DestroyTexture(is->sub_texture);
1299 av_free(is);
1300 }
1301
do_exit(VideoState * is)1302 static void do_exit(VideoState *is)
1303 {
1304 if (is) {
1305 stream_close(is);
1306 }
1307 if (renderer)
1308 SDL_DestroyRenderer(renderer);
1309 if (window)
1310 SDL_DestroyWindow(window);
1311 uninit_opts();
1312 #if CONFIG_AVFILTER
1313 av_freep(&vfilters_list);
1314 #endif
1315 avformat_network_deinit();
1316 if (show_status)
1317 printf("\n");
1318 SDL_Quit();
1319 av_log(NULL, AV_LOG_QUIET, "%s", "");
1320 exit(0);
1321 }
1322
sigterm_handler(int sig)1323 static void sigterm_handler(int sig)
1324 {
1325 exit(123);
1326 }
1327
set_default_window_size(int width,int height,AVRational sar)1328 static void set_default_window_size(int width, int height, AVRational sar)
1329 {
1330 SDL_Rect rect;
1331 int max_width = screen_width ? screen_width : INT_MAX;
1332 int max_height = screen_height ? screen_height : INT_MAX;
1333 if (max_width == INT_MAX && max_height == INT_MAX)
1334 max_height = height;
1335 calculate_display_rect(&rect, 0, 0, max_width, max_height, width, height, sar);
1336 default_width = rect.w;
1337 default_height = rect.h;
1338 }
1339
video_open(VideoState * is)1340 static int video_open(VideoState *is)
1341 {
1342 int w,h;
1343
1344 w = screen_width ? screen_width : default_width;
1345 h = screen_height ? screen_height : default_height;
1346
1347 if (!window_title)
1348 window_title = input_filename;
1349 SDL_SetWindowTitle(window, window_title);
1350
1351 SDL_SetWindowSize(window, w, h);
1352 SDL_SetWindowPosition(window, screen_left, screen_top);
1353 if (is_full_screen)
1354 SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
1355 SDL_ShowWindow(window);
1356
1357 is->width = w;
1358 is->height = h;
1359
1360 return 0;
1361 }
1362
1363 /* display the current picture, if any */
video_display(VideoState * is)1364 static void video_display(VideoState *is)
1365 {
1366 if (!is->width)
1367 video_open(is);
1368
1369 SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
1370 SDL_RenderClear(renderer);
1371 if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
1372 video_audio_display(is);
1373 else if (is->video_st)
1374 video_image_display(is);
1375 SDL_RenderPresent(renderer);
1376 }
1377
get_clock(Clock * c)1378 static double get_clock(Clock *c)
1379 {
1380 if (*c->queue_serial != c->serial)
1381 return NAN;
1382 if (c->paused) {
1383 return c->pts;
1384 } else {
1385 double time = av_gettime_relative() / 1000000.0;
1386 return c->pts_drift + time - (time - c->last_updated) * (1.0 - c->speed);
1387 }
1388 }
1389
set_clock_at(Clock * c,double pts,int serial,double time)1390 static void set_clock_at(Clock *c, double pts, int serial, double time)
1391 {
1392 c->pts = pts;
1393 c->last_updated = time;
1394 c->pts_drift = c->pts - time;
1395 c->serial = serial;
1396 }
1397
set_clock(Clock * c,double pts,int serial)1398 static void set_clock(Clock *c, double pts, int serial)
1399 {
1400 double time = av_gettime_relative() / 1000000.0;
1401 set_clock_at(c, pts, serial, time);
1402 }
1403
set_clock_speed(Clock * c,double speed)1404 static void set_clock_speed(Clock *c, double speed)
1405 {
1406 set_clock(c, get_clock(c), c->serial);
1407 c->speed = speed;
1408 }
1409
init_clock(Clock * c,int * queue_serial)1410 static void init_clock(Clock *c, int *queue_serial)
1411 {
1412 c->speed = 1.0;
1413 c->paused = 0;
1414 c->queue_serial = queue_serial;
1415 set_clock(c, NAN, -1);
1416 }
1417
sync_clock_to_slave(Clock * c,Clock * slave)1418 static void sync_clock_to_slave(Clock *c, Clock *slave)
1419 {
1420 double clock = get_clock(c);
1421 double slave_clock = get_clock(slave);
1422 if (!isnan(slave_clock) && (isnan(clock) || fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))
1423 set_clock(c, slave_clock, slave->serial);
1424 }
1425
get_master_sync_type(VideoState * is)1426 static int get_master_sync_type(VideoState *is) {
1427 if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
1428 if (is->video_st)
1429 return AV_SYNC_VIDEO_MASTER;
1430 else
1431 return AV_SYNC_AUDIO_MASTER;
1432 } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
1433 if (is->audio_st)
1434 return AV_SYNC_AUDIO_MASTER;
1435 else
1436 return AV_SYNC_EXTERNAL_CLOCK;
1437 } else {
1438 return AV_SYNC_EXTERNAL_CLOCK;
1439 }
1440 }
1441
1442 /* get the current master clock value */
get_master_clock(VideoState * is)1443 static double get_master_clock(VideoState *is)
1444 {
1445 double val;
1446
1447 switch (get_master_sync_type(is)) {
1448 case AV_SYNC_VIDEO_MASTER:
1449 val = get_clock(&is->vidclk);
1450 break;
1451 case AV_SYNC_AUDIO_MASTER:
1452 val = get_clock(&is->audclk);
1453 break;
1454 default:
1455 val = get_clock(&is->extclk);
1456 break;
1457 }
1458 return val;
1459 }
1460
check_external_clock_speed(VideoState * is)1461 static void check_external_clock_speed(VideoState *is) {
1462 if (is->video_stream >= 0 && is->videoq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES ||
1463 is->audio_stream >= 0 && is->audioq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES) {
1464 set_clock_speed(&is->extclk, FFMAX(EXTERNAL_CLOCK_SPEED_MIN, is->extclk.speed - EXTERNAL_CLOCK_SPEED_STEP));
1465 } else if ((is->video_stream < 0 || is->videoq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES) &&
1466 (is->audio_stream < 0 || is->audioq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES)) {
1467 set_clock_speed(&is->extclk, FFMIN(EXTERNAL_CLOCK_SPEED_MAX, is->extclk.speed + EXTERNAL_CLOCK_SPEED_STEP));
1468 } else {
1469 double speed = is->extclk.speed;
1470 if (speed != 1.0)
1471 set_clock_speed(&is->extclk, speed + EXTERNAL_CLOCK_SPEED_STEP * (1.0 - speed) / fabs(1.0 - speed));
1472 }
1473 }
1474
1475 /* seek in the stream */
stream_seek(VideoState * is,int64_t pos,int64_t rel,int seek_by_bytes)1476 static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)
1477 {
1478 if (!is->seek_req) {
1479 is->seek_pos = pos;
1480 is->seek_rel = rel;
1481 is->seek_flags &= ~AVSEEK_FLAG_BYTE;
1482 if (seek_by_bytes)
1483 is->seek_flags |= AVSEEK_FLAG_BYTE;
1484 is->seek_req = 1;
1485 SDL_CondSignal(is->continue_read_thread);
1486 }
1487 }
1488
1489 /* pause or resume the video */
stream_toggle_pause(VideoState * is)1490 static void stream_toggle_pause(VideoState *is)
1491 {
1492 if (is->paused) {
1493 is->frame_timer += av_gettime_relative() / 1000000.0 - is->vidclk.last_updated;
1494 if (is->read_pause_return != AVERROR(ENOSYS)) {
1495 is->vidclk.paused = 0;
1496 }
1497 set_clock(&is->vidclk, get_clock(&is->vidclk), is->vidclk.serial);
1498 }
1499 set_clock(&is->extclk, get_clock(&is->extclk), is->extclk.serial);
1500 is->paused = is->audclk.paused = is->vidclk.paused = is->extclk.paused = !is->paused;
1501 }
1502
toggle_pause(VideoState * is)1503 static void toggle_pause(VideoState *is)
1504 {
1505 stream_toggle_pause(is);
1506 is->step = 0;
1507 }
1508
toggle_mute(VideoState * is)1509 static void toggle_mute(VideoState *is)
1510 {
1511 is->muted = !is->muted;
1512 }
1513
update_volume(VideoState * is,int sign,double step)1514 static void update_volume(VideoState *is, int sign, double step)
1515 {
1516 double volume_level = is->audio_volume ? (20 * log(is->audio_volume / (double)SDL_MIX_MAXVOLUME) / log(10)) : -1000.0;
1517 int new_volume = lrint(SDL_MIX_MAXVOLUME * pow(10.0, (volume_level + sign * step) / 20.0));
1518 is->audio_volume = av_clip(is->audio_volume == new_volume ? (is->audio_volume + sign) : new_volume, 0, SDL_MIX_MAXVOLUME);
1519 }
1520
step_to_next_frame(VideoState * is)1521 static void step_to_next_frame(VideoState *is)
1522 {
1523 /* if the stream is paused unpause it, then step */
1524 if (is->paused)
1525 stream_toggle_pause(is);
1526 is->step = 1;
1527 }
1528
compute_target_delay(double delay,VideoState * is)1529 static double compute_target_delay(double delay, VideoState *is)
1530 {
1531 double sync_threshold, diff = 0;
1532
1533 /* update delay to follow master synchronisation source */
1534 if (get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER) {
1535 /* if video is slave, we try to correct big delays by
1536 duplicating or deleting a frame */
1537 diff = get_clock(&is->vidclk) - get_master_clock(is);
1538
1539 /* skip or repeat frame. We take into account the
1540 delay to compute the threshold. I still don't know
1541 if it is the best guess */
1542 sync_threshold = FFMAX(AV_SYNC_THRESHOLD_MIN, FFMIN(AV_SYNC_THRESHOLD_MAX, delay));
1543 if (!isnan(diff) && fabs(diff) < is->max_frame_duration) {
1544 if (diff <= -sync_threshold)
1545 delay = FFMAX(0, delay + diff);
1546 else if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD)
1547 delay = delay + diff;
1548 else if (diff >= sync_threshold)
1549 delay = 2 * delay;
1550 }
1551 }
1552
1553 av_log(NULL, AV_LOG_TRACE, "video: delay=%0.3f A-V=%f\n",
1554 delay, -diff);
1555
1556 return delay;
1557 }
1558
vp_duration(VideoState * is,Frame * vp,Frame * nextvp)1559 static double vp_duration(VideoState *is, Frame *vp, Frame *nextvp) {
1560 if (vp->serial == nextvp->serial) {
1561 double duration = nextvp->pts - vp->pts;
1562 if (isnan(duration) || duration <= 0 || duration > is->max_frame_duration)
1563 return vp->duration;
1564 else
1565 return duration;
1566 } else {
1567 return 0.0;
1568 }
1569 }
1570
update_video_pts(VideoState * is,double pts,int64_t pos,int serial)1571 static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
1572 /* update current video pts */
1573 set_clock(&is->vidclk, pts, serial);
1574 sync_clock_to_slave(&is->extclk, &is->vidclk);
1575 }
1576
1577 /* called to display each frame */
video_refresh(void * opaque,double * remaining_time)1578 static void video_refresh(void *opaque, double *remaining_time)
1579 {
1580 VideoState *is = opaque;
1581 double time;
1582
1583 Frame *sp, *sp2;
1584
1585 if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
1586 check_external_clock_speed(is);
1587
1588 if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {
1589 time = av_gettime_relative() / 1000000.0;
1590 if (is->force_refresh || is->last_vis_time + rdftspeed < time) {
1591 video_display(is);
1592 is->last_vis_time = time;
1593 }
1594 *remaining_time = FFMIN(*remaining_time, is->last_vis_time + rdftspeed - time);
1595 }
1596
1597 if (is->video_st) {
1598 retry:
1599 if (frame_queue_nb_remaining(&is->pictq) == 0) {
1600 // nothing to do, no picture to display in the queue
1601 } else {
1602 double last_duration, duration, delay;
1603 Frame *vp, *lastvp;
1604
1605 /* dequeue the picture */
1606 lastvp = frame_queue_peek_last(&is->pictq);
1607 vp = frame_queue_peek(&is->pictq);
1608
1609 if (vp->serial != is->videoq.serial) {
1610 frame_queue_next(&is->pictq);
1611 goto retry;
1612 }
1613
1614 if (lastvp->serial != vp->serial)
1615 is->frame_timer = av_gettime_relative() / 1000000.0;
1616
1617 if (is->paused)
1618 goto display;
1619
1620 /* compute nominal last_duration */
1621 last_duration = vp_duration(is, lastvp, vp);
1622 delay = compute_target_delay(last_duration, is);
1623
1624 time= av_gettime_relative()/1000000.0;
1625 if (time < is->frame_timer + delay) {
1626 *remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);
1627 goto display;
1628 }
1629
1630 is->frame_timer += delay;
1631 if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)
1632 is->frame_timer = time;
1633
1634 SDL_LockMutex(is->pictq.mutex);
1635 if (!isnan(vp->pts))
1636 update_video_pts(is, vp->pts, vp->pos, vp->serial);
1637 SDL_UnlockMutex(is->pictq.mutex);
1638
1639 if (frame_queue_nb_remaining(&is->pictq) > 1) {
1640 Frame *nextvp = frame_queue_peek_next(&is->pictq);
1641 duration = vp_duration(is, vp, nextvp);
1642 if(!is->step && (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
1643 is->frame_drops_late++;
1644 frame_queue_next(&is->pictq);
1645 goto retry;
1646 }
1647 }
1648
1649 if (is->subtitle_st) {
1650 while (frame_queue_nb_remaining(&is->subpq) > 0) {
1651 sp = frame_queue_peek(&is->subpq);
1652
1653 if (frame_queue_nb_remaining(&is->subpq) > 1)
1654 sp2 = frame_queue_peek_next(&is->subpq);
1655 else
1656 sp2 = NULL;
1657
1658 if (sp->serial != is->subtitleq.serial
1659 || (is->vidclk.pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1660 || (sp2 && is->vidclk.pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1661 {
1662 if (sp->uploaded) {
1663 int i;
1664 for (i = 0; i < sp->sub.num_rects; i++) {
1665 AVSubtitleRect *sub_rect = sp->sub.rects[i];
1666 uint8_t *pixels;
1667 int pitch, j;
1668
1669 if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)&pixels, &pitch)) {
1670 for (j = 0; j < sub_rect->h; j++, pixels += pitch)
1671 memset(pixels, 0, sub_rect->w << 2);
1672 SDL_UnlockTexture(is->sub_texture);
1673 }
1674 }
1675 }
1676 frame_queue_next(&is->subpq);
1677 } else {
1678 break;
1679 }
1680 }
1681 }
1682
1683 frame_queue_next(&is->pictq);
1684 is->force_refresh = 1;
1685
1686 if (is->step && !is->paused)
1687 stream_toggle_pause(is);
1688 }
1689 display:
1690 /* display picture */
1691 if (!display_disable && is->force_refresh && is->show_mode == SHOW_MODE_VIDEO && is->pictq.rindex_shown)
1692 video_display(is);
1693 }
1694 is->force_refresh = 0;
1695 if (show_status) {
1696 AVBPrint buf;
1697 static int64_t last_time;
1698 int64_t cur_time;
1699 int aqsize, vqsize, sqsize;
1700 double av_diff;
1701
1702 cur_time = av_gettime_relative();
1703 if (!last_time || (cur_time - last_time) >= 30000) {
1704 aqsize = 0;
1705 vqsize = 0;
1706 sqsize = 0;
1707 if (is->audio_st)
1708 aqsize = is->audioq.size;
1709 if (is->video_st)
1710 vqsize = is->videoq.size;
1711 if (is->subtitle_st)
1712 sqsize = is->subtitleq.size;
1713 av_diff = 0;
1714 if (is->audio_st && is->video_st)
1715 av_diff = get_clock(&is->audclk) - get_clock(&is->vidclk);
1716 else if (is->video_st)
1717 av_diff = get_master_clock(is) - get_clock(&is->vidclk);
1718 else if (is->audio_st)
1719 av_diff = get_master_clock(is) - get_clock(&is->audclk);
1720
1721 av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
1722 av_bprintf(&buf,
1723 "%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64" \r",
1724 get_master_clock(is),
1725 (is->audio_st && is->video_st) ? "A-V" : (is->video_st ? "M-V" : (is->audio_st ? "M-A" : " ")),
1726 av_diff,
1727 is->frame_drops_early + is->frame_drops_late,
1728 aqsize / 1024,
1729 vqsize / 1024,
1730 sqsize,
1731 is->video_st ? is->viddec.avctx->pts_correction_num_faulty_dts : 0,
1732 is->video_st ? is->viddec.avctx->pts_correction_num_faulty_pts : 0);
1733
1734 if (show_status == 1 && AV_LOG_INFO > av_log_get_level())
1735 fprintf(stderr, "%s", buf.str);
1736 else
1737 av_log(NULL, AV_LOG_INFO, "%s", buf.str);
1738
1739 fflush(stderr);
1740 av_bprint_finalize(&buf, NULL);
1741
1742 last_time = cur_time;
1743 }
1744 }
1745 }
1746
queue_picture(VideoState * is,AVFrame * src_frame,double pts,double duration,int64_t pos,int serial)1747 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, double duration, int64_t pos, int serial)
1748 {
1749 Frame *vp;
1750
1751 #if defined(DEBUG_SYNC)
1752 printf("frame_type=%c pts=%0.3f\n",
1753 av_get_picture_type_char(src_frame->pict_type), pts);
1754 #endif
1755
1756 if (!(vp = frame_queue_peek_writable(&is->pictq)))
1757 return -1;
1758
1759 vp->sar = src_frame->sample_aspect_ratio;
1760 vp->uploaded = 0;
1761
1762 vp->width = src_frame->width;
1763 vp->height = src_frame->height;
1764 vp->format = src_frame->format;
1765
1766 vp->pts = pts;
1767 vp->duration = duration;
1768 vp->pos = pos;
1769 vp->serial = serial;
1770
1771 set_default_window_size(vp->width, vp->height, vp->sar);
1772
1773 av_frame_move_ref(vp->frame, src_frame);
1774 frame_queue_push(&is->pictq);
1775 return 0;
1776 }
1777
get_video_frame(VideoState * is,AVFrame * frame)1778 static int get_video_frame(VideoState *is, AVFrame *frame)
1779 {
1780 int got_picture;
1781
1782 if ((got_picture = decoder_decode_frame(&is->viddec, frame, NULL)) < 0)
1783 return -1;
1784
1785 if (got_picture) {
1786 double dpts = NAN;
1787
1788 if (frame->pts != AV_NOPTS_VALUE)
1789 dpts = av_q2d(is->video_st->time_base) * frame->pts;
1790
1791 frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
1792
1793 if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
1794 if (frame->pts != AV_NOPTS_VALUE) {
1795 double diff = dpts - get_master_clock(is);
1796 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD &&
1797 diff - is->frame_last_filter_delay < 0 &&
1798 is->viddec.pkt_serial == is->vidclk.serial &&
1799 is->videoq.nb_packets) {
1800 is->frame_drops_early++;
1801 av_frame_unref(frame);
1802 got_picture = 0;
1803 }
1804 }
1805 }
1806 }
1807
1808 return got_picture;
1809 }
1810
1811 #if CONFIG_AVFILTER
configure_filtergraph(AVFilterGraph * graph,const char * filtergraph,AVFilterContext * source_ctx,AVFilterContext * sink_ctx)1812 static int configure_filtergraph(AVFilterGraph *graph, const char *filtergraph,
1813 AVFilterContext *source_ctx, AVFilterContext *sink_ctx)
1814 {
1815 int ret, i;
1816 int nb_filters = graph->nb_filters;
1817 AVFilterInOut *outputs = NULL, *inputs = NULL;
1818
1819 if (filtergraph) {
1820 outputs = avfilter_inout_alloc();
1821 inputs = avfilter_inout_alloc();
1822 if (!outputs || !inputs) {
1823 ret = AVERROR(ENOMEM);
1824 goto fail;
1825 }
1826
1827 outputs->name = av_strdup("in");
1828 outputs->filter_ctx = source_ctx;
1829 outputs->pad_idx = 0;
1830 outputs->next = NULL;
1831
1832 inputs->name = av_strdup("out");
1833 inputs->filter_ctx = sink_ctx;
1834 inputs->pad_idx = 0;
1835 inputs->next = NULL;
1836
1837 if ((ret = avfilter_graph_parse_ptr(graph, filtergraph, &inputs, &outputs, NULL)) < 0)
1838 goto fail;
1839 } else {
1840 if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
1841 goto fail;
1842 }
1843
1844 /* Reorder the filters to ensure that inputs of the custom filters are merged first */
1845 for (i = 0; i < graph->nb_filters - nb_filters; i++)
1846 FFSWAP(AVFilterContext*, graph->filters[i], graph->filters[i + nb_filters]);
1847
1848 ret = avfilter_graph_config(graph, NULL);
1849 fail:
1850 avfilter_inout_free(&outputs);
1851 avfilter_inout_free(&inputs);
1852 return ret;
1853 }
1854
configure_video_filters(AVFilterGraph * graph,VideoState * is,const char * vfilters,AVFrame * frame)1855 static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const char *vfilters, AVFrame *frame)
1856 {
1857 enum AVPixelFormat pix_fmts[FF_ARRAY_ELEMS(sdl_texture_format_map)];
1858 char sws_flags_str[512] = "";
1859 char buffersrc_args[256];
1860 int ret;
1861 AVFilterContext *filt_src = NULL, *filt_out = NULL, *last_filter = NULL;
1862 AVCodecParameters *codecpar = is->video_st->codecpar;
1863 AVRational fr = av_guess_frame_rate(is->ic, is->video_st, NULL);
1864 AVDictionaryEntry *e = NULL;
1865 int nb_pix_fmts = 0;
1866 int i, j;
1867
1868 for (i = 0; i < renderer_info.num_texture_formats; i++) {
1869 for (j = 0; j < FF_ARRAY_ELEMS(sdl_texture_format_map) - 1; j++) {
1870 if (renderer_info.texture_formats[i] == sdl_texture_format_map[j].texture_fmt) {
1871 pix_fmts[nb_pix_fmts++] = sdl_texture_format_map[j].format;
1872 break;
1873 }
1874 }
1875 }
1876 pix_fmts[nb_pix_fmts] = AV_PIX_FMT_NONE;
1877
1878 while ((e = av_dict_get(sws_dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
1879 if (!strcmp(e->key, "sws_flags")) {
1880 av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", "flags", e->value);
1881 } else
1882 av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", e->key, e->value);
1883 }
1884 if (strlen(sws_flags_str))
1885 sws_flags_str[strlen(sws_flags_str)-1] = '\0';
1886
1887 graph->scale_sws_opts = av_strdup(sws_flags_str);
1888
1889 snprintf(buffersrc_args, sizeof(buffersrc_args),
1890 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
1891 frame->width, frame->height, frame->format,
1892 is->video_st->time_base.num, is->video_st->time_base.den,
1893 codecpar->sample_aspect_ratio.num, FFMAX(codecpar->sample_aspect_ratio.den, 1));
1894 if (fr.num && fr.den)
1895 av_strlcatf(buffersrc_args, sizeof(buffersrc_args), ":frame_rate=%d/%d", fr.num, fr.den);
1896
1897 if ((ret = avfilter_graph_create_filter(&filt_src,
1898 avfilter_get_by_name("buffer"),
1899 "ffplay_buffer", buffersrc_args, NULL,
1900 graph)) < 0)
1901 goto fail;
1902
1903 ret = avfilter_graph_create_filter(&filt_out,
1904 avfilter_get_by_name("buffersink"),
1905 "ffplay_buffersink", NULL, NULL, graph);
1906 if (ret < 0)
1907 goto fail;
1908
1909 if ((ret = av_opt_set_int_list(filt_out, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1910 goto fail;
1911
1912 last_filter = filt_out;
1913
1914 /* Note: this macro adds a filter before the lastly added filter, so the
1915 * processing order of the filters is in reverse */
1916 #define INSERT_FILT(name, arg) do { \
1917 AVFilterContext *filt_ctx; \
1918 \
1919 ret = avfilter_graph_create_filter(&filt_ctx, \
1920 avfilter_get_by_name(name), \
1921 "ffplay_" name, arg, NULL, graph); \
1922 if (ret < 0) \
1923 goto fail; \
1924 \
1925 ret = avfilter_link(filt_ctx, 0, last_filter, 0); \
1926 if (ret < 0) \
1927 goto fail; \
1928 \
1929 last_filter = filt_ctx; \
1930 } while (0)
1931
1932 if (autorotate) {
1933 double theta = get_rotation(is->video_st);
1934
1935 if (fabs(theta - 90) < 1.0) {
1936 INSERT_FILT("transpose", "clock");
1937 } else if (fabs(theta - 180) < 1.0) {
1938 INSERT_FILT("hflip", NULL);
1939 INSERT_FILT("vflip", NULL);
1940 } else if (fabs(theta - 270) < 1.0) {
1941 INSERT_FILT("transpose", "cclock");
1942 } else if (fabs(theta) > 1.0) {
1943 char rotate_buf[64];
1944 snprintf(rotate_buf, sizeof(rotate_buf), "%f*PI/180", theta);
1945 INSERT_FILT("rotate", rotate_buf);
1946 }
1947 }
1948
1949 if ((ret = configure_filtergraph(graph, vfilters, filt_src, last_filter)) < 0)
1950 goto fail;
1951
1952 is->in_video_filter = filt_src;
1953 is->out_video_filter = filt_out;
1954
1955 fail:
1956 return ret;
1957 }
1958
configure_audio_filters(VideoState * is,const char * afilters,int force_output_format)1959 static int configure_audio_filters(VideoState *is, const char *afilters, int force_output_format)
1960 {
1961 static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
1962 int sample_rates[2] = { 0, -1 };
1963 int64_t channel_layouts[2] = { 0, -1 };
1964 int channels[2] = { 0, -1 };
1965 AVFilterContext *filt_asrc = NULL, *filt_asink = NULL;
1966 char aresample_swr_opts[512] = "";
1967 AVDictionaryEntry *e = NULL;
1968 char asrc_args[256];
1969 int ret;
1970
1971 avfilter_graph_free(&is->agraph);
1972 if (!(is->agraph = avfilter_graph_alloc()))
1973 return AVERROR(ENOMEM);
1974 is->agraph->nb_threads = filter_nbthreads;
1975
1976 while ((e = av_dict_get(swr_opts, "", e, AV_DICT_IGNORE_SUFFIX)))
1977 av_strlcatf(aresample_swr_opts, sizeof(aresample_swr_opts), "%s=%s:", e->key, e->value);
1978 if (strlen(aresample_swr_opts))
1979 aresample_swr_opts[strlen(aresample_swr_opts)-1] = '\0';
1980 av_opt_set(is->agraph, "aresample_swr_opts", aresample_swr_opts, 0);
1981
1982 ret = snprintf(asrc_args, sizeof(asrc_args),
1983 "sample_rate=%d:sample_fmt=%s:channels=%d:time_base=%d/%d",
1984 is->audio_filter_src.freq, av_get_sample_fmt_name(is->audio_filter_src.fmt),
1985 is->audio_filter_src.channels,
1986 1, is->audio_filter_src.freq);
1987 if (is->audio_filter_src.channel_layout)
1988 snprintf(asrc_args + ret, sizeof(asrc_args) - ret,
1989 ":channel_layout=0x%"PRIx64, is->audio_filter_src.channel_layout);
1990
1991 ret = avfilter_graph_create_filter(&filt_asrc,
1992 avfilter_get_by_name("abuffer"), "ffplay_abuffer",
1993 asrc_args, NULL, is->agraph);
1994 if (ret < 0)
1995 goto end;
1996
1997
1998 ret = avfilter_graph_create_filter(&filt_asink,
1999 avfilter_get_by_name("abuffersink"), "ffplay_abuffersink",
2000 NULL, NULL, is->agraph);
2001 if (ret < 0)
2002 goto end;
2003
2004 if ((ret = av_opt_set_int_list(filt_asink, "sample_fmts", sample_fmts, AV_SAMPLE_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
2005 goto end;
2006 if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 1, AV_OPT_SEARCH_CHILDREN)) < 0)
2007 goto end;
2008
2009 if (force_output_format) {
2010 channel_layouts[0] = is->audio_tgt.channel_layout;
2011 channels [0] = is->audio_tgt.channels;
2012 sample_rates [0] = is->audio_tgt.freq;
2013 if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 0, AV_OPT_SEARCH_CHILDREN)) < 0)
2014 goto end;
2015 if ((ret = av_opt_set_int_list(filt_asink, "channel_layouts", channel_layouts, -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2016 goto end;
2017 if ((ret = av_opt_set_int_list(filt_asink, "channel_counts" , channels , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2018 goto end;
2019 if ((ret = av_opt_set_int_list(filt_asink, "sample_rates" , sample_rates , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2020 goto end;
2021 }
2022
2023
2024 if ((ret = configure_filtergraph(is->agraph, afilters, filt_asrc, filt_asink)) < 0)
2025 goto end;
2026
2027 is->in_audio_filter = filt_asrc;
2028 is->out_audio_filter = filt_asink;
2029
2030 end:
2031 if (ret < 0)
2032 avfilter_graph_free(&is->agraph);
2033 return ret;
2034 }
2035 #endif /* CONFIG_AVFILTER */
2036
audio_thread(void * arg)2037 static int audio_thread(void *arg)
2038 {
2039 VideoState *is = arg;
2040 AVFrame *frame = av_frame_alloc();
2041 Frame *af;
2042 #if CONFIG_AVFILTER
2043 int last_serial = -1;
2044 int64_t dec_channel_layout;
2045 int reconfigure;
2046 #endif
2047 int got_frame = 0;
2048 AVRational tb;
2049 int ret = 0;
2050
2051 if (!frame)
2052 return AVERROR(ENOMEM);
2053
2054 do {
2055 if ((got_frame = decoder_decode_frame(&is->auddec, frame, NULL)) < 0)
2056 goto the_end;
2057
2058 if (got_frame) {
2059 tb = (AVRational){1, frame->sample_rate};
2060
2061 #if CONFIG_AVFILTER
2062 dec_channel_layout = get_valid_channel_layout(frame->channel_layout, frame->channels);
2063
2064 reconfigure =
2065 cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
2066 frame->format, frame->channels) ||
2067 is->audio_filter_src.channel_layout != dec_channel_layout ||
2068 is->audio_filter_src.freq != frame->sample_rate ||
2069 is->auddec.pkt_serial != last_serial;
2070
2071 if (reconfigure) {
2072 char buf1[1024], buf2[1024];
2073 av_get_channel_layout_string(buf1, sizeof(buf1), -1, is->audio_filter_src.channel_layout);
2074 av_get_channel_layout_string(buf2, sizeof(buf2), -1, dec_channel_layout);
2075 av_log(NULL, AV_LOG_DEBUG,
2076 "Audio frame changed from rate:%d ch:%d fmt:%s layout:%s serial:%d to rate:%d ch:%d fmt:%s layout:%s serial:%d\n",
2077 is->audio_filter_src.freq, is->audio_filter_src.channels, av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, last_serial,
2078 frame->sample_rate, frame->channels, av_get_sample_fmt_name(frame->format), buf2, is->auddec.pkt_serial);
2079
2080 is->audio_filter_src.fmt = frame->format;
2081 is->audio_filter_src.channels = frame->channels;
2082 is->audio_filter_src.channel_layout = dec_channel_layout;
2083 is->audio_filter_src.freq = frame->sample_rate;
2084 last_serial = is->auddec.pkt_serial;
2085
2086 if ((ret = configure_audio_filters(is, afilters, 1)) < 0)
2087 goto the_end;
2088 }
2089
2090 if ((ret = av_buffersrc_add_frame(is->in_audio_filter, frame)) < 0)
2091 goto the_end;
2092
2093 while ((ret = av_buffersink_get_frame_flags(is->out_audio_filter, frame, 0)) >= 0) {
2094 tb = av_buffersink_get_time_base(is->out_audio_filter);
2095 #endif
2096 if (!(af = frame_queue_peek_writable(&is->sampq)))
2097 goto the_end;
2098
2099 af->pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2100 af->pos = frame->pkt_pos;
2101 af->serial = is->auddec.pkt_serial;
2102 af->duration = av_q2d((AVRational){frame->nb_samples, frame->sample_rate});
2103
2104 av_frame_move_ref(af->frame, frame);
2105 frame_queue_push(&is->sampq);
2106
2107 #if CONFIG_AVFILTER
2108 if (is->audioq.serial != is->auddec.pkt_serial)
2109 break;
2110 }
2111 if (ret == AVERROR_EOF)
2112 is->auddec.finished = is->auddec.pkt_serial;
2113 #endif
2114 }
2115 } while (ret >= 0 || ret == AVERROR(EAGAIN) || ret == AVERROR_EOF);
2116 the_end:
2117 #if CONFIG_AVFILTER
2118 avfilter_graph_free(&is->agraph);
2119 #endif
2120 av_frame_free(&frame);
2121 return ret;
2122 }
2123
decoder_start(Decoder * d,int (* fn)(void *),const char * thread_name,void * arg)2124 static int decoder_start(Decoder *d, int (*fn)(void *), const char *thread_name, void* arg)
2125 {
2126 packet_queue_start(d->queue);
2127 d->decoder_tid = SDL_CreateThread(fn, thread_name, arg);
2128 if (!d->decoder_tid) {
2129 av_log(NULL, AV_LOG_ERROR, "SDL_CreateThread(): %s\n", SDL_GetError());
2130 return AVERROR(ENOMEM);
2131 }
2132 return 0;
2133 }
2134
video_thread(void * arg)2135 static int video_thread(void *arg)
2136 {
2137 VideoState *is = arg;
2138 AVFrame *frame = av_frame_alloc();
2139 double pts;
2140 double duration;
2141 int ret;
2142 AVRational tb = is->video_st->time_base;
2143 AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);
2144
2145 #if CONFIG_AVFILTER
2146 AVFilterGraph *graph = NULL;
2147 AVFilterContext *filt_out = NULL, *filt_in = NULL;
2148 int last_w = 0;
2149 int last_h = 0;
2150 enum AVPixelFormat last_format = -2;
2151 int last_serial = -1;
2152 int last_vfilter_idx = 0;
2153 #endif
2154
2155 if (!frame)
2156 return AVERROR(ENOMEM);
2157
2158 for (;;) {
2159 ret = get_video_frame(is, frame);
2160 if (ret < 0)
2161 goto the_end;
2162 if (!ret)
2163 continue;
2164
2165 #if CONFIG_AVFILTER
2166 if ( last_w != frame->width
2167 || last_h != frame->height
2168 || last_format != frame->format
2169 || last_serial != is->viddec.pkt_serial
2170 || last_vfilter_idx != is->vfilter_idx) {
2171 av_log(NULL, AV_LOG_DEBUG,
2172 "Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
2173 last_w, last_h,
2174 (const char *)av_x_if_null(av_get_pix_fmt_name(last_format), "none"), last_serial,
2175 frame->width, frame->height,
2176 (const char *)av_x_if_null(av_get_pix_fmt_name(frame->format), "none"), is->viddec.pkt_serial);
2177 avfilter_graph_free(&graph);
2178 graph = avfilter_graph_alloc();
2179 if (!graph) {
2180 ret = AVERROR(ENOMEM);
2181 goto the_end;
2182 }
2183 graph->nb_threads = filter_nbthreads;
2184 if ((ret = configure_video_filters(graph, is, vfilters_list ? vfilters_list[is->vfilter_idx] : NULL, frame)) < 0) {
2185 SDL_Event event;
2186 event.type = FF_QUIT_EVENT;
2187 event.user.data1 = is;
2188 SDL_PushEvent(&event);
2189 goto the_end;
2190 }
2191 filt_in = is->in_video_filter;
2192 filt_out = is->out_video_filter;
2193 last_w = frame->width;
2194 last_h = frame->height;
2195 last_format = frame->format;
2196 last_serial = is->viddec.pkt_serial;
2197 last_vfilter_idx = is->vfilter_idx;
2198 frame_rate = av_buffersink_get_frame_rate(filt_out);
2199 }
2200
2201 ret = av_buffersrc_add_frame(filt_in, frame);
2202 if (ret < 0)
2203 goto the_end;
2204
2205 while (ret >= 0) {
2206 is->frame_last_returned_time = av_gettime_relative() / 1000000.0;
2207
2208 ret = av_buffersink_get_frame_flags(filt_out, frame, 0);
2209 if (ret < 0) {
2210 if (ret == AVERROR_EOF)
2211 is->viddec.finished = is->viddec.pkt_serial;
2212 ret = 0;
2213 break;
2214 }
2215
2216 is->frame_last_filter_delay = av_gettime_relative() / 1000000.0 - is->frame_last_returned_time;
2217 if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
2218 is->frame_last_filter_delay = 0;
2219 tb = av_buffersink_get_time_base(filt_out);
2220 #endif
2221 duration = (frame_rate.num && frame_rate.den ? av_q2d((AVRational){frame_rate.den, frame_rate.num}) : 0);
2222 pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2223 ret = queue_picture(is, frame, pts, duration, frame->pkt_pos, is->viddec.pkt_serial);
2224 av_frame_unref(frame);
2225 #if CONFIG_AVFILTER
2226 if (is->videoq.serial != is->viddec.pkt_serial)
2227 break;
2228 }
2229 #endif
2230
2231 if (ret < 0)
2232 goto the_end;
2233 }
2234 the_end:
2235 #if CONFIG_AVFILTER
2236 avfilter_graph_free(&graph);
2237 #endif
2238 av_frame_free(&frame);
2239 return 0;
2240 }
2241
subtitle_thread(void * arg)2242 static int subtitle_thread(void *arg)
2243 {
2244 VideoState *is = arg;
2245 Frame *sp;
2246 int got_subtitle;
2247 double pts;
2248
2249 for (;;) {
2250 if (!(sp = frame_queue_peek_writable(&is->subpq)))
2251 return 0;
2252
2253 if ((got_subtitle = decoder_decode_frame(&is->subdec, NULL, &sp->sub)) < 0)
2254 break;
2255
2256 pts = 0;
2257
2258 if (got_subtitle && sp->sub.format == 0) {
2259 if (sp->sub.pts != AV_NOPTS_VALUE)
2260 pts = sp->sub.pts / (double)AV_TIME_BASE;
2261 sp->pts = pts;
2262 sp->serial = is->subdec.pkt_serial;
2263 sp->width = is->subdec.avctx->width;
2264 sp->height = is->subdec.avctx->height;
2265 sp->uploaded = 0;
2266
2267 /* now we can update the picture count */
2268 frame_queue_push(&is->subpq);
2269 } else if (got_subtitle) {
2270 avsubtitle_free(&sp->sub);
2271 }
2272 }
2273 return 0;
2274 }
2275
2276 /* copy samples for viewing in editor window */
update_sample_display(VideoState * is,short * samples,int samples_size)2277 static void update_sample_display(VideoState *is, short *samples, int samples_size)
2278 {
2279 int size, len;
2280
2281 size = samples_size / sizeof(short);
2282 while (size > 0) {
2283 len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
2284 if (len > size)
2285 len = size;
2286 memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
2287 samples += len;
2288 is->sample_array_index += len;
2289 if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
2290 is->sample_array_index = 0;
2291 size -= len;
2292 }
2293 }
2294
2295 /* return the wanted number of samples to get better sync if sync_type is video
2296 * or external master clock */
synchronize_audio(VideoState * is,int nb_samples)2297 static int synchronize_audio(VideoState *is, int nb_samples)
2298 {
2299 int wanted_nb_samples = nb_samples;
2300
2301 /* if not master, then we try to remove or add samples to correct the clock */
2302 if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
2303 double diff, avg_diff;
2304 int min_nb_samples, max_nb_samples;
2305
2306 diff = get_clock(&is->audclk) - get_master_clock(is);
2307
2308 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD) {
2309 is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
2310 if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
2311 /* not enough measures to have a correct estimate */
2312 is->audio_diff_avg_count++;
2313 } else {
2314 /* estimate the A-V difference */
2315 avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
2316
2317 if (fabs(avg_diff) >= is->audio_diff_threshold) {
2318 wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);
2319 min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2320 max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2321 wanted_nb_samples = av_clip(wanted_nb_samples, min_nb_samples, max_nb_samples);
2322 }
2323 av_log(NULL, AV_LOG_TRACE, "diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
2324 diff, avg_diff, wanted_nb_samples - nb_samples,
2325 is->audio_clock, is->audio_diff_threshold);
2326 }
2327 } else {
2328 /* too big difference : may be initial PTS errors, so
2329 reset A-V filter */
2330 is->audio_diff_avg_count = 0;
2331 is->audio_diff_cum = 0;
2332 }
2333 }
2334
2335 return wanted_nb_samples;
2336 }
2337
2338 /**
2339 * Decode one audio frame and return its uncompressed size.
2340 *
2341 * The processed audio frame is decoded, converted if required, and
2342 * stored in is->audio_buf, with size in bytes given by the return
2343 * value.
2344 */
audio_decode_frame(VideoState * is)2345 static int audio_decode_frame(VideoState *is)
2346 {
2347 int data_size, resampled_data_size;
2348 int64_t dec_channel_layout;
2349 av_unused double audio_clock0;
2350 int wanted_nb_samples;
2351 Frame *af;
2352
2353 if (is->paused)
2354 return -1;
2355
2356 do {
2357 #if defined(_WIN32)
2358 while (frame_queue_nb_remaining(&is->sampq) == 0) {
2359 if ((av_gettime_relative() - audio_callback_time) > 1000000LL * is->audio_hw_buf_size / is->audio_tgt.bytes_per_sec / 2)
2360 return -1;
2361 av_usleep (1000);
2362 }
2363 #endif
2364 if (!(af = frame_queue_peek_readable(&is->sampq)))
2365 return -1;
2366 frame_queue_next(&is->sampq);
2367 } while (af->serial != is->audioq.serial);
2368
2369 data_size = av_samples_get_buffer_size(NULL, af->frame->channels,
2370 af->frame->nb_samples,
2371 af->frame->format, 1);
2372
2373 dec_channel_layout =
2374 (af->frame->channel_layout && af->frame->channels == av_get_channel_layout_nb_channels(af->frame->channel_layout)) ?
2375 af->frame->channel_layout : av_get_default_channel_layout(af->frame->channels);
2376 wanted_nb_samples = synchronize_audio(is, af->frame->nb_samples);
2377
2378 if (af->frame->format != is->audio_src.fmt ||
2379 dec_channel_layout != is->audio_src.channel_layout ||
2380 af->frame->sample_rate != is->audio_src.freq ||
2381 (wanted_nb_samples != af->frame->nb_samples && !is->swr_ctx)) {
2382 swr_free(&is->swr_ctx);
2383 is->swr_ctx = swr_alloc_set_opts(NULL,
2384 is->audio_tgt.channel_layout, is->audio_tgt.fmt, is->audio_tgt.freq,
2385 dec_channel_layout, af->frame->format, af->frame->sample_rate,
2386 0, NULL);
2387 if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
2388 av_log(NULL, AV_LOG_ERROR,
2389 "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
2390 af->frame->sample_rate, av_get_sample_fmt_name(af->frame->format), af->frame->channels,
2391 is->audio_tgt.freq, av_get_sample_fmt_name(is->audio_tgt.fmt), is->audio_tgt.channels);
2392 swr_free(&is->swr_ctx);
2393 return -1;
2394 }
2395 is->audio_src.channel_layout = dec_channel_layout;
2396 is->audio_src.channels = af->frame->channels;
2397 is->audio_src.freq = af->frame->sample_rate;
2398 is->audio_src.fmt = af->frame->format;
2399 }
2400
2401 if (is->swr_ctx) {
2402 const uint8_t **in = (const uint8_t **)af->frame->extended_data;
2403 uint8_t **out = &is->audio_buf1;
2404 int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate + 256;
2405 int out_size = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, out_count, is->audio_tgt.fmt, 0);
2406 int len2;
2407 if (out_size < 0) {
2408 av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size() failed\n");
2409 return -1;
2410 }
2411 if (wanted_nb_samples != af->frame->nb_samples) {
2412 if (swr_set_compensation(is->swr_ctx, (wanted_nb_samples - af->frame->nb_samples) * is->audio_tgt.freq / af->frame->sample_rate,
2413 wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate) < 0) {
2414 av_log(NULL, AV_LOG_ERROR, "swr_set_compensation() failed\n");
2415 return -1;
2416 }
2417 }
2418 av_fast_malloc(&is->audio_buf1, &is->audio_buf1_size, out_size);
2419 if (!is->audio_buf1)
2420 return AVERROR(ENOMEM);
2421 len2 = swr_convert(is->swr_ctx, out, out_count, in, af->frame->nb_samples);
2422 if (len2 < 0) {
2423 av_log(NULL, AV_LOG_ERROR, "swr_convert() failed\n");
2424 return -1;
2425 }
2426 if (len2 == out_count) {
2427 av_log(NULL, AV_LOG_WARNING, "audio buffer is probably too small\n");
2428 if (swr_init(is->swr_ctx) < 0)
2429 swr_free(&is->swr_ctx);
2430 }
2431 is->audio_buf = is->audio_buf1;
2432 resampled_data_size = len2 * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2433 } else {
2434 is->audio_buf = af->frame->data[0];
2435 resampled_data_size = data_size;
2436 }
2437
2438 audio_clock0 = is->audio_clock;
2439 /* update the audio clock with the pts */
2440 if (!isnan(af->pts))
2441 is->audio_clock = af->pts + (double) af->frame->nb_samples / af->frame->sample_rate;
2442 else
2443 is->audio_clock = NAN;
2444 is->audio_clock_serial = af->serial;
2445 #ifdef DEBUG
2446 {
2447 static double last_clock;
2448 printf("audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
2449 is->audio_clock - last_clock,
2450 is->audio_clock, audio_clock0);
2451 last_clock = is->audio_clock;
2452 }
2453 #endif
2454 return resampled_data_size;
2455 }
2456
2457 /* prepare a new audio buffer */
sdl_audio_callback(void * opaque,Uint8 * stream,int len)2458 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
2459 {
2460 VideoState *is = opaque;
2461 int audio_size, len1;
2462
2463 audio_callback_time = av_gettime_relative();
2464
2465 while (len > 0) {
2466 if (is->audio_buf_index >= is->audio_buf_size) {
2467 audio_size = audio_decode_frame(is);
2468 if (audio_size < 0) {
2469 /* if error, just output silence */
2470 is->audio_buf = NULL;
2471 is->audio_buf_size = SDL_AUDIO_MIN_BUFFER_SIZE / is->audio_tgt.frame_size * is->audio_tgt.frame_size;
2472 } else {
2473 if (is->show_mode != SHOW_MODE_VIDEO)
2474 update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
2475 is->audio_buf_size = audio_size;
2476 }
2477 is->audio_buf_index = 0;
2478 }
2479 len1 = is->audio_buf_size - is->audio_buf_index;
2480 if (len1 > len)
2481 len1 = len;
2482 if (!is->muted && is->audio_buf && is->audio_volume == SDL_MIX_MAXVOLUME)
2483 memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
2484 else {
2485 memset(stream, 0, len1);
2486 if (!is->muted && is->audio_buf)
2487 SDL_MixAudioFormat(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, AUDIO_S16SYS, len1, is->audio_volume);
2488 }
2489 len -= len1;
2490 stream += len1;
2491 is->audio_buf_index += len1;
2492 }
2493 is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
2494 /* Let's assume the audio driver that is used by SDL has two periods. */
2495 if (!isnan(is->audio_clock)) {
2496 set_clock_at(&is->audclk, is->audio_clock - (double)(2 * is->audio_hw_buf_size + is->audio_write_buf_size) / is->audio_tgt.bytes_per_sec, is->audio_clock_serial, audio_callback_time / 1000000.0);
2497 sync_clock_to_slave(&is->extclk, &is->audclk);
2498 }
2499 }
2500
audio_open(void * opaque,int64_t wanted_channel_layout,int wanted_nb_channels,int wanted_sample_rate,struct AudioParams * audio_hw_params)2501 static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
2502 {
2503 SDL_AudioSpec wanted_spec, spec;
2504 const char *env;
2505 static const int next_nb_channels[] = {0, 0, 1, 6, 2, 6, 4, 6};
2506 static const int next_sample_rates[] = {0, 44100, 48000, 96000, 192000};
2507 int next_sample_rate_idx = FF_ARRAY_ELEMS(next_sample_rates) - 1;
2508
2509 env = SDL_getenv("SDL_AUDIO_CHANNELS");
2510 if (env) {
2511 wanted_nb_channels = atoi(env);
2512 wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2513 }
2514 if (!wanted_channel_layout || wanted_nb_channels != av_get_channel_layout_nb_channels(wanted_channel_layout)) {
2515 wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2516 wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
2517 }
2518 wanted_nb_channels = av_get_channel_layout_nb_channels(wanted_channel_layout);
2519 wanted_spec.channels = wanted_nb_channels;
2520 wanted_spec.freq = wanted_sample_rate;
2521 if (wanted_spec.freq <= 0 || wanted_spec.channels <= 0) {
2522 av_log(NULL, AV_LOG_ERROR, "Invalid sample rate or channel count!\n");
2523 return -1;
2524 }
2525 while (next_sample_rate_idx && next_sample_rates[next_sample_rate_idx] >= wanted_spec.freq)
2526 next_sample_rate_idx--;
2527 wanted_spec.format = AUDIO_S16SYS;
2528 wanted_spec.silence = 0;
2529 wanted_spec.samples = FFMAX(SDL_AUDIO_MIN_BUFFER_SIZE, 2 << av_log2(wanted_spec.freq / SDL_AUDIO_MAX_CALLBACKS_PER_SEC));
2530 wanted_spec.callback = sdl_audio_callback;
2531 wanted_spec.userdata = opaque;
2532 while (!(audio_dev = SDL_OpenAudioDevice(NULL, 0, &wanted_spec, &spec, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE | SDL_AUDIO_ALLOW_CHANNELS_CHANGE))) {
2533 av_log(NULL, AV_LOG_WARNING, "SDL_OpenAudio (%d channels, %d Hz): %s\n",
2534 wanted_spec.channels, wanted_spec.freq, SDL_GetError());
2535 wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
2536 if (!wanted_spec.channels) {
2537 wanted_spec.freq = next_sample_rates[next_sample_rate_idx--];
2538 wanted_spec.channels = wanted_nb_channels;
2539 if (!wanted_spec.freq) {
2540 av_log(NULL, AV_LOG_ERROR,
2541 "No more combinations to try, audio open failed\n");
2542 return -1;
2543 }
2544 }
2545 wanted_channel_layout = av_get_default_channel_layout(wanted_spec.channels);
2546 }
2547 if (spec.format != AUDIO_S16SYS) {
2548 av_log(NULL, AV_LOG_ERROR,
2549 "SDL advised audio format %d is not supported!\n", spec.format);
2550 return -1;
2551 }
2552 if (spec.channels != wanted_spec.channels) {
2553 wanted_channel_layout = av_get_default_channel_layout(spec.channels);
2554 if (!wanted_channel_layout) {
2555 av_log(NULL, AV_LOG_ERROR,
2556 "SDL advised channel count %d is not supported!\n", spec.channels);
2557 return -1;
2558 }
2559 }
2560
2561 audio_hw_params->fmt = AV_SAMPLE_FMT_S16;
2562 audio_hw_params->freq = spec.freq;
2563 audio_hw_params->channel_layout = wanted_channel_layout;
2564 audio_hw_params->channels = spec.channels;
2565 audio_hw_params->frame_size = av_samples_get_buffer_size(NULL, audio_hw_params->channels, 1, audio_hw_params->fmt, 1);
2566 audio_hw_params->bytes_per_sec = av_samples_get_buffer_size(NULL, audio_hw_params->channels, audio_hw_params->freq, audio_hw_params->fmt, 1);
2567 if (audio_hw_params->bytes_per_sec <= 0 || audio_hw_params->frame_size <= 0) {
2568 av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size failed\n");
2569 return -1;
2570 }
2571 return spec.size;
2572 }
2573
2574 /* open a given stream. Return 0 if OK */
stream_component_open(VideoState * is,int stream_index)2575 static int stream_component_open(VideoState *is, int stream_index)
2576 {
2577 AVFormatContext *ic = is->ic;
2578 AVCodecContext *avctx;
2579 AVCodec *codec;
2580 const char *forced_codec_name = NULL;
2581 AVDictionary *opts = NULL;
2582 AVDictionaryEntry *t = NULL;
2583 int sample_rate, nb_channels;
2584 int64_t channel_layout;
2585 int ret = 0;
2586 int stream_lowres = lowres;
2587
2588 if (stream_index < 0 || stream_index >= ic->nb_streams)
2589 return -1;
2590
2591 avctx = avcodec_alloc_context3(NULL);
2592 if (!avctx)
2593 return AVERROR(ENOMEM);
2594
2595 ret = avcodec_parameters_to_context(avctx, ic->streams[stream_index]->codecpar);
2596 if (ret < 0)
2597 goto fail;
2598 avctx->pkt_timebase = ic->streams[stream_index]->time_base;
2599
2600 codec = avcodec_find_decoder(avctx->codec_id);
2601
2602 switch(avctx->codec_type){
2603 case AVMEDIA_TYPE_AUDIO : is->last_audio_stream = stream_index; forced_codec_name = audio_codec_name; break;
2604 case AVMEDIA_TYPE_SUBTITLE: is->last_subtitle_stream = stream_index; forced_codec_name = subtitle_codec_name; break;
2605 case AVMEDIA_TYPE_VIDEO : is->last_video_stream = stream_index; forced_codec_name = video_codec_name; break;
2606 }
2607 if (forced_codec_name)
2608 codec = avcodec_find_decoder_by_name(forced_codec_name);
2609 if (!codec) {
2610 if (forced_codec_name) av_log(NULL, AV_LOG_WARNING,
2611 "No codec could be found with name '%s'\n", forced_codec_name);
2612 else av_log(NULL, AV_LOG_WARNING,
2613 "No decoder could be found for codec %s\n", avcodec_get_name(avctx->codec_id));
2614 ret = AVERROR(EINVAL);
2615 goto fail;
2616 }
2617
2618 avctx->codec_id = codec->id;
2619 if (stream_lowres > codec->max_lowres) {
2620 av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2621 codec->max_lowres);
2622 stream_lowres = codec->max_lowres;
2623 }
2624 avctx->lowres = stream_lowres;
2625
2626 if (fast)
2627 avctx->flags2 |= AV_CODEC_FLAG2_FAST;
2628
2629 opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
2630 if (!av_dict_get(opts, "threads", NULL, 0))
2631 av_dict_set(&opts, "threads", "auto", 0);
2632 if (stream_lowres)
2633 av_dict_set_int(&opts, "lowres", stream_lowres, 0);
2634 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
2635 av_dict_set(&opts, "refcounted_frames", "1", 0);
2636 if ((ret = avcodec_open2(avctx, codec, &opts)) < 0) {
2637 goto fail;
2638 }
2639 if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2640 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2641 ret = AVERROR_OPTION_NOT_FOUND;
2642 goto fail;
2643 }
2644
2645 is->eof = 0;
2646 ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
2647 switch (avctx->codec_type) {
2648 case AVMEDIA_TYPE_AUDIO:
2649 #if CONFIG_AVFILTER
2650 {
2651 AVFilterContext *sink;
2652
2653 is->audio_filter_src.freq = avctx->sample_rate;
2654 is->audio_filter_src.channels = avctx->channels;
2655 is->audio_filter_src.channel_layout = get_valid_channel_layout(avctx->channel_layout, avctx->channels);
2656 is->audio_filter_src.fmt = avctx->sample_fmt;
2657 if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
2658 goto fail;
2659 sink = is->out_audio_filter;
2660 sample_rate = av_buffersink_get_sample_rate(sink);
2661 nb_channels = av_buffersink_get_channels(sink);
2662 channel_layout = av_buffersink_get_channel_layout(sink);
2663 }
2664 #else
2665 sample_rate = avctx->sample_rate;
2666 nb_channels = avctx->channels;
2667 channel_layout = avctx->channel_layout;
2668 #endif
2669
2670 /* prepare audio output */
2671 if ((ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)) < 0)
2672 goto fail;
2673 is->audio_hw_buf_size = ret;
2674 is->audio_src = is->audio_tgt;
2675 is->audio_buf_size = 0;
2676 is->audio_buf_index = 0;
2677
2678 /* init averaging filter */
2679 is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
2680 is->audio_diff_avg_count = 0;
2681 /* since we do not have a precise anough audio FIFO fullness,
2682 we correct audio sync only if larger than this threshold */
2683 is->audio_diff_threshold = (double)(is->audio_hw_buf_size) / is->audio_tgt.bytes_per_sec;
2684
2685 is->audio_stream = stream_index;
2686 is->audio_st = ic->streams[stream_index];
2687
2688 decoder_init(&is->auddec, avctx, &is->audioq, is->continue_read_thread);
2689 if ((is->ic->iformat->flags & (AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH | AVFMT_NO_BYTE_SEEK)) && !is->ic->iformat->read_seek) {
2690 is->auddec.start_pts = is->audio_st->start_time;
2691 is->auddec.start_pts_tb = is->audio_st->time_base;
2692 }
2693 if ((ret = decoder_start(&is->auddec, audio_thread, "audio_decoder", is)) < 0)
2694 goto out;
2695 SDL_PauseAudioDevice(audio_dev, 0);
2696 break;
2697 case AVMEDIA_TYPE_VIDEO:
2698 is->video_stream = stream_index;
2699 is->video_st = ic->streams[stream_index];
2700
2701 decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread);
2702 if ((ret = decoder_start(&is->viddec, video_thread, "video_decoder", is)) < 0)
2703 goto out;
2704 is->queue_attachments_req = 1;
2705 break;
2706 case AVMEDIA_TYPE_SUBTITLE:
2707 is->subtitle_stream = stream_index;
2708 is->subtitle_st = ic->streams[stream_index];
2709
2710 decoder_init(&is->subdec, avctx, &is->subtitleq, is->continue_read_thread);
2711 if ((ret = decoder_start(&is->subdec, subtitle_thread, "subtitle_decoder", is)) < 0)
2712 goto out;
2713 break;
2714 default:
2715 break;
2716 }
2717 goto out;
2718
2719 fail:
2720 avcodec_free_context(&avctx);
2721 out:
2722 av_dict_free(&opts);
2723
2724 return ret;
2725 }
2726
decode_interrupt_cb(void * ctx)2727 static int decode_interrupt_cb(void *ctx)
2728 {
2729 VideoState *is = ctx;
2730 return is->abort_request;
2731 }
2732
stream_has_enough_packets(AVStream * st,int stream_id,PacketQueue * queue)2733 static int stream_has_enough_packets(AVStream *st, int stream_id, PacketQueue *queue) {
2734 return stream_id < 0 ||
2735 queue->abort_request ||
2736 (st->disposition & AV_DISPOSITION_ATTACHED_PIC) ||
2737 queue->nb_packets > MIN_FRAMES && (!queue->duration || av_q2d(st->time_base) * queue->duration > 1.0);
2738 }
2739
is_realtime(AVFormatContext * s)2740 static int is_realtime(AVFormatContext *s)
2741 {
2742 if( !strcmp(s->iformat->name, "rtp")
2743 || !strcmp(s->iformat->name, "rtsp")
2744 || !strcmp(s->iformat->name, "sdp")
2745 )
2746 return 1;
2747
2748 if(s->pb && ( !strncmp(s->url, "rtp:", 4)
2749 || !strncmp(s->url, "udp:", 4)
2750 )
2751 )
2752 return 1;
2753 return 0;
2754 }
2755
2756 /* this thread gets the stream from the disk or the network */
read_thread(void * arg)2757 static int read_thread(void *arg)
2758 {
2759 VideoState *is = arg;
2760 AVFormatContext *ic = NULL;
2761 int err, i, ret;
2762 int st_index[AVMEDIA_TYPE_NB];
2763 AVPacket pkt1, *pkt = &pkt1;
2764 int64_t stream_start_time;
2765 int pkt_in_play_range = 0;
2766 AVDictionaryEntry *t;
2767 SDL_mutex *wait_mutex = SDL_CreateMutex();
2768 int scan_all_pmts_set = 0;
2769 int64_t pkt_ts;
2770
2771 if (!wait_mutex) {
2772 av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
2773 ret = AVERROR(ENOMEM);
2774 goto fail;
2775 }
2776
2777 memset(st_index, -1, sizeof(st_index));
2778 is->eof = 0;
2779
2780 ic = avformat_alloc_context();
2781 if (!ic) {
2782 av_log(NULL, AV_LOG_FATAL, "Could not allocate context.\n");
2783 ret = AVERROR(ENOMEM);
2784 goto fail;
2785 }
2786 ic->interrupt_callback.callback = decode_interrupt_cb;
2787 ic->interrupt_callback.opaque = is;
2788 if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
2789 av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
2790 scan_all_pmts_set = 1;
2791 }
2792 err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
2793 if (err < 0) {
2794 print_error(is->filename, err);
2795 ret = -1;
2796 goto fail;
2797 }
2798 if (scan_all_pmts_set)
2799 av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
2800
2801 if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2802 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2803 ret = AVERROR_OPTION_NOT_FOUND;
2804 goto fail;
2805 }
2806 is->ic = ic;
2807
2808 if (genpts)
2809 ic->flags |= AVFMT_FLAG_GENPTS;
2810
2811 av_format_inject_global_side_data(ic);
2812
2813 if (find_stream_info) {
2814 AVDictionary **opts = setup_find_stream_info_opts(ic, codec_opts);
2815 int orig_nb_streams = ic->nb_streams;
2816
2817 err = avformat_find_stream_info(ic, opts);
2818
2819 for (i = 0; i < orig_nb_streams; i++)
2820 av_dict_free(&opts[i]);
2821 av_freep(&opts);
2822
2823 if (err < 0) {
2824 av_log(NULL, AV_LOG_WARNING,
2825 "%s: could not find codec parameters\n", is->filename);
2826 ret = -1;
2827 goto fail;
2828 }
2829 }
2830
2831 if (ic->pb)
2832 ic->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use avio_feof() to test for the end
2833
2834 if (seek_by_bytes < 0)
2835 seek_by_bytes = !!(ic->iformat->flags & AVFMT_TS_DISCONT) && strcmp("ogg", ic->iformat->name);
2836
2837 is->max_frame_duration = (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;
2838
2839 if (!window_title && (t = av_dict_get(ic->metadata, "title", NULL, 0)))
2840 window_title = av_asprintf("%s - %s", t->value, input_filename);
2841
2842 /* if seeking requested, we execute it */
2843 if (start_time != AV_NOPTS_VALUE) {
2844 int64_t timestamp;
2845
2846 timestamp = start_time;
2847 /* add the stream start time */
2848 if (ic->start_time != AV_NOPTS_VALUE)
2849 timestamp += ic->start_time;
2850 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
2851 if (ret < 0) {
2852 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2853 is->filename, (double)timestamp / AV_TIME_BASE);
2854 }
2855 }
2856
2857 is->realtime = is_realtime(ic);
2858
2859 if (show_status)
2860 av_dump_format(ic, 0, is->filename, 0);
2861
2862 for (i = 0; i < ic->nb_streams; i++) {
2863 AVStream *st = ic->streams[i];
2864 enum AVMediaType type = st->codecpar->codec_type;
2865 st->discard = AVDISCARD_ALL;
2866 if (type >= 0 && wanted_stream_spec[type] && st_index[type] == -1)
2867 if (avformat_match_stream_specifier(ic, st, wanted_stream_spec[type]) > 0)
2868 st_index[type] = i;
2869 }
2870 for (i = 0; i < AVMEDIA_TYPE_NB; i++) {
2871 if (wanted_stream_spec[i] && st_index[i] == -1) {
2872 av_log(NULL, AV_LOG_ERROR, "Stream specifier %s does not match any %s stream\n", wanted_stream_spec[i], av_get_media_type_string(i));
2873 st_index[i] = INT_MAX;
2874 }
2875 }
2876
2877 if (!video_disable)
2878 st_index[AVMEDIA_TYPE_VIDEO] =
2879 av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
2880 st_index[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
2881 if (!audio_disable)
2882 st_index[AVMEDIA_TYPE_AUDIO] =
2883 av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
2884 st_index[AVMEDIA_TYPE_AUDIO],
2885 st_index[AVMEDIA_TYPE_VIDEO],
2886 NULL, 0);
2887 if (!video_disable && !subtitle_disable)
2888 st_index[AVMEDIA_TYPE_SUBTITLE] =
2889 av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
2890 st_index[AVMEDIA_TYPE_SUBTITLE],
2891 (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
2892 st_index[AVMEDIA_TYPE_AUDIO] :
2893 st_index[AVMEDIA_TYPE_VIDEO]),
2894 NULL, 0);
2895
2896 is->show_mode = show_mode;
2897 if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2898 AVStream *st = ic->streams[st_index[AVMEDIA_TYPE_VIDEO]];
2899 AVCodecParameters *codecpar = st->codecpar;
2900 AVRational sar = av_guess_sample_aspect_ratio(ic, st, NULL);
2901 if (codecpar->width)
2902 set_default_window_size(codecpar->width, codecpar->height, sar);
2903 }
2904
2905 /* open the streams */
2906 if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
2907 stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
2908 }
2909
2910 ret = -1;
2911 if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2912 ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
2913 }
2914 if (is->show_mode == SHOW_MODE_NONE)
2915 is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
2916
2917 if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
2918 stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
2919 }
2920
2921 if (is->video_stream < 0 && is->audio_stream < 0) {
2922 av_log(NULL, AV_LOG_FATAL, "Failed to open file '%s' or configure filtergraph\n",
2923 is->filename);
2924 ret = -1;
2925 goto fail;
2926 }
2927
2928 if (infinite_buffer < 0 && is->realtime)
2929 infinite_buffer = 1;
2930
2931 for (;;) {
2932 if (is->abort_request)
2933 break;
2934 if (is->paused != is->last_paused) {
2935 is->last_paused = is->paused;
2936 if (is->paused)
2937 is->read_pause_return = av_read_pause(ic);
2938 else
2939 av_read_play(ic);
2940 }
2941 #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
2942 if (is->paused &&
2943 (!strcmp(ic->iformat->name, "rtsp") ||
2944 (ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
2945 /* wait 10 ms to avoid trying to get another packet */
2946 /* XXX: horrible */
2947 SDL_Delay(10);
2948 continue;
2949 }
2950 #endif
2951 if (is->seek_req) {
2952 int64_t seek_target = is->seek_pos;
2953 int64_t seek_min = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
2954 int64_t seek_max = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
2955 // FIXME the +-2 is due to rounding being not done in the correct direction in generation
2956 // of the seek_pos/seek_rel variables
2957
2958 ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
2959 if (ret < 0) {
2960 av_log(NULL, AV_LOG_ERROR,
2961 "%s: error while seeking\n", is->ic->url);
2962 } else {
2963 if (is->audio_stream >= 0) {
2964 packet_queue_flush(&is->audioq);
2965 packet_queue_put(&is->audioq, &flush_pkt);
2966 }
2967 if (is->subtitle_stream >= 0) {
2968 packet_queue_flush(&is->subtitleq);
2969 packet_queue_put(&is->subtitleq, &flush_pkt);
2970 }
2971 if (is->video_stream >= 0) {
2972 packet_queue_flush(&is->videoq);
2973 packet_queue_put(&is->videoq, &flush_pkt);
2974 }
2975 if (is->seek_flags & AVSEEK_FLAG_BYTE) {
2976 set_clock(&is->extclk, NAN, 0);
2977 } else {
2978 set_clock(&is->extclk, seek_target / (double)AV_TIME_BASE, 0);
2979 }
2980 }
2981 is->seek_req = 0;
2982 is->queue_attachments_req = 1;
2983 is->eof = 0;
2984 if (is->paused)
2985 step_to_next_frame(is);
2986 }
2987 if (is->queue_attachments_req) {
2988 if (is->video_st && is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC) {
2989 AVPacket copy;
2990 if ((ret = av_packet_ref(©, &is->video_st->attached_pic)) < 0)
2991 goto fail;
2992 packet_queue_put(&is->videoq, ©);
2993 packet_queue_put_nullpacket(&is->videoq, is->video_stream);
2994 }
2995 is->queue_attachments_req = 0;
2996 }
2997
2998 /* if the queue are full, no need to read more */
2999 if (infinite_buffer<1 &&
3000 (is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
3001 || (stream_has_enough_packets(is->audio_st, is->audio_stream, &is->audioq) &&
3002 stream_has_enough_packets(is->video_st, is->video_stream, &is->videoq) &&
3003 stream_has_enough_packets(is->subtitle_st, is->subtitle_stream, &is->subtitleq)))) {
3004 /* wait 10 ms */
3005 SDL_LockMutex(wait_mutex);
3006 SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3007 SDL_UnlockMutex(wait_mutex);
3008 continue;
3009 }
3010 if (!is->paused &&
3011 (!is->audio_st || (is->auddec.finished == is->audioq.serial && frame_queue_nb_remaining(&is->sampq) == 0)) &&
3012 (!is->video_st || (is->viddec.finished == is->videoq.serial && frame_queue_nb_remaining(&is->pictq) == 0))) {
3013 if (loop != 1 && (!loop || --loop)) {
3014 stream_seek(is, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
3015 } else if (autoexit) {
3016 ret = AVERROR_EOF;
3017 goto fail;
3018 }
3019 }
3020 ret = av_read_frame(ic, pkt);
3021 if (ret < 0) {
3022 if ((ret == AVERROR_EOF || avio_feof(ic->pb)) && !is->eof) {
3023 if (is->video_stream >= 0)
3024 packet_queue_put_nullpacket(&is->videoq, is->video_stream);
3025 if (is->audio_stream >= 0)
3026 packet_queue_put_nullpacket(&is->audioq, is->audio_stream);
3027 if (is->subtitle_stream >= 0)
3028 packet_queue_put_nullpacket(&is->subtitleq, is->subtitle_stream);
3029 is->eof = 1;
3030 }
3031 if (ic->pb && ic->pb->error)
3032 break;
3033 SDL_LockMutex(wait_mutex);
3034 SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3035 SDL_UnlockMutex(wait_mutex);
3036 continue;
3037 } else {
3038 is->eof = 0;
3039 }
3040 /* check if packet is in play range specified by user, then queue, otherwise discard */
3041 stream_start_time = ic->streams[pkt->stream_index]->start_time;
3042 pkt_ts = pkt->pts == AV_NOPTS_VALUE ? pkt->dts : pkt->pts;
3043 pkt_in_play_range = duration == AV_NOPTS_VALUE ||
3044 (pkt_ts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
3045 av_q2d(ic->streams[pkt->stream_index]->time_base) -
3046 (double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
3047 <= ((double)duration / 1000000);
3048 if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
3049 packet_queue_put(&is->audioq, pkt);
3050 } else if (pkt->stream_index == is->video_stream && pkt_in_play_range
3051 && !(is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
3052 packet_queue_put(&is->videoq, pkt);
3053 } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
3054 packet_queue_put(&is->subtitleq, pkt);
3055 } else {
3056 av_packet_unref(pkt);
3057 }
3058 }
3059
3060 ret = 0;
3061 fail:
3062 if (ic && !is->ic)
3063 avformat_close_input(&ic);
3064
3065 if (ret != 0) {
3066 SDL_Event event;
3067
3068 event.type = FF_QUIT_EVENT;
3069 event.user.data1 = is;
3070 SDL_PushEvent(&event);
3071 }
3072 SDL_DestroyMutex(wait_mutex);
3073 return 0;
3074 }
3075
stream_open(const char * filename,AVInputFormat * iformat)3076 static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
3077 {
3078 VideoState *is;
3079
3080 is = av_mallocz(sizeof(VideoState));
3081 if (!is)
3082 return NULL;
3083 is->last_video_stream = is->video_stream = -1;
3084 is->last_audio_stream = is->audio_stream = -1;
3085 is->last_subtitle_stream = is->subtitle_stream = -1;
3086 is->filename = av_strdup(filename);
3087 if (!is->filename)
3088 goto fail;
3089 is->iformat = iformat;
3090 is->ytop = 0;
3091 is->xleft = 0;
3092
3093 /* start video display */
3094 if (frame_queue_init(&is->pictq, &is->videoq, VIDEO_PICTURE_QUEUE_SIZE, 1) < 0)
3095 goto fail;
3096 if (frame_queue_init(&is->subpq, &is->subtitleq, SUBPICTURE_QUEUE_SIZE, 0) < 0)
3097 goto fail;
3098 if (frame_queue_init(&is->sampq, &is->audioq, SAMPLE_QUEUE_SIZE, 1) < 0)
3099 goto fail;
3100
3101 if (packet_queue_init(&is->videoq) < 0 ||
3102 packet_queue_init(&is->audioq) < 0 ||
3103 packet_queue_init(&is->subtitleq) < 0)
3104 goto fail;
3105
3106 if (!(is->continue_read_thread = SDL_CreateCond())) {
3107 av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
3108 goto fail;
3109 }
3110
3111 init_clock(&is->vidclk, &is->videoq.serial);
3112 init_clock(&is->audclk, &is->audioq.serial);
3113 init_clock(&is->extclk, &is->extclk.serial);
3114 is->audio_clock_serial = -1;
3115 if (startup_volume < 0)
3116 av_log(NULL, AV_LOG_WARNING, "-volume=%d < 0, setting to 0\n", startup_volume);
3117 if (startup_volume > 100)
3118 av_log(NULL, AV_LOG_WARNING, "-volume=%d > 100, setting to 100\n", startup_volume);
3119 startup_volume = av_clip(startup_volume, 0, 100);
3120 startup_volume = av_clip(SDL_MIX_MAXVOLUME * startup_volume / 100, 0, SDL_MIX_MAXVOLUME);
3121 is->audio_volume = startup_volume;
3122 is->muted = 0;
3123 is->av_sync_type = av_sync_type;
3124 is->read_tid = SDL_CreateThread(read_thread, "read_thread", is);
3125 if (!is->read_tid) {
3126 av_log(NULL, AV_LOG_FATAL, "SDL_CreateThread(): %s\n", SDL_GetError());
3127 fail:
3128 stream_close(is);
3129 return NULL;
3130 }
3131 return is;
3132 }
3133
stream_cycle_channel(VideoState * is,int codec_type)3134 static void stream_cycle_channel(VideoState *is, int codec_type)
3135 {
3136 AVFormatContext *ic = is->ic;
3137 int start_index, stream_index;
3138 int old_index;
3139 AVStream *st;
3140 AVProgram *p = NULL;
3141 int nb_streams = is->ic->nb_streams;
3142
3143 if (codec_type == AVMEDIA_TYPE_VIDEO) {
3144 start_index = is->last_video_stream;
3145 old_index = is->video_stream;
3146 } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
3147 start_index = is->last_audio_stream;
3148 old_index = is->audio_stream;
3149 } else {
3150 start_index = is->last_subtitle_stream;
3151 old_index = is->subtitle_stream;
3152 }
3153 stream_index = start_index;
3154
3155 if (codec_type != AVMEDIA_TYPE_VIDEO && is->video_stream != -1) {
3156 p = av_find_program_from_stream(ic, NULL, is->video_stream);
3157 if (p) {
3158 nb_streams = p->nb_stream_indexes;
3159 for (start_index = 0; start_index < nb_streams; start_index++)
3160 if (p->stream_index[start_index] == stream_index)
3161 break;
3162 if (start_index == nb_streams)
3163 start_index = -1;
3164 stream_index = start_index;
3165 }
3166 }
3167
3168 for (;;) {
3169 if (++stream_index >= nb_streams)
3170 {
3171 if (codec_type == AVMEDIA_TYPE_SUBTITLE)
3172 {
3173 stream_index = -1;
3174 is->last_subtitle_stream = -1;
3175 goto the_end;
3176 }
3177 if (start_index == -1)
3178 return;
3179 stream_index = 0;
3180 }
3181 if (stream_index == start_index)
3182 return;
3183 st = is->ic->streams[p ? p->stream_index[stream_index] : stream_index];
3184 if (st->codecpar->codec_type == codec_type) {
3185 /* check that parameters are OK */
3186 switch (codec_type) {
3187 case AVMEDIA_TYPE_AUDIO:
3188 if (st->codecpar->sample_rate != 0 &&
3189 st->codecpar->channels != 0)
3190 goto the_end;
3191 break;
3192 case AVMEDIA_TYPE_VIDEO:
3193 case AVMEDIA_TYPE_SUBTITLE:
3194 goto the_end;
3195 default:
3196 break;
3197 }
3198 }
3199 }
3200 the_end:
3201 if (p && stream_index != -1)
3202 stream_index = p->stream_index[stream_index];
3203 av_log(NULL, AV_LOG_INFO, "Switch %s stream from #%d to #%d\n",
3204 av_get_media_type_string(codec_type),
3205 old_index,
3206 stream_index);
3207
3208 stream_component_close(is, old_index);
3209 stream_component_open(is, stream_index);
3210 }
3211
3212
toggle_full_screen(VideoState * is)3213 static void toggle_full_screen(VideoState *is)
3214 {
3215 is_full_screen = !is_full_screen;
3216 SDL_SetWindowFullscreen(window, is_full_screen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
3217 }
3218
toggle_audio_display(VideoState * is)3219 static void toggle_audio_display(VideoState *is)
3220 {
3221 int next = is->show_mode;
3222 do {
3223 next = (next + 1) % SHOW_MODE_NB;
3224 } while (next != is->show_mode && (next == SHOW_MODE_VIDEO && !is->video_st || next != SHOW_MODE_VIDEO && !is->audio_st));
3225 if (is->show_mode != next) {
3226 is->force_refresh = 1;
3227 is->show_mode = next;
3228 }
3229 }
3230
refresh_loop_wait_event(VideoState * is,SDL_Event * event)3231 static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
3232 double remaining_time = 0.0;
3233 SDL_PumpEvents();
3234 while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) {
3235 if (!cursor_hidden && av_gettime_relative() - cursor_last_shown > CURSOR_HIDE_DELAY) {
3236 SDL_ShowCursor(0);
3237 cursor_hidden = 1;
3238 }
3239 if (remaining_time > 0.0)
3240 av_usleep((int64_t)(remaining_time * 1000000.0));
3241 remaining_time = REFRESH_RATE;
3242 if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
3243 video_refresh(is, &remaining_time);
3244 SDL_PumpEvents();
3245 }
3246 }
3247
seek_chapter(VideoState * is,int incr)3248 static void seek_chapter(VideoState *is, int incr)
3249 {
3250 int64_t pos = get_master_clock(is) * AV_TIME_BASE;
3251 int i;
3252
3253 if (!is->ic->nb_chapters)
3254 return;
3255
3256 /* find the current chapter */
3257 for (i = 0; i < is->ic->nb_chapters; i++) {
3258 AVChapter *ch = is->ic->chapters[i];
3259 if (av_compare_ts(pos, AV_TIME_BASE_Q, ch->start, ch->time_base) < 0) {
3260 i--;
3261 break;
3262 }
3263 }
3264
3265 i += incr;
3266 i = FFMAX(i, 0);
3267 if (i >= is->ic->nb_chapters)
3268 return;
3269
3270 av_log(NULL, AV_LOG_VERBOSE, "Seeking to chapter %d.\n", i);
3271 stream_seek(is, av_rescale_q(is->ic->chapters[i]->start, is->ic->chapters[i]->time_base,
3272 AV_TIME_BASE_Q), 0, 0);
3273 }
3274
3275 /* handle an event sent by the GUI */
event_loop(VideoState * cur_stream)3276 static void event_loop(VideoState *cur_stream)
3277 {
3278 SDL_Event event;
3279 double incr, pos, frac;
3280
3281 for (;;) {
3282 double x;
3283 refresh_loop_wait_event(cur_stream, &event);
3284 switch (event.type) {
3285 case SDL_KEYDOWN:
3286 if (exit_on_keydown || event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_q) {
3287 do_exit(cur_stream);
3288 break;
3289 }
3290 // If we don't yet have a window, skip all key events, because read_thread might still be initializing...
3291 if (!cur_stream->width)
3292 continue;
3293 switch (event.key.keysym.sym) {
3294 case SDLK_f:
3295 toggle_full_screen(cur_stream);
3296 cur_stream->force_refresh = 1;
3297 break;
3298 case SDLK_p:
3299 case SDLK_SPACE:
3300 toggle_pause(cur_stream);
3301 break;
3302 case SDLK_m:
3303 toggle_mute(cur_stream);
3304 break;
3305 case SDLK_KP_MULTIPLY:
3306 case SDLK_0:
3307 update_volume(cur_stream, 1, SDL_VOLUME_STEP);
3308 break;
3309 case SDLK_KP_DIVIDE:
3310 case SDLK_9:
3311 update_volume(cur_stream, -1, SDL_VOLUME_STEP);
3312 break;
3313 case SDLK_s: // S: Step to next frame
3314 step_to_next_frame(cur_stream);
3315 break;
3316 case SDLK_a:
3317 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3318 break;
3319 case SDLK_v:
3320 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3321 break;
3322 case SDLK_c:
3323 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3324 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3325 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3326 break;
3327 case SDLK_t:
3328 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3329 break;
3330 case SDLK_w:
3331 #if CONFIG_AVFILTER
3332 if (cur_stream->show_mode == SHOW_MODE_VIDEO && cur_stream->vfilter_idx < nb_vfilters - 1) {
3333 if (++cur_stream->vfilter_idx >= nb_vfilters)
3334 cur_stream->vfilter_idx = 0;
3335 } else {
3336 cur_stream->vfilter_idx = 0;
3337 toggle_audio_display(cur_stream);
3338 }
3339 #else
3340 toggle_audio_display(cur_stream);
3341 #endif
3342 break;
3343 case SDLK_PAGEUP:
3344 if (cur_stream->ic->nb_chapters <= 1) {
3345 incr = 600.0;
3346 goto do_seek;
3347 }
3348 seek_chapter(cur_stream, 1);
3349 break;
3350 case SDLK_PAGEDOWN:
3351 if (cur_stream->ic->nb_chapters <= 1) {
3352 incr = -600.0;
3353 goto do_seek;
3354 }
3355 seek_chapter(cur_stream, -1);
3356 break;
3357 case SDLK_LEFT:
3358 incr = seek_interval ? -seek_interval : -10.0;
3359 goto do_seek;
3360 case SDLK_RIGHT:
3361 incr = seek_interval ? seek_interval : 10.0;
3362 goto do_seek;
3363 case SDLK_UP:
3364 incr = 60.0;
3365 goto do_seek;
3366 case SDLK_DOWN:
3367 incr = -60.0;
3368 do_seek:
3369 if (seek_by_bytes) {
3370 pos = -1;
3371 if (pos < 0 && cur_stream->video_stream >= 0)
3372 pos = frame_queue_last_pos(&cur_stream->pictq);
3373 if (pos < 0 && cur_stream->audio_stream >= 0)
3374 pos = frame_queue_last_pos(&cur_stream->sampq);
3375 if (pos < 0)
3376 pos = avio_tell(cur_stream->ic->pb);
3377 if (cur_stream->ic->bit_rate)
3378 incr *= cur_stream->ic->bit_rate / 8.0;
3379 else
3380 incr *= 180000.0;
3381 pos += incr;
3382 stream_seek(cur_stream, pos, incr, 1);
3383 } else {
3384 pos = get_master_clock(cur_stream);
3385 if (isnan(pos))
3386 pos = (double)cur_stream->seek_pos / AV_TIME_BASE;
3387 pos += incr;
3388 if (cur_stream->ic->start_time != AV_NOPTS_VALUE && pos < cur_stream->ic->start_time / (double)AV_TIME_BASE)
3389 pos = cur_stream->ic->start_time / (double)AV_TIME_BASE;
3390 stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE), 0);
3391 }
3392 break;
3393 default:
3394 break;
3395 }
3396 break;
3397 case SDL_MOUSEBUTTONDOWN:
3398 if (exit_on_mousedown) {
3399 do_exit(cur_stream);
3400 break;
3401 }
3402 if (event.button.button == SDL_BUTTON_LEFT) {
3403 static int64_t last_mouse_left_click = 0;
3404 if (av_gettime_relative() - last_mouse_left_click <= 500000) {
3405 toggle_full_screen(cur_stream);
3406 cur_stream->force_refresh = 1;
3407 last_mouse_left_click = 0;
3408 } else {
3409 last_mouse_left_click = av_gettime_relative();
3410 }
3411 }
3412 case SDL_MOUSEMOTION:
3413 if (cursor_hidden) {
3414 SDL_ShowCursor(1);
3415 cursor_hidden = 0;
3416 }
3417 cursor_last_shown = av_gettime_relative();
3418 if (event.type == SDL_MOUSEBUTTONDOWN) {
3419 if (event.button.button != SDL_BUTTON_RIGHT)
3420 break;
3421 x = event.button.x;
3422 } else {
3423 if (!(event.motion.state & SDL_BUTTON_RMASK))
3424 break;
3425 x = event.motion.x;
3426 }
3427 if (seek_by_bytes || cur_stream->ic->duration <= 0) {
3428 uint64_t size = avio_size(cur_stream->ic->pb);
3429 stream_seek(cur_stream, size*x/cur_stream->width, 0, 1);
3430 } else {
3431 int64_t ts;
3432 int ns, hh, mm, ss;
3433 int tns, thh, tmm, tss;
3434 tns = cur_stream->ic->duration / 1000000LL;
3435 thh = tns / 3600;
3436 tmm = (tns % 3600) / 60;
3437 tss = (tns % 60);
3438 frac = x / cur_stream->width;
3439 ns = frac * tns;
3440 hh = ns / 3600;
3441 mm = (ns % 3600) / 60;
3442 ss = (ns % 60);
3443 av_log(NULL, AV_LOG_INFO,
3444 "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d) \n", frac*100,
3445 hh, mm, ss, thh, tmm, tss);
3446 ts = frac * cur_stream->ic->duration;
3447 if (cur_stream->ic->start_time != AV_NOPTS_VALUE)
3448 ts += cur_stream->ic->start_time;
3449 stream_seek(cur_stream, ts, 0, 0);
3450 }
3451 break;
3452 case SDL_WINDOWEVENT:
3453 switch (event.window.event) {
3454 case SDL_WINDOWEVENT_SIZE_CHANGED:
3455 screen_width = cur_stream->width = event.window.data1;
3456 screen_height = cur_stream->height = event.window.data2;
3457 if (cur_stream->vis_texture) {
3458 SDL_DestroyTexture(cur_stream->vis_texture);
3459 cur_stream->vis_texture = NULL;
3460 }
3461 case SDL_WINDOWEVENT_EXPOSED:
3462 cur_stream->force_refresh = 1;
3463 }
3464 break;
3465 case SDL_QUIT:
3466 case FF_QUIT_EVENT:
3467 do_exit(cur_stream);
3468 break;
3469 default:
3470 break;
3471 }
3472 }
3473 }
3474
opt_frame_size(void * optctx,const char * opt,const char * arg)3475 static int opt_frame_size(void *optctx, const char *opt, const char *arg)
3476 {
3477 av_log(NULL, AV_LOG_WARNING, "Option -s is deprecated, use -video_size.\n");
3478 return opt_default(NULL, "video_size", arg);
3479 }
3480
opt_width(void * optctx,const char * opt,const char * arg)3481 static int opt_width(void *optctx, const char *opt, const char *arg)
3482 {
3483 screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3484 return 0;
3485 }
3486
opt_height(void * optctx,const char * opt,const char * arg)3487 static int opt_height(void *optctx, const char *opt, const char *arg)
3488 {
3489 screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3490 return 0;
3491 }
3492
opt_format(void * optctx,const char * opt,const char * arg)3493 static int opt_format(void *optctx, const char *opt, const char *arg)
3494 {
3495 file_iformat = av_find_input_format(arg);
3496 if (!file_iformat) {
3497 av_log(NULL, AV_LOG_FATAL, "Unknown input format: %s\n", arg);
3498 return AVERROR(EINVAL);
3499 }
3500 return 0;
3501 }
3502
opt_frame_pix_fmt(void * optctx,const char * opt,const char * arg)3503 static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
3504 {
3505 av_log(NULL, AV_LOG_WARNING, "Option -pix_fmt is deprecated, use -pixel_format.\n");
3506 return opt_default(NULL, "pixel_format", arg);
3507 }
3508
opt_sync(void * optctx,const char * opt,const char * arg)3509 static int opt_sync(void *optctx, const char *opt, const char *arg)
3510 {
3511 if (!strcmp(arg, "audio"))
3512 av_sync_type = AV_SYNC_AUDIO_MASTER;
3513 else if (!strcmp(arg, "video"))
3514 av_sync_type = AV_SYNC_VIDEO_MASTER;
3515 else if (!strcmp(arg, "ext"))
3516 av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
3517 else {
3518 av_log(NULL, AV_LOG_ERROR, "Unknown value for %s: %s\n", opt, arg);
3519 exit(1);
3520 }
3521 return 0;
3522 }
3523
opt_seek(void * optctx,const char * opt,const char * arg)3524 static int opt_seek(void *optctx, const char *opt, const char *arg)
3525 {
3526 start_time = parse_time_or_die(opt, arg, 1);
3527 return 0;
3528 }
3529
opt_duration(void * optctx,const char * opt,const char * arg)3530 static int opt_duration(void *optctx, const char *opt, const char *arg)
3531 {
3532 duration = parse_time_or_die(opt, arg, 1);
3533 return 0;
3534 }
3535
opt_show_mode(void * optctx,const char * opt,const char * arg)3536 static int opt_show_mode(void *optctx, const char *opt, const char *arg)
3537 {
3538 show_mode = !strcmp(arg, "video") ? SHOW_MODE_VIDEO :
3539 !strcmp(arg, "waves") ? SHOW_MODE_WAVES :
3540 !strcmp(arg, "rdft" ) ? SHOW_MODE_RDFT :
3541 parse_number_or_die(opt, arg, OPT_INT, 0, SHOW_MODE_NB-1);
3542 return 0;
3543 }
3544
opt_input_file(void * optctx,const char * filename)3545 static void opt_input_file(void *optctx, const char *filename)
3546 {
3547 if (input_filename) {
3548 av_log(NULL, AV_LOG_FATAL,
3549 "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3550 filename, input_filename);
3551 exit(1);
3552 }
3553 if (!strcmp(filename, "-"))
3554 filename = "pipe:";
3555 input_filename = filename;
3556 }
3557
opt_codec(void * optctx,const char * opt,const char * arg)3558 static int opt_codec(void *optctx, const char *opt, const char *arg)
3559 {
3560 const char *spec = strchr(opt, ':');
3561 if (!spec) {
3562 av_log(NULL, AV_LOG_ERROR,
3563 "No media specifier was specified in '%s' in option '%s'\n",
3564 arg, opt);
3565 return AVERROR(EINVAL);
3566 }
3567 spec++;
3568 switch (spec[0]) {
3569 case 'a' : audio_codec_name = arg; break;
3570 case 's' : subtitle_codec_name = arg; break;
3571 case 'v' : video_codec_name = arg; break;
3572 default:
3573 av_log(NULL, AV_LOG_ERROR,
3574 "Invalid media specifier '%s' in option '%s'\n", spec, opt);
3575 return AVERROR(EINVAL);
3576 }
3577 return 0;
3578 }
3579
3580 static int dummy;
3581
3582 static const OptionDef options[] = {
3583 CMDUTILS_COMMON_OPTIONS
3584 { "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
3585 { "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
3586 { "s", HAS_ARG | OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
3587 { "fs", OPT_BOOL, { &is_full_screen }, "force full screen" },
3588 { "an", OPT_BOOL, { &audio_disable }, "disable audio" },
3589 { "vn", OPT_BOOL, { &video_disable }, "disable video" },
3590 { "sn", OPT_BOOL, { &subtitle_disable }, "disable subtitling" },
3591 { "ast", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_specifier" },
3592 { "vst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_specifier" },
3593 { "sst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_specifier" },
3594 { "ss", HAS_ARG, { .func_arg = opt_seek }, "seek to a given position in seconds", "pos" },
3595 { "t", HAS_ARG, { .func_arg = opt_duration }, "play \"duration\" seconds of audio/video", "duration" },
3596 { "bytes", OPT_INT | HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
3597 { "seek_interval", OPT_FLOAT | HAS_ARG, { &seek_interval }, "set seek interval for left/right keys, in seconds", "seconds" },
3598 { "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
3599 { "noborder", OPT_BOOL, { &borderless }, "borderless window" },
3600 { "alwaysontop", OPT_BOOL, { &alwaysontop }, "window always on top" },
3601 { "volume", OPT_INT | HAS_ARG, { &startup_volume}, "set startup volume 0=min 100=max", "volume" },
3602 { "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
3603 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
3604 { "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" },
3605 { "fast", OPT_BOOL | OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
3606 { "genpts", OPT_BOOL | OPT_EXPERT, { &genpts }, "generate pts", "" },
3607 { "drp", OPT_INT | HAS_ARG | OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
3608 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, { &lowres }, "", "" },
3609 { "sync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
3610 { "autoexit", OPT_BOOL | OPT_EXPERT, { &autoexit }, "exit at the end", "" },
3611 { "exitonkeydown", OPT_BOOL | OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
3612 { "exitonmousedown", OPT_BOOL | OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
3613 { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
3614 { "framedrop", OPT_BOOL | OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
3615 { "infbuf", OPT_BOOL | OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
3616 { "window_title", OPT_STRING | HAS_ARG, { &window_title }, "set window title", "window title" },
3617 { "left", OPT_INT | HAS_ARG | OPT_EXPERT, { &screen_left }, "set the x position for the left of the window", "x pos" },
3618 { "top", OPT_INT | HAS_ARG | OPT_EXPERT, { &screen_top }, "set the y position for the top of the window", "y pos" },
3619 #if CONFIG_AVFILTER
3620 { "vf", OPT_EXPERT | HAS_ARG, { .func_arg = opt_add_vfilter }, "set video filters", "filter_graph" },
3621 { "af", OPT_STRING | HAS_ARG, { &afilters }, "set audio filters", "filter_graph" },
3622 #endif
3623 { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
3624 { "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
3625 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default }, "generic catch all option", "" },
3626 { "i", OPT_BOOL, { &dummy}, "read specified file", "input_file"},
3627 { "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
3628 { "acodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &audio_codec_name }, "force audio decoder", "decoder_name" },
3629 { "scodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
3630 { "vcodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &video_codec_name }, "force video decoder", "decoder_name" },
3631 { "autorotate", OPT_BOOL, { &autorotate }, "automatically rotate video", "" },
3632 { "find_stream_info", OPT_BOOL | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3633 "read and decode the streams to fill missing information with heuristics" },
3634 { "filter_threads", HAS_ARG | OPT_INT | OPT_EXPERT, { &filter_nbthreads }, "number of filter threads per graph" },
3635 { NULL, },
3636 };
3637
show_usage(void)3638 static void show_usage(void)
3639 {
3640 av_log(NULL, AV_LOG_INFO, "Simple media player\n");
3641 av_log(NULL, AV_LOG_INFO, "usage: %s [options] input_file\n", program_name);
3642 av_log(NULL, AV_LOG_INFO, "\n");
3643 }
3644
show_help_default(const char * opt,const char * arg)3645 void show_help_default(const char *opt, const char *arg)
3646 {
3647 av_log_set_callback(log_callback_help);
3648 show_usage();
3649 show_help_options(options, "Main options:", 0, OPT_EXPERT, 0);
3650 show_help_options(options, "Advanced options:", OPT_EXPERT, 0, 0);
3651 printf("\n");
3652 show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3653 show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3654 #if !CONFIG_AVFILTER
3655 show_help_children(sws_get_class(), AV_OPT_FLAG_ENCODING_PARAM);
3656 #else
3657 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
3658 #endif
3659 printf("\nWhile playing:\n"
3660 "q, ESC quit\n"
3661 "f toggle full screen\n"
3662 "p, SPC pause\n"
3663 "m toggle mute\n"
3664 "9, 0 decrease and increase volume respectively\n"
3665 "/, * decrease and increase volume respectively\n"
3666 "a cycle audio channel in the current program\n"
3667 "v cycle video channel\n"
3668 "t cycle subtitle channel in the current program\n"
3669 "c cycle program\n"
3670 "w cycle video filters or show modes\n"
3671 "s activate frame-step mode\n"
3672 "left/right seek backward/forward 10 seconds or to custom interval if -seek_interval is set\n"
3673 "down/up seek backward/forward 1 minute\n"
3674 "page down/page up seek backward/forward 10 minutes\n"
3675 "right mouse click seek to percentage in file corresponding to fraction of width\n"
3676 "left double-click toggle full screen\n"
3677 );
3678 }
3679
3680 /* Called from the main */
main(int argc,char ** argv)3681 int main(int argc, char **argv)
3682 {
3683 int flags;
3684 VideoState *is;
3685
3686 init_dynload();
3687
3688 av_log_set_flags(AV_LOG_SKIP_REPEATED);
3689 parse_loglevel(argc, argv, options);
3690
3691 /* register all codecs, demux and protocols */
3692 #if CONFIG_AVDEVICE
3693 avdevice_register_all();
3694 #endif
3695 avformat_network_init();
3696
3697 init_opts();
3698
3699 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
3700 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
3701
3702 show_banner(argc, argv, options);
3703
3704 parse_options(NULL, argc, argv, options, opt_input_file);
3705
3706 if (!input_filename) {
3707 show_usage();
3708 av_log(NULL, AV_LOG_FATAL, "An input file must be specified\n");
3709 av_log(NULL, AV_LOG_FATAL,
3710 "Use -h to get full help or, even better, run 'man %s'\n", program_name);
3711 exit(1);
3712 }
3713
3714 if (display_disable) {
3715 video_disable = 1;
3716 }
3717 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
3718 if (audio_disable)
3719 flags &= ~SDL_INIT_AUDIO;
3720 else {
3721 /* Try to work around an occasional ALSA buffer underflow issue when the
3722 * period size is NPOT due to ALSA resampling by forcing the buffer size. */
3723 if (!SDL_getenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE"))
3724 SDL_setenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE","1", 1);
3725 }
3726 if (display_disable)
3727 flags &= ~SDL_INIT_VIDEO;
3728 if (SDL_Init (flags)) {
3729 av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n", SDL_GetError());
3730 av_log(NULL, AV_LOG_FATAL, "(Did you set the DISPLAY variable?)\n");
3731 exit(1);
3732 }
3733
3734 SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
3735 SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
3736
3737 av_init_packet(&flush_pkt);
3738 flush_pkt.data = (uint8_t *)&flush_pkt;
3739
3740 if (!display_disable) {
3741 int flags = SDL_WINDOW_HIDDEN;
3742 if (alwaysontop)
3743 #if SDL_VERSION_ATLEAST(2,0,5)
3744 flags |= SDL_WINDOW_ALWAYS_ON_TOP;
3745 #else
3746 av_log(NULL, AV_LOG_WARNING, "Your SDL version doesn't support SDL_WINDOW_ALWAYS_ON_TOP. Feature will be inactive.\n");
3747 #endif
3748 if (borderless)
3749 flags |= SDL_WINDOW_BORDERLESS;
3750 else
3751 flags |= SDL_WINDOW_RESIZABLE;
3752 window = SDL_CreateWindow(program_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, default_width, default_height, flags);
3753 SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
3754 if (window) {
3755 renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
3756 if (!renderer) {
3757 av_log(NULL, AV_LOG_WARNING, "Failed to initialize a hardware accelerated renderer: %s\n", SDL_GetError());
3758 renderer = SDL_CreateRenderer(window, -1, 0);
3759 }
3760 if (renderer) {
3761 if (!SDL_GetRendererInfo(renderer, &renderer_info))
3762 av_log(NULL, AV_LOG_VERBOSE, "Initialized %s renderer.\n", renderer_info.name);
3763 }
3764 }
3765 if (!window || !renderer || !renderer_info.num_texture_formats) {
3766 av_log(NULL, AV_LOG_FATAL, "Failed to create window or renderer: %s", SDL_GetError());
3767 do_exit(NULL);
3768 }
3769 }
3770
3771 is = stream_open(input_filename, file_iformat);
3772 if (!is) {
3773 av_log(NULL, AV_LOG_FATAL, "Failed to initialize VideoState!\n");
3774 do_exit(NULL);
3775 }
3776
3777 event_loop(is);
3778
3779 /* never returns */
3780
3781 return 0;
3782 }
3783