59 #include <SDL_thread.h> 68 #define MAX_QUEUE_SIZE (15 * 1024 * 1024) 70 #define EXTERNAL_CLOCK_MIN_FRAMES 2 71 #define EXTERNAL_CLOCK_MAX_FRAMES 10 74 #define SDL_AUDIO_MIN_BUFFER_SIZE 512 76 #define SDL_AUDIO_MAX_CALLBACKS_PER_SEC 30 79 #define SDL_VOLUME_STEP (0.75) 82 #define AV_SYNC_THRESHOLD_MIN 0.04 84 #define AV_SYNC_THRESHOLD_MAX 0.1 86 #define AV_SYNC_FRAMEDUP_THRESHOLD 0.1 88 #define AV_NOSYNC_THRESHOLD 10.0 91 #define SAMPLE_CORRECTION_PERCENT_MAX 10 94 #define EXTERNAL_CLOCK_SPEED_MIN 0.900 95 #define EXTERNAL_CLOCK_SPEED_MAX 1.010 96 #define EXTERNAL_CLOCK_SPEED_STEP 0.001 99 #define AUDIO_DIFF_AVG_NB 20 102 #define REFRESH_RATE 0.01 106 #define SAMPLE_ARRAY_SIZE (8 * 65536) 108 #define CURSOR_HIDE_DELAY 1000000 110 #define USE_ONEPASS_SUBTITLE_RENDER 1 130 #define VIDEO_PICTURE_QUEUE_SIZE 3 131 #define SUBPICTURE_QUEUE_SIZE 16 132 #define SAMPLE_QUEUE_SIZE 9 133 #define FRAME_QUEUE_SIZE FFMAX(SAMPLE_QUEUE_SIZE, FFMAX(VIDEO_PICTURE_QUEUE_SIZE, SUBPICTURE_QUEUE_SIZE)) 263 SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO = 0,
SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB
352 static const char **vfilters_list =
NULL;
353 static int nb_vfilters = 0;
354 static char *afilters =
NULL;
364 #define FF_QUIT_EVENT (SDL_USEREVENT + 2) 398 static int opt_add_vfilter(
void *optctx,
const char *opt,
const char *
arg)
401 vfilters_list[nb_vfilters - 1] =
arg;
411 if (channel_count1 == 1 && channel_count2 == 1)
414 return channel_count1 != channel_count2 || fmt1 != fmt2;
421 return channel_layout;
446 SDL_CondSignal(q->
cond);
462 SDL_LockMutex(q->
mutex);
464 SDL_UnlockMutex(q->
mutex);
485 q->
mutex = SDL_CreateMutex();
490 q->
cond = SDL_CreateCond();
503 SDL_LockMutex(q->
mutex);
512 SDL_UnlockMutex(q->
mutex);
519 SDL_DestroyMutex(q->
mutex);
520 SDL_DestroyCond(q->
cond);
525 SDL_LockMutex(q->
mutex);
529 SDL_CondSignal(q->
cond);
531 SDL_UnlockMutex(q->
mutex);
536 SDL_LockMutex(q->
mutex);
539 SDL_UnlockMutex(q->
mutex);
548 SDL_LockMutex(q->
mutex);
574 SDL_UnlockMutex(q->
mutex);
633 }
while (ret !=
AVERROR(EAGAIN));
663 if (got_frame && !d->
pkt->
data) {
671 av_log(d->
avctx,
AV_LOG_ERROR,
"Receive_frame and send_packet both returned EAGAIN, which is an API violation.\n");
695 if (!(f->
mutex = SDL_CreateMutex())) {
699 if (!(f->
cond = SDL_CreateCond())) {
720 SDL_DestroyMutex(f->
mutex);
721 SDL_DestroyCond(f->
cond);
726 SDL_LockMutex(f->
mutex);
727 SDL_CondSignal(f->
cond);
728 SDL_UnlockMutex(f->
mutex);
749 SDL_LockMutex(f->
mutex);
754 SDL_UnlockMutex(f->
mutex);
765 SDL_LockMutex(f->
mutex);
770 SDL_UnlockMutex(f->
mutex);
782 SDL_LockMutex(f->
mutex);
784 SDL_CondSignal(f->
cond);
785 SDL_UnlockMutex(f->
mutex);
797 SDL_LockMutex(f->
mutex);
799 SDL_CondSignal(f->
cond);
800 SDL_UnlockMutex(f->
mutex);
836 SDL_RenderFillRect(
renderer, &rect);
839 static int realloc_texture(SDL_Texture **texture, Uint32 new_format,
int new_width,
int new_height, SDL_BlendMode blendmode,
int init_texture)
843 if (!*texture || SDL_QueryTexture(*texture, &format, &access, &w, &h) < 0 || new_width != w || new_height != h || new_format != format) {
847 SDL_DestroyTexture(*texture);
848 if (!(*texture = SDL_CreateTexture(
renderer, new_format, SDL_TEXTUREACCESS_STREAMING, new_width, new_height)))
850 if (SDL_SetTextureBlendMode(*texture, blendmode) < 0)
853 if (SDL_LockTexture(*texture,
NULL, &pixels, &pitch) < 0)
855 memset(pixels, 0, pitch * new_height);
856 SDL_UnlockTexture(*texture);
858 av_log(
NULL,
AV_LOG_VERBOSE,
"Created %dx%d texture with %s.\n", new_width, new_height, SDL_GetPixelFormatName(new_format));
864 int scr_xleft,
int scr_ytop,
int scr_width,
int scr_height,
865 int pic_width,
int pic_height,
AVRational pic_sar)
878 if (width > scr_width) {
882 x = (scr_width -
width) / 2;
883 y = (scr_height -
height) / 2;
884 rect->x = scr_xleft + x;
885 rect->y = scr_ytop + y;
886 rect->w =
FFMAX((
int)width, 1);
887 rect->h =
FFMAX((
int)height, 1);
893 *sdl_blendmode = SDL_BLENDMODE_NONE;
894 *sdl_pix_fmt = SDL_PIXELFORMAT_UNKNOWN;
899 *sdl_blendmode = SDL_BLENDMODE_BLEND;
911 SDL_BlendMode sdl_blendmode;
913 if (
realloc_texture(tex, sdl_pix_fmt == SDL_PIXELFORMAT_UNKNOWN ? SDL_PIXELFORMAT_ARGB8888 : sdl_pix_fmt, frame->
width, frame->
height, sdl_blendmode, 0) < 0)
915 switch (sdl_pix_fmt) {
916 case SDL_PIXELFORMAT_UNKNOWN:
921 if (*img_convert_ctx !=
NULL) {
924 if (!SDL_LockTexture(*tex,
NULL, (
void **)pixels, pitch)) {
926 0, frame->
height, pixels, pitch);
927 SDL_UnlockTexture(*tex);
934 case SDL_PIXELFORMAT_IYUV:
961 #if SDL_VERSION_ATLEAST(2,0,8) 962 SDL_YUV_CONVERSION_MODE
mode = SDL_YUV_CONVERSION_AUTOMATIC;
965 mode = SDL_YUV_CONVERSION_JPEG;
967 mode = SDL_YUV_CONVERSION_BT709;
969 mode = SDL_YUV_CONVERSION_BT601;
971 SDL_SetYUVConversionMode(mode);
1014 if (!SDL_LockTexture(is->
sub_texture, (SDL_Rect *)sub_rect, (
void **)pixels, pitch)) {
1016 0, sub_rect->
h, pixels, pitch);
1040 #if USE_ONEPASS_SUBTITLE_RENDER 1044 double xratio = (double)rect.w / (
double)sp->
width;
1045 double yratio = (double)rect.h / (
double)sp->
height;
1047 SDL_Rect *sub_rect = (SDL_Rect*)sp->
sub.
rects[i];
1048 SDL_Rect target = {.
x = rect.x + sub_rect->x * xratio,
1049 .y = rect.y + sub_rect->y * yratio,
1050 .w = sub_rect->w * xratio,
1051 .h = sub_rect->h * yratio};
1060 return a < 0 ? a%b + b : a%
b;
1065 int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
1068 int rdft_bits, nb_freq;
1070 for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->
height; rdft_bits++)
1072 nb_freq = 1 << (rdft_bits - 1);
1078 int data_used= s->
show_mode == SHOW_MODE_WAVES ? s->
width : (2*nb_freq);
1090 delay += 2 * data_used;
1091 if (delay < data_used)
1097 for (i = 0; i < 1000; i +=
channels) {
1104 if (h < score && (b ^ c) < 0) {
1117 SDL_SetRenderDrawColor(
renderer, 255, 255, 255, 255);
1120 h = s->
height / nb_display_channels;
1123 for (ch = 0; ch < nb_display_channels; ch++) {
1125 y1 = s->
ytop + ch * h + (h / 2);
1126 for (x = 0; x < s->
width; x++) {
1141 SDL_SetRenderDrawColor(
renderer, 0, 0, 255, 255);
1143 for (ch = 1; ch < nb_display_channels; ch++) {
1144 y = s->
ytop + ch *
h;
1151 nb_display_channels=
FFMIN(nb_display_channels, 2);
1167 for (ch = 0; ch < nb_display_channels; ch++) {
1168 data[ch] = s->
rdft_data + 2 * nb_freq * ch;
1170 for (x = 0; x < 2 * nb_freq; x++) {
1171 double w = (x-nb_freq) * (1.0 / nb_freq);
1181 if (!SDL_LockTexture(s->
vis_texture, &rect, (
void **)&pixels, &pitch)) {
1183 pixels += pitch * s->
height;
1184 for (y = 0; y < s->
height; y++) {
1185 double w = 1 / sqrt(nb_freq);
1186 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]));
1187 int b = (nb_display_channels == 2 ) ? sqrt(w *
hypot(data[1][2 * y + 0], data[1][2 * y + 1]))
1192 *pixels = (a << 16) + (b << 8) + ((a+b) >> 1);
1210 if (stream_index < 0 || stream_index >= ic->
nb_streams)
1307 SDL_DestroyWindow(
window);
1330 if (max_width == INT_MAX && max_height == INT_MAX)
1348 SDL_SetWindowSize(
window, w, h);
1351 SDL_SetWindowFullscreen(
window, SDL_WINDOW_FULLSCREEN_DESKTOP);
1366 SDL_SetRenderDrawColor(
renderer, 0, 0, 0, 255);
1513 double volume_level = is->
audio_volume ? (20 * log(is->
audio_volume / (
double)SDL_MIX_MAXVOLUME) / log(10)) : -1000.0;
1514 int new_volume =
lrint(SDL_MIX_MAXVOLUME * pow(10.0, (volume_level + sign * step) / 20.0));
1528 double sync_threshold,
diff = 0;
1541 if (diff <= -sync_threshold)
1542 delay =
FFMAX(0, delay + diff);
1544 delay = delay +
diff;
1545 else if (diff >= sync_threshold)
1599 double last_duration,
duration, delay;
1622 if (time < is->frame_timer + delay) {
1666 if (!SDL_LockTexture(is->
sub_texture, (SDL_Rect *)sub_rect, (
void **)&pixels, &pitch)) {
1667 for (j = 0; j < sub_rect->
h; j++, pixels += pitch)
1668 memset(pixels, 0, sub_rect->
w << 2);
1694 static int64_t last_time;
1696 int aqsize, vqsize, sqsize;
1700 if (!last_time || (cur_time - last_time) >= 30000) {
1720 "%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64
"/%"PRId64
" \r",
1732 fprintf(stderr,
"%s", buf.str);
1739 last_time = cur_time;
1748 #if defined(DEBUG_SYNC) 1749 printf(
"frame_type=%c pts=%0.3f\n",
1819 if (!outputs || !inputs) {
1830 inputs->filter_ctx = sink_ctx;
1831 inputs->pad_idx = 0;
1832 inputs->next =
NULL;
1842 for (i = 0; i < graph->
nb_filters - nb_filters; i++)
1855 char sws_flags_str[512] =
"";
1856 char buffersrc_args[256];
1862 int nb_pix_fmts = 0;
1876 if (!strcmp(e->
key,
"sws_flags")) {
1877 av_strlcatf(sws_flags_str,
sizeof(sws_flags_str),
"%s=%s:",
"flags", e->
value);
1881 if (strlen(sws_flags_str))
1882 sws_flags_str[strlen(sws_flags_str)-1] =
'\0';
1886 snprintf(buffersrc_args,
sizeof(buffersrc_args),
1887 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
1892 av_strlcatf(buffersrc_args,
sizeof(buffersrc_args),
":frame_rate=%d/%d", fr.
num, fr.
den);
1896 "ffplay_buffer", buffersrc_args,
NULL,
1902 "ffplay_buffersink",
NULL,
NULL, graph);
1909 last_filter = filt_out;
1913 #define INSERT_FILT(name, arg) do { \ 1914 AVFilterContext *filt_ctx; \ 1916 ret = avfilter_graph_create_filter(&filt_ctx, \ 1917 avfilter_get_by_name(name), \ 1918 "ffplay_" name, arg, NULL, graph); \ 1922 ret = avfilter_link(filt_ctx, 0, last_filter, 0); \ 1926 last_filter = filt_ctx; \ 1932 if (
fabs(theta - 90) < 1.0) {
1933 INSERT_FILT(
"transpose",
"clock");
1934 }
else if (
fabs(theta - 180) < 1.0) {
1935 INSERT_FILT(
"hflip",
NULL);
1936 INSERT_FILT(
"vflip",
NULL);
1937 }
else if (
fabs(theta - 270) < 1.0) {
1938 INSERT_FILT(
"transpose",
"cclock");
1939 }
else if (
fabs(theta) > 1.0) {
1940 char rotate_buf[64];
1941 snprintf(rotate_buf,
sizeof(rotate_buf),
"%f*PI/180", theta);
1942 INSERT_FILT(
"rotate", rotate_buf);
1949 is->in_video_filter = filt_src;
1950 is->out_video_filter = filt_out;
1956 static int configure_audio_filters(
VideoState *is,
const char *afilters,
int force_output_format)
1963 char aresample_swr_opts[512] =
"";
1965 char asrc_args[256];
1975 if (strlen(aresample_swr_opts))
1976 aresample_swr_opts[strlen(aresample_swr_opts)-1] =
'\0';
1977 av_opt_set(is->agraph,
"aresample_swr_opts", aresample_swr_opts, 0);
1979 ret =
snprintf(asrc_args,
sizeof(asrc_args),
1980 "sample_rate=%d:sample_fmt=%s:channels=%d:time_base=%d/%d",
1982 is->audio_filter_src.channels,
1983 1, is->audio_filter_src.freq);
1984 if (is->audio_filter_src.channel_layout)
1985 snprintf(asrc_args + ret,
sizeof(asrc_args) - ret,
1986 ":channel_layout=0x%"PRIx64, is->audio_filter_src.channel_layout);
1990 asrc_args,
NULL, is->agraph);
2006 if (force_output_format) {
2024 is->in_audio_filter = filt_asrc;
2025 is->out_audio_filter = filt_asink;
2040 int last_serial = -1;
2041 int64_t dec_channel_layout;
2062 cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
2064 is->audio_filter_src.channel_layout != dec_channel_layout ||
2065 is->audio_filter_src.freq != frame->
sample_rate ||
2069 char buf1[1024], buf2[1024];
2073 "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",
2074 is->audio_filter_src.freq, is->audio_filter_src.channels,
av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, last_serial,
2077 is->audio_filter_src.fmt = frame->
format;
2078 is->audio_filter_src.channels = frame->
channels;
2079 is->audio_filter_src.channel_layout = dec_channel_layout;
2083 if ((ret = configure_audio_filters(is, afilters, 1)) < 0)
2148 int last_serial = -1;
2149 int last_vfilter_idx = 0;
2163 if ( last_w != frame->
width 2164 || last_h != frame->
height 2165 || last_format != frame->
format 2167 || last_vfilter_idx != is->vfilter_idx) {
2169 "Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
2181 if ((ret = configure_video_filters(graph, is, vfilters_list ? vfilters_list[is->vfilter_idx] :
NULL, frame)) < 0) {
2184 event.user.data1 =
is;
2185 SDL_PushEvent(&event);
2188 filt_in = is->in_video_filter;
2189 filt_out = is->out_video_filter;
2190 last_w = frame->
width;
2192 last_format = frame->
format;
2194 last_vfilter_idx = is->vfilter_idx;
2255 if (got_subtitle && sp->
sub.
format == 0) {
2266 }
else if (got_subtitle) {
2278 size = samples_size /
sizeof(
short);
2296 int wanted_nb_samples = nb_samples;
2300 double diff, avg_diff;
2301 int min_nb_samples, max_nb_samples;
2318 wanted_nb_samples =
av_clip(wanted_nb_samples, min_nb_samples, max_nb_samples);
2321 diff, avg_diff, wanted_nb_samples - nb_samples,
2332 return wanted_nb_samples;
2344 int data_size, resampled_data_size;
2345 int64_t dec_channel_layout;
2347 int wanted_nb_samples;
2370 dec_channel_layout =
2386 "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
2423 if (len2 == out_count) {
2432 resampled_data_size = data_size;
2444 static double last_clock;
2445 printf(
"audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
2451 return resampled_data_size;
2458 int audio_size, len1;
2465 if (audio_size < 0) {
2482 memset(stream, 0, len1);
2498 static int audio_open(
void *opaque, int64_t wanted_channel_layout,
int wanted_nb_channels,
int wanted_sample_rate,
struct AudioParams *audio_hw_params)
2500 SDL_AudioSpec wanted_spec, spec;
2502 static const int next_nb_channels[] = {0, 0, 1, 6, 2, 6, 4, 6};
2503 static const int next_sample_rates[] = {0, 44100, 48000, 96000, 192000};
2504 int next_sample_rate_idx =
FF_ARRAY_ELEMS(next_sample_rates) - 1;
2506 env = SDL_getenv(
"SDL_AUDIO_CHANNELS");
2508 wanted_nb_channels = atoi(env);
2516 wanted_spec.channels = wanted_nb_channels;
2517 wanted_spec.freq = wanted_sample_rate;
2518 if (wanted_spec.freq <= 0 || wanted_spec.channels <= 0) {
2522 while (next_sample_rate_idx && next_sample_rates[next_sample_rate_idx] >= wanted_spec.freq)
2523 next_sample_rate_idx--;
2524 wanted_spec.format = AUDIO_S16SYS;
2525 wanted_spec.silence = 0;
2528 wanted_spec.userdata = opaque;
2529 while (!(
audio_dev = SDL_OpenAudioDevice(
NULL, 0, &wanted_spec, &spec, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE | SDL_AUDIO_ALLOW_CHANNELS_CHANGE))) {
2531 wanted_spec.channels, wanted_spec.freq, SDL_GetError());
2532 wanted_spec.channels = next_nb_channels[
FFMIN(7, wanted_spec.channels)];
2533 if (!wanted_spec.channels) {
2534 wanted_spec.freq = next_sample_rates[next_sample_rate_idx--];
2535 wanted_spec.channels = wanted_nb_channels;
2536 if (!wanted_spec.freq) {
2538 "No more combinations to try, audio open failed\n");
2544 if (spec.format != AUDIO_S16SYS) {
2546 "SDL advised audio format %d is not supported!\n", spec.format);
2549 if (spec.channels != wanted_spec.channels) {
2551 if (!wanted_channel_layout) {
2553 "SDL advised channel count %d is not supported!\n", spec.channels);
2559 audio_hw_params->
freq = spec.freq;
2561 audio_hw_params->
channels = spec.channels;
2577 const char *forced_codec_name =
NULL;
2581 int64_t channel_layout;
2583 int stream_lowres =
lowres;
2585 if (stream_index < 0 || stream_index >= ic->
nb_streams)
2604 if (forced_codec_name)
2608 "No codec could be found with name '%s'\n", forced_codec_name);
2621 avctx->
lowres = stream_lowres;
2651 is->audio_filter_src.channels = avctx->
channels;
2653 is->audio_filter_src.fmt = avctx->
sample_fmt;
2654 if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
2656 sink = is->out_audio_filter;
2734 return stream_id < 0 ||
2748 if(s->
pb && ( !strncmp(s->
url,
"rtp:", 4)
2749 || !strncmp(s->
url,
"udp:", 4)
2764 int64_t stream_start_time;
2765 int pkt_in_play_range = 0;
2767 SDL_mutex *wait_mutex = SDL_CreateMutex();
2768 int scan_all_pmts_set = 0;
2777 memset(st_index, -1,
sizeof(st_index));
2796 scan_all_pmts_set = 1;
2804 if (scan_all_pmts_set)
2825 for (i = 0; i < orig_nb_streams; i++)
2831 "%s: could not find codec parameters\n", is->
filename);
2879 st_index[
i] = INT_MAX;
2891 st_index[AVMEDIA_TYPE_VIDEO],
2897 (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
2898 st_index[AVMEDIA_TYPE_AUDIO] :
2899 st_index[AVMEDIA_TYPE_VIDEO]),
2903 if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2907 if (codecpar->
width)
2912 if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
2917 if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2921 is->
show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
2923 if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
2934 if (infinite_buffer < 0 && is->realtime)
2947 #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL 2958 int64_t seek_target = is->
seek_pos;
2959 int64_t seek_min = is->
seek_rel > 0 ? seek_target - is->
seek_rel + 2: INT64_MIN;
2960 int64_t seek_max = is->
seek_rel < 0 ? seek_target - is->
seek_rel - 2: INT64_MAX;
2967 "%s: error while seeking\n", is->
ic->
url);
3004 SDL_LockMutex(wait_mutex);
3006 SDL_UnlockMutex(wait_mutex);
3036 SDL_LockMutex(wait_mutex);
3038 SDL_UnlockMutex(wait_mutex);
3047 (pkt_ts - (stream_start_time !=
AV_NOPTS_VALUE ? stream_start_time : 0)) *
3073 event.user.data1 =
is;
3074 SDL_PushEvent(&event);
3076 SDL_DestroyMutex(wait_mutex);
3141 int start_index, stream_index;
3157 stream_index = start_index;
3163 for (start_index = 0; start_index <
nb_streams; start_index++)
3166 if (start_index == nb_streams)
3168 stream_index = start_index;
3173 if (++stream_index >= nb_streams)
3181 if (start_index == -1)
3185 if (stream_index == start_index)
3190 switch (codec_type) {
3205 if (p && stream_index != -1)
3227 next = (next + 1) % SHOW_MODE_NB;
3228 }
while (next != is->
show_mode && (next == SHOW_MODE_VIDEO && !is->
video_st || next != SHOW_MODE_VIDEO && !is->
audio_st));
3236 double remaining_time = 0.0;
3238 while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) {
3243 if (remaining_time > 0.0)
3244 av_usleep((int64_t)(remaining_time * 1000000.0));
3283 double incr,
pos, frac;
3288 switch (event.type) {
3290 if (
exit_on_keydown || event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_q) {
3295 if (!cur_stream->
width)
3297 switch (event.key.keysym.sym) {
3309 case SDLK_KP_MULTIPLY:
3313 case SDLK_KP_DIVIDE:
3336 if (cur_stream->
show_mode == SHOW_MODE_VIDEO && cur_stream->vfilter_idx < nb_vfilters - 1) {
3337 if (++cur_stream->vfilter_idx >= nb_vfilters)
3338 cur_stream->vfilter_idx = 0;
3340 cur_stream->vfilter_idx = 0;
3401 case SDL_MOUSEBUTTONDOWN:
3406 if (event.button.button == SDL_BUTTON_LEFT) {
3407 static int64_t last_mouse_left_click = 0;
3411 last_mouse_left_click = 0;
3416 case SDL_MOUSEMOTION:
3422 if (event.type == SDL_MOUSEBUTTONDOWN) {
3423 if (event.button.button != SDL_BUTTON_RIGHT)
3427 if (!(event.motion.state & SDL_BUTTON_RMASK))
3437 int tns, thh, tmm, tss;
3440 tmm = (tns % 3600) / 60;
3442 frac = x / cur_stream->
width;
3445 mm = (ns % 3600) / 60;
3448 "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d) \n", frac*100,
3449 hh, mm, ss, thh, tmm, tss);
3456 case SDL_WINDOWEVENT:
3457 switch (event.window.event) {
3458 case SDL_WINDOWEVENT_SIZE_CHANGED:
3465 case SDL_WINDOWEVENT_EXPOSED:
3500 if (!file_iformat) {
3515 if (!strcmp(arg,
"audio"))
3517 else if (!strcmp(arg,
"video"))
3519 else if (!strcmp(arg,
"ext"))
3542 show_mode = !strcmp(arg,
"video") ? SHOW_MODE_VIDEO :
3543 !strcmp(arg,
"waves") ? SHOW_MODE_WAVES :
3544 !strcmp(arg,
"rdft" ) ? SHOW_MODE_RDFT :
3553 "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3557 if (!strcmp(filename,
"-"))
3564 const char *spec = strchr(opt,
':');
3567 "No media specifier was specified in '%s' in option '%s'\n",
3578 "Invalid media specifier '%s' in option '%s'\n", spec, opt);
3588 {
"x",
HAS_ARG, { .func_arg =
opt_width },
"force displayed width",
"width" },
3589 {
"y",
HAS_ARG, { .func_arg =
opt_height },
"force displayed height",
"height" },
3598 {
"ss",
HAS_ARG, { .func_arg =
opt_seek },
"seek to a given position in seconds",
"pos" },
3599 {
"t",
HAS_ARG, { .func_arg =
opt_duration },
"play \"duration\" seconds of audio/video",
"duration" },
3613 {
"sync",
HAS_ARG |
OPT_EXPERT, { .func_arg =
opt_sync },
"set audio-video sync. type (type=audio/video/ext)",
"type" },
3624 {
"vf",
OPT_EXPERT |
HAS_ARG, { .func_arg = opt_add_vfilter },
"set video filters",
"filter_graph" },
3625 {
"af",
OPT_STRING |
HAS_ARG, { &afilters },
"set audio filters",
"filter_graph" },
3628 {
"showmode",
HAS_ARG, { .func_arg =
opt_show_mode},
"select show mode (0 = video, 1 = waves, 2 = RDFT)",
"mode" },
3630 {
"i",
OPT_BOOL, { &dummy},
"read specified file",
"input_file"},
3631 {
"codec",
HAS_ARG, { .func_arg =
opt_codec},
"force decoder",
"decoder_name" },
3637 "read and decode the streams to fill missing information with heuristics" },
3658 #if !CONFIG_AVFILTER 3663 printf(
"\nWhile playing:\n" 3665 "f toggle full screen\n" 3668 "9, 0 decrease and increase volume respectively\n" 3669 "/, * decrease and increase volume respectively\n" 3670 "a cycle audio channel in the current program\n" 3671 "v cycle video channel\n" 3672 "t cycle subtitle channel in the current program\n" 3674 "w cycle video filters or show modes\n" 3675 "s activate frame-step mode\n" 3676 "left/right seek backward/forward 10 seconds or to custom interval if -seek_interval is set\n" 3677 "down/up seek backward/forward 1 minute\n" 3678 "page down/page up seek backward/forward 10 minutes\n" 3679 "right mouse click seek to percentage in file corresponding to fraction of width\n" 3680 "left double-click toggle full screen\n" 3714 "Use -h to get full help or, even better, run 'man %s'\n",
program_name);
3721 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
3723 flags &= ~SDL_INIT_AUDIO;
3727 if (!SDL_getenv(
"SDL_AUDIO_ALSA_SET_BUFFER_SIZE"))
3728 SDL_setenv(
"SDL_AUDIO_ALSA_SET_BUFFER_SIZE",
"1", 1);
3731 flags &= ~SDL_INIT_VIDEO;
3732 if (SDL_Init (flags)) {
3738 SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
3739 SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
3742 int flags = SDL_WINDOW_HIDDEN;
3744 #if SDL_VERSION_ATLEAST(2,0,5) 3745 flags |= SDL_WINDOW_ALWAYS_ON_TOP;
3747 av_log(
NULL,
AV_LOG_WARNING,
"Your SDL version doesn't support SDL_WINDOW_ALWAYS_ON_TOP. Feature will be inactive.\n");
3750 flags |= SDL_WINDOW_BORDERLESS;
3752 flags |= SDL_WINDOW_RESIZABLE;
3754 SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY,
"linear");
3756 renderer = SDL_CreateRenderer(
window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
unsigned int nb_chapters
Number of chapters in AVChapter array.
#define EXTERNAL_CLOCK_SPEED_STEP
AVFilterContext ** filters
static void packet_queue_abort(PacketQueue *q)
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
static int opt_show_mode(void *optctx, const char *opt, const char *arg)
void init_dynload(void)
Initialize dynamic library loading.
static void frame_queue_push(FrameQueue *f)
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
static SDL_AudioDeviceID audio_dev
static void video_image_display(VideoState *is)
static int filter_nbthreads
int av_fifo_grow(AVFifoBuffer *f, unsigned int size)
Enlarge an AVFifoBuffer.
static void packet_queue_flush(PacketQueue *q)
static double get_clock(Clock *c)
int64_t avio_size(AVIOContext *s)
Get the filesize.
void av_bprintf(AVBPrint *buf, const char *fmt,...)
static int opt_height(void *optctx, const char *opt, const char *arg)
static const struct TextureFormatEntry sdl_texture_format_map[]
const int program_birth_year
program birth year, defined by the program for show_banner()
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
#define EXTERNAL_CLOCK_SPEED_MIN
This structure describes decoded (raw) audio or video data.
#define VIDEO_PICTURE_QUEUE_SIZE
static SDL_Renderer * renderer
int x
top left corner of pict, undefined when pict is not set
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
ptrdiff_t const GLvoid * data
static AVInputFormat * file_iformat
static void opt_input_file(void *optctx, const char *filename)
double get_rotation(AVStream *st)
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
static int opt_format(void *optctx, const char *opt, const char *arg)
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
#define AV_LOG_WARNING
Something somehow does not look correct.
static int get_master_sync_type(VideoState *is)
Main libavfilter public API header.
packed RGB 8:8:8, 24bpp, RGBRGB...
#define AV_SYNC_FRAMEDUP_THRESHOLD
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
static int default_height
Memory buffer source API.
double frame_last_filter_delay
enum VideoState::ShowMode show_mode
int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
Check validity and configure all the links and formats in the graph.
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
AVRational sample_aspect_ratio
Video only.
struct AVFilterInOut * next
next input/input in the list, NULL if this is the last
#define av_opt_set_int_list(obj, name, val, term, flags)
Set a binary option to an integer list.
AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
Guess the sample aspect ratio of a frame, based on both the stream and the frame aspect ratio...
static void stream_cycle_channel(VideoState *is, int codec_type)
static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
static void stream_toggle_pause(VideoState *is)
static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
enum AVMediaType codec_type
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
void show_banner(int argc, char **argv, const OptionDef *options)
Print the program banner to stderr.
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
static int opt_codec(void *optctx, const char *opt, const char *arg)
static AVStream * video_stream
static unsigned sws_flags
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
static void set_clock_at(Clock *c, double pts, int serial, double time)
static void toggle_pause(VideoState *is)
double audio_diff_threshold
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
#define FF_ARRAY_ELEMS(a)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
int av_usleep(unsigned usec)
Sleep for a period of time.
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
#define AV_PIX_FMT_RGB444
static const char * audio_codec_name
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate.The lists are not just lists
static void seek_chapter(VideoState *is, int incr)
#define CMDUTILS_COMMON_OPTIONS
AVDictionary * filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, AVCodec *codec)
Filter out options for given codec.
This struct describes the properties of an encoded stream.
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
functionally identical to above
char * scale_sws_opts
sws options to use for the auto-inserted scale filters
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int(*func)(void *, void *, int))
Feed data from a user-supplied callback to an AVFifoBuffer.
static VideoState * stream_open(const char *filename, AVInputFormat *iformat)
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
struct SwsContext * img_convert_ctx
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
static void toggle_audio_display(VideoState *is)
AVRational av_guess_frame_rate(AVFormatContext *ctx, AVStream *stream, AVFrame *frame)
Guess the frame rate, based on both the container and codec information.
memory buffer sink API for audio and video
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
unsigned int nb_stream_indexes
#define AV_LOG_QUIET
Print no output.
int w
width of pict, undefined when pict is not set
int av_buffersink_get_sample_rate(const AVFilterContext *ctx)
double audio_diff_avg_coef
static int read_thread(void *arg)
static int decoder_init(Decoder *d, AVCodecContext *avctx, PacketQueue *queue, SDL_cond *empty_queue_cond)
int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)
Link two filters together.
int swr_set_compensation(struct SwrContext *s, int sample_delta, int compensation_distance)
Activate resampling compensation ("soft" compensation).
static Frame * frame_queue_peek(FrameQueue *f)
static int64_t start_time
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
enum AVSampleFormat sample_fmt
audio sample format
The exact code depends on how similar the blocks are and how related they are to the block
void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
Trivial log callback.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
int opt_default(void *optctx, const char *opt, const char *arg)
Fallback for options that are not explicitly handled, these will be parsed through AVOptions...
8 bits with AV_PIX_FMT_RGB32 palette
static void stream_component_close(VideoState *is, int stream_index)
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
static int decode_interrupt_cb(void *ctx)
struct SwrContext * swr_ctx
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
static void event_loop(VideoState *cur_stream)
static int cmp_audio_fmts(enum AVSampleFormat fmt1, int64_t channel_count1, enum AVSampleFormat fmt2, int64_t channel_count2)
int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the stream st contained in s is matched by the stream specifier spec.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
static void packet_queue_destroy(PacketQueue *q)
int av_fifo_space(const AVFifoBuffer *f)
Return the amount of space in bytes in the AVFifoBuffer, that is the amount of data you can write int...
SDL_Texture * vis_texture
void init_opts(void)
Initialize the cmdutils option system, in particular allocate the *_opts contexts.
AVStream ** streams
A list of all streams in the file.
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
int avfilter_graph_create_filter(AVFilterContext **filt_ctx, const AVFilter *filt, const char *name, const char *args, void *opaque, AVFilterGraph *graph_ctx)
Create and add a filter instance into an existing graph.
static float seek_interval
AVRational av_buffersink_get_frame_rate(const AVFilterContext *ctx)
static int64_t audio_callback_time
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
static int64_t get_valid_channel_layout(int64_t channel_layout, int channels)
int flags
Flags modifying the (de)muxer behaviour.
static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)
static void sigterm_handler(int sig)
void parse_options(void *optctx, int argc, char **argv, const OptionDef *options, void(*parse_arg_function)(void *, const char *))
static double av_q2d(AVRational a)
Convert an AVRational to a double.
int nb_threads
Maximum number of threads used by filters in this graph.
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
int avformat_network_init(void)
Do global initialization of network libraries.
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Frame queue[FRAME_QUEUE_SIZE]
#define AVERROR_EOF
End of file.
#define AV_LOG_VERBOSE
Detailed information.
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
void parse_loglevel(int argc, char **argv, const OptionDef *options)
Find the '-loglevel' option in the command line args and apply it.
#define AV_NOSYNC_THRESHOLD
int h
height of pict, undefined when pict is not set
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags, int alt_flags)
Print help for all options matching specified flags.
static int packet_queue_put_nullpacket(PacketQueue *q, AVPacket *pkt, int stream_index)
unsigned int * stream_index
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
AVDictionary * format_opts
static int realloc_texture(SDL_Texture **texture, Uint32 new_format, int new_width, int new_height, SDL_BlendMode blendmode, int init_texture)
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
#define SAMPLE_ARRAY_SIZE
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
static void toggle_mute(VideoState *is)
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
Print detailed information about the input or output format, such as duration, bitrate, streams, container, programs, metadata, side data, codec and time base.
Main libavdevice API header.
static int decoder_start(Decoder *d, int(*fn)(void *), const char *thread_name, void *arg)
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec **decoder_ret, int flags)
Find the "best" stream in the file.
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
libswresample public header
AVProgram * av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
Find the programs which belong to a given stream.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
AVDictionary * metadata
Metadata that applies to the whole file.
#define AV_PIX_FMT_BGR32_1
#define AV_PIX_FMT_NE(be, le)
static void video_refresh(void *opaque, double *remaining_time)
#define AV_OPT_FLAG_FILTERING_PARAM
a generic parameter which can be set by the user for filtering
static __device__ float fabs(float a)
int y
top left corner of pict, undefined when pict is not set
static AVStream * audio_stream
static void frame_queue_next(FrameQueue *f)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
The libswresample context.
ff_const59 struct AVInputFormat * iformat
The input container format.
static int frame_queue_nb_remaining(FrameQueue *f)
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
#define EXTERNAL_CLOCK_MAX_FRAMES
char * url
input or output URL.
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void(*func)(void *, void *, int))
Feed data from an AVFifoBuffer to a user-supplied callback.
#define CURSOR_HIDE_DELAY
int av_read_play(AVFormatContext *s)
Start playing a network-based stream (e.g.
static double compute_target_delay(double delay, VideoState *is)
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
enum AVMediaType codec_type
General type of the encoded data.
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
ff_const59 AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
enum AVColorSpace colorspace
YUV colorspace type.
static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
#define AV_LOG_SKIP_REPEATED
Skip repeated messages, this requires the user app to use av_log() instead of (f)printf as the 2 woul...
simple assert() macros that are a bit more flexible than ISO C assert().
static void stream_close(VideoState *is)
int av_log_get_level(void)
Get the current log level.
static int find_stream_info
#define AV_PIX_FMT_0BGR32
static int video_open(VideoState *is)
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
static void init_clock(Clock *c, int *queue_serial)
static void get_sdl_pix_fmt_and_blendmode(int format, Uint32 *sdl_pix_fmt, SDL_BlendMode *sdl_blendmode)
static enum ShowMode show_mode
New fields can be added to the end with minor version bumps.
static void packet_queue_start(PacketQueue *q)
static const OptionDef options[]
int attribute_align_arg av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags)
Get a frame with filtered data from sink and put it in frame.
enum AVPixelFormat format
uint64_t channel_layout
Audio channel layout.
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
static int opt_sync(void *optctx, const char *opt, const char *arg)
struct SwsContext * sws_getCachedContext(struct SwsContext *context, int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, SwsFilter *srcFilter, SwsFilter *dstFilter, const double *param)
Check if context can be reused, otherwise reallocate a new one.
static void update_sample_display(VideoState *is, short *samples, int samples_size)
void av_rdft_calc(RDFTContext *s, FFTSample *data)
uint32_t end_display_time
static void decoder_destroy(Decoder *d)
int64_t pts
Same as packet pts, in AV_TIME_BASE.
uint64_t channel_layout
Channel layout of the audio data.
double frame_last_returned_time
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
char * av_asprintf(const char *fmt,...)
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
static const char * subtitle_codec_name
static int subtitle_disable
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
static SDL_Window * window
const char program_name[]
program name, defined by the program for show_version().
int av_read_pause(AVFormatContext *s)
Pause a network-based stream (e.g.
static av_const double hypot(double x, double y)
#define ss(width, name, subs,...)
#define SAMPLE_QUEUE_SIZE
int channels
number of audio channels, only used for audio.
#define SUBPICTURE_QUEUE_SIZE
enum AVPictureType pict_type
Picture type of the frame.
#define AV_CH_LAYOUT_STEREO_DOWNMIX
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
#define AV_TIME_BASE
Internal time base represented as integer.
void av_log_set_callback(void(*callback)(void *, int, const char *, va_list))
Set the logging callback.
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
int width
picture width / height.
int main(int argc, char **argv)
static void show_usage(void)
static int opt_width(void *optctx, const char *opt, const char *arg)
static int get_video_frame(VideoState *is, AVFrame *frame)
struct AudioParams audio_src
static void refresh_loop_wait_event(VideoState *is, SDL_Event *event)
static void set_clock_speed(Clock *c, double speed)
#define SDL_AUDIO_MAX_CALLBACKS_PER_SEC
struct SwrContext * swr_alloc_set_opts(struct SwrContext *s, int64_t out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate, int64_t in_ch_layout, enum AVSampleFormat in_sample_fmt, int in_sample_rate, int log_offset, void *log_ctx)
Allocate SwrContext if needed and set/reset common parameters.
void sws_freeContext(struct SwsContext *swsContext)
Free the swscaler context swsContext.
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
void av_rdft_end(RDFTContext *s)
static void step_to_next_frame(VideoState *is)
packed RGB 8:8:8, 24bpp, BGRBGR...
static int audio_decode_frame(VideoState *is)
Decode one audio frame and return its uncompressed size.
RDFTContext * av_rdft_init(int nbits, enum RDFTransformType trans)
Set up a real FFT.
static int is_full_screen
#define AV_SYNC_THRESHOLD_MAX
static void fill_rectangle(int x, int y, int w, int h)
static int stream_has_enough_packets(AVStream *st, int stream_id, PacketQueue *queue)
static int startup_volume
#define SDL_AUDIO_MIN_BUFFER_SIZE
static int packet_queue_init(PacketQueue *q)
uint8_t * data[4]
data+linesize for the bitmap of this subtitle.
static int decoder_reorder_pts
#define AUDIO_DIFF_AVG_NB
static void set_clock(Clock *c, double pts, int serial)
int16_t sample_array[SAMPLE_ARRAY_SIZE]
AVFilterContext * filter_ctx
filter context associated to this input/output
static const char * input_filename
static const AVFilterPad outputs[]
static Frame * frame_queue_peek_last(FrameQueue *f)
void show_help_default(const char *opt, const char *arg)
Per-fftool specific help handler.
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
const AVClass * avfilter_get_class(void)
A linked-list of the inputs/outputs of the filter chain.
#define SAMPLE_CORRECTION_PERCENT_MAX
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
#define AV_PIX_FMT_BGR555
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.