2 * Copyright (c) 2003 Fabrice Bellard
4 * This file is part of FFmpeg.
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.
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.
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
23 * simple media player based on the FFmpeg libraries
33 #include "libavutil/avstring.h"
34 #include "libavutil/colorspace.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 "libavformat/avformat.h"
44 #include "libavdevice/avdevice.h"
45 #include "libswscale/swscale.h"
46 #include "libavutil/opt.h"
47 #include "libavcodec/avfft.h"
48 #include "libswresample/swresample.h"
51 # include "libavfilter/avcodec.h"
52 # include "libavfilter/avfilter.h"
53 # include "libavfilter/buffersink.h"
54 # include "libavfilter/buffersrc.h"
58 #include <SDL_thread.h>
64 const char program_name[] = "ffplay";
65 const int program_birth_year = 2003;
67 #define MAX_QUEUE_SIZE (15 * 1024 * 1024)
70 /* SDL audio buffer size, in samples. Should be small to have precise
71 A/V sync as SDL does not have hardware buffer fullness info. */
72 #define SDL_AUDIO_BUFFER_SIZE 1024
74 /* no AV sync correction is done if below the minimum AV sync threshold */
75 #define AV_SYNC_THRESHOLD_MIN 0.01
76 /* AV sync correction is done if above the maximum AV sync threshold */
77 #define AV_SYNC_THRESHOLD_MAX 0.1
78 /* If a frame duration is longer than this, it will not be duplicated to compensate AV sync */
79 #define AV_SYNC_FRAMEDUP_THRESHOLD 0.1
80 /* no AV correction is done if too big error */
81 #define AV_NOSYNC_THRESHOLD 10.0
83 /* maximum audio speed change to get correct sync */
84 #define SAMPLE_CORRECTION_PERCENT_MAX 10
86 /* external clock speed adjustment constants for realtime sources based on buffer fullness */
87 #define EXTERNAL_CLOCK_SPEED_MIN 0.900
88 #define EXTERNAL_CLOCK_SPEED_MAX 1.010
89 #define EXTERNAL_CLOCK_SPEED_STEP 0.001
91 /* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
92 #define AUDIO_DIFF_AVG_NB 20
94 /* polls for possible required screen refresh at least this often, should be less than 1/fps */
95 #define REFRESH_RATE 0.01
97 /* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
98 /* TODO: We assume that a decoded and resampled frame fits into this buffer */
99 #define SAMPLE_ARRAY_SIZE (8 * 65536)
101 #define CURSOR_HIDE_DELAY 1000000
103 static int64_t sws_flags = SWS_BICUBIC;
105 typedef struct MyAVPacketList {
107 struct MyAVPacketList *next;
111 typedef struct PacketQueue {
112 MyAVPacketList *first_pkt, *last_pkt;
121 #define VIDEO_PICTURE_QUEUE_SIZE 3
122 #define SUBPICTURE_QUEUE_SIZE 4
124 typedef struct VideoPicture {
125 double pts; // presentation timestamp for this picture
126 double duration; // estimated duration based on frame rate
127 int64_t pos; // byte position in file
129 int width, height; /* source height & width */
137 typedef struct SubPicture {
138 double pts; /* presentation time stamp for this picture */
143 typedef struct AudioParams {
146 int64_t channel_layout;
147 enum AVSampleFormat fmt;
150 typedef struct Clock {
151 double pts; /* clock base */
152 double pts_drift; /* clock base minus time at which we updated the clock */
155 int serial; /* clock is based on a packet with this serial */
157 int *queue_serial; /* pointer to the current packet queue serial, used for obsolete clock detection */
161 AV_SYNC_AUDIO_MASTER, /* default choice */
162 AV_SYNC_VIDEO_MASTER,
163 AV_SYNC_EXTERNAL_CLOCK, /* synchronize to an external clock */
166 typedef struct VideoState {
167 SDL_Thread *read_tid;
168 SDL_Thread *video_tid;
169 AVInputFormat *iformat;
175 int queue_attachments_req;
180 int read_pause_return;
195 int audio_clock_serial;
196 double audio_diff_cum; /* used for AV difference average computation */
197 double audio_diff_avg_coef;
198 double audio_diff_threshold;
199 int audio_diff_avg_count;
202 int audio_hw_buf_size;
203 uint8_t silence_buf[SDL_AUDIO_BUFFER_SIZE];
206 unsigned int audio_buf_size; /* in bytes */
207 unsigned int audio_buf1_size;
208 int audio_buf_index; /* in bytes */
209 int audio_write_buf_size;
210 int audio_buf_frames_pending;
211 AVPacket audio_pkt_temp;
213 int audio_pkt_temp_serial;
214 int audio_last_serial;
215 struct AudioParams audio_src;
217 struct AudioParams audio_filter_src;
219 struct AudioParams audio_tgt;
220 struct SwrContext *swr_ctx;
221 int frame_drops_early;
222 int frame_drops_late;
224 int64_t audio_frame_next_pts;
227 SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO = 0, SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB
229 int16_t sample_array[SAMPLE_ARRAY_SIZE];
230 int sample_array_index;
234 FFTSample *rdft_data;
236 double last_vis_time;
238 SDL_Thread *subtitle_tid;
240 AVStream *subtitle_st;
241 PacketQueue subtitleq;
242 SubPicture subpq[SUBPICTURE_QUEUE_SIZE];
243 int subpq_size, subpq_rindex, subpq_windex;
244 SDL_mutex *subpq_mutex;
245 SDL_cond *subpq_cond;
248 double frame_last_returned_time;
249 double frame_last_filter_delay;
253 int64_t video_current_pos; // current displayed file pos
254 double max_frame_duration; // maximum duration of a frame - above this, we consider the jump a timestamp discontinuity
255 VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];
256 int pictq_size, pictq_rindex, pictq_windex;
257 SDL_mutex *pictq_mutex;
258 SDL_cond *pictq_cond;
260 struct SwsContext *img_convert_ctx;
262 SDL_Rect last_display_rect;
265 int width, height, xleft, ytop;
269 AVFilterContext *in_video_filter; // the first filter in the video chain
270 AVFilterContext *out_video_filter; // the last filter in the video chain
271 AVFilterContext *in_audio_filter; // the first filter in the audio chain
272 AVFilterContext *out_audio_filter; // the last filter in the audio chain
273 AVFilterGraph *agraph; // audio filter graph
276 int last_video_stream, last_audio_stream, last_subtitle_stream;
278 SDL_cond *continue_read_thread;
281 /* options specified by the user */
282 static AVInputFormat *file_iformat;
283 static const char *input_filename;
284 static const char *window_title;
285 static int fs_screen_width;
286 static int fs_screen_height;
287 static int default_width = 640;
288 static int default_height = 480;
289 static int screen_width = 0;
290 static int screen_height = 0;
291 static int audio_disable;
292 static int video_disable;
293 static int subtitle_disable;
294 static int wanted_stream[AVMEDIA_TYPE_NB] = {
295 [AVMEDIA_TYPE_AUDIO] = -1,
296 [AVMEDIA_TYPE_VIDEO] = -1,
297 [AVMEDIA_TYPE_SUBTITLE] = -1,
299 static int seek_by_bytes = -1;
300 static int display_disable;
301 static int show_status = 1;
302 static int av_sync_type = AV_SYNC_AUDIO_MASTER;
303 static int64_t start_time = AV_NOPTS_VALUE;
304 static int64_t duration = AV_NOPTS_VALUE;
305 static int workaround_bugs = 1;
307 static int genpts = 0;
308 static int lowres = 0;
309 static int error_concealment = 3;
310 static int decoder_reorder_pts = -1;
312 static int exit_on_keydown;
313 static int exit_on_mousedown;
315 static int framedrop = -1;
316 static int infinite_buffer = -1;
317 static enum ShowMode show_mode = SHOW_MODE_NONE;
318 static const char *audio_codec_name;
319 static const char *subtitle_codec_name;
320 static const char *video_codec_name;
321 double rdftspeed = 0.02;
322 static int64_t cursor_last_shown;
323 static int cursor_hidden = 0;
325 static char *vfilters = NULL;
326 static char *afilters = NULL;
329 /* current context */
330 static int is_full_screen;
331 static int64_t audio_callback_time;
333 static AVPacket flush_pkt;
335 #define FF_ALLOC_EVENT (SDL_USEREVENT)
336 #define FF_QUIT_EVENT (SDL_USEREVENT + 2)
338 static SDL_Surface *screen;
341 int cmp_audio_fmts(enum AVSampleFormat fmt1, int64_t channel_count1,
342 enum AVSampleFormat fmt2, int64_t channel_count2)
344 /* If channel count == 1, planar and non-planar formats are the same */
345 if (channel_count1 == 1 && channel_count2 == 1)
346 return av_get_packed_sample_fmt(fmt1) != av_get_packed_sample_fmt(fmt2);
348 return channel_count1 != channel_count2 || fmt1 != fmt2;
352 int64_t get_valid_channel_layout(int64_t channel_layout, int channels)
354 if (channel_layout && av_get_channel_layout_nb_channels(channel_layout) == channels)
355 return channel_layout;
360 static int packet_queue_put(PacketQueue *q, AVPacket *pkt);
362 static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
364 MyAVPacketList *pkt1;
366 if (q->abort_request)
369 pkt1 = av_malloc(sizeof(MyAVPacketList));
374 if (pkt == &flush_pkt)
376 pkt1->serial = q->serial;
381 q->last_pkt->next = pkt1;
384 q->size += pkt1->pkt.size + sizeof(*pkt1);
385 /* XXX: should duplicate packet data in DV case */
386 SDL_CondSignal(q->cond);
390 static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
394 /* duplicate the packet */
395 if (pkt != &flush_pkt && av_dup_packet(pkt) < 0)
398 SDL_LockMutex(q->mutex);
399 ret = packet_queue_put_private(q, pkt);
400 SDL_UnlockMutex(q->mutex);
402 if (pkt != &flush_pkt && ret < 0)
408 static int packet_queue_put_nullpacket(PacketQueue *q, int stream_index)
410 AVPacket pkt1, *pkt = &pkt1;
414 pkt->stream_index = stream_index;
415 return packet_queue_put(q, pkt);
418 /* packet queue handling */
419 static void packet_queue_init(PacketQueue *q)
421 memset(q, 0, sizeof(PacketQueue));
422 q->mutex = SDL_CreateMutex();
423 q->cond = SDL_CreateCond();
424 q->abort_request = 1;
427 static void packet_queue_flush(PacketQueue *q)
429 MyAVPacketList *pkt, *pkt1;
431 SDL_LockMutex(q->mutex);
432 for (pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
434 av_free_packet(&pkt->pkt);
441 SDL_UnlockMutex(q->mutex);
444 static void packet_queue_destroy(PacketQueue *q)
446 packet_queue_flush(q);
447 SDL_DestroyMutex(q->mutex);
448 SDL_DestroyCond(q->cond);
451 static void packet_queue_abort(PacketQueue *q)
453 SDL_LockMutex(q->mutex);
455 q->abort_request = 1;
457 SDL_CondSignal(q->cond);
459 SDL_UnlockMutex(q->mutex);
462 static void packet_queue_start(PacketQueue *q)
464 SDL_LockMutex(q->mutex);
465 q->abort_request = 0;
466 packet_queue_put_private(q, &flush_pkt);
467 SDL_UnlockMutex(q->mutex);
470 /* return < 0 if aborted, 0 if no packet and > 0 if packet. */
471 static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)
473 MyAVPacketList *pkt1;
476 SDL_LockMutex(q->mutex);
479 if (q->abort_request) {
486 q->first_pkt = pkt1->next;
490 q->size -= pkt1->pkt.size + sizeof(*pkt1);
493 *serial = pkt1->serial;
501 SDL_CondWait(q->cond, q->mutex);
504 SDL_UnlockMutex(q->mutex);
508 static inline void fill_rectangle(SDL_Surface *screen,
509 int x, int y, int w, int h, int color, int update)
516 SDL_FillRect(screen, &rect, color);
517 if (update && w > 0 && h > 0)
518 SDL_UpdateRect(screen, x, y, w, h);
521 /* draw only the border of a rectangle */
522 static void fill_border(int xleft, int ytop, int width, int height, int x, int y, int w, int h, int color, int update)
526 /* fill the background */
530 w2 = width - (x + w);
536 h2 = height - (y + h);
539 fill_rectangle(screen,
543 fill_rectangle(screen,
544 xleft + width - w2, ytop,
547 fill_rectangle(screen,
551 fill_rectangle(screen,
552 xleft + w1, ytop + height - h2,
557 #define ALPHA_BLEND(a, oldp, newp, s)\
558 ((((oldp << s) * (255 - (a))) + (newp * (a))) / (255 << s))
560 #define RGBA_IN(r, g, b, a, s)\
562 unsigned int v = ((const uint32_t *)(s))[0];\
563 a = (v >> 24) & 0xff;\
564 r = (v >> 16) & 0xff;\
565 g = (v >> 8) & 0xff;\
569 #define YUVA_IN(y, u, v, a, s, pal)\
571 unsigned int val = ((const uint32_t *)(pal))[*(const uint8_t*)(s)];\
572 a = (val >> 24) & 0xff;\
573 y = (val >> 16) & 0xff;\
574 u = (val >> 8) & 0xff;\
578 #define YUVA_OUT(d, y, u, v, a)\
580 ((uint32_t *)(d))[0] = (a << 24) | (y << 16) | (u << 8) | v;\
586 static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect, int imgw, int imgh)
588 int wrap, wrap3, width2, skip2;
589 int y, u, v, a, u1, v1, a1, w, h;
590 uint8_t *lum, *cb, *cr;
593 int dstx, dsty, dstw, dsth;
595 dstw = av_clip(rect->w, 0, imgw);
596 dsth = av_clip(rect->h, 0, imgh);
597 dstx = av_clip(rect->x, 0, imgw - dstw);
598 dsty = av_clip(rect->y, 0, imgh - dsth);
599 lum = dst->data[0] + dsty * dst->linesize[0];
600 cb = dst->data[1] + (dsty >> 1) * dst->linesize[1];
601 cr = dst->data[2] + (dsty >> 1) * dst->linesize[2];
603 width2 = ((dstw + 1) >> 1) + (dstx & ~dstw & 1);
605 wrap = dst->linesize[0];
606 wrap3 = rect->pict.linesize[0];
607 p = rect->pict.data[0];
608 pal = (const uint32_t *)rect->pict.data[1]; /* Now in YCrCb! */
616 YUVA_IN(y, u, v, a, p, pal);
617 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
618 cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
619 cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
625 for (w = dstw - (dstx & 1); w >= 2; w -= 2) {
626 YUVA_IN(y, u, v, a, p, pal);
630 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
632 YUVA_IN(y, u, v, a, p + BPP, pal);
636 lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
637 cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
638 cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
645 YUVA_IN(y, u, v, a, p, pal);
646 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
647 cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
648 cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
652 p += wrap3 - dstw * BPP;
653 lum += wrap - dstw - dstx;
654 cb += dst->linesize[1] - width2 - skip2;
655 cr += dst->linesize[2] - width2 - skip2;
657 for (h = dsth - (dsty & 1); h >= 2; h -= 2) {
663 YUVA_IN(y, u, v, a, p, pal);
667 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
670 YUVA_IN(y, u, v, a, p, pal);
674 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
675 cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
676 cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
682 for (w = dstw - (dstx & 1); w >= 2; w -= 2) {
683 YUVA_IN(y, u, v, a, p, pal);
687 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
689 YUVA_IN(y, u, v, a, p + BPP, pal);
693 lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
697 YUVA_IN(y, u, v, a, p, pal);
701 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
703 YUVA_IN(y, u, v, a, p + BPP, pal);
707 lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
709 cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 2);
710 cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 2);
714 p += -wrap3 + 2 * BPP;
718 YUVA_IN(y, u, v, a, p, pal);
722 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
725 YUVA_IN(y, u, v, a, p, pal);
729 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
730 cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
731 cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
737 p += wrap3 + (wrap3 - dstw * BPP);
738 lum += wrap + (wrap - dstw - dstx);
739 cb += dst->linesize[1] - width2 - skip2;
740 cr += dst->linesize[2] - width2 - skip2;
742 /* handle odd height */
749 YUVA_IN(y, u, v, a, p, pal);
750 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
751 cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
752 cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
758 for (w = dstw - (dstx & 1); w >= 2; w -= 2) {
759 YUVA_IN(y, u, v, a, p, pal);
763 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
765 YUVA_IN(y, u, v, a, p + BPP, pal);
769 lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
770 cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u, 1);
771 cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v, 1);
778 YUVA_IN(y, u, v, a, p, pal);
779 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
780 cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
781 cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
786 static void free_picture(VideoPicture *vp)
789 SDL_FreeYUVOverlay(vp->bmp);
794 static void free_subpicture(SubPicture *sp)
796 avsubtitle_free(&sp->sub);
799 static void calculate_display_rect(SDL_Rect *rect, int scr_xleft, int scr_ytop, int scr_width, int scr_height, VideoPicture *vp)
802 int width, height, x, y;
804 if (vp->sar.num == 0)
807 aspect_ratio = av_q2d(vp->sar);
809 if (aspect_ratio <= 0.0)
811 aspect_ratio *= (float)vp->width / (float)vp->height;
813 /* XXX: we suppose the screen has a 1.0 pixel ratio */
815 width = ((int)rint(height * aspect_ratio)) & ~1;
816 if (width > scr_width) {
818 height = ((int)rint(width / aspect_ratio)) & ~1;
820 x = (scr_width - width) / 2;
821 y = (scr_height - height) / 2;
822 rect->x = scr_xleft + x;
823 rect->y = scr_ytop + y;
824 rect->w = FFMAX(width, 1);
825 rect->h = FFMAX(height, 1);
828 static void video_image_display(VideoState *is)
836 vp = &is->pictq[is->pictq_rindex];
838 if (is->subtitle_st) {
839 if (is->subpq_size > 0) {
840 sp = &is->subpq[is->subpq_rindex];
842 if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {
843 SDL_LockYUVOverlay (vp->bmp);
845 pict.data[0] = vp->bmp->pixels[0];
846 pict.data[1] = vp->bmp->pixels[2];
847 pict.data[2] = vp->bmp->pixels[1];
849 pict.linesize[0] = vp->bmp->pitches[0];
850 pict.linesize[1] = vp->bmp->pitches[2];
851 pict.linesize[2] = vp->bmp->pitches[1];
853 for (i = 0; i < sp->sub.num_rects; i++)
854 blend_subrect(&pict, sp->sub.rects[i],
855 vp->bmp->w, vp->bmp->h);
857 SDL_UnlockYUVOverlay (vp->bmp);
862 calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp);
864 SDL_DisplayYUVOverlay(vp->bmp, &rect);
866 if (rect.x != is->last_display_rect.x || rect.y != is->last_display_rect.y || rect.w != is->last_display_rect.w || rect.h != is->last_display_rect.h || is->force_refresh) {
867 int bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
868 fill_border(is->xleft, is->ytop, is->width, is->height, rect.x, rect.y, rect.w, rect.h, bgcolor, 1);
869 is->last_display_rect = rect;
874 static inline int compute_mod(int a, int b)
876 return a < 0 ? a%b + b : a%b;
879 static void video_audio_display(VideoState *s)
881 int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
882 int ch, channels, h, h2, bgcolor, fgcolor;
884 int rdft_bits, nb_freq;
886 for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++)
888 nb_freq = 1 << (rdft_bits - 1);
890 /* compute display index : center on currently output samples */
891 channels = s->audio_tgt.channels;
892 nb_display_channels = channels;
894 int data_used= s->show_mode == SHOW_MODE_WAVES ? s->width : (2*nb_freq);
896 delay = s->audio_write_buf_size;
899 /* to be more precise, we take into account the time spent since
900 the last buffer computation */
901 if (audio_callback_time) {
902 time_diff = av_gettime() - audio_callback_time;
903 delay -= (time_diff * s->audio_tgt.freq) / 1000000;
906 delay += 2 * data_used;
907 if (delay < data_used)
910 i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
911 if (s->show_mode == SHOW_MODE_WAVES) {
913 for (i = 0; i < 1000; i += channels) {
914 int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
915 int a = s->sample_array[idx];
916 int b = s->sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];
917 int c = s->sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];
918 int d = s->sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];
920 if (h < score && (b ^ c) < 0) {
927 s->last_i_start = i_start;
929 i_start = s->last_i_start;
932 bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
933 if (s->show_mode == SHOW_MODE_WAVES) {
934 fill_rectangle(screen,
935 s->xleft, s->ytop, s->width, s->height,
938 fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);
940 /* total height for one channel */
941 h = s->height / nb_display_channels;
942 /* graph height / 2 */
944 for (ch = 0; ch < nb_display_channels; ch++) {
946 y1 = s->ytop + ch * h + (h / 2); /* position of center line */
947 for (x = 0; x < s->width; x++) {
948 y = (s->sample_array[i] * h2) >> 15;
955 fill_rectangle(screen,
956 s->xleft + x, ys, 1, y,
959 if (i >= SAMPLE_ARRAY_SIZE)
960 i -= SAMPLE_ARRAY_SIZE;
964 fgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff);
966 for (ch = 1; ch < nb_display_channels; ch++) {
967 y = s->ytop + ch * h;
968 fill_rectangle(screen,
969 s->xleft, y, s->width, 1,
972 SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height);
974 nb_display_channels= FFMIN(nb_display_channels, 2);
975 if (rdft_bits != s->rdft_bits) {
976 av_rdft_end(s->rdft);
977 av_free(s->rdft_data);
978 s->rdft = av_rdft_init(rdft_bits, DFT_R2C);
979 s->rdft_bits = rdft_bits;
980 s->rdft_data = av_malloc(4 * nb_freq * sizeof(*s->rdft_data));
984 for (ch = 0; ch < nb_display_channels; ch++) {
985 data[ch] = s->rdft_data + 2 * nb_freq * ch;
987 for (x = 0; x < 2 * nb_freq; x++) {
988 double w = (x-nb_freq) * (1.0 / nb_freq);
989 data[ch][x] = s->sample_array[i] * (1.0 - w * w);
991 if (i >= SAMPLE_ARRAY_SIZE)
992 i -= SAMPLE_ARRAY_SIZE;
994 av_rdft_calc(s->rdft, data[ch]);
996 /* Least efficient way to do this, we should of course
997 * directly access it but it is more than fast enough. */
998 for (y = 0; y < s->height; y++) {
999 double w = 1 / sqrt(nb_freq);
1000 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]));
1001 int b = (nb_display_channels == 2 ) ? sqrt(w * sqrt(data[1][2 * y + 0] * data[1][2 * y + 0]
1002 + data[1][2 * y + 1] * data[1][2 * y + 1])) : a;
1005 fgcolor = SDL_MapRGB(screen->format, a, b, (a + b) / 2);
1007 fill_rectangle(screen,
1008 s->xpos, s->height-y, 1, 1,
1012 SDL_UpdateRect(screen, s->xpos, s->ytop, 1, s->height);
1015 if (s->xpos >= s->width)
1020 static void stream_close(VideoState *is)
1023 /* XXX: use a special url_shutdown call to abort parse cleanly */
1024 is->abort_request = 1;
1025 SDL_WaitThread(is->read_tid, NULL);
1026 packet_queue_destroy(&is->videoq);
1027 packet_queue_destroy(&is->audioq);
1028 packet_queue_destroy(&is->subtitleq);
1030 /* free all pictures */
1031 for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++)
1032 free_picture(&is->pictq[i]);
1033 for (i = 0; i < SUBPICTURE_QUEUE_SIZE; i++)
1034 free_subpicture(&is->subpq[i]);
1035 SDL_DestroyMutex(is->pictq_mutex);
1036 SDL_DestroyCond(is->pictq_cond);
1037 SDL_DestroyMutex(is->subpq_mutex);
1038 SDL_DestroyCond(is->subpq_cond);
1039 SDL_DestroyCond(is->continue_read_thread);
1040 #if !CONFIG_AVFILTER
1041 sws_freeContext(is->img_convert_ctx);
1046 static void do_exit(VideoState *is)
1051 av_lockmgr_register(NULL);
1054 av_freep(&vfilters);
1056 avformat_network_deinit();
1060 av_log(NULL, AV_LOG_QUIET, "%s", "");
1064 static void sigterm_handler(int sig)
1069 static int video_open(VideoState *is, int force_set_video_mode, VideoPicture *vp)
1071 int flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL;
1075 if (is_full_screen) flags |= SDL_FULLSCREEN;
1076 else flags |= SDL_RESIZABLE;
1078 if (vp && vp->width) {
1079 calculate_display_rect(&rect, 0, 0, INT_MAX, vp->height, vp);
1080 default_width = rect.w;
1081 default_height = rect.h;
1084 if (is_full_screen && fs_screen_width) {
1085 w = fs_screen_width;
1086 h = fs_screen_height;
1087 } else if (!is_full_screen && screen_width) {
1094 w = FFMIN(16383, w);
1095 if (screen && is->width == screen->w && screen->w == w
1096 && is->height== screen->h && screen->h == h && !force_set_video_mode)
1098 screen = SDL_SetVideoMode(w, h, 0, flags);
1100 av_log(NULL, AV_LOG_FATAL, "SDL: could not set video mode - exiting\n");
1104 window_title = input_filename;
1105 SDL_WM_SetCaption(window_title, window_title);
1107 is->width = screen->w;
1108 is->height = screen->h;
1113 /* display the current picture, if any */
1114 static void video_display(VideoState *is)
1117 video_open(is, 0, NULL);
1118 if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
1119 video_audio_display(is);
1120 else if (is->video_st)
1121 video_image_display(is);
1124 static double get_clock(Clock *c)
1126 if (*c->queue_serial != c->serial)
1131 double time = av_gettime() / 1000000.0;
1132 return c->pts_drift + time - (time - c->last_updated) * (1.0 - c->speed);
1136 static void set_clock_at(Clock *c, double pts, int serial, double time)
1139 c->last_updated = time;
1140 c->pts_drift = c->pts - time;
1144 static void set_clock(Clock *c, double pts, int serial)
1146 double time = av_gettime() / 1000000.0;
1147 set_clock_at(c, pts, serial, time);
1150 static void set_clock_speed(Clock *c, double speed)
1152 set_clock(c, get_clock(c), c->serial);
1156 static void init_clock(Clock *c, int *queue_serial)
1160 c->queue_serial = queue_serial;
1161 set_clock(c, NAN, -1);
1164 static void sync_clock_to_slave(Clock *c, Clock *slave)
1166 double clock = get_clock(c);
1167 double slave_clock = get_clock(slave);
1168 if (!isnan(slave_clock) && (isnan(clock) || fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))
1169 set_clock(c, slave_clock, slave->serial);
1172 static int get_master_sync_type(VideoState *is) {
1173 if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
1175 return AV_SYNC_VIDEO_MASTER;
1177 return AV_SYNC_AUDIO_MASTER;
1178 } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
1180 return AV_SYNC_AUDIO_MASTER;
1182 return AV_SYNC_EXTERNAL_CLOCK;
1184 return AV_SYNC_EXTERNAL_CLOCK;
1188 /* get the current master clock value */
1189 static double get_master_clock(VideoState *is)
1193 switch (get_master_sync_type(is)) {
1194 case AV_SYNC_VIDEO_MASTER:
1195 val = get_clock(&is->vidclk);
1197 case AV_SYNC_AUDIO_MASTER:
1198 val = get_clock(&is->audclk);
1201 val = get_clock(&is->extclk);
1207 static void check_external_clock_speed(VideoState *is) {
1208 if (is->video_stream >= 0 && is->videoq.nb_packets <= MIN_FRAMES / 2 ||
1209 is->audio_stream >= 0 && is->audioq.nb_packets <= MIN_FRAMES / 2) {
1210 set_clock_speed(&is->extclk, FFMAX(EXTERNAL_CLOCK_SPEED_MIN, is->extclk.speed - EXTERNAL_CLOCK_SPEED_STEP));
1211 } else if ((is->video_stream < 0 || is->videoq.nb_packets > MIN_FRAMES * 2) &&
1212 (is->audio_stream < 0 || is->audioq.nb_packets > MIN_FRAMES * 2)) {
1213 set_clock_speed(&is->extclk, FFMIN(EXTERNAL_CLOCK_SPEED_MAX, is->extclk.speed + EXTERNAL_CLOCK_SPEED_STEP));
1215 double speed = is->extclk.speed;
1217 set_clock_speed(&is->extclk, speed + EXTERNAL_CLOCK_SPEED_STEP * (1.0 - speed) / fabs(1.0 - speed));
1221 /* seek in the stream */
1222 static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)
1224 if (!is->seek_req) {
1227 is->seek_flags &= ~AVSEEK_FLAG_BYTE;
1229 is->seek_flags |= AVSEEK_FLAG_BYTE;
1231 SDL_CondSignal(is->continue_read_thread);
1235 /* pause or resume the video */
1236 static void stream_toggle_pause(VideoState *is)
1239 is->frame_timer += av_gettime() / 1000000.0 + is->vidclk.pts_drift - is->vidclk.pts;
1240 if (is->read_pause_return != AVERROR(ENOSYS)) {
1241 is->vidclk.paused = 0;
1243 set_clock(&is->vidclk, get_clock(&is->vidclk), is->vidclk.serial);
1245 set_clock(&is->extclk, get_clock(&is->extclk), is->extclk.serial);
1246 is->paused = is->audclk.paused = is->vidclk.paused = is->extclk.paused = !is->paused;
1249 static void toggle_pause(VideoState *is)
1251 stream_toggle_pause(is);
1255 static void step_to_next_frame(VideoState *is)
1257 /* if the stream is paused unpause it, then step */
1259 stream_toggle_pause(is);
1263 static double compute_target_delay(double delay, VideoState *is)
1265 double sync_threshold, diff;
1267 /* update delay to follow master synchronisation source */
1268 if (get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER) {
1269 /* if video is slave, we try to correct big delays by
1270 duplicating or deleting a frame */
1271 diff = get_clock(&is->vidclk) - get_master_clock(is);
1273 /* skip or repeat frame. We take into account the
1274 delay to compute the threshold. I still don't know
1275 if it is the best guess */
1276 sync_threshold = FFMAX(AV_SYNC_THRESHOLD_MIN, FFMIN(AV_SYNC_THRESHOLD_MAX, delay));
1277 if (!isnan(diff) && fabs(diff) < is->max_frame_duration) {
1278 if (diff <= -sync_threshold)
1279 delay = FFMAX(0, delay + diff);
1280 else if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD)
1281 delay = delay + diff;
1282 else if (diff >= sync_threshold)
1287 av_dlog(NULL, "video: delay=%0.3f A-V=%f\n",
1293 static double vp_duration(VideoState *is, VideoPicture *vp, VideoPicture *nextvp) {
1294 if (vp->serial == nextvp->serial) {
1295 double duration = nextvp->pts - vp->pts;
1296 if (isnan(duration) || duration <= 0 || duration > is->max_frame_duration)
1297 return vp->duration;
1305 static void pictq_next_picture(VideoState *is) {
1306 /* update queue size and signal for next picture */
1307 if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE)
1308 is->pictq_rindex = 0;
1310 SDL_LockMutex(is->pictq_mutex);
1312 SDL_CondSignal(is->pictq_cond);
1313 SDL_UnlockMutex(is->pictq_mutex);
1316 static int pictq_prev_picture(VideoState *is) {
1317 VideoPicture *prevvp;
1319 /* update queue size and signal for the previous picture */
1320 prevvp = &is->pictq[(is->pictq_rindex + VIDEO_PICTURE_QUEUE_SIZE - 1) % VIDEO_PICTURE_QUEUE_SIZE];
1321 if (prevvp->allocated && prevvp->serial == is->videoq.serial) {
1322 SDL_LockMutex(is->pictq_mutex);
1323 if (is->pictq_size < VIDEO_PICTURE_QUEUE_SIZE) {
1324 if (--is->pictq_rindex == -1)
1325 is->pictq_rindex = VIDEO_PICTURE_QUEUE_SIZE - 1;
1329 SDL_CondSignal(is->pictq_cond);
1330 SDL_UnlockMutex(is->pictq_mutex);
1335 static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
1336 /* update current video pts */
1337 set_clock(&is->vidclk, pts, serial);
1338 sync_clock_to_slave(&is->extclk, &is->vidclk);
1339 is->video_current_pos = pos;
1342 /* called to display each frame */
1343 static void video_refresh(void *opaque, double *remaining_time)
1345 VideoState *is = opaque;
1348 SubPicture *sp, *sp2;
1350 if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
1351 check_external_clock_speed(is);
1353 if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {
1354 time = av_gettime() / 1000000.0;
1355 if (is->force_refresh || is->last_vis_time + rdftspeed < time) {
1357 is->last_vis_time = time;
1359 *remaining_time = FFMIN(*remaining_time, is->last_vis_time + rdftspeed - time);
1364 if (is->force_refresh)
1365 redisplay = pictq_prev_picture(is);
1367 if (is->pictq_size == 0) {
1368 // nothing to do, no picture to display in the queue
1370 double last_duration, duration, delay;
1371 VideoPicture *vp, *lastvp;
1373 /* dequeue the picture */
1374 vp = &is->pictq[is->pictq_rindex];
1375 lastvp = &is->pictq[(is->pictq_rindex + VIDEO_PICTURE_QUEUE_SIZE - 1) % VIDEO_PICTURE_QUEUE_SIZE];
1377 if (vp->serial != is->videoq.serial) {
1378 pictq_next_picture(is);
1386 /* compute nominal last_duration */
1387 last_duration = vp_duration(is, lastvp, vp);
1391 delay = compute_target_delay(last_duration, is);
1393 time= av_gettime()/1000000.0;
1394 if (time < is->frame_timer + delay && !redisplay) {
1395 *remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);
1399 is->frame_timer += delay;
1400 if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)
1401 is->frame_timer = time;
1403 SDL_LockMutex(is->pictq_mutex);
1404 if (!redisplay && !isnan(vp->pts))
1405 update_video_pts(is, vp->pts, vp->pos, vp->serial);
1406 SDL_UnlockMutex(is->pictq_mutex);
1408 if (is->pictq_size > 1) {
1409 VideoPicture *nextvp = &is->pictq[(is->pictq_rindex + 1) % VIDEO_PICTURE_QUEUE_SIZE];
1410 duration = vp_duration(is, vp, nextvp);
1411 if(!is->step && (redisplay || framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
1413 is->frame_drops_late++;
1414 pictq_next_picture(is);
1420 if (is->subtitle_st) {
1421 while (is->subpq_size > 0) {
1422 sp = &is->subpq[is->subpq_rindex];
1424 if (is->subpq_size > 1)
1425 sp2 = &is->subpq[(is->subpq_rindex + 1) % SUBPICTURE_QUEUE_SIZE];
1429 if (sp->serial != is->subtitleq.serial
1430 || (is->vidclk.pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1431 || (sp2 && is->vidclk.pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1433 free_subpicture(sp);
1435 /* update queue size and signal for next picture */
1436 if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
1437 is->subpq_rindex = 0;
1439 SDL_LockMutex(is->subpq_mutex);
1441 SDL_CondSignal(is->subpq_cond);
1442 SDL_UnlockMutex(is->subpq_mutex);
1450 /* display picture */
1451 if (!display_disable && is->show_mode == SHOW_MODE_VIDEO)
1454 pictq_next_picture(is);
1456 if (is->step && !is->paused)
1457 stream_toggle_pause(is);
1460 is->force_refresh = 0;
1462 static int64_t last_time;
1464 int aqsize, vqsize, sqsize;
1467 cur_time = av_gettime();
1468 if (!last_time || (cur_time - last_time) >= 30000) {
1473 aqsize = is->audioq.size;
1475 vqsize = is->videoq.size;
1476 if (is->subtitle_st)
1477 sqsize = is->subtitleq.size;
1479 if (is->audio_st && is->video_st)
1480 av_diff = get_clock(&is->audclk) - get_clock(&is->vidclk);
1481 else if (is->video_st)
1482 av_diff = get_master_clock(is) - get_clock(&is->vidclk);
1483 else if (is->audio_st)
1484 av_diff = get_master_clock(is) - get_clock(&is->audclk);
1485 av_log(NULL, AV_LOG_INFO,
1486 "%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64" \r",
1487 get_master_clock(is),
1488 (is->audio_st && is->video_st) ? "A-V" : (is->video_st ? "M-V" : (is->audio_st ? "M-A" : " ")),
1490 is->frame_drops_early + is->frame_drops_late,
1494 is->video_st ? is->video_st->codec->pts_correction_num_faulty_dts : 0,
1495 is->video_st ? is->video_st->codec->pts_correction_num_faulty_pts : 0);
1497 last_time = cur_time;
1502 /* allocate a picture (needs to do that in main thread to avoid
1503 potential locking problems */
1504 static void alloc_picture(VideoState *is)
1509 vp = &is->pictq[is->pictq_windex];
1513 video_open(is, 0, vp);
1515 vp->bmp = SDL_CreateYUVOverlay(vp->width, vp->height,
1518 bufferdiff = vp->bmp ? FFMAX(vp->bmp->pixels[0], vp->bmp->pixels[1]) - FFMIN(vp->bmp->pixels[0], vp->bmp->pixels[1]) : 0;
1519 if (!vp->bmp || vp->bmp->pitches[0] < vp->width || bufferdiff < (int64_t)vp->height * vp->bmp->pitches[0]) {
1520 /* SDL allocates a buffer smaller than requested if the video
1521 * overlay hardware is unable to support the requested size. */
1522 av_log(NULL, AV_LOG_FATAL,
1523 "Error: the video system does not support an image\n"
1524 "size of %dx%d pixels. Try using -lowres or -vf \"scale=w:h\"\n"
1525 "to reduce the image size.\n", vp->width, vp->height );
1529 SDL_LockMutex(is->pictq_mutex);
1531 SDL_CondSignal(is->pictq_cond);
1532 SDL_UnlockMutex(is->pictq_mutex);
1535 static void duplicate_right_border_pixels(SDL_Overlay *bmp) {
1536 int i, width, height;
1538 for (i = 0; i < 3; i++) {
1545 if (bmp->pitches[i] > width) {
1546 maxp = bmp->pixels[i] + bmp->pitches[i] * height - 1;
1547 for (p = bmp->pixels[i] + width - 1; p < maxp; p += bmp->pitches[i])
1553 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, double duration, int64_t pos, int serial)
1557 #if defined(DEBUG_SYNC) && 0
1558 printf("frame_type=%c pts=%0.3f\n",
1559 av_get_picture_type_char(src_frame->pict_type), pts);
1562 /* wait until we have space to put a new picture */
1563 SDL_LockMutex(is->pictq_mutex);
1565 /* keep the last already displayed picture in the queue */
1566 while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE - 1 &&
1567 !is->videoq.abort_request) {
1568 SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1570 SDL_UnlockMutex(is->pictq_mutex);
1572 if (is->videoq.abort_request)
1575 vp = &is->pictq[is->pictq_windex];
1577 vp->sar = src_frame->sample_aspect_ratio;
1579 /* alloc or resize hardware picture buffer */
1580 if (!vp->bmp || vp->reallocate || !vp->allocated ||
1581 vp->width != src_frame->width ||
1582 vp->height != src_frame->height) {
1587 vp->width = src_frame->width;
1588 vp->height = src_frame->height;
1590 /* the allocation must be done in the main thread to avoid
1591 locking problems. */
1592 event.type = FF_ALLOC_EVENT;
1593 event.user.data1 = is;
1594 SDL_PushEvent(&event);
1596 /* wait until the picture is allocated */
1597 SDL_LockMutex(is->pictq_mutex);
1598 while (!vp->allocated && !is->videoq.abort_request) {
1599 SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1601 /* if the queue is aborted, we have to pop the pending ALLOC event or wait for the allocation to complete */
1602 if (is->videoq.abort_request && SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_EVENTMASK(FF_ALLOC_EVENT)) != 1) {
1603 while (!vp->allocated) {
1604 SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1607 SDL_UnlockMutex(is->pictq_mutex);
1609 if (is->videoq.abort_request)
1613 /* if the frame is not skipped, then display it */
1615 AVPicture pict = { { 0 } };
1617 /* get a pointer on the bitmap */
1618 SDL_LockYUVOverlay (vp->bmp);
1620 pict.data[0] = vp->bmp->pixels[0];
1621 pict.data[1] = vp->bmp->pixels[2];
1622 pict.data[2] = vp->bmp->pixels[1];
1624 pict.linesize[0] = vp->bmp->pitches[0];
1625 pict.linesize[1] = vp->bmp->pitches[2];
1626 pict.linesize[2] = vp->bmp->pitches[1];
1629 // FIXME use direct rendering
1630 av_picture_copy(&pict, (AVPicture *)src_frame,
1631 src_frame->format, vp->width, vp->height);
1633 av_opt_get_int(sws_opts, "sws_flags", 0, &sws_flags);
1634 is->img_convert_ctx = sws_getCachedContext(is->img_convert_ctx,
1635 vp->width, vp->height, src_frame->format, vp->width, vp->height,
1636 AV_PIX_FMT_YUV420P, sws_flags, NULL, NULL, NULL);
1637 if (is->img_convert_ctx == NULL) {
1638 av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
1641 sws_scale(is->img_convert_ctx, src_frame->data, src_frame->linesize,
1642 0, vp->height, pict.data, pict.linesize);
1644 /* workaround SDL PITCH_WORKAROUND */
1645 duplicate_right_border_pixels(vp->bmp);
1646 /* update the bitmap content */
1647 SDL_UnlockYUVOverlay(vp->bmp);
1650 vp->duration = duration;
1652 vp->serial = serial;
1654 /* now we can update the picture count */
1655 if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE)
1656 is->pictq_windex = 0;
1657 SDL_LockMutex(is->pictq_mutex);
1659 SDL_UnlockMutex(is->pictq_mutex);
1664 static int get_video_frame(VideoState *is, AVFrame *frame, AVPacket *pkt, int *serial)
1668 if (packet_queue_get(&is->videoq, pkt, 1, serial) < 0)
1671 if (pkt->data == flush_pkt.data) {
1672 avcodec_flush_buffers(is->video_st->codec);
1674 SDL_LockMutex(is->pictq_mutex);
1675 // Make sure there are no long delay timers (ideally we should just flush the queue but that's harder)
1676 while (is->pictq_size && !is->videoq.abort_request) {
1677 SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1679 is->video_current_pos = -1;
1680 is->frame_timer = (double)av_gettime() / 1000000.0;
1681 SDL_UnlockMutex(is->pictq_mutex);
1685 if(avcodec_decode_video2(is->video_st->codec, frame, &got_picture, pkt) < 0)
1688 if (!got_picture && !pkt->data)
1689 is->video_finished = *serial;
1695 if (decoder_reorder_pts == -1) {
1696 frame->pts = av_frame_get_best_effort_timestamp(frame);
1697 } else if (decoder_reorder_pts) {
1698 frame->pts = frame->pkt_pts;
1700 frame->pts = frame->pkt_dts;
1703 if (frame->pts != AV_NOPTS_VALUE)
1704 dpts = av_q2d(is->video_st->time_base) * frame->pts;
1706 frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
1708 if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
1709 if (frame->pts != AV_NOPTS_VALUE) {
1710 double diff = dpts - get_master_clock(is);
1711 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD &&
1712 diff - is->frame_last_filter_delay < 0 &&
1713 *serial == is->vidclk.serial &&
1714 is->videoq.nb_packets) {
1715 is->frame_drops_early++;
1716 av_frame_unref(frame);
1728 static int configure_filtergraph(AVFilterGraph *graph, const char *filtergraph,
1729 AVFilterContext *source_ctx, AVFilterContext *sink_ctx)
1732 AVFilterInOut *outputs = NULL, *inputs = NULL;
1735 outputs = avfilter_inout_alloc();
1736 inputs = avfilter_inout_alloc();
1737 if (!outputs || !inputs) {
1738 ret = AVERROR(ENOMEM);
1742 outputs->name = av_strdup("in");
1743 outputs->filter_ctx = source_ctx;
1744 outputs->pad_idx = 0;
1745 outputs->next = NULL;
1747 inputs->name = av_strdup("out");
1748 inputs->filter_ctx = sink_ctx;
1749 inputs->pad_idx = 0;
1750 inputs->next = NULL;
1752 if ((ret = avfilter_graph_parse_ptr(graph, filtergraph, &inputs, &outputs, NULL)) < 0)
1755 if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
1759 ret = avfilter_graph_config(graph, NULL);
1761 avfilter_inout_free(&outputs);
1762 avfilter_inout_free(&inputs);
1766 static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const char *vfilters, AVFrame *frame)
1768 static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
1769 char sws_flags_str[128];
1770 char buffersrc_args[256];
1772 AVFilterContext *filt_src = NULL, *filt_out = NULL, *filt_crop;
1773 AVCodecContext *codec = is->video_st->codec;
1774 AVRational fr = av_guess_frame_rate(is->ic, is->video_st, NULL);
1776 av_opt_get_int(sws_opts, "sws_flags", 0, &sws_flags);
1777 snprintf(sws_flags_str, sizeof(sws_flags_str), "flags=%"PRId64, sws_flags);
1778 graph->scale_sws_opts = av_strdup(sws_flags_str);
1780 snprintf(buffersrc_args, sizeof(buffersrc_args),
1781 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
1782 frame->width, frame->height, frame->format,
1783 is->video_st->time_base.num, is->video_st->time_base.den,
1784 codec->sample_aspect_ratio.num, FFMAX(codec->sample_aspect_ratio.den, 1));
1785 if (fr.num && fr.den)
1786 av_strlcatf(buffersrc_args, sizeof(buffersrc_args), ":frame_rate=%d/%d", fr.num, fr.den);
1788 if ((ret = avfilter_graph_create_filter(&filt_src,
1789 avfilter_get_by_name("buffer"),
1790 "ffplay_buffer", buffersrc_args, NULL,
1794 ret = avfilter_graph_create_filter(&filt_out,
1795 avfilter_get_by_name("buffersink"),
1796 "ffplay_buffersink", NULL, NULL, graph);
1800 if ((ret = av_opt_set_int_list(filt_out, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1803 /* SDL YUV code is not handling odd width/height for some driver
1804 * combinations, therefore we crop the picture to an even width/height. */
1805 if ((ret = avfilter_graph_create_filter(&filt_crop,
1806 avfilter_get_by_name("crop"),
1807 "ffplay_crop", "floor(in_w/2)*2:floor(in_h/2)*2", NULL, graph)) < 0)
1809 if ((ret = avfilter_link(filt_crop, 0, filt_out, 0)) < 0)
1812 if ((ret = configure_filtergraph(graph, vfilters, filt_src, filt_crop)) < 0)
1815 is->in_video_filter = filt_src;
1816 is->out_video_filter = filt_out;
1822 static int configure_audio_filters(VideoState *is, const char *afilters, int force_output_format)
1824 static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
1825 int sample_rates[2] = { 0, -1 };
1826 int64_t channel_layouts[2] = { 0, -1 };
1827 int channels[2] = { 0, -1 };
1828 AVFilterContext *filt_asrc = NULL, *filt_asink = NULL;
1829 char aresample_swr_opts[512] = "";
1830 AVDictionaryEntry *e = NULL;
1831 char asrc_args[256];
1834 avfilter_graph_free(&is->agraph);
1835 if (!(is->agraph = avfilter_graph_alloc()))
1836 return AVERROR(ENOMEM);
1838 while ((e = av_dict_get(swr_opts, "", e, AV_DICT_IGNORE_SUFFIX)))
1839 av_strlcatf(aresample_swr_opts, sizeof(aresample_swr_opts), "%s=%s:", e->key, e->value);
1840 if (strlen(aresample_swr_opts))
1841 aresample_swr_opts[strlen(aresample_swr_opts)-1] = '\0';
1842 av_opt_set(is->agraph, "aresample_swr_opts", aresample_swr_opts, 0);
1844 ret = snprintf(asrc_args, sizeof(asrc_args),
1845 "sample_rate=%d:sample_fmt=%s:channels=%d:time_base=%d/%d",
1846 is->audio_filter_src.freq, av_get_sample_fmt_name(is->audio_filter_src.fmt),
1847 is->audio_filter_src.channels,
1848 1, is->audio_filter_src.freq);
1849 if (is->audio_filter_src.channel_layout)
1850 snprintf(asrc_args + ret, sizeof(asrc_args) - ret,
1851 ":channel_layout=0x%"PRIx64, is->audio_filter_src.channel_layout);
1853 ret = avfilter_graph_create_filter(&filt_asrc,
1854 avfilter_get_by_name("abuffer"), "ffplay_abuffer",
1855 asrc_args, NULL, is->agraph);
1860 ret = avfilter_graph_create_filter(&filt_asink,
1861 avfilter_get_by_name("abuffersink"), "ffplay_abuffersink",
1862 NULL, NULL, is->agraph);
1866 if ((ret = av_opt_set_int_list(filt_asink, "sample_fmts", sample_fmts, AV_SAMPLE_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1868 if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 1, AV_OPT_SEARCH_CHILDREN)) < 0)
1871 if (force_output_format) {
1872 channel_layouts[0] = is->audio_tgt.channel_layout;
1873 channels [0] = is->audio_tgt.channels;
1874 sample_rates [0] = is->audio_tgt.freq;
1875 if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 0, AV_OPT_SEARCH_CHILDREN)) < 0)
1877 if ((ret = av_opt_set_int_list(filt_asink, "channel_layouts", channel_layouts, -1, AV_OPT_SEARCH_CHILDREN)) < 0)
1879 if ((ret = av_opt_set_int_list(filt_asink, "channel_counts" , channels , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
1881 if ((ret = av_opt_set_int_list(filt_asink, "sample_rates" , sample_rates , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
1886 if ((ret = configure_filtergraph(is->agraph, afilters, filt_asrc, filt_asink)) < 0)
1889 is->in_audio_filter = filt_asrc;
1890 is->out_audio_filter = filt_asink;
1894 avfilter_graph_free(&is->agraph);
1897 #endif /* CONFIG_AVFILTER */
1899 static int video_thread(void *arg)
1901 AVPacket pkt = { 0 };
1902 VideoState *is = arg;
1903 AVFrame *frame = av_frame_alloc();
1908 AVRational tb = is->video_st->time_base;
1909 AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);
1912 AVFilterGraph *graph = avfilter_graph_alloc();
1913 AVFilterContext *filt_out = NULL, *filt_in = NULL;
1916 enum AVPixelFormat last_format = -2;
1917 int last_serial = -1;
1921 while (is->paused && !is->videoq.abort_request)
1924 avcodec_get_frame_defaults(frame);
1925 av_free_packet(&pkt);
1927 ret = get_video_frame(is, frame, &pkt, &serial);
1934 if ( last_w != frame->width
1935 || last_h != frame->height
1936 || last_format != frame->format
1937 || last_serial != serial) {
1938 av_log(NULL, AV_LOG_DEBUG,
1939 "Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
1941 (const char *)av_x_if_null(av_get_pix_fmt_name(last_format), "none"), last_serial,
1942 frame->width, frame->height,
1943 (const char *)av_x_if_null(av_get_pix_fmt_name(frame->format), "none"), serial);
1944 avfilter_graph_free(&graph);
1945 graph = avfilter_graph_alloc();
1946 if ((ret = configure_video_filters(graph, is, vfilters, frame)) < 0) {
1948 event.type = FF_QUIT_EVENT;
1949 event.user.data1 = is;
1950 SDL_PushEvent(&event);
1951 av_free_packet(&pkt);
1954 filt_in = is->in_video_filter;
1955 filt_out = is->out_video_filter;
1956 last_w = frame->width;
1957 last_h = frame->height;
1958 last_format = frame->format;
1959 last_serial = serial;
1960 frame_rate = filt_out->inputs[0]->frame_rate;
1963 ret = av_buffersrc_add_frame(filt_in, frame);
1966 av_frame_unref(frame);
1967 avcodec_get_frame_defaults(frame);
1968 av_free_packet(&pkt);
1971 is->frame_last_returned_time = av_gettime() / 1000000.0;
1973 ret = av_buffersink_get_frame_flags(filt_out, frame, 0);
1975 if (ret == AVERROR_EOF)
1976 is->video_finished = serial;
1981 is->frame_last_filter_delay = av_gettime() / 1000000.0 - is->frame_last_returned_time;
1982 if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
1983 is->frame_last_filter_delay = 0;
1984 tb = filt_out->inputs[0]->time_base;
1986 duration = (frame_rate.num && frame_rate.den ? av_q2d((AVRational){frame_rate.den, frame_rate.num}) : 0);
1987 pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
1988 ret = queue_picture(is, frame, pts, duration, av_frame_get_pkt_pos(frame), serial);
1989 av_frame_unref(frame);
1998 avcodec_flush_buffers(is->video_st->codec);
2000 avfilter_graph_free(&graph);
2002 av_free_packet(&pkt);
2003 av_frame_free(&frame);
2007 static int subtitle_thread(void *arg)
2009 VideoState *is = arg;
2011 AVPacket pkt1, *pkt = &pkt1;
2016 int r, g, b, y, u, v, a;
2019 while (is->paused && !is->subtitleq.abort_request) {
2022 if (packet_queue_get(&is->subtitleq, pkt, 1, &serial) < 0)
2025 if (pkt->data == flush_pkt.data) {
2026 avcodec_flush_buffers(is->subtitle_st->codec);
2029 SDL_LockMutex(is->subpq_mutex);
2030 while (is->subpq_size >= SUBPICTURE_QUEUE_SIZE &&
2031 !is->subtitleq.abort_request) {
2032 SDL_CondWait(is->subpq_cond, is->subpq_mutex);
2034 SDL_UnlockMutex(is->subpq_mutex);
2036 if (is->subtitleq.abort_request)
2039 sp = &is->subpq[is->subpq_windex];
2041 /* NOTE: ipts is the PTS of the _first_ picture beginning in
2042 this packet, if any */
2044 if (pkt->pts != AV_NOPTS_VALUE)
2045 pts = av_q2d(is->subtitle_st->time_base) * pkt->pts;
2047 avcodec_decode_subtitle2(is->subtitle_st->codec, &sp->sub,
2048 &got_subtitle, pkt);
2049 if (got_subtitle && sp->sub.format == 0) {
2050 if (sp->sub.pts != AV_NOPTS_VALUE)
2051 pts = sp->sub.pts / (double)AV_TIME_BASE;
2053 sp->serial = serial;
2055 for (i = 0; i < sp->sub.num_rects; i++)
2057 for (j = 0; j < sp->sub.rects[i]->nb_colors; j++)
2059 RGBA_IN(r, g, b, a, (uint32_t*)sp->sub.rects[i]->pict.data[1] + j);
2060 y = RGB_TO_Y_CCIR(r, g, b);
2061 u = RGB_TO_U_CCIR(r, g, b, 0);
2062 v = RGB_TO_V_CCIR(r, g, b, 0);
2063 YUVA_OUT((uint32_t*)sp->sub.rects[i]->pict.data[1] + j, y, u, v, a);
2067 /* now we can update the picture count */
2068 if (++is->subpq_windex == SUBPICTURE_QUEUE_SIZE)
2069 is->subpq_windex = 0;
2070 SDL_LockMutex(is->subpq_mutex);
2072 SDL_UnlockMutex(is->subpq_mutex);
2073 } else if (got_subtitle) {
2074 avsubtitle_free(&sp->sub);
2076 av_free_packet(pkt);
2081 /* copy samples for viewing in editor window */
2082 static void update_sample_display(VideoState *is, short *samples, int samples_size)
2086 size = samples_size / sizeof(short);
2088 len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
2091 memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
2093 is->sample_array_index += len;
2094 if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
2095 is->sample_array_index = 0;
2100 /* return the wanted number of samples to get better sync if sync_type is video
2101 * or external master clock */
2102 static int synchronize_audio(VideoState *is, int nb_samples)
2104 int wanted_nb_samples = nb_samples;
2106 /* if not master, then we try to remove or add samples to correct the clock */
2107 if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
2108 double diff, avg_diff;
2109 int min_nb_samples, max_nb_samples;
2111 diff = get_clock(&is->audclk) - get_master_clock(is);
2113 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD) {
2114 is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
2115 if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
2116 /* not enough measures to have a correct estimate */
2117 is->audio_diff_avg_count++;
2119 /* estimate the A-V difference */
2120 avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
2122 if (fabs(avg_diff) >= is->audio_diff_threshold) {
2123 wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);
2124 min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2125 max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2126 wanted_nb_samples = FFMIN(FFMAX(wanted_nb_samples, min_nb_samples), max_nb_samples);
2128 av_dlog(NULL, "diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
2129 diff, avg_diff, wanted_nb_samples - nb_samples,
2130 is->audio_clock, is->audio_diff_threshold);
2133 /* too big difference : may be initial PTS errors, so
2135 is->audio_diff_avg_count = 0;
2136 is->audio_diff_cum = 0;
2140 return wanted_nb_samples;
2144 * Decode one audio frame and return its uncompressed size.
2146 * The processed audio frame is decoded, converted if required, and
2147 * stored in is->audio_buf, with size in bytes given by the return
2150 static int audio_decode_frame(VideoState *is)
2152 AVPacket *pkt_temp = &is->audio_pkt_temp;
2153 AVPacket *pkt = &is->audio_pkt;
2154 AVCodecContext *dec = is->audio_st->codec;
2155 int len1, data_size, resampled_data_size;
2156 int64_t dec_channel_layout;
2158 av_unused double audio_clock0;
2159 int wanted_nb_samples;
2165 /* NOTE: the audio packet can contain several frames */
2166 while (pkt_temp->stream_index != -1 || is->audio_buf_frames_pending) {
2168 if (!(is->frame = av_frame_alloc()))
2169 return AVERROR(ENOMEM);
2171 av_frame_unref(is->frame);
2172 avcodec_get_frame_defaults(is->frame);
2175 if (is->audioq.serial != is->audio_pkt_temp_serial)
2181 if (!is->audio_buf_frames_pending) {
2182 len1 = avcodec_decode_audio4(dec, is->frame, &got_frame, pkt_temp);
2184 /* if error, we skip the frame */
2190 pkt_temp->pts = AV_NOPTS_VALUE;
2191 pkt_temp->data += len1;
2192 pkt_temp->size -= len1;
2193 if (pkt_temp->data && pkt_temp->size <= 0 || !pkt_temp->data && !got_frame)
2194 pkt_temp->stream_index = -1;
2195 if (!pkt_temp->data && !got_frame)
2196 is->audio_finished = is->audio_pkt_temp_serial;
2201 tb = (AVRational){1, is->frame->sample_rate};
2202 if (is->frame->pts != AV_NOPTS_VALUE)
2203 is->frame->pts = av_rescale_q(is->frame->pts, dec->time_base, tb);
2204 else if (is->frame->pkt_pts != AV_NOPTS_VALUE)
2205 is->frame->pts = av_rescale_q(is->frame->pkt_pts, is->audio_st->time_base, tb);
2206 else if (is->audio_frame_next_pts != AV_NOPTS_VALUE)
2208 is->frame->pts = av_rescale_q(is->audio_frame_next_pts, (AVRational){1, is->audio_filter_src.freq}, tb);
2210 is->frame->pts = av_rescale_q(is->audio_frame_next_pts, (AVRational){1, is->audio_src.freq}, tb);
2213 if (is->frame->pts != AV_NOPTS_VALUE)
2214 is->audio_frame_next_pts = is->frame->pts + is->frame->nb_samples;
2217 dec_channel_layout = get_valid_channel_layout(is->frame->channel_layout, av_frame_get_channels(is->frame));
2220 cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
2221 is->frame->format, av_frame_get_channels(is->frame)) ||
2222 is->audio_filter_src.channel_layout != dec_channel_layout ||
2223 is->audio_filter_src.freq != is->frame->sample_rate ||
2224 is->audio_pkt_temp_serial != is->audio_last_serial;
2227 char buf1[1024], buf2[1024];
2228 av_get_channel_layout_string(buf1, sizeof(buf1), -1, is->audio_filter_src.channel_layout);
2229 av_get_channel_layout_string(buf2, sizeof(buf2), -1, dec_channel_layout);
2230 av_log(NULL, AV_LOG_DEBUG,
2231 "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",
2232 is->audio_filter_src.freq, is->audio_filter_src.channels, av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, is->audio_last_serial,
2233 is->frame->sample_rate, av_frame_get_channels(is->frame), av_get_sample_fmt_name(is->frame->format), buf2, is->audio_pkt_temp_serial);
2235 is->audio_filter_src.fmt = is->frame->format;
2236 is->audio_filter_src.channels = av_frame_get_channels(is->frame);
2237 is->audio_filter_src.channel_layout = dec_channel_layout;
2238 is->audio_filter_src.freq = is->frame->sample_rate;
2239 is->audio_last_serial = is->audio_pkt_temp_serial;
2241 if ((ret = configure_audio_filters(is, afilters, 1)) < 0)
2245 if ((ret = av_buffersrc_add_frame(is->in_audio_filter, is->frame)) < 0)
2247 av_frame_unref(is->frame);
2251 if ((ret = av_buffersink_get_frame_flags(is->out_audio_filter, is->frame, 0)) < 0) {
2252 if (ret == AVERROR(EAGAIN)) {
2253 is->audio_buf_frames_pending = 0;
2256 if (ret == AVERROR_EOF)
2257 is->audio_finished = is->audio_pkt_temp_serial;
2260 is->audio_buf_frames_pending = 1;
2261 tb = is->out_audio_filter->inputs[0]->time_base;
2264 data_size = av_samples_get_buffer_size(NULL, av_frame_get_channels(is->frame),
2265 is->frame->nb_samples,
2266 is->frame->format, 1);
2268 dec_channel_layout =
2269 (is->frame->channel_layout && av_frame_get_channels(is->frame) == av_get_channel_layout_nb_channels(is->frame->channel_layout)) ?
2270 is->frame->channel_layout : av_get_default_channel_layout(av_frame_get_channels(is->frame));
2271 wanted_nb_samples = synchronize_audio(is, is->frame->nb_samples);
2273 if (is->frame->format != is->audio_src.fmt ||
2274 dec_channel_layout != is->audio_src.channel_layout ||
2275 is->frame->sample_rate != is->audio_src.freq ||
2276 (wanted_nb_samples != is->frame->nb_samples && !is->swr_ctx)) {
2277 swr_free(&is->swr_ctx);
2278 is->swr_ctx = swr_alloc_set_opts(NULL,
2279 is->audio_tgt.channel_layout, is->audio_tgt.fmt, is->audio_tgt.freq,
2280 dec_channel_layout, is->frame->format, is->frame->sample_rate,
2282 if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
2283 av_log(NULL, AV_LOG_ERROR,
2284 "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
2285 is->frame->sample_rate, av_get_sample_fmt_name(is->frame->format), av_frame_get_channels(is->frame),
2286 is->audio_tgt.freq, av_get_sample_fmt_name(is->audio_tgt.fmt), is->audio_tgt.channels);
2289 is->audio_src.channel_layout = dec_channel_layout;
2290 is->audio_src.channels = av_frame_get_channels(is->frame);
2291 is->audio_src.freq = is->frame->sample_rate;
2292 is->audio_src.fmt = is->frame->format;
2296 const uint8_t **in = (const uint8_t **)is->frame->extended_data;
2297 uint8_t **out = &is->audio_buf1;
2298 int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / is->frame->sample_rate + 256;
2299 int out_size = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, out_count, is->audio_tgt.fmt, 0);
2302 av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size() failed\n");
2305 if (wanted_nb_samples != is->frame->nb_samples) {
2306 if (swr_set_compensation(is->swr_ctx, (wanted_nb_samples - is->frame->nb_samples) * is->audio_tgt.freq / is->frame->sample_rate,
2307 wanted_nb_samples * is->audio_tgt.freq / is->frame->sample_rate) < 0) {
2308 av_log(NULL, AV_LOG_ERROR, "swr_set_compensation() failed\n");
2312 av_fast_malloc(&is->audio_buf1, &is->audio_buf1_size, out_size);
2313 if (!is->audio_buf1)
2314 return AVERROR(ENOMEM);
2315 len2 = swr_convert(is->swr_ctx, out, out_count, in, is->frame->nb_samples);
2317 av_log(NULL, AV_LOG_ERROR, "swr_convert() failed\n");
2320 if (len2 == out_count) {
2321 av_log(NULL, AV_LOG_WARNING, "audio buffer is probably too small\n");
2322 swr_init(is->swr_ctx);
2324 is->audio_buf = is->audio_buf1;
2325 resampled_data_size = len2 * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2327 is->audio_buf = is->frame->data[0];
2328 resampled_data_size = data_size;
2331 audio_clock0 = is->audio_clock;
2332 /* update the audio clock with the pts */
2333 if (is->frame->pts != AV_NOPTS_VALUE)
2334 is->audio_clock = is->frame->pts * av_q2d(tb) + (double) is->frame->nb_samples / is->frame->sample_rate;
2336 is->audio_clock = NAN;
2337 is->audio_clock_serial = is->audio_pkt_temp_serial;
2340 static double last_clock;
2341 printf("audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
2342 is->audio_clock - last_clock,
2343 is->audio_clock, audio_clock0);
2344 last_clock = is->audio_clock;
2347 return resampled_data_size;
2350 /* free the current packet */
2352 av_free_packet(pkt);
2353 memset(pkt_temp, 0, sizeof(*pkt_temp));
2354 pkt_temp->stream_index = -1;
2356 if (is->audioq.abort_request) {
2360 if (is->audioq.nb_packets == 0)
2361 SDL_CondSignal(is->continue_read_thread);
2363 /* read next packet */
2364 if ((packet_queue_get(&is->audioq, pkt, 1, &is->audio_pkt_temp_serial)) < 0)
2367 if (pkt->data == flush_pkt.data) {
2368 avcodec_flush_buffers(dec);
2369 is->audio_buf_frames_pending = 0;
2370 is->audio_frame_next_pts = AV_NOPTS_VALUE;
2371 if ((is->ic->iformat->flags & (AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH | AVFMT_NO_BYTE_SEEK)) && !is->ic->iformat->read_seek)
2372 is->audio_frame_next_pts = is->audio_st->start_time;
2379 /* prepare a new audio buffer */
2380 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
2382 VideoState *is = opaque;
2383 int audio_size, len1;
2385 int frame_size = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, 1, is->audio_tgt.fmt, 1);
2387 audio_callback_time = av_gettime();
2390 if (is->audio_buf_index >= is->audio_buf_size) {
2391 audio_size = audio_decode_frame(is);
2392 if (audio_size < 0) {
2393 /* if error, just output silence */
2394 is->audio_buf = is->silence_buf;
2395 is->audio_buf_size = sizeof(is->silence_buf) / frame_size * frame_size;
2397 if (is->show_mode != SHOW_MODE_VIDEO)
2398 update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
2399 is->audio_buf_size = audio_size;
2401 is->audio_buf_index = 0;
2403 len1 = is->audio_buf_size - is->audio_buf_index;
2406 memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
2409 is->audio_buf_index += len1;
2411 bytes_per_sec = is->audio_tgt.freq * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2412 is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
2413 /* Let's assume the audio driver that is used by SDL has two periods. */
2414 if (!isnan(is->audio_clock)) {
2415 set_clock_at(&is->audclk, is->audio_clock - (double)(2 * is->audio_hw_buf_size + is->audio_write_buf_size) / bytes_per_sec, is->audio_clock_serial, audio_callback_time / 1000000.0);
2416 sync_clock_to_slave(&is->extclk, &is->audclk);
2420 static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
2422 SDL_AudioSpec wanted_spec, spec;
2424 static const int next_nb_channels[] = {0, 0, 1, 6, 2, 6, 4, 6};
2426 env = SDL_getenv("SDL_AUDIO_CHANNELS");
2428 wanted_nb_channels = atoi(env);
2429 wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2431 if (!wanted_channel_layout || wanted_nb_channels != av_get_channel_layout_nb_channels(wanted_channel_layout)) {
2432 wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2433 wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
2435 wanted_spec.channels = av_get_channel_layout_nb_channels(wanted_channel_layout);
2436 wanted_spec.freq = wanted_sample_rate;
2437 if (wanted_spec.freq <= 0 || wanted_spec.channels <= 0) {
2438 av_log(NULL, AV_LOG_ERROR, "Invalid sample rate or channel count!\n");
2441 wanted_spec.format = AUDIO_S16SYS;
2442 wanted_spec.silence = 0;
2443 wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
2444 wanted_spec.callback = sdl_audio_callback;
2445 wanted_spec.userdata = opaque;
2446 while (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
2447 av_log(NULL, AV_LOG_WARNING, "SDL_OpenAudio (%d channels): %s\n", wanted_spec.channels, SDL_GetError());
2448 wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
2449 if (!wanted_spec.channels) {
2450 av_log(NULL, AV_LOG_ERROR,
2451 "No more channel combinations to try, audio open failed\n");
2454 wanted_channel_layout = av_get_default_channel_layout(wanted_spec.channels);
2456 if (spec.format != AUDIO_S16SYS) {
2457 av_log(NULL, AV_LOG_ERROR,
2458 "SDL advised audio format %d is not supported!\n", spec.format);
2461 if (spec.channels != wanted_spec.channels) {
2462 wanted_channel_layout = av_get_default_channel_layout(spec.channels);
2463 if (!wanted_channel_layout) {
2464 av_log(NULL, AV_LOG_ERROR,
2465 "SDL advised channel count %d is not supported!\n", spec.channels);
2470 audio_hw_params->fmt = AV_SAMPLE_FMT_S16;
2471 audio_hw_params->freq = spec.freq;
2472 audio_hw_params->channel_layout = wanted_channel_layout;
2473 audio_hw_params->channels = spec.channels;
2477 /* open a given stream. Return 0 if OK */
2478 static int stream_component_open(VideoState *is, int stream_index)
2480 AVFormatContext *ic = is->ic;
2481 AVCodecContext *avctx;
2483 const char *forced_codec_name = NULL;
2485 AVDictionaryEntry *t = NULL;
2486 int sample_rate, nb_channels;
2487 int64_t channel_layout;
2489 int stream_lowres = lowres;
2491 if (stream_index < 0 || stream_index >= ic->nb_streams)
2493 avctx = ic->streams[stream_index]->codec;
2495 codec = avcodec_find_decoder(avctx->codec_id);
2497 switch(avctx->codec_type){
2498 case AVMEDIA_TYPE_AUDIO : is->last_audio_stream = stream_index; forced_codec_name = audio_codec_name; break;
2499 case AVMEDIA_TYPE_SUBTITLE: is->last_subtitle_stream = stream_index; forced_codec_name = subtitle_codec_name; break;
2500 case AVMEDIA_TYPE_VIDEO : is->last_video_stream = stream_index; forced_codec_name = video_codec_name; break;
2502 if (forced_codec_name)
2503 codec = avcodec_find_decoder_by_name(forced_codec_name);
2505 if (forced_codec_name) av_log(NULL, AV_LOG_WARNING,
2506 "No codec could be found with name '%s'\n", forced_codec_name);
2507 else av_log(NULL, AV_LOG_WARNING,
2508 "No codec could be found with id %d\n", avctx->codec_id);
2512 avctx->codec_id = codec->id;
2513 avctx->workaround_bugs = workaround_bugs;
2514 if(stream_lowres > av_codec_get_max_lowres(codec)){
2515 av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2516 av_codec_get_max_lowres(codec));
2517 stream_lowres = av_codec_get_max_lowres(codec);
2519 av_codec_set_lowres(avctx, stream_lowres);
2520 avctx->error_concealment = error_concealment;
2522 if(stream_lowres) avctx->flags |= CODEC_FLAG_EMU_EDGE;
2523 if (fast) avctx->flags2 |= CODEC_FLAG2_FAST;
2524 if(codec->capabilities & CODEC_CAP_DR1)
2525 avctx->flags |= CODEC_FLAG_EMU_EDGE;
2527 opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
2528 if (!av_dict_get(opts, "threads", NULL, 0))
2529 av_dict_set(&opts, "threads", "auto", 0);
2531 av_dict_set(&opts, "lowres", av_asprintf("%d", stream_lowres), AV_DICT_DONT_STRDUP_VAL);
2532 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
2533 av_dict_set(&opts, "refcounted_frames", "1", 0);
2534 if (avcodec_open2(avctx, codec, &opts) < 0)
2536 if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2537 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2538 return AVERROR_OPTION_NOT_FOUND;
2541 ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
2542 switch (avctx->codec_type) {
2543 case AVMEDIA_TYPE_AUDIO:
2548 is->audio_filter_src.freq = avctx->sample_rate;
2549 is->audio_filter_src.channels = avctx->channels;
2550 is->audio_filter_src.channel_layout = get_valid_channel_layout(avctx->channel_layout, avctx->channels);
2551 is->audio_filter_src.fmt = avctx->sample_fmt;
2552 if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
2554 link = is->out_audio_filter->inputs[0];
2555 sample_rate = link->sample_rate;
2556 nb_channels = link->channels;
2557 channel_layout = link->channel_layout;
2560 sample_rate = avctx->sample_rate;
2561 nb_channels = avctx->channels;
2562 channel_layout = avctx->channel_layout;
2565 /* prepare audio output */
2566 if ((ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)) < 0)
2568 is->audio_hw_buf_size = ret;
2569 is->audio_src = is->audio_tgt;
2570 is->audio_buf_size = 0;
2571 is->audio_buf_index = 0;
2573 /* init averaging filter */
2574 is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
2575 is->audio_diff_avg_count = 0;
2576 /* since we do not have a precise anough audio fifo fullness,
2577 we correct audio sync only if larger than this threshold */
2578 is->audio_diff_threshold = 2.0 * is->audio_hw_buf_size / av_samples_get_buffer_size(NULL, is->audio_tgt.channels, is->audio_tgt.freq, is->audio_tgt.fmt, 1);
2580 memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
2581 memset(&is->audio_pkt_temp, 0, sizeof(is->audio_pkt_temp));
2582 is->audio_pkt_temp.stream_index = -1;
2584 is->audio_stream = stream_index;
2585 is->audio_st = ic->streams[stream_index];
2587 packet_queue_start(&is->audioq);
2590 case AVMEDIA_TYPE_VIDEO:
2591 is->video_stream = stream_index;
2592 is->video_st = ic->streams[stream_index];
2594 packet_queue_start(&is->videoq);
2595 is->video_tid = SDL_CreateThread(video_thread, is);
2596 is->queue_attachments_req = 1;
2598 case AVMEDIA_TYPE_SUBTITLE:
2599 is->subtitle_stream = stream_index;
2600 is->subtitle_st = ic->streams[stream_index];
2601 packet_queue_start(&is->subtitleq);
2603 is->subtitle_tid = SDL_CreateThread(subtitle_thread, is);
2611 static void stream_component_close(VideoState *is, int stream_index)
2613 AVFormatContext *ic = is->ic;
2614 AVCodecContext *avctx;
2616 if (stream_index < 0 || stream_index >= ic->nb_streams)
2618 avctx = ic->streams[stream_index]->codec;
2620 switch (avctx->codec_type) {
2621 case AVMEDIA_TYPE_AUDIO:
2622 packet_queue_abort(&is->audioq);
2626 packet_queue_flush(&is->audioq);
2627 av_free_packet(&is->audio_pkt);
2628 swr_free(&is->swr_ctx);
2629 av_freep(&is->audio_buf1);
2630 is->audio_buf1_size = 0;
2631 is->audio_buf = NULL;
2632 av_frame_free(&is->frame);
2635 av_rdft_end(is->rdft);
2636 av_freep(&is->rdft_data);
2641 avfilter_graph_free(&is->agraph);
2644 case AVMEDIA_TYPE_VIDEO:
2645 packet_queue_abort(&is->videoq);
2647 /* note: we also signal this mutex to make sure we deblock the
2648 video thread in all cases */
2649 SDL_LockMutex(is->pictq_mutex);
2650 SDL_CondSignal(is->pictq_cond);
2651 SDL_UnlockMutex(is->pictq_mutex);
2653 SDL_WaitThread(is->video_tid, NULL);
2655 packet_queue_flush(&is->videoq);
2657 case AVMEDIA_TYPE_SUBTITLE:
2658 packet_queue_abort(&is->subtitleq);
2660 /* note: we also signal this mutex to make sure we deblock the
2661 video thread in all cases */
2662 SDL_LockMutex(is->subpq_mutex);
2663 SDL_CondSignal(is->subpq_cond);
2664 SDL_UnlockMutex(is->subpq_mutex);
2666 SDL_WaitThread(is->subtitle_tid, NULL);
2668 packet_queue_flush(&is->subtitleq);
2674 ic->streams[stream_index]->discard = AVDISCARD_ALL;
2675 avcodec_close(avctx);
2676 switch (avctx->codec_type) {
2677 case AVMEDIA_TYPE_AUDIO:
2678 is->audio_st = NULL;
2679 is->audio_stream = -1;
2681 case AVMEDIA_TYPE_VIDEO:
2682 is->video_st = NULL;
2683 is->video_stream = -1;
2685 case AVMEDIA_TYPE_SUBTITLE:
2686 is->subtitle_st = NULL;
2687 is->subtitle_stream = -1;
2694 static int decode_interrupt_cb(void *ctx)
2696 VideoState *is = ctx;
2697 return is->abort_request;
2700 static int is_realtime(AVFormatContext *s)
2702 if( !strcmp(s->iformat->name, "rtp")
2703 || !strcmp(s->iformat->name, "rtsp")
2704 || !strcmp(s->iformat->name, "sdp")
2708 if(s->pb && ( !strncmp(s->filename, "rtp:", 4)
2709 || !strncmp(s->filename, "udp:", 4)
2716 /* this thread gets the stream from the disk or the network */
2717 static int read_thread(void *arg)
2719 VideoState *is = arg;
2720 AVFormatContext *ic = NULL;
2722 int st_index[AVMEDIA_TYPE_NB];
2723 AVPacket pkt1, *pkt = &pkt1;
2725 int64_t stream_start_time;
2726 int pkt_in_play_range = 0;
2727 AVDictionaryEntry *t;
2728 AVDictionary **opts;
2729 int orig_nb_streams;
2730 SDL_mutex *wait_mutex = SDL_CreateMutex();
2732 memset(st_index, -1, sizeof(st_index));
2733 is->last_video_stream = is->video_stream = -1;
2734 is->last_audio_stream = is->audio_stream = -1;
2735 is->last_subtitle_stream = is->subtitle_stream = -1;
2737 ic = avformat_alloc_context();
2738 ic->interrupt_callback.callback = decode_interrupt_cb;
2739 ic->interrupt_callback.opaque = is;
2740 err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
2742 print_error(is->filename, err);
2746 if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2747 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2748 ret = AVERROR_OPTION_NOT_FOUND;
2754 ic->flags |= AVFMT_FLAG_GENPTS;
2756 opts = setup_find_stream_info_opts(ic, codec_opts);
2757 orig_nb_streams = ic->nb_streams;
2759 err = avformat_find_stream_info(ic, opts);
2761 av_log(NULL, AV_LOG_WARNING,
2762 "%s: could not find codec parameters\n", is->filename);
2766 for (i = 0; i < orig_nb_streams; i++)
2767 av_dict_free(&opts[i]);
2771 ic->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use url_feof() to test for the end
2773 if (seek_by_bytes < 0)
2774 seek_by_bytes = !!(ic->iformat->flags & AVFMT_TS_DISCONT) && strcmp("ogg", ic->iformat->name);
2776 is->max_frame_duration = (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;
2778 if (!window_title && (t = av_dict_get(ic->metadata, "title", NULL, 0)))
2779 window_title = av_asprintf("%s - %s", t->value, input_filename);
2781 /* if seeking requested, we execute it */
2782 if (start_time != AV_NOPTS_VALUE) {
2785 timestamp = start_time;
2786 /* add the stream start time */
2787 if (ic->start_time != AV_NOPTS_VALUE)
2788 timestamp += ic->start_time;
2789 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
2791 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2792 is->filename, (double)timestamp / AV_TIME_BASE);
2796 is->realtime = is_realtime(ic);
2798 for (i = 0; i < ic->nb_streams; i++)
2799 ic->streams[i]->discard = AVDISCARD_ALL;
2801 st_index[AVMEDIA_TYPE_VIDEO] =
2802 av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
2803 wanted_stream[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
2805 st_index[AVMEDIA_TYPE_AUDIO] =
2806 av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
2807 wanted_stream[AVMEDIA_TYPE_AUDIO],
2808 st_index[AVMEDIA_TYPE_VIDEO],
2810 if (!video_disable && !subtitle_disable)
2811 st_index[AVMEDIA_TYPE_SUBTITLE] =
2812 av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
2813 wanted_stream[AVMEDIA_TYPE_SUBTITLE],
2814 (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
2815 st_index[AVMEDIA_TYPE_AUDIO] :
2816 st_index[AVMEDIA_TYPE_VIDEO]),
2819 av_dump_format(ic, 0, is->filename, 0);
2822 is->show_mode = show_mode;
2824 /* open the streams */
2825 if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
2826 stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
2830 if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2831 ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
2833 if (is->show_mode == SHOW_MODE_NONE)
2834 is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
2836 if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
2837 stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
2840 if (is->video_stream < 0 && is->audio_stream < 0) {
2841 av_log(NULL, AV_LOG_FATAL, "Failed to open file '%s' or configure filtergraph\n",
2847 if (infinite_buffer < 0 && is->realtime)
2848 infinite_buffer = 1;
2851 if (is->abort_request)
2853 if (is->paused != is->last_paused) {
2854 is->last_paused = is->paused;
2856 is->read_pause_return = av_read_pause(ic);
2860 #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
2862 (!strcmp(ic->iformat->name, "rtsp") ||
2863 (ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
2864 /* wait 10 ms to avoid trying to get another packet */
2871 int64_t seek_target = is->seek_pos;
2872 int64_t seek_min = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
2873 int64_t seek_max = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
2874 // FIXME the +-2 is due to rounding being not done in the correct direction in generation
2875 // of the seek_pos/seek_rel variables
2877 ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
2879 av_log(NULL, AV_LOG_ERROR,
2880 "%s: error while seeking\n", is->ic->filename);
2882 if (is->audio_stream >= 0) {
2883 packet_queue_flush(&is->audioq);
2884 packet_queue_put(&is->audioq, &flush_pkt);
2886 if (is->subtitle_stream >= 0) {
2887 packet_queue_flush(&is->subtitleq);
2888 packet_queue_put(&is->subtitleq, &flush_pkt);
2890 if (is->video_stream >= 0) {
2891 packet_queue_flush(&is->videoq);
2892 packet_queue_put(&is->videoq, &flush_pkt);
2894 if (is->seek_flags & AVSEEK_FLAG_BYTE) {
2895 set_clock(&is->extclk, NAN, 0);
2897 set_clock(&is->extclk, seek_target / (double)AV_TIME_BASE, 0);
2901 is->queue_attachments_req = 1;
2904 step_to_next_frame(is);
2906 if (is->queue_attachments_req) {
2907 if (is->video_st && is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC) {
2909 if ((ret = av_copy_packet(©, &is->video_st->attached_pic)) < 0)
2911 packet_queue_put(&is->videoq, ©);
2912 packet_queue_put_nullpacket(&is->videoq, is->video_stream);
2914 is->queue_attachments_req = 0;
2917 /* if the queue are full, no need to read more */
2918 if (infinite_buffer<1 &&
2919 (is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
2920 || ( (is->audioq .nb_packets > MIN_FRAMES || is->audio_stream < 0 || is->audioq.abort_request)
2921 && (is->videoq .nb_packets > MIN_FRAMES || is->video_stream < 0 || is->videoq.abort_request
2922 || (is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2923 && (is->subtitleq.nb_packets > MIN_FRAMES || is->subtitle_stream < 0 || is->subtitleq.abort_request)))) {
2925 SDL_LockMutex(wait_mutex);
2926 SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
2927 SDL_UnlockMutex(wait_mutex);
2931 (!is->audio_st || is->audio_finished == is->audioq.serial) &&
2932 (!is->video_st || (is->video_finished == is->videoq.serial && is->pictq_size == 0))) {
2933 if (loop != 1 && (!loop || --loop)) {
2934 stream_seek(is, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
2935 } else if (autoexit) {
2941 if (is->video_stream >= 0)
2942 packet_queue_put_nullpacket(&is->videoq, is->video_stream);
2943 if (is->audio_stream >= 0)
2944 packet_queue_put_nullpacket(&is->audioq, is->audio_stream);
2949 ret = av_read_frame(ic, pkt);
2951 if (ret == AVERROR_EOF || url_feof(ic->pb))
2953 if (ic->pb && ic->pb->error)
2955 SDL_LockMutex(wait_mutex);
2956 SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
2957 SDL_UnlockMutex(wait_mutex);
2960 /* check if packet is in play range specified by user, then queue, otherwise discard */
2961 stream_start_time = ic->streams[pkt->stream_index]->start_time;
2962 pkt_in_play_range = duration == AV_NOPTS_VALUE ||
2963 (pkt->pts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
2964 av_q2d(ic->streams[pkt->stream_index]->time_base) -
2965 (double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
2966 <= ((double)duration / 1000000);
2967 if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
2968 packet_queue_put(&is->audioq, pkt);
2969 } else if (pkt->stream_index == is->video_stream && pkt_in_play_range
2970 && !(is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
2971 packet_queue_put(&is->videoq, pkt);
2972 } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
2973 packet_queue_put(&is->subtitleq, pkt);
2975 av_free_packet(pkt);
2978 /* wait until the end */
2979 while (!is->abort_request) {
2985 /* close each stream */
2986 if (is->audio_stream >= 0)
2987 stream_component_close(is, is->audio_stream);
2988 if (is->video_stream >= 0)
2989 stream_component_close(is, is->video_stream);
2990 if (is->subtitle_stream >= 0)
2991 stream_component_close(is, is->subtitle_stream);
2993 avformat_close_input(&is->ic);
2999 event.type = FF_QUIT_EVENT;
3000 event.user.data1 = is;
3001 SDL_PushEvent(&event);
3003 SDL_DestroyMutex(wait_mutex);
3007 static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
3011 is = av_mallocz(sizeof(VideoState));
3014 av_strlcpy(is->filename, filename, sizeof(is->filename));
3015 is->iformat = iformat;
3019 /* start video display */
3020 is->pictq_mutex = SDL_CreateMutex();
3021 is->pictq_cond = SDL_CreateCond();
3023 is->subpq_mutex = SDL_CreateMutex();
3024 is->subpq_cond = SDL_CreateCond();
3026 packet_queue_init(&is->videoq);
3027 packet_queue_init(&is->audioq);
3028 packet_queue_init(&is->subtitleq);
3030 is->continue_read_thread = SDL_CreateCond();
3032 init_clock(&is->vidclk, &is->videoq.serial);
3033 init_clock(&is->audclk, &is->audioq.serial);
3034 init_clock(&is->extclk, &is->extclk.serial);
3035 is->audio_clock_serial = -1;
3036 is->audio_last_serial = -1;
3037 is->av_sync_type = av_sync_type;
3038 is->read_tid = SDL_CreateThread(read_thread, is);
3039 if (!is->read_tid) {
3046 static void stream_cycle_channel(VideoState *is, int codec_type)
3048 AVFormatContext *ic = is->ic;
3049 int start_index, stream_index;
3052 AVProgram *p = NULL;
3053 int nb_streams = is->ic->nb_streams;
3055 if (codec_type == AVMEDIA_TYPE_VIDEO) {
3056 start_index = is->last_video_stream;
3057 old_index = is->video_stream;
3058 } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
3059 start_index = is->last_audio_stream;
3060 old_index = is->audio_stream;
3062 start_index = is->last_subtitle_stream;
3063 old_index = is->subtitle_stream;
3065 stream_index = start_index;
3067 if (codec_type != AVMEDIA_TYPE_VIDEO && is->video_stream != -1) {
3068 p = av_find_program_from_stream(ic, NULL, is->video_stream);
3070 nb_streams = p->nb_stream_indexes;
3071 for (start_index = 0; start_index < nb_streams; start_index++)
3072 if (p->stream_index[start_index] == stream_index)
3074 if (start_index == nb_streams)
3076 stream_index = start_index;
3081 if (++stream_index >= nb_streams)
3083 if (codec_type == AVMEDIA_TYPE_SUBTITLE)
3086 is->last_subtitle_stream = -1;
3089 if (start_index == -1)
3093 if (stream_index == start_index)
3095 st = is->ic->streams[p ? p->stream_index[stream_index] : stream_index];
3096 if (st->codec->codec_type == codec_type) {
3097 /* check that parameters are OK */
3098 switch (codec_type) {
3099 case AVMEDIA_TYPE_AUDIO:
3100 if (st->codec->sample_rate != 0 &&
3101 st->codec->channels != 0)
3104 case AVMEDIA_TYPE_VIDEO:
3105 case AVMEDIA_TYPE_SUBTITLE:
3113 if (p && stream_index != -1)
3114 stream_index = p->stream_index[stream_index];
3115 stream_component_close(is, old_index);
3116 stream_component_open(is, stream_index);
3120 static void toggle_full_screen(VideoState *is)
3122 #if defined(__APPLE__) && SDL_VERSION_ATLEAST(1, 2, 14)
3123 /* OS X needs to reallocate the SDL overlays */
3125 for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++)
3126 is->pictq[i].reallocate = 1;
3128 is_full_screen = !is_full_screen;
3129 video_open(is, 1, NULL);
3132 static void toggle_audio_display(VideoState *is)
3134 int bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
3135 int next = is->show_mode;
3137 next = (next + 1) % SHOW_MODE_NB;
3138 } while (next != is->show_mode && (next == SHOW_MODE_VIDEO && !is->video_st || next != SHOW_MODE_VIDEO && !is->audio_st));
3139 if (is->show_mode != next) {
3140 fill_rectangle(screen,
3141 is->xleft, is->ytop, is->width, is->height,
3143 is->force_refresh = 1;
3144 is->show_mode = next;
3148 static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
3149 double remaining_time = 0.0;
3151 while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_ALLEVENTS)) {
3152 if (!cursor_hidden && av_gettime() - cursor_last_shown > CURSOR_HIDE_DELAY) {
3156 if (remaining_time > 0.0)
3157 av_usleep((int64_t)(remaining_time * 1000000.0));
3158 remaining_time = REFRESH_RATE;
3159 if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
3160 video_refresh(is, &remaining_time);
3165 /* handle an event sent by the GUI */
3166 static void event_loop(VideoState *cur_stream)
3169 double incr, pos, frac;
3173 refresh_loop_wait_event(cur_stream, &event);
3174 switch (event.type) {
3176 if (exit_on_keydown) {
3177 do_exit(cur_stream);
3180 switch (event.key.keysym.sym) {
3183 do_exit(cur_stream);
3186 toggle_full_screen(cur_stream);
3187 cur_stream->force_refresh = 1;
3191 toggle_pause(cur_stream);
3193 case SDLK_s: // S: Step to next frame
3194 step_to_next_frame(cur_stream);
3197 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3200 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3203 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3204 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3205 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3208 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3211 toggle_audio_display(cur_stream);
3231 if (seek_by_bytes) {
3232 if (cur_stream->video_stream >= 0 && cur_stream->video_current_pos >= 0) {
3233 pos = cur_stream->video_current_pos;
3234 } else if (cur_stream->audio_stream >= 0 && cur_stream->audio_pkt.pos >= 0) {
3235 pos = cur_stream->audio_pkt.pos;
3237 pos = avio_tell(cur_stream->ic->pb);
3238 if (cur_stream->ic->bit_rate)
3239 incr *= cur_stream->ic->bit_rate / 8.0;
3243 stream_seek(cur_stream, pos, incr, 1);
3245 pos = get_master_clock(cur_stream);
3247 pos = (double)cur_stream->seek_pos / AV_TIME_BASE;
3249 if (cur_stream->ic->start_time != AV_NOPTS_VALUE && pos < cur_stream->ic->start_time / (double)AV_TIME_BASE)
3250 pos = cur_stream->ic->start_time / (double)AV_TIME_BASE;
3251 stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE), 0);
3258 case SDL_VIDEOEXPOSE:
3259 cur_stream->force_refresh = 1;
3261 case SDL_MOUSEBUTTONDOWN:
3262 if (exit_on_mousedown) {
3263 do_exit(cur_stream);
3266 case SDL_MOUSEMOTION:
3267 if (cursor_hidden) {
3271 cursor_last_shown = av_gettime();
3272 if (event.type == SDL_MOUSEBUTTONDOWN) {
3275 if (event.motion.state != SDL_PRESSED)
3279 if (seek_by_bytes || cur_stream->ic->duration <= 0) {
3280 uint64_t size = avio_size(cur_stream->ic->pb);
3281 stream_seek(cur_stream, size*x/cur_stream->width, 0, 1);
3285 int tns, thh, tmm, tss;
3286 tns = cur_stream->ic->duration / 1000000LL;
3288 tmm = (tns % 3600) / 60;
3290 frac = x / cur_stream->width;
3293 mm = (ns % 3600) / 60;
3295 av_log(NULL, AV_LOG_INFO,
3296 "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d) \n", frac*100,
3297 hh, mm, ss, thh, tmm, tss);
3298 ts = frac * cur_stream->ic->duration;
3299 if (cur_stream->ic->start_time != AV_NOPTS_VALUE)
3300 ts += cur_stream->ic->start_time;
3301 stream_seek(cur_stream, ts, 0, 0);
3304 case SDL_VIDEORESIZE:
3305 screen = SDL_SetVideoMode(FFMIN(16383, event.resize.w), event.resize.h, 0,
3306 SDL_HWSURFACE|SDL_RESIZABLE|SDL_ASYNCBLIT|SDL_HWACCEL);
3308 av_log(NULL, AV_LOG_FATAL, "Failed to set video mode\n");
3309 do_exit(cur_stream);
3311 screen_width = cur_stream->width = screen->w;
3312 screen_height = cur_stream->height = screen->h;
3313 cur_stream->force_refresh = 1;
3317 do_exit(cur_stream);
3319 case FF_ALLOC_EVENT:
3320 alloc_picture(event.user.data1);
3328 static int opt_frame_size(void *optctx, const char *opt, const char *arg)
3330 av_log(NULL, AV_LOG_WARNING, "Option -s is deprecated, use -video_size.\n");
3331 return opt_default(NULL, "video_size", arg);
3334 static int opt_width(void *optctx, const char *opt, const char *arg)
3336 screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3340 static int opt_height(void *optctx, const char *opt, const char *arg)
3342 screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3346 static int opt_format(void *optctx, const char *opt, const char *arg)
3348 file_iformat = av_find_input_format(arg);
3349 if (!file_iformat) {
3350 av_log(NULL, AV_LOG_FATAL, "Unknown input format: %s\n", arg);
3351 return AVERROR(EINVAL);
3356 static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
3358 av_log(NULL, AV_LOG_WARNING, "Option -pix_fmt is deprecated, use -pixel_format.\n");
3359 return opt_default(NULL, "pixel_format", arg);
3362 static int opt_sync(void *optctx, const char *opt, const char *arg)
3364 if (!strcmp(arg, "audio"))
3365 av_sync_type = AV_SYNC_AUDIO_MASTER;
3366 else if (!strcmp(arg, "video"))
3367 av_sync_type = AV_SYNC_VIDEO_MASTER;
3368 else if (!strcmp(arg, "ext"))
3369 av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
3371 av_log(NULL, AV_LOG_ERROR, "Unknown value for %s: %s\n", opt, arg);
3377 static int opt_seek(void *optctx, const char *opt, const char *arg)
3379 start_time = parse_time_or_die(opt, arg, 1);
3383 static int opt_duration(void *optctx, const char *opt, const char *arg)
3385 duration = parse_time_or_die(opt, arg, 1);
3389 static int opt_show_mode(void *optctx, const char *opt, const char *arg)
3391 show_mode = !strcmp(arg, "video") ? SHOW_MODE_VIDEO :
3392 !strcmp(arg, "waves") ? SHOW_MODE_WAVES :
3393 !strcmp(arg, "rdft" ) ? SHOW_MODE_RDFT :
3394 parse_number_or_die(opt, arg, OPT_INT, 0, SHOW_MODE_NB-1);
3398 static void opt_input_file(void *optctx, const char *filename)
3400 if (input_filename) {
3401 av_log(NULL, AV_LOG_FATAL,
3402 "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3403 filename, input_filename);
3406 if (!strcmp(filename, "-"))
3408 input_filename = filename;
3411 static int opt_codec(void *optctx, const char *opt, const char *arg)
3413 const char *spec = strchr(opt, ':');
3415 av_log(NULL, AV_LOG_ERROR,
3416 "No media specifier was specified in '%s' in option '%s'\n",
3418 return AVERROR(EINVAL);
3422 case 'a' : audio_codec_name = arg; break;
3423 case 's' : subtitle_codec_name = arg; break;
3424 case 'v' : video_codec_name = arg; break;
3426 av_log(NULL, AV_LOG_ERROR,
3427 "Invalid media specifier '%s' in option '%s'\n", spec, opt);
3428 return AVERROR(EINVAL);
3435 static const OptionDef options[] = {
3436 #include "cmdutils_common_opts.h"
3437 { "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
3438 { "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
3439 { "s", HAS_ARG | OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
3440 { "fs", OPT_BOOL, { &is_full_screen }, "force full screen" },
3441 { "an", OPT_BOOL, { &audio_disable }, "disable audio" },
3442 { "vn", OPT_BOOL, { &video_disable }, "disable video" },
3443 { "sn", OPT_BOOL, { &subtitle_disable }, "disable subtitling" },
3444 { "ast", OPT_INT | HAS_ARG | OPT_EXPERT, { &wanted_stream[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_number" },
3445 { "vst", OPT_INT | HAS_ARG | OPT_EXPERT, { &wanted_stream[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_number" },
3446 { "sst", OPT_INT | HAS_ARG | OPT_EXPERT, { &wanted_stream[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_number" },
3447 { "ss", HAS_ARG, { .func_arg = opt_seek }, "seek to a given position in seconds", "pos" },
3448 { "t", HAS_ARG, { .func_arg = opt_duration }, "play \"duration\" seconds of audio/video", "duration" },
3449 { "bytes", OPT_INT | HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
3450 { "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
3451 { "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
3452 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
3453 { "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" },
3454 { "bug", OPT_INT | HAS_ARG | OPT_EXPERT, { &workaround_bugs }, "workaround bugs", "" },
3455 { "fast", OPT_BOOL | OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
3456 { "genpts", OPT_BOOL | OPT_EXPERT, { &genpts }, "generate pts", "" },
3457 { "drp", OPT_INT | HAS_ARG | OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
3458 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, { &lowres }, "", "" },
3459 { "ec", OPT_INT | HAS_ARG | OPT_EXPERT, { &error_concealment }, "set error concealment options", "bit_mask" },
3460 { "sync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
3461 { "autoexit", OPT_BOOL | OPT_EXPERT, { &autoexit }, "exit at the end", "" },
3462 { "exitonkeydown", OPT_BOOL | OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
3463 { "exitonmousedown", OPT_BOOL | OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
3464 { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
3465 { "framedrop", OPT_BOOL | OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
3466 { "infbuf", OPT_BOOL | OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
3467 { "window_title", OPT_STRING | HAS_ARG, { &window_title }, "set window title", "window title" },
3469 { "vf", OPT_STRING | HAS_ARG, { &vfilters }, "set video filters", "filter_graph" },
3470 { "af", OPT_STRING | HAS_ARG, { &afilters }, "set audio filters", "filter_graph" },
3472 { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
3473 { "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
3474 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default }, "generic catch all option", "" },
3475 { "i", OPT_BOOL, { &dummy}, "read specified file", "input_file"},
3476 { "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
3477 { "acodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &audio_codec_name }, "force audio decoder", "decoder_name" },
3478 { "scodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
3479 { "vcodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &video_codec_name }, "force video decoder", "decoder_name" },
3483 static void show_usage(void)
3485 av_log(NULL, AV_LOG_INFO, "Simple media player\n");
3486 av_log(NULL, AV_LOG_INFO, "usage: %s [options] input_file\n", program_name);
3487 av_log(NULL, AV_LOG_INFO, "\n");
3490 void show_help_default(const char *opt, const char *arg)
3492 av_log_set_callback(log_callback_help);
3494 show_help_options(options, "Main options:", 0, OPT_EXPERT, 0);
3495 show_help_options(options, "Advanced options:", OPT_EXPERT, 0, 0);
3497 show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3498 show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3499 #if !CONFIG_AVFILTER
3500 show_help_children(sws_get_class(), AV_OPT_FLAG_ENCODING_PARAM);
3502 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
3504 printf("\nWhile playing:\n"
3506 "f toggle full screen\n"
3508 "a cycle audio channel in the current program\n"
3509 "v cycle video channel\n"
3510 "t cycle subtitle channel in the current program\n"
3512 "w show audio waves\n"
3513 "s activate frame-step mode\n"
3514 "left/right seek backward/forward 10 seconds\n"
3515 "down/up seek backward/forward 1 minute\n"
3516 "page down/page up seek backward/forward 10 minutes\n"
3517 "mouse click seek to percentage in file corresponding to fraction of width\n"
3521 static int lockmgr(void **mtx, enum AVLockOp op)
3524 case AV_LOCK_CREATE:
3525 *mtx = SDL_CreateMutex();
3529 case AV_LOCK_OBTAIN:
3530 return !!SDL_LockMutex(*mtx);
3531 case AV_LOCK_RELEASE:
3532 return !!SDL_UnlockMutex(*mtx);
3533 case AV_LOCK_DESTROY:
3534 SDL_DestroyMutex(*mtx);
3540 /* Called from the main */
3541 int main(int argc, char **argv)
3545 char dummy_videodriver[] = "SDL_VIDEODRIVER=dummy";
3547 av_log_set_flags(AV_LOG_SKIP_REPEATED);
3548 parse_loglevel(argc, argv, options);
3550 /* register all codecs, demux and protocols */
3552 avdevice_register_all();
3555 avfilter_register_all();
3558 avformat_network_init();
3562 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
3563 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
3565 show_banner(argc, argv, options);
3567 parse_options(NULL, argc, argv, options, opt_input_file);
3569 if (!input_filename) {
3571 av_log(NULL, AV_LOG_FATAL, "An input file must be specified\n");
3572 av_log(NULL, AV_LOG_FATAL,
3573 "Use -h to get full help or, even better, run 'man %s'\n", program_name);
3577 if (display_disable) {
3580 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
3582 flags &= ~SDL_INIT_AUDIO;
3583 if (display_disable)
3584 SDL_putenv(dummy_videodriver); /* For the event queue, we always need a video driver. */
3585 #if !defined(__MINGW32__) && !defined(__APPLE__)
3586 flags |= SDL_INIT_EVENTTHREAD; /* Not supported on Windows or Mac OS X */
3588 if (SDL_Init (flags)) {
3589 av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n", SDL_GetError());
3590 av_log(NULL, AV_LOG_FATAL, "(Did you set the DISPLAY variable?)\n");
3594 if (!display_disable) {
3595 const SDL_VideoInfo *vi = SDL_GetVideoInfo();
3596 fs_screen_width = vi->current_w;
3597 fs_screen_height = vi->current_h;
3600 SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
3601 SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
3602 SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
3604 if (av_lockmgr_register(lockmgr)) {
3605 av_log(NULL, AV_LOG_FATAL, "Could not initialize lock manager!\n");
3609 av_init_packet(&flush_pkt);
3610 flush_pkt.data = (uint8_t *)&flush_pkt;
3612 is = stream_open(input_filename, file_iformat);
3614 av_log(NULL, AV_LOG_FATAL, "Failed to initialize VideoState!\n");