hdkv/yuzu
1
Fork 0
Code Issues Pull Requests Releases 1 Activity

remove old files

Browse Source
This commit is contained in:
mgthepro
2022-01-24 11:43:50 +01:00
parent 87def5b55b
commit ae416cfe9f
8874 changed files with 0 additions and 2090184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
externals/ffmpeg/tests/.gitignore vendored
View File

@@ -1,11 +0,0 @@
/audiogen
/audiomatch
/base64
/data/
/pixfmts.mak
/rotozoom
/test_copy.ffmeta
/tiny_psnr
/tiny_ssim
/videogen
/vsynth1/

290
externals/ffmpeg/tests/Makefile vendored
View File

@@ -1,290 +0,0 @@
THREADS = 1
VREF = tests/vsynth1/00.pgm
AREF = tests/data/asynth1.sw
FATEW = 34
FATEH = 34
FFMPEG=ffmpeg$(PROGSSUF)$(EXESUF)
$(AREF): CMP=
APITESTSDIR := tests/api
DNNTESTSDIR := tests/dnn
FATE_OUTDIRS = tests/data tests/data/fate tests/data/filtergraphs tests/data/lavf tests/data/lavf-fate tests/data/pixfmt tests/vsynth1 $(APITESTSDIR) $(DNNTESTSDIR)
OUTDIRS += $(FATE_OUTDIRS)
$(VREF): tests/videogen$(HOSTEXESUF) | tests/vsynth1
$(M)./$< 'tests/vsynth1/'
$(AREF): tests/audiogen$(HOSTEXESUF) | tests/data
$(M)./$< $@
tests/data/asynth-%.wav: tests/audiogen$(HOSTEXESUF) | tests/data
$(M)./$< $@ $(subst -, ,$*)
tests/data/vsynth1.yuv: tests/videogen$(HOSTEXESUF) | tests/data
$(M)$< $@
tests/data/vsynth2.yuv: tests/rotozoom$(HOSTEXESUF) | tests/data
$(M)$< $(SRC_PATH)/tests/reference.pnm $@
tests/data/vsynth_lena.yuv: tests/rotozoom$(HOSTEXESUF) | tests/data
$(M)$< $(SAMPLES)/lena.pnm $@
tests/data/vsynth3.yuv: tests/videogen$(HOSTEXESUF) | tests/data
$(M)$< $@ $(FATEW) $(FATEH)
tests/test_copy.ffmeta: TAG = COPY
tests/test_copy.ffmeta: tests/data
$(M)cp -f $(SRC_PATH)/tests/test.ffmeta tests/test_copy.ffmeta
tests/data/ffprobe-test.nut: ffmpeg$(PROGSSUF)$(EXESUF) tests/test_copy.ffmeta
$(M)$(TARGET_EXEC) $(TARGET_PATH)/$< \
-f lavfi -i "aevalsrc=sin(400*PI*2*t):d=0.125[out0]; testsrc=d=0.125[out1]; testsrc=s=100x100:d=0.125[out2]" \
-f ffmetadata -i $(TARGET_PATH)/tests/test_copy.ffmeta \
-flags +bitexact -fflags +bitexact -map 0:0 -map 0:1 -map 0:2 -map_metadata 1 \
-map_metadata:s:0 1:s:0 -map_metadata:s:1 1:s:1 \
-vcodec rawvideo -acodec pcm_s16le \
-y $(TARGET_PATH)/$@ 2>/dev/null
tests/data/%.sw tests/data/asynth% tests/data/vsynth%.yuv tests/vsynth%/00.pgm tests/data/%.nut: TAG = GEN
tests/data/filtergraphs/%: TAG = COPY
tests/data/filtergraphs/%: $(SRC_PATH)/tests/filtergraphs/% | tests/data/filtergraphs
$(M)cp $< $@
RUNNING_FATE := $(filter check fate%,$(filter-out fate-rsync,$(MAKECMDGOALS)))
# Check sanity of dependencies when running FATE tests.
ifneq (,$(RUNNING_FATE))
CHKCFG = $(if $($(1))$(!$(1)),$($(1)), $(error No such config: $(1)))
endif
ALLYES = $(strip $(call XYES, $(1)))
XYES = $(if $(strip $(1)), \
$(if $(call CHKCFG,CONFIG_$(firstword $(1))), \
$(call XYES, $(wordlist 2, $(words $(1)), $(1)))), \
yes)
ENCDEC = $(call ALLYES, $(firstword $(1))_ENCODER $(lastword $(1))_DECODER \
$(firstword $(2))_MUXER $(lastword $(2))_DEMUXER)
ENCDEC2 = $(call ALLYES, $(firstword $(1))_ENCODER $(lastword $(1))_DECODER \
$(firstword $(2))_ENCODER $(lastword $(2))_DECODER \
$(firstword $(3))_MUXER $(lastword $(3))_DEMUXER)
DEMDEC = $(call ALLYES, $(1)_DEMUXER $(2:%=%_DECODER))
ENCMUX = $(call ALLYES, $(1:%=%_ENCODER) $(2)_MUXER)
DEMMUX = $(call ALLYES, $(1)_DEMUXER $(2)_MUXER)
FILTERDEMDEC = $(call ALLYES, $(1:%=%_FILTER) $(2)_DEMUXER $(3)_DECODER)
FILTERDEMDECMUX = $(call ALLYES, $(1:%=%_FILTER) $(2)_DEMUXER $(3)_DECODER $(4)_MUXER)
FILTERDEMDECENCMUX = $(call ALLYES, $(1:%=%_FILTER) $(2)_DEMUXER $(3)_DECODER $(4)_ENCODER $(5)_MUXER)
PARSERDEMDEC = $(call ALLYES, $(1)_PARSER $(2)_DEMUXER $(3)_DECODER)
# Allow overriding CONFIG_LARGE_TESTS via LARGE_TESTS, if set on the
# make command line.
ifeq ($(LARGE_TESTS), yes)
CONFIG_LARGE_TESTS:=yes
!CONFIG_LARGE_TESTS:=
else ifeq ($(LARGE_TESTS), no)
CONFIG_LARGE_TESTS:=
!CONFIG_LARGE_TESTS:=yes
endif
include $(SRC_PATH)/$(APITESTSDIR)/Makefile
include $(SRC_PATH)/$(DNNTESTSDIR)/Makefile
include $(SRC_PATH)/tests/fate/acodec.mak
include $(SRC_PATH)/tests/fate/vcodec.mak
include $(SRC_PATH)/tests/fate/lavf-audio.mak
include $(SRC_PATH)/tests/fate/lavf-container.mak
include $(SRC_PATH)/tests/fate/lavf-image.mak
include $(SRC_PATH)/tests/fate/lavf-image2pipe.mak
include $(SRC_PATH)/tests/fate/lavf-video.mak
include $(SRC_PATH)/tests/fate/seek.mak
include $(SRC_PATH)/tests/fate/aac.mak
include $(SRC_PATH)/tests/fate/ac3.mak
include $(SRC_PATH)/tests/fate/adpcm.mak
include $(SRC_PATH)/tests/fate/alac.mak
include $(SRC_PATH)/tests/fate/als.mak
include $(SRC_PATH)/tests/fate/amrnb.mak
include $(SRC_PATH)/tests/fate/amrwb.mak
include $(SRC_PATH)/tests/fate/api.mak
include $(SRC_PATH)/tests/fate/apng.mak
include $(SRC_PATH)/tests/fate/atrac.mak
include $(SRC_PATH)/tests/fate/audio.mak
include $(SRC_PATH)/tests/fate/bmp.mak
include $(SRC_PATH)/tests/fate/build.mak
include $(SRC_PATH)/tests/fate/canopus.mak
include $(SRC_PATH)/tests/fate/cbs.mak
include $(SRC_PATH)/tests/fate/cdxl.mak
include $(SRC_PATH)/tests/fate/checkasm.mak
include $(SRC_PATH)/tests/fate/concatdec.mak
include $(SRC_PATH)/tests/fate/cover-art.mak
include $(SRC_PATH)/tests/fate/dca.mak
include $(SRC_PATH)/tests/fate/demux.mak
include $(SRC_PATH)/tests/fate/dfa.mak
include $(SRC_PATH)/tests/fate/dnn.mak
include $(SRC_PATH)/tests/fate/dnxhd.mak
include $(SRC_PATH)/tests/fate/dpcm.mak
include $(SRC_PATH)/tests/fate/ea.mak
include $(SRC_PATH)/tests/fate/exif.mak
include $(SRC_PATH)/tests/fate/ffmpeg.mak
include $(SRC_PATH)/tests/fate/ffprobe.mak
include $(SRC_PATH)/tests/fate/fft.mak
include $(SRC_PATH)/tests/fate/fifo-muxer.mak
include $(SRC_PATH)/tests/fate/filter-audio.mak
include $(SRC_PATH)/tests/fate/filter-video.mak
include $(SRC_PATH)/tests/fate/fits.mak
include $(SRC_PATH)/tests/fate/flac.mak
include $(SRC_PATH)/tests/fate/flvenc.mak
include $(SRC_PATH)/tests/fate/gapless.mak
include $(SRC_PATH)/tests/fate/gif.mak
include $(SRC_PATH)/tests/fate/h264.mak
include $(SRC_PATH)/tests/fate/hap.mak
include $(SRC_PATH)/tests/fate/hevc.mak
include $(SRC_PATH)/tests/fate/hlsenc.mak
include $(SRC_PATH)/tests/fate/hw.mak
include $(SRC_PATH)/tests/fate/id3v2.mak
include $(SRC_PATH)/tests/fate/image.mak
include $(SRC_PATH)/tests/fate/indeo.mak
include $(SRC_PATH)/tests/fate/libavcodec.mak
include $(SRC_PATH)/tests/fate/libavdevice.mak
include $(SRC_PATH)/tests/fate/libavformat.mak
include $(SRC_PATH)/tests/fate/libavresample.mak
include $(SRC_PATH)/tests/fate/libavutil.mak
include $(SRC_PATH)/tests/fate/libswresample.mak
include $(SRC_PATH)/tests/fate/libswscale.mak
include $(SRC_PATH)/tests/fate/lossless-audio.mak
include $(SRC_PATH)/tests/fate/lossless-video.mak
include $(SRC_PATH)/tests/fate/matroska.mak
include $(SRC_PATH)/tests/fate/microsoft.mak
include $(SRC_PATH)/tests/fate/monkeysaudio.mak
include $(SRC_PATH)/tests/fate/mov.mak
include $(SRC_PATH)/tests/fate/mp3.mak
include $(SRC_PATH)/tests/fate/mpc.mak
include $(SRC_PATH)/tests/fate/mpeg4.mak
include $(SRC_PATH)/tests/fate/mpegps.mak
include $(SRC_PATH)/tests/fate/mpegts.mak
include $(SRC_PATH)/tests/fate/mxf.mak
include $(SRC_PATH)/tests/fate/opus.mak
include $(SRC_PATH)/tests/fate/pcm.mak
include $(SRC_PATH)/tests/fate/pixfmt.mak
include $(SRC_PATH)/tests/fate/pixlet.mak
include $(SRC_PATH)/tests/fate/probe.mak
include $(SRC_PATH)/tests/fate/prores.mak
include $(SRC_PATH)/tests/fate/qt.mak
include $(SRC_PATH)/tests/fate/qtrle.mak
include $(SRC_PATH)/tests/fate/real.mak
include $(SRC_PATH)/tests/fate/screen.mak
include $(SRC_PATH)/tests/fate/segment.mak
include $(SRC_PATH)/tests/fate/source.mak
include $(SRC_PATH)/tests/fate/speedhq.mak
include $(SRC_PATH)/tests/fate/subtitles.mak
include $(SRC_PATH)/tests/fate/truehd.mak
include $(SRC_PATH)/tests/fate/utvideo.mak
include $(SRC_PATH)/tests/fate/video.mak
include $(SRC_PATH)/tests/fate/voice.mak
include $(SRC_PATH)/tests/fate/vorbis.mak
include $(SRC_PATH)/tests/fate/vpx.mak
include $(SRC_PATH)/tests/fate/vqf.mak
include $(SRC_PATH)/tests/fate/wavpack.mak
include $(SRC_PATH)/tests/fate/wma.mak
include $(SRC_PATH)/tests/fate/xvid.mak
FATE_FFMPEG += $(FATE_FFMPEG-yes) $(FATE_AVCONV) $(FATE_AVCONV-yes)
FATE-$(CONFIG_FFMPEG) += $(FATE_FFMPEG)
FATE-$(CONFIG_FFPROBE) += $(FATE_FFPROBE)
FATE-$(call ALLYES, FFMPEG FFPROBE) += $(FATE_FFMPEG_FFPROBE)
FATE_SAMPLES_AVCONV += $(FATE_SAMPLES_AVCONV-yes)
FATE_SAMPLES_FFMPEG += $(FATE_SAMPLES_FFMPEG-yes)
FATE_EXTERN-$(CONFIG_FFMPEG) += $(FATE_SAMPLES_AVCONV) $(FATE_SAMPLES_FFMPEG)
FATE_EXTERN-$(CONFIG_FFPROBE) += $(FATE_SAMPLES_FFPROBE)
FATE_SAMPLES_FFMPEG_FFPROBE += $(FATE_SAMPLES_FFMPEG_FFPROBE-yes)
FATE_EXTERN-$(call ALLYES, FFMPEG FFPROBE) += $(FATE_SAMPLES_FFMPEG_FFPROBE)
FATE_EXTERN += $(FATE_EXTERN-yes) $(FATE_SAMPLES_FASTSTART)
FATE += $(FATE-yes)
RSYNC_OPTIONS-$(HAVE_RSYNC_CONTIMEOUT) += --contimeout=60
RSYNC_OPTIONS = -vrltLW --timeout=60 $(RSYNC_OPTIONS-yes)
$(FATE_FFMPEG) $(FATE_FFMPEG_FFPROBE) $(FATE_SAMPLES_AVCONV) $(FATE_SAMPLES_FFMPEG) $(FATE_SAMPLES_FFMPEG_FFPROBE): ffmpeg$(PROGSSUF)$(EXESUF)
$(FATE_FFPROBE) $(FATE_FFMPEG_FFPROBE) $(FATE_SAMPLES_FFPROBE) $(FATE_SAMPLES_FFMPEG_FFPROBE): ffprobe$(PROGSSUF)$(EXESUF)
$(FATE_SAMPLES_FASTSTART): tools/qt-faststart$(EXESUF)
$(FATE_SAMPLES_DUMP_DATA): tools/venc_data_dump$(EXESUF)
ifdef SAMPLES
FATE += $(FATE_EXTERN)
fate-rsync:
rsync $(RSYNC_OPTIONS) rsync://fate-suite.ffmpeg.org/fate-suite/ $(SAMPLES)
else
fate::
@echo "warning: only a subset of the fate tests will be run because SAMPLES is not specified"
fate-rsync:
@echo "use 'make fate-rsync SAMPLES=/path/to/samples' to sync the fate suite"
$(FATE_EXTERN):
@echo "$@ requires external samples and SAMPLES not specified"; false
endif
FATE_UTILS = base64 tiny_psnr tiny_ssim audiomatch
TOOL = ffmpeg
$(addprefix fate-, $(IGNORE_TESTS)): REPORT=ignore
fate:: $(FATE)
# Tests requiring hardware support are not included in a default fate run.
fate-hw: $(FATE_HW-yes)
FATE += $(FATE_HW-yes)
$(FATE) $(FATE_TESTS-no): export PROGSUF = $(PROGSSUF)
$(FATE) $(FATE_TESTS-no): export EXECSUF = $(EXESUF)
$(FATE) $(FATE_TESTS-no): export HOSTEXECSUF = $(HOSTEXESUF)
$(FATE) $(FATE_TESTS-no): $(FATE_UTILS:%=tests/%$(HOSTEXESUF)) | $(FATE_OUTDIRS)
@echo "TEST $(@:fate-%=%)"
$(Q)$(SRC_PATH)/tests/fate-run.sh $@ "$(TARGET_SAMPLES)" "$(TARGET_EXEC)" "$(TARGET_PATH)" '$(CMD)' '$(CMP)' '$(REF)' '$(FUZZ)' '$(THREADS)' '$(THREAD_TYPE)' '$(CPUFLAGS)' '$(CMP_SHIFT)' '$(CMP_TARGET)' '$(SIZE_TOLERANCE)' '$(CMP_UNIT)' '$(GEN)' '$(HWACCEL)' '$(REPORT)' '$(KEEP)'
fate-list:
@printf '%s\n' $(sort $(FATE))
coverage.info: TAG = LCOV
coverage.info:
$(M)lcov -q -d $(CURDIR) -b $(patsubst src%,./,$(SRC_LINK)) --capture | \
sed "s,$(CURDIR)/\./,$(CURDIR)/," > $@.in
$(M)lcov -q --remove $@.in "/usr*" > $@
$(Q)$(RM) $@.in
lcov: TAG = GENHTML
lcov: coverage.info
$(M)genhtml -q -o $(CURDIR)/lcov $<
lcov-reset: TAG = LCOV
lcov-reset:
$(M)lcov -q -d $(CURDIR) --zerocounters
$(Q)$(RM) -f coverage.info
clean:: testclean
testclean::
$(RM) -r tests/vsynth1 tests/data tools/lavfi-showfiltfmts$(PROGSSUF)$(EXESUF)
$(RM) $(CLEANSUFFIXES:%=tests/%)
$(RM) $(TESTTOOLS:%=tests/%$(HOSTEXESUF))
$(RM) tests/pixfmts.mak tests/test_copy.ffmeta
-include $(wildcard tests/*.d)
include $(SRC_PATH)/tests/checkasm/Makefile
.PHONY: fate* lcov lcov-reset
.INTERMEDIATE: coverage.info

1
externals/ffmpeg/tests/api/.gitignore vendored
View File

@@ -1 +0,0 @@
/*-test

22
externals/ffmpeg/tests/api/Makefile vendored
View File

@@ -1,22 +0,0 @@
APITESTPROGS-$(call ENCDEC, FLAC, FLAC) += api-flac
APITESTPROGS-$(call DEMDEC, H264, H264) += api-h264
APITESTPROGS-$(call DEMDEC, H264, H264) += api-h264-slice
APITESTPROGS-yes += api-seek
APITESTPROGS-yes += api-codec-param
APITESTPROGS-$(call DEMDEC, H263, H263) += api-band
APITESTPROGS-$(HAVE_THREADS) += api-threadmessage
APITESTPROGS += $(APITESTPROGS-yes)
APITESTOBJS := $(APITESTOBJS:%=$(APITESTSDIR)%) $(APITESTPROGS:%=$(APITESTSDIR)/%-test.o)
APITESTPROGS := $(APITESTPROGS:%=$(APITESTSDIR)/%-test$(EXESUF))
-include $(wildcard $(APITESTOBJS:.o=.d))
$(APITESTOBJS): | $(sort $(dir $(APITESTOBJS)))
$(APITESTOBJS) $(APITESTOBJS:.o=.i): CPPFLAGS += -DTEST
$(APITESTOBJS) $(APITESTOBJS:.o=.i): CFLAGS += -Umain
$(APITESTPROGS): %$(EXESUF): %.o $(FF_DEP_LIBS)
$(LD) $(LDFLAGS) $(LDEXEFLAGS) $(LD_O) $(filter %.o,$^) $(FF_EXTRALIBS) $(ELIBS)
testclean::
$(RM) $(addprefix $(APITESTSDIR)/,$(CLEANSUFFIXES) *-test$(EXESUF))

220
externals/ffmpeg/tests/api/api-band-test.c vendored
View File

@@ -1,220 +0,0 @@
/*
* Copyright (c) 2015 Ludmila Glinskih
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
/**
* draw_horiz_band test.
*/
#include "libavutil/adler32.h"
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libavutil/imgutils.h"
uint8_t *slice_byte_buffer;
uint8_t slice_byte_buffer_size;
int draw_horiz_band_called;
static void draw_horiz_band(AVCodecContext *ctx, const AVFrame *fr, int offset[4],
int slice_position, int type, int height)
{
int i;
const AVPixFmtDescriptor *pix_fmt_desc;
int chroma_w, chroma_h;
int shift_slice_position;
int shift_height;
draw_horiz_band_called = 1;
pix_fmt_desc = av_pix_fmt_desc_get(ctx->pix_fmt);
chroma_w = -((-ctx->width) >> pix_fmt_desc->log2_chroma_w);
chroma_h = -((-height) >> pix_fmt_desc->log2_chroma_h);
shift_slice_position = -((-slice_position) >> pix_fmt_desc->log2_chroma_h);
shift_height = -((-ctx->height) >> pix_fmt_desc->log2_chroma_h);
for (i = 0; i < height; i++) {
memcpy(slice_byte_buffer + ctx->width * slice_position + i * ctx->width,
fr->data[0] + offset[0] + i * fr->linesize[0], ctx->width);
}
for (i = 0; i < chroma_h; i++) {
memcpy(slice_byte_buffer + ctx->width * ctx->height + chroma_w * shift_slice_position + i * chroma_w,
fr->data[1] + offset[1] + i * fr->linesize[1], chroma_w);
}
for (i = 0; i < chroma_h; i++) {
memcpy(slice_byte_buffer + ctx->width * ctx->height + chroma_w * shift_height + chroma_w * shift_slice_position + i * chroma_w,
fr->data[2] + offset[2] + i * fr->linesize[2], chroma_w);
}
}
static int video_decode(const char *input_filename)
{
AVCodec *codec = NULL;
AVCodecContext *ctx= NULL;
AVCodecParameters *origin_par = NULL;
uint8_t *byte_buffer = NULL;
AVFrame *fr = NULL;
AVPacket pkt;
AVFormatContext *fmt_ctx = NULL;
int number_of_written_bytes;
int video_stream;
int got_frame = 0;
int byte_buffer_size;
int result;
int end_of_stream = 0;
draw_horiz_band_called = 0;
result = avformat_open_input(&fmt_ctx, input_filename, NULL, NULL);
if (result < 0) {
av_log(NULL, AV_LOG_ERROR, "Can't open file\n");
return result;
}
result = avformat_find_stream_info(fmt_ctx, NULL);
if (result < 0) {
av_log(NULL, AV_LOG_ERROR, "Can't get stream info\n");
return result;
}
video_stream = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
if (video_stream < 0) {
av_log(NULL, AV_LOG_ERROR, "Can't find video stream in input file\n");
return -1;
}
origin_par = fmt_ctx->streams[video_stream]->codecpar;
codec = avcodec_find_decoder(origin_par->codec_id);
if (!codec) {
av_log(NULL, AV_LOG_ERROR, "Can't find decoder\n");
return -1;
}
ctx = avcodec_alloc_context3(codec);
if (!ctx) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate decoder context\n");
return AVERROR(ENOMEM);
}
result = avcodec_parameters_to_context(ctx, origin_par);
if (result) {
av_log(NULL, AV_LOG_ERROR, "Can't copy decoder context\n");
return result;
}
ctx->draw_horiz_band = draw_horiz_band;
ctx->thread_count = 1;
result = avcodec_open2(ctx, codec, NULL);
if (result < 0) {
av_log(ctx, AV_LOG_ERROR, "Can't open decoder\n");
return result;
}
fr = av_frame_alloc();
if (!fr) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate frame\n");
return AVERROR(ENOMEM);
}
if (strcmp(codec->name, "flv") && strcmp(codec->name, "mpeg4") && strcmp(codec->name, "huffyuv")) {
av_log(NULL, AV_LOG_ERROR, "Wrong codec\n");
return -1;
}
byte_buffer_size = av_image_get_buffer_size(ctx->pix_fmt, ctx->width, ctx->height, 32);
byte_buffer = av_malloc(byte_buffer_size);
if (!byte_buffer) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate buffer\n");
return AVERROR(ENOMEM);
}
slice_byte_buffer = av_malloc(byte_buffer_size);
if (!slice_byte_buffer) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate buffer\n");
return AVERROR(ENOMEM);
}
memset(slice_byte_buffer, 0, byte_buffer_size);
slice_byte_buffer_size = byte_buffer_size;
av_init_packet(&pkt);
do {
if (!end_of_stream) {
if (av_read_frame(fmt_ctx, &pkt) < 0) {
end_of_stream = 1;
}
}
if (end_of_stream) {
pkt.data = NULL;
pkt.size = 0;
}
if (pkt.stream_index == video_stream || end_of_stream) {
got_frame = 0;
result = avcodec_decode_video2(ctx, fr, &got_frame, &pkt);
if (result < 0) {
av_log(NULL, AV_LOG_ERROR, "Error decoding frame\n");
return result;
}
if (got_frame) {
number_of_written_bytes = av_image_copy_to_buffer(byte_buffer, byte_buffer_size,
(const uint8_t* const *)fr->data, (const int*) fr->linesize,
ctx->pix_fmt, ctx->width, ctx->height, 1);
if (number_of_written_bytes < 0) {
av_log(NULL, AV_LOG_ERROR, "Can't copy image to buffer\n");
return number_of_written_bytes;
}
if (draw_horiz_band_called == 0) {
av_log(NULL, AV_LOG_ERROR, "draw_horiz_band haven't been called!\n");
return -1;
}
if (av_adler32_update(0, (const uint8_t*)byte_buffer, number_of_written_bytes) !=
av_adler32_update(0, (const uint8_t*)slice_byte_buffer, number_of_written_bytes)) {
av_log(NULL, AV_LOG_ERROR, "Decoded frames with and without draw_horiz_band are not the same!\n");
return -1;
}
}
av_packet_unref(&pkt);
av_init_packet(&pkt);
}
} while (!end_of_stream || got_frame);
av_packet_unref(&pkt);
av_frame_free(&fr);
avformat_close_input(&fmt_ctx);
avcodec_free_context(&ctx);
av_freep(&byte_buffer);
av_freep(&slice_byte_buffer);
return 0;
}
int main(int argc, char **argv)
{
if (argc < 2)
{
av_log(NULL, AV_LOG_ERROR, "Incorrect input: expected %s <name of a video file>\nNote that test works only for huffyuv, flv and mpeg4 decoders\n", argv[0]);
return 1;
}
if (video_decode(argv[1]) != 0)
return 1;
return 0;
}

256
externals/ffmpeg/tests/api/api-codec-param-test.c vendored
View File

@@ -1,256 +0,0 @@
/*
* Copyright (c) 2015 Matthieu Bouron <matthieu.bouron stupeflix.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include "libavformat/avformat.h"
#include "libavutil/pixdesc.h"
#include "libavcodec/internal.h"
#include "libavutil/avassert.h"
#include "libavutil/opt.h"
static int try_decode_video_frame(AVCodecContext *codec_ctx, AVPacket *pkt, int decode)
{
int ret = 0;
int got_frame = 0;
AVFrame *frame = NULL;
int skip_frame = codec_ctx->skip_frame;
if (!avcodec_is_open(codec_ctx)) {
const AVCodec *codec = avcodec_find_decoder(codec_ctx->codec_id);
ret = avcodec_open2(codec_ctx, codec, NULL);
if (ret < 0) {
av_log(codec_ctx, AV_LOG_ERROR, "Failed to open codec\n");
goto end;
}
}
frame = av_frame_alloc();
if (!frame) {
av_log(NULL, AV_LOG_ERROR, "Failed to allocate frame\n");
goto end;
}
if (!decode && avpriv_codec_get_cap_skip_frame_fill_param(codec_ctx->codec)) {
codec_ctx->skip_frame = AVDISCARD_ALL;
}
do {
ret = avcodec_decode_video2(codec_ctx, frame, &got_frame, pkt);
av_assert0(decode || (!decode && !got_frame));
if (ret < 0)
break;
pkt->data += ret;
pkt->size -= ret;
if (got_frame) {
break;
}
} while (pkt->size > 0);
end:
codec_ctx->skip_frame = skip_frame;
av_frame_free(&frame);
return ret;
}
static int find_video_stream_info(AVFormatContext *fmt_ctx, int decode)
{
int ret = 0;
int i, done = 0;
AVPacket pkt;
av_init_packet(&pkt);
while (!done) {
AVCodecContext *codec_ctx = NULL;
AVStream *st;
if ((ret = av_read_frame(fmt_ctx, &pkt)) < 0) {
av_log(fmt_ctx, AV_LOG_ERROR, "Failed to read frame\n");
goto end;
}
st = fmt_ctx->streams[pkt.stream_index];
codec_ctx = st->codec;
/* Writing to AVStream.codec_info_nb_frames must not be done by
* user applications. It is done here for testing purposing as
* find_video_stream_info tries to mimic avformat_find_stream_info
* which writes to this field.
* */
if (codec_ctx->codec_type != AVMEDIA_TYPE_VIDEO ||
st->codec_info_nb_frames++ > 0) {
av_packet_unref(&pkt);
continue;
}
ret = try_decode_video_frame(codec_ctx, &pkt, decode);
if (ret < 0) {
av_log(fmt_ctx, AV_LOG_ERROR, "Failed to decode video frame\n");
goto end;
}
av_packet_unref(&pkt);
/* check if all video streams have demuxed a packet */
done = 1;
for (i = 0; i < fmt_ctx->nb_streams; i++) {
st = fmt_ctx->streams[i];
codec_ctx = st->codec;
if (codec_ctx->codec_type != AVMEDIA_TYPE_VIDEO)
continue;
done &= st->codec_info_nb_frames > 0;
}
}
end:
av_packet_unref(&pkt);
/* close all codecs opened in try_decode_video_frame */
for (i = 0; i < fmt_ctx->nb_streams; i++) {
AVStream *st = fmt_ctx->streams[i];
avcodec_close(st->codec);
}
return ret < 0;
}
static void dump_video_streams(const AVFormatContext *fmt_ctx, int decode)
{
int i;
for (i = 0; i < fmt_ctx->nb_streams; i++) {
const AVOption *opt = NULL;
const AVStream *st = fmt_ctx->streams[i];
AVCodecContext *codec_ctx = st->codec;
printf("stream=%d, decode=%d\n", i, decode);
while (opt = av_opt_next(codec_ctx, opt)) {
uint8_t *str;
if (opt->type == AV_OPT_TYPE_CONST)
continue;
if (!strcmp(opt->name, "frame_number"))
continue;
if (av_opt_get(codec_ctx, opt->name, 0, &str) >= 0) {
printf(" %s=%s\n", opt->name, str);
av_free(str);
}
}
}
}
static int open_and_probe_video_streams(AVFormatContext **fmt_ctx, const char *filename, int decode)
{
int ret = 0;
ret = avformat_open_input(fmt_ctx, filename, NULL, NULL);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Failed to open input '%s'", filename);
goto end;
}
ret = find_video_stream_info(*fmt_ctx, decode);
if (ret < 0) {
goto end;
}
dump_video_streams(*fmt_ctx, decode);
end:
return ret;
}
static int check_video_streams(const AVFormatContext *fmt_ctx1, const AVFormatContext *fmt_ctx2)
{
int i;
int ret = 0;
av_assert0(fmt_ctx1->nb_streams == fmt_ctx2->nb_streams);
for (i = 0; i < fmt_ctx1->nb_streams; i++) {
const AVOption *opt = NULL;
const AVStream *st1 = fmt_ctx1->streams[i];
const AVStream *st2 = fmt_ctx2->streams[i];
AVCodecContext *codec_ctx1 = st1->codec;
AVCodecContext *codec_ctx2 = st2->codec;
if (codec_ctx1->codec_type != AVMEDIA_TYPE_VIDEO)
continue;
while (opt = av_opt_next(codec_ctx1, opt)) {
uint8_t *str1 = NULL, *str2 = NULL;
if (opt->type == AV_OPT_TYPE_CONST)
continue;
if (!strcmp(opt->name, "frame_number"))
continue;
av_assert0(av_opt_get(codec_ctx1, opt->name, 0, &str1) >= 0);
av_assert0(av_opt_get(codec_ctx2, opt->name, 0, &str2) >= 0);
if (strcmp(str1, str2)) {
av_log(NULL, AV_LOG_ERROR, "Field %s differs: %s %s", opt->name, str1, str2);
ret = AVERROR(EINVAL);
}
av_free(str1);
av_free(str2);
}
}
return ret;
}
int main(int argc, char* argv[])
{
int ret = 0;
AVFormatContext *fmt_ctx = NULL;
AVFormatContext *fmt_ctx_no_decode = NULL;
if (argc < 2) {
av_log(NULL, AV_LOG_ERROR, "Usage: %s <input>\n", argv[0]);
return -1;
}
if ((ret = open_and_probe_video_streams(&fmt_ctx_no_decode, argv[1], 0)) < 0) {
av_log(NULL, AV_LOG_ERROR, "Failed to probe '%s' without frame decoding\n", argv[1]);
goto end;
}
if ((ret = open_and_probe_video_streams(&fmt_ctx, argv[1], 1)) < 0) {
av_log(NULL, AV_LOG_ERROR, "Failed to probe '%s' with frame decoding\n", argv[1]);
goto end;
}
ret = check_video_streams(fmt_ctx, fmt_ctx_no_decode);
end:
avformat_close_input(&fmt_ctx);
avformat_close_input(&fmt_ctx_no_decode);
return ret;
}

260
externals/ffmpeg/tests/api/api-flac-test.c vendored
View File

@@ -1,260 +0,0 @@
/*
* Copyright (c) 2015 Ludmila Glinskih
* Copyright (c) 2001 Fabrice Bellard
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
/*
* FLAC codec test.
* Encodes raw data to FLAC format and decodes it back to raw. Compares raw-data
* after that.
*/
#include "libavcodec/avcodec.h"
#include "libavutil/common.h"
#include "libavutil/samplefmt.h"
#define NUMBER_OF_AUDIO_FRAMES 200
#define NAME_BUFF_SIZE 100
/* generate i-th frame of test audio */
static int generate_raw_frame(uint16_t *frame_data, int i, int sample_rate,
int channels, int frame_size)
{
int j, k;
for (j = 0; j < frame_size; j++) {
frame_data[channels * j] = 10000 * ((j / 10 * i) % 2);
for (k = 1; k < channels; k++)
frame_data[channels * j + k] = frame_data[channels * j] * (k + 1);
}
return 0;
}
static int init_encoder(AVCodec *enc, AVCodecContext **enc_ctx,
int64_t ch_layout, int sample_rate)
{
AVCodecContext *ctx;
int result;
char name_buff[NAME_BUFF_SIZE];
av_get_channel_layout_string(name_buff, NAME_BUFF_SIZE, 0, ch_layout);
av_log(NULL, AV_LOG_INFO, "channel layout: %s, sample rate: %i\n", name_buff, sample_rate);
ctx = avcodec_alloc_context3(enc);
if (!ctx) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate encoder context\n");
return AVERROR(ENOMEM);
}
ctx->sample_fmt = AV_SAMPLE_FMT_S16;
ctx->sample_rate = sample_rate;
ctx->channel_layout = ch_layout;
result = avcodec_open2(ctx, enc, NULL);
if (result < 0) {
av_log(ctx, AV_LOG_ERROR, "Can't open encoder\n");
return result;
}
*enc_ctx = ctx;
return 0;
}
static int init_decoder(AVCodec *dec, AVCodecContext **dec_ctx,
int64_t ch_layout)
{
AVCodecContext *ctx;
int result;
ctx = avcodec_alloc_context3(dec);
if (!ctx) {
av_log(NULL, AV_LOG_ERROR , "Can't allocate decoder context\n");
return AVERROR(ENOMEM);
}
ctx->request_sample_fmt = AV_SAMPLE_FMT_S16;
/* XXX: FLAC ignores it for some reason */
ctx->request_channel_layout = ch_layout;
ctx->channel_layout = ch_layout;
result = avcodec_open2(ctx, dec, NULL);
if (result < 0) {
av_log(ctx, AV_LOG_ERROR, "Can't open decoder\n");
return result;
}
*dec_ctx = ctx;
return 0;
}
static int run_test(AVCodec *enc, AVCodec *dec, AVCodecContext *enc_ctx,
AVCodecContext *dec_ctx)
{
AVPacket enc_pkt;
AVFrame *in_frame, *out_frame;
uint8_t *raw_in = NULL, *raw_out = NULL;
int in_offset = 0, out_offset = 0;
int result = 0;
int got_output = 0;
int i = 0;
int in_frame_bytes, out_frame_bytes;
in_frame = av_frame_alloc();
if (!in_frame) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate input frame\n");
return AVERROR(ENOMEM);
}
in_frame->nb_samples = enc_ctx->frame_size;
in_frame->format = enc_ctx->sample_fmt;
in_frame->channel_layout = enc_ctx->channel_layout;
if (av_frame_get_buffer(in_frame, 0) != 0) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate a buffer for input frame\n");
return AVERROR(ENOMEM);
}
out_frame = av_frame_alloc();
if (!out_frame) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate output frame\n");
return AVERROR(ENOMEM);
}
raw_in = av_malloc(in_frame->linesize[0] * NUMBER_OF_AUDIO_FRAMES);
if (!raw_in) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate memory for raw_in\n");
return AVERROR(ENOMEM);
}
raw_out = av_malloc(in_frame->linesize[0] * NUMBER_OF_AUDIO_FRAMES);
if (!raw_out) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate memory for raw_out\n");
return AVERROR(ENOMEM);
}
for (i = 0; i < NUMBER_OF_AUDIO_FRAMES; i++) {
av_init_packet(&enc_pkt);
enc_pkt.data = NULL;
enc_pkt.size = 0;
generate_raw_frame((uint16_t*)(in_frame->data[0]), i, enc_ctx->sample_rate,
enc_ctx->channels, enc_ctx->frame_size);
in_frame_bytes = in_frame->nb_samples * in_frame->channels * sizeof(uint16_t);
if (in_frame_bytes > in_frame->linesize[0]) {
av_log(NULL, AV_LOG_ERROR, "Incorrect value of input frame linesize\n");
return 1;
}
memcpy(raw_in + in_offset, in_frame->data[0], in_frame_bytes);
in_offset += in_frame_bytes;
result = avcodec_encode_audio2(enc_ctx, &enc_pkt, in_frame, &got_output);
if (result < 0) {
av_log(NULL, AV_LOG_ERROR, "Error encoding audio frame\n");
return result;
}
/* if we get an encoded packet, feed it straight to the decoder */
if (got_output) {
result = avcodec_decode_audio4(dec_ctx, out_frame, &got_output, &enc_pkt);
if (result < 0) {
av_log(NULL, AV_LOG_ERROR, "Error decoding audio packet\n");
return result;
}
if (got_output) {
if (result != enc_pkt.size) {
av_log(NULL, AV_LOG_INFO, "Decoder consumed only part of a packet, it is allowed to do so -- need to update this test\n");
return AVERROR_UNKNOWN;
}
if (in_frame->nb_samples != out_frame->nb_samples) {
av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different number of samples\n");
return AVERROR_UNKNOWN;
}
if (in_frame->channel_layout != out_frame->channel_layout) {
av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different channel layout\n");
return AVERROR_UNKNOWN;
}
if (in_frame->format != out_frame->format) {
av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different sample format\n");
return AVERROR_UNKNOWN;
}
out_frame_bytes = out_frame->nb_samples * out_frame->channels * sizeof(uint16_t);
if (out_frame_bytes > out_frame->linesize[0]) {
av_log(NULL, AV_LOG_ERROR, "Incorrect value of output frame linesize\n");
return 1;
}
memcpy(raw_out + out_offset, out_frame->data[0], out_frame_bytes);
out_offset += out_frame_bytes;
}
}
av_packet_unref(&enc_pkt);
}
if (memcmp(raw_in, raw_out, out_frame_bytes * NUMBER_OF_AUDIO_FRAMES) != 0) {
av_log(NULL, AV_LOG_ERROR, "Output differs\n");
return 1;
}
av_log(NULL, AV_LOG_INFO, "OK\n");
av_freep(&raw_in);
av_freep(&raw_out);
av_frame_free(&in_frame);
av_frame_free(&out_frame);
return 0;
}
int main(void)
{
AVCodec *enc = NULL, *dec = NULL;
AVCodecContext *enc_ctx = NULL, *dec_ctx = NULL;
uint64_t channel_layouts[] = {AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_5POINT1_BACK, AV_CH_LAYOUT_SURROUND, AV_CH_LAYOUT_STEREO_DOWNMIX};
int sample_rates[] = {8000, 44100, 48000, 192000};
int cl, sr;
enc = avcodec_find_encoder(AV_CODEC_ID_FLAC);
if (!enc) {
av_log(NULL, AV_LOG_ERROR, "Can't find encoder\n");
return 1;
}
dec = avcodec_find_decoder(AV_CODEC_ID_FLAC);
if (!dec) {
av_log(NULL, AV_LOG_ERROR, "Can't find decoder\n");
return 1;
}
for (cl = 0; cl < FF_ARRAY_ELEMS(channel_layouts); cl++) {
for (sr = 0; sr < FF_ARRAY_ELEMS(sample_rates); sr++) {
if (init_encoder(enc, &enc_ctx, channel_layouts[cl], sample_rates[sr]) != 0)
return 1;
if (init_decoder(dec, &dec_ctx, channel_layouts[cl]) != 0)
return 1;
if (run_test(enc, dec, enc_ctx, dec_ctx) != 0)
return 1;
avcodec_free_context(&enc_ctx);
avcodec_free_context(&dec_ctx);
}
}
return 0;
}

237
externals/ffmpeg/tests/api/api-h264-slice-test.c vendored
View File

@@ -1,237 +0,0 @@
/*
* Copyright (c) 2001 Fabrice Bellard
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#define MAX_SLICES 8
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#if HAVE_IO_H
#include <io.h>
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "libavcodec/avcodec.h"
#include "libavutil/pixdesc.h"
#include "libavutil/hash.h"
#include "libavutil/bswap.h"
static int header = 0;
static int decode(AVCodecContext *dec_ctx, AVFrame *frame,
AVPacket *pkt)
{
static uint64_t frame_cnt = 0;
int ret;
ret = avcodec_send_packet(dec_ctx, pkt);
if (ret < 0) {
fprintf(stderr, "Error sending a packet for decoding: %s\n", av_err2str(ret));
return ret;
}
while (ret >= 0) {
const AVPixFmtDescriptor *desc;
char sum[AV_HASH_MAX_SIZE * 2 + 1];
struct AVHashContext *hash;
ret = avcodec_receive_frame(dec_ctx, frame);
if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
return 0;
} else if (ret < 0) {
fprintf(stderr, "Error during decoding: %s\n", av_err2str(ret));
return ret;
}
if (!header) {
printf(
"#format: frame checksums\n"
"#version: 2\n"
"#hash: MD5\n"
"#tb 0: 1/30\n"
"#media_type 0: video\n"
"#codec_id 0: rawvideo\n"
"#dimensions 0: 352x288\n"
"#sar 0: 128/117\n"
"#stream#, dts, pts, duration, size, hash\n");
header = 1;
}
desc = av_pix_fmt_desc_get(dec_ctx->pix_fmt);
if ((ret = av_hash_alloc(&hash, "md5")) < 0) {
return ret;
}
av_hash_init(hash);
for (int i = 0; i < frame->height; i++)
av_hash_update(hash, &frame->data[0][i * frame->linesize[0]], frame->width);
for (int i = 0; i < frame->height >> desc->log2_chroma_h; i++)
av_hash_update(hash, &frame->data[1][i * frame->linesize[1]], frame->width >> desc->log2_chroma_w);
for (int i = 0; i < frame->height >> desc->log2_chroma_h; i++)
av_hash_update(hash, &frame->data[2][i * frame->linesize[2]], frame->width >> desc->log2_chroma_w);
av_hash_final_hex(hash, sum, av_hash_get_size(hash) * 2 + 1);
printf("0, %10"PRId64", %10"PRId64", 1, %8d, %s\n",
frame_cnt, frame_cnt,
(frame->width * frame->height + 2 * (frame->height >> desc->log2_chroma_h) * (frame->width >> desc->log2_chroma_w)), sum);
frame_cnt += 1;
av_hash_freep(&hash);
}
return 0;
}
int main(int argc, char **argv)
{
const AVCodec *codec = NULL;
AVCodecContext *c = NULL;
AVFrame *frame = NULL;
unsigned int threads;
AVPacket *pkt;
FILE *file = NULL;
char * nal = NULL;
int nals = 0, ret = 0;
char *p;
if (argc < 3) {
fprintf(stderr, "Usage: %s <threads> <input file>\n", argv[0]);
return -1;
}
if (!(threads = strtoul(argv[1], NULL, 0)))
threads = 1;
else if (threads > MAX_SLICES)
threads = MAX_SLICES;
#ifdef _WIN32
setmode(fileno(stdout), O_BINARY);
#endif
if (!(pkt = av_packet_alloc())) {
return -1;
}
nal = av_malloc(MAX_SLICES * UINT16_MAX + AV_INPUT_BUFFER_PADDING_SIZE);
if (!nal)
goto err;
p = nal;
if (!(codec = avcodec_find_decoder(AV_CODEC_ID_H264))) {
fprintf(stderr, "Codec not found\n");
ret = -1;
goto err;
}
if (!(c = avcodec_alloc_context3(codec))) {
fprintf(stderr, "Could not allocate video codec context\n");
ret = -1;
goto err;
}
c->width = 352;
c->height = 288;
c->flags2 |= AV_CODEC_FLAG2_CHUNKS;
c->thread_type = FF_THREAD_SLICE;
c->thread_count = threads;
if ((ret = avcodec_open2(c, codec, NULL)) < 0) {
fprintf(stderr, "Could not open codec\n");
goto err;
}
#if HAVE_THREADS
if (c->active_thread_type != FF_THREAD_SLICE) {
fprintf(stderr, "Couldn't activate slice threading: %d\n", c->active_thread_type);
ret = -1;
goto err;
}
#else
fprintf(stderr, "WARN: not using threads, only checking decoding slice NALUs\n");
#endif
if (!(frame = av_frame_alloc())) {
fprintf(stderr, "Could not allocate video frame\n");
ret = -1;
goto err;
}
if (!(file = fopen(argv[2], "rb"))) {
fprintf(stderr, "Couldn't open NALU file: %s\n", argv[2]);
ret = -1;
goto err;
}
while(1) {
uint16_t size = 0;
size_t ret = fread(&size, 1, sizeof(uint16_t), file);
if (ret != sizeof(uint16_t))
break;
size = av_be2ne16(size);
ret = fread(p, 1, size, file);
if (ret != size) {
perror("Couldn't read data");
goto err;
}
p += ret;
if (++nals >= threads) {
int decret = 0;
pkt->data = nal;
pkt->size = p - nal;
if ((decret = decode(c, frame, pkt)) < 0) {
goto err;
}
memset(nal, 0, MAX_SLICES * UINT16_MAX + AV_INPUT_BUFFER_PADDING_SIZE);
nals = 0;
p = nal;
}
}
if (nals) {
pkt->data = nal;
pkt->size = p - nal;
if ((ret = decode(c, frame, pkt)) < 0) {
goto err;
}
}
ret = decode(c, frame, NULL);
err:
if (nal)
av_free(nal);
if (file)
fclose(file);
av_frame_free(&frame);
avcodec_free_context(&c);
av_packet_free(&pkt);
return ret;
}

165
externals/ffmpeg/tests/api/api-h264-test.c vendored
View File

@@ -1,165 +0,0 @@
/*
* Copyright (c) 2015 Ludmila Glinskih
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
/**
* H264 codec test.
*/
#include "libavutil/adler32.h"
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libavutil/imgutils.h"
#include "libavutil/timestamp.h"
static int video_decode_example(const char *input_filename)
{
AVCodec *codec = NULL;
AVCodecContext *ctx= NULL;
AVCodecParameters *origin_par = NULL;
AVFrame *fr = NULL;
uint8_t *byte_buffer = NULL;
AVPacket pkt;
AVFormatContext *fmt_ctx = NULL;
int number_of_written_bytes;
int video_stream;
int got_frame = 0;
int byte_buffer_size;
int i = 0;
int result;
int end_of_stream = 0;
result = avformat_open_input(&fmt_ctx, input_filename, NULL, NULL);
if (result < 0) {
av_log(NULL, AV_LOG_ERROR, "Can't open file\n");
return result;
}
result = avformat_find_stream_info(fmt_ctx, NULL);
if (result < 0) {
av_log(NULL, AV_LOG_ERROR, "Can't get stream info\n");
return result;
}
video_stream = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
if (video_stream < 0) {
av_log(NULL, AV_LOG_ERROR, "Can't find video stream in input file\n");
return -1;
}
origin_par = fmt_ctx->streams[video_stream]->codecpar;
codec = avcodec_find_decoder(origin_par->codec_id);
if (!codec) {
av_log(NULL, AV_LOG_ERROR, "Can't find decoder\n");
return -1;
}
ctx = avcodec_alloc_context3(codec);
if (!ctx) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate decoder context\n");
return AVERROR(ENOMEM);
}
result = avcodec_parameters_to_context(ctx, origin_par);
if (result) {
av_log(NULL, AV_LOG_ERROR, "Can't copy decoder context\n");
return result;
}
result = avcodec_open2(ctx, codec, NULL);
if (result < 0) {
av_log(ctx, AV_LOG_ERROR, "Can't open decoder\n");
return result;
}
fr = av_frame_alloc();
if (!fr) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate frame\n");
return AVERROR(ENOMEM);
}
byte_buffer_size = av_image_get_buffer_size(ctx->pix_fmt, ctx->width, ctx->height, 16);
byte_buffer = av_malloc(byte_buffer_size);
if (!byte_buffer) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate buffer\n");
return AVERROR(ENOMEM);
}
printf("#tb %d: %d/%d\n", video_stream, fmt_ctx->streams[video_stream]->time_base.num, fmt_ctx->streams[video_stream]->time_base.den);
i = 0;
av_init_packet(&pkt);
do {
if (!end_of_stream)
if (av_read_frame(fmt_ctx, &pkt) < 0)
end_of_stream = 1;
if (end_of_stream) {
pkt.data = NULL;
pkt.size = 0;
}
if (pkt.stream_index == video_stream || end_of_stream) {
got_frame = 0;
if (pkt.pts == AV_NOPTS_VALUE)
pkt.pts = pkt.dts = i;
result = avcodec_decode_video2(ctx, fr, &got_frame, &pkt);
if (result < 0) {
av_log(NULL, AV_LOG_ERROR, "Error decoding frame\n");
return result;
}
if (got_frame) {
number_of_written_bytes = av_image_copy_to_buffer(byte_buffer, byte_buffer_size,
(const uint8_t* const *)fr->data, (const int*) fr->linesize,
ctx->pix_fmt, ctx->width, ctx->height, 1);
if (number_of_written_bytes < 0) {
av_log(NULL, AV_LOG_ERROR, "Can't copy image to buffer\n");
return number_of_written_bytes;
}
printf("%d, %s, %s, %8"PRId64", %8d, 0x%08lx\n", video_stream,
av_ts2str(fr->pts), av_ts2str(fr->pkt_dts), fr->pkt_duration,
number_of_written_bytes, av_adler32_update(0, (const uint8_t*)byte_buffer, number_of_written_bytes));
}
av_packet_unref(&pkt);
av_init_packet(&pkt);
}
i++;
} while (!end_of_stream || got_frame);
av_packet_unref(&pkt);
av_frame_free(&fr);
avformat_close_input(&fmt_ctx);
avcodec_free_context(&ctx);
av_freep(&byte_buffer);
return 0;
}
int main(int argc, char **argv)
{
if (argc < 2)
{
av_log(NULL, AV_LOG_ERROR, "Incorrect input\n");
return 1;
}
if (video_decode_example(argv[1]) != 0)
return 1;
return 0;
}

285
externals/ffmpeg/tests/api/api-seek-test.c vendored
View File

@@ -1,285 +0,0 @@
/*
* Copyright (c) 2015 Ludmila Glinskih
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
/**
* Seek test.
*/
#include "libavutil/adler32.h"
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libavutil/imgutils.h"
int64_t *pts_array;
uint32_t *crc_array;
int size_of_array;
int number_of_elements;
static int add_crc_to_array(uint32_t crc, int64_t pts)
{
if (size_of_array <= number_of_elements) {
if (size_of_array == 0)
size_of_array = 10;
size_of_array *= 2;
crc_array = av_realloc_f(crc_array, size_of_array, sizeof(uint32_t));
pts_array = av_realloc_f(pts_array, size_of_array, sizeof(int64_t));
if ((crc_array == NULL) || (pts_array == NULL)) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate array to store crcs\n");
return AVERROR(ENOMEM);
}
}
crc_array[number_of_elements] = crc;
pts_array[number_of_elements] = pts;
number_of_elements++;
return 0;
}
static int compare_crc_in_array(uint32_t crc, int64_t pts)
{
int i;
for (i = 0; i < number_of_elements; i++) {
if (pts_array[i] == pts) {
if (crc_array[i] == crc) {
printf("Comparing 0x%08"PRIx32" %"PRId64" %d is OK\n", crc, pts, i);
return 0;
}
else {
av_log(NULL, AV_LOG_ERROR, "Incorrect crc of a frame after seeking\n");
return -1;
}
}
}
av_log(NULL, AV_LOG_ERROR, "Incorrect pts of a frame after seeking\n");
return -1;
}
static int compute_crc_of_packets(AVFormatContext *fmt_ctx, int video_stream,
AVCodecContext *ctx, AVFrame *fr, uint64_t ts_start, uint64_t ts_end, int no_seeking)
{
int number_of_written_bytes;
int got_frame = 0;
int result;
int end_of_stream = 0;
int byte_buffer_size;
uint8_t *byte_buffer;
uint32_t crc;
AVPacket pkt;
byte_buffer_size = av_image_get_buffer_size(ctx->pix_fmt, ctx->width, ctx->height, 16);
byte_buffer = av_malloc(byte_buffer_size);
if (!byte_buffer) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate buffer\n");
return AVERROR(ENOMEM);
}
if (!no_seeking) {
result = av_seek_frame(fmt_ctx, video_stream, ts_start, AVSEEK_FLAG_ANY);
printf("Seeking to %"PRId64", computing crc for frames with pts < %"PRId64"\n", ts_start, ts_end);
if (result < 0) {
av_log(NULL, AV_LOG_ERROR, "Error in seeking\n");
return result;
}
avcodec_flush_buffers(ctx);
}
av_init_packet(&pkt);
do {
if (!end_of_stream)
if (av_read_frame(fmt_ctx, &pkt) < 0)
end_of_stream = 1;
if (end_of_stream) {
pkt.data = NULL;
pkt.size = 0;
}
if (pkt.stream_index == video_stream || end_of_stream) {
got_frame = 0;
if ((pkt.pts == AV_NOPTS_VALUE) && (!end_of_stream)) {
av_log(NULL, AV_LOG_ERROR, "Error: frames doesn't have pts values\n");
return -1;
}
result = avcodec_decode_video2(ctx, fr, &got_frame, &pkt);
if (result < 0) {
av_log(NULL, AV_LOG_ERROR, "Error decoding frame\n");
return result;
}
if (got_frame) {
number_of_written_bytes = av_image_copy_to_buffer(byte_buffer, byte_buffer_size,
(const uint8_t* const *)fr->data, (const int*) fr->linesize,
ctx->pix_fmt, ctx->width, ctx->height, 1);
if (number_of_written_bytes < 0) {
av_log(NULL, AV_LOG_ERROR, "Can't copy image to buffer\n");
return number_of_written_bytes;
}
if ((!no_seeking) && (fr->pts > ts_end))
break;
crc = av_adler32_update(0, (const uint8_t*)byte_buffer, number_of_written_bytes);
printf("%10"PRId64", 0x%08"PRIx32"\n", fr->pts, crc);
if (no_seeking) {
if (add_crc_to_array(crc, fr->pts) < 0)
return -1;
}
else {
if (compare_crc_in_array(crc, fr->pts) < 0)
return -1;
}
}
}
av_packet_unref(&pkt);
av_init_packet(&pkt);
} while ((!end_of_stream || got_frame) && (no_seeking || (fr->pts + fr->pkt_duration <= ts_end)));
av_packet_unref(&pkt);
av_freep(&byte_buffer);
return 0;
}
static long int read_seek_range(const char *string_with_number)
{
long int number;
char *end_of_string = NULL;
number = strtol(string_with_number, &end_of_string, 10);
if ((strlen(string_with_number) != end_of_string - string_with_number) || (number < 0)) {
av_log(NULL, AV_LOG_ERROR, "Incorrect input ranges of seeking\n");
return -1;
}
else if ((number == LONG_MAX) || (number == LONG_MIN)) {
if (errno == ERANGE) {
av_log(NULL, AV_LOG_ERROR, "Incorrect input ranges of seeking\n");
return -1;
}
}
return number;
}
static int seek_test(const char *input_filename, const char *start, const char *end)
{
AVCodec *codec = NULL;
AVCodecContext *ctx= NULL;
AVCodecParameters *origin_par = NULL;
AVFrame *fr = NULL;
AVFormatContext *fmt_ctx = NULL;
int video_stream;
int result;
int i, j;
long int start_ts, end_ts;
size_of_array = 0;
number_of_elements = 0;
crc_array = NULL;
pts_array = NULL;
result = avformat_open_input(&fmt_ctx, input_filename, NULL, NULL);
if (result < 0) {
av_log(NULL, AV_LOG_ERROR, "Can't open file\n");
return result;
}
result = avformat_find_stream_info(fmt_ctx, NULL);
if (result < 0) {
av_log(NULL, AV_LOG_ERROR, "Can't get stream info\n");
goto end;
}
start_ts = read_seek_range(start);
end_ts = read_seek_range(end);
if ((start_ts < 0) || (end_ts < 0)) {
result = -1;
goto end;
}
//TODO: add ability to work with audio format
video_stream = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
if (video_stream < 0) {
av_log(NULL, AV_LOG_ERROR, "Can't find video stream in input file\n");
result = video_stream;
goto end;
}
origin_par = fmt_ctx->streams[video_stream]->codecpar;
codec = avcodec_find_decoder(origin_par->codec_id);
if (!codec) {
av_log(NULL, AV_LOG_ERROR, "Can't find decoder\n");
result = AVERROR_DECODER_NOT_FOUND;
goto end;
}
ctx = avcodec_alloc_context3(codec);
if (!ctx) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate decoder context\n");
result = AVERROR(ENOMEM);
goto end;
}
result = avcodec_parameters_to_context(ctx, origin_par);
if (result) {
av_log(NULL, AV_LOG_ERROR, "Can't copy decoder context\n");
goto end;
}
result = avcodec_open2(ctx, codec, NULL);
if (result < 0) {
av_log(ctx, AV_LOG_ERROR, "Can't open decoder\n");
goto end;
}
fr = av_frame_alloc();
if (!fr) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate frame\n");
result = AVERROR(ENOMEM);
goto end;
}
result = compute_crc_of_packets(fmt_ctx, video_stream, ctx, fr, 0, 0, 1);
if (result != 0)
goto end;
for (i = start_ts; i < end_ts; i += 100) {
for (j = i + 100; j < end_ts; j += 100) {
result = compute_crc_of_packets(fmt_ctx, video_stream, ctx, fr, i, j, 0);
if (result != 0)
break;
}
}
end:
av_freep(&crc_array);
av_freep(&pts_array);
av_frame_free(&fr);
avformat_close_input(&fmt_ctx);
avcodec_free_context(&ctx);
return result;
}
int main(int argc, char **argv)
{
if (argc < 4) {
av_log(NULL, AV_LOG_ERROR, "Incorrect input\n");
return 1;
}
if (seek_test(argv[1], argv[2], argv[3]) != 0)
return 1;
return 0;
}

262
externals/ffmpeg/tests/api/api-threadmessage-test.c vendored
View File

@@ -1,262 +0,0 @@
/*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
/**
* Thread message API test
*/
#include "libavutil/avassert.h"
#include "libavutil/avstring.h"
#include "libavutil/frame.h"
#include "libavutil/threadmessage.h"
#include "libavutil/thread.h" // not public
struct sender_data {
int id;
pthread_t tid;
int workload;
AVThreadMessageQueue *queue;
};
/* same as sender_data but shuffled for testing purpose */
struct receiver_data {
pthread_t tid;
int workload;
int id;
AVThreadMessageQueue *queue;
};
struct message {
AVFrame *frame;
// we add some junk in the message to make sure the message size is >
// sizeof(void*)
int magic;
};
#define MAGIC 0xdeadc0de
static void free_frame(void *arg)
{
struct message *msg = arg;
av_assert0(msg->magic == MAGIC);
av_frame_free(&msg->frame);
}
static void *sender_thread(void *arg)
{
int i, ret = 0;
struct sender_data *wd = arg;
av_log(NULL, AV_LOG_INFO, "sender #%d: workload=%d\n", wd->id, wd->workload);
for (i = 0; i < wd->workload; i++) {
if (rand() % wd->workload < wd->workload / 10) {
av_log(NULL, AV_LOG_INFO, "sender #%d: flushing the queue\n", wd->id);
av_thread_message_flush(wd->queue);
} else {
char *val;
AVDictionary *meta = NULL;
struct message msg = {
.magic = MAGIC,
.frame = av_frame_alloc(),
};
if (!msg.frame) {
ret = AVERROR(ENOMEM);
break;
}
/* we add some metadata to identify the frames */
val = av_asprintf("frame %d/%d from sender %d",
i + 1, wd->workload, wd->id);
if (!val) {
av_frame_free(&msg.frame);
ret = AVERROR(ENOMEM);
break;
}
ret = av_dict_set(&meta, "sig", val, AV_DICT_DONT_STRDUP_VAL);
if (ret < 0) {
av_frame_free(&msg.frame);
break;
}
msg.frame->metadata = meta;
/* allocate a real frame in order to simulate "real" work */
msg.frame->format = AV_PIX_FMT_RGBA;
msg.frame->width = 320;
msg.frame->height = 240;
ret = av_frame_get_buffer(msg.frame, 0);
if (ret < 0) {
av_frame_free(&msg.frame);
break;
}
/* push the frame in the common queue */
av_log(NULL, AV_LOG_INFO, "sender #%d: sending my work (%d/%d frame:%p)\n",
wd->id, i + 1, wd->workload, msg.frame);
ret = av_thread_message_queue_send(wd->queue, &msg, 0);
if (ret < 0) {
av_frame_free(&msg.frame);
break;
}
}
}
av_log(NULL, AV_LOG_INFO, "sender #%d: my work is done here (%s)\n",
wd->id, av_err2str(ret));
av_thread_message_queue_set_err_recv(wd->queue, ret < 0 ? ret : AVERROR_EOF);
return NULL;
}
static void *receiver_thread(void *arg)
{
int i, ret = 0;
struct receiver_data *rd = arg;
for (i = 0; i < rd->workload; i++) {
if (rand() % rd->workload < rd->workload / 10) {
av_log(NULL, AV_LOG_INFO, "receiver #%d: flushing the queue, "
"discarding %d message(s)\n", rd->id,
av_thread_message_queue_nb_elems(rd->queue));
av_thread_message_flush(rd->queue);
} else {
struct message msg;
AVDictionary *meta;
AVDictionaryEntry *e;
ret = av_thread_message_queue_recv(rd->queue, &msg, 0);
if (ret < 0)
break;
av_assert0(msg.magic == MAGIC);
meta = msg.frame->metadata;
e = av_dict_get(meta, "sig", NULL, 0);
av_log(NULL, AV_LOG_INFO, "got \"%s\" (%p)\n", e->value, msg.frame);
av_frame_free(&msg.frame);
}
}
av_log(NULL, AV_LOG_INFO, "consumed enough (%d), stop\n", i);
av_thread_message_queue_set_err_send(rd->queue, ret < 0 ? ret : AVERROR_EOF);
return NULL;
}
static int get_workload(int minv, int maxv)
{
return maxv == minv ? maxv : rand() % (maxv - minv) + minv;
}
int main(int ac, char **av)
{
int i, ret = 0;
int max_queue_size;
int nb_senders, sender_min_load, sender_max_load;
int nb_receivers, receiver_min_load, receiver_max_load;
struct sender_data *senders;
struct receiver_data *receivers;
AVThreadMessageQueue *queue = NULL;
if (ac != 8) {
av_log(NULL, AV_LOG_ERROR, "%s <max_queue_size> "
"<nb_senders> <sender_min_send> <sender_max_send> "
"<nb_receivers> <receiver_min_recv> <receiver_max_recv>\n", av[0]);
return 1;
}
max_queue_size = atoi(av[1]);
nb_senders = atoi(av[2]);
sender_min_load = atoi(av[3]);
sender_max_load = atoi(av[4]);
nb_receivers = atoi(av[5]);
receiver_min_load = atoi(av[6]);
receiver_max_load = atoi(av[7]);
if (max_queue_size <= 0 ||
nb_senders <= 0 || sender_min_load <= 0 || sender_max_load <= 0 ||
nb_receivers <= 0 || receiver_min_load <= 0 || receiver_max_load <= 0) {
av_log(NULL, AV_LOG_ERROR, "negative values not allowed\n");
return 1;
}
av_log(NULL, AV_LOG_INFO, "qsize:%d / %d senders sending [%d-%d] / "
"%d receivers receiving [%d-%d]\n", max_queue_size,
nb_senders, sender_min_load, sender_max_load,
nb_receivers, receiver_min_load, receiver_max_load);
senders = av_mallocz_array(nb_senders, sizeof(*senders));
receivers = av_mallocz_array(nb_receivers, sizeof(*receivers));
if (!senders || !receivers) {
ret = AVERROR(ENOMEM);
goto end;
}
ret = av_thread_message_queue_alloc(&queue, max_queue_size, sizeof(struct message));
if (ret < 0)
goto end;
av_thread_message_queue_set_free_func(queue, free_frame);
#define SPAWN_THREADS(type) do { \
for (i = 0; i < nb_##type##s; i++) { \
struct type##_data *td = &type##s[i]; \
\
td->id = i; \
td->queue = queue; \
td->workload = get_workload(type##_min_load, type##_max_load); \
\
ret = pthread_create(&td->tid, NULL, type##_thread, td); \
if (ret) { \
const int err = AVERROR(ret); \
av_log(NULL, AV_LOG_ERROR, "Unable to start " AV_STRINGIFY(type) \
" thread: %s\n", av_err2str(err)); \
goto end; \
} \
} \
} while (0)
#define WAIT_THREADS(type) do { \
for (i = 0; i < nb_##type##s; i++) { \
struct type##_data *td = &type##s[i]; \
\
ret = pthread_join(td->tid, NULL); \
if (ret) { \
const int err = AVERROR(ret); \
av_log(NULL, AV_LOG_ERROR, "Unable to join " AV_STRINGIFY(type) \
" thread: %s\n", av_err2str(err)); \
goto end; \
} \
} \
} while (0)
SPAWN_THREADS(receiver);
SPAWN_THREADS(sender);
WAIT_THREADS(sender);
WAIT_THREADS(receiver);
end:
av_thread_message_queue_free(&queue);
av_freep(&senders);
av_freep(&receivers);
if (ret < 0 && ret != AVERROR_EOF) {
av_log(NULL, AV_LOG_ERROR, "Error: %s\n", av_err2str(ret));
return 1;
}
return 0;
}

248
externals/ffmpeg/tests/audiogen.c vendored
View File

@@ -1,248 +0,0 @@
/*
* Generate a synthetic stereo sound.
* NOTE: No floats are used to guarantee bitexact output.
*
* Copyright (c) 2002 Fabrice Bellard
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#define MAX_CHANNELS 12
static unsigned int myrnd(unsigned int *seed_ptr, int n)
{
unsigned int seed, val;
seed = *seed_ptr;
seed = (seed * 314159) + 1;
if (n == 256) {
val = seed >> 24;
} else {
val = seed % n;
}
*seed_ptr = seed;
return val;
}
#define FRAC_BITS 16
#define FRAC_ONE (1 << FRAC_BITS)
#define COS_TABLE_BITS 7
/* integer cosine */
static const unsigned short cos_table[(1 << COS_TABLE_BITS) + 2] = {
0x8000, 0x7ffe, 0x7ff6, 0x7fea, 0x7fd9, 0x7fc2, 0x7fa7, 0x7f87,
0x7f62, 0x7f38, 0x7f0a, 0x7ed6, 0x7e9d, 0x7e60, 0x7e1e, 0x7dd6,
0x7d8a, 0x7d3a, 0x7ce4, 0x7c89, 0x7c2a, 0x7bc6, 0x7b5d, 0x7aef,
0x7a7d, 0x7a06, 0x798a, 0x790a, 0x7885, 0x77fb, 0x776c, 0x76d9,
0x7642, 0x75a6, 0x7505, 0x7460, 0x73b6, 0x7308, 0x7255, 0x719e,
0x70e3, 0x7023, 0x6f5f, 0x6e97, 0x6dca, 0x6cf9, 0x6c24, 0x6b4b,
0x6a6e, 0x698c, 0x68a7, 0x67bd, 0x66d0, 0x65de, 0x64e9, 0x63ef,
0x62f2, 0x61f1, 0x60ec, 0x5fe4, 0x5ed7, 0x5dc8, 0x5cb4, 0x5b9d,
0x5a82, 0x5964, 0x5843, 0x571e, 0x55f6, 0x54ca, 0x539b, 0x5269,
0x5134, 0x4ffb, 0x4ec0, 0x4d81, 0x4c40, 0x4afb, 0x49b4, 0x486a,
0x471d, 0x45cd, 0x447b, 0x4326, 0x41ce, 0x4074, 0x3f17, 0x3db8,
0x3c57, 0x3af3, 0x398d, 0x3825, 0x36ba, 0x354e, 0x33df, 0x326e,
0x30fc, 0x2f87, 0x2e11, 0x2c99, 0x2b1f, 0x29a4, 0x2827, 0x26a8,
0x2528, 0x23a7, 0x2224, 0x209f, 0x1f1a, 0x1d93, 0x1c0c, 0x1a83,
0x18f9, 0x176e, 0x15e2, 0x1455, 0x12c8, 0x113a, 0x0fab, 0x0e1c,
0x0c8c, 0x0afb, 0x096b, 0x07d9, 0x0648, 0x04b6, 0x0324, 0x0192,
0x0000, 0x0000,
};
#define CSHIFT (FRAC_BITS - COS_TABLE_BITS - 2)
static int int_cos(int a)
{
int neg, v, f;
const unsigned short *p;
a = a & (FRAC_ONE - 1); /* modulo 2 * pi */
if (a >= (FRAC_ONE / 2))
a = FRAC_ONE - a;
neg = 0;
if (a > (FRAC_ONE / 4)) {
neg = -1;
a = (FRAC_ONE / 2) - a;
}
p = cos_table + (a >> CSHIFT);
/* linear interpolation */
f = a & ((1 << CSHIFT) - 1);
v = p[0] + (((p[1] - p[0]) * f + (1 << (CSHIFT - 1))) >> CSHIFT);
v = (v ^ neg) - neg;
v = v << (FRAC_BITS - 15);
return v;
}
FILE *outfile;
static void put16(int16_t v)
{
fputc( v & 0xff, outfile);
fputc((v >> 8) & 0xff, outfile);
}
static void put32(uint32_t v)
{
fputc( v & 0xff, outfile);
fputc((v >> 8) & 0xff, outfile);
fputc((v >> 16) & 0xff, outfile);
fputc((v >> 24) & 0xff, outfile);
}
#define HEADER_SIZE 46
#define FMT_SIZE 18
#define SAMPLE_SIZE 2
#define WFORMAT_PCM 0x0001
static void put_wav_header(int sample_rate, int channels, int nb_samples)
{
int block_align = SAMPLE_SIZE * channels;
int data_size = block_align * nb_samples;
fputs("RIFF", outfile);
put32(HEADER_SIZE + data_size);
fputs("WAVEfmt ", outfile);
put32(FMT_SIZE);
put16(WFORMAT_PCM);
put16(channels);
put32(sample_rate);
put32(block_align * sample_rate);
put16(block_align);
put16(SAMPLE_SIZE * 8);
put16(0);
fputs("data", outfile);
put32(data_size);
}
int main(int argc, char **argv)
{
int i, a, v, j, f, amp, ampa;
unsigned int seed = 1;
int tabf1[MAX_CHANNELS], tabf2[MAX_CHANNELS];
int taba[MAX_CHANNELS];
int sample_rate = 44100;
int nb_channels = 2;
char *ext;
if (argc < 2 || argc > 5) {
printf("usage: %s file [<sample rate> [<channels>] [<random seed>]]\n"
"generate a test raw 16 bit audio stream\n"
"If the file extension is .wav a WAVE header will be added.\n"
"default: 44100 Hz stereo\n", argv[0]);
exit(1);
}
if (argc > 2) {
sample_rate = atoi(argv[2]);
if (sample_rate <= 0) {
fprintf(stderr, "invalid sample rate: %d\n", sample_rate);
return 1;
}
}
if (argc > 3) {
nb_channels = atoi(argv[3]);
if (nb_channels < 1 || nb_channels > MAX_CHANNELS) {
fprintf(stderr, "invalid number of channels: %d\n", nb_channels);
return 1;
}
}
if (argc > 4)
seed = atoi(argv[4]);
outfile = fopen(argv[1], "wb");
if (!outfile) {
perror(argv[1]);
return 1;
}
if ((ext = strrchr(argv[1], '.')) && !strcmp(ext, ".wav"))
put_wav_header(sample_rate, nb_channels, 6 * sample_rate);
/* 1 second of single freq sine at 1000 Hz */
a = 0;
for (i = 0; i < 1 * sample_rate; i++) {
v = (int_cos(a) * 10000) >> FRAC_BITS;
for (j = 0; j < nb_channels; j++)
put16(v);
a += (1000 * FRAC_ONE) / sample_rate;
}
/* 1 second of varying frequency between 100 and 10000 Hz */
a = 0;
for (i = 0; i < 1 * sample_rate; i++) {
v = (int_cos(a) * 10000) >> FRAC_BITS;
for (j = 0; j < nb_channels; j++)
put16(v);
f = 100 + (((10000 - 100) * i) / sample_rate);
a += (f * FRAC_ONE) / sample_rate;
}
/* 0.5 second of low amplitude white noise */
for (i = 0; i < sample_rate / 2; i++) {
v = myrnd(&seed, 20000) - 10000;
for (j = 0; j < nb_channels; j++)
put16(v);
}
/* 0.5 second of high amplitude white noise */
for (i = 0; i < sample_rate / 2; i++) {
v = myrnd(&seed, 65535) - 32768;
for (j = 0; j < nb_channels; j++)
put16(v);
}
/* 1 second of unrelated ramps for each channel */
for (j = 0; j < nb_channels; j++) {
taba[j] = 0;
tabf1[j] = 100 + myrnd(&seed, 5000);
tabf2[j] = 100 + myrnd(&seed, 5000);
}
for (i = 0; i < 1 * sample_rate; i++) {
for (j = 0; j < nb_channels; j++) {
v = (int_cos(taba[j]) * 10000) >> FRAC_BITS;
put16(v);
f = tabf1[j] + (((tabf2[j] - tabf1[j]) * i) / sample_rate);
taba[j] += (f * FRAC_ONE) / sample_rate;
}
}
/* 2 seconds of 500 Hz with varying volume */
a = 0;
ampa = 0;
for (i = 0; i < 2 * sample_rate; i++) {
for (j = 0; j < nb_channels; j++) {
amp = ((FRAC_ONE + int_cos(ampa)) * 5000) >> FRAC_BITS;
if (j & 1)
amp = 10000 - amp;
v = (int_cos(a) * amp) >> FRAC_BITS;
put16(v);
a += (500 * FRAC_ONE) / sample_rate;
ampa += (2 * FRAC_ONE) / sample_rate;
}
}
fclose(outfile);
return 0;
}

114
externals/ffmpeg/tests/audiomatch.c vendored
View File

@@ -1,114 +0,0 @@
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <inttypes.h>
#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
static int64_t fsize(FILE *f) {
int64_t end, pos = ftell(f);
fseek(f, 0, SEEK_END);
end = ftell(f);
fseek(f, pos, SEEK_SET);
return end;
}
int main(int argc, char **argv) {
FILE *f[2];
int i, pos;
int siglen, datlen;
int bestpos = 0;
double bestc = 0;
double sigamp = 0;
int16_t *signal, *data;
int maxshift = 16384;
if (argc < 3) {
printf("audiomatch <testfile> <reffile>\n");
printf("WAV headers are skipped automatically.\n");
return 1;
}
f[0] = fopen(argv[1], "rb");
f[1] = fopen(argv[2], "rb");
if (!f[0] || !f[1]) {
fprintf(stderr, "Could not open input files.\n");
return 1;
}
for (i = 0; i < 2; i++) {
uint8_t p[100];
if (fread(p, 1, 12, f[i]) != 12)
return 1;
if (!memcmp(p, "RIFF", 4) &&
!memcmp(p + 8, "WAVE", 4)) {
if (fread(p, 1, 8, f[i]) != 8)
return 1;
while (memcmp(p, "data", 4)) {
int s = p[4] | p[5] << 8 | p[6] << 16 | p[7] << 24;
fseek(f[i], s, SEEK_CUR);
if (fread(p, 1, 8, f[i]) != 8)
return 1;
}
} else {
fseek(f[i], -12, SEEK_CUR);
}
}
datlen = fsize(f[0]) - ftell(f[0]);
siglen = fsize(f[1]) - ftell(f[1]);
data = malloc(datlen * sizeof(*data));
signal = malloc(siglen * sizeof(*signal));
if (fread(data , 1, datlen, f[0]) != datlen)
return 1;
if (fread(signal, 1, siglen, f[1]) != siglen)
return 1;
datlen /= 2;
siglen /= 2;
for (i = 0; i < siglen; i++) {
signal[i] = ((uint8_t*)(signal + i))[0] + 256*((uint8_t*)(signal + i))[1];
sigamp += signal[i] * signal[i];
}
for (i = 0; i < datlen; i++)
data[i] = ((uint8_t*)(data + i))[0] + 256*((uint8_t*)(data + i))[1];
for (pos = 0; pos < maxshift; pos = pos < 0 ? -pos: -pos-1) {
int64_t c = 0;
int testlen = FFMIN(siglen, datlen-pos);
for (i = FFMAX(0, -pos); i < testlen; i++) {
int j = pos + i;
c += signal[i] * data[j];
}
if (fabs(c) > sigamp * 0.94)
maxshift = FFMIN(maxshift, fabs(pos)+32);
if (fabs(c) > fabs(bestc)) {
bestc = c;
bestpos = pos;
}
}
printf("presig: %d postsig:%d c:%7.4f lenerr:%d\n", bestpos, datlen - siglen - bestpos, bestc / sigamp, datlen - siglen);
return 0;
}

54
externals/ffmpeg/tests/base64.c vendored
View File

@@ -1,54 +0,0 @@
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/*
* Based on libavutil/base64.c
*/
#include <stdio.h>
int main(void)
{
static const char b64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
unsigned i_bits = 0;
int i_shift = 0;
int out_len = 0;
int in;
#define putb64() \
do { \
putchar(b64[(i_bits << 6 >> i_shift) & 0x3f]); \
out_len++; \
i_shift -= 6; \
} while (0)
while ((in = getchar()) != EOF) {
i_bits = (i_bits << 8) + in;
i_shift += 8;
while (i_shift > 6)
putb64();
}
while (i_shift > 0)
putb64();
while (out_len++ & 3)
putchar('=');
putchar('\n');
return 0;
}

1
externals/ffmpeg/tests/checkasm/.gitignore vendored
View File

@@ -1 +0,0 @@
/checkasm

85
externals/ffmpeg/tests/checkasm/Makefile vendored
View File

@@ -1,85 +0,0 @@
# libavcodec tests
# subsystems
AVCODECOBJS-$(CONFIG_AUDIODSP) += audiodsp.o
AVCODECOBJS-$(CONFIG_BLOCKDSP) += blockdsp.o
AVCODECOBJS-$(CONFIG_BSWAPDSP) += bswapdsp.o
AVCODECOBJS-$(CONFIG_FLACDSP) += flacdsp.o
AVCODECOBJS-$(CONFIG_FMTCONVERT) += fmtconvert.o
AVCODECOBJS-$(CONFIG_G722DSP) += g722dsp.o
AVCODECOBJS-$(CONFIG_H264DSP) += h264dsp.o
AVCODECOBJS-$(CONFIG_H264PRED) += h264pred.o
AVCODECOBJS-$(CONFIG_H264QPEL) += h264qpel.o
AVCODECOBJS-$(CONFIG_LLVIDDSP) += llviddsp.o
AVCODECOBJS-$(CONFIG_LLVIDENCDSP) += llviddspenc.o
AVCODECOBJS-$(CONFIG_VP8DSP) += vp8dsp.o
AVCODECOBJS-$(CONFIG_VIDEODSP) += videodsp.o
# decoders/encoders
AVCODECOBJS-$(CONFIG_AAC_DECODER) += aacpsdsp.o \
sbrdsp.o
AVCODECOBJS-$(CONFIG_ALAC_DECODER) += alacdsp.o
AVCODECOBJS-$(CONFIG_DCA_DECODER) += synth_filter.o
AVCODECOBJS-$(CONFIG_EXR_DECODER) += exrdsp.o
AVCODECOBJS-$(CONFIG_HUFFYUV_DECODER) += huffyuvdsp.o
AVCODECOBJS-$(CONFIG_JPEG2000_DECODER) += jpeg2000dsp.o
AVCODECOBJS-$(CONFIG_OPUS_DECODER) += opusdsp.o
AVCODECOBJS-$(CONFIG_PIXBLOCKDSP) += pixblockdsp.o
AVCODECOBJS-$(CONFIG_HEVC_DECODER) += hevc_add_res.o hevc_idct.o hevc_sao.o
AVCODECOBJS-$(CONFIG_UTVIDEO_DECODER) += utvideodsp.o
AVCODECOBJS-$(CONFIG_V210_DECODER) += v210dec.o
AVCODECOBJS-$(CONFIG_V210_ENCODER) += v210enc.o
AVCODECOBJS-$(CONFIG_VP9_DECODER) += vp9dsp.o
CHECKASMOBJS-$(CONFIG_AVCODEC) += $(AVCODECOBJS-yes)
# libavfilter tests
AVFILTEROBJS-$(CONFIG_AFIR_FILTER) += af_afir.o
AVFILTEROBJS-$(CONFIG_BLEND_FILTER) += vf_blend.o
AVFILTEROBJS-$(CONFIG_COLORSPACE_FILTER) += vf_colorspace.o
AVFILTEROBJS-$(CONFIG_EQ_FILTER) += vf_eq.o
AVFILTEROBJS-$(CONFIG_GBLUR_FILTER) += vf_gblur.o
AVFILTEROBJS-$(CONFIG_HFLIP_FILTER) += vf_hflip.o
AVFILTEROBJS-$(CONFIG_THRESHOLD_FILTER) += vf_threshold.o
AVFILTEROBJS-$(CONFIG_NLMEANS_FILTER) += vf_nlmeans.o
CHECKASMOBJS-$(CONFIG_AVFILTER) += $(AVFILTEROBJS-yes)
# swscale tests
SWSCALEOBJS += sw_rgb.o sw_scale.o
CHECKASMOBJS-$(CONFIG_SWSCALE) += $(SWSCALEOBJS)
# libavutil tests
AVUTILOBJS += fixed_dsp.o
AVUTILOBJS += float_dsp.o
CHECKASMOBJS-$(CONFIG_AVUTIL) += $(AVUTILOBJS)
CHECKASMOBJS-$(ARCH_AARCH64) += aarch64/checkasm.o
CHECKASMOBJS-$(HAVE_ARMV5TE_EXTERNAL) += arm/checkasm.o
CHECKASMOBJS-$(HAVE_X86ASM) += x86/checkasm.o
CHECKASMOBJS += $(CHECKASMOBJS-yes) checkasm.o
CHECKASMOBJS := $(sort $(CHECKASMOBJS:%=tests/checkasm/%))
-include $(CHECKASMOBJS:.o=.d)
CHECKASMDIRS := $(sort $(dir $(CHECKASMOBJS)))
$(CHECKASMOBJS): | $(CHECKASMDIRS)
OUTDIRS += $(CHECKASMDIRS)
tests/checkasm/checkasm.o: CFLAGS += -Umain
CHECKASM := tests/checkasm/checkasm$(EXESUF)
$(CHECKASM): $(CHECKASMOBJS) $(FF_STATIC_DEP_LIBS)
$(LD) $(LDFLAGS) $(LDEXEFLAGS) $(LD_O) $(CHECKASMOBJS) $(FF_STATIC_DEP_LIBS) $(EXTRALIBS-avcodec) $(EXTRALIBS-avfilter) $(EXTRALIBS-avformat) $(EXTRALIBS-avutil) $(EXTRALIBS-swresample) $(EXTRALIBS)
checkasm: $(CHECKASM)
testclean:: checkasmclean
checkasmclean:
$(RM) $(CHECKASM) $(CLEANSUFFIXES:%=tests/checkasm/%) $(CLEANSUFFIXES:%=tests/checkasm/$(ARCH)/%)
.PHONY: checkasm

261
externals/ffmpeg/tests/checkasm/aacpsdsp.c vendored
View File

@@ -1,261 +0,0 @@
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "libavcodec/aacpsdsp.h"
#include "libavutil/intfloat.h"
#include "checkasm.h"
#define N 32
#define STRIDE 128
#define BUF_SIZE (N * STRIDE)
#define randomize(buf, len) do { \
int i; \
for (i = 0; i < len; i++) { \
const INTFLOAT f = (INTFLOAT)rnd() / UINT_MAX; \
(buf)[i] = f; \
} \
} while (0)
#define EPS 0.005
static void clear_less_significant_bits(INTFLOAT *buf, int len, int bits)
{
int i;
for (i = 0; i < len; i++) {
union av_intfloat32 u = { .f = buf[i] };
u.i &= (0xffffffff << bits);
buf[i] = u.f;
}
}
static void test_add_squares(void)
{
LOCAL_ALIGNED_16(INTFLOAT, dst0, [BUF_SIZE]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [BUF_SIZE]);
LOCAL_ALIGNED_16(INTFLOAT, src, [BUF_SIZE], [2]);
declare_func(void, INTFLOAT *dst,
const INTFLOAT (*src)[2], int n);
randomize((INTFLOAT *)src, BUF_SIZE * 2);
randomize(dst0, BUF_SIZE);
memcpy(dst1, dst0, BUF_SIZE * sizeof(INTFLOAT));
call_ref(dst0, src, BUF_SIZE);
call_new(dst1, src, BUF_SIZE);
if (!float_near_abs_eps_array(dst0, dst1, EPS, BUF_SIZE))
fail();
bench_new(dst1, src, BUF_SIZE);
}
static void test_mul_pair_single(void)
{
LOCAL_ALIGNED_16(INTFLOAT, dst0, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, src0, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, src1, [BUF_SIZE]);
declare_func(void, INTFLOAT (*dst)[2],
INTFLOAT (*src0)[2], INTFLOAT *src1, int n);
randomize((INTFLOAT *)src0, BUF_SIZE * 2);
randomize(src1, BUF_SIZE);
call_ref(dst0, src0, src1, BUF_SIZE);
call_new(dst1, src0, src1, BUF_SIZE);
if (!float_near_abs_eps_array((float *)dst0, (float *)dst1, EPS, BUF_SIZE * 2))
fail();
bench_new(dst1, src0, src1, BUF_SIZE);
}
static void test_hybrid_analysis(void)
{
LOCAL_ALIGNED_16(INTFLOAT, dst0, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, in, [13], [2]);
LOCAL_ALIGNED_16(INTFLOAT, filter, [N], [8][2]);
declare_func(void, INTFLOAT (*out)[2], INTFLOAT (*in)[2],
const INTFLOAT (*filter)[8][2],
ptrdiff_t stride, int n);
randomize((INTFLOAT *)in, 13 * 2);
randomize((INTFLOAT *)filter, N * 8 * 2);
randomize((INTFLOAT *)dst0, BUF_SIZE * 2);
memcpy(dst1, dst0, BUF_SIZE * 2 * sizeof(INTFLOAT));
call_ref(dst0, in, filter, STRIDE, N);
call_new(dst1, in, filter, STRIDE, N);
if (!float_near_abs_eps_array((float *)dst0, (float *)dst1, EPS, BUF_SIZE * 2))
fail();
bench_new(dst1, in, filter, STRIDE, N);
}
static void test_hybrid_analysis_ileave(void)
{
LOCAL_ALIGNED_16(INTFLOAT, in, [2], [38][64]);
LOCAL_ALIGNED_16(INTFLOAT, out0, [91], [32][2]);
LOCAL_ALIGNED_16(INTFLOAT, out1, [91], [32][2]);
declare_func(void, INTFLOAT (*out)[32][2], INTFLOAT L[2][38][64],
int i, int len);
randomize((INTFLOAT *)out0, 91 * 32 * 2);
randomize((INTFLOAT *)in, 2 * 38 * 64);
memcpy(out1, out0, 91 * 32 * 2 * sizeof(INTFLOAT));
/* len is hardcoded to 32 as that's the only value used in
libavcodec. asm functions are likely to be optimized
hardcoding this value in their loops and could fail with
anything else.
i is hardcoded to the two values currently used by the
aac decoder because the arm neon implementation is
micro-optimized for them and will fail for almost every
other value. */
call_ref(out0, in, 3, 32);
call_new(out1, in, 3, 32);
/* the function just moves data around, so memcmp is enough */
if (memcmp(out0, out1, 91 * 32 * 2 * sizeof(INTFLOAT)))
fail();
call_ref(out0, in, 5, 32);
call_new(out1, in, 5, 32);
if (memcmp(out0, out1, 91 * 32 * 2 * sizeof(INTFLOAT)))
fail();
bench_new(out1, in, 3, 32);
}
static void test_hybrid_synthesis_deint(void)
{
LOCAL_ALIGNED_16(INTFLOAT, out0, [2], [38][64]);
LOCAL_ALIGNED_16(INTFLOAT, out1, [2], [38][64]);
LOCAL_ALIGNED_16(INTFLOAT, in, [91], [32][2]);
declare_func(void, INTFLOAT out[2][38][64], INTFLOAT (*in)[32][2],
int i, int len);
randomize((INTFLOAT *)in, 91 * 32 * 2);
randomize((INTFLOAT *)out0, 2 * 38 * 64);
memcpy(out1, out0, 2 * 38 * 64 * sizeof(INTFLOAT));
/* len is hardcoded to 32 as that's the only value used in
libavcodec. asm functions are likely to be optimized
hardcoding this value in their loops and could fail with
anything else.
i is hardcoded to the two values currently used by the
aac decoder because the arm neon implementation is
micro-optimized for them and will fail for almost every
other value. */
call_ref(out0, in, 3, 32);
call_new(out1, in, 3, 32);
/* the function just moves data around, so memcmp is enough */
if (memcmp(out0, out1, 2 * 38 * 64 * sizeof(INTFLOAT)))
fail();
call_ref(out0, in, 5, 32);
call_new(out1, in, 5, 32);
if (memcmp(out0, out1, 2 * 38 * 64 * sizeof(INTFLOAT)))
fail();
bench_new(out1, in, 3, 32);
}
static void test_stereo_interpolate(PSDSPContext *psdsp)
{
int i;
LOCAL_ALIGNED_16(INTFLOAT, l, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, r, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, l0, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, r0, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, l1, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, r1, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, h, [2], [4]);
LOCAL_ALIGNED_16(INTFLOAT, h_step, [2], [4]);
declare_func(void, INTFLOAT (*l)[2], INTFLOAT (*r)[2],
INTFLOAT h[2][4], INTFLOAT h_step[2][4], int len);
randomize((INTFLOAT *)l, BUF_SIZE * 2);
randomize((INTFLOAT *)r, BUF_SIZE * 2);
for (i = 0; i < 2; i++) {
if (check_func(psdsp->stereo_interpolate[i], "ps_stereo_interpolate%s", i ? "_ipdopd" : "")) {
memcpy(l0, l, BUF_SIZE * 2 * sizeof(INTFLOAT));
memcpy(l1, l, BUF_SIZE * 2 * sizeof(INTFLOAT));
memcpy(r0, r, BUF_SIZE * 2 * sizeof(INTFLOAT));
memcpy(r1, r, BUF_SIZE * 2 * sizeof(INTFLOAT));
randomize((INTFLOAT *)h, 2 * 4);
randomize((INTFLOAT *)h_step, 2 * 4);
// Clear the least significant 14 bits of h_step, to avoid
// divergence when accumulating h_step BUF_SIZE times into
// a float variable which may or may not have extra intermediate
// precision. Therefore clear roughly log2(BUF_SIZE) less
// significant bits, to get the same result regardless of any
// extra precision in the accumulator.
clear_less_significant_bits((INTFLOAT *)h_step, 2 * 4, 14);
call_ref(l0, r0, h, h_step, BUF_SIZE);
call_new(l1, r1, h, h_step, BUF_SIZE);
if (!float_near_abs_eps_array((float *)l0, (float *)l1, EPS, BUF_SIZE * 2) ||
!float_near_abs_eps_array((float *)r0, (float *)r1, EPS, BUF_SIZE * 2))
fail();
memcpy(l1, l, BUF_SIZE * 2 * sizeof(INTFLOAT));
memcpy(r1, r, BUF_SIZE * 2 * sizeof(INTFLOAT));
bench_new(l1, r1, h, h_step, BUF_SIZE);
}
}
}
void checkasm_check_aacpsdsp(void)
{
PSDSPContext psdsp;
ff_psdsp_init(&psdsp);
if (check_func(psdsp.add_squares, "ps_add_squares"))
test_add_squares();
report("add_squares");
if (check_func(psdsp.mul_pair_single, "ps_mul_pair_single"))
test_mul_pair_single();
report("mul_pair_single");
if (check_func(psdsp.hybrid_analysis, "ps_hybrid_analysis"))
test_hybrid_analysis();
report("hybrid_analysis");
if (check_func(psdsp.hybrid_analysis_ileave, "ps_hybrid_analysis_ileave"))
test_hybrid_analysis_ileave();
report("hybrid_analysis_ileave");
if (check_func(psdsp.hybrid_synthesis_deint, "ps_hybrid_synthesis_deint"))
test_hybrid_synthesis_deint();
report("hybrid_synthesis_deint");
test_stereo_interpolate(&psdsp);
report("stereo_interpolate");
}

198
externals/ffmpeg/tests/checkasm/aarch64/checkasm.S vendored
View File

@@ -1,198 +0,0 @@
/****************************************************************************
* Assembly testing and benchmarking tool
* Copyright (c) 2015 Martin Storsjo
* Copyright (c) 2015 Janne Grunau
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
*****************************************************************************/
#include "libavutil/aarch64/asm.S"
const register_init, align=4
.quad 0x21f86d66c8ca00ce
.quad 0x75b6ba21077c48ad
.quad 0xed56bb2dcb3c7736
.quad 0x8bda43d3fd1a7e06
.quad 0xb64a9c9e5d318408
.quad 0xdf9a54b303f1d3a3
.quad 0x4a75479abd64e097
.quad 0x249214109d5d1c88
.quad 0x1a1b2550a612b48c
.quad 0x79445c159ce79064
.quad 0x2eed899d5a28ddcd
.quad 0x86b2536fcd8cf636
.quad 0xb0856806085e7943
.quad 0x3f2bf84fc0fcca4e
.quad 0xacbd382dcf5b8de2
.quad 0xd229e1f5b281303f
.quad 0x71aeaff20b095fd9
.quad 0xab63e2e11fa38ed9
endconst
const error_message_register
.asciz "failed to preserve register"
error_message_stack:
.asciz "stack clobbered"
endconst
// max number of args used by any asm function.
#define MAX_ARGS 15
#define CLOBBER_STACK ((8*MAX_ARGS + 15) & ~15)
function checkasm_stack_clobber, export=1
mov x3, sp
mov x2, #CLOBBER_STACK
1:
stp x0, x1, [sp, #-16]!
subs x2, x2, #16
b.gt 1b
mov sp, x3
ret
endfunc
// + 16 for stack canary reference
#define ARG_STACK ((8*(MAX_ARGS - 8) + 15) & ~15 + 16)
function checkasm_checked_call, export=1
stp x29, x30, [sp, #-16]!
mov x29, sp
stp x19, x20, [sp, #-16]!
stp x21, x22, [sp, #-16]!
stp x23, x24, [sp, #-16]!
stp x25, x26, [sp, #-16]!
stp x27, x28, [sp, #-16]!
stp d8, d9, [sp, #-16]!
stp d10, d11, [sp, #-16]!
stp d12, d13, [sp, #-16]!
stp d14, d15, [sp, #-16]!
movrel x9, register_init
ldp d8, d9, [x9], #16
ldp d10, d11, [x9], #16
ldp d12, d13, [x9], #16
ldp d14, d15, [x9], #16
ldp x19, x20, [x9], #16
ldp x21, x22, [x9], #16
ldp x23, x24, [x9], #16
ldp x25, x26, [x9], #16
ldp x27, x28, [x9], #16
sub sp, sp, #ARG_STACK
.equ pos, 0
.rept MAX_ARGS-8
// Skip the first 8 args, that are loaded into registers
ldr x9, [x29, #16 + 8*8 + pos]
str x9, [sp, #pos]
.equ pos, pos + 8
.endr
// Fill x8-x17 with garbage. This doesn't have to be preserved,
// but avoids relying on them having any particular value.
movrel x9, register_init
ldp x10, x11, [x9], #32
ldp x12, x13, [x9], #32
ldp x14, x15, [x9], #32
ldp x16, x17, [x9], #32
ldp x8, x9, [x9]
// For stack overflows, the callee is free to overwrite the parameters
// that were passed on the stack (if any), so we can only check after
// that point. First figure out how many parameters the function
// really took on the stack:
ldr w2, [x29, #16 + 8*8 + (MAX_ARGS-8)*8]
// Load the first non-parameter value from the stack, that should be
// left untouched by the function. Store a copy of it inverted, so that
// e.g. overwriting everything with zero would be noticed.
ldr x2, [sp, x2, lsl #3]
mvn x2, x2
str x2, [sp, #ARG_STACK-8]
// Load the in-register arguments
mov x12, x0
ldp x0, x1, [x29, #16]
ldp x2, x3, [x29, #32]
ldp x4, x5, [x29, #48]
ldp x6, x7, [x29, #64]
// Call the target function
blr x12
// Load the number of stack parameters, stack canary and its reference
ldr w2, [x29, #16 + 8*8 + (MAX_ARGS-8)*8]
ldr x2, [sp, x2, lsl #3]
ldr x3, [sp, #ARG_STACK-8]
add sp, sp, #ARG_STACK
stp x0, x1, [sp, #-16]!
mvn x3, x3
cmp x2, x3
b.ne 2f
movrel x9, register_init
movi v3.8h, #0
.macro check_reg_neon reg1, reg2
ldr q1, [x9], #16
uzp1 v2.2d, v\reg1\().2d, v\reg2\().2d
eor v1.16b, v1.16b, v2.16b
orr v3.16b, v3.16b, v1.16b
.endm
check_reg_neon 8, 9
check_reg_neon 10, 11
check_reg_neon 12, 13
check_reg_neon 14, 15
uqxtn v3.8b, v3.8h
umov x3, v3.d[0]
.macro check_reg reg1, reg2
ldp x0, x1, [x9], #16
eor x0, x0, \reg1
eor x1, x1, \reg2
orr x3, x3, x0
orr x3, x3, x1
.endm
check_reg x19, x20
check_reg x21, x22
check_reg x23, x24
check_reg x25, x26
check_reg x27, x28
cbz x3, 0f
movrel x0, error_message_register
b 1f
2:
movrel x0, error_message_stack
1:
bl X(checkasm_fail_func)
0:
ldp x0, x1, [sp], #16
ldp d14, d15, [sp], #16
ldp d12, d13, [sp], #16
ldp d10, d11, [sp], #16
ldp d8, d9, [sp], #16
ldp x27, x28, [sp], #16
ldp x25, x26, [sp], #16
ldp x23, x24, [sp], #16
ldp x21, x22, [sp], #16
ldp x19, x20, [sp], #16
ldp x29, x30, [sp], #16
ret
endfunc

95
externals/ffmpeg/tests/checkasm/af_afir.c vendored
View File

@@ -1,95 +0,0 @@
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include <float.h>
#include <stdint.h>
#include "libavfilter/af_afir.h"
#include "libavutil/internal.h"
#include "checkasm.h"
#define LEN 256
#define randomize_buffer(buf) \
do { \
int i; \
double bmg[2], stddev = 10.0, mean = 0.0; \
\
for (i = 0; i < LEN*2+8; i += 2) { \
av_bmg_get(&checkasm_lfg, bmg); \
buf[i] = bmg[0] * stddev + mean; \
buf[i + 1] = bmg[1] * stddev + mean; \
} \
} while(0);
static void test_fcmul_add(const float *src0, const float *src1, const float *src2)
{
LOCAL_ALIGNED_32(float, cdst, [LEN*2+8]);
LOCAL_ALIGNED_32(float, odst, [LEN*2+8]);
int i;
declare_func(void, float *sum, const float *t, const float *c,
ptrdiff_t len);
memcpy(cdst, src0, (LEN*2+8) * sizeof(float));
memcpy(odst, src0, (LEN*2+8) * sizeof(float));
call_ref(cdst, src1, src2, LEN);
call_new(odst, src1, src2, LEN);
for (i = 0; i <= LEN*2; i++) {
int idx = i & ~1;
float cre = src2[idx];
float cim = src2[idx + 1];
float tre = src1[idx];
float tim = src1[idx + 1];
double t = fabs(src0[i]) +
fabs(tre) + fabs(tim) + fabs(cre) + fabs(cim) +
fabs(tre * cre) + fabs(tim * cim) +
fabs(tre * cim) + fabs(tim * cre) +
fabs(tre * cre - tim * cim) +
fabs(tre * cim + tim * cre) +
fabs(cdst[i]) + 1.0;
if (!float_near_abs_eps(cdst[i], odst[i], t * 2 * FLT_EPSILON)) {
fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
i, cdst[i], odst[i], cdst[i] - odst[i]);
fail();
break;
}
}
memcpy(odst, src0, (LEN*2+8) * sizeof(float));
bench_new(odst, src1, src2, LEN);
}
void checkasm_check_afir(void)
{
LOCAL_ALIGNED_32(float, src0, [LEN*2+8]);
LOCAL_ALIGNED_32(float, src1, [LEN*2+8]);
LOCAL_ALIGNED_32(float, src2, [LEN*2+8]);
AudioFIRDSPContext fir = { 0 };
ff_afir_init(&fir);
randomize_buffer(src0);
randomize_buffer(src1);
randomize_buffer(src2);
if (check_func(fir.fcmul_add, "fcmul_add"))
test_fcmul_add(src0, src1, src2);
report("fcmul_add");
}

119
externals/ffmpeg/tests/checkasm/alacdsp.c vendored
View File

@@ -1,119 +0,0 @@
/*
* Copyright (c) 2015 James Almer
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavcodec/alacdsp.h"
#include "libavcodec/mathops.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#define BUF_SIZE 256
#define MAX_CHANNELS 2
#define randomize_buffers() \
do { \
int i; \
for (i = 0; i < BUF_SIZE*MAX_CHANNELS; i++) { \
int32_t r = sign_extend(rnd(), 24); \
ref_buf[i] = r; \
new_buf[i] = r; \
} \
} while (0)
static void check_decorrelate_stereo(void)
{
LOCAL_ALIGNED_16(int32_t, ref_buf, [BUF_SIZE*MAX_CHANNELS]);
LOCAL_ALIGNED_16(int32_t, new_buf, [BUF_SIZE*MAX_CHANNELS]);
int32_t *ref[2] = { &ref_buf[BUF_SIZE*0], &ref_buf[BUF_SIZE*1] };
int32_t *new[2] = { &new_buf[BUF_SIZE*0], &new_buf[BUF_SIZE*1] };
ALACDSPContext c;
ff_alacdsp_init(&c);
if (check_func(c.decorrelate_stereo, "alac_decorrelate_stereo")) {
int len = (rnd() & 0xFF) + 1;
int shift = rnd() & 0x1F;
int weight = rnd() & 0xFF;
declare_func(void, int32_t *buf[2], int len, int shift, int weight);
randomize_buffers();
call_ref(ref, len, shift, weight);
call_new(new, len, shift, weight);
if (memcmp(ref[0], new[0], len * sizeof(int32_t)) ||
memcmp(ref[1], new[1], len * sizeof(int32_t)))
fail();
bench_new(new, BUF_SIZE, shift, weight);
}
report("decorrelate_stereo");
}
#undef randomize_buffers
#define randomize_buffers() \
do { \
int i, j; \
for (i = 0; i < BUF_SIZE; i++) { \
for (j = 0; j < ch; j++) { \
int32_t r = sign_extend(rnd(), 24); \
ref[j][i] = r; \
new[j][i] = r; \
r = rnd() & 0xFF; \
ref_ebb[j][i] = r; \
new_ebb[j][i] = r; \
} \
} \
} while (0)
static void check_append_extra_bits(void)
{
LOCAL_ALIGNED_16(int32_t, ref_buf, [BUF_SIZE*MAX_CHANNELS*2]);
LOCAL_ALIGNED_16(int32_t, new_buf, [BUF_SIZE*MAX_CHANNELS*2]);
int32_t *ref[2] = { &ref_buf[BUF_SIZE*0], &ref_buf[BUF_SIZE*1] };
int32_t *new[2] = { &new_buf[BUF_SIZE*0], &new_buf[BUF_SIZE*1] };
int32_t *ref_ebb[2] = { &ref_buf[BUF_SIZE*2], &ref_buf[BUF_SIZE*3] };
int32_t *new_ebb[2] = { &new_buf[BUF_SIZE*2], &new_buf[BUF_SIZE*3] };
ALACDSPContext c;
static const char * const channels[2] = { "mono", "stereo" };
int ch;
ff_alacdsp_init(&c);
for (ch = 1; ch <= 2; ch++) {
if (check_func(c.append_extra_bits[ch-1], "alac_append_extra_bits_%s", channels[ch-1])) {
int len = (rnd() & 0xFF) + 1;
declare_func(void, int32_t *buf[2], int32_t *ebb[2], int ebits, int ch, int len);
randomize_buffers();
call_ref(ref, ref_ebb, 8, ch, len);
call_new(new, new_ebb, 8, ch, len);
if ( memcmp(ref[0], new[0], len * sizeof(int32_t)) ||
(ch == 2 && memcmp(ref[1], new[1], len * sizeof(int32_t))))
fail();
bench_new(new, new_ebb, 8, ch, BUF_SIZE);
}
}
report("append_extra_bits");
}
void checkasm_check_alacdsp(void)
{
check_decorrelate_stereo();
check_append_extra_bits();
}

197
externals/ffmpeg/tests/checkasm/arm/checkasm.S vendored
View File

@@ -1,197 +0,0 @@
/****************************************************************************
* Assembly testing and benchmarking tool
* Copyright (c) 2015 Martin Storsjo
* Copyright (c) 2015 Janne Grunau
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
*****************************************************************************/
#include "libavutil/arm/asm.S"
/* override fpu so that NEON instructions are rejected */
#if HAVE_VFP
FPU .fpu vfp
ELF .eabi_attribute 10, 0 @ suppress Tag_FP_arch
#endif
const register_init, align=3
.quad 0x21f86d66c8ca00ce
.quad 0x75b6ba21077c48ad
.quad 0xed56bb2dcb3c7736
.quad 0x8bda43d3fd1a7e06
.quad 0xb64a9c9e5d318408
.quad 0xdf9a54b303f1d3a3
.quad 0x4a75479abd64e097
.quad 0x249214109d5d1c88
endconst
const error_message_fpscr
.asciz "failed to preserve register FPSCR, changed bits: %x"
error_message_gpr:
.asciz "failed to preserve register r%d"
error_message_vfp:
.asciz "failed to preserve register d%d"
error_message_stack:
.asciz "failed to preserve stack"
endconst
@ max number of args used by any asm function.
#define MAX_ARGS 15
#define ARG_STACK 4*(MAX_ARGS - 4)
@ Align the used stack space to 8 to preserve the stack alignment.
@ +8 for stack canary reference.
#define ARG_STACK_A (((ARG_STACK + pushed + 7) & ~7) - pushed + 8)
.macro clobbercheck variant
.equ pushed, 4*9
function checkasm_checked_call_\variant, export=1
push {r4-r11, lr}
.ifc \variant, vfp
vpush {d8-d15}
fmrx r4, FPSCR
push {r4}
.equ pushed, pushed + 16*4 + 4
.endif
movrel r12, register_init
.ifc \variant, vfp
vldm r12, {d8-d15}
.endif
ldm r12, {r4-r11}
sub sp, sp, #ARG_STACK_A
.equ pos, 0
.rept MAX_ARGS-4
ldr r12, [sp, #ARG_STACK_A + pushed + 8 + pos]
str r12, [sp, #pos]
.equ pos, pos + 4
.endr
@ For stack overflows, the callee is free to overwrite the parameters
@ that were passed on the stack (if any), so we can only check after
@ that point. First figure out how many parameters the function
@ really took on the stack:
ldr r12, [sp, #ARG_STACK_A + pushed + 8 + 4*(MAX_ARGS-4)]
@ Load the first non-parameter value from the stack, that should be
@ left untouched by the function. Store a copy of it inverted, so that
@ e.g. overwriting everything with zero would be noticed.
ldr r12, [sp, r12, lsl #2]
mvn r12, r12
str r12, [sp, #ARG_STACK_A - 4]
mov r12, r0
mov r0, r2
mov r1, r3
ldrd r2, r3, [sp, #ARG_STACK_A + pushed]
@ Call the target function
blx r12
@ Load the number of stack parameters, stack canary and its reference
ldr r12, [sp, #ARG_STACK_A + pushed + 8 + 4*(MAX_ARGS-4)]
ldr r2, [sp, r12, lsl #2]
ldr r3, [sp, #ARG_STACK_A - 4]
add sp, sp, #ARG_STACK_A
push {r0, r1}
mvn r3, r3
cmp r2, r3
bne 5f
movrel r12, register_init
.ifc \variant, vfp
.macro check_reg_vfp, dreg, offset
ldrd r2, r3, [r12, #8 * (\offset)]
vmov r0, lr, \dreg
eor r2, r2, r0
eor r3, r3, lr
orrs r2, r2, r3
bne 4f
.endm
.irp n, 8, 9, 10, 11, 12, 13, 14, 15
@ keep track of the checked double/SIMD register
mov r1, #\n
check_reg_vfp d\n, \n-8
.endr
.purgem check_reg_vfp
fmrx r1, FPSCR
ldr r3, [sp, #8]
eor r1, r1, r3
@ Ignore changes in bits 0-4 and 7
bic r1, r1, #0x9f
@ Ignore changes in the topmost 5 bits
bics r1, r1, #0xf8000000
bne 3f
.endif
@ keep track of the checked GPR
mov r1, #4
.macro check_reg reg1, reg2=
ldrd r2, r3, [r12], #8
eors r2, r2, \reg1
bne 2f
add r1, r1, #1
.ifnb \reg2
eors r3, r3, \reg2
bne 2f
.endif
add r1, r1, #1
.endm
check_reg r4, r5
check_reg r6, r7
@ r9 is a volatile register in the ios ABI
#ifdef __APPLE__
check_reg r8
#else
check_reg r8, r9
#endif
check_reg r10, r11
.purgem check_reg
b 0f
5:
movrel r0, error_message_stack
b 1f
4:
movrel r0, error_message_vfp
b 1f
3:
movrel r0, error_message_fpscr
b 1f
2:
movrel r0, error_message_gpr
1:
bl X(checkasm_fail_func)
0:
pop {r0, r1}
.ifc \variant, vfp
pop {r2}
fmxr FPSCR, r2
vpop {d8-d15}
.endif
pop {r4-r11, pc}
endfunc
.endm
#if HAVE_VFP || HAVE_NEON
clobbercheck vfp
#endif
clobbercheck novfp

146
externals/ffmpeg/tests/checkasm/audiodsp.c vendored
View File

@@ -1,146 +0,0 @@
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <math.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "libavcodec/audiodsp.h"
#include "libavutil/common.h"
#include "libavutil/intreadwrite.h"
#include "checkasm.h"
#define MAX_SIZE (32 * 128)
#define randomize_float(buf, len) \
do { \
int i; \
for (i = 0; i < len; i++) { \
float f = (float)rnd() / (UINT_MAX >> 5) - 16.0f; \
buf[i] = f; \
} \
} while (0)
#define randomize_int(buf, len, size, bits) \
do { \
int i; \
for (i = 0; i < len; i++) { \
uint ## size ## _t r = rnd() & ((1LL << bits) - 1); \
AV_WN ## size ## A(buf + i, -(1LL << (bits - 1)) + r); \
} \
} while (0)
void checkasm_check_audiodsp(void)
{
AudioDSPContext adsp;
ff_audiodsp_init(&adsp);
if (check_func(adsp.scalarproduct_int16, "audiodsp.scalarproduct_int16")) {
LOCAL_ALIGNED(32, int16_t, v1, [MAX_SIZE]);
LOCAL_ALIGNED(32, int16_t, v2, [MAX_SIZE]);
unsigned int len_bits_minus4, v1_bits, v2_bits, len;
int32_t res0, res1;
declare_func_emms(AV_CPU_FLAG_MMX, int32_t, const int16_t *v1, const int16_t *v2, int len);
// generate random 5-12bit vector length
len_bits_minus4 = rnd() % 8;
len = rnd() & ((1 << len_bits_minus4) - 1);
len = 16 * FFMAX(len, 1);
// generate the bit counts for each of the vectors such that the result
// fits into int32
v1_bits = 1 + rnd() % 15;
v2_bits = FFMIN(32 - (len_bits_minus4 + 4) - v1_bits - 1, 15);
randomize_int(v1, MAX_SIZE, 16, v1_bits + 1);
randomize_int(v2, MAX_SIZE, 16, v2_bits + 1);
res0 = call_ref(v1, v2, len);
res1 = call_new(v1, v2, len);
if (res0 != res1)
fail();
bench_new(v1, v2, MAX_SIZE);
}
if (check_func(adsp.vector_clip_int32, "audiodsp.vector_clip_int32")) {
LOCAL_ALIGNED(32, int32_t, src, [MAX_SIZE]);
LOCAL_ALIGNED(32, int32_t, dst0, [MAX_SIZE]);
LOCAL_ALIGNED(32, int32_t, dst1, [MAX_SIZE]);
int32_t val1, val2, min, max;
int len;
declare_func_emms(AV_CPU_FLAG_MMX, void, int32_t *dst, const int32_t *src,
int32_t min, int32_t max, unsigned int len);
val1 = ((int32_t)rnd());
val1 = FFSIGN(val1) * (val1 & ((1 << 24) - 1));
val2 = ((int32_t)rnd());
val2 = FFSIGN(val2) * (val2 & ((1 << 24) - 1));
min = FFMIN(val1, val2);
max = FFMAX(val1, val2);
randomize_int(src, MAX_SIZE, 32, 32);
len = rnd() % 128;
len = 32 * FFMAX(len, 1);
call_ref(dst0, src, min, max, len);
call_new(dst1, src, min, max, len);
if (memcmp(dst0, dst1, len * sizeof(*dst0)))
fail();
bench_new(dst1, src, min, max, MAX_SIZE);
}
if (check_func(adsp.vector_clipf, "audiodsp.vector_clipf")) {
LOCAL_ALIGNED(32, float, src, [MAX_SIZE]);
LOCAL_ALIGNED(32, float, dst0, [MAX_SIZE]);
LOCAL_ALIGNED(32, float, dst1, [MAX_SIZE]);
float val1, val2, min, max;
int i, len;
declare_func_emms(AV_CPU_FLAG_MMX, void, float *dst, const float *src,
int len, float min, float max);
val1 = (float)rnd() / (UINT_MAX >> 1) - 1.0f;
val2 = (float)rnd() / (UINT_MAX >> 1) - 1.0f;
min = FFMIN(val1, val2);
max = FFMAX(val1, val2);
randomize_float(src, MAX_SIZE);
len = rnd() % 128;
len = 16 * FFMAX(len, 1);
call_ref(dst0, src, len, min, max);
call_new(dst1, src, len, min, max);
for (i = 0; i < len; i++) {
if (!float_near_ulp_array(dst0, dst1, 3, len))
fail();
}
bench_new(dst1, src, MAX_SIZE, min, max);
}
report("audiodsp");
}

68
externals/ffmpeg/tests/checkasm/blockdsp.c vendored
View File

@@ -1,68 +0,0 @@
/*
* Copyright (c) 2015 Henrik Gramner
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavcodec/blockdsp.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/intreadwrite.h"
#define randomize_buffers(size) \
do { \
int i; \
for (i = 0; i < size; i++) { \
uint16_t r = rnd(); \
AV_WN16A(buf0 + i, r); \
AV_WN16A(buf1 + i, r); \
} \
} while (0)
#define check_clear(func, size) \
do { \
if (check_func(h.func, "blockdsp." #func)) { \
declare_func_emms(AV_CPU_FLAG_MMX, void, int16_t *block); \
randomize_buffers(size); \
call_ref(buf0); \
call_new(buf1); \
if (memcmp(buf0, buf1, sizeof(*buf0) * size)) \
fail(); \
bench_new(buf0); \
} \
} while (0)
void checkasm_check_blockdsp(void)
{
LOCAL_ALIGNED_32(uint16_t, buf0, [6 * 8 * 8]);
LOCAL_ALIGNED_32(uint16_t, buf1, [6 * 8 * 8]);
AVCodecContext avctx = { 0 };
BlockDSPContext h;
ff_blockdsp_init(&h, &avctx);
check_clear(clear_block, 8 * 8);
check_clear(clear_blocks, 8 * 8 * 6);
report("blockdsp");
}

76
externals/ffmpeg/tests/checkasm/bswapdsp.c vendored
View File

@@ -1,76 +0,0 @@
/*
* Copyright (c) 2015 Henrik Gramner
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavcodec/bswapdsp.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/intreadwrite.h"
#define BUF_SIZE 512
#define randomize_buffers() \
do { \
int i; \
for (i = 0; i < BUF_SIZE; i += 4) { \
uint32_t r = rnd(); \
AV_WN32A(src0 + i, r); \
AV_WN32A(src1 + i, r); \
r = rnd(); \
AV_WN32A(dst0 + i, r); \
AV_WN32A(dst1 + i, r); \
} \
} while (0)
#define check_bswap(type) \
do { \
int w; \
declare_func(void, type *dst, const type *src, int w); \
\
for (w = 0; w < BUF_SIZE / sizeof(type); w++) { \
int offset = (BUF_SIZE / sizeof(type) - w) & 15; /* Test various alignments */ \
randomize_buffers(); \
call_ref((type *)dst0 + offset, (type *)src0 + offset, w); \
call_new((type *)dst1 + offset, (type *)src1 + offset, w); \
if (memcmp(src0, src1, BUF_SIZE) || memcmp(dst0, dst1, BUF_SIZE)) \
fail(); \
bench_new((type *)dst1 + offset, (type *)src1 + offset, w); \
} \
} while (0)
void checkasm_check_bswapdsp(void)
{
LOCAL_ALIGNED_16(uint8_t, src0, [BUF_SIZE]);
LOCAL_ALIGNED_16(uint8_t, src1, [BUF_SIZE]);
LOCAL_ALIGNED_16(uint8_t, dst0, [BUF_SIZE]);
LOCAL_ALIGNED_16(uint8_t, dst1, [BUF_SIZE]);
BswapDSPContext h;
ff_bswapdsp_init(&h);
if (check_func(h.bswap_buf, "bswap_buf"))
check_bswap(uint32_t);
if (check_func(h.bswap16_buf, "bswap16_buf"))
check_bswap(uint16_t);
report("bswap");
}

881
externals/ffmpeg/tests/checkasm/checkasm.c vendored
View File

@@ -1,881 +0,0 @@
/*
* Assembly testing and benchmarking tool
* Copyright (c) 2015 Henrik Gramner
* Copyright (c) 2008 Loren Merritt
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#if CONFIG_LINUX_PERF
# ifndef _GNU_SOURCE
# define _GNU_SOURCE // for syscall (performance monitoring API)
# endif
#endif
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "checkasm.h"
#include "libavutil/common.h"
#include "libavutil/cpu.h"
#include "libavutil/intfloat.h"
#include "libavutil/random_seed.h"
#if HAVE_IO_H
#include <io.h>
#endif
#if HAVE_SETCONSOLETEXTATTRIBUTE && HAVE_GETSTDHANDLE
#include <windows.h>
#define COLOR_RED FOREGROUND_RED
#define COLOR_GREEN FOREGROUND_GREEN
#define COLOR_YELLOW (FOREGROUND_RED|FOREGROUND_GREEN)
#else
#define COLOR_RED 1
#define COLOR_GREEN 2
#define COLOR_YELLOW 3
#endif
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#if !HAVE_ISATTY
#define isatty(fd) 1
#endif
#if ARCH_ARM && HAVE_ARMV5TE_EXTERNAL
#include "libavutil/arm/cpu.h"
void (*checkasm_checked_call)(void *func, int dummy, ...) = checkasm_checked_call_novfp;
#endif
/* List of tests to invoke */
static const struct {
const char *name;
void (*func)(void);
} tests[] = {
#if CONFIG_AVCODEC
#if CONFIG_AAC_DECODER
{ "aacpsdsp", checkasm_check_aacpsdsp },
{ "sbrdsp", checkasm_check_sbrdsp },
#endif
#if CONFIG_ALAC_DECODER
{ "alacdsp", checkasm_check_alacdsp },
#endif
#if CONFIG_AUDIODSP
{ "audiodsp", checkasm_check_audiodsp },
#endif
#if CONFIG_BLOCKDSP
{ "blockdsp", checkasm_check_blockdsp },
#endif
#if CONFIG_BSWAPDSP
{ "bswapdsp", checkasm_check_bswapdsp },
#endif
#if CONFIG_DCA_DECODER
{ "synth_filter", checkasm_check_synth_filter },
#endif
#if CONFIG_EXR_DECODER
{ "exrdsp", checkasm_check_exrdsp },
#endif
#if CONFIG_FLACDSP
{ "flacdsp", checkasm_check_flacdsp },
#endif
#if CONFIG_FMTCONVERT
{ "fmtconvert", checkasm_check_fmtconvert },
#endif
#if CONFIG_G722DSP
{ "g722dsp", checkasm_check_g722dsp },
#endif
#if CONFIG_H264DSP
{ "h264dsp", checkasm_check_h264dsp },
#endif
#if CONFIG_H264PRED
{ "h264pred", checkasm_check_h264pred },
#endif
#if CONFIG_H264QPEL
{ "h264qpel", checkasm_check_h264qpel },
#endif
#if CONFIG_HEVC_DECODER
{ "hevc_add_res", checkasm_check_hevc_add_res },
{ "hevc_idct", checkasm_check_hevc_idct },
{ "hevc_sao", checkasm_check_hevc_sao },
#endif
#if CONFIG_HUFFYUV_DECODER
{ "huffyuvdsp", checkasm_check_huffyuvdsp },
#endif
#if CONFIG_JPEG2000_DECODER
{ "jpeg2000dsp", checkasm_check_jpeg2000dsp },
#endif
#if CONFIG_HUFFYUVDSP
{ "llviddsp", checkasm_check_llviddsp },
#endif
#if CONFIG_LLVIDENCDSP
{ "llviddspenc", checkasm_check_llviddspenc },
#endif
#if CONFIG_OPUS_DECODER
{ "opusdsp", checkasm_check_opusdsp },
#endif
#if CONFIG_PIXBLOCKDSP
{ "pixblockdsp", checkasm_check_pixblockdsp },
#endif
#if CONFIG_UTVIDEO_DECODER
{ "utvideodsp", checkasm_check_utvideodsp },
#endif
#if CONFIG_V210_DECODER
{ "v210dec", checkasm_check_v210dec },
#endif
#if CONFIG_V210_ENCODER
{ "v210enc", checkasm_check_v210enc },
#endif
#if CONFIG_VP8DSP
{ "vp8dsp", checkasm_check_vp8dsp },
#endif
#if CONFIG_VP9_DECODER
{ "vp9dsp", checkasm_check_vp9dsp },
#endif
#if CONFIG_VIDEODSP
{ "videodsp", checkasm_check_videodsp },
#endif
#endif
#if CONFIG_AVFILTER
#if CONFIG_AFIR_FILTER
{ "af_afir", checkasm_check_afir },
#endif
#if CONFIG_BLEND_FILTER
{ "vf_blend", checkasm_check_blend },
#endif
#if CONFIG_COLORSPACE_FILTER
{ "vf_colorspace", checkasm_check_colorspace },
#endif
#if CONFIG_EQ_FILTER
{ "vf_eq", checkasm_check_vf_eq },
#endif
#if CONFIG_GBLUR_FILTER
{ "vf_gblur", checkasm_check_vf_gblur },
#endif
#if CONFIG_HFLIP_FILTER
{ "vf_hflip", checkasm_check_vf_hflip },
#endif
#if CONFIG_NLMEANS_FILTER
{ "vf_nlmeans", checkasm_check_nlmeans },
#endif
#if CONFIG_THRESHOLD_FILTER
{ "vf_threshold", checkasm_check_vf_threshold },
#endif
#endif
#if CONFIG_SWSCALE
{ "sw_rgb", checkasm_check_sw_rgb },
{ "sw_scale", checkasm_check_sw_scale },
#endif
#if CONFIG_AVUTIL
{ "fixed_dsp", checkasm_check_fixed_dsp },
{ "float_dsp", checkasm_check_float_dsp },
#endif
{ NULL }
};
/* List of cpu flags to check */
static const struct {
const char *name;
const char *suffix;
int flag;
} cpus[] = {
#if ARCH_AARCH64
{ "ARMV8", "armv8", AV_CPU_FLAG_ARMV8 },
{ "NEON", "neon", AV_CPU_FLAG_NEON },
#elif ARCH_ARM
{ "ARMV5TE", "armv5te", AV_CPU_FLAG_ARMV5TE },
{ "ARMV6", "armv6", AV_CPU_FLAG_ARMV6 },
{ "ARMV6T2", "armv6t2", AV_CPU_FLAG_ARMV6T2 },
{ "VFP", "vfp", AV_CPU_FLAG_VFP },
{ "VFP_VM", "vfp_vm", AV_CPU_FLAG_VFP_VM },
{ "VFPV3", "vfp3", AV_CPU_FLAG_VFPV3 },
{ "NEON", "neon", AV_CPU_FLAG_NEON },
#elif ARCH_PPC
{ "ALTIVEC", "altivec", AV_CPU_FLAG_ALTIVEC },
{ "VSX", "vsx", AV_CPU_FLAG_VSX },
{ "POWER8", "power8", AV_CPU_FLAG_POWER8 },
#elif ARCH_X86
{ "MMX", "mmx", AV_CPU_FLAG_MMX|AV_CPU_FLAG_CMOV },
{ "MMXEXT", "mmxext", AV_CPU_FLAG_MMXEXT },
{ "3DNOW", "3dnow", AV_CPU_FLAG_3DNOW },
{ "3DNOWEXT", "3dnowext", AV_CPU_FLAG_3DNOWEXT },
{ "SSE", "sse", AV_CPU_FLAG_SSE },
{ "SSE2", "sse2", AV_CPU_FLAG_SSE2|AV_CPU_FLAG_SSE2SLOW },
{ "SSE3", "sse3", AV_CPU_FLAG_SSE3|AV_CPU_FLAG_SSE3SLOW },
{ "SSSE3", "ssse3", AV_CPU_FLAG_SSSE3|AV_CPU_FLAG_ATOM },
{ "SSE4.1", "sse4", AV_CPU_FLAG_SSE4 },
{ "SSE4.2", "sse42", AV_CPU_FLAG_SSE42 },
{ "AES-NI", "aesni", AV_CPU_FLAG_AESNI },
{ "AVX", "avx", AV_CPU_FLAG_AVX },
{ "XOP", "xop", AV_CPU_FLAG_XOP },
{ "FMA3", "fma3", AV_CPU_FLAG_FMA3 },
{ "FMA4", "fma4", AV_CPU_FLAG_FMA4 },
{ "AVX2", "avx2", AV_CPU_FLAG_AVX2 },
{ "AVX-512", "avx512", AV_CPU_FLAG_AVX512 },
#endif
{ NULL }
};
typedef struct CheckasmFuncVersion {
struct CheckasmFuncVersion *next;
void *func;
int ok;
int cpu;
CheckasmPerf perf;
} CheckasmFuncVersion;
/* Binary search tree node */
typedef struct CheckasmFunc {
struct CheckasmFunc *child[2];
CheckasmFuncVersion versions;
uint8_t color; /* 0 = red, 1 = black */
char name[1];
} CheckasmFunc;
/* Internal state */
static struct {
CheckasmFunc *funcs;
CheckasmFunc *current_func;
CheckasmFuncVersion *current_func_ver;
const char *current_test_name;
const char *bench_pattern;
int bench_pattern_len;
int num_checked;
int num_failed;
/* perf */
int nop_time;
int sysfd;
int cpu_flag;
const char *cpu_flag_name;
const char *test_name;
int verbose;
} state;
/* PRNG state */
AVLFG checkasm_lfg;
/* float compare support code */
static int is_negative(union av_intfloat32 u)
{
return u.i >> 31;
}
int float_near_ulp(float a, float b, unsigned max_ulp)
{
union av_intfloat32 x, y;
x.f = a;
y.f = b;
if (is_negative(x) != is_negative(y)) {
// handle -0.0 == +0.0
return a == b;
}
if (llabs((int64_t)x.i - y.i) <= max_ulp)
return 1;
return 0;
}
int float_near_ulp_array(const float *a, const float *b, unsigned max_ulp,
unsigned len)
{
unsigned i;
for (i = 0; i < len; i++) {
if (!float_near_ulp(a[i], b[i], max_ulp))
return 0;
}
return 1;
}
int float_near_abs_eps(float a, float b, float eps)
{
float abs_diff = fabsf(a - b);
if (abs_diff < eps)
return 1;
fprintf(stderr, "test failed comparing %g with %g (abs diff=%g with EPS=%g)\n", a, b, abs_diff, eps);
return 0;
}
int float_near_abs_eps_array(const float *a, const float *b, float eps,
unsigned len)
{
unsigned i;
for (i = 0; i < len; i++) {
if (!float_near_abs_eps(a[i], b[i], eps))
return 0;
}
return 1;
}
int float_near_abs_eps_ulp(float a, float b, float eps, unsigned max_ulp)
{
return float_near_ulp(a, b, max_ulp) || float_near_abs_eps(a, b, eps);
}
int float_near_abs_eps_array_ulp(const float *a, const float *b, float eps,
unsigned max_ulp, unsigned len)
{
unsigned i;
for (i = 0; i < len; i++) {
if (!float_near_abs_eps_ulp(a[i], b[i], eps, max_ulp))
return 0;
}
return 1;
}
int double_near_abs_eps(double a, double b, double eps)
{
double abs_diff = fabs(a - b);
return abs_diff < eps;
}
int double_near_abs_eps_array(const double *a, const double *b, double eps,
unsigned len)
{
unsigned i;
for (i = 0; i < len; i++) {
if (!double_near_abs_eps(a[i], b[i], eps))
return 0;
}
return 1;
}
/* Print colored text to stderr if the terminal supports it */
static void color_printf(int color, const char *fmt, ...)
{
static int use_color = -1;
va_list arg;
#if HAVE_SETCONSOLETEXTATTRIBUTE && HAVE_GETSTDHANDLE
static HANDLE con;
static WORD org_attributes;
if (use_color < 0) {
CONSOLE_SCREEN_BUFFER_INFO con_info;
con = GetStdHandle(STD_ERROR_HANDLE);
if (con && con != INVALID_HANDLE_VALUE && GetConsoleScreenBufferInfo(con, &con_info)) {
org_attributes = con_info.wAttributes;
use_color = 1;
} else
use_color = 0;
}
if (use_color)
SetConsoleTextAttribute(con, (org_attributes & 0xfff0) | (color & 0x0f));
#else
if (use_color < 0) {
const char *term = getenv("TERM");
use_color = term && strcmp(term, "dumb") && isatty(2);
}
if (use_color)
fprintf(stderr, "\x1b[%d;3%dm", (color & 0x08) >> 3, color & 0x07);
#endif
va_start(arg, fmt);
vfprintf(stderr, fmt, arg);
va_end(arg);
if (use_color) {
#if HAVE_SETCONSOLETEXTATTRIBUTE && HAVE_GETSTDHANDLE
SetConsoleTextAttribute(con, org_attributes);
#else
fprintf(stderr, "\x1b[0m");
#endif
}
}
/* Deallocate a tree */
static void destroy_func_tree(CheckasmFunc *f)
{
if (f) {
CheckasmFuncVersion *v = f->versions.next;
while (v) {
CheckasmFuncVersion *next = v->next;
free(v);
v = next;
}
destroy_func_tree(f->child[0]);
destroy_func_tree(f->child[1]);
free(f);
}
}
/* Allocate a zero-initialized block, clean up and exit on failure */
static void *checkasm_malloc(size_t size)
{
void *ptr = calloc(1, size);
if (!ptr) {
fprintf(stderr, "checkasm: malloc failed\n");
destroy_func_tree(state.funcs);
exit(1);
}
return ptr;
}
/* Get the suffix of the specified cpu flag */
static const char *cpu_suffix(int cpu)
{
int i = FF_ARRAY_ELEMS(cpus);
while (--i >= 0)
if (cpu & cpus[i].flag)
return cpus[i].suffix;
return "c";
}
static int cmp_nop(const void *a, const void *b)
{
return *(const uint16_t*)a - *(const uint16_t*)b;
}
/* Measure the overhead of the timing code (in decicycles) */
static int measure_nop_time(void)
{
uint16_t nops[10000];
int i, nop_sum = 0;
av_unused const int sysfd = state.sysfd;
uint64_t t = 0;
for (i = 0; i < 10000; i++) {
PERF_START(t);
PERF_STOP(t);
nops[i] = t;
}
qsort(nops, 10000, sizeof(uint16_t), cmp_nop);
for (i = 2500; i < 7500; i++)
nop_sum += nops[i];
return nop_sum / 500;
}
/* Print benchmark results */
static void print_benchs(CheckasmFunc *f)
{
if (f) {
print_benchs(f->child[0]);
/* Only print functions with at least one assembly version */
if (f->versions.cpu || f->versions.next) {
CheckasmFuncVersion *v = &f->versions;
do {
CheckasmPerf *p = &v->perf;
if (p->iterations) {
int decicycles = (10*p->cycles/p->iterations - state.nop_time) / 4;
printf("%s_%s: %d.%d\n", f->name, cpu_suffix(v->cpu), decicycles/10, decicycles%10);
}
} while ((v = v->next));
}
print_benchs(f->child[1]);
}
}
/* ASCIIbetical sort except preserving natural order for numbers */
static int cmp_func_names(const char *a, const char *b)
{
const char *start = a;
int ascii_diff, digit_diff;
for (; !(ascii_diff = *(const unsigned char*)a - *(const unsigned char*)b) && *a; a++, b++);
for (; av_isdigit(*a) && av_isdigit(*b); a++, b++);
if (a > start && av_isdigit(a[-1]) && (digit_diff = av_isdigit(*a) - av_isdigit(*b)))
return digit_diff;
return ascii_diff;
}
/* Perform a tree rotation in the specified direction and return the new root */
static CheckasmFunc *rotate_tree(CheckasmFunc *f, int dir)
{
CheckasmFunc *r = f->child[dir^1];
f->child[dir^1] = r->child[dir];
r->child[dir] = f;
r->color = f->color;
f->color = 0;
return r;
}
#define is_red(f) ((f) && !(f)->color)
/* Balance a left-leaning red-black tree at the specified node */
static void balance_tree(CheckasmFunc **root)
{
CheckasmFunc *f = *root;
if (is_red(f->child[0]) && is_red(f->child[1])) {
f->color ^= 1;
f->child[0]->color = f->child[1]->color = 1;
}
if (!is_red(f->child[0]) && is_red(f->child[1]))
*root = rotate_tree(f, 0); /* Rotate left */
else if (is_red(f->child[0]) && is_red(f->child[0]->child[0]))
*root = rotate_tree(f, 1); /* Rotate right */
}
/* Get a node with the specified name, creating it if it doesn't exist */
static CheckasmFunc *get_func(CheckasmFunc **root, const char *name)
{
CheckasmFunc *f = *root;
if (f) {
/* Search the tree for a matching node */
int cmp = cmp_func_names(name, f->name);
if (cmp) {
f = get_func(&f->child[cmp > 0], name);
/* Rebalance the tree on the way up if a new node was inserted */
if (!f->versions.func)
balance_tree(root);
}
} else {
/* Allocate and insert a new node into the tree */
int name_length = strlen(name);
f = *root = checkasm_malloc(sizeof(CheckasmFunc) + name_length);
memcpy(f->name, name, name_length + 1);
}
return f;
}
/* Perform tests and benchmarks for the specified cpu flag if supported by the host */
static void check_cpu_flag(const char *name, int flag)
{
int old_cpu_flag = state.cpu_flag;
flag |= old_cpu_flag;
av_force_cpu_flags(-1);
state.cpu_flag = flag & av_get_cpu_flags();
av_force_cpu_flags(state.cpu_flag);
if (!flag || state.cpu_flag != old_cpu_flag) {
int i;
state.cpu_flag_name = name;
for (i = 0; tests[i].func; i++) {
if (state.test_name && strcmp(tests[i].name, state.test_name))
continue;
state.current_test_name = tests[i].name;
tests[i].func();
}
}
}
/* Print the name of the current CPU flag, but only do it once */
static void print_cpu_name(void)
{
if (state.cpu_flag_name) {
color_printf(COLOR_YELLOW, "%s:\n", state.cpu_flag_name);
state.cpu_flag_name = NULL;
}
}
#if CONFIG_LINUX_PERF
static int bench_init_linux(void)
{
struct perf_event_attr attr = {
.type = PERF_TYPE_HARDWARE,
.size = sizeof(struct perf_event_attr),
.config = PERF_COUNT_HW_CPU_CYCLES,
.disabled = 1, // start counting only on demand
.exclude_kernel = 1,
.exclude_hv = 1,
};
printf("benchmarking with Linux Perf Monitoring API\n");
state.sysfd = syscall(__NR_perf_event_open, &attr, 0, -1, -1, 0);
if (state.sysfd == -1) {
perror("syscall");
return -1;
}
return 0;
}
#endif
#if !CONFIG_LINUX_PERF
static int bench_init_ffmpeg(void)
{
#ifdef AV_READ_TIME
printf("benchmarking with native FFmpeg timers\n");
return 0;
#else
fprintf(stderr, "checkasm: --bench is not supported on your system\n");
return -1;
#endif
}
#endif
static int bench_init(void)
{
#if CONFIG_LINUX_PERF
int ret = bench_init_linux();
#else
int ret = bench_init_ffmpeg();
#endif
if (ret < 0)
return ret;
state.nop_time = measure_nop_time();
printf("nop: %d.%d\n", state.nop_time/10, state.nop_time%10);
return 0;
}
static void bench_uninit(void)
{
#if CONFIG_LINUX_PERF
if (state.sysfd > 0)
close(state.sysfd);
#endif
}
int main(int argc, char *argv[])
{
unsigned int seed = av_get_random_seed();
int i, ret = 0;
#if ARCH_ARM && HAVE_ARMV5TE_EXTERNAL
if (have_vfp(av_get_cpu_flags()) || have_neon(av_get_cpu_flags()))
checkasm_checked_call = checkasm_checked_call_vfp;
#endif
if (!tests[0].func || !cpus[0].flag) {
fprintf(stderr, "checkasm: no tests to perform\n");
return 0;
}
while (argc > 1) {
if (!strncmp(argv[1], "--bench", 7)) {
if (bench_init() < 0)
return 1;
if (argv[1][7] == '=') {
state.bench_pattern = argv[1] + 8;
state.bench_pattern_len = strlen(state.bench_pattern);
} else
state.bench_pattern = "";
} else if (!strncmp(argv[1], "--test=", 7)) {
state.test_name = argv[1] + 7;
} else if (!strcmp(argv[1], "--verbose") || !strcmp(argv[1], "-v")) {
state.verbose = 1;
} else {
seed = strtoul(argv[1], NULL, 10);
}
argc--;
argv++;
}
fprintf(stderr, "checkasm: using random seed %u\n", seed);
av_lfg_init(&checkasm_lfg, seed);
check_cpu_flag(NULL, 0);
for (i = 0; cpus[i].flag; i++)
check_cpu_flag(cpus[i].name, cpus[i].flag);
if (state.num_failed) {
fprintf(stderr, "checkasm: %d of %d tests have failed\n", state.num_failed, state.num_checked);
ret = 1;
} else {
fprintf(stderr, "checkasm: all %d tests passed\n", state.num_checked);
if (state.bench_pattern) {
print_benchs(state.funcs);
}
}
destroy_func_tree(state.funcs);
bench_uninit();
return ret;
}
/* Decide whether or not the specified function needs to be tested and
* allocate/initialize data structures if needed. Returns a pointer to a
* reference function if the function should be tested, otherwise NULL */
void *checkasm_check_func(void *func, const char *name, ...)
{
char name_buf[256];
void *ref = func;
CheckasmFuncVersion *v;
int name_length;
va_list arg;
va_start(arg, name);
name_length = vsnprintf(name_buf, sizeof(name_buf), name, arg);
va_end(arg);
if (!func || name_length <= 0 || name_length >= sizeof(name_buf))
return NULL;
state.current_func = get_func(&state.funcs, name_buf);
state.funcs->color = 1;
v = &state.current_func->versions;
if (v->func) {
CheckasmFuncVersion *prev;
do {
/* Only test functions that haven't already been tested */
if (v->func == func)
return NULL;
if (v->ok)
ref = v->func;
prev = v;
} while ((v = v->next));
v = prev->next = checkasm_malloc(sizeof(CheckasmFuncVersion));
}
v->func = func;
v->ok = 1;
v->cpu = state.cpu_flag;
state.current_func_ver = v;
if (state.cpu_flag)
state.num_checked++;
return ref;
}
/* Decide whether or not the current function needs to be benchmarked */
int checkasm_bench_func(void)
{
return !state.num_failed && state.bench_pattern &&
!strncmp(state.current_func->name, state.bench_pattern, state.bench_pattern_len);
}
/* Indicate that the current test has failed */
void checkasm_fail_func(const char *msg, ...)
{
if (state.current_func_ver->cpu && state.current_func_ver->ok) {
va_list arg;
print_cpu_name();
fprintf(stderr, " %s_%s (", state.current_func->name, cpu_suffix(state.current_func_ver->cpu));
va_start(arg, msg);
vfprintf(stderr, msg, arg);
va_end(arg);
fprintf(stderr, ")\n");
state.current_func_ver->ok = 0;
state.num_failed++;
}
}
/* Get the benchmark context of the current function */
CheckasmPerf *checkasm_get_perf_context(void)
{
CheckasmPerf *perf = &state.current_func_ver->perf;
memset(perf, 0, sizeof(*perf));
perf->sysfd = state.sysfd;
return perf;
}
/* Print the outcome of all tests performed since the last time this function was called */
void checkasm_report(const char *name, ...)
{
static int prev_checked, prev_failed, max_length;
if (state.num_checked > prev_checked) {
int pad_length = max_length + 4;
va_list arg;
print_cpu_name();
pad_length -= fprintf(stderr, " - %s.", state.current_test_name);
va_start(arg, name);
pad_length -= vfprintf(stderr, name, arg);
va_end(arg);
fprintf(stderr, "%*c", FFMAX(pad_length, 0) + 2, '[');
if (state.num_failed == prev_failed)
color_printf(COLOR_GREEN, "OK");
else
color_printf(COLOR_RED, "FAILED");
fprintf(stderr, "]\n");
prev_checked = state.num_checked;
prev_failed = state.num_failed;
} else if (!state.cpu_flag) {
/* Calculate the amount of padding required to make the output vertically aligned */
int length = strlen(state.current_test_name);
va_list arg;
va_start(arg, name);
length += vsnprintf(NULL, 0, name, arg);
va_end(arg);
if (length > max_length)
max_length = length;
}
}
#define DEF_CHECKASM_CHECK_FUNC(type, fmt) \
int checkasm_check_##type(const char *const file, const int line, \
const type *buf1, ptrdiff_t stride1, \
const type *buf2, ptrdiff_t stride2, \
const int w, int h, const char *const name) \
{ \
int y = 0; \
stride1 /= sizeof(*buf1); \
stride2 /= sizeof(*buf2); \
for (y = 0; y < h; y++) \
if (memcmp(&buf1[y*stride1], &buf2[y*stride2], w*sizeof(*buf1))) \
break; \
if (y == h) \
return 0; \
checkasm_fail_func("%s:%d", file, line); \
if (!state.verbose) \
return 1; \
fprintf(stderr, "%s:\n", name); \
while (h--) { \
for (int x = 0; x < w; x++) \
fprintf(stderr, " " fmt, buf1[x]); \
fprintf(stderr, " "); \
for (int x = 0; x < w; x++) \
fprintf(stderr, " " fmt, buf2[x]); \
fprintf(stderr, " "); \
for (int x = 0; x < w; x++) \
fprintf(stderr, "%c", buf1[x] != buf2[x] ? 'x' : '.'); \
buf1 += stride1; \
buf2 += stride2; \
fprintf(stderr, "\n"); \
} \
return 1; \
}
DEF_CHECKASM_CHECK_FUNC(uint8_t, "%02x")
DEF_CHECKASM_CHECK_FUNC(uint16_t, "%04x")
DEF_CHECKASM_CHECK_FUNC(int16_t, "%6d")
DEF_CHECKASM_CHECK_FUNC(int32_t, "%9d")

282
externals/ffmpeg/tests/checkasm/checkasm.h vendored
View File

@@ -1,282 +0,0 @@
/*
* Assembly testing and benchmarking tool
* Copyright (c) 2015 Henrik Gramner
* Copyright (c) 2008 Loren Merritt
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef TESTS_CHECKASM_CHECKASM_H
#define TESTS_CHECKASM_CHECKASM_H
#include <stdint.h>
#include "config.h"
#if CONFIG_LINUX_PERF
#include <unistd.h> // read(3)
#include <sys/ioctl.h>
#include <asm/unistd.h>
#include <linux/perf_event.h>
#endif
#include "libavutil/avstring.h"
#include "libavutil/cpu.h"
#include "libavutil/internal.h"
#include "libavutil/lfg.h"
#include "libavutil/timer.h"
void checkasm_check_aacpsdsp(void);
void checkasm_check_afir(void);
void checkasm_check_alacdsp(void);
void checkasm_check_audiodsp(void);
void checkasm_check_blend(void);
void checkasm_check_blockdsp(void);
void checkasm_check_bswapdsp(void);
void checkasm_check_colorspace(void);
void checkasm_check_exrdsp(void);
void checkasm_check_fixed_dsp(void);
void checkasm_check_flacdsp(void);
void checkasm_check_float_dsp(void);
void checkasm_check_fmtconvert(void);
void checkasm_check_g722dsp(void);
void checkasm_check_h264dsp(void);
void checkasm_check_h264pred(void);
void checkasm_check_h264qpel(void);
void checkasm_check_hevc_add_res(void);
void checkasm_check_hevc_idct(void);
void checkasm_check_hevc_sao(void);
void checkasm_check_huffyuvdsp(void);
void checkasm_check_jpeg2000dsp(void);
void checkasm_check_llviddsp(void);
void checkasm_check_llviddspenc(void);
void checkasm_check_nlmeans(void);
void checkasm_check_opusdsp(void);
void checkasm_check_pixblockdsp(void);
void checkasm_check_sbrdsp(void);
void checkasm_check_synth_filter(void);
void checkasm_check_sw_rgb(void);
void checkasm_check_sw_scale(void);
void checkasm_check_utvideodsp(void);
void checkasm_check_v210dec(void);
void checkasm_check_v210enc(void);
void checkasm_check_vf_eq(void);
void checkasm_check_vf_gblur(void);
void checkasm_check_vf_hflip(void);
void checkasm_check_vf_threshold(void);
void checkasm_check_vp8dsp(void);
void checkasm_check_vp9dsp(void);
void checkasm_check_videodsp(void);
struct CheckasmPerf;
void *checkasm_check_func(void *func, const char *name, ...) av_printf_format(2, 3);
int checkasm_bench_func(void);
void checkasm_fail_func(const char *msg, ...) av_printf_format(1, 2);
struct CheckasmPerf *checkasm_get_perf_context(void);
void checkasm_report(const char *name, ...) av_printf_format(1, 2);
/* float compare utilities */
int float_near_ulp(float a, float b, unsigned max_ulp);
int float_near_abs_eps(float a, float b, float eps);
int float_near_abs_eps_ulp(float a, float b, float eps, unsigned max_ulp);
int float_near_ulp_array(const float *a, const float *b, unsigned max_ulp,
unsigned len);
int float_near_abs_eps_array(const float *a, const float *b, float eps,
unsigned len);
int float_near_abs_eps_array_ulp(const float *a, const float *b, float eps,
unsigned max_ulp, unsigned len);
int double_near_abs_eps(double a, double b, double eps);
int double_near_abs_eps_array(const double *a, const double *b, double eps,
unsigned len);
extern AVLFG checkasm_lfg;
#define rnd() av_lfg_get(&checkasm_lfg)
static av_unused void *func_ref, *func_new;
#define BENCH_RUNS 1000 /* Trade-off between accuracy and speed */
/* Decide whether or not the specified function needs to be tested */
#define check_func(func, ...) (func_ref = checkasm_check_func((func_new = func), __VA_ARGS__))
/* Declare the function prototype. The first argument is the return value, the remaining
* arguments are the function parameters. Naming parameters is optional. */
#define declare_func(ret, ...) declare_new(ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)
#define declare_func_float(ret, ...) declare_new_float(ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)
#define declare_func_emms(cpu_flags, ret, ...) declare_new_emms(cpu_flags, ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)
/* Indicate that the current test has failed */
#define fail() checkasm_fail_func("%s:%d", av_basename(__FILE__), __LINE__)
/* Print the test outcome */
#define report checkasm_report
/* Call the reference function */
#define call_ref(...) ((func_type *)func_ref)(__VA_ARGS__)
#if ARCH_X86 && HAVE_X86ASM
/* Verifies that clobbered callee-saved registers are properly saved and restored
* and that either no MMX registers are touched or emms is issued */
void checkasm_checked_call(void *func, ...);
/* Verifies that clobbered callee-saved registers are properly saved and restored
* and issues emms for asm functions which are not required to do so */
void checkasm_checked_call_emms(void *func, ...);
/* Verifies that clobbered callee-saved registers are properly saved and restored
* but doesn't issue emms. Meant for dsp functions returning float or double */
void checkasm_checked_call_float(void *func, ...);
#if ARCH_X86_64
/* Evil hack: detect incorrect assumptions that 32-bit ints are zero-extended to 64-bit.
* This is done by clobbering the stack with junk around the stack pointer and calling the
* assembly function through checked_call() with added dummy arguments which forces all
* real arguments to be passed on the stack and not in registers. For 32-bit arguments the
* upper half of the 64-bit register locations on the stack will now contain junk which will
* cause misbehaving functions to either produce incorrect output or segfault. Note that
* even though this works extremely well in practice, it's technically not guaranteed
* and false negatives is theoretically possible, but there can never be any false positives.
*/
void checkasm_stack_clobber(uint64_t clobber, ...);
#define declare_new(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__)\
= (void *)checkasm_checked_call;
#define declare_new_float(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__)\
= (void *)checkasm_checked_call_float;
#define declare_new_emms(cpu_flags, ret, ...) \
ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__) = \
((cpu_flags) & av_get_cpu_flags()) ? (void *)checkasm_checked_call_emms : \
(void *)checkasm_checked_call;
#define CLOB (UINT64_C(0xdeadbeefdeadbeef))
#define call_new(...) (checkasm_stack_clobber(CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,\
CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\
checked_call(func_new, 0, 0, 0, 0, 0, __VA_ARGS__))
#elif ARCH_X86_32
#define declare_new(ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = (void *)checkasm_checked_call;
#define declare_new_float(ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = (void *)checkasm_checked_call_float;
#define declare_new_emms(cpu_flags, ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = \
((cpu_flags) & av_get_cpu_flags()) ? (void *)checkasm_checked_call_emms : \
(void *)checkasm_checked_call;
#define call_new(...) checked_call(func_new, __VA_ARGS__)
#endif
#elif ARCH_ARM && HAVE_ARMV5TE_EXTERNAL
/* Use a dummy argument, to offset the real parameters by 2, not only 1.
* This makes sure that potential 8-byte-alignment of parameters is kept the same
* even when the extra parameters have been removed. */
void checkasm_checked_call_vfp(void *func, int dummy, ...);
void checkasm_checked_call_novfp(void *func, int dummy, ...);
extern void (*checkasm_checked_call)(void *func, int dummy, ...);
#define declare_new(ret, ...) ret (*checked_call)(void *, int dummy, __VA_ARGS__, \
int, int, int, int, int, int, int, int, \
int, int, int, int, int, int, int) = (void *)checkasm_checked_call;
#define call_new(...) checked_call(func_new, 0, __VA_ARGS__, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0)
#elif ARCH_AARCH64 && !defined(__APPLE__)
void checkasm_stack_clobber(uint64_t clobber, ...);
void checkasm_checked_call(void *func, ...);
#define declare_new(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, int, int, __VA_ARGS__,\
int, int, int, int, int, int, int, int,\
int, int, int, int, int, int, int)\
= (void *)checkasm_checked_call;
#define CLOB (UINT64_C(0xdeadbeefdeadbeef))
#define call_new(...) (checkasm_stack_clobber(CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,\
CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\
checked_call(func_new, 0, 0, 0, 0, 0, 0, 0, __VA_ARGS__,\
7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0))
#else
#define declare_new(ret, ...)
#define declare_new_float(ret, ...)
#define declare_new_emms(cpu_flags, ret, ...)
/* Call the function */
#define call_new(...) ((func_type *)func_new)(__VA_ARGS__)
#endif
#ifndef declare_new_emms
#define declare_new_emms(cpu_flags, ret, ...) declare_new(ret, __VA_ARGS__)
#endif
#ifndef declare_new_float
#define declare_new_float(ret, ...) declare_new(ret, __VA_ARGS__)
#endif
typedef struct CheckasmPerf {
int sysfd;
uint64_t cycles;
int iterations;
} CheckasmPerf;
#if defined(AV_READ_TIME) || CONFIG_LINUX_PERF
#if CONFIG_LINUX_PERF
#define PERF_START(t) do { \
ioctl(sysfd, PERF_EVENT_IOC_RESET, 0); \
ioctl(sysfd, PERF_EVENT_IOC_ENABLE, 0); \
} while (0)
#define PERF_STOP(t) do { \
ioctl(sysfd, PERF_EVENT_IOC_DISABLE, 0); \
read(sysfd, &t, sizeof(t)); \
} while (0)
#else
#define PERF_START(t) t = AV_READ_TIME()
#define PERF_STOP(t) t = AV_READ_TIME() - t
#endif
/* Benchmark the function */
#define bench_new(...)\
do {\
if (checkasm_bench_func()) {\
struct CheckasmPerf *perf = checkasm_get_perf_context();\
av_unused const int sysfd = perf->sysfd;\
func_type *tfunc = func_new;\
uint64_t tsum = 0;\
int ti, tcount = 0;\
uint64_t t = 0; \
for (ti = 0; ti < BENCH_RUNS; ti++) {\
PERF_START(t);\
tfunc(__VA_ARGS__);\
tfunc(__VA_ARGS__);\
tfunc(__VA_ARGS__);\
tfunc(__VA_ARGS__);\
PERF_STOP(t);\
if (t*tcount <= tsum*4 && ti > 0) {\
tsum += t;\
tcount++;\
}\
}\
emms_c();\
perf->cycles += t;\
perf->iterations++;\
}\
} while (0)
#else
#define bench_new(...) while(0)
#define PERF_START(t) while(0)
#define PERF_STOP(t) while(0)
#endif
#define DECL_CHECKASM_CHECK_FUNC(type) \
int checkasm_check_##type(const char *const file, const int line, \
const type *const buf1, const ptrdiff_t stride1, \
const type *const buf2, const ptrdiff_t stride2, \
const int w, const int h, const char *const name)
DECL_CHECKASM_CHECK_FUNC(uint8_t);
DECL_CHECKASM_CHECK_FUNC(uint16_t);
DECL_CHECKASM_CHECK_FUNC(int16_t);
DECL_CHECKASM_CHECK_FUNC(int32_t);
#define PASTE(a,b) a ## b
#define CONCAT(a,b) PASTE(a,b)
#define checkasm_check(prefix, ...) CONCAT(checkasm_check_, prefix)(__FILE__, __LINE__, __VA_ARGS__)
#endif /* TESTS_CHECKASM_CHECKASM_H */

91
externals/ffmpeg/tests/checkasm/exrdsp.c vendored
View File

@@ -1,91 +0,0 @@
/*
* Copyright (c) 2017 James Almer
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavcodec/avcodec.h"
#include "libavcodec/exrdsp.h"
#include "libavutil/intreadwrite.h"
#define BUF_SIZE 5120
#define PADDED_BUF_SIZE BUF_SIZE+AV_INPUT_BUFFER_PADDING_SIZE*2
#define randomize_buffers() \
do { \
int i; \
for (i = 0; i < BUF_SIZE; i += 4) { \
uint32_t r = rnd(); \
AV_WN32A(src + i, r); \
} \
} while (0)
static void check_reorder_pixels(void) {
LOCAL_ALIGNED_32(uint8_t, src, [PADDED_BUF_SIZE]);
LOCAL_ALIGNED_32(uint8_t, dst_ref, [PADDED_BUF_SIZE]);
LOCAL_ALIGNED_32(uint8_t, dst_new, [PADDED_BUF_SIZE]);
declare_func(void, uint8_t *dst, const uint8_t *src, ptrdiff_t size);
memset(src, 0, PADDED_BUF_SIZE);
memset(dst_ref, 0, PADDED_BUF_SIZE);
memset(dst_new, 0, PADDED_BUF_SIZE);
randomize_buffers();
call_ref(dst_ref, src, BUF_SIZE);
call_new(dst_new, src, BUF_SIZE);
if (memcmp(dst_ref, dst_new, BUF_SIZE))
fail();
bench_new(dst_new, src, BUF_SIZE);
}
static void check_predictor(void) {
LOCAL_ALIGNED_32(uint8_t, src, [PADDED_BUF_SIZE]);
LOCAL_ALIGNED_32(uint8_t, dst_ref, [PADDED_BUF_SIZE]);
LOCAL_ALIGNED_32(uint8_t, dst_new, [PADDED_BUF_SIZE]);
declare_func(void, uint8_t *src, ptrdiff_t size);
memset(src, 0, PADDED_BUF_SIZE);
randomize_buffers();
memcpy(dst_ref, src, PADDED_BUF_SIZE);
memcpy(dst_new, src, PADDED_BUF_SIZE);
call_ref(dst_ref, BUF_SIZE);
call_new(dst_new, BUF_SIZE);
if (memcmp(dst_ref, dst_new, BUF_SIZE))
fail();
bench_new(dst_new, BUF_SIZE);
}
void checkasm_check_exrdsp(void)
{
ExrDSPContext h;
ff_exrdsp_init(&h);
if (check_func(h.reorder_pixels, "reorder_pixels"))
check_reorder_pixels();
report("reorder_pixels");
if (check_func(h.predictor, "predictor"))
check_predictor();
report("predictor");
}

159
externals/ffmpeg/tests/checkasm/fixed_dsp.c vendored
View File

@@ -1,159 +0,0 @@
/*
* Copyright (c) 2015 James Almer
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "checkasm.h"
#include "libavutil/common.h"
#include "libavutil/fixed_dsp.h"
#include "libavutil/internal.h"
#include "libavutil/mem.h"
#define BUF_SIZE 256
#define randomize_buffers() \
do { \
int i; \
for (i = 0; i < BUF_SIZE; i++) { \
src0[i] = sign_extend(rnd(), 24); \
src1[i] = sign_extend(rnd(), 24); \
src2[i] = sign_extend(rnd(), 24); \
} \
} while (0)
static void check_vector_fmul(const int *src0, const int *src1)
{
LOCAL_ALIGNED_32(int, ref, [BUF_SIZE]);
LOCAL_ALIGNED_32(int, new, [BUF_SIZE]);
declare_func(void, int *dst, const int *src0, const int *src1, int len);
call_ref(ref, src0, src1, BUF_SIZE);
call_new(new, src0, src1, BUF_SIZE);
if (memcmp(ref, new, BUF_SIZE * sizeof(int)))
fail();
bench_new(new, src0, src1, BUF_SIZE);
}
static void check_vector_fmul_add(const int *src0, const int *src1, const int *src2)
{
LOCAL_ALIGNED_32(int, ref, [BUF_SIZE]);
LOCAL_ALIGNED_32(int, new, [BUF_SIZE]);
declare_func(void, int *dst, const int *src0, const int *src1, const int *src2, int len);
call_ref(ref, src0, src1, src2, BUF_SIZE);
call_new(new, src0, src1, src2, BUF_SIZE);
if (memcmp(ref, new, BUF_SIZE * sizeof(int)))
fail();
bench_new(new, src0, src1, src2, BUF_SIZE);
}
static void check_vector_fmul_window(const int32_t *src0, const int32_t *src1, const int32_t *win)
{
LOCAL_ALIGNED_32(int32_t, ref, [BUF_SIZE]);
LOCAL_ALIGNED_32(int32_t, new, [BUF_SIZE]);
declare_func(void, int32_t *dst, const int32_t *src0, const int32_t *src1, const int32_t *win, int len);
call_ref(ref, src0, src1, win, BUF_SIZE / 2);
call_new(new, src0, src1, win, BUF_SIZE / 2);
if (memcmp(ref, new, BUF_SIZE * sizeof(int32_t)))
fail();
bench_new(new, src0, src1, win, BUF_SIZE / 2);
}
static void check_vector_fmul_window_scaled(const int32_t *src0, const int32_t *src1, const int32_t *win)
{
LOCAL_ALIGNED_16(int16_t, ref, [BUF_SIZE]);
LOCAL_ALIGNED_16(int16_t, new, [BUF_SIZE]);
declare_func(void, int16_t *dst, const int32_t *src0, const int32_t *src1, const int32_t *win, int len, uint8_t bits);
call_ref(ref, src0, src1, win, BUF_SIZE / 2, 2);
call_new(new, src0, src1, win, BUF_SIZE / 2, 2);
if (memcmp(ref, new, BUF_SIZE * sizeof(int16_t)))
fail();
bench_new(new, src0, src1, win, BUF_SIZE / 2, 2);
}
static void check_butterflies(const int *src0, const int *src1)
{
LOCAL_ALIGNED_16(int, ref0, [BUF_SIZE]);
LOCAL_ALIGNED_16(int, ref1, [BUF_SIZE]);
LOCAL_ALIGNED_16(int, new0, [BUF_SIZE]);
LOCAL_ALIGNED_16(int, new1, [BUF_SIZE]);
declare_func(void, int *av_restrict src0, int *av_restrict src1, int len);
memcpy(ref0, src0, BUF_SIZE * sizeof(*src0));
memcpy(ref1, src1, BUF_SIZE * sizeof(*src1));
memcpy(new0, src0, BUF_SIZE * sizeof(*src0));
memcpy(new1, src1, BUF_SIZE * sizeof(*src1));
call_ref(ref0, ref1, BUF_SIZE);
call_new(new0, new1, BUF_SIZE);
if (memcmp(ref0, new0, BUF_SIZE * sizeof(*ref0)) ||
memcmp(ref1, new1, BUF_SIZE * sizeof(*ref1)))
fail();
memcpy(new0, src0, BUF_SIZE * sizeof(*src0));
memcpy(new1, src1, BUF_SIZE * sizeof(*src1));
bench_new(new0, new1, BUF_SIZE);
}
static void check_scalarproduct_fixed(const int *src0, const int *src1)
{
int ref, new;
declare_func(int, const int *src0, const int *src1, int len);
ref = call_ref(src0, src1, BUF_SIZE);
new = call_new(src0, src1, BUF_SIZE);
if (ref != new)
fail();
bench_new(src0, src1, BUF_SIZE);
}
void checkasm_check_fixed_dsp(void)
{
LOCAL_ALIGNED_32(int32_t, src0, [BUF_SIZE]);
LOCAL_ALIGNED_32(int32_t, src1, [BUF_SIZE]);
LOCAL_ALIGNED_32(int32_t, src2, [BUF_SIZE]);
AVFixedDSPContext *fdsp = avpriv_alloc_fixed_dsp(1);
randomize_buffers();
if (check_func(fdsp->vector_fmul, "vector_fmul_fixed"))
check_vector_fmul(src0, src1);
if (check_func(fdsp->vector_fmul_add, "vector_fmul_add_fixed"))
check_vector_fmul_add(src0, src1, src2);
if (check_func(fdsp->vector_fmul_reverse, "vector_fmul_reverse_fixed"))
check_vector_fmul(src0, src1);
if (check_func(fdsp->vector_fmul_window, "vector_fmul_window_fixed"))
check_vector_fmul_window(src0, src1, src2);
if (check_func(fdsp->vector_fmul_window_scaled, "vector_fmul_window_scaled_fixed"))
check_vector_fmul_window_scaled(src0, src1, src2);
report("vector_fmul");
if (check_func(fdsp->butterflies_fixed, "butterflies_fixed"))
check_butterflies(src0, src1);
report("butterflies_fixed");
if (check_func(fdsp->scalarproduct_fixed, "scalarproduct_fixed"))
check_scalarproduct_fixed(src0, src1);
report("scalarproduct_fixed");
av_freep(&fdsp);
}

90
externals/ffmpeg/tests/checkasm/flacdsp.c vendored
View File

@@ -1,90 +0,0 @@
/*
* Copyright (c) 2015 James Almer
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavcodec/flacdsp.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/intreadwrite.h"
#define BUF_SIZE 256
#define MAX_CHANNELS 8
#define randomize_buffers() \
do { \
int i, j; \
for (i = 0; i < BUF_SIZE; i += 4) { \
for (j = 0; j < channels; j++) { \
uint32_t r = rnd() & (1 << (bits - 2)) - 1; \
AV_WN32A(ref_src[j] + i, r); \
AV_WN32A(new_src[j] + i, r); \
} \
} \
} while (0)
static void check_decorrelate(uint8_t **ref_dst, uint8_t **ref_src, uint8_t **new_dst, uint8_t **new_src,
int channels, int bits) {
declare_func(void, uint8_t **out, int32_t **in, int channels, int len, int shift);
randomize_buffers();
call_ref(ref_dst, (int32_t **)ref_src, channels, BUF_SIZE / sizeof(int32_t), 8);
call_new(new_dst, (int32_t **)new_src, channels, BUF_SIZE / sizeof(int32_t), 8);
if (memcmp(*ref_dst, *new_dst, bits == 16 ? BUF_SIZE * (channels/2) : BUF_SIZE * channels) ||
memcmp(*ref_src, *new_src, BUF_SIZE * channels))
fail();
bench_new(new_dst, (int32_t **)new_src, channels, BUF_SIZE / sizeof(int32_t), 8);
}
void checkasm_check_flacdsp(void)
{
LOCAL_ALIGNED_16(uint8_t, ref_dst, [BUF_SIZE*MAX_CHANNELS]);
LOCAL_ALIGNED_16(uint8_t, ref_buf, [BUF_SIZE*MAX_CHANNELS]);
LOCAL_ALIGNED_16(uint8_t, new_dst, [BUF_SIZE*MAX_CHANNELS]);
LOCAL_ALIGNED_16(uint8_t, new_buf, [BUF_SIZE*MAX_CHANNELS]);
uint8_t *ref_src[] = { &ref_buf[BUF_SIZE*0], &ref_buf[BUF_SIZE*1], &ref_buf[BUF_SIZE*2], &ref_buf[BUF_SIZE*3],
&ref_buf[BUF_SIZE*4], &ref_buf[BUF_SIZE*5], &ref_buf[BUF_SIZE*6], &ref_buf[BUF_SIZE*7] };
uint8_t *new_src[] = { &new_buf[BUF_SIZE*0], &new_buf[BUF_SIZE*1], &new_buf[BUF_SIZE*2], &new_buf[BUF_SIZE*3],
&new_buf[BUF_SIZE*4], &new_buf[BUF_SIZE*5], &new_buf[BUF_SIZE*6], &new_buf[BUF_SIZE*7] };
static const char * const names[3] = { "ls", "rs", "ms" };
static const struct {
enum AVSampleFormat fmt;
int bits;
} fmts[] = {
{ AV_SAMPLE_FMT_S16, 16 },
{ AV_SAMPLE_FMT_S32, 32 },
};
FLACDSPContext h;
int i, j;
for (i = 0; i < 2; i++) {
ff_flacdsp_init(&h, fmts[i].fmt, 2, 0);
for (j = 0; j < 3; j++)
if (check_func(h.decorrelate[j], "flac_decorrelate_%s_%d", names[j], fmts[i].bits))
check_decorrelate(&ref_dst, ref_src, &new_dst, new_src, 2, fmts[i].bits);
for (j = 2; j <= MAX_CHANNELS; j += 2) {
ff_flacdsp_init(&h, fmts[i].fmt, j, 0);
if (check_func(h.decorrelate[0], "flac_decorrelate_indep%d_%d", j, fmts[i].bits))
check_decorrelate(&ref_dst, ref_src, &new_dst, new_src, j, fmts[i].bits);
}
}
report("decorrelate");
}

338
externals/ffmpeg/tests/checkasm/float_dsp.c vendored
View File

@@ -1,338 +0,0 @@
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include <float.h>
#include <stdint.h>
#include "libavutil/float_dsp.h"
#include "libavutil/internal.h"
#include "checkasm.h"
#define LEN 256
#define randomize_buffer(buf) \
do { \
int i; \
double bmg[2], stddev = 10.0, mean = 0.0; \
\
for (i = 0; i < LEN; i += 2) { \
av_bmg_get(&checkasm_lfg, bmg); \
buf[i] = bmg[0] * stddev + mean; \
buf[i + 1] = bmg[1] * stddev + mean; \
} \
} while(0);
static void test_vector_fmul(const float *src0, const float *src1)
{
LOCAL_ALIGNED_32(float, cdst, [LEN]);
LOCAL_ALIGNED_32(float, odst, [LEN]);
int i;
declare_func(void, float *dst, const float *src0, const float *src1,
int len);
call_ref(cdst, src0, src1, LEN);
call_new(odst, src0, src1, LEN);
for (i = 0; i < LEN; i++) {
double t = fabs(src0[i]) + fabs(src1[i]) + fabs(src0[i] * src1[i]) + 1.0;
if (!float_near_abs_eps(cdst[i], odst[i], t * 2 * FLT_EPSILON)) {
fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
i, cdst[i], odst[i], cdst[i] - odst[i]);
fail();
break;
}
}
bench_new(odst, src0, src1, LEN);
}
static void test_vector_dmul(const double *src0, const double *src1)
{
LOCAL_ALIGNED_32(double, cdst, [LEN]);
LOCAL_ALIGNED_32(double, odst, [LEN]);
int i;
declare_func(void, double *dst, const double *src0, const double *src1,
int len);
call_ref(cdst, src0, src1, LEN);
call_new(odst, src0, src1, LEN);
for (i = 0; i < LEN; i++) {
double t = fabs(src0[i]) + fabs(src1[i]) + fabs(src0[i] * src1[i]) + 1.0;
if (!double_near_abs_eps(cdst[i], odst[i], t * 2 * DBL_EPSILON)) {
fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
i, cdst[i], odst[i], cdst[i] - odst[i]);
fail();
break;
}
}
bench_new(odst, src0, src1, LEN);
}
#define ARBITRARY_FMUL_ADD_CONST 0.005
static void test_vector_fmul_add(const float *src0, const float *src1, const float *src2)
{
LOCAL_ALIGNED_32(float, cdst, [LEN]);
LOCAL_ALIGNED_32(float, odst, [LEN]);
int i;
declare_func(void, float *dst, const float *src0, const float *src1,
const float *src2, int len);
call_ref(cdst, src0, src1, src2, LEN);
call_new(odst, src0, src1, src2, LEN);
for (i = 0; i < LEN; i++) {
if (!float_near_abs_eps(cdst[i], odst[i], ARBITRARY_FMUL_ADD_CONST)) {
fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
i, cdst[i], odst[i], cdst[i] - odst[i]);
fail();
break;
}
}
bench_new(odst, src0, src1, src2, LEN);
}
static void test_vector_fmul_scalar(const float *src0, const float *src1)
{
LOCAL_ALIGNED_16(float, cdst, [LEN]);
LOCAL_ALIGNED_16(float, odst, [LEN]);
int i;
declare_func(void, float *dst, const float *src, float mul, int len);
call_ref(cdst, src0, src1[0], LEN);
call_new(odst, src0, src1[0], LEN);
for (i = 0; i < LEN; i++) {
double t = fabs(src0[i]) + fabs(src1[0]) + fabs(src0[i] * src1[0]) + 1.0;
if (!float_near_abs_eps(cdst[i], odst[i], t * 2 * FLT_EPSILON)) {
fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
i, cdst[i], odst[i], cdst[i] - odst[i]);
fail();
break;
}
}
bench_new(odst, src0, src1[0], LEN);
}
#define ARBITRARY_FMUL_WINDOW_CONST 0.008
static void test_vector_fmul_window(const float *src0, const float *src1, const float *win)
{
LOCAL_ALIGNED_16(float, cdst, [LEN]);
LOCAL_ALIGNED_16(float, odst, [LEN]);
int i;
declare_func(void, float *dst, const float *src0, const float *src1,
const float *win, int len);
call_ref(cdst, src0, src1, win, LEN / 2);
call_new(odst, src0, src1, win, LEN / 2);
for (i = 0; i < LEN; i++) {
if (!float_near_abs_eps(cdst[i], odst[i], ARBITRARY_FMUL_WINDOW_CONST)) {
fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
i, cdst[i], odst[i], cdst[i] - odst[i]);
fail();
break;
}
}
bench_new(odst, src0, src1, win, LEN / 2);
}
#define ARBITRARY_FMAC_SCALAR_CONST 0.005
static void test_vector_fmac_scalar(const float *src0, const float *src1, const float *src2)
{
LOCAL_ALIGNED_32(float, cdst, [LEN]);
LOCAL_ALIGNED_32(float, odst, [LEN]);
int i;
declare_func(void, float *dst, const float *src, float mul, int len);
memcpy(cdst, src2, LEN * sizeof(*src2));
memcpy(odst, src2, LEN * sizeof(*src2));
call_ref(cdst, src0, src1[0], LEN);
call_new(odst, src0, src1[0], LEN);
for (i = 0; i < LEN; i++) {
if (!float_near_abs_eps(cdst[i], odst[i], ARBITRARY_FMAC_SCALAR_CONST)) {
fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
i, cdst[i], odst[i], cdst[i] - odst[i]);
fail();
break;
}
}
memcpy(odst, src2, LEN * sizeof(*src2));
bench_new(odst, src0, src1[0], LEN);
}
static void test_vector_dmul_scalar(const double *src0, const double *src1)
{
LOCAL_ALIGNED_32(double, cdst, [LEN]);
LOCAL_ALIGNED_32(double, odst, [LEN]);
int i;
declare_func(void, double *dst, const double *src, double mul, int len);
call_ref(cdst, src0, src1[0], LEN);
call_new(odst, src0, src1[0], LEN);
for (i = 0; i < LEN; i++) {
double t = fabs(src1[0]) + fabs(src0[i]) + fabs(src1[0] * src0[i]) + 1.0;
if (!double_near_abs_eps(cdst[i], odst[i], t * 2 * DBL_EPSILON)) {
fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n", i,
cdst[i], odst[i], cdst[i] - odst[i]);
fail();
break;
}
}
bench_new(odst, src0, src1[0], LEN);
}
#define ARBITRARY_DMAC_SCALAR_CONST 0.005
static void test_vector_dmac_scalar(const double *src0, const double *src1, const double *src2)
{
LOCAL_ALIGNED_32(double, cdst, [LEN]);
LOCAL_ALIGNED_32(double, odst, [LEN]);
int i;
declare_func(void, double *dst, const double *src, double mul, int len);
memcpy(cdst, src2, LEN * sizeof(*src2));
memcpy(odst, src2, LEN * sizeof(*src2));
call_ref(cdst, src0, src1[0], LEN);
call_new(odst, src0, src1[0], LEN);
for (i = 0; i < LEN; i++) {
if (!double_near_abs_eps(cdst[i], odst[i], ARBITRARY_DMAC_SCALAR_CONST)) {
fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
i, cdst[i], odst[i], cdst[i] - odst[i]);
fail();
break;
}
}
memcpy(odst, src2, LEN * sizeof(*src2));
bench_new(odst, src0, src1[0], LEN);
}
static void test_butterflies_float(const float *src0, const float *src1)
{
LOCAL_ALIGNED_16(float, cdst, [LEN]);
LOCAL_ALIGNED_16(float, odst, [LEN]);
LOCAL_ALIGNED_16(float, cdst1, [LEN]);
LOCAL_ALIGNED_16(float, odst1, [LEN]);
int i;
declare_func(void, float *av_restrict src0, float *av_restrict src1,
int len);
memcpy(cdst, src0, LEN * sizeof(*src0));
memcpy(cdst1, src1, LEN * sizeof(*src1));
memcpy(odst, src0, LEN * sizeof(*src0));
memcpy(odst1, src1, LEN * sizeof(*src1));
call_ref(cdst, cdst1, LEN);
call_new(odst, odst1, LEN);
for (i = 0; i < LEN; i++) {
if (!float_near_abs_eps(cdst[i], odst[i], FLT_EPSILON) ||
!float_near_abs_eps(cdst1[i], odst1[i], FLT_EPSILON)) {
fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
i, cdst[i], odst[i], cdst[i] - odst[i]);
fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
i, cdst1[i], odst1[i], cdst1[i] - odst1[i]);
fail();
break;
}
}
memcpy(odst, src0, LEN * sizeof(*src0));
memcpy(odst1, src1, LEN * sizeof(*src1));
bench_new(odst, odst1, LEN);
}
#define ARBITRARY_SCALARPRODUCT_CONST 0.2
static void test_scalarproduct_float(const float *src0, const float *src1)
{
float cprod, oprod;
declare_func_float(float, const float *src0, const float *src1, int len);
cprod = call_ref(src0, src1, LEN);
oprod = call_new(src0, src1, LEN);
if (!float_near_abs_eps(cprod, oprod, ARBITRARY_SCALARPRODUCT_CONST)) {
fprintf(stderr, "%- .12f - %- .12f = % .12g\n",
cprod, oprod, cprod - oprod);
fail();
}
bench_new(src0, src1, LEN);
}
void checkasm_check_float_dsp(void)
{
LOCAL_ALIGNED_32(float, src0, [LEN]);
LOCAL_ALIGNED_32(float, src1, [LEN]);
LOCAL_ALIGNED_32(float, src2, [LEN]);
LOCAL_ALIGNED_16(float, src3, [LEN]);
LOCAL_ALIGNED_16(float, src4, [LEN]);
LOCAL_ALIGNED_16(float, src5, [LEN]);
LOCAL_ALIGNED_32(double, dbl_src0, [LEN]);
LOCAL_ALIGNED_32(double, dbl_src1, [LEN]);
LOCAL_ALIGNED_32(double, dbl_src2, [LEN]);
AVFloatDSPContext *fdsp = avpriv_float_dsp_alloc(1);
if (!fdsp) {
fprintf(stderr, "floatdsp: Out of memory error\n");
return;
}
randomize_buffer(src0);
randomize_buffer(src1);
randomize_buffer(src2);
randomize_buffer(src3);
randomize_buffer(src4);
randomize_buffer(src5);
randomize_buffer(dbl_src0);
randomize_buffer(dbl_src1);
randomize_buffer(dbl_src2);
if (check_func(fdsp->vector_fmul, "vector_fmul"))
test_vector_fmul(src0, src1);
if (check_func(fdsp->vector_fmul_add, "vector_fmul_add"))
test_vector_fmul_add(src0, src1, src2);
if (check_func(fdsp->vector_fmul_scalar, "vector_fmul_scalar"))
test_vector_fmul_scalar(src3, src4);
if (check_func(fdsp->vector_fmul_reverse, "vector_fmul_reverse"))
test_vector_fmul(src0, src1);
if (check_func(fdsp->vector_fmul_window, "vector_fmul_window"))
test_vector_fmul_window(src3, src4, src5);
report("vector_fmul");
if (check_func(fdsp->vector_fmac_scalar, "vector_fmac_scalar"))
test_vector_fmac_scalar(src0, src1, src2);
report("vector_fmac");
if (check_func(fdsp->vector_dmul, "vector_dmul"))
test_vector_dmul(dbl_src0, dbl_src1);
if (check_func(fdsp->vector_dmul_scalar, "vector_dmul_scalar"))
test_vector_dmul_scalar(dbl_src0, dbl_src1);
report("vector_dmul");
if (check_func(fdsp->vector_dmac_scalar, "vector_dmac_scalar"))
test_vector_dmac_scalar(dbl_src0, dbl_src1, dbl_src2);
report("vector_dmac");
if (check_func(fdsp->butterflies_float, "butterflies_float"))
test_butterflies_float(src3, src4);
report("butterflies_float");
if (check_func(fdsp->scalarproduct_float, "scalarproduct_float"))
test_scalarproduct_float(src3, src4);
report("scalarproduct_float");
av_freep(&fdsp);
}

105
externals/ffmpeg/tests/checkasm/fmtconvert.c vendored
View File

@@ -1,105 +0,0 @@
/*
* Copyright (c) 2015 Janne Grunau
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <math.h>
#include <stdint.h>
#include <string.h>
#include "libavutil/internal.h"
#include "libavutil/common.h"
#include "libavcodec/fmtconvert.h"
#include "checkasm.h"
#define BUF_SIZE 1024
#define randomize_input(len) \
do { \
int k; \
for (k = 0; k < len; k++) { \
in[k] = rnd() - INT32_MAX; \
} \
for ( ; k < BUF_SIZE; k++) { \
in[k] = INT32_MAX; \
} \
} while (0)
void checkasm_check_fmtconvert(void)
{
FmtConvertContext c;
LOCAL_ALIGNED(32, float, dst0, [BUF_SIZE]);
LOCAL_ALIGNED(32, float, dst1, [BUF_SIZE]);
LOCAL_ALIGNED(32, int32_t, in, [BUF_SIZE]);
float scale_arr[128];
int length[] = {8, 16, 24, 56, 72, 128, 512, 520, 656, 768, 992};
int i, j;
for (i = 0; i < FF_ARRAY_ELEMS(scale_arr); i++)
scale_arr[i] = (FF_ARRAY_ELEMS(scale_arr) - FF_ARRAY_ELEMS(scale_arr) / 2) / 13;
ff_fmt_convert_init(&c, NULL);
memset(dst0, 0, sizeof(*dst0) * BUF_SIZE);
memset(dst1, 0, sizeof(*dst1) * BUF_SIZE);
if (check_func(c.int32_to_float_fmul_scalar, "int32_to_float_fmul_scalar")) {
declare_func(void, float *, const int32_t *, float, int);
for (i = 0; i < FF_ARRAY_ELEMS(scale_arr); i++) {
for (j = 0; j < FF_ARRAY_ELEMS(length); j++) {
randomize_input(length[j]);
call_ref(dst0, in, scale_arr[i], length[j]);
call_new(dst1, in, scale_arr[i], length[j]);
if (!float_near_ulp_array(dst0, dst1, 3, length[j])) {
fail();
break;
}
bench_new(dst1, in, scale_arr[i], length[j]);
}
}
}
if (check_func(c.int32_to_float_fmul_array8, "int32_to_float_fmul_array8")) {
declare_func(void, FmtConvertContext *, float *, const int32_t *,
const float *, int);
for (i = 0; i < 4; i++) {
for (j = 0; j < FF_ARRAY_ELEMS(length); j++) {
randomize_input(length[j]);
call_ref(&c, dst0, in, scale_arr, length[j]);
call_new(&c, dst1, in, scale_arr, length[j]);
if (!float_near_ulp_array(dst0, dst1, 3, length[j])) {
fail();
fprintf(stderr, "int32_to_float_fmul_array8: len: %d\n", length[j]);
break;
}
bench_new(&c, dst1, in, scale_arr, length[j]);
}
}
}
report("fmtconvert");
}

63
externals/ffmpeg/tests/checkasm/g722dsp.c vendored
View File

@@ -1,63 +0,0 @@
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavcodec/g722.h"
#include "libavcodec/g722dsp.h"
#include "libavcodec/mathops.h"
#define randomize_buffers() \
do { \
int i; \
for (i = 0; i < PREV_SAMPLES_BUF_SIZE; i++) { \
src0[i] = src1[i] = sign_extend(rnd(), 16); \
} \
} while (0)
static void check_qmf(void) {
int16_t src0[PREV_SAMPLES_BUF_SIZE];
int16_t src1[PREV_SAMPLES_BUF_SIZE];
const int16_t *tmp0 = src0;
const int16_t *tmp1 = src1;
int dst0[2], dst1[2];
int i;
declare_func(void, const int16_t *prev_samples, int xout[2]);
randomize_buffers();
for (i = 0; i < PREV_SAMPLES_BUF_SIZE - 24; i++) {
call_ref(tmp0++, dst0);
call_new(tmp1++, dst1);
if (memcmp(dst0, dst1, sizeof(dst0)))
fail();
}
bench_new(src1, dst1);
}
void checkasm_check_g722dsp(void)
{
G722DSPContext h;
ff_g722dsp_init(&h);
if (check_func(h.apply_qmf, "g722_apply_qmf"))
check_qmf();
report("apply_qmf");
}

452
externals/ffmpeg/tests/checkasm/h264dsp.c vendored
View File

@@ -1,452 +0,0 @@
/*
* Copyright (c) 2016 Martin Storsjo
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavcodec/avcodec.h"
#include "libavcodec/h264dsp.h"
#include "libavcodec/h264data.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/intreadwrite.h"
static const uint32_t pixel_mask[3] = { 0xffffffff, 0x01ff01ff, 0x03ff03ff };
static const uint32_t pixel_mask_lf[3] = { 0xff0fff0f, 0x01ff000f, 0x03ff000f };
#define SIZEOF_PIXEL ((bit_depth + 7) / 8)
#define SIZEOF_COEF (2 * ((bit_depth + 7) / 8))
#define PIXEL_STRIDE 16
#define randomize_buffers() \
do { \
int x, y; \
uint32_t mask = pixel_mask[bit_depth - 8]; \
for (y = 0; y < sz; y++) { \
for (x = 0; x < PIXEL_STRIDE; x += 4) { \
AV_WN32A(src + y * PIXEL_STRIDE + x, rnd() & mask); \
AV_WN32A(dst + y * PIXEL_STRIDE + x, rnd() & mask); \
} \
for (x = 0; x < sz; x++) { \
if (bit_depth == 8) { \
coef[y * sz + x] = src[y * PIXEL_STRIDE + x] - \
dst[y * PIXEL_STRIDE + x]; \
} else { \
((int32_t *)coef)[y * sz + x] = \
((uint16_t *)src)[y * (PIXEL_STRIDE/2) + x] - \
((uint16_t *)dst)[y * (PIXEL_STRIDE/2) + x]; \
} \
} \
} \
} while (0)
#define dct4x4_impl(size, dctcoef) \
static void dct4x4_##size(dctcoef *coef) \
{ \
int i, y, x; \
dctcoef tmp[16]; \
for (i = 0; i < 4; i++) { \
const int z0 = coef[i*4 + 0] + coef[i*4 + 3]; \
const int z1 = coef[i*4 + 1] + coef[i*4 + 2]; \
const int z2 = coef[i*4 + 0] - coef[i*4 + 3]; \
const int z3 = coef[i*4 + 1] - coef[i*4 + 2]; \
tmp[i + 4*0] = z0 + z1; \
tmp[i + 4*1] = 2*z2 + z3; \
tmp[i + 4*2] = z0 - z1; \
tmp[i + 4*3] = z2 - 2*z3; \
} \
for (i = 0; i < 4; i++) { \
const int z0 = tmp[i*4 + 0] + tmp[i*4 + 3]; \
const int z1 = tmp[i*4 + 1] + tmp[i*4 + 2]; \
const int z2 = tmp[i*4 + 0] - tmp[i*4 + 3]; \
const int z3 = tmp[i*4 + 1] - tmp[i*4 + 2]; \
coef[i*4 + 0] = z0 + z1; \
coef[i*4 + 1] = 2*z2 + z3; \
coef[i*4 + 2] = z0 - z1; \
coef[i*4 + 3] = z2 - 2*z3; \
} \
for (y = 0; y < 4; y++) { \
for (x = 0; x < 4; x++) { \
static const int scale[] = { 13107 * 10, 8066 * 13, 5243 * 16 }; \
const int idx = (y & 1) + (x & 1); \
coef[y*4 + x] = (coef[y*4 + x] * scale[idx] + (1 << 14)) >> 15; \
} \
} \
}
#define DCT8_1D(src, srcstride, dst, dststride) do { \
const int a0 = (src)[srcstride * 0] + (src)[srcstride * 7]; \
const int a1 = (src)[srcstride * 0] - (src)[srcstride * 7]; \
const int a2 = (src)[srcstride * 1] + (src)[srcstride * 6]; \
const int a3 = (src)[srcstride * 1] - (src)[srcstride * 6]; \
const int a4 = (src)[srcstride * 2] + (src)[srcstride * 5]; \
const int a5 = (src)[srcstride * 2] - (src)[srcstride * 5]; \
const int a6 = (src)[srcstride * 3] + (src)[srcstride * 4]; \
const int a7 = (src)[srcstride * 3] - (src)[srcstride * 4]; \
const int b0 = a0 + a6; \
const int b1 = a2 + a4; \
const int b2 = a0 - a6; \
const int b3 = a2 - a4; \
const int b4 = a3 + a5 + (a1 + (a1 >> 1)); \
const int b5 = a1 - a7 - (a5 + (a5 >> 1)); \
const int b6 = a1 + a7 - (a3 + (a3 >> 1)); \
const int b7 = a3 - a5 + (a7 + (a7 >> 1)); \
(dst)[dststride * 0] = b0 + b1; \
(dst)[dststride * 1] = b4 + (b7 >> 2); \
(dst)[dststride * 2] = b2 + (b3 >> 1); \
(dst)[dststride * 3] = b5 + (b6 >> 2); \
(dst)[dststride * 4] = b0 - b1; \
(dst)[dststride * 5] = b6 - (b5 >> 2); \
(dst)[dststride * 6] = (b2 >> 1) - b3; \
(dst)[dststride * 7] = (b4 >> 2) - b7; \
} while (0)
#define dct8x8_impl(size, dctcoef) \
static void dct8x8_##size(dctcoef *coef) \
{ \
int i, x, y; \
dctcoef tmp[64]; \
for (i = 0; i < 8; i++) \
DCT8_1D(coef + i, 8, tmp + i, 8); \
\
for (i = 0; i < 8; i++) \
DCT8_1D(tmp + 8*i, 1, coef + i, 8); \
\
for (y = 0; y < 8; y++) { \
for (x = 0; x < 8; x++) { \
static const int scale[] = { \
13107 * 20, 11428 * 18, 20972 * 32, \
12222 * 19, 16777 * 25, 15481 * 24, \
}; \
static const int idxmap[] = { \
0, 3, 4, 3, \
3, 1, 5, 1, \
4, 5, 2, 5, \
3, 1, 5, 1, \
}; \
const int idx = idxmap[(y & 3) * 4 + (x & 3)]; \
coef[y*8 + x] = ((int64_t)coef[y*8 + x] * \
scale[idx] + (1 << 17)) >> 18; \
} \
} \
}
dct4x4_impl(16, int16_t)
dct4x4_impl(32, int32_t)
dct8x8_impl(16, int16_t)
dct8x8_impl(32, int32_t)
static void dct4x4(int16_t *coef, int bit_depth)
{
if (bit_depth == 8)
dct4x4_16(coef);
else
dct4x4_32((int32_t *) coef);
}
static void dct8x8(int16_t *coef, int bit_depth)
{
if (bit_depth == 8) {
dct8x8_16(coef);
} else {
dct8x8_32((int32_t *) coef);
}
}
static void check_idct(void)
{
LOCAL_ALIGNED_16(uint8_t, src, [8 * 8 * 2]);
LOCAL_ALIGNED_16(uint8_t, dst, [8 * 8 * 2]);
LOCAL_ALIGNED_16(uint8_t, dst0, [8 * 8 * 2]);
LOCAL_ALIGNED_16(uint8_t, dst1_base, [8 * 8 * 2 + 32]);
LOCAL_ALIGNED_16(int16_t, coef, [8 * 8 * 2]);
LOCAL_ALIGNED_16(int16_t, subcoef0, [8 * 8 * 2]);
LOCAL_ALIGNED_16(int16_t, subcoef1, [8 * 8 * 2]);
H264DSPContext h;
int bit_depth, sz, align, dc;
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, int16_t *block, int stride);
for (bit_depth = 8; bit_depth <= 10; bit_depth++) {
ff_h264dsp_init(&h, bit_depth, 1);
for (sz = 4; sz <= 8; sz += 4) {
randomize_buffers();
if (sz == 4)
dct4x4(coef, bit_depth);
else
dct8x8(coef, bit_depth);
for (dc = 0; dc <= 1; dc++) {
void (*idct)(uint8_t *, int16_t *, int) = NULL;
switch ((sz << 1) | dc) {
case (4 << 1) | 0: idct = h.h264_idct_add; break;
case (4 << 1) | 1: idct = h.h264_idct_dc_add; break;
case (8 << 1) | 0: idct = h.h264_idct8_add; break;
case (8 << 1) | 1: idct = h.h264_idct8_dc_add; break;
}
if (check_func(idct, "h264_idct%d_add%s_%dbpp", sz, dc ? "_dc" : "", bit_depth)) {
for (align = 0; align < 16; align += sz * SIZEOF_PIXEL) {
uint8_t *dst1 = dst1_base + align;
if (dc) {
memset(subcoef0, 0, sz * sz * SIZEOF_COEF);
memcpy(subcoef0, coef, SIZEOF_COEF);
} else {
memcpy(subcoef0, coef, sz * sz * SIZEOF_COEF);
}
memcpy(dst0, dst, sz * PIXEL_STRIDE);
memcpy(dst1, dst, sz * PIXEL_STRIDE);
memcpy(subcoef1, subcoef0, sz * sz * SIZEOF_COEF);
call_ref(dst0, subcoef0, PIXEL_STRIDE);
call_new(dst1, subcoef1, PIXEL_STRIDE);
if (memcmp(dst0, dst1, sz * PIXEL_STRIDE) ||
memcmp(subcoef0, subcoef1, sz * sz * SIZEOF_COEF))
fail();
bench_new(dst1, subcoef1, sz * SIZEOF_PIXEL);
}
}
}
}
}
}
static void check_idct_multiple(void)
{
LOCAL_ALIGNED_16(uint8_t, dst_full, [16 * 16 * 2]);
LOCAL_ALIGNED_16(int16_t, coef_full, [16 * 16 * 2]);
LOCAL_ALIGNED_16(uint8_t, dst0, [16 * 16 * 2]);
LOCAL_ALIGNED_16(uint8_t, dst1, [16 * 16 * 2]);
LOCAL_ALIGNED_16(int16_t, coef0, [16 * 16 * 2]);
LOCAL_ALIGNED_16(int16_t, coef1, [16 * 16 * 2]);
LOCAL_ALIGNED_16(uint8_t, nnzc, [15 * 8]);
H264DSPContext h;
int bit_depth, i, y, func;
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, const int *block_offset, int16_t *block, int stride, const uint8_t nnzc[15*8]);
for (bit_depth = 8; bit_depth <= 10; bit_depth++) {
ff_h264dsp_init(&h, bit_depth, 1);
for (func = 0; func < 3; func++) {
void (*idct)(uint8_t *, const int *, int16_t *, int, const uint8_t[]) = NULL;
const char *name;
int sz = 4, intra = 0;
int block_offset[16] = { 0 };
switch (func) {
case 0:
idct = h.h264_idct_add16;
name = "h264_idct_add16";
break;
case 1:
idct = h.h264_idct_add16intra;
name = "h264_idct_add16intra";
intra = 1;
break;
case 2:
idct = h.h264_idct8_add4;
name = "h264_idct8_add4";
sz = 8;
break;
}
memset(nnzc, 0, 15 * 8);
memset(coef_full, 0, 16 * 16 * SIZEOF_COEF);
for (i = 0; i < 16 * 16; i += sz * sz) {
uint8_t src[8 * 8 * 2];
uint8_t dst[8 * 8 * 2];
int16_t coef[8 * 8 * 2];
int index = i / sz;
int block_y = (index / 16) * sz;
int block_x = index % 16;
int offset = (block_y * 16 + block_x) * SIZEOF_PIXEL;
int nnz = rnd() % 3;
randomize_buffers();
if (sz == 4)
dct4x4(coef, bit_depth);
else
dct8x8(coef, bit_depth);
for (y = 0; y < sz; y++)
memcpy(&dst_full[offset + y * 16 * SIZEOF_PIXEL],
&dst[PIXEL_STRIDE * y], sz * SIZEOF_PIXEL);
if (nnz > 1)
nnz = sz * sz;
memcpy(&coef_full[i * SIZEOF_COEF/sizeof(coef[0])],
coef, nnz * SIZEOF_COEF);
if (intra && nnz == 1)
nnz = 0;
nnzc[scan8[i / 16]] = nnz;
block_offset[i / 16] = offset;
}
if (check_func(idct, "%s_%dbpp", name, bit_depth)) {
memcpy(coef0, coef_full, 16 * 16 * SIZEOF_COEF);
memcpy(coef1, coef_full, 16 * 16 * SIZEOF_COEF);
memcpy(dst0, dst_full, 16 * 16 * SIZEOF_PIXEL);
memcpy(dst1, dst_full, 16 * 16 * SIZEOF_PIXEL);
call_ref(dst0, block_offset, coef0, 16 * SIZEOF_PIXEL, nnzc);
call_new(dst1, block_offset, coef1, 16 * SIZEOF_PIXEL, nnzc);
if (memcmp(dst0, dst1, 16 * 16 * SIZEOF_PIXEL) ||
memcmp(coef0, coef1, 16 * 16 * SIZEOF_COEF))
fail();
bench_new(dst1, block_offset, coef1, 16 * SIZEOF_PIXEL, nnzc);
}
}
}
}
static void check_loop_filter(void)
{
LOCAL_ALIGNED_16(uint8_t, dst, [32 * 16 * 2]);
LOCAL_ALIGNED_16(uint8_t, dst0, [32 * 16 * 2]);
LOCAL_ALIGNED_16(uint8_t, dst1, [32 * 16 * 2]);
H264DSPContext h;
int bit_depth;
int alphas[36], betas[36];
int8_t tc0[36][4];
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *pix, ptrdiff_t stride,
int alpha, int beta, int8_t *tc0);
for (bit_depth = 8; bit_depth <= 10; bit_depth++) {
int i, j, a, c;
uint32_t mask = pixel_mask_lf[bit_depth - 8];
ff_h264dsp_init(&h, bit_depth, 1);
for (i = 35, a = 255, c = 250; i >= 0; i--) {
alphas[i] = a << (bit_depth - 8);
betas[i] = (i + 1) / 2 << (bit_depth - 8);
tc0[i][0] = tc0[i][3] = (c + 6) / 10;
tc0[i][1] = (c + 7) / 15;
tc0[i][2] = (c + 9) / 20;
a = a*9/10;
c = c*9/10;
}
#define CHECK_LOOP_FILTER(name, align, idc) \
do { \
if (check_func(h.name, #name #idc "_%dbpp", bit_depth)) { \
for (j = 0; j < 36; j++) { \
intptr_t off = 8 * 32 + (j & 15) * 4 * !align; \
for (i = 0; i < 1024; i+=4) { \
AV_WN32A(dst + i, rnd() & mask); \
} \
memcpy(dst0, dst, 32 * 16 * 2); \
memcpy(dst1, dst, 32 * 16 * 2); \
\
call_ref(dst0 + off, 32, alphas[j], betas[j], tc0[j]); \
call_new(dst1 + off, 32, alphas[j], betas[j], tc0[j]); \
if (memcmp(dst0, dst1, 32 * 16 * SIZEOF_PIXEL)) { \
fprintf(stderr, #name #idc ": j:%d, alpha:%d beta:%d " \
"tc0:{%d,%d,%d,%d}\n", j, alphas[j], betas[j], \
tc0[j][0], tc0[j][1], tc0[j][2], tc0[j][3]); \
fail(); \
} \
bench_new(dst1, 32, alphas[j], betas[j], tc0[j]); \
} \
} \
} while (0)
CHECK_LOOP_FILTER(h264_v_loop_filter_luma, 1,);
CHECK_LOOP_FILTER(h264_h_loop_filter_luma, 0,);
CHECK_LOOP_FILTER(h264_h_loop_filter_luma_mbaff, 0,);
CHECK_LOOP_FILTER(h264_v_loop_filter_chroma, 1,);
CHECK_LOOP_FILTER(h264_h_loop_filter_chroma, 0,);
CHECK_LOOP_FILTER(h264_h_loop_filter_chroma_mbaff, 0,);
ff_h264dsp_init(&h, bit_depth, 2);
CHECK_LOOP_FILTER(h264_h_loop_filter_chroma, 0, 422);
CHECK_LOOP_FILTER(h264_h_loop_filter_chroma_mbaff, 0, 422);
#undef CHECK_LOOP_FILTER
}
}
static void check_loop_filter_intra(void)
{
LOCAL_ALIGNED_16(uint8_t, dst, [32 * 16 * 2]);
LOCAL_ALIGNED_16(uint8_t, dst0, [32 * 16 * 2]);
LOCAL_ALIGNED_16(uint8_t, dst1, [32 * 16 * 2]);
H264DSPContext h;
int bit_depth;
int alphas[36], betas[36];
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *pix, ptrdiff_t stride,
int alpha, int beta);
for (bit_depth = 8; bit_depth <= 10; bit_depth++) {
int i, j, a;
uint32_t mask = pixel_mask_lf[bit_depth - 8];
ff_h264dsp_init(&h, bit_depth, 1);
for (i = 35, a = 255; i >= 0; i--) {
alphas[i] = a << (bit_depth - 8);
betas[i] = (i + 1) / 2 << (bit_depth - 8);
a = a*9/10;
}
#define CHECK_LOOP_FILTER(name, align, idc) \
do { \
if (check_func(h.name, #name #idc "_%dbpp", bit_depth)) { \
for (j = 0; j < 36; j++) { \
intptr_t off = 8 * 32 + (j & 15) * 4 * !align; \
for (i = 0; i < 1024; i+=4) { \
AV_WN32A(dst + i, rnd() & mask); \
} \
memcpy(dst0, dst, 32 * 16 * 2); \
memcpy(dst1, dst, 32 * 16 * 2); \
\
call_ref(dst0 + off, 32, alphas[j], betas[j]); \
call_new(dst1 + off, 32, alphas[j], betas[j]); \
if (memcmp(dst0, dst1, 32 * 16 * SIZEOF_PIXEL)) { \
fprintf(stderr, #name #idc ": j:%d, alpha:%d beta:%d\n", \
j, alphas[j], betas[j]); \
fail(); \
} \
bench_new(dst1, 32, alphas[j], betas[j]); \
} \
} \
} while (0)
CHECK_LOOP_FILTER(h264_v_loop_filter_luma_intra, 1,);
CHECK_LOOP_FILTER(h264_h_loop_filter_luma_intra, 0,);
CHECK_LOOP_FILTER(h264_h_loop_filter_luma_mbaff_intra, 0,);
CHECK_LOOP_FILTER(h264_v_loop_filter_chroma_intra, 1,);
CHECK_LOOP_FILTER(h264_h_loop_filter_chroma_intra, 0,);
CHECK_LOOP_FILTER(h264_h_loop_filter_chroma_mbaff_intra, 0,);
ff_h264dsp_init(&h, bit_depth, 2);
CHECK_LOOP_FILTER(h264_h_loop_filter_chroma_intra, 0, 422);
CHECK_LOOP_FILTER(h264_h_loop_filter_chroma_mbaff_intra, 0, 422);
#undef CHECK_LOOP_FILTER
}
}
void checkasm_check_h264dsp(void)
{
check_idct();
check_idct_multiple();
report("idct");
check_loop_filter();
report("loop_filter");
check_loop_filter_intra();
report("loop_filter_intra");
}

260
externals/ffmpeg/tests/checkasm/h264pred.c vendored
View File

@@ -1,260 +0,0 @@
/*
* Copyright (c) 2015 Henrik Gramner
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavcodec/avcodec.h"
#include "libavcodec/h264pred.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/intreadwrite.h"
static const int codec_ids[4] = { AV_CODEC_ID_H264, AV_CODEC_ID_VP8, AV_CODEC_ID_RV40, AV_CODEC_ID_SVQ3 };
static const char * const pred4x4_modes[4][15] = {
{ /* H.264 */
[VERT_PRED ] = "vertical",
[HOR_PRED ] = "horizontal",
[DC_PRED ] = "dc",
[DIAG_DOWN_LEFT_PRED ] = "down_left",
[DIAG_DOWN_RIGHT_PRED] = "down_right",
[VERT_RIGHT_PRED ] = "vertical_right",
[HOR_DOWN_PRED ] = "horizontal_right",
[VERT_LEFT_PRED ] = "vertical_left",
[HOR_UP_PRED ] = "horizontal_up",
[LEFT_DC_PRED ] = "left_dc",
[TOP_DC_PRED ] = "top_dc",
[DC_128_PRED ] = "dc_128",
},
{ /* VP8 */
[VERT_PRED ] = "vertical_vp8",
[HOR_PRED ] = "horizontal_vp8",
[VERT_LEFT_PRED] = "vertical_left_vp8",
[TM_VP8_PRED ] = "tm_vp8",
[DC_127_PRED ] = "dc_127_vp8",
[DC_129_PRED ] = "dc_129_vp8",
},
{ /* RV40 */
[DIAG_DOWN_LEFT_PRED ] = "down_left_rv40",
[VERT_LEFT_PRED ] = "vertical_left_rv40",
[HOR_UP_PRED ] = "horizontal_up_rv40",
[DIAG_DOWN_LEFT_PRED_RV40_NODOWN] = "down_left_nodown_rv40",
[HOR_UP_PRED_RV40_NODOWN ] = "horizontal_up_nodown_rv40",
[VERT_LEFT_PRED_RV40_NODOWN ] = "vertical_left_nodown_rv40",
},
{ /* SVQ3 */
[DIAG_DOWN_LEFT_PRED] = "down_left_svq3",
},
};
static const char * const pred8x8_modes[4][11] = {
{ /* H.264 */
[DC_PRED8x8 ] = "dc",
[HOR_PRED8x8 ] = "horizontal",
[VERT_PRED8x8 ] = "vertical",
[PLANE_PRED8x8 ] = "plane",
[LEFT_DC_PRED8x8 ] = "left_dc",
[TOP_DC_PRED8x8 ] = "top_dc",
[DC_128_PRED8x8 ] = "dc_128",
[ALZHEIMER_DC_L0T_PRED8x8] = "mad_cow_dc_l0t",
[ALZHEIMER_DC_0LT_PRED8x8] = "mad_cow_dc_0lt",
[ALZHEIMER_DC_L00_PRED8x8] = "mad_cow_dc_l00",
[ALZHEIMER_DC_0L0_PRED8x8] = "mad_cow_dc_0l0",
},
{ /* VP8 */
[PLANE_PRED8x8 ] = "tm_vp8",
[DC_127_PRED8x8] = "dc_127_vp8",
[DC_129_PRED8x8] = "dc_129_vp8",
},
{ /* RV40 */
[DC_PRED8x8 ] = "dc_rv40",
[LEFT_DC_PRED8x8] = "left_dc_rv40",
[TOP_DC_PRED8x8 ] = "top_dc_rv40",
},
/* nothing for SVQ3 */
};
static const char * const pred16x16_modes[4][9] = {
{ /* H.264 */
[DC_PRED8x8 ] = "dc",
[HOR_PRED8x8 ] = "horizontal",
[VERT_PRED8x8 ] = "vertical",
[PLANE_PRED8x8 ] = "plane",
[LEFT_DC_PRED8x8] = "left_dc",
[TOP_DC_PRED8x8 ] = "top_dc",
[DC_128_PRED8x8 ] = "dc_128",
},
{ /* VP8 */
[PLANE_PRED8x8 ] = "tm_vp8",
[DC_127_PRED8x8] = "dc_127_vp8",
[DC_129_PRED8x8] = "dc_129_vp8",
},
{ /* RV40 */
[PLANE_PRED8x8] = "plane_rv40",
},
{ /* SVQ3 */
[PLANE_PRED8x8] = "plane_svq3",
},
};
static const uint32_t pixel_mask[3] = { 0xffffffff, 0x01ff01ff, 0x03ff03ff };
#define SIZEOF_PIXEL ((bit_depth + 7) / 8)
#define BUF_SIZE (3 * 16 * 17)
#define check_pred_func(func, name, mode_name) \
(mode_name && ((codec_ids[codec] == AV_CODEC_ID_H264) ? \
check_func(func, "pred%s_%s_%d", name, mode_name, bit_depth) : \
check_func(func, "pred%s_%s", name, mode_name)))
#define randomize_buffers() \
do { \
uint32_t mask = pixel_mask[bit_depth - 8]; \
int i; \
for (i = 0; i < BUF_SIZE; i += 4) { \
uint32_t r = rnd() & mask; \
AV_WN32A(buf0 + i, r); \
AV_WN32A(buf1 + i, r); \
} \
} while (0)
#define src0 (buf0 + 4 * 16) /* Offset to allow room for top and left */
#define src1 (buf1 + 4 * 16)
static void check_pred4x4(H264PredContext *h, uint8_t *buf0, uint8_t *buf1,
int codec, int chroma_format, int bit_depth)
{
if (chroma_format == 1) {
uint8_t *topright = buf0 + 2*16;
int pred_mode;
declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *src, const uint8_t *topright, ptrdiff_t stride);
for (pred_mode = 0; pred_mode < 15; pred_mode++) {
if (check_pred_func(h->pred4x4[pred_mode], "4x4", pred4x4_modes[codec][pred_mode])) {
randomize_buffers();
call_ref(src0, topright, 12*SIZEOF_PIXEL);
call_new(src1, topright, 12*SIZEOF_PIXEL);
if (memcmp(buf0, buf1, BUF_SIZE))
fail();
bench_new(src1, topright, 12*SIZEOF_PIXEL);
}
}
}
}
static void check_pred8x8(H264PredContext *h, uint8_t *buf0, uint8_t *buf1,
int codec, int chroma_format, int bit_depth)
{
int pred_mode;
declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *src, ptrdiff_t stride);
for (pred_mode = 0; pred_mode < 11; pred_mode++) {
if (check_pred_func(h->pred8x8[pred_mode], (chroma_format == 2) ? "8x16" : "8x8",
pred8x8_modes[codec][pred_mode])) {
randomize_buffers();
call_ref(src0, 24*SIZEOF_PIXEL);
call_new(src1, 24*SIZEOF_PIXEL);
if (memcmp(buf0, buf1, BUF_SIZE))
fail();
bench_new(src1, 24*SIZEOF_PIXEL);
}
}
}
static void check_pred16x16(H264PredContext *h, uint8_t *buf0, uint8_t *buf1,
int codec, int chroma_format, int bit_depth)
{
if (chroma_format == 1) {
int pred_mode;
declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *src, ptrdiff_t stride);
for (pred_mode = 0; pred_mode < 9; pred_mode++) {
if (check_pred_func(h->pred16x16[pred_mode], "16x16", pred16x16_modes[codec][pred_mode])) {
randomize_buffers();
call_ref(src0, 48);
call_new(src1, 48);
if (memcmp(buf0, buf1, BUF_SIZE))
fail();
bench_new(src1, 48);
}
}
}
}
static void check_pred8x8l(H264PredContext *h, uint8_t *buf0, uint8_t *buf1,
int codec, int chroma_format, int bit_depth)
{
if (chroma_format == 1 && codec_ids[codec] == AV_CODEC_ID_H264) {
int pred_mode;
declare_func_emms(AV_CPU_FLAG_MMXEXT, void, uint8_t *src, int topleft, int topright, ptrdiff_t stride);
for (pred_mode = 0; pred_mode < 12; pred_mode++) {
if (check_pred_func(h->pred8x8l[pred_mode], "8x8l", pred4x4_modes[codec][pred_mode])) {
int neighbors;
for (neighbors = 0; neighbors <= 0xc000; neighbors += 0x4000) {
int has_topleft = neighbors & 0x8000;
int has_topright = neighbors & 0x4000;
if ((pred_mode == DIAG_DOWN_RIGHT_PRED || pred_mode == VERT_RIGHT_PRED) && !has_topleft)
continue; /* Those aren't allowed according to the spec */
randomize_buffers();
call_ref(src0, has_topleft, has_topright, 24*SIZEOF_PIXEL);
call_new(src1, has_topleft, has_topright, 24*SIZEOF_PIXEL);
if (memcmp(buf0, buf1, BUF_SIZE))
fail();
bench_new(src1, has_topleft, has_topright, 24*SIZEOF_PIXEL);
}
}
}
}
}
/* TODO: Add tests for H.264 lossless H/V prediction */
void checkasm_check_h264pred(void)
{
static const struct {
void (*func)(H264PredContext*, uint8_t*, uint8_t*, int, int, int);
const char *name;
} tests[] = {
{ check_pred4x4, "pred4x4" },
{ check_pred8x8, "pred8x8" },
{ check_pred16x16, "pred16x16" },
{ check_pred8x8l, "pred8x8l" },
};
LOCAL_ALIGNED_16(uint8_t, buf0, [BUF_SIZE]);
LOCAL_ALIGNED_16(uint8_t, buf1, [BUF_SIZE]);
H264PredContext h;
int test, codec, chroma_format, bit_depth;
for (test = 0; test < FF_ARRAY_ELEMS(tests); test++) {
for (codec = 0; codec < 4; codec++) {
int codec_id = codec_ids[codec];
for (bit_depth = 8; bit_depth <= (codec_id == AV_CODEC_ID_H264 ? 10 : 8); bit_depth++)
for (chroma_format = 1; chroma_format <= (codec_id == AV_CODEC_ID_H264 ? 2 : 1); chroma_format++) {
ff_h264_pred_init(&h, codec_id, bit_depth, chroma_format);
tests[test].func(&h, buf0, buf1, codec, chroma_format, bit_depth);
}
}
report("%s", tests[test].name);
}
}

81
externals/ffmpeg/tests/checkasm/h264qpel.c vendored
View File

@@ -1,81 +0,0 @@
/*
* Copyright (c) 2015 Henrik Gramner
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavcodec/h264qpel.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/intreadwrite.h"
static const uint32_t pixel_mask[3] = { 0xffffffff, 0x01ff01ff, 0x03ff03ff };
#define SIZEOF_PIXEL ((bit_depth + 7) / 8)
#define BUF_SIZE (2 * 16 * (16 + 3 + 4))
#define randomize_buffers() \
do { \
uint32_t mask = pixel_mask[bit_depth - 8]; \
int k; \
for (k = 0; k < BUF_SIZE; k += 4) { \
uint32_t r = rnd() & mask; \
AV_WN32A(buf0 + k, r); \
AV_WN32A(buf1 + k, r); \
r = rnd(); \
AV_WN32A(dst0 + k, r); \
AV_WN32A(dst1 + k, r); \
} \
} while (0)
#define src0 (buf0 + 3 * 2 * 16) /* h264qpel functions read data from negative src pointer offsets */
#define src1 (buf1 + 3 * 2 * 16)
void checkasm_check_h264qpel(void)
{
LOCAL_ALIGNED_16(uint8_t, buf0, [BUF_SIZE]);
LOCAL_ALIGNED_16(uint8_t, buf1, [BUF_SIZE]);
LOCAL_ALIGNED_16(uint8_t, dst0, [BUF_SIZE]);
LOCAL_ALIGNED_16(uint8_t, dst1, [BUF_SIZE]);
H264QpelContext h;
int op, bit_depth, i, j;
declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *dst, const uint8_t *src, ptrdiff_t stride);
for (op = 0; op < 2; op++) {
qpel_mc_func (*tab)[16] = op ? h.avg_h264_qpel_pixels_tab : h.put_h264_qpel_pixels_tab;
const char *op_name = op ? "avg" : "put";
for (bit_depth = 8; bit_depth <= 10; bit_depth++) {
ff_h264qpel_init(&h, bit_depth);
for (i = 0; i < (op ? 3 : 4); i++) {
int size = 16 >> i;
for (j = 0; j < 16; j++)
if (check_func(tab[i][j], "%s_h264_qpel_%d_mc%d%d_%d", op_name, size, j & 3, j >> 2, bit_depth)) {
randomize_buffers();
call_ref(dst0, src0, size * SIZEOF_PIXEL);
call_new(dst1, src1, size * SIZEOF_PIXEL);
if (memcmp(buf0, buf1, BUF_SIZE) || memcmp(dst0, dst1, BUF_SIZE))
fail();
bench_new(dst1, src1, size * SIZEOF_PIXEL);
}
}
}
report("%s", op_name);
}
}

96
externals/ffmpeg/tests/checkasm/hevc_add_res.c vendored
View File

@@ -1,96 +0,0 @@
/*
* Copyright (c) 2016 Alexandra Hájková
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "libavutil/intreadwrite.h"
#include "libavcodec/hevcdsp.h"
#include "checkasm.h"
#define randomize_buffers(buf, size) \
do { \
int j; \
for (j = 0; j < size; j++) { \
int16_t r = rnd(); \
AV_WN16A(buf + j, r >> 3); \
} \
} while (0)
#define randomize_buffers2(buf, size) \
do { \
int j; \
for (j = 0; j < size; j++) \
AV_WN16A(buf + j * 2, rnd() & 0x3FF); \
} while (0)
static void compare_add_res(int size, ptrdiff_t stride, int overflow_test)
{
LOCAL_ALIGNED_32(int16_t, res0, [32 * 32]);
LOCAL_ALIGNED_32(int16_t, res1, [32 * 32]);
LOCAL_ALIGNED_32(uint8_t, dst0, [32 * 32 * 2]);
LOCAL_ALIGNED_32(uint8_t, dst1, [32 * 32 * 2]);
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, int16_t *res, ptrdiff_t stride);
randomize_buffers(res0, size);
randomize_buffers2(dst0, size);
if (overflow_test)
res0[0] = 0x8000;
memcpy(res1, res0, sizeof(*res0) * size);
memcpy(dst1, dst0, sizeof(int16_t) * size);
call_ref(dst0, res0, stride);
call_new(dst1, res1, stride);
if (memcmp(dst0, dst1, size))
fail();
bench_new(dst1, res1, stride);
}
static void check_add_res(HEVCDSPContext h, int bit_depth)
{
int i;
for (i = 2; i <= 5; i++) {
int block_size = 1 << i;
int size = block_size * block_size;
ptrdiff_t stride = block_size << (bit_depth > 8);
if (check_func(h.add_residual[i - 2], "hevc_add_res_%dx%d_%d", block_size, block_size, bit_depth)) {
compare_add_res(size, stride, 0);
// overflow test for res = -32768
compare_add_res(size, stride, 1);
}
}
}
void checkasm_check_hevc_add_res(void)
{
int bit_depth;
for (bit_depth = 8; bit_depth <= 10; bit_depth++) {
HEVCDSPContext h;
ff_hevc_dsp_init(&h, bit_depth);
check_add_res(h, bit_depth);
}
report("add_residual");
}

105
externals/ffmpeg/tests/checkasm/hevc_idct.c vendored
View File

@@ -1,105 +0,0 @@
/*
* Copyright (c) 2016 Alexandra Hájková
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "libavutil/intreadwrite.h"
#include "libavcodec/hevcdsp.h"
#include "checkasm.h"
#define randomize_buffers(buf, size) \
do { \
int j; \
for (j = 0; j < size; j++) { \
int16_t r = rnd(); \
AV_WN16A(buf + j, r); \
} \
} while (0)
static void check_idct(HEVCDSPContext h, int bit_depth)
{
int i;
LOCAL_ALIGNED(32, int16_t, coeffs0, [32 * 32]);
LOCAL_ALIGNED(32, int16_t, coeffs1, [32 * 32]);
for (i = 2; i <= 5; i++) {
int block_size = 1 << i;
int size = block_size * block_size;
int col_limit = block_size;
declare_func(void, int16_t *coeffs, int col_limit);
randomize_buffers(coeffs0, size);
memcpy(coeffs1, coeffs0, sizeof(*coeffs0) * size);
if (check_func(h.idct[i - 2], "hevc_idct_%dx%d_%d", block_size, block_size, bit_depth)) {
call_ref(coeffs0, col_limit);
call_new(coeffs1, col_limit);
if (memcmp(coeffs0, coeffs1, sizeof(*coeffs0) * size))
fail();
bench_new(coeffs1, col_limit);
}
}
}
static void check_idct_dc(HEVCDSPContext h, int bit_depth)
{
int i;
LOCAL_ALIGNED(32, int16_t, coeffs0, [32 * 32]);
LOCAL_ALIGNED(32, int16_t, coeffs1, [32 * 32]);
for (i = 2; i <= 5; i++) {
int block_size = 1 << i;
int size = block_size * block_size;
declare_func_emms(AV_CPU_FLAG_MMXEXT, void, int16_t *coeffs);
randomize_buffers(coeffs0, size);
memcpy(coeffs1, coeffs0, sizeof(*coeffs0) * size);
if (check_func(h.idct_dc[i - 2], "hevc_idct_%dx%d_dc_%d", block_size, block_size, bit_depth)) {
call_ref(coeffs0);
call_new(coeffs1);
if (memcmp(coeffs0, coeffs1, sizeof(*coeffs0) * size))
fail();
bench_new(coeffs1);
}
}
}
void checkasm_check_hevc_idct(void)
{
int bit_depth;
for (bit_depth = 8; bit_depth <= 12; bit_depth += 2) {
HEVCDSPContext h;
ff_hevc_dsp_init(&h, bit_depth);
check_idct_dc(h, bit_depth);
}
report("idct_dc");
for (bit_depth = 8; bit_depth <= 12; bit_depth += 2) {
HEVCDSPContext h;
ff_hevc_dsp_init(&h, bit_depth);
check_idct(h, bit_depth);
}
report("idct");
}

150
externals/ffmpeg/tests/checkasm/hevc_sao.c vendored
View File

@@ -1,150 +0,0 @@
/*
* Copyright (c) 2018 Yingming Fan <yingmingfan@gmail.com>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "libavutil/intreadwrite.h"
#include "libavcodec/avcodec.h"
#include "libavcodec/hevcdsp.h"
#include "checkasm.h"
static const uint32_t pixel_mask[3] = { 0xffffffff, 0x03ff03ff, 0x0fff0fff };
static const uint32_t sao_size[5] = {8, 16, 32, 48, 64};
#define SIZEOF_PIXEL ((bit_depth + 7) / 8)
#define PIXEL_STRIDE (2*MAX_PB_SIZE + AV_INPUT_BUFFER_PADDING_SIZE) //same with sao_edge src_stride
#define BUF_SIZE (PIXEL_STRIDE * (64+2) * 2) //+2 for top and bottom row, *2 for high bit depth
#define OFFSET_THRESH (1 << (bit_depth - 5))
#define OFFSET_LENGTH 5
#define randomize_buffers(buf0, buf1, size) \
do { \
uint32_t mask = pixel_mask[(bit_depth - 8) >> 1]; \
int k; \
for (k = 0; k < size; k += 4) { \
uint32_t r = rnd() & mask; \
AV_WN32A(buf0 + k, r); \
AV_WN32A(buf1 + k, r); \
} \
} while (0)
#define randomize_buffers2(buf, size) \
do { \
uint32_t max_offset = OFFSET_THRESH; \
int k; \
if (bit_depth == 8) { \
for (k = 0; k < size; k++) { \
uint8_t r = rnd() % max_offset; \
buf[k] = r; \
} \
} else { \
for (k = 0; k < size; k++) { \
uint16_t r = rnd() % max_offset; \
buf[k] = r; \
} \
} \
} while (0)
static void check_sao_band(HEVCDSPContext h, int bit_depth)
{
int i;
LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
LOCAL_ALIGNED_32(uint8_t, src0, [BUF_SIZE]);
LOCAL_ALIGNED_32(uint8_t, src1, [BUF_SIZE]);
int16_t offset_val[OFFSET_LENGTH];
int left_class = rnd()%32;
for (i = 0; i <= 4; i++) {
int block_size = sao_size[i];
ptrdiff_t stride = PIXEL_STRIDE*SIZEOF_PIXEL;
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, uint8_t *src, ptrdiff_t dst_stride, ptrdiff_t src_stride,
int16_t *sao_offset_val, int sao_left_class, int width, int height);
randomize_buffers(src0, src1, BUF_SIZE);
randomize_buffers2(offset_val, OFFSET_LENGTH);
memset(dst0, 0, BUF_SIZE);
memset(dst1, 0, BUF_SIZE);
if (check_func(h.sao_band_filter[i], "hevc_sao_band_%dx%d_%d", block_size, block_size, bit_depth)) {
call_ref(dst0, src0, stride, stride, offset_val, left_class, block_size, block_size);
call_new(dst1, src1, stride, stride, offset_val, left_class, block_size, block_size);
if (memcmp(dst0, dst1, BUF_SIZE))
fail();
bench_new(dst1, src1, stride, stride, offset_val, left_class, block_size, block_size);
}
}
}
static void check_sao_edge(HEVCDSPContext h, int bit_depth)
{
int i;
LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
LOCAL_ALIGNED_32(uint8_t, src0, [BUF_SIZE]);
LOCAL_ALIGNED_32(uint8_t, src1, [BUF_SIZE]);
int16_t offset_val[OFFSET_LENGTH];
int eo = rnd()%4;
for (i = 0; i <= 4; i++) {
int block_size = sao_size[i];
ptrdiff_t stride = PIXEL_STRIDE*SIZEOF_PIXEL;
int offset = (AV_INPUT_BUFFER_PADDING_SIZE + PIXEL_STRIDE)*SIZEOF_PIXEL;
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, uint8_t *src, ptrdiff_t stride_dst,
int16_t *sao_offset_val, int eo, int width, int height);
randomize_buffers(src0, src1, BUF_SIZE);
randomize_buffers2(offset_val, OFFSET_LENGTH);
memset(dst0, 0, BUF_SIZE);
memset(dst1, 0, BUF_SIZE);
if (check_func(h.sao_edge_filter[i], "hevc_sao_edge_%dx%d_%d", block_size, block_size, bit_depth)) {
call_ref(dst0, src0 + offset, stride, offset_val, eo, block_size, block_size);
call_new(dst1, src1 + offset, stride, offset_val, eo, block_size, block_size);
if (memcmp(dst0, dst1, BUF_SIZE))
fail();
bench_new(dst1, src1 + offset, stride, offset_val, eo, block_size, block_size);
}
}
}
void checkasm_check_hevc_sao(void)
{
int bit_depth;
for (bit_depth = 8; bit_depth <= 12; bit_depth += 2) {
HEVCDSPContext h;
ff_hevc_dsp_init(&h, bit_depth);
check_sao_band(h, bit_depth);
}
report("sao_band");
for (bit_depth = 8; bit_depth <= 12; bit_depth += 2) {
HEVCDSPContext h;
ff_hevc_dsp_init(&h, bit_depth);
check_sao_edge(h, bit_depth);
}
report("sao_edge");
}

81
externals/ffmpeg/tests/checkasm/huffyuvdsp.c vendored
View File

@@ -1,81 +0,0 @@
/*
* Copyright (c) 2016 Alexandra Hájková
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "libavutil/common.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/mem.h"
#include "libavcodec/huffyuvdsp.h"
#include "checkasm.h"
#define randomize_buffers(buf, size) \
do { \
int j; \
for (j = 0; j < size; j++) \
buf[j] = rnd() & 0xFFFF; \
} while (0)
static void check_add_int16(HuffYUVDSPContext c, unsigned mask, int width, const char * name)
{
uint16_t *src0 = av_mallocz(width * sizeof(uint16_t));
uint16_t *src1 = av_mallocz(width * sizeof(uint16_t));
uint16_t *dst0 = av_mallocz(width * sizeof(uint16_t));
uint16_t *dst1 = av_mallocz(width * sizeof(uint16_t));
declare_func_emms(AV_CPU_FLAG_MMX, void, uint16_t *dst, uint16_t *src, unsigned mask, int w);
if (!src0 || !src1 || !dst0 || !dst1)
fail();
randomize_buffers(src0, width);
memcpy(src1, src0, width * sizeof(uint16_t));
if (check_func(c.add_int16, "%s", name)) {
call_ref(dst0, src0, mask, width);
call_new(dst1, src1, mask, width);
if (memcmp(dst0, dst1, width * sizeof(uint16_t)))
fail();
bench_new(dst1, src1, mask, width);
}
av_free(src0);
av_free(src1);
av_free(dst0);
av_free(dst1);
}
void checkasm_check_huffyuvdsp(void)
{
HuffYUVDSPContext c;
int width = 16 * av_clip(rnd(), 16, 128);
ff_huffyuvdsp_init(&c, AV_PIX_FMT_YUV422P);
/*! test width not multiple of mmsize */
check_add_int16(c, 65535, width, "add_int16_rnd_width");
report("add_int16_rnd_width");
/*! test always with the same size (for perf test) */
check_add_int16(c, 65535, 16*128, "add_int16_128");
report("add_int16_128");
}

103
externals/ffmpeg/tests/checkasm/jpeg2000dsp.c vendored
View File

@@ -1,103 +0,0 @@
/*
* Copyright (c) 2015 James Almer
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "checkasm.h"
#include "libavcodec/jpeg2000dsp.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/intreadwrite.h"
#define BUF_SIZE 512
#define randomize_buffers() \
do { \
int i; \
for (i = 0; i < BUF_SIZE*3; i++) \
src[i] = rnd(); \
} while (0)
#define randomize_buffers_float() \
do { \
int i; \
for (i = 0; i < BUF_SIZE*3; i++) \
src[i] = (float)rnd() / (UINT_MAX >> 5); \
} while (0)
static void check_rct_int(void)
{
LOCAL_ALIGNED_32(int32_t, src, [BUF_SIZE*3]);
LOCAL_ALIGNED_32(int32_t, ref, [BUF_SIZE*3]);
LOCAL_ALIGNED_32(int32_t, new, [BUF_SIZE*3]);
int32_t *ref0 = &ref[BUF_SIZE*0], *new0 = &new[BUF_SIZE*0];
int32_t *ref1 = &ref[BUF_SIZE*1], *new1 = &new[BUF_SIZE*1];
int32_t *ref2 = &ref[BUF_SIZE*2], *new2 = &new[BUF_SIZE*2];
declare_func(void, void *src0, void *src1, void *src2, int csize);
randomize_buffers();
memcpy(ref, src, BUF_SIZE * 3 * sizeof(*src));
memcpy(new, src, BUF_SIZE * 3 * sizeof(*src));
call_ref(ref0, ref1, ref2, BUF_SIZE);
call_new(new0, new1, new2, BUF_SIZE);
if (memcmp(ref0, new0, BUF_SIZE * sizeof(*src)) ||
memcmp(ref1, new1, BUF_SIZE * sizeof(*src)) ||
memcmp(ref2, new2, BUF_SIZE * sizeof(*src)))
fail();
memcpy(new, src, BUF_SIZE * 3 * sizeof(*src));
bench_new(new0, new1, new2, BUF_SIZE);
}
static void check_ict_float(void)
{
LOCAL_ALIGNED_32(float, src, [BUF_SIZE*3]);
LOCAL_ALIGNED_32(float, ref, [BUF_SIZE*3]);
LOCAL_ALIGNED_32(float, new, [BUF_SIZE*3]);
float *ref0 = &ref[BUF_SIZE*0], *new0 = &new[BUF_SIZE*0];
float *ref1 = &ref[BUF_SIZE*1], *new1 = &new[BUF_SIZE*1];
float *ref2 = &ref[BUF_SIZE*2], *new2 = &new[BUF_SIZE*2];
declare_func(void, void *src0, void *src1, void *src2, int csize);
randomize_buffers_float();
memcpy(ref, src, BUF_SIZE * 3 * sizeof(*src));
memcpy(new, src, BUF_SIZE * 3 * sizeof(*src));
call_ref(ref0, ref1, ref2, BUF_SIZE);
call_new(new0, new1, new2, BUF_SIZE);
if (!float_near_abs_eps_array(ref0, new0, 1.0e-5, BUF_SIZE) ||
!float_near_abs_eps_array(ref1, new1, 1.0e-5, BUF_SIZE) ||
!float_near_abs_eps_array(ref2, new2, 1.0e-5, BUF_SIZE))
fail();
memcpy(new, src, BUF_SIZE * 3 * sizeof(*src));
bench_new(new0, new1, new2, BUF_SIZE);
}
void checkasm_check_jpeg2000dsp(void)
{
Jpeg2000DSPContext h;
ff_jpeg2000dsp_init(&h);
if (check_func(h.mct_decode[FF_DWT53], "jpeg2000_rct_int"))
check_rct_int();
if (check_func(h.mct_decode[FF_DWT97], "jpeg2000_ict_float"))
check_ict_float();
report("mct_decode");
}

220
externals/ffmpeg/tests/checkasm/llviddsp.c vendored
View File

@@ -1,220 +0,0 @@
/*
* Copyright (c) 2016 Alexandra Hájková
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "libavutil/common.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/mem.h"
#include "libavcodec/lossless_videodsp.h"
#include "checkasm.h"
#define randomize_buffers(buf, size) \
do { \
int j; \
uint8_t *tmp_buf = (uint8_t *)buf;\
for (j = 0; j < size; j++) \
tmp_buf[j] = rnd() & 0xFF; \
} while (0)
#define init_buffer(a0, a1, type, width)\
if (!a0 || !a1)\
fail();\
randomize_buffers(a0, width * sizeof(type));\
memcpy(a1, a0, width*sizeof(type));\
static void check_add_bytes(LLVidDSPContext c, int width)
{
uint8_t *dst0 = av_mallocz(width);
uint8_t *dst1 = av_mallocz(width);
uint8_t *src0 = av_mallocz_array(width, sizeof(uint8_t));
uint8_t *src1 = av_mallocz_array(width, sizeof(uint8_t));
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, uint8_t *src, ptrdiff_t w);
init_buffer(src0, src1, uint8_t, width);
if (!dst0 || !dst1)
fail();
if (check_func(c.add_bytes, "add_bytes")) {
call_ref(dst0, src0, width);
call_new(dst1, src1, width);
if (memcmp(dst0, dst1, width))
fail();
bench_new(dst1, src1, width);
}
av_free(src0);
av_free(src1);
av_free(dst0);
av_free(dst1);
}
static void check_add_median_pred(LLVidDSPContext c, int width) {
int A0, A1, B0, B1;
uint8_t *dst0 = av_mallocz(width);
uint8_t *dst1 = av_mallocz(width);
uint8_t *src0 = av_mallocz_array(width, sizeof(uint8_t));
uint8_t *src1 = av_mallocz_array(width, sizeof(uint8_t));
uint8_t *diff0 = av_mallocz_array(width, sizeof(uint8_t));
uint8_t *diff1 = av_mallocz_array(width, sizeof(uint8_t));
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, const uint8_t *src1,
const uint8_t *diff, ptrdiff_t w,
int *left, int *left_top);
init_buffer(src0, src1, uint8_t, width);
init_buffer(diff0, diff1, uint8_t, width);
A0 = rnd() & 0xFF;
B0 = rnd() & 0xFF;
A1 = A0;
B1 = B0;
if (check_func(c.add_median_pred, "add_median_pred")) {
call_ref(dst0, src0, diff0, width, &A0, &B0);
call_new(dst1, src1, diff1, width, &A1, &B1);
if (memcmp(dst0, dst1, width) || (A0 != A1) || (B0 != B1))
fail();
bench_new(dst1, src1, diff1, width, &A1, &B1);
}
av_free(src0);
av_free(src1);
av_free(diff0);
av_free(diff1);
av_free(dst0);
av_free(dst1);
}
static void check_add_left_pred(LLVidDSPContext c, int width, int acc, const char * report)
{
int res0, res1;
uint8_t *dst0 = av_mallocz(width);
uint8_t *dst1 = av_mallocz(width);
uint8_t *src0 = av_mallocz_array(width, sizeof(uint8_t));
uint8_t *src1 = av_mallocz_array(width, sizeof(uint8_t));
declare_func_emms(AV_CPU_FLAG_MMX, int, uint8_t *dst, uint8_t *src, ptrdiff_t w, int acc);
init_buffer(src0, src1, uint8_t, width);
if (!dst0 || !dst1)
fail();
if (check_func(c.add_left_pred, "%s", report)) {
res0 = call_ref(dst0, src0, width, acc);
res1 = call_new(dst1, src1, width, acc);
if ((res0 & 0xFF) != (res1 & 0xFF)||\
memcmp(dst0, dst1, width))
fail();
bench_new(dst1, src1, width, acc);
}
av_free(src0);
av_free(src1);
av_free(dst0);
av_free(dst1);
}
static void check_add_left_pred_16(LLVidDSPContext c, unsigned mask, int width, unsigned acc, const char * report)
{
int res0, res1;
uint16_t *dst0 = av_mallocz_array(width, sizeof(uint16_t));
uint16_t *dst1 = av_mallocz_array(width, sizeof(uint16_t));
uint16_t *src0 = av_mallocz_array(width, sizeof(uint16_t));
uint16_t *src1 = av_mallocz_array(width, sizeof(uint16_t));
declare_func_emms(AV_CPU_FLAG_MMX, int, uint16_t *dst, uint16_t *src, unsigned mask, ptrdiff_t w, unsigned acc);
init_buffer(src0, src1, uint16_t, width);
if (!dst0 || !dst1)
fail();
if (check_func(c.add_left_pred_int16, "%s", report)) {
res0 = call_ref(dst0, src0, mask, width, acc);
res1 = call_new(dst1, src1, mask, width, acc);
if ((res0 &0xFFFF) != (res1 &0xFFFF)||\
memcmp(dst0, dst1, width))
fail();
bench_new(dst1, src1, mask, width, acc);
}
av_free(src0);
av_free(src1);
av_free(dst0);
av_free(dst1);
}
static void check_add_gradient_pred(LLVidDSPContext c, int w) {
int src_size, stride;
uint8_t *src0, *src1;
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *src, const ptrdiff_t stride,
const ptrdiff_t width);
stride = w + 32;
src_size = (stride + 32) * 2; /* dsp need previous line, and ignore the start of the line */
src0 = av_mallocz(src_size);
src1 = av_mallocz(src_size);
init_buffer(src0, src1, uint8_t, src_size);
if (check_func(c.add_gradient_pred, "add_gradient_pred")) {
call_ref(src0 + stride + 32, stride, w);
call_new(src1 + stride + 32, stride, w);
if (memcmp(src0, src1, stride)||/* previous line doesn't change */
memcmp(src0+stride, src1 + stride, w + 32)) {
fail();
}
bench_new(src1 + stride + 32, stride, w);
}
av_free(src0);
av_free(src1);
}
void checkasm_check_llviddsp(void)
{
LLVidDSPContext c;
int width = 16 * av_clip(rnd(), 16, 128);
int accRnd = rnd() & 0xFF;
ff_llviddsp_init(&c);
check_add_bytes(c, width);
report("add_bytes");
check_add_median_pred(c, width);
report("add_median_pred");
check_add_left_pred(c, width, 0, "add_left_pred_zero");
report("add_left_pred_zero");
check_add_left_pred(c, width, accRnd, "add_left_pred_rnd_acc");
report("add_left_pred_rnd_acc");
check_add_left_pred_16(c, 255, width, accRnd, "add_left_pred_int16");
report("add_left_pred_int16");
check_add_gradient_pred(c, width);
report("add_gradient_pred");
}

114
externals/ffmpeg/tests/checkasm/llviddspenc.c vendored
View File

@@ -1,114 +0,0 @@
/*
* Copyright (c) 2016 Alexandra Hájková
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "libavutil/common.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/mem.h"
#include "libavcodec/lossless_videoencdsp.h"
#include "checkasm.h"
#define randomize_buffers(buf, size) \
do { \
int j; \
for (j = 0; j < size; j+=4) \
AV_WN32(buf + j, rnd()); \
} while (0)
static const struct {uint8_t w, h, s;} planes[] = {
{16,16,16}, {21,23,25}, {32,17,48}, {15,128,16}, {128,127,128}
};
#define MAX_STRIDE 128
#define MAX_HEIGHT 127
static void check_diff_bytes(LLVidEncDSPContext *c)
{
int i;
LOCAL_ALIGNED_32(uint8_t, dst0, [MAX_STRIDE]);
LOCAL_ALIGNED_32(uint8_t, dst1, [MAX_STRIDE]);
LOCAL_ALIGNED_32(uint8_t, src0, [MAX_STRIDE]);
LOCAL_ALIGNED_32(uint8_t, src1, [MAX_STRIDE]);
LOCAL_ALIGNED_32(uint8_t, src2, [MAX_STRIDE]);
LOCAL_ALIGNED_32(uint8_t, src3, [MAX_STRIDE]);
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, const uint8_t *src1,
const uint8_t *src2, intptr_t w);
memset(dst0, 0, MAX_STRIDE);
memset(dst1, 0, MAX_STRIDE);
randomize_buffers(src0, MAX_STRIDE);
memcpy(src1, src0, MAX_STRIDE);
randomize_buffers(src2, MAX_STRIDE);
memcpy(src3, src2, MAX_STRIDE);
if (check_func(c->diff_bytes, "diff_bytes")) {
for (i = 0; i < 5; i ++) {
call_ref(dst0, src0, src2, planes[i].w);
call_new(dst1, src1, src3, planes[i].w);
if (memcmp(dst0, dst1, planes[i].w))
fail();
}
bench_new(dst1, src0, src2, planes[4].w);
}
}
static void check_sub_left_pred(LLVidEncDSPContext *c)
{
int i;
LOCAL_ALIGNED_32(uint8_t, dst0, [MAX_STRIDE * MAX_HEIGHT]);
LOCAL_ALIGNED_32(uint8_t, dst1, [MAX_STRIDE * MAX_HEIGHT]);
LOCAL_ALIGNED_32(uint8_t, src0, [MAX_STRIDE * MAX_HEIGHT]);
LOCAL_ALIGNED_32(uint8_t, src1, [MAX_STRIDE * MAX_HEIGHT]);
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, const uint8_t *src,
ptrdiff_t stride, ptrdiff_t width, int height);
memset(dst0, 0, MAX_STRIDE * MAX_HEIGHT);
memset(dst1, 0, MAX_STRIDE * MAX_HEIGHT);
randomize_buffers(src0, MAX_STRIDE * MAX_HEIGHT);
memcpy(src1, src0, MAX_STRIDE * MAX_HEIGHT);
if (check_func(c->sub_left_predict, "sub_left_predict")) {
for (i = 0; i < 5; i ++) {
call_ref(dst0, src0, planes[i].s, planes[i].w, planes[i].h);
call_new(dst1, src1, planes[i].s, planes[i].w, planes[i].h);
if (memcmp(dst0, dst1, planes[i].w * planes[i].h))
fail();
break;
}
bench_new(dst1, src0, planes[4].s, planes[4].w, planes[4].h);
}
}
void checkasm_check_llviddspenc(void)
{
LLVidEncDSPContext c;
ff_llvidencdsp_init(&c);
check_diff_bytes(&c);
report("diff_bytes");
check_sub_left_pred(&c);
report("sub_left_predict");
}

103
externals/ffmpeg/tests/checkasm/opusdsp.c vendored
View File

@@ -1,103 +0,0 @@
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "libavcodec/opusdsp.h"
#include "checkasm.h"
#define randomize_float(buf, len) \
do { \
for (int i = 0; i < len; i++) { \
float f = (float)rnd() / (UINT_MAX >> 5) - 16.0f; \
buf[i] = f; \
} \
} while (0)
#define EPS 0.005
#define MAX_SIZE (960)
/* period is between 15 and 1022, inclusive */
static void test_postfilter(int period)
{
LOCAL_ALIGNED(16, float, data0, [MAX_SIZE + 1024]);
LOCAL_ALIGNED(16, float, data1, [MAX_SIZE + 1024]);
/* This filter can explode very easily, so use a tapset from the codec.
* In the codec these are usually multiplied by at least 0.09375f,
* so its outside the largest filter value, but the filter is still stable
* so use it. */
float gains[3] = { 0.3066406250f, 0.2170410156f, 0.1296386719f };
/* The codec will always call with an offset which is aligned once
* (period + 2) is subtracted, but here we have to align it outselves. */
int offset = FFALIGN(period + 2, 4);
declare_func(void, float *data, int period, float *gains, int len);
randomize_float(data0, MAX_SIZE + 1024);
memcpy(data1, data0, (MAX_SIZE + 1024)*sizeof(float));
call_ref(data0 + offset, period, gains, MAX_SIZE);
call_new(data1 + offset, period, gains, MAX_SIZE);
if (!float_near_abs_eps_array(data0 + offset, data1 + offset, EPS, MAX_SIZE))
fail();
bench_new(data1 + offset, period, gains, MAX_SIZE);
}
static void test_deemphasis(void)
{
LOCAL_ALIGNED(16, float, src, [FFALIGN(MAX_SIZE, 4)]);
LOCAL_ALIGNED(16, float, dst0, [FFALIGN(MAX_SIZE, 4)]);
LOCAL_ALIGNED(16, float, dst1, [FFALIGN(MAX_SIZE, 4)]);
float coeff0 = (float)rnd() / (UINT_MAX >> 5) - 16.0f, coeff1 = coeff0;
declare_func_float(float, float *out, float *in, float coeff, int len);
randomize_float(src, MAX_SIZE);
coeff0 = call_ref(dst0, src, coeff0, MAX_SIZE);
coeff1 = call_new(dst1, src, coeff1, MAX_SIZE);
if (!float_near_abs_eps(coeff0, coeff1, EPS) ||
!float_near_abs_eps_array(dst0, dst1, EPS, MAX_SIZE))
fail();
bench_new(dst1, src, coeff1, MAX_SIZE);
}
void checkasm_check_opusdsp(void)
{
OpusDSP ctx;
ff_opus_dsp_init(&ctx);
if (check_func(ctx.postfilter, "postfilter_15"))
test_postfilter(15);
report("postfilter_15");
if (check_func(ctx.postfilter, "postfilter_512"))
test_postfilter(512);
report("postfilter_512");
if (check_func(ctx.postfilter, "postfilter_1022"))
test_postfilter(1022);
report("postfilter_1022");
if (check_func(ctx.deemphasis, "deemphasis"))
test_deemphasis();
report("deemphasis");
}

111
externals/ffmpeg/tests/checkasm/pixblockdsp.c vendored
View File

@@ -1,111 +0,0 @@
/*
* Copyright (c) 2015 Tiancheng "Timothy" Gu
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavcodec/pixblockdsp.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/intreadwrite.h"
#define BUF_UNITS 8
#define BUF_SIZE (BUF_UNITS * 128 + 8 * BUF_UNITS)
#define randomize_buffers() \
do { \
int i; \
for (i = 0; i < BUF_SIZE; i += 4) { \
uint32_t r = rnd(); \
AV_WN32A(src10 + i, r); \
AV_WN32A(src11 + i, r); \
r = rnd(); \
AV_WN32A(src20 + i, r); \
AV_WN32A(src21 + i, r); \
r = rnd(); \
AV_WN32A(dst0_ + i, r); \
AV_WN32A(dst1_ + i, r); \
} \
} while (0)
#define check_get_pixels(type, aligned) \
do { \
int i; \
declare_func_emms(AV_CPU_FLAG_MMX, void, int16_t *block, const uint8_t *pixels, ptrdiff_t line_size); \
\
for (i = 0; i < BUF_UNITS; i++) { \
int src_offset = i * 64 * sizeof(type) + (aligned ? 8 : 1) * i; \
int dst_offset = i * 64; /* dst must be aligned */ \
randomize_buffers(); \
call_ref(dst0 + dst_offset, src10 + src_offset, 8); \
call_new(dst1 + dst_offset, src11 + src_offset, 8); \
if (memcmp(src10, src11, BUF_SIZE)|| memcmp(dst0, dst1, BUF_SIZE)) \
fail(); \
bench_new(dst1 + dst_offset, src11 + src_offset, 8); \
} \
} while (0)
#define check_diff_pixels(type, aligned) \
do { \
int i; \
declare_func_emms(AV_CPU_FLAG_MMX, void, int16_t *av_restrict block, const uint8_t *s1, const uint8_t *s2, ptrdiff_t stride); \
\
for (i = 0; i < BUF_UNITS; i++) { \
int src_offset = i * 64 * sizeof(type) + (aligned ? 8 : 1) * i; \
int dst_offset = i * 64; /* dst must be aligned */ \
randomize_buffers(); \
call_ref(dst0 + dst_offset, src10 + src_offset, src20 + src_offset, 8); \
call_new(dst1 + dst_offset, src11 + src_offset, src21 + src_offset, 8); \
if (memcmp(src10, src11, BUF_SIZE) || memcmp(src20, src21, BUF_SIZE) || memcmp(dst0, dst1, BUF_SIZE)) \
fail(); \
bench_new(dst1 + dst_offset, src11 + src_offset, src21 + src_offset, 8); \
} \
} while (0)
void checkasm_check_pixblockdsp(void)
{
LOCAL_ALIGNED_16(uint8_t, src10, [BUF_SIZE]);
LOCAL_ALIGNED_16(uint8_t, src11, [BUF_SIZE]);
LOCAL_ALIGNED_16(uint8_t, src20, [BUF_SIZE]);
LOCAL_ALIGNED_16(uint8_t, src21, [BUF_SIZE]);
LOCAL_ALIGNED_16(uint8_t, dst0_, [BUF_SIZE]);
LOCAL_ALIGNED_16(uint8_t, dst1_, [BUF_SIZE]);
uint16_t *dst0 = (uint16_t *)dst0_;
uint16_t *dst1 = (uint16_t *)dst1_;
PixblockDSPContext h;
AVCodecContext avctx = {
.bits_per_raw_sample = 8,
};
ff_pixblockdsp_init(&h, &avctx);
if (check_func(h.get_pixels, "get_pixels"))
check_get_pixels(uint8_t, 1);
if (check_func(h.get_pixels_unaligned, "get_pixels_unaligned"))
check_get_pixels(uint8_t, 0);
report("get_pixels");
if (check_func(h.diff_pixels, "diff_pixels"))
check_diff_pixels(uint8_t, 1);
if (check_func(h.diff_pixels_unaligned, "diff_pixels_unaligned"))
check_diff_pixels(uint8_t, 0);
report("diff_pixels");
}

300
externals/ffmpeg/tests/checkasm/sbrdsp.c vendored
View File

@@ -1,300 +0,0 @@
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "libavcodec/sbrdsp.h"
#include <float.h>
#include "checkasm.h"
#define randomize(buf, len) do { \
int i; \
for (i = 0; i < len; i++) { \
const INTFLOAT f = (INTFLOAT)rnd() / UINT_MAX; \
(buf)[i] = f; \
} \
} while (0)
#define EPS 0.0001
static void test_sum64x5(void)
{
LOCAL_ALIGNED_16(INTFLOAT, dst0, [64 + 256]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [64 + 256]);
declare_func(void, INTFLOAT *z);
randomize((INTFLOAT *)dst0, 64 + 256);
memcpy(dst1, dst0, (64 + 256) * sizeof(INTFLOAT));
call_ref(dst0);
call_new(dst1);
if (!float_near_abs_eps_array(dst0, dst1, EPS, 64 + 256))
fail();
bench_new(dst1);
}
static void test_sum_square(void)
{
INTFLOAT res0;
INTFLOAT res1;
LOCAL_ALIGNED_16(INTFLOAT, src, [256], [2]);
double t = 4 * 256;
declare_func_float(INTFLOAT, INTFLOAT (*x)[2], int n);
randomize((INTFLOAT *)src, 256 * 2);
res0 = call_ref(src, 256);
res1 = call_new(src, 256);
if (!float_near_abs_eps(res0, res1, t * 2 * FLT_EPSILON))
fail();
bench_new(src, 256);
}
static void test_neg_odd_64(void)
{
LOCAL_ALIGNED_16(INTFLOAT, dst0, [64]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [64]);
declare_func(void, INTFLOAT *x);
randomize((INTFLOAT *)dst0, 64);
memcpy(dst1, dst0, (64) * sizeof(INTFLOAT));
call_ref(dst0);
call_new(dst1);
if (!float_near_abs_eps_array(dst0, dst1, EPS, 64))
fail();
bench_new(dst1);
}
static void test_qmf_pre_shuffle(void)
{
LOCAL_ALIGNED_16(INTFLOAT, dst0, [128]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [128]);
declare_func(void, INTFLOAT *z);
randomize((INTFLOAT *)dst0, 128);
memcpy(dst1, dst0, (128) * sizeof(INTFLOAT));
call_ref(dst0);
call_new(dst1);
if (!float_near_abs_eps_array(dst0, dst1, EPS, 128))
fail();
bench_new(dst1);
}
static void test_qmf_post_shuffle(void)
{
LOCAL_ALIGNED_16(INTFLOAT, src, [64]);
LOCAL_ALIGNED_16(INTFLOAT, dst0, [32], [2]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [32], [2]);
declare_func(void, INTFLOAT W[32][2], const INTFLOAT *z);
randomize((INTFLOAT *)src, 64);
call_ref(dst0, src);
call_new(dst1, src);
if (!float_near_abs_eps_array((INTFLOAT *)dst0, (INTFLOAT *)dst1, EPS, 64))
fail();
bench_new(dst1, src);
}
static void test_qmf_deint_neg(void)
{
LOCAL_ALIGNED_16(INTFLOAT, src, [64]);
LOCAL_ALIGNED_16(INTFLOAT, dst0, [64]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [64]);
declare_func(void, INTFLOAT *v, const INTFLOAT *src);
randomize((INTFLOAT *)src, 64);
call_ref(dst0, src);
call_new(dst1, src);
if (!float_near_abs_eps_array(dst0, dst1, EPS, 64))
fail();
bench_new(dst1, src);
}
static void test_qmf_deint_bfly(void)
{
LOCAL_ALIGNED_16(INTFLOAT, src0, [64]);
LOCAL_ALIGNED_16(INTFLOAT, src1, [64]);
LOCAL_ALIGNED_16(INTFLOAT, dst0, [128]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [128]);
declare_func(void, INTFLOAT *v, const INTFLOAT *src0, const INTFLOAT *src1);
memset(dst0, 0, 128 * sizeof(INTFLOAT));
memset(dst1, 0, 128 * sizeof(INTFLOAT));
randomize((INTFLOAT *)src0, 64);
randomize((INTFLOAT *)src1, 64);
call_ref(dst0, src0, src1);
call_new(dst1, src0, src1);
if (!float_near_abs_eps_array(dst0, dst1, EPS, 128))
fail();
bench_new(dst1, src0, src1);
}
static void test_autocorrelate(void)
{
LOCAL_ALIGNED_16(INTFLOAT, src, [40], [2]);
LOCAL_ALIGNED_16(INTFLOAT, dst0, [3], [2][2]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [3], [2][2]);
declare_func(void, const INTFLOAT x[40][2], INTFLOAT phi[3][2][2]);
memset(dst0, 0, 3 * 2 * 2 * sizeof(INTFLOAT));
memset(dst1, 0, 3 * 2 * 2 * sizeof(INTFLOAT));
randomize((INTFLOAT *)src, 80);
call_ref(src, dst0);
call_new(src, dst1);
if (!float_near_abs_eps_array((INTFLOAT *)dst0, (INTFLOAT *)dst1, EPS, 3 * 2 * 2))
fail();
bench_new(src, dst1);
}
static void test_hf_gen(void)
{
LOCAL_ALIGNED_16(INTFLOAT, low, [128], [2]);
LOCAL_ALIGNED_16(INTFLOAT, alpha0, [2]);
LOCAL_ALIGNED_16(INTFLOAT, alpha1, [2]);
LOCAL_ALIGNED_16(INTFLOAT, dst0, [128], [2]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [128], [2]);
INTFLOAT bw = (INTFLOAT)rnd() / UINT_MAX;
int i;
declare_func(void, INTFLOAT (*X_high)[2], const INTFLOAT (*X_low)[2],
const INTFLOAT alpha0[2], const INTFLOAT alpha1[2],
INTFLOAT bw, int start, int end);
randomize((INTFLOAT *)low, 128 * 2);
randomize((INTFLOAT *)alpha0, 2);
randomize((INTFLOAT *)alpha1, 2);
for (i = 2; i < 64; i += 2) {
memset(dst0, 0, 128 * 2 * sizeof(INTFLOAT));
memset(dst1, 0, 128 * 2 * sizeof(INTFLOAT));
call_ref(dst0, low, alpha0, alpha1, 0.0, i, 128);
call_new(dst1, low, alpha0, alpha1, 0.0, i, 128);
if (!float_near_abs_eps_array((INTFLOAT *)dst0, (INTFLOAT *)dst1, EPS, 128 * 2))
fail();
bench_new(dst1, low, alpha0, alpha1, bw, i, 128);
}
}
static void test_hf_g_filt(void)
{
LOCAL_ALIGNED_16(INTFLOAT, high, [128], [40][2]);
LOCAL_ALIGNED_16(INTFLOAT, g_filt, [128]);
LOCAL_ALIGNED_16(INTFLOAT, dst0, [128], [2]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [128], [2]);
declare_func(void, INTFLOAT (*Y)[2], const INTFLOAT (*X_high)[40][2],
const INTFLOAT *g_filt, int m_max, intptr_t ixh);
randomize((INTFLOAT *)high, 128 * 40 * 2);
randomize((INTFLOAT *)g_filt, 128);
call_ref(dst0, high, g_filt, 128, 20);
call_new(dst1, high, g_filt, 128, 20);
if (!float_near_abs_eps_array((INTFLOAT *)dst0, (INTFLOAT *)dst1, EPS, 128 * 2))
fail();
bench_new(dst1, high, g_filt, 128, 20);
}
static void test_hf_apply_noise(const SBRDSPContext *sbrdsp)
{
LOCAL_ALIGNED_16(AAC_FLOAT, s_m, [128]);
LOCAL_ALIGNED_16(AAC_FLOAT, q_filt, [128]);
LOCAL_ALIGNED_16(INTFLOAT, ref, [128], [2]);
LOCAL_ALIGNED_16(INTFLOAT, dst0, [128], [2]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [128], [2]);
int noise = 0x2a;
int i, j;
declare_func(void, INTFLOAT (*Y)[2], const AAC_FLOAT *s_m,
const AAC_FLOAT *q_filt, int noise,
int kx, int m_max);
randomize((INTFLOAT *)ref, 128 * 2);
randomize((INTFLOAT *)s_m, 128);
randomize((INTFLOAT *)q_filt, 128);
for (i = 0; i < 4; i++) {
if (check_func(sbrdsp->hf_apply_noise[i], "hf_apply_noise_%d", i)) {
for (j = 0; j < 2; j++) {
memcpy(dst0, ref, 128 * 2 * sizeof(INTFLOAT));
memcpy(dst1, ref, 128 * 2 * sizeof(INTFLOAT));
call_ref(dst0, s_m, q_filt, noise, j, 128);
call_new(dst1, s_m, q_filt, noise, j, 128);
if (!float_near_abs_eps_array((INTFLOAT *)dst0, (INTFLOAT *)dst1, EPS, 128 * 2))
fail();
bench_new(dst1, s_m, q_filt, noise, j, 128);
}
}
}
}
void checkasm_check_sbrdsp(void)
{
SBRDSPContext sbrdsp;
ff_sbrdsp_init(&sbrdsp);
if (check_func(sbrdsp.sum64x5, "sum64x5"))
test_sum64x5();
report("sum64x5");
if (check_func(sbrdsp.sum_square, "sum_square"))
test_sum_square();
report("sum_square");
if (check_func(sbrdsp.neg_odd_64, "neg_odd_64"))
test_neg_odd_64();
report("neg_odd_64");
if (check_func(sbrdsp.qmf_pre_shuffle, "qmf_pre_shuffle"))
test_qmf_pre_shuffle();
report("qmf_pre_shuffle");
if (check_func(sbrdsp.qmf_post_shuffle, "qmf_post_shuffle"))
test_qmf_post_shuffle();
report("qmf_post_shuffle");
if (check_func(sbrdsp.qmf_deint_neg, "qmf_deint_neg"))
test_qmf_deint_neg();
report("qmf_deint_neg");
if (check_func(sbrdsp.qmf_deint_bfly, "qmf_deint_bfly"))
test_qmf_deint_bfly();
report("qmf_deint_bfly");
if (check_func(sbrdsp.autocorrelate, "autocorrelate"))
test_autocorrelate();
report("autocorrelate");
if (check_func(sbrdsp.hf_gen, "hf_gen"))
test_hf_gen();
report("hf_gen");
if (check_func(sbrdsp.hf_g_filt, "hf_g_filt"))
test_hf_g_filt();
report("hf_g_filt");
test_hf_apply_noise(&sbrdsp);
report("hf_apply_noise");
}

206
externals/ffmpeg/tests/checkasm/sw_rgb.c vendored
View File

@@ -1,206 +0,0 @@
/*
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "libavutil/common.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/mem.h"
#include "libswscale/rgb2rgb.h"
#include "checkasm.h"
#define randomize_buffers(buf, size) \
do { \
int j; \
for (j = 0; j < size; j+=4) \
AV_WN32(buf + j, rnd()); \
} while (0)
static const uint8_t width[] = {12, 16, 20, 32, 36, 128};
static const struct {uint8_t w, h, s;} planes[] = {
{12,16,12}, {16,16,16}, {20,23,25}, {32,18,48}, {8,128,16}, {128,128,128}
};
#define MAX_STRIDE 128
#define MAX_HEIGHT 128
static void check_shuffle_bytes(void * func, const char * report)
{
int i;
LOCAL_ALIGNED_32(uint8_t, src0, [MAX_STRIDE]);
LOCAL_ALIGNED_32(uint8_t, src1, [MAX_STRIDE]);
LOCAL_ALIGNED_32(uint8_t, dst0, [MAX_STRIDE]);
LOCAL_ALIGNED_32(uint8_t, dst1, [MAX_STRIDE]);
declare_func_emms(AV_CPU_FLAG_MMX, void, const uint8_t *src, uint8_t *dst, int src_size);
memset(dst0, 0, MAX_STRIDE);
memset(dst1, 0, MAX_STRIDE);
randomize_buffers(src0, MAX_STRIDE);
memcpy(src1, src0, MAX_STRIDE);
if (check_func(func, "%s", report)) {
for (i = 0; i < 6; i ++) {
call_ref(src0, dst0, width[i]);
call_new(src1, dst1, width[i]);
if (memcmp(dst0, dst1, MAX_STRIDE))
fail();
}
bench_new(src0, dst0, width[5]);
}
}
static void check_uyvy_to_422p(void)
{
int i;
LOCAL_ALIGNED_32(uint8_t, src0, [MAX_STRIDE * MAX_HEIGHT * 2]);
LOCAL_ALIGNED_32(uint8_t, src1, [MAX_STRIDE * MAX_HEIGHT * 2]);
LOCAL_ALIGNED_32(uint8_t, dst_y_0, [MAX_STRIDE * MAX_HEIGHT]);
LOCAL_ALIGNED_32(uint8_t, dst_y_1, [MAX_STRIDE * MAX_HEIGHT]);
LOCAL_ALIGNED_32(uint8_t, dst_u_0, [(MAX_STRIDE/2) * MAX_HEIGHT]);
LOCAL_ALIGNED_32(uint8_t, dst_u_1, [(MAX_STRIDE/2) * MAX_HEIGHT]);
LOCAL_ALIGNED_32(uint8_t, dst_v_0, [(MAX_STRIDE/2) * MAX_HEIGHT]);
LOCAL_ALIGNED_32(uint8_t, dst_v_1, [(MAX_STRIDE/2) * MAX_HEIGHT]);
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
const uint8_t *src, int width, int height,
int lumStride, int chromStride, int srcStride);
randomize_buffers(src0, MAX_STRIDE * MAX_HEIGHT * 2);
memcpy(src1, src0, MAX_STRIDE * MAX_HEIGHT * 2);
if (check_func(uyvytoyuv422, "uyvytoyuv422")) {
for (i = 0; i < 6; i ++) {
memset(dst_y_0, 0, MAX_STRIDE * MAX_HEIGHT);
memset(dst_y_1, 0, MAX_STRIDE * MAX_HEIGHT);
memset(dst_u_0, 0, (MAX_STRIDE/2) * MAX_HEIGHT);
memset(dst_u_1, 0, (MAX_STRIDE/2) * MAX_HEIGHT);
memset(dst_v_0, 0, (MAX_STRIDE/2) * MAX_HEIGHT);
memset(dst_v_1, 0, (MAX_STRIDE/2) * MAX_HEIGHT);
call_ref(dst_y_0, dst_u_0, dst_v_0, src0, planes[i].w, planes[i].h,
MAX_STRIDE, MAX_STRIDE / 2, planes[i].s);
call_new(dst_y_1, dst_u_1, dst_v_1, src1, planes[i].w, planes[i].h,
MAX_STRIDE, MAX_STRIDE / 2, planes[i].s);
if (memcmp(dst_y_0, dst_y_1, MAX_STRIDE * MAX_HEIGHT) ||
memcmp(dst_u_0, dst_u_1, (MAX_STRIDE/2) * MAX_HEIGHT) ||
memcmp(dst_v_0, dst_v_1, (MAX_STRIDE/2) * MAX_HEIGHT))
fail();
}
bench_new(dst_y_1, dst_u_1, dst_v_1, src1, planes[5].w, planes[5].h,
MAX_STRIDE, MAX_STRIDE / 2, planes[5].s);
}
}
static void check_interleave_bytes(void)
{
LOCAL_ALIGNED_16(uint8_t, src0_buf, [MAX_STRIDE*MAX_HEIGHT+1]);
LOCAL_ALIGNED_16(uint8_t, src1_buf, [MAX_STRIDE*MAX_HEIGHT+1]);
LOCAL_ALIGNED_16(uint8_t, dst0_buf, [2*MAX_STRIDE*MAX_HEIGHT+2]);
LOCAL_ALIGNED_16(uint8_t, dst1_buf, [2*MAX_STRIDE*MAX_HEIGHT+2]);
// Intentionally using unaligned buffers, as this function doesn't have
// any alignment requirements.
uint8_t *src0 = src0_buf + 1;
uint8_t *src1 = src1_buf + 1;
uint8_t *dst0 = dst0_buf + 2;
uint8_t *dst1 = dst1_buf + 2;
declare_func_emms(AV_CPU_FLAG_MMX, void, const uint8_t *, const uint8_t *,
uint8_t *, int, int, int, int, int);
randomize_buffers(src0, MAX_STRIDE * MAX_HEIGHT);
randomize_buffers(src1, MAX_STRIDE * MAX_HEIGHT);
if (check_func(interleaveBytes, "interleave_bytes")) {
for (int i = 0; i <= 16; i++) {
// Try all widths [1,16], and try one random width.
int w = i > 0 ? i : (1 + (rnd() % (MAX_STRIDE-2)));
int h = 1 + (rnd() % (MAX_HEIGHT-2));
int src0_offset = 0, src0_stride = MAX_STRIDE;
int src1_offset = 0, src1_stride = MAX_STRIDE;
int dst_offset = 0, dst_stride = 2 * MAX_STRIDE;
memset(dst0, 0, 2 * MAX_STRIDE * MAX_HEIGHT);
memset(dst1, 0, 2 * MAX_STRIDE * MAX_HEIGHT);
// Try different combinations of negative strides
if (i & 1) {
src0_offset = (h-1)*src0_stride;
src0_stride = -src0_stride;
}
if (i & 2) {
src1_offset = (h-1)*src1_stride;
src1_stride = -src1_stride;
}
if (i & 4) {
dst_offset = (h-1)*dst_stride;
dst_stride = -dst_stride;
}
call_ref(src0 + src0_offset, src1 + src1_offset, dst0 + dst_offset,
w, h, src0_stride, src1_stride, dst_stride);
call_new(src0 + src0_offset, src1 + src1_offset, dst1 + dst_offset,
w, h, src0_stride, src1_stride, dst_stride);
// Check a one pixel-pair edge around the destination area,
// to catch overwrites past the end.
checkasm_check(uint8_t, dst0, 2*MAX_STRIDE, dst1, 2*MAX_STRIDE,
2 * w + 2, h + 1, "dst");
}
bench_new(src0, src1, dst1, 127, MAX_HEIGHT,
MAX_STRIDE, MAX_STRIDE, 2*MAX_STRIDE);
}
if (check_func(interleaveBytes, "interleave_bytes_aligned")) {
// Bench the function in a more typical case, with aligned
// buffers and widths.
bench_new(src0_buf, src1_buf, dst1_buf, 128, MAX_HEIGHT,
MAX_STRIDE, MAX_STRIDE, 2*MAX_STRIDE);
}
}
void checkasm_check_sw_rgb(void)
{
ff_sws_rgb2rgb_init();
check_shuffle_bytes(shuffle_bytes_2103, "shuffle_bytes_2103");
report("shuffle_bytes_2103");
check_shuffle_bytes(shuffle_bytes_0321, "shuffle_bytes_0321");
report("shuffle_bytes_0321");
check_shuffle_bytes(shuffle_bytes_1230, "shuffle_bytes_1230");
report("shuffle_bytes_1230");
check_shuffle_bytes(shuffle_bytes_3012, "shuffle_bytes_3012");
report("shuffle_bytes_3012");
check_shuffle_bytes(shuffle_bytes_3210, "shuffle_bytes_3210");
report("shuffle_bytes_3210");
check_uyvy_to_422p();
report("uyvytoyuv422");
check_interleave_bytes();
report("interleave_bytes");
}

134
externals/ffmpeg/tests/checkasm/sw_scale.c vendored
View File

@@ -1,134 +0,0 @@
/*
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "libavutil/common.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/mem.h"
#include "libswscale/swscale.h"
#include "libswscale/swscale_internal.h"
#include "checkasm.h"
#define randomize_buffers(buf, size) \
do { \
int j; \
for (j = 0; j < size; j+=4) \
AV_WN32(buf + j, rnd()); \
} while (0)
#define SRC_PIXELS 128
static void check_hscale(void)
{
#define MAX_FILTER_WIDTH 40
#define FILTER_SIZES 5
static const int filter_sizes[FILTER_SIZES] = { 4, 8, 16, 32, 40 };
#define HSCALE_PAIRS 2
static const int hscale_pairs[HSCALE_PAIRS][2] = {
{ 8, 14 },
{ 8, 18 },
};
int i, j, fsi, hpi, width;
struct SwsContext *ctx;
// padded
LOCAL_ALIGNED_32(uint8_t, src, [FFALIGN(SRC_PIXELS + MAX_FILTER_WIDTH - 1, 4)]);
LOCAL_ALIGNED_32(uint32_t, dst0, [SRC_PIXELS]);
LOCAL_ALIGNED_32(uint32_t, dst1, [SRC_PIXELS]);
// padded
LOCAL_ALIGNED_32(int16_t, filter, [SRC_PIXELS * MAX_FILTER_WIDTH + MAX_FILTER_WIDTH]);
LOCAL_ALIGNED_32(int32_t, filterPos, [SRC_PIXELS]);
// The dst parameter here is either int16_t or int32_t but we use void* to
// just cover both cases.
declare_func_emms(AV_CPU_FLAG_MMX, void, void *c, void *dst, int dstW,
const uint8_t *src, const int16_t *filter,
const int32_t *filterPos, int filterSize);
ctx = sws_alloc_context();
if (sws_init_context(ctx, NULL, NULL) < 0)
fail();
randomize_buffers(src, SRC_PIXELS + MAX_FILTER_WIDTH - 1);
for (hpi = 0; hpi < HSCALE_PAIRS; hpi++) {
for (fsi = 0; fsi < FILTER_SIZES; fsi++) {
width = filter_sizes[fsi];
ctx->srcBpc = hscale_pairs[hpi][0];
ctx->dstBpc = hscale_pairs[hpi][1];
ctx->hLumFilterSize = ctx->hChrFilterSize = width;
for (i = 0; i < SRC_PIXELS; i++) {
filterPos[i] = i;
// These filter cofficients are chosen to try break two corner
// cases, namely:
//
// - Negative filter coefficients. The filters output signed
// values, and it should be possible to end up with negative
// output values.
//
// - Positive clipping. The hscale filter function has clipping
// at (1<<15) - 1
//
// The coefficients sum to the 1.0 point for the hscale
// functions (1 << 14).
for (j = 0; j < width; j++) {
filter[i * width + j] = -((1 << 14) / (width - 1));
}
filter[i * width + (rnd() % width)] = ((1 << 15) - 1);
}
for (i = 0; i < MAX_FILTER_WIDTH; i++) {
// These values should be unused in SIMD implementations but
// may still be read, random coefficients here should help show
// issues where they are used in error.
filter[SRC_PIXELS * width + i] = rnd();
}
ff_getSwsFunc(ctx);
if (check_func(ctx->hcScale, "hscale_%d_to_%d_width%d", ctx->srcBpc, ctx->dstBpc + 1, width)) {
memset(dst0, 0, SRC_PIXELS * sizeof(dst0[0]));
memset(dst1, 0, SRC_PIXELS * sizeof(dst1[0]));
call_ref(NULL, dst0, SRC_PIXELS, src, filter, filterPos, width);
call_new(NULL, dst1, SRC_PIXELS, src, filter, filterPos, width);
if (memcmp(dst0, dst1, SRC_PIXELS * sizeof(dst0[0])))
fail();
bench_new(NULL, dst0, SRC_PIXELS, src, filter, filterPos, width);
}
}
}
sws_freeContext(ctx);
}
void checkasm_check_sw_scale(void)
{
check_hscale();
report("hscale");
}

121
externals/ffmpeg/tests/checkasm/synth_filter.c vendored
View File

@@ -1,121 +0,0 @@
/*
* Copyright (c) 2015 Janne Grunau
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <math.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "libavutil/internal.h"
#include "libavutil/intfloat.h"
#include "libavcodec/dcadata.h"
#include "libavcodec/synth_filter.h"
#include "checkasm.h"
#define BUF_SIZE 32
#define randomize_input() \
do { \
int i; \
for (i = 0; i < BUF_SIZE; i++) { \
float f = (float)rnd() / (UINT_MAX >> 5) - 16.0f; \
in[i] = f; \
} \
} while (0)
void checkasm_check_synth_filter(void)
{
FFTContext imdct;
SynthFilterContext synth;
ff_mdct_init(&imdct, 6, 1, 1.0);
ff_synth_filter_init(&synth);
if (check_func(synth.synth_filter_float, "synth_filter_float")) {
LOCAL_ALIGNED(32, float, out0, [BUF_SIZE]);
LOCAL_ALIGNED(32, float, out1, [BUF_SIZE]);
LOCAL_ALIGNED(32, float, out_b, [BUF_SIZE]);
LOCAL_ALIGNED(32, float, in, [BUF_SIZE]);
LOCAL_ALIGNED(32, float, buf2_0, [BUF_SIZE]);
LOCAL_ALIGNED(32, float, buf2_1, [BUF_SIZE]);
LOCAL_ALIGNED(32, float, buf2_b, [BUF_SIZE]);
LOCAL_ALIGNED(32, float, buf0, [512]);
LOCAL_ALIGNED(32, float, buf1, [512]);
LOCAL_ALIGNED(32, float, buf_b, [512]);
float scale = 1.0f;
int i, offset0 = 0, offset1 = 0, offset_b = 0;
declare_func(void, FFTContext *, float *, int *, float[32], const float[512],
float[32], float[32], float);
memset(buf2_0, 0, sizeof(*buf2_0) * BUF_SIZE);
memset(buf2_1, 0, sizeof(*buf2_1) * BUF_SIZE);
memset(buf2_b, 0, sizeof(*buf2_b) * BUF_SIZE);
memset(buf0, 0, sizeof(*buf2_0) * 512);
memset(buf1, 0, sizeof(*buf2_1) * 512);
memset(buf_b, 0, sizeof(*buf2_b) * 512);
/* more than 1 synth_buf_offset wrap-around */
for (i = 0; i < 20; i++) {
int j;
const float * window = (i & 1) ? ff_dca_fir_32bands_perfect : ff_dca_fir_32bands_nonperfect;
memset(out0, 0, sizeof(*out0) * BUF_SIZE);
memset(out1, 0, sizeof(*out1) * BUF_SIZE);
memset(out_b, 0, sizeof(*out_b) * BUF_SIZE);
randomize_input();
call_ref(&imdct, buf0, &offset0, buf2_0, window,
out0, in, scale);
call_new(&imdct, buf1, &offset1, buf2_1, window,
out1, in, scale);
if (offset0 != offset1) {
fail();
fprintf(stderr, "offsets do not match: %d, %d", offset0, offset1);
break;
}
for (j = 0; j < BUF_SIZE; j++) {
if (!float_near_abs_eps_ulp(out0[j], out1[j], 7.0e-7, 16) ||
!float_near_abs_eps_ulp(buf2_0[j], buf2_1[j], 7.0e-7, 16)) {
union av_intfloat32 o0, o1, b0, b1;
fail();
o0.f = out0[j]; o1.f = out1[j];
b0.f = buf2_0[j], b1.f = buf2_1[j];
fprintf(stderr, "out: %11g (0x%08x); %11g (0x%08x); abs diff %11g\n",
o0.f, o0.i, o1.f, o1.i, fabsf(o0.f - o1.f));
fprintf(stderr, "buf2: %11g (0x%08x); %11g (0x%08x); abs diff %11g\n",
b0.f, b0.i, b1.f, b1.i, fabsf(b0.f - b1.f));
break;
}
}
bench_new(&imdct, buf_b, &offset_b, buf2_b, window,
out_b, in, scale);
}
}
ff_mdct_end(&imdct);
report("synth_filter");
}

105
externals/ffmpeg/tests/checkasm/utvideodsp.c vendored
View File

@@ -1,105 +0,0 @@
/*
* Copyright (c) 2017 Jokyo Images
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavcodec/avcodec.h"
#include "libavcodec/utvideodsp.h"
#include "libavutil/intreadwrite.h"
#define WIDTH 240
#define HEIGHT 120
#define WIDTH_PADDED (WIDTH + 16) /* padded to 32 */
#define BUFFER_SIZE (WIDTH_PADDED * HEIGHT)
#define randomize_plane(buf, type) \
do { \
int w, h; \
type * tmp = buf; \
for (h = 0; h < HEIGHT; h++) { \
for (w = 0; w < WIDTH; w++) \
tmp[w] = rnd() & 0xFF; \
tmp += WIDTH_PADDED; \
} \
} while (0)
#define cmp_plane(buf0, buf1, s) \
do { \
int h; \
for (h = 0; h < HEIGHT; h++) { \
if (memcmp(buf0 + h*WIDTH_PADDED, \
buf1 + h*WIDTH_PADDED, WIDTH *s)) \
fail();\
} \
} while (0)
#define CHECK_RESTORE(type)\
LOCAL_ALIGNED_32(type, src_r0, [BUFFER_SIZE]); \
LOCAL_ALIGNED_32(type, src_g0, [BUFFER_SIZE]); \
LOCAL_ALIGNED_32(type, src_b0, [BUFFER_SIZE]); \
LOCAL_ALIGNED_32(type, src_r1, [BUFFER_SIZE]); \
LOCAL_ALIGNED_32(type, src_g1, [BUFFER_SIZE]); \
LOCAL_ALIGNED_32(type, src_b1, [BUFFER_SIZE]); \
declare_func(void, type *src_r, type *src_g, type *src_b, \
ptrdiff_t linesize_r, ptrdiff_t linesize_g, \
ptrdiff_t linesize_b, int width, int height); \
memset(src_r0, 0, BUFFER_SIZE * sizeof(type)); \
memset(src_g0, 0, BUFFER_SIZE * sizeof(type)); \
memset(src_b0, 0, BUFFER_SIZE * sizeof(type)); \
randomize_plane(src_r0, type); \
randomize_plane(src_g0, type); \
randomize_plane(src_b0, type); \
memcpy(src_r1, src_r0, BUFFER_SIZE * sizeof(type)); \
memcpy(src_g1, src_g0, BUFFER_SIZE * sizeof(type)); \
memcpy(src_b1, src_b0, BUFFER_SIZE * sizeof(type)); \
call_ref(src_r0, src_g0, src_b0, WIDTH_PADDED, WIDTH_PADDED, WIDTH_PADDED, WIDTH, HEIGHT);\
call_new(src_r1, src_g1, src_b1, WIDTH_PADDED, WIDTH_PADDED, WIDTH_PADDED, WIDTH, HEIGHT);\
cmp_plane(src_r0, src_r1, sizeof(type)); \
cmp_plane(src_g0, src_g1, sizeof(type)); \
cmp_plane(src_b0, src_b1, sizeof(type)); \
bench_new(src_r1, src_g1, src_b1, WIDTH_PADDED, WIDTH_PADDED, WIDTH_PADDED, WIDTH, HEIGHT)
static void check_restore_rgb_planes(void) {
CHECK_RESTORE(uint8_t);
}
static void check_restore_rgb_planes10(void) {
CHECK_RESTORE(uint16_t);
}
void checkasm_check_utvideodsp(void)
{
UTVideoDSPContext h;
ff_utvideodsp_init(&h);
if (check_func(h.restore_rgb_planes, "restore_rgb_planes"))
check_restore_rgb_planes();
report("restore_rgb_planes");
if (check_func(h.restore_rgb_planes10, "restore_rgb_planes10"))
check_restore_rgb_planes10();
report("restore_rgb_planes10");
}

77
externals/ffmpeg/tests/checkasm/v210dec.c vendored
View File

@@ -1,77 +0,0 @@
/*
* Copyright (c) 2019 James Darnley
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavcodec/v210dec.h"
static uint32_t get_v210(void)
{
uint32_t t0 = rnd() & 0x3ff,
t1 = rnd() & 0x3ff,
t2 = rnd() & 0x3ff;
uint32_t value = t0
| (t1 << 10)
| (t2 << 20);
return value;
}
#define NUM_SAMPLES 2048
static void randomize_buffers(uint32_t *src0, uint32_t *src1, int len)
{
for (int i = 0; i < len; i++) {
uint32_t value = get_v210();
src0[i] = value;
src1[i] = value;
}
}
void checkasm_check_v210dec(void)
{
V210DecContext h;
h.aligned_input = 0;
ff_v210dec_init(&h);
if (check_func(h.unpack_frame, "v210_unpack")) {
uint32_t src0[NUM_SAMPLES/3];
uint32_t src1[NUM_SAMPLES/3];
uint16_t y0[NUM_SAMPLES/2];
uint16_t y1[NUM_SAMPLES/2];
uint16_t u0[NUM_SAMPLES/4];
uint16_t u1[NUM_SAMPLES/4];
uint16_t v0[NUM_SAMPLES/4];
uint16_t v1[NUM_SAMPLES/4];
declare_func(void, const uint32_t *src, uint16_t *y, uint16_t *u, uint16_t *v, int width);
const int pixels = NUM_SAMPLES / 2 / 6 * 6;
randomize_buffers(src0, src1, NUM_SAMPLES/3);
call_ref(src0, y0, u0, v0, pixels);
call_new(src1, y1, u1, v1, pixels);
if (memcmp(src0, src1, NUM_SAMPLES/3 * sizeof src0[0])
|| memcmp(y0, y1, pixels * sizeof y0[0])
|| memcmp(u0, u1, pixels/2 * sizeof u0[0])
|| memcmp(v0, v1, pixels/2 * sizeof v0[0]))
fail();
bench_new(src1, y1, u1, v1, pixels);
}
report("v210_unpack");
}

94
externals/ffmpeg/tests/checkasm/v210enc.c vendored
View File

@@ -1,94 +0,0 @@
/*
* Copyright (c) 2015 Henrik Gramner
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavcodec/v210enc.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/intreadwrite.h"
#define BUF_SIZE 512
#define randomize_buffers(mask) \
do { \
int i, size = sizeof(*y0); \
for (i = 0; i < BUF_SIZE; i += 4 / size) { \
uint32_t r = rnd() & mask; \
AV_WN32A(y0 + i, r); \
AV_WN32A(y1 + i, r); \
} \
for (i = 0; i < BUF_SIZE / 2; i += 4 / size) { \
uint32_t r = rnd() & mask; \
AV_WN32A(u0 + i, r); \
AV_WN32A(u1 + i, r); \
r = rnd() & mask; \
AV_WN32A(v0 + i, r); \
AV_WN32A(v1 + i, r); \
} \
for (i = 0; i < width * 8 / 3; i += 4) { \
uint32_t r = rnd(); \
AV_WN32A(dst0 + i, r); \
AV_WN32A(dst1 + i, r); \
} \
} while (0)
#define check_pack_line(type, mask) \
do { \
LOCAL_ALIGNED_16(type, y0, [BUF_SIZE]); \
LOCAL_ALIGNED_16(type, y1, [BUF_SIZE]); \
LOCAL_ALIGNED_16(type, u0, [BUF_SIZE / 2]); \
LOCAL_ALIGNED_16(type, u1, [BUF_SIZE / 2]); \
LOCAL_ALIGNED_16(type, v0, [BUF_SIZE / 2]); \
LOCAL_ALIGNED_16(type, v1, [BUF_SIZE / 2]); \
LOCAL_ALIGNED_16(uint8_t, dst0, [BUF_SIZE * 8 / 3]); \
LOCAL_ALIGNED_16(uint8_t, dst1, [BUF_SIZE * 8 / 3]); \
\
declare_func(void, const type * y, const type * u, const type * v, \
uint8_t * dst, ptrdiff_t width); \
ptrdiff_t width, step = 12 / sizeof(type); \
\
for (width = step; width < BUF_SIZE - 15; width += step) { \
int y_offset = rnd() & 15; \
int uv_offset = y_offset / 2; \
randomize_buffers(mask); \
call_ref(y0 + y_offset, u0 + uv_offset, v0 + uv_offset, dst0, width); \
call_new(y1 + y_offset, u1 + uv_offset, v1 + uv_offset, dst1, width); \
if (memcmp(y0, y1, BUF_SIZE) || memcmp(u0, u1, BUF_SIZE / 2) || \
memcmp(v0, v1, BUF_SIZE / 2) || memcmp(dst0, dst1, width * 8 / 3)) \
fail(); \
bench_new(y1 + y_offset, u1 + uv_offset, v1 + uv_offset, dst1, width); \
} \
} while (0)
void checkasm_check_v210enc(void)
{
V210EncContext h;
ff_v210enc_init(&h);
if (check_func(h.pack_line_8, "v210_planar_pack_8"))
check_pack_line(uint8_t, 0xffffffff);
if (check_func(h.pack_line_10, "v210_planar_pack_10"))
check_pack_line(uint16_t, 0x03ff03ff);
report("planar_pack");
}

149
externals/ffmpeg/tests/checkasm/vf_blend.c vendored
View File

@@ -1,149 +0,0 @@
/*
* Copyright (c) 2016 Tiancheng "Timothy" Gu
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavfilter/blend.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/intreadwrite.h"
#define WIDTH 256
#define HEIGHT 256
#define BUF_UNITS 3
#define SIZE_PER_UNIT (WIDTH * HEIGHT)
#define BUF_SIZE (BUF_UNITS * SIZE_PER_UNIT)
#define randomize_buffers() \
do { \
int i, j; \
for (i = 0; i < HEIGHT; i++) { \
for (j = 0; j < WIDTH; j++) { \
top1[i * WIDTH + j] = \
top2[i * WIDTH + j] = i; \
bot1[i * WIDTH + j] = \
bot2[i * WIDTH + j] = j; \
} \
} \
for (i = 0; i < SIZE_PER_UNIT; i += 4) { \
uint32_t r = rnd(); \
AV_WN32A(dst1 + i, r); \
AV_WN32A(dst2 + i, r); \
} \
for (; i < BUF_SIZE; i += 4) { \
uint32_t r = rnd(); \
AV_WN32A(top1 + i, r); \
AV_WN32A(top2 + i, r); \
r = rnd(); \
AV_WN32A(bot1 + i, r); \
AV_WN32A(bot2 + i, r); \
r = rnd(); \
AV_WN32A(dst1 + i, r); \
AV_WN32A(dst2 + i, r); \
} \
} while (0)
#define check_blend_func(depth) \
do { \
int i, w; \
declare_func(void, const uint8_t *top, ptrdiff_t top_linesize, \
const uint8_t *bottom, ptrdiff_t bottom_linesize, \
uint8_t *dst, ptrdiff_t dst_linesize, \
ptrdiff_t width, ptrdiff_t height, \
struct FilterParams *param, double *values); \
w = WIDTH / depth; \
\
for (i = 0; i < BUF_UNITS - 1; i++) { \
int src_offset = i * SIZE_PER_UNIT + (BUF_UNITS - 1 - i) * depth; /* Test various alignments */ \
int dst_offset = i * SIZE_PER_UNIT; /* dst must be aligned */ \
randomize_buffers(); \
call_ref(top1 + src_offset, w, bot1 + src_offset, w, \
dst1 + dst_offset, w, w, HEIGHT, &param, NULL); \
call_new(top2 + src_offset, w, bot2 + src_offset, w, \
dst2 + dst_offset, w, w, HEIGHT, &param, NULL); \
if (memcmp(top1, top2, BUF_SIZE) || memcmp(bot1, bot2, BUF_SIZE) || memcmp(dst1, dst2, BUF_SIZE)) \
fail(); \
} \
bench_new(top2, w / 4, bot2, w / 4, dst2, w / 4, \
w / 4, HEIGHT / 4, &param, NULL); \
} while (0)
void checkasm_check_blend(void)
{
uint8_t *top1 = av_malloc(BUF_SIZE);
uint8_t *top2 = av_malloc(BUF_SIZE);
uint8_t *bot1 = av_malloc(BUF_SIZE);
uint8_t *bot2 = av_malloc(BUF_SIZE);
uint8_t *dst1 = av_malloc(BUF_SIZE);
uint8_t *dst2 = av_malloc(BUF_SIZE);
FilterParams param = {
.opacity = 1.0,
};
#define check_and_report(name, val, depth) \
param.mode = val; \
ff_blend_init(&param, depth - 1); \
if (check_func(param.blend, #name)) \
check_blend_func(depth);
check_and_report(addition, BLEND_ADDITION, 1)
check_and_report(grainmerge, BLEND_GRAINMERGE, 1)
check_and_report(and, BLEND_AND, 1)
check_and_report(average, BLEND_AVERAGE, 1)
check_and_report(darken, BLEND_DARKEN, 1)
check_and_report(grainextract, BLEND_GRAINEXTRACT, 1)
check_and_report(hardmix, BLEND_HARDMIX, 1)
check_and_report(lighten, BLEND_LIGHTEN, 1)
check_and_report(multiply, BLEND_MULTIPLY, 1)
check_and_report(or, BLEND_OR, 1)
check_and_report(phoenix, BLEND_PHOENIX, 1)
check_and_report(screen, BLEND_SCREEN, 1)
check_and_report(subtract, BLEND_SUBTRACT, 1)
check_and_report(xor, BLEND_XOR, 1)
check_and_report(difference, BLEND_DIFFERENCE, 1)
check_and_report(extremity, BLEND_EXTREMITY, 1)
check_and_report(negation, BLEND_NEGATION, 1)
report("8bit");
check_and_report(addition_16, BLEND_ADDITION, 2)
check_and_report(grainmerge_16, BLEND_GRAINMERGE, 2)
check_and_report(and_16, BLEND_AND, 2)
check_and_report(average_16, BLEND_AVERAGE, 2)
check_and_report(darken_16, BLEND_DARKEN, 2)
check_and_report(grainextract_16, BLEND_GRAINEXTRACT, 2)
check_and_report(difference_16, BLEND_DIFFERENCE, 2)
check_and_report(extremity_16, BLEND_EXTREMITY, 2)
check_and_report(negation_16, BLEND_NEGATION, 2)
check_and_report(lighten_16, BLEND_LIGHTEN, 2)
check_and_report(or_16, BLEND_OR, 2)
check_and_report(phoenix_16, BLEND_PHOENIX, 2)
check_and_report(subtract_16, BLEND_SUBTRACT, 2)
check_and_report(xor_16, BLEND_SUBTRACT, 2)
report("16bit");
av_freep(&top1);
av_freep(&top2);
av_freep(&bot1);
av_freep(&bot2);
av_freep(&dst1);
av_freep(&dst2);
}

314
externals/ffmpeg/tests/checkasm/vf_colorspace.c vendored
View File

@@ -1,314 +0,0 @@
/*
* Copyright (c) 2016 Ronald S. Bultje <rsbultje@gmail.com>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <string.h>
#include "checkasm.h"
#include "libavfilter/colorspacedsp.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/intreadwrite.h"
#define W 64
#define H 64
#define randomize_buffers() \
do { \
unsigned mask = bpp_mask[idepth]; \
int n, m; \
int bpp = 1 + (!!idepth); \
int buf_size = W * H * bpp; \
for (m = 0; m < 3; m++) { \
int ss = m ? ss_w + ss_h : 0; \
int plane_sz = buf_size >> ss; \
for (n = 0; n < plane_sz; n += 4) { \
unsigned r = rnd() & mask; \
AV_WN32A(&src[m][n], r); \
} \
} \
} while (0)
static const char *format_string[] = {
"444", "422", "420"
};
static const unsigned bpp_mask[] = { 0xffffffff, 0x03ff03ff, 0x0fff0fff };
static void check_yuv2yuv(void)
{
declare_func(void, uint8_t *dst[3], ptrdiff_t dst_stride[3],
uint8_t *src[3], ptrdiff_t src_stride[3],
int w, int h, const int16_t coeff[3][3][8],
const int16_t off[2][8]);
ColorSpaceDSPContext dsp;
int idepth, odepth, fmt, n;
LOCAL_ALIGNED_32(uint8_t, src_y, [W * H * 2]);
LOCAL_ALIGNED_32(uint8_t, src_u, [W * H * 2]);
LOCAL_ALIGNED_32(uint8_t, src_v, [W * H * 2]);
uint8_t *src[3] = { src_y, src_u, src_v };
LOCAL_ALIGNED_32(uint8_t, dst0_y, [W * H * 2]);
LOCAL_ALIGNED_32(uint8_t, dst0_u, [W * H * 2]);
LOCAL_ALIGNED_32(uint8_t, dst0_v, [W * H * 2]);
LOCAL_ALIGNED_32(uint8_t, dst1_y, [W * H * 2]);
LOCAL_ALIGNED_32(uint8_t, dst1_u, [W * H * 2]);
LOCAL_ALIGNED_32(uint8_t, dst1_v, [W * H * 2]);
uint8_t *dst0[3] = { dst0_y, dst0_u, dst0_v }, *dst1[3] = { dst1_y, dst1_u, dst1_v };
LOCAL_ALIGNED_32(int16_t, offset_buf, [16]);
LOCAL_ALIGNED_32(int16_t, coeff_buf, [3 * 3 * 8]);
int16_t (*offset)[8] = (int16_t(*)[8]) offset_buf;
int16_t (*coeff)[3][8] = (int16_t(*)[3][8]) coeff_buf;
ff_colorspacedsp_init(&dsp);
for (n = 0; n < 8; n++) {
offset[0][n] = offset[1][n] = 16;
coeff[0][0][n] = (1 << 14) + (1 << 7) + 1;
coeff[0][1][n] = (1 << 7) - 1;
coeff[0][2][n] = -(1 << 8);
coeff[1][0][n] = coeff[2][0][n] = 0;
coeff[1][1][n] = (1 << 14) + (1 << 7);
coeff[1][2][n] = -(1 << 7);
coeff[2][2][n] = (1 << 14) - (1 << 6);
coeff[2][1][n] = 1 << 6;
}
for (idepth = 0; idepth < 3; idepth++) {
for (odepth = 0; odepth < 3; odepth++) {
for (fmt = 0; fmt < 3; fmt++) {
if (check_func(dsp.yuv2yuv[idepth][odepth][fmt],
"ff_colorspacedsp_yuv2yuv_%sp%dto%d",
format_string[fmt],
idepth * 2 + 8, odepth * 2 + 8)) {
int ss_w = !!fmt, ss_h = fmt == 2;
int y_src_stride = W << !!idepth, y_dst_stride = W << !!odepth;
int uv_src_stride = y_src_stride >> ss_w, uv_dst_stride = y_dst_stride >> ss_w;
randomize_buffers();
call_ref(dst0, (ptrdiff_t[3]) { y_dst_stride, uv_dst_stride, uv_dst_stride },
src, (ptrdiff_t[3]) { y_src_stride, uv_src_stride, uv_src_stride },
W, H, coeff, offset);
call_new(dst1, (ptrdiff_t[3]) { y_dst_stride, uv_dst_stride, uv_dst_stride },
src, (ptrdiff_t[3]) { y_src_stride, uv_src_stride, uv_src_stride },
W, H, coeff, offset);
if (memcmp(dst0[0], dst1[0], y_dst_stride * H) ||
memcmp(dst0[1], dst1[1], uv_dst_stride * H >> ss_h) ||
memcmp(dst0[2], dst1[2], uv_dst_stride * H >> ss_h)) {
fail();
}
}
}
}
}
report("yuv2yuv");
}
static void check_yuv2rgb(void)
{
declare_func(void, int16_t *dst[3], ptrdiff_t dst_stride,
uint8_t *src[3], ptrdiff_t src_stride[3],
int w, int h, const int16_t coeff[3][3][8],
const int16_t off[8]);
ColorSpaceDSPContext dsp;
int idepth, fmt, n;
LOCAL_ALIGNED_32(uint8_t, src_y, [W * H * 2]);
LOCAL_ALIGNED_32(uint8_t, src_u, [W * H * 2]);
LOCAL_ALIGNED_32(uint8_t, src_v, [W * H * 2]);
uint8_t *src[3] = { src_y, src_u, src_v };
LOCAL_ALIGNED_32(int16_t, dst0_y, [W * H]);
LOCAL_ALIGNED_32(int16_t, dst0_u, [W * H]);
LOCAL_ALIGNED_32(int16_t, dst0_v, [W * H]);
LOCAL_ALIGNED_32(int16_t, dst1_y, [W * H]);
LOCAL_ALIGNED_32(int16_t, dst1_u, [W * H]);
LOCAL_ALIGNED_32(int16_t, dst1_v, [W * H]);
int16_t *dst0[3] = { dst0_y, dst0_u, dst0_v }, *dst1[3] = { dst1_y, dst1_u, dst1_v };
LOCAL_ALIGNED_32(int16_t, offset, [8]);
LOCAL_ALIGNED_32(int16_t, coeff_buf, [3 * 3 * 8]);
int16_t (*coeff)[3][8] = (int16_t(*)[3][8]) coeff_buf;
ff_colorspacedsp_init(&dsp);
for (n = 0; n < 8; n++) {
offset[n] = 16;
coeff[0][0][n] = coeff[1][0][n] = coeff[2][0][n] = (1 << 14) | 1;
coeff[0][1][n] = coeff[2][2][n] = 0;
coeff[0][2][n] = 1 << 13;
coeff[1][1][n] = -(1 << 12);
coeff[1][2][n] = 1 << 12;
coeff[2][1][n] = 1 << 11;
}
for (idepth = 0; idepth < 3; idepth++) {
for (fmt = 0; fmt < 3; fmt++) {
if (check_func(dsp.yuv2rgb[idepth][fmt],
"ff_colorspacedsp_yuv2rgb_%sp%d",
format_string[fmt], idepth * 2 + 8)) {
int ss_w = !!fmt, ss_h = fmt == 2;
int y_src_stride = W << !!idepth;
int uv_src_stride = y_src_stride >> ss_w;
randomize_buffers();
call_ref(dst0, W, src,
(ptrdiff_t[3]) { y_src_stride, uv_src_stride, uv_src_stride },
W, H, coeff, offset);
call_new(dst1, W, src,
(ptrdiff_t[3]) { y_src_stride, uv_src_stride, uv_src_stride },
W, H, coeff, offset);
if (memcmp(dst0[0], dst1[0], W * H * sizeof(int16_t)) ||
memcmp(dst0[1], dst1[1], W * H * sizeof(int16_t)) ||
memcmp(dst0[2], dst1[2], W * H * sizeof(int16_t))) {
fail();
}
}
}
}
report("yuv2rgb");
}
#undef randomize_buffers
#define randomize_buffers() \
do { \
int y, x, p; \
for (p = 0; p < 3; p++) { \
for (y = 0; y < H; y++) { \
for (x = 0; x < W; x++) { \
int r = rnd() & 0x7fff; \
r -= (32768 - 28672) >> 1; \
src[p][y * W + x] = r; \
} \
} \
} \
} while (0)
static void check_rgb2yuv(void)
{
declare_func(void, uint8_t *dst[3], ptrdiff_t dst_stride[3],
int16_t *src[3], ptrdiff_t src_stride,
int w, int h, const int16_t coeff[3][3][8],
const int16_t off[8]);
ColorSpaceDSPContext dsp;
int odepth, fmt, n;
LOCAL_ALIGNED_32(int16_t, src_y, [W * H * 2]);
LOCAL_ALIGNED_32(int16_t, src_u, [W * H * 2]);
LOCAL_ALIGNED_32(int16_t, src_v, [W * H * 2]);
int16_t *src[3] = { src_y, src_u, src_v };
LOCAL_ALIGNED_32(uint8_t, dst0_y, [W * H * 2]);
LOCAL_ALIGNED_32(uint8_t, dst0_u, [W * H * 2]);
LOCAL_ALIGNED_32(uint8_t, dst0_v, [W * H * 2]);
LOCAL_ALIGNED_32(uint8_t, dst1_y, [W * H * 2]);
LOCAL_ALIGNED_32(uint8_t, dst1_u, [W * H * 2]);
LOCAL_ALIGNED_32(uint8_t, dst1_v, [W * H * 2]);
uint8_t *dst0[3] = { dst0_y, dst0_u, dst0_v }, *dst1[3] = { dst1_y, dst1_u, dst1_v };
LOCAL_ALIGNED_32(int16_t, offset, [8]);
LOCAL_ALIGNED_32(int16_t, coeff_buf, [3 * 3 * 8]);
int16_t (*coeff)[3][8] = (int16_t(*)[3][8]) coeff_buf;
ff_colorspacedsp_init(&dsp);
for (n = 0; n < 8; n++) {
offset[n] = 16;
// these somewhat resemble bt601/smpte170m coefficients
coeff[0][0][n] = lrint(0.3 * (1 << 14));
coeff[0][1][n] = lrint(0.6 * (1 << 14));
coeff[0][2][n] = lrint(0.1 * (1 << 14));
coeff[1][0][n] = lrint(-0.15 * (1 << 14));
coeff[1][1][n] = lrint(-0.35 * (1 << 14));
coeff[1][2][n] = lrint(0.5 * (1 << 14));
coeff[2][0][n] = lrint(0.5 * (1 << 14));
coeff[2][1][n] = lrint(-0.42 * (1 << 14));
coeff[2][2][n] = lrint(-0.08 * (1 << 14));
}
for (odepth = 0; odepth < 3; odepth++) {
for (fmt = 0; fmt < 3; fmt++) {
if (check_func(dsp.rgb2yuv[odepth][fmt],
"ff_colorspacedsp_rgb2yuv_%sp%d",
format_string[fmt], odepth * 2 + 8)) {
int ss_w = !!fmt, ss_h = fmt == 2;
int y_dst_stride = W << !!odepth;
int uv_dst_stride = y_dst_stride >> ss_w;
randomize_buffers();
call_ref(dst0, (ptrdiff_t[3]) { y_dst_stride, uv_dst_stride, uv_dst_stride },
src, W, W, H, coeff, offset);
call_new(dst1, (ptrdiff_t[3]) { y_dst_stride, uv_dst_stride, uv_dst_stride },
src, W, W, H, coeff, offset);
if (memcmp(dst0[0], dst1[0], H * y_dst_stride) ||
memcmp(dst0[1], dst1[1], H * uv_dst_stride >> ss_h) ||
memcmp(dst0[2], dst1[2], H * uv_dst_stride >> ss_h)) {
fail();
}
}
}
}
report("rgb2yuv");
}
static void check_multiply3x3(void)
{
declare_func(void, int16_t *data[3], ptrdiff_t stride,
int w, int h, const int16_t coeff[3][3][8]);
ColorSpaceDSPContext dsp;
LOCAL_ALIGNED_32(int16_t, dst0_y, [W * H]);
LOCAL_ALIGNED_32(int16_t, dst0_u, [W * H]);
LOCAL_ALIGNED_32(int16_t, dst0_v, [W * H]);
LOCAL_ALIGNED_32(int16_t, dst1_y, [W * H]);
LOCAL_ALIGNED_32(int16_t, dst1_u, [W * H]);
LOCAL_ALIGNED_32(int16_t, dst1_v, [W * H]);
int16_t *dst0[3] = { dst0_y, dst0_u, dst0_v }, *dst1[3] = { dst1_y, dst1_u, dst1_v };
int16_t **src = dst0;
LOCAL_ALIGNED_32(int16_t, coeff_buf, [3 * 3 * 8]);
int16_t (*coeff)[3][8] = (int16_t(*)[3][8]) coeff_buf;
int n;
ff_colorspacedsp_init(&dsp);
for (n = 0; n < 8; n++) {
coeff[0][0][n] = lrint(0.85 * (1 << 14));
coeff[0][1][n] = lrint(0.10 * (1 << 14));
coeff[0][2][n] = lrint(0.05 * (1 << 14));
coeff[1][0][n] = lrint(-0.1 * (1 << 14));
coeff[1][1][n] = lrint(0.95 * (1 << 14));
coeff[1][2][n] = lrint(0.15 * (1 << 14));
coeff[2][0][n] = lrint(-0.2 * (1 << 14));
coeff[2][1][n] = lrint(0.30 * (1 << 14));
coeff[2][2][n] = lrint(0.90 * (1 << 14));
}
if (check_func(dsp.multiply3x3, "ff_colorspacedsp_multiply3x3")) {
randomize_buffers();
memcpy(dst1_y, dst0_y, W * H * sizeof(*dst1_y));
memcpy(dst1_u, dst0_u, W * H * sizeof(*dst1_u));
memcpy(dst1_v, dst0_v, W * H * sizeof(*dst1_v));
call_ref(dst0, W, W, H, coeff);
call_new(dst1, W, W, H, coeff);
if (memcmp(dst0[0], dst1[0], H * W * sizeof(*dst0_y)) ||
memcmp(dst0[1], dst1[1], H * W * sizeof(*dst0_u)) ||
memcmp(dst0[2], dst1[2], H * W * sizeof(*dst0_v))) {
fail();
}
}
report("multiply3x3");
}
void checkasm_check_colorspace(void)
{
check_yuv2yuv();
check_yuv2rgb();
check_rgb2yuv();
check_multiply3x3();
}

79
externals/ffmpeg/tests/checkasm/vf_eq.c vendored
View File

@@ -1,79 +0,0 @@
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavfilter/avfilter.h"
#include "libavfilter/vf_eq.h"
#include "libavutil/intreadwrite.h"
#define WIDTH 256
#define HEIGHT 256
#define SRC_STRIDE 256
#define PIXELS (WIDTH * HEIGHT)
#define RANDOM_RANGE 80000
#define SCALE 10000
#define randomize_buffers(buf, size) \
do { \
int j; \
uint8_t *tmp_buf = (uint8_t *)buf;\
for (j = 0; j< size; j++) \
tmp_buf[j] = rnd() & 0xFF; \
} while (0)
static void check_eq(void)
{
LOCAL_ALIGNED_32(uint8_t, src, [PIXELS]);
LOCAL_ALIGNED_32(uint8_t, dst_ref, [PIXELS]);
LOCAL_ALIGNED_32(uint8_t, dst_new, [PIXELS]);
int w = WIDTH;
int h = HEIGHT;
int src_stride = SRC_STRIDE;
int dst_stride = SRC_STRIDE;
EQParameters pa;
EQContext eq;
declare_func(void, EQParameters *param, uint8_t *dst, int dst_stride,
const uint8_t *src, int src_stride, int w, int h);
double rand_contrast = (int)(rnd() % (RANDOM_RANGE * 2) - RANDOM_RANGE) /
(SCALE * 1.0);
double rand_brightness = (int)(rnd() % (SCALE * 2) - SCALE) /
(SCALE * 1.0);
pa.contrast = rand_contrast;
pa.brightness = rand_brightness;
memset(dst_ref, 0, PIXELS);
memset(dst_new, 0, PIXELS);
randomize_buffers(src, PIXELS);
ff_eq_init(&eq);
if (check_func(eq.process, "process")) {
call_ref(&pa, dst_ref, dst_stride, src, src_stride, w, h);
call_new(&pa, dst_new, dst_stride, src, src_stride, w, h);
if (memcmp(dst_ref, dst_new, PIXELS))
fail();
bench_new(&pa, dst_new, dst_stride, src, src_stride, w, h);
}
}
void checkasm_check_vf_eq(void)
{
check_eq();
report("eq");
}

66
externals/ffmpeg/tests/checkasm/vf_gblur.c vendored
View File

@@ -1,66 +0,0 @@
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavfilter/gblur.h"
#define WIDTH 256
#define HEIGHT 256
#define PIXELS (WIDTH * HEIGHT)
#define BUF_SIZE (PIXELS * 4)
#define randomize_buffers(buf, size) \
do { \
int j; \
float *tmp_buf = (float *)buf; \
for (j = 0; j < size; j++) \
tmp_buf[j] = (float)(rnd() & 0xFF); \
} while (0)
void checkasm_check_vf_gblur(void)
{
float *dst_ref = av_malloc(BUF_SIZE);
float *dst_new = av_malloc(BUF_SIZE);
int w = WIDTH;
int h = HEIGHT;
int steps = 2;
float nu = 0.101f;
float bscale = 1.112f;
GBlurContext s;
declare_func(void, float *dst, int w, int h, int steps, float nu, float bscale);
randomize_buffers(dst_ref, PIXELS);
memcpy(dst_new, dst_ref, BUF_SIZE);
ff_gblur_init(&s);
if (check_func(s.horiz_slice, "horiz_slice")) {
call_ref(dst_ref, w, h, steps, nu, bscale);
call_new(dst_new, w, h, steps, nu, bscale);
if (!float_near_abs_eps_array(dst_ref, dst_new, 0.01f, PIXELS)) {
fail();
}
bench_new(dst_new, w, h, 1, nu, bscale);
}
report("horiz_slice");
av_freep(&dst_ref);
av_freep(&dst_new);
}

76
externals/ffmpeg/tests/checkasm/vf_hflip.c vendored
View File

@@ -1,76 +0,0 @@
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavfilter/hflip.h"
#include "libavutil/intreadwrite.h"
#define WIDTH 256
#define WIDTH_PADDED 256 + 32
#define randomize_buffers(buf, size) \
do { \
int j; \
uint8_t *tmp_buf = (uint8_t *)buf;\
for (j = 0; j < size; j++) \
tmp_buf[j] = rnd() & 0xFF; \
} while (0)
static void check_hflip(int step, const char * report_name){
LOCAL_ALIGNED_32(uint8_t, src, [WIDTH_PADDED]);
LOCAL_ALIGNED_32(uint8_t, dst_ref, [WIDTH_PADDED]);
LOCAL_ALIGNED_32(uint8_t, dst_new, [WIDTH_PADDED]);
int w = WIDTH;
int i;
int step_array[4] = {1, 1, 1, 1};
FlipContext s;
declare_func(void, const uint8_t *src, uint8_t *dst, int w);
memset(src, 0, WIDTH_PADDED);
memset(dst_ref, 0, WIDTH_PADDED);
memset(dst_new, 0, WIDTH_PADDED);
randomize_buffers(src, WIDTH_PADDED);
if (step == 2) {
w /= 2;
for (i = 0; i < 4; i++)
step_array[i] = step;
}
ff_hflip_init(&s, step_array, 4);
if (check_func(s.flip_line[0], "hflip_%s", report_name)) {
for (i = 1; i < w; i++) {
call_ref(src + (w - 1) * step, dst_ref, i);
call_new(src + (w - 1) * step, dst_new, i);
if (memcmp(dst_ref, dst_new, i * step))
fail();
}
bench_new(src + (w - 1) * step, dst_new, w);
}
}
void checkasm_check_vf_hflip(void)
{
check_hflip(1, "byte");
report("hflip_byte");
check_hflip(2, "short");
report("hflip_short");
}

113
externals/ffmpeg/tests/checkasm/vf_nlmeans.c vendored
View File

@@ -1,113 +0,0 @@
/*
* Copyright (c) 2018 Clément Bœsch <u pkh me>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "checkasm.h"
#include "libavfilter/vf_nlmeans.h"
#include "libavutil/avassert.h"
#define randomize_buffer(buf, size) do { \
int i; \
for (i = 0; i < size / 4; i++) \
((uint32_t *)buf)[i] = rnd(); \
} while (0)
void checkasm_check_nlmeans(void)
{
NLMeansDSPContext dsp = {0};
const int w = 123; // source width
const int h = 45; // source height
const int p = 3; // patch half size
const int r = 2; // research window half size
ff_nlmeans_init(&dsp);
/* See the filter's code for the explanations on the variables */
if (check_func(dsp.compute_safe_ssd_integral_image, "ssd_integral_image")) {
int offx, offy;
const int e = p + r;
const int ii_w = w + e*2;
const int ii_h = h + e*2;
const int ii_lz_32 = FFALIGN(ii_w + 1, 4);
uint32_t *ii_orig_ref = av_mallocz_array(ii_h + 1, ii_lz_32 * sizeof(*ii_orig_ref));
uint32_t *ii_ref = ii_orig_ref + ii_lz_32 + 1;
uint32_t *ii_orig_new = av_mallocz_array(ii_h + 1, ii_lz_32 * sizeof(*ii_orig_new));
uint32_t *ii_new = ii_orig_new + ii_lz_32 + 1;
const int src_lz = FFALIGN(w, 16);
uint8_t *src = av_mallocz_array(h, src_lz);
declare_func(void, uint32_t *dst, ptrdiff_t dst_linesize_32,
const uint8_t *s1, ptrdiff_t linesize1,
const uint8_t *s2, ptrdiff_t linesize2,
int w, int h);
randomize_buffer(src, h * src_lz);
for (offy = -r; offy <= r; offy++) {
for (offx = -r; offx <= r; offx++) {
if (offx || offy) {
const int s1x = e;
const int s1y = e;
const int s2x = e + offx;
const int s2y = e + offy;
const int startx_safe = FFMAX(s1x, s2x);
const int starty_safe = FFMAX(s1y, s2y);
const int u_endx_safe = FFMIN(s1x + w, s2x + w);
const int endy_safe = FFMIN(s1y + h, s2y + h);
const int safe_pw = (u_endx_safe - startx_safe) & ~0xf;
const int safe_ph = endy_safe - starty_safe;
av_assert0(safe_pw && safe_ph);
av_assert0(startx_safe - s1x >= 0); av_assert0(startx_safe - s1x < w);
av_assert0(starty_safe - s1y >= 0); av_assert0(starty_safe - s1y < h);
av_assert0(startx_safe - s2x >= 0); av_assert0(startx_safe - s2x < w);
av_assert0(starty_safe - s2y >= 0); av_assert0(starty_safe - s2y < h);
memset(ii_ref, 0, (ii_lz_32 * ii_h - 1) * sizeof(*ii_ref));
memset(ii_new, 0, (ii_lz_32 * ii_h - 1) * sizeof(*ii_new));
call_ref(ii_ref + starty_safe*ii_lz_32 + startx_safe, ii_lz_32,
src + (starty_safe - s1y) * src_lz + (startx_safe - s1x), src_lz,
src + (starty_safe - s2y) * src_lz + (startx_safe - s2x), src_lz,
safe_pw, safe_ph);
call_new(ii_new + starty_safe*ii_lz_32 + startx_safe, ii_lz_32,
src + (starty_safe - s1y) * src_lz + (startx_safe - s1x), src_lz,
src + (starty_safe - s2y) * src_lz + (startx_safe - s2x), src_lz,
safe_pw, safe_ph);
if (memcmp(ii_ref, ii_new, (ii_lz_32 * ii_h - 1) * sizeof(*ii_ref)))
fail();
memset(ii_new, 0, (ii_lz_32 * ii_h - 1) * sizeof(*ii_new));
bench_new(ii_new + starty_safe*ii_lz_32 + startx_safe, ii_lz_32,
src + (starty_safe - s1y) * src_lz + (startx_safe - s1x), src_lz,
src + (starty_safe - s2y) * src_lz + (startx_safe - s2x), src_lz,
safe_pw, safe_ph);
}
}
}
av_freep(&ii_orig_ref);
av_freep(&ii_orig_new);
av_freep(&src);
}
report("dsp");
}

85
externals/ffmpeg/tests/checkasm/vf_threshold.c vendored
View File

@@ -1,85 +0,0 @@
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavfilter/threshold.h"
#include "libavutil/intreadwrite.h"
#define WIDTH 256
#define WIDTH_PADDED 256 + 32
#define randomize_buffers(buf, size) \
do { \
int j; \
uint8_t *tmp_buf = (uint8_t *)buf;\
for (j = 0; j < size; j++) \
tmp_buf[j] = rnd() & 0xFF; \
} while (0)
static void check_threshold(int depth){
LOCAL_ALIGNED_32(uint8_t, in , [WIDTH_PADDED]);
LOCAL_ALIGNED_32(uint8_t, threshold, [WIDTH_PADDED]);
LOCAL_ALIGNED_32(uint8_t, min , [WIDTH_PADDED]);
LOCAL_ALIGNED_32(uint8_t, max , [WIDTH_PADDED]);
LOCAL_ALIGNED_32(uint8_t, out_ref , [WIDTH_PADDED]);
LOCAL_ALIGNED_32(uint8_t, out_new , [WIDTH_PADDED]);
ptrdiff_t line_size = WIDTH_PADDED;
int w = WIDTH;
declare_func(void, const uint8_t *in, const uint8_t *threshold,
const uint8_t *min, const uint8_t *max, uint8_t *out,
ptrdiff_t ilinesize, ptrdiff_t tlinesize,
ptrdiff_t flinesize, ptrdiff_t slinesize,
ptrdiff_t olinesize, int w, int h);
ThresholdContext s;
s.depth = depth;
ff_threshold_init(&s);
memset(in, 0, WIDTH_PADDED);
memset(threshold, 0, WIDTH_PADDED);
memset(min, 0, WIDTH_PADDED);
memset(max, 0, WIDTH_PADDED);
memset(out_ref, 0, WIDTH_PADDED);
memset(out_new, 0, WIDTH_PADDED);
randomize_buffers(in, WIDTH);
randomize_buffers(threshold, WIDTH);
randomize_buffers(min, WIDTH);
randomize_buffers(max, WIDTH);
if (depth == 16)
w /= 2;
if (check_func(s.threshold, "threshold%d", depth)) {
call_ref(in, threshold, min, max, out_ref, line_size, line_size, line_size, line_size, line_size, w, 1);
call_new(in, threshold, min, max, out_new, line_size, line_size, line_size, line_size, line_size, w, 1);
if (memcmp(out_ref, out_new, WIDTH))
fail();
bench_new(in, threshold, min, max, out_new, line_size, line_size, line_size, line_size, line_size, w, 1);
}
}
void checkasm_check_vf_threshold(void)
{
check_threshold(8);
report("threshold8");
check_threshold(16);
report("threshold16");
}

89
externals/ffmpeg/tests/checkasm/videodsp.c vendored
View File

@@ -1,89 +0,0 @@
/*
* Copyright (c) 2016 Ronald S. Bultje <rsbultje@gmail.com>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "checkasm.h"
#include "libavcodec/videodsp.h"
#include "libavutil/internal.h"
#include "libavutil/intreadwrite.h"
#define randomize_buffers(w, h) \
do { \
int i; \
for (i = 0; i < w * h * sizeof(*src0); i += 4) \
AV_WN32A(((uint8_t *) src0) + i, rnd()); \
} while (0)
#define iter_1d(type, fix, fix_val, var, var_start, var_end) \
for (fix = fix_val, var = var_start; var <= var_end; var++) { \
call_ref((type *) dst0, (const type *) (src0 + y * pw + x), \
bw * sizeof(type), pw * sizeof(type), \
bw, bh, x, y, pw, ph); \
call_new((type *) dst1, (const type *) (src1 + y * pw + x), \
bw * sizeof(type), pw * sizeof(type), \
bw, bh, x, y, pw, ph); \
if (memcmp(dst0, dst1, bw * bh * sizeof(type))) \
fail(); \
bench_new((type *) dst1, (const type *) (src1 + y * pw + x),\
bw * sizeof(type), pw * sizeof(type), \
bw, bh, x, y, pw, ph); \
}
#define check_emu_edge_size(type, src_w, src_h, dst_w, dst_h) \
do { \
LOCAL_ALIGNED_16(type, src0, [src_w * src_h]); \
LOCAL_ALIGNED_16(type, src1, [src_w * src_h]); \
int bw = dst_w, bh = dst_h; \
int pw = src_w, ph = src_h; \
int y, x; \
randomize_buffers(src_w, src_h); \
memcpy(src1, src0, pw * ph * sizeof(type)); \
iter_1d(type, y, 0 - src_h, x, 0 - src_w, src_w - 0); \
iter_1d(type, x, src_w - 0, y, 0 - src_h, src_h - 0); \
iter_1d(type, y, src_h - 0, x, 0 - src_w, src_w - 0); \
iter_1d(type, x, 0 - src_w, y, 0 - src_h, src_h - 0); \
} while (0)
#define check_emu_edge(type) \
do { \
LOCAL_ALIGNED_16(type, dst0, [64 * 64]); \
LOCAL_ALIGNED_16(type, dst1, [64 * 64]); \
declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, \
void, type *dst, const type *src, \
ptrdiff_t dst_linesize, \
ptrdiff_t src_linesize, \
int block_w, int block_h, \
int src_x, int src_y, \
int src_w, int src_h); \
check_emu_edge_size(type, 16, 1, 64, 64); \
check_emu_edge_size(type, 16, 16, 64, 64); \
check_emu_edge_size(type, 64, 64, 64, 64); \
} while (0)
void checkasm_check_videodsp(void)
{
VideoDSPContext vdsp;
ff_videodsp_init(&vdsp, 8);
if (check_func(vdsp.emulated_edge_mc, "emulated_edge_mc_8"))
check_emu_edge(uint8_t);
report("emulated_edge_mc");
}

519
externals/ffmpeg/tests/checkasm/vp8dsp.c vendored
View File

@@ -1,519 +0,0 @@
/*
* Copyright (c) 2016 Martin Storsjo
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <string.h>
#include "libavcodec/avcodec.h"
#include "libavcodec/vp8dsp.h"
#include "libavutil/common.h"
#include "libavutil/intreadwrite.h"
#include "checkasm.h"
#define PIXEL_STRIDE 16
#define randomize_buffers(src, dst, stride, coef) \
do { \
int x, y; \
for (y = 0; y < 4; y++) { \
AV_WN32A((src) + y * (stride), rnd()); \
AV_WN32A((dst) + y * (stride), rnd()); \
for (x = 0; x < 4; x++) \
(coef)[y * 4 + x] = (src)[y * (stride) + x] - \
(dst)[y * (stride) + x]; \
} \
} while (0)
static void dct4x4(int16_t *coef)
{
int i;
for (i = 0; i < 4; i++) {
const int a1 = (coef[i*4 + 0] + coef[i*4 + 3]) * 8;
const int b1 = (coef[i*4 + 1] + coef[i*4 + 2]) * 8;
const int c1 = (coef[i*4 + 1] - coef[i*4 + 2]) * 8;
const int d1 = (coef[i*4 + 0] - coef[i*4 + 3]) * 8;
coef[i*4 + 0] = a1 + b1;
coef[i*4 + 1] = (c1 * 2217 + d1 * 5352 + 14500) >> 12;
coef[i*4 + 2] = a1 - b1;
coef[i*4 + 3] = (d1 * 2217 - c1 * 5352 + 7500) >> 12;
}
for (i = 0; i < 4; i++) {
const int a1 = coef[i + 0*4] + coef[i + 3*4];
const int b1 = coef[i + 1*4] + coef[i + 2*4];
const int c1 = coef[i + 1*4] - coef[i + 2*4];
const int d1 = coef[i + 0*4] - coef[i + 3*4];
coef[i + 0*4] = (a1 + b1 + 7) >> 4;
coef[i + 1*4] = ((c1 * 2217 + d1 * 5352 + 12000) >> 16) + !!d1;
coef[i + 2*4] = (a1 - b1 + 7) >> 4;
coef[i + 3*4] = (d1 * 2217 - c1 * 5352 + 51000) >> 16;
}
}
static void wht4x4(int16_t *coef)
{
int i;
for (i = 0; i < 4; i++) {
int a1 = coef[0 * 4 + i];
int b1 = coef[1 * 4 + i];
int c1 = coef[2 * 4 + i];
int d1 = coef[3 * 4 + i];
int e1;
a1 += b1;
d1 -= c1;
e1 = (a1 - d1) >> 1;
b1 = e1 - b1;
c1 = e1 - c1;
a1 -= c1;
d1 += b1;
coef[0 * 4 + i] = a1;
coef[1 * 4 + i] = c1;
coef[2 * 4 + i] = d1;
coef[3 * 4 + i] = b1;
}
for (i = 0; i < 4; i++) {
int a1 = coef[i * 4 + 0];
int b1 = coef[i * 4 + 1];
int c1 = coef[i * 4 + 2];
int d1 = coef[i * 4 + 3];
int e1;
a1 += b1;
d1 -= c1;
e1 = (a1 - d1) >> 1;
b1 = e1 - b1;
c1 = e1 - c1;
a1 -= c1;
d1 += b1;
coef[i * 4 + 0] = a1 * 2;
coef[i * 4 + 1] = c1 * 2;
coef[i * 4 + 2] = d1 * 2;
coef[i * 4 + 3] = b1 * 2;
}
}
static void check_idct(void)
{
LOCAL_ALIGNED_16(uint8_t, src, [4 * 4]);
LOCAL_ALIGNED_16(uint8_t, dst, [4 * 4]);
LOCAL_ALIGNED_16(uint8_t, dst0, [4 * 4]);
LOCAL_ALIGNED_16(uint8_t, dst1, [4 * 4]);
LOCAL_ALIGNED_16(int16_t, coef, [4 * 4]);
LOCAL_ALIGNED_16(int16_t, subcoef0, [4 * 4]);
LOCAL_ALIGNED_16(int16_t, subcoef1, [4 * 4]);
VP8DSPContext d;
int dc;
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, int16_t *block, ptrdiff_t stride);
ff_vp8dsp_init(&d);
randomize_buffers(src, dst, 4, coef);
dct4x4(coef);
for (dc = 0; dc <= 1; dc++) {
void (*idct)(uint8_t *, int16_t *, ptrdiff_t) = dc ? d.vp8_idct_dc_add : d.vp8_idct_add;
if (check_func(idct, "vp8_idct_%sadd", dc ? "dc_" : "")) {
if (dc) {
memset(subcoef0, 0, 4 * 4 * sizeof(int16_t));
subcoef0[0] = coef[0];
} else {
memcpy(subcoef0, coef, 4 * 4 * sizeof(int16_t));
}
memcpy(dst0, dst, 4 * 4);
memcpy(dst1, dst, 4 * 4);
memcpy(subcoef1, subcoef0, 4 * 4 * sizeof(int16_t));
// Note, this uses a pixel stride of 4, even though the real decoder uses a stride as a
// multiple of 16. If optimizations want to take advantage of that, this test needs to be
// updated to make it more like the h264dsp tests.
call_ref(dst0, subcoef0, 4);
call_new(dst1, subcoef1, 4);
if (memcmp(dst0, dst1, 4 * 4) ||
memcmp(subcoef0, subcoef1, 4 * 4 * sizeof(int16_t)))
fail();
bench_new(dst1, subcoef1, 4);
}
}
}
static void check_idct_dc4(void)
{
LOCAL_ALIGNED_16(uint8_t, src, [4 * 4 * 4]);
LOCAL_ALIGNED_16(uint8_t, dst, [4 * 4 * 4]);
LOCAL_ALIGNED_16(uint8_t, dst0, [4 * 4 * 4]);
LOCAL_ALIGNED_16(uint8_t, dst1, [4 * 4 * 4]);
LOCAL_ALIGNED_16(int16_t, coef, [4], [4 * 4]);
LOCAL_ALIGNED_16(int16_t, subcoef0, [4], [4 * 4]);
LOCAL_ALIGNED_16(int16_t, subcoef1, [4], [4 * 4]);
VP8DSPContext d;
int i, chroma;
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, int16_t block[4][16], ptrdiff_t stride);
ff_vp8dsp_init(&d);
for (chroma = 0; chroma <= 1; chroma++) {
void (*idct4dc)(uint8_t *, int16_t[4][16], ptrdiff_t) = chroma ? d.vp8_idct_dc_add4uv : d.vp8_idct_dc_add4y;
if (check_func(idct4dc, "vp8_idct_dc_add4%s", chroma ? "uv" : "y")) {
ptrdiff_t stride = chroma ? 8 : 16;
int w = chroma ? 2 : 4;
for (i = 0; i < 4; i++) {
int blockx = 4 * (i % w);
int blocky = 4 * (i / w);
randomize_buffers(src + stride * blocky + blockx, dst + stride * blocky + blockx, stride, coef[i]);
dct4x4(coef[i]);
memset(&coef[i][1], 0, 15 * sizeof(int16_t));
}
memcpy(dst0, dst, 4 * 4 * 4);
memcpy(dst1, dst, 4 * 4 * 4);
memcpy(subcoef0, coef, 4 * 4 * 4 * sizeof(int16_t));
memcpy(subcoef1, coef, 4 * 4 * 4 * sizeof(int16_t));
call_ref(dst0, subcoef0, stride);
call_new(dst1, subcoef1, stride);
if (memcmp(dst0, dst1, 4 * 4 * 4) ||
memcmp(subcoef0, subcoef1, 4 * 4 * 4 * sizeof(int16_t)))
fail();
bench_new(dst1, subcoef1, stride);
}
}
}
static void check_luma_dc_wht(void)
{
LOCAL_ALIGNED_16(int16_t, dc, [4 * 4]);
LOCAL_ALIGNED_16(int16_t, dc0, [4 * 4]);
LOCAL_ALIGNED_16(int16_t, dc1, [4 * 4]);
int16_t block[4][4][16];
LOCAL_ALIGNED_16(int16_t, block0, [4], [4][16]);
LOCAL_ALIGNED_16(int16_t, block1, [4], [4][16]);
VP8DSPContext d;
int dc_only;
int blockx, blocky;
declare_func_emms(AV_CPU_FLAG_MMX, void, int16_t block[4][4][16], int16_t dc[16]);
ff_vp8dsp_init(&d);
for (blocky = 0; blocky < 4; blocky++) {
for (blockx = 0; blockx < 4; blockx++) {
uint8_t src[16], dst[16];
randomize_buffers(src, dst, 4, block[blocky][blockx]);
dct4x4(block[blocky][blockx]);
dc[blocky * 4 + blockx] = block[blocky][blockx][0];
block[blocky][blockx][0] = rnd();
}
}
wht4x4(dc);
for (dc_only = 0; dc_only <= 1; dc_only++) {
void (*idct)(int16_t [4][4][16], int16_t [16]) = dc_only ? d.vp8_luma_dc_wht_dc : d.vp8_luma_dc_wht;
if (check_func(idct, "vp8_luma_dc_wht%s", dc_only ? "_dc" : "")) {
if (dc_only) {
memset(dc0, 0, 16 * sizeof(int16_t));
dc0[0] = dc[0];
} else {
memcpy(dc0, dc, 16 * sizeof(int16_t));
}
memcpy(dc1, dc0, 16 * sizeof(int16_t));
memcpy(block0, block, 4 * 4 * 16 * sizeof(int16_t));
memcpy(block1, block, 4 * 4 * 16 * sizeof(int16_t));
call_ref(block0, dc0);
call_new(block1, dc1);
if (memcmp(block0, block1, 4 * 4 * 16 * sizeof(int16_t)) ||
memcmp(dc0, dc1, 16 * sizeof(int16_t)))
fail();
bench_new(block1, dc1);
}
}
}
#define SRC_BUF_STRIDE 32
#define SRC_BUF_SIZE (((size << (size < 16)) + 5) * SRC_BUF_STRIDE)
// The mc subpixel interpolation filter needs the 2 previous pixels in either
// direction, the +1 is to make sure the actual load addresses always are
// unaligned.
#define src (buf + 2 * SRC_BUF_STRIDE + 2 + 1)
#undef randomize_buffers
#define randomize_buffers() \
do { \
int k; \
for (k = 0; k < SRC_BUF_SIZE; k += 4) { \
AV_WN32A(buf + k, rnd()); \
} \
} while (0)
static void check_mc(void)
{
LOCAL_ALIGNED_16(uint8_t, buf, [32 * 32]);
LOCAL_ALIGNED_16(uint8_t, dst0, [16 * 16]);
LOCAL_ALIGNED_16(uint8_t, dst1, [16 * 16]);
VP8DSPContext d;
int type, k, dx, dy;
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, ptrdiff_t, uint8_t *, ptrdiff_t, int, int, int);
ff_vp78dsp_init(&d);
for (type = 0; type < 2; type++) {
vp8_mc_func (*tab)[3][3] = type ? d.put_vp8_bilinear_pixels_tab : d.put_vp8_epel_pixels_tab;
for (k = 1; k < 8; k++) {
int hsize = k / 3;
int size = 16 >> hsize;
int height = (size << 1) >> (k % 3);
for (dy = 0; dy < 3; dy++) {
for (dx = 0; dx < 3; dx++) {
char str[100];
if (dx || dy) {
if (type == 0) {
static const char *dx_names[] = { "", "h4", "h6" };
static const char *dy_names[] = { "", "v4", "v6" };
snprintf(str, sizeof(str), "epel%d_%s%s", size, dx_names[dx], dy_names[dy]);
} else {
snprintf(str, sizeof(str), "bilin%d_%s%s", size, dx ? "h" : "", dy ? "v" : "");
}
} else {
snprintf(str, sizeof(str), "pixels%d", size);
}
if (check_func(tab[hsize][dy][dx], "vp8_put_%s", str)) {
int mx, my;
int i;
if (type == 0) {
mx = dx == 2 ? 2 + 2 * (rnd() % 3) : dx == 1 ? 1 + 2 * (rnd() % 4) : 0;
my = dy == 2 ? 2 + 2 * (rnd() % 3) : dy == 1 ? 1 + 2 * (rnd() % 4) : 0;
} else {
mx = dx ? 1 + (rnd() % 7) : 0;
my = dy ? 1 + (rnd() % 7) : 0;
}
randomize_buffers();
for (i = -2; i <= 3; i++) {
int val = (i == -1 || i == 2) ? 0 : 0xff;
// Set pixels in the first row and column to the maximum pattern,
// to test for potential overflows in the filter.
src[i ] = val;
src[i * SRC_BUF_STRIDE] = val;
}
call_ref(dst0, size, src, SRC_BUF_STRIDE, height, mx, my);
call_new(dst1, size, src, SRC_BUF_STRIDE, height, mx, my);
if (memcmp(dst0, dst1, size * height))
fail();
bench_new(dst1, size, src, SRC_BUF_STRIDE, height, mx, my);
}
}
}
}
}
}
#undef randomize_buffers
#define setpx(a, b, c) buf[(a) + (b) * jstride] = av_clip_uint8(c)
// Set the pixel to c +/- [0,d]
#define setdx(a, b, c, d) setpx(a, b, c - (d) + (rnd() % ((d) * 2 + 1)))
// Set the pixel to c +/- [d,d+e] (making sure it won't be clipped)
#define setdx2(a, b, o, c, d, e) setpx(a, b, o = c + ((d) + (rnd() % (e))) * (c >= 128 ? -1 : 1))
static void randomize_loopfilter_buffers(int lineoff, int str,
int dir, int flim_E, int flim_I,
int hev_thresh, uint8_t *buf,
int force_hev)
{
uint32_t mask = 0xff;
int off = dir ? lineoff : lineoff * str;
int istride = dir ? 1 : str;
int jstride = dir ? str : 1;
int i;
for (i = 0; i < 8; i += 2) {
// Row 0 will trigger hev for q0/q1, row 2 will trigger hev for p0/p1,
// rows 4 and 6 will not trigger hev.
// force_hev 1 will make sure all rows trigger hev, while force_hev -1
// makes none of them trigger it.
int idx = off + i * istride, p2, p1, p0, q0, q1, q2;
setpx(idx, 0, q0 = rnd() & mask);
if (i == 0 && force_hev >= 0 || force_hev > 0)
setdx2(idx, 1, q1, q0, hev_thresh + 1, flim_I - hev_thresh - 1);
else
setdx(idx, 1, q1 = q0, hev_thresh);
setdx(idx, 2, q2 = q1, flim_I);
setdx(idx, 3, q2, flim_I);
setdx(idx, -1, p0 = q0, flim_E >> 2);
if (i == 2 && force_hev >= 0 || force_hev > 0)
setdx2(idx, -2, p1, p0, hev_thresh + 1, flim_I - hev_thresh - 1);
else
setdx(idx, -2, p1 = p0, hev_thresh);
setdx(idx, -3, p2 = p1, flim_I);
setdx(idx, -4, p2, flim_I);
}
}
// Fill the buffer with random pixels
static void fill_loopfilter_buffers(uint8_t *buf, ptrdiff_t stride, int w, int h)
{
int x, y;
for (y = 0; y < h; y++)
for (x = 0; x < w; x++)
buf[y * stride + x] = rnd() & 0xff;
}
#define randomize_buffers(buf, lineoff, str, force_hev) \
randomize_loopfilter_buffers(lineoff, str, dir, flim_E, flim_I, hev_thresh, buf, force_hev)
static void check_loopfilter_16y(void)
{
LOCAL_ALIGNED_16(uint8_t, base0, [32 + 16 * 16]);
LOCAL_ALIGNED_16(uint8_t, base1, [32 + 16 * 16]);
VP8DSPContext d;
int dir, edge, force_hev;
int flim_E = 20, flim_I = 10, hev_thresh = 7;
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, ptrdiff_t, int, int, int);
ff_vp8dsp_init(&d);
for (dir = 0; dir < 2; dir++) {
int midoff = dir ? 4 * 16 : 4;
int midoff_aligned = dir ? 4 * 16 : 16;
uint8_t *buf0 = base0 + midoff_aligned;
uint8_t *buf1 = base1 + midoff_aligned;
for (edge = 0; edge < 2; edge++) {
void (*func)(uint8_t *, ptrdiff_t, int, int, int) = NULL;
switch (dir << 1 | edge) {
case (0 << 1) | 0: func = d.vp8_h_loop_filter16y; break;
case (1 << 1) | 0: func = d.vp8_v_loop_filter16y; break;
case (0 << 1) | 1: func = d.vp8_h_loop_filter16y_inner; break;
case (1 << 1) | 1: func = d.vp8_v_loop_filter16y_inner; break;
}
if (check_func(func, "vp8_loop_filter16y%s_%s", edge ? "_inner" : "", dir ? "v" : "h")) {
for (force_hev = -1; force_hev <= 1; force_hev++) {
fill_loopfilter_buffers(buf0 - midoff, 16, 16, 16);
randomize_buffers(buf0, 0, 16, force_hev);
randomize_buffers(buf0, 8, 16, force_hev);
memcpy(buf1 - midoff, buf0 - midoff, 16 * 16);
call_ref(buf0, 16, flim_E, flim_I, hev_thresh);
call_new(buf1, 16, flim_E, flim_I, hev_thresh);
if (memcmp(buf0 - midoff, buf1 - midoff, 16 * 16))
fail();
}
fill_loopfilter_buffers(buf0 - midoff, 16, 16, 16);
randomize_buffers(buf0, 0, 16, 0);
randomize_buffers(buf0, 8, 16, 0);
bench_new(buf0, 16, flim_E, flim_I, hev_thresh);
}
}
}
}
static void check_loopfilter_8uv(void)
{
LOCAL_ALIGNED_16(uint8_t, base0u, [32 + 16 * 16]);
LOCAL_ALIGNED_16(uint8_t, base0v, [32 + 16 * 16]);
LOCAL_ALIGNED_16(uint8_t, base1u, [32 + 16 * 16]);
LOCAL_ALIGNED_16(uint8_t, base1v, [32 + 16 * 16]);
VP8DSPContext d;
int dir, edge, force_hev;
int flim_E = 20, flim_I = 10, hev_thresh = 7;
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, uint8_t *, ptrdiff_t, int, int, int);
ff_vp8dsp_init(&d);
for (dir = 0; dir < 2; dir++) {
int midoff = dir ? 4 * 16 : 4;
int midoff_aligned = dir ? 4 * 16 : 16;
uint8_t *buf0u = base0u + midoff_aligned;
uint8_t *buf0v = base0v + midoff_aligned;
uint8_t *buf1u = base1u + midoff_aligned;
uint8_t *buf1v = base1v + midoff_aligned;
for (edge = 0; edge < 2; edge++) {
void (*func)(uint8_t *, uint8_t *, ptrdiff_t, int, int, int) = NULL;
switch (dir << 1 | edge) {
case (0 << 1) | 0: func = d.vp8_h_loop_filter8uv; break;
case (1 << 1) | 0: func = d.vp8_v_loop_filter8uv; break;
case (0 << 1) | 1: func = d.vp8_h_loop_filter8uv_inner; break;
case (1 << 1) | 1: func = d.vp8_v_loop_filter8uv_inner; break;
}
if (check_func(func, "vp8_loop_filter8uv%s_%s", edge ? "_inner" : "", dir ? "v" : "h")) {
for (force_hev = -1; force_hev <= 1; force_hev++) {
fill_loopfilter_buffers(buf0u - midoff, 16, 16, 16);
fill_loopfilter_buffers(buf0v - midoff, 16, 16, 16);
randomize_buffers(buf0u, 0, 16, force_hev);
randomize_buffers(buf0v, 0, 16, force_hev);
memcpy(buf1u - midoff, buf0u - midoff, 16 * 16);
memcpy(buf1v - midoff, buf0v - midoff, 16 * 16);
call_ref(buf0u, buf0v, 16, flim_E, flim_I, hev_thresh);
call_new(buf1u, buf1v, 16, flim_E, flim_I, hev_thresh);
if (memcmp(buf0u - midoff, buf1u - midoff, 16 * 16) ||
memcmp(buf0v - midoff, buf1v - midoff, 16 * 16))
fail();
}
fill_loopfilter_buffers(buf0u - midoff, 16, 16, 16);
fill_loopfilter_buffers(buf0v - midoff, 16, 16, 16);
randomize_buffers(buf0u, 0, 16, 0);
randomize_buffers(buf0v, 0, 16, 0);
bench_new(buf0u, buf0v, 16, flim_E, flim_I, hev_thresh);
}
}
}
}
static void check_loopfilter_simple(void)
{
LOCAL_ALIGNED_16(uint8_t, base0, [32 + 16 * 16]);
LOCAL_ALIGNED_16(uint8_t, base1, [32 + 16 * 16]);
VP8DSPContext d;
int dir;
int flim_E = 20, flim_I = 30, hev_thresh = 0;
declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, ptrdiff_t, int);
ff_vp8dsp_init(&d);
for (dir = 0; dir < 2; dir++) {
int midoff = dir ? 4 * 16 : 4;
int midoff_aligned = dir ? 4 * 16 : 16;
uint8_t *buf0 = base0 + midoff_aligned;
uint8_t *buf1 = base1 + midoff_aligned;
void (*func)(uint8_t *, ptrdiff_t, int) = dir ? d.vp8_v_loop_filter_simple : d.vp8_h_loop_filter_simple;
if (check_func(func, "vp8_loop_filter_simple_%s", dir ? "v" : "h")) {
fill_loopfilter_buffers(buf0 - midoff, 16, 16, 16);
randomize_buffers(buf0, 0, 16, -1);
randomize_buffers(buf0, 8, 16, -1);
memcpy(buf1 - midoff, buf0 - midoff, 16 * 16);
call_ref(buf0, 16, flim_E);
call_new(buf1, 16, flim_E);
if (memcmp(buf0 - midoff, buf1 - midoff, 16 * 16))
fail();
bench_new(buf0, 16, flim_E);
}
}
}
void checkasm_check_vp8dsp(void)
{
check_idct();
check_idct_dc4();
check_luma_dc_wht();
report("idct");
check_mc();
report("mc");
check_loopfilter_16y();
check_loopfilter_8uv();
check_loopfilter_simple();
report("loopfilter");
}

631
externals/ffmpeg/tests/checkasm/vp9dsp.c vendored
View File

@@ -1,631 +0,0 @@
/*
* Copyright (c) 2015 Ronald S. Bultje <rsbultje@gmail.com>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <math.h>
#include <string.h>
#include "checkasm.h"
#include "libavcodec/vp9data.h"
#include "libavcodec/vp9.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/mathematics.h"
static const uint32_t pixel_mask[3] = { 0xffffffff, 0x03ff03ff, 0x0fff0fff };
#define SIZEOF_PIXEL ((bit_depth + 7) / 8)
#define randomize_buffers() \
do { \
uint32_t mask = pixel_mask[(bit_depth - 8) >> 1]; \
int k; \
for (k = -4; k < SIZEOF_PIXEL * FFMAX(8, size); k += 4) { \
uint32_t r = rnd() & mask; \
AV_WN32A(a + k, r); \
} \
for (k = 0; k < size * SIZEOF_PIXEL; k += 4) { \
uint32_t r = rnd() & mask; \
AV_WN32A(l + k, r); \
} \
} while (0)
static void check_ipred(void)
{
LOCAL_ALIGNED_32(uint8_t, a_buf, [64 * 2]);
uint8_t *a = &a_buf[32 * 2];
LOCAL_ALIGNED_32(uint8_t, l, [32 * 2]);
LOCAL_ALIGNED_32(uint8_t, dst0, [32 * 32 * 2]);
LOCAL_ALIGNED_32(uint8_t, dst1, [32 * 32 * 2]);
VP9DSPContext dsp;
int tx, mode, bit_depth;
declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *dst, ptrdiff_t stride,
const uint8_t *left, const uint8_t *top);
static const char *const mode_names[N_INTRA_PRED_MODES] = {
[VERT_PRED] = "vert",
[HOR_PRED] = "hor",
[DC_PRED] = "dc",
[DIAG_DOWN_LEFT_PRED] = "diag_downleft",
[DIAG_DOWN_RIGHT_PRED] = "diag_downright",
[VERT_RIGHT_PRED] = "vert_right",
[HOR_DOWN_PRED] = "hor_down",
[VERT_LEFT_PRED] = "vert_left",
[HOR_UP_PRED] = "hor_up",
[TM_VP8_PRED] = "tm",
[LEFT_DC_PRED] = "dc_left",
[TOP_DC_PRED] = "dc_top",
[DC_128_PRED] = "dc_128",
[DC_127_PRED] = "dc_127",
[DC_129_PRED] = "dc_129",
};
for (bit_depth = 8; bit_depth <= 12; bit_depth += 2) {
ff_vp9dsp_init(&dsp, bit_depth, 0);
for (tx = 0; tx < 4; tx++) {
int size = 4 << tx;
for (mode = 0; mode < N_INTRA_PRED_MODES; mode++) {
if (check_func(dsp.intra_pred[tx][mode], "vp9_%s_%dx%d_%dbpp",
mode_names[mode], size, size, bit_depth)) {
randomize_buffers();
call_ref(dst0, size * SIZEOF_PIXEL, l, a);
call_new(dst1, size * SIZEOF_PIXEL, l, a);
if (memcmp(dst0, dst1, size * size * SIZEOF_PIXEL))
fail();
bench_new(dst1, size * SIZEOF_PIXEL,l, a);
}
}
}
}
report("ipred");
}
#undef randomize_buffers
#define randomize_buffers() \
do { \
uint32_t mask = pixel_mask[(bit_depth - 8) >> 1]; \
for (y = 0; y < sz; y++) { \
for (x = 0; x < sz * SIZEOF_PIXEL; x += 4) { \
uint32_t r = rnd() & mask; \
AV_WN32A(dst + y * sz * SIZEOF_PIXEL + x, r); \
AV_WN32A(src + y * sz * SIZEOF_PIXEL + x, rnd() & mask); \
} \
for (x = 0; x < sz; x++) { \
if (bit_depth == 8) { \
coef[y * sz + x] = src[y * sz + x] - dst[y * sz + x]; \
} else { \
((int32_t *) coef)[y * sz + x] = \
((uint16_t *) src)[y * sz + x] - \
((uint16_t *) dst)[y * sz + x]; \
} \
} \
} \
} while(0)
// wht function copied from libvpx
static void fwht_1d(double *out, const double *in, int sz)
{
double t0 = in[0] + in[1];
double t3 = in[3] - in[2];
double t4 = trunc((t0 - t3) * 0.5);
double t1 = t4 - in[1];
double t2 = t4 - in[2];
out[0] = t0 - t2;
out[1] = t2;
out[2] = t3 + t1;
out[3] = t1;
}
// standard DCT-II
static void fdct_1d(double *out, const double *in, int sz)
{
int k, n;
for (k = 0; k < sz; k++) {
out[k] = 0.0;
for (n = 0; n < sz; n++)
out[k] += in[n] * cos(M_PI * (2 * n + 1) * k / (sz * 2.0));
}
out[0] *= M_SQRT1_2;
}
// see "Towards jointly optimal spatial prediction and adaptive transform in
// video/image coding", by J. Han, A. Saxena, and K. Rose
// IEEE Proc. ICASSP, pp. 726-729, Mar. 2010.
static void fadst4_1d(double *out, const double *in, int sz)
{
int k, n;
for (k = 0; k < sz; k++) {
out[k] = 0.0;
for (n = 0; n < sz; n++)
out[k] += in[n] * sin(M_PI * (n + 1) * (2 * k + 1) / (sz * 2.0 + 1.0));
}
}
// see "A Butterfly Structured Design of The Hybrid Transform Coding Scheme",
// by Jingning Han, Yaowu Xu, and Debargha Mukherjee
// http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/41418.pdf
static void fadst_1d(double *out, const double *in, int sz)
{
int k, n;
for (k = 0; k < sz; k++) {
out[k] = 0.0;
for (n = 0; n < sz; n++)
out[k] += in[n] * sin(M_PI * (2 * n + 1) * (2 * k + 1) / (sz * 4.0));
}
}
typedef void (*ftx1d_fn)(double *out, const double *in, int sz);
static void ftx_2d(double *out, const double *in, enum TxfmMode tx,
enum TxfmType txtp, int sz)
{
static const double scaling_factors[5][4] = {
{ 4.0, 16.0 * M_SQRT1_2 / 3.0, 16.0 * M_SQRT1_2 / 3.0, 32.0 / 9.0 },
{ 2.0, 2.0, 2.0, 2.0 },
{ 1.0, 1.0, 1.0, 1.0 },
{ 0.25 },
{ 4.0 }
};
static const ftx1d_fn ftx1d_tbl[5][4][2] = {
{
{ fdct_1d, fdct_1d },
{ fadst4_1d, fdct_1d },
{ fdct_1d, fadst4_1d },
{ fadst4_1d, fadst4_1d },
}, {
{ fdct_1d, fdct_1d },
{ fadst_1d, fdct_1d },
{ fdct_1d, fadst_1d },
{ fadst_1d, fadst_1d },
}, {
{ fdct_1d, fdct_1d },
{ fadst_1d, fdct_1d },
{ fdct_1d, fadst_1d },
{ fadst_1d, fadst_1d },
}, {
{ fdct_1d, fdct_1d },
}, {
{ fwht_1d, fwht_1d },
},
};
double temp[1024];
double scaling_factor = scaling_factors[tx][txtp];
int i, j;
// cols
for (i = 0; i < sz; ++i) {
double temp_out[32];
ftx1d_tbl[tx][txtp][0](temp_out, &in[i * sz], sz);
// scale and transpose
for (j = 0; j < sz; ++j)
temp[j * sz + i] = temp_out[j] * scaling_factor;
}
// rows
for (i = 0; i < sz; i++)
ftx1d_tbl[tx][txtp][1](&out[i * sz], &temp[i * sz], sz);
}
static void ftx(int16_t *buf, enum TxfmMode tx,
enum TxfmType txtp, int sz, int bit_depth)
{
double ind[1024], outd[1024];
int n;
emms_c();
for (n = 0; n < sz * sz; n++) {
if (bit_depth == 8)
ind[n] = buf[n];
else
ind[n] = ((int32_t *) buf)[n];
}
ftx_2d(outd, ind, tx, txtp, sz);
for (n = 0; n < sz * sz; n++) {
if (bit_depth == 8)
buf[n] = lrint(outd[n]);
else
((int32_t *) buf)[n] = lrint(outd[n]);
}
}
static int copy_subcoefs(int16_t *out, const int16_t *in, enum TxfmMode tx,
enum TxfmType txtp, int sz, int sub, int bit_depth)
{
// copy the topleft coefficients such that the return value (being the
// coefficient scantable index for the eob token) guarantees that only
// the topleft $sub out of $sz (where $sz >= $sub) coefficients in both
// dimensions are non-zero. This leads to braching to specific optimized
// simd versions (e.g. dc-only) so that we get full asm coverage in this
// test
int n;
const int16_t *scan = ff_vp9_scans[tx][txtp];
int eob;
for (n = 0; n < sz * sz; n++) {
int rc = scan[n], rcx = rc % sz, rcy = rc / sz;
// find eob for this sub-idct
if (rcx >= sub || rcy >= sub)
break;
// copy coef
if (bit_depth == 8) {
out[rc] = in[rc];
} else {
AV_COPY32(&out[rc * 2], &in[rc * 2]);
}
}
eob = n;
for (; n < sz * sz; n++) {
int rc = scan[n];
// zero
if (bit_depth == 8) {
out[rc] = 0;
} else {
AV_ZERO32(&out[rc * 2]);
}
}
return eob;
}
static int iszero(const int16_t *c, int sz)
{
int n;
for (n = 0; n < sz / sizeof(int16_t); n += 2)
if (AV_RN32A(&c[n]))
return 0;
return 1;
}
#define SIZEOF_COEF (2 * ((bit_depth + 7) / 8))
static void check_itxfm(void)
{
LOCAL_ALIGNED_32(uint8_t, src, [32 * 32 * 2]);
LOCAL_ALIGNED_32(uint8_t, dst, [32 * 32 * 2]);
LOCAL_ALIGNED_32(uint8_t, dst0, [32 * 32 * 2]);
LOCAL_ALIGNED_32(uint8_t, dst1, [32 * 32 * 2]);
LOCAL_ALIGNED_32(int16_t, coef, [32 * 32 * 2]);
LOCAL_ALIGNED_32(int16_t, subcoef0, [32 * 32 * 2]);
LOCAL_ALIGNED_32(int16_t, subcoef1, [32 * 32 * 2]);
declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *dst, ptrdiff_t stride, int16_t *block, int eob);
VP9DSPContext dsp;
int y, x, tx, txtp, bit_depth, sub;
static const char *const txtp_types[N_TXFM_TYPES] = {
[DCT_DCT] = "dct_dct", [DCT_ADST] = "adst_dct",
[ADST_DCT] = "dct_adst", [ADST_ADST] = "adst_adst"
};
for (bit_depth = 8; bit_depth <= 12; bit_depth += 2) {
ff_vp9dsp_init(&dsp, bit_depth, 0);
for (tx = TX_4X4; tx <= N_TXFM_SIZES /* 4 = lossless */; tx++) {
int sz = 4 << (tx & 3);
int n_txtps = tx < TX_32X32 ? N_TXFM_TYPES : 1;
for (txtp = 0; txtp < n_txtps; txtp++) {
// skip testing sub-IDCTs for WHT or ADST since they don't
// implement it in any of the SIMD functions. If they do,
// consider changing this to ensure we have complete test
// coverage. Test sub=1 for dc-only, then 2, 4, 8, 12, etc,
// since the arm version can distinguish them at that level.
for (sub = (txtp == 0 && tx < 4) ? 1 : sz; sub <= sz;
sub < 4 ? (sub <<= 1) : (sub += 4)) {
if (check_func(dsp.itxfm_add[tx][txtp],
"vp9_inv_%s_%dx%d_sub%d_add_%d",
tx == 4 ? "wht_wht" : txtp_types[txtp],
sz, sz, sub, bit_depth)) {
int eob;
randomize_buffers();
ftx(coef, tx, txtp, sz, bit_depth);
if (sub < sz) {
eob = copy_subcoefs(subcoef0, coef, tx, txtp,
sz, sub, bit_depth);
} else {
eob = sz * sz;
memcpy(subcoef0, coef, sz * sz * SIZEOF_COEF);
}
memcpy(dst0, dst, sz * sz * SIZEOF_PIXEL);
memcpy(dst1, dst, sz * sz * SIZEOF_PIXEL);
memcpy(subcoef1, subcoef0, sz * sz * SIZEOF_COEF);
call_ref(dst0, sz * SIZEOF_PIXEL, subcoef0, eob);
call_new(dst1, sz * SIZEOF_PIXEL, subcoef1, eob);
if (memcmp(dst0, dst1, sz * sz * SIZEOF_PIXEL) ||
!iszero(subcoef0, sz * sz * SIZEOF_COEF) ||
!iszero(subcoef1, sz * sz * SIZEOF_COEF))
fail();
bench_new(dst, sz * SIZEOF_PIXEL, coef, eob);
}
}
}
}
}
report("itxfm");
}
#undef randomize_buffers
#define setpx(a,b,c) \
do { \
if (SIZEOF_PIXEL == 1) { \
buf0[(a) + (b) * jstride] = av_clip_uint8(c); \
} else { \
((uint16_t *)buf0)[(a) + (b) * jstride] = av_clip_uintp2(c, bit_depth); \
} \
} while (0)
// c can be an assignment and must not be put under ()
#define setdx(a,b,c,d) setpx(a,b,c-(d)+(rnd()%((d)*2+1)))
#define setsx(a,b,c,d) setdx(a,b,c,(d) << (bit_depth - 8))
static void randomize_loopfilter_buffers(int bidx, int lineoff, int str,
int bit_depth, int dir, const int *E,
const int *F, const int *H, const int *I,
uint8_t *buf0, uint8_t *buf1)
{
uint32_t mask = (1 << bit_depth) - 1;
int off = dir ? lineoff : lineoff * 16;
int istride = dir ? 1 : 16;
int jstride = dir ? str : 1;
int i, j;
for (i = 0; i < 2; i++) /* flat16 */ {
int idx = off + i * istride, p0, q0;
setpx(idx, 0, q0 = rnd() & mask);
setsx(idx, -1, p0 = q0, E[bidx] >> 2);
for (j = 1; j < 8; j++) {
setsx(idx, -1 - j, p0, F[bidx]);
setsx(idx, j, q0, F[bidx]);
}
}
for (i = 2; i < 4; i++) /* flat8 */ {
int idx = off + i * istride, p0, q0;
setpx(idx, 0, q0 = rnd() & mask);
setsx(idx, -1, p0 = q0, E[bidx] >> 2);
for (j = 1; j < 4; j++) {
setsx(idx, -1 - j, p0, F[bidx]);
setsx(idx, j, q0, F[bidx]);
}
for (j = 4; j < 8; j++) {
setpx(idx, -1 - j, rnd() & mask);
setpx(idx, j, rnd() & mask);
}
}
for (i = 4; i < 6; i++) /* regular */ {
int idx = off + i * istride, p2, p1, p0, q0, q1, q2;
setpx(idx, 0, q0 = rnd() & mask);
setsx(idx, 1, q1 = q0, I[bidx]);
setsx(idx, 2, q2 = q1, I[bidx]);
setsx(idx, 3, q2, I[bidx]);
setsx(idx, -1, p0 = q0, E[bidx] >> 2);
setsx(idx, -2, p1 = p0, I[bidx]);
setsx(idx, -3, p2 = p1, I[bidx]);
setsx(idx, -4, p2, I[bidx]);
for (j = 4; j < 8; j++) {
setpx(idx, -1 - j, rnd() & mask);
setpx(idx, j, rnd() & mask);
}
}
for (i = 6; i < 8; i++) /* off */ {
int idx = off + i * istride;
for (j = 0; j < 8; j++) {
setpx(idx, -1 - j, rnd() & mask);
setpx(idx, j, rnd() & mask);
}
}
}
#define randomize_buffers(bidx, lineoff, str) \
randomize_loopfilter_buffers(bidx, lineoff, str, bit_depth, dir, \
E, F, H, I, buf0, buf1)
static void check_loopfilter(void)
{
LOCAL_ALIGNED_32(uint8_t, base0, [32 + 16 * 16 * 2]);
LOCAL_ALIGNED_32(uint8_t, base1, [32 + 16 * 16 * 2]);
VP9DSPContext dsp;
int dir, wd, wd2, bit_depth;
static const char *const dir_name[2] = { "h", "v" };
static const int E[2] = { 20, 28 }, I[2] = { 10, 16 };
static const int H[2] = { 7, 11 }, F[2] = { 1, 1 };
declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *dst, ptrdiff_t stride, int E, int I, int H);
for (bit_depth = 8; bit_depth <= 12; bit_depth += 2) {
ff_vp9dsp_init(&dsp, bit_depth, 0);
for (dir = 0; dir < 2; dir++) {
int midoff = (dir ? 8 * 8 : 8) * SIZEOF_PIXEL;
int midoff_aligned = (dir ? 8 * 8 : 16) * SIZEOF_PIXEL;
uint8_t *buf0 = base0 + midoff_aligned;
uint8_t *buf1 = base1 + midoff_aligned;
for (wd = 0; wd < 3; wd++) {
// 4/8/16wd_8px
if (check_func(dsp.loop_filter_8[wd][dir],
"vp9_loop_filter_%s_%d_8_%dbpp",
dir_name[dir], 4 << wd, bit_depth)) {
randomize_buffers(0, 0, 8);
memcpy(buf1 - midoff, buf0 - midoff,
16 * 8 * SIZEOF_PIXEL);
call_ref(buf0, 16 * SIZEOF_PIXEL >> dir, E[0], I[0], H[0]);
call_new(buf1, 16 * SIZEOF_PIXEL >> dir, E[0], I[0], H[0]);
if (memcmp(buf0 - midoff, buf1 - midoff, 16 * 8 * SIZEOF_PIXEL))
fail();
bench_new(buf1, 16 * SIZEOF_PIXEL >> dir, E[0], I[0], H[0]);
}
}
midoff = (dir ? 16 * 8 : 8) * SIZEOF_PIXEL;
midoff_aligned = (dir ? 16 * 8 : 16) * SIZEOF_PIXEL;
buf0 = base0 + midoff_aligned;
buf1 = base1 + midoff_aligned;
// 16wd_16px loopfilter
if (check_func(dsp.loop_filter_16[dir],
"vp9_loop_filter_%s_16_16_%dbpp",
dir_name[dir], bit_depth)) {
randomize_buffers(0, 0, 16);
randomize_buffers(0, 8, 16);
memcpy(buf1 - midoff, buf0 - midoff, 16 * 16 * SIZEOF_PIXEL);
call_ref(buf0, 16 * SIZEOF_PIXEL, E[0], I[0], H[0]);
call_new(buf1, 16 * SIZEOF_PIXEL, E[0], I[0], H[0]);
if (memcmp(buf0 - midoff, buf1 - midoff, 16 * 16 * SIZEOF_PIXEL))
fail();
bench_new(buf1, 16 * SIZEOF_PIXEL, E[0], I[0], H[0]);
}
for (wd = 0; wd < 2; wd++) {
for (wd2 = 0; wd2 < 2; wd2++) {
// mix2 loopfilter
if (check_func(dsp.loop_filter_mix2[wd][wd2][dir],
"vp9_loop_filter_mix2_%s_%d%d_16_%dbpp",
dir_name[dir], 4 << wd, 4 << wd2, bit_depth)) {
randomize_buffers(0, 0, 16);
randomize_buffers(1, 8, 16);
memcpy(buf1 - midoff, buf0 - midoff, 16 * 16 * SIZEOF_PIXEL);
#define M(a) (((a)[1] << 8) | (a)[0])
call_ref(buf0, 16 * SIZEOF_PIXEL, M(E), M(I), M(H));
call_new(buf1, 16 * SIZEOF_PIXEL, M(E), M(I), M(H));
if (memcmp(buf0 - midoff, buf1 - midoff, 16 * 16 * SIZEOF_PIXEL))
fail();
bench_new(buf1, 16 * SIZEOF_PIXEL, M(E), M(I), M(H));
#undef M
}
}
}
}
}
report("loopfilter");
}
#undef setsx
#undef setpx
#undef setdx
#undef randomize_buffers
#define DST_BUF_SIZE (size * size * SIZEOF_PIXEL)
#define SRC_BUF_STRIDE 72
#define SRC_BUF_SIZE ((size + 7) * SRC_BUF_STRIDE * SIZEOF_PIXEL)
#define src (buf + 3 * SIZEOF_PIXEL * (SRC_BUF_STRIDE + 1))
#define randomize_buffers() \
do { \
uint32_t mask = pixel_mask[(bit_depth - 8) >> 1]; \
int k; \
for (k = 0; k < SRC_BUF_SIZE; k += 4) { \
uint32_t r = rnd() & mask; \
AV_WN32A(buf + k, r); \
} \
if (op == 1) { \
for (k = 0; k < DST_BUF_SIZE; k += 4) { \
uint32_t r = rnd() & mask; \
AV_WN32A(dst0 + k, r); \
AV_WN32A(dst1 + k, r); \
} \
} \
} while (0)
static void check_mc(void)
{
LOCAL_ALIGNED_32(uint8_t, buf, [72 * 72 * 2]);
LOCAL_ALIGNED_32(uint8_t, dst0, [64 * 64 * 2]);
LOCAL_ALIGNED_32(uint8_t, dst1, [64 * 64 * 2]);
VP9DSPContext dsp;
int op, hsize, bit_depth, filter, dx, dy;
declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *dst, ptrdiff_t dst_stride,
const uint8_t *ref, ptrdiff_t ref_stride,
int h, int mx, int my);
static const char *const filter_names[4] = {
"8tap_smooth", "8tap_regular", "8tap_sharp", "bilin"
};
static const char *const subpel_names[2][2] = { { "", "h" }, { "v", "hv" } };
static const char *const op_names[2] = { "put", "avg" };
char str[256];
for (op = 0; op < 2; op++) {
for (bit_depth = 8; bit_depth <= 12; bit_depth += 2) {
ff_vp9dsp_init(&dsp, bit_depth, 0);
for (hsize = 0; hsize < 5; hsize++) {
int size = 64 >> hsize;
for (filter = 0; filter < 4; filter++) {
for (dx = 0; dx < 2; dx++) {
for (dy = 0; dy < 2; dy++) {
if (dx || dy) {
snprintf(str, sizeof(str),
"%s_%s_%d%s", op_names[op],
filter_names[filter], size,
subpel_names[dy][dx]);
} else {
snprintf(str, sizeof(str),
"%s%d", op_names[op], size);
}
if (check_func(dsp.mc[hsize][filter][op][dx][dy],
"vp9_%s_%dbpp", str, bit_depth)) {
int mx = dx ? 1 + (rnd() % 14) : 0;
int my = dy ? 1 + (rnd() % 14) : 0;
randomize_buffers();
call_ref(dst0, size * SIZEOF_PIXEL,
src, SRC_BUF_STRIDE * SIZEOF_PIXEL,
size, mx, my);
call_new(dst1, size * SIZEOF_PIXEL,
src, SRC_BUF_STRIDE * SIZEOF_PIXEL,
size, mx, my);
if (memcmp(dst0, dst1, DST_BUF_SIZE))
fail();
// simd implementations for each filter of subpel
// functions are identical
if (filter >= 1 && filter <= 2) continue;
// 10/12 bpp for bilin are identical
if (bit_depth == 12 && filter == 3) continue;
bench_new(dst1, size * SIZEOF_PIXEL,
src, SRC_BUF_STRIDE * SIZEOF_PIXEL,
size, mx, my);
}
}
}
}
}
}
}
report("mc");
}
void checkasm_check_vp9dsp(void)
{
check_ipred();
check_itxfm();
check_loopfilter();
check_mc();
}

244
externals/ffmpeg/tests/checkasm/x86/checkasm.asm vendored
View File

@@ -1,244 +0,0 @@
;*****************************************************************************
;* Assembly testing and benchmarking tool
;* Copyright (c) 2008 Loren Merritt
;* Copyright (c) 2012 Henrik Gramner
;*
;* This file is part of FFmpeg.
;*
;* FFmpeg is free software; you can redistribute it and/or modify
;* it under the terms of the GNU General Public License as published by
;* the Free Software Foundation; either version 2 of the License, or
;* (at your option) any later version.
;*
;* FFmpeg is distributed in the hope that it will be useful,
;* but WITHOUT ANY WARRANTY; without even the implied warranty of
;* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;* GNU General Public License for more details.
;*
;* You should have received a copy of the GNU General Public License
;* along with this program; if not, write to the Free Software
;* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
;*****************************************************************************
%define private_prefix checkasm
%include "libavutil/x86/x86inc.asm"
SECTION_RODATA
error_message: db "failed to preserve register", 0
error_message_emms: db "failed to issue emms", 0
%if ARCH_X86_64
; just random numbers to reduce the chance of incidental match
ALIGN 16
x6: dq 0x1a1b2550a612b48c,0x79445c159ce79064
x7: dq 0x2eed899d5a28ddcd,0x86b2536fcd8cf636
x8: dq 0xb0856806085e7943,0x3f2bf84fc0fcca4e
x9: dq 0xacbd382dcf5b8de2,0xd229e1f5b281303f
x10: dq 0x71aeaff20b095fd9,0xab63e2e11fa38ed9
x11: dq 0x89b0c0765892729a,0x77d410d5c42c882d
x12: dq 0xc45ea11a955d8dd5,0x24b3c1d2a024048b
x13: dq 0x2e8ec680de14b47c,0xdd7b8919edd42786
x14: dq 0x135ce6888fa02cbf,0x11e53e2b2ac655ef
x15: dq 0x011ff554472a7a10,0x6de8f4c914c334d5
n7: dq 0x21f86d66c8ca00ce
n8: dq 0x75b6ba21077c48ad
n9: dq 0xed56bb2dcb3c7736
n10: dq 0x8bda43d3fd1a7e06
n11: dq 0xb64a9c9e5d318408
n12: dq 0xdf9a54b303f1d3a3
n13: dq 0x4a75479abd64e097
n14: dq 0x249214109d5d1c88
%endif
SECTION .text
cextern fail_func
; max number of args used by any asm function.
; (max_args % 4) must equal 3 for stack alignment
%define max_args 15
%if ARCH_X86_64
;-----------------------------------------------------------------------------
; int checkasm_stack_clobber(uint64_t clobber, ...)
;-----------------------------------------------------------------------------
cglobal stack_clobber, 1,2
; Clobber the stack with junk below the stack pointer
%define argsize (max_args+6)*8
SUB rsp, argsize
mov r1, argsize-8
.loop:
mov [rsp+r1], r0
sub r1, 8
jge .loop
ADD rsp, argsize
RET
%if WIN64
%assign free_regs 7
DECLARE_REG_TMP 4
%else
%assign free_regs 9
DECLARE_REG_TMP 7
%endif
%macro report_fail 1
mov r9, rax
mov r10, rdx
lea r0, [%1]
xor eax, eax
call fail_func
mov rdx, r10
mov rax, r9
%endmacro
;-----------------------------------------------------------------------------
; void checkasm_checked_call(void *func, ...)
;-----------------------------------------------------------------------------
INIT_XMM
%macro CHECKED_CALL 0-1
cglobal checked_call%1, 2,15,16,max_args*8+8
mov t0, r0
; All arguments have been pushed on the stack instead of registers in order to
; test for incorrect assumptions that 32-bit ints are zero-extended to 64-bit.
mov r0, r6mp
mov r1, r7mp
mov r2, r8mp
mov r3, r9mp
%if UNIX64
mov r4, r10mp
mov r5, r11mp
%assign i 6
%rep max_args-6
mov r9, [rsp+stack_offset+(i+1)*8]
mov [rsp+(i-6)*8], r9
%assign i i+1
%endrep
%else ; WIN64
%assign i 4
%rep max_args-4
mov r9, [rsp+stack_offset+(i+7)*8]
mov [rsp+i*8], r9
%assign i i+1
%endrep
; Move possible floating-point arguments to the correct registers
movq m0, r0
movq m1, r1
movq m2, r2
movq m3, r3
%assign i 6
%rep 16-6
mova m %+ i, [x %+ i]
%assign i i+1
%endrep
%endif
%assign i 14
%rep 15-free_regs
mov r %+ i, [n %+ i]
%assign i i-1
%endrep
call t0
%assign i 14
%rep 15-free_regs
xor r %+ i, [n %+ i]
or r14, r %+ i
%assign i i-1
%endrep
%if WIN64
%assign i 6
%rep 16-6
pxor m %+ i, [x %+ i]
por m6, m %+ i
%assign i i+1
%endrep
packsswb m6, m6
movq r5, m6
or r14, r5
%endif
; Call fail_func() with a descriptive message to mark it as a failure
; if the called function didn't preserve all callee-saved registers.
; Save the return value located in rdx:rax first to prevent clobbering.
jz .clobber_ok
report_fail error_message
.clobber_ok:
%ifidn %1, _emms
emms
%elifnidn %1, _float
fstenv [rsp]
cmp word [rsp + 8], 0xffff
je .emms_ok
report_fail error_message_emms
emms
.emms_ok:
%endif
RET
%endmacro
%else
; just random numbers to reduce the chance of incidental match
%define n3 dword 0x6549315c
%define n4 dword 0xe02f3e23
%define n5 dword 0xb78d0d1d
%define n6 dword 0x33627ba7
%macro report_fail 1
mov r3, eax
mov r4, edx
lea r0, [%1]
mov [esp], r0
call fail_func
mov edx, r4
mov eax, r3
%endmacro
%macro CHECKED_CALL 0-1
;-----------------------------------------------------------------------------
; void checkasm_checked_call(void *func, ...)
;-----------------------------------------------------------------------------
cglobal checked_call%1, 1,7
mov r3, n3
mov r4, n4
mov r5, n5
mov r6, n6
%rep max_args
PUSH dword [esp+20+max_args*4]
%endrep
call r0
xor r3, n3
xor r4, n4
xor r5, n5
xor r6, n6
or r3, r4
or r5, r6
or r3, r5
jz .clobber_ok
report_fail error_message
.clobber_ok:
%ifidn %1, _emms
emms
%elifnidn %1, _float
fstenv [esp]
cmp word [esp + 8], 0xffff
je .emms_ok
report_fail error_message_emms
emms
.emms_ok:
%endif
add esp, max_args*4
REP_RET
%endmacro
%endif ; ARCH_X86_64
CHECKED_CALL
CHECKED_CALL _emms
CHECKED_CALL _float

30
externals/ffmpeg/tests/copycooker.sh vendored
View File

@@ -1,30 +0,0 @@
#!/bin/sh
LC_ALL=C
export LC_ALL
datadir="tests/data"
logfile="$datadir/copy.regression"
reffile="$1"
list=$(grep -oh ' ./tests/data/.*' tests/ref/{acodec,lavf,vsynth1}/*| sort)
rm -f $logfile
for i in $list ; do
echo ---------------- >> $logfile
echo $i >> $logfile
./ffmpeg_g -flags +bitexact -i $i -acodec copy -vcodec copy -y first.nut
./ffmpeg_g -flags +bitexact -i first.nut -acodec copy -vcodec copy -y second.nut
cmp first.nut second.nut >> $logfile
md5sum first.nut >> $logfile
done
if diff -u -w "$reffile" "$logfile" ; then
echo
echo copy regression test: success
exit 0
else
echo
echo copy regression test: error
exit 1
fi

6
externals/ffmpeg/tests/dnn/.gitignore vendored
View File

@@ -1,6 +0,0 @@
/dnn-layer-conv2d-test
/dnn-layer-depth2space-test
/dnn-layer-maximum-test
/dnn-layer-pad-test
/dnn-layer-mathbinary-test
/dnn-layer-mathunary-test

16
externals/ffmpeg/tests/dnn/Makefile vendored
View File

@@ -1,16 +0,0 @@
DNNTESTPROGS += dnn-layer-pad
DNNTESTPROGS += dnn-layer-conv2d
DNNTESTPROGS += dnn-layer-depth2space
DNNTESTPROGS += dnn-layer-mathbinary
DNNTESTPROGS += dnn-layer-maximum
DNNTESTPROGS += dnn-layer-mathunary
DNNTESTOBJS := $(DNNTESTOBJS:%=$(DNNTESTSDIR)%) $(DNNTESTPROGS:%=$(DNNTESTSDIR)/%-test.o)
DNNTESTPROGS := $(DNNTESTPROGS:%=$(DNNTESTSDIR)/%-test$(EXESUF))
-include $(wildcard $(DNNTESTOBJS:.o=.d))
$(DNNTESTPROGS): %$(EXESUF): %.o $(FF_STATIC_DEP_LIBS)
$(LD) $(LDFLAGS) $(LDEXEFLAGS) $(LD_O) $(filter %.o,$^) $(FF_STATIC_DEP_LIBS) $(EXTRALIBS-avcodec) $(EXTRALIBS-avfilter) $(EXTRALIBS-avformat) $(EXTRALIBS-avutil) $(EXTRALIBS-swresample) $(EXTRALIBS)
testclean::
$(RM) $(addprefix $(DNNTESTSDIR)/,$(CLEANSUFFIXES) *-test$(EXESUF))

240
externals/ffmpeg/tests/dnn/dnn-layer-conv2d-test.c vendored
View File

@@ -1,240 +0,0 @@
/*
* Copyright (c) 2019 Guo Yejun
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "libavfilter/dnn/dnn_backend_native_layer_conv2d.h"
#define EPSON 0.00001
static int test_with_same_dilate(void)
{
// the input data and expected data are generated with below python code.
/*
x = tf.placeholder(tf.float32, shape=[1, None, None, 3])
y = tf.layers.conv2d(x, 2, 3, activation=tf.nn.tanh, padding='same', dilation_rate=(2, 2), bias_initializer=tf.keras.initializers.he_normal())
data = np.random.rand(1, 5, 6, 3);
sess=tf.Session()
sess.run(tf.global_variables_initializer())
weights = dict([(var.name, sess.run(var)) for var in tf.trainable_variables()])
kernel = weights['conv2d/kernel:0']
kernel = np.transpose(kernel, [3, 0, 1, 2])
print("kernel:")
print(kernel.shape)
print(list(kernel.flatten()))
bias = weights['conv2d/bias:0']
print("bias:")
print(bias.shape)
print(list(bias.flatten()))
output = sess.run(y, feed_dict={x: data})
print("input:")
print(data.shape)
print(list(data.flatten()))
print("output:")
print(output.shape)
print(list(output.flatten()))
*/
ConvolutionalParams params;
DnnOperand operands[2];
int32_t input_indexes[1];
float input[1*5*6*3] = {
0.7012556460308194, 0.4233847954643357, 0.19515900664313612, 0.16343083004926495, 0.5758261611052848, 0.9510767434014871, 0.11014085055947687,
0.906327053637727, 0.8136794715542507, 0.45371764543639526, 0.5768443343523952, 0.19543668786046986, 0.15648326047898609, 0.2099500241141279,
0.17658777090552413, 0.059335724777169196, 0.1729991838469117, 0.8150514704819208, 0.4435535466703049, 0.3752188477566878, 0.749936650421431,
0.6823494635284907, 0.10776389679424747, 0.34247481674596836, 0.5147867256244629, 0.9063709728129032, 0.12423605800856818, 0.6064872945412728,
0.5891681538551459, 0.9865836236466314, 0.9002163879294677, 0.003968273184274618, 0.8628374809643967, 0.1327176268279583, 0.8449799925703798,
0.1937671869354366, 0.41524410152707425, 0.02038786604756837, 0.49792466069597496, 0.8881874553848784, 0.9683921035597336, 0.4122972568010813,
0.843553550993252, 0.9588482762501964, 0.5190350762645546, 0.4283584264145317, 0.09781496073714646, 0.9501058833776156, 0.8665541760152776,
0.31669272550095806, 0.07133074675453632, 0.606438007334886, 0.7007157020538224, 0.4827996264130444, 0.5167615606392761, 0.6385043039312651,
0.23069664707810555, 0.058233497329354456, 0.06323892961591071, 0.24816458893245974, 0.8646369065257812, 0.24742185893094837, 0.09991225948167437,
0.625700606979606, 0.7678541502111257, 0.6215834594679912, 0.5623003956582483, 0.07389123942681242, 0.7659100715711249, 0.486061471642225,
0.9947455699829012, 0.9094911797643259, 0.7644355876253265, 0.05384315321492239, 0.13565394382783613, 0.9810628204953316, 0.007386389078887889,
0.226182754156241, 0.2609021390764772, 0.24182802076928933, 0.13264782451941648, 0.2035816485767682, 0.005504188177612557, 0.7014619934040155,
0.956215988391991, 0.5670398541013633, 0.9809764721750784, 0.6886338100487461, 0.5758152317218274, 0.7137823176776179
};
float expected_output[1*5*6*2] = {
-0.9480655, -0.7169147, -0.9404794, -0.5567385, -0.8991124, -0.8306558, -0.94487447, -0.8932543, -0.88238764, -0.7301602,
-0.8974813, -0.7026703, -0.8858988, -0.53203243, -0.92881465, -0.5648504, -0.8871471, -0.7000097, -0.91754407, -0.79684794,
-0.760465, -0.117928326, -0.88302773, -0.8975289, -0.70615053, 0.19231977, -0.8318776, -0.386184, -0.80698484, -0.8556624,
-0.7336671, -0.6168619, -0.7658234, -0.63449603, -0.73314047, -0.87502456, -0.58158904, -0.4184259, -0.52618927, -0.13613208,
-0.5093187, -0.21027721, -0.39455596, -0.44507834, -0.22269244, -0.73400885, -0.77655095, -0.74408925, -0.57313335, -0.15333457,
-0.74620694, -0.34858236, -0.42586932, -0.5240488, 0.1634339, -0.2447881, -0.57927346, -0.62732303, -0.82287043, -0.8474058
};
float *output;
float kernel[2*3*3*3] = {
0.26025516, 0.16536498, -0.24351254, 0.33892477, -0.34005195, 0.35202783, 0.34056443, 0.01422739, 0.13799345, 0.29489166,
0.2781723, 0.178585, 0.22122234, 0.044115514, 0.13134438, 0.31705368, 0.22527462, -0.021323413, 0.115134746, -0.18216397,
-0.21197563, -0.027848959, -0.01704529, -0.12401503, -0.23415318, -0.12661739, -0.35338148, 0.20049328, -0.076153606,
-0.23642601, -0.3125769, -0.025851756, -0.30006272, 0.050762743, 0.32003498, 0.3052225, -0.0017385483, 0.25337684, -0.25664508,
0.27846587, -0.3112659, 0.2066065, 0.31499845, 0.113178134, 0.09449363, -0.11828774, -0.12671001, -0.36259216, 0.2710235,
-0.19676702, 0.023612618, -0.2596915, -0.34949252, -0.108270735
};
float bias[2] = { -1.6574852, -0.72915393 };
params.activation = TANH;
params.has_bias = 1;
params.biases = bias;
params.dilation = 2;
params.input_num = 3;
params.kernel = kernel;
params.kernel_size = 3;
params.output_num = 2;
params.padding_method = SAME;
operands[0].data = input;
operands[0].dims[0] = 1;
operands[0].dims[1] = 5;
operands[0].dims[2] = 6;
operands[0].dims[3] = 3;
operands[1].data = NULL;
input_indexes[0] = 0;
dnn_execute_layer_conv2d(operands, input_indexes, 1, &params);
output = operands[1].data;
for (int i = 0; i < sizeof(expected_output) / sizeof(float); i++) {
if (fabs(output[i] - expected_output[i]) > EPSON) {
printf("at index %d, output: %f, expected_output: %f\n", i, output[i], expected_output[i]);
av_freep(&output);
return 1;
}
}
av_freep(&output);
return 0;
}
static int test_with_valid(void)
{
// the input data and expected data are generated with below python code.
/*
x = tf.placeholder(tf.float32, shape=[1, None, None, 3])
y = tf.layers.conv2d(x, 2, 3, activation=tf.nn.tanh, padding='valid', bias_initializer=tf.keras.initializers.he_normal())
data = np.random.rand(1, 5, 6, 3);
sess=tf.Session()
sess.run(tf.global_variables_initializer())
weights = dict([(var.name, sess.run(var)) for var in tf.trainable_variables()])
kernel = weights['conv2d/kernel:0']
kernel = np.transpose(kernel, [3, 0, 1, 2])
print("kernel:")
print(kernel.shape)
print(list(kernel.flatten()))
bias = weights['conv2d/bias:0']
print("bias:")
print(bias.shape)
print(list(bias.flatten()))
output = sess.run(y, feed_dict={x: data})
print("input:")
print(data.shape)
print(list(data.flatten()))
print("output:")
print(output.shape)
print(list(output.flatten()))
*/
ConvolutionalParams params;
DnnOperand operands[2];
int32_t input_indexes[1];
float input[1*5*6*3] = {
0.26126657468269665, 0.42762216215337556, 0.7466274030131497, 0.802550266787863, 0.3709323443076644, 0.5919817068197668, 0.49274512279324967,
0.7170132295090351, 0.0911793215410649, 0.5134213878288361, 0.670132600785118, 0.49417034512633484, 0.03887389460089885, 0.436785102836845,
0.1490231658611978, 0.6413606121498127, 0.8595987991375995, 0.9132593077586231, 0.7075959004873255, 0.17754995944845464, 0.5212507214937141,
0.35379732738215475, 0.25205107358505296, 0.3928792840544273, 0.09485294189485782, 0.8685115437448666, 0.6489046799288605, 0.509253797582924,
0.8993255536791972, 0.18740056466602373, 0.34237617336313986, 0.3871438962989183, 0.1488532571774911, 0.5187002331293636, 0.8137098818752955,
0.521761863717401, 0.4622312310118274, 0.29038411334638825, 0.16194915718170566, 0.5175999923925211, 0.8852230040101133, 0.0218263385047206,
0.08482355352852367, 0.3463638568376264, 0.28627127120619733, 0.9553293378948409, 0.4803391055970835, 0.841635695030805, 0.3556828280031952,
0.06778527221541808, 0.28193560357091596, 0.8399957619031576, 0.03305536359456385, 0.6625039162109645, 0.9300552020023897, 0.8551529138204146,
0.6133216915522418, 0.222427800857393, 0.1315422686800336, 0.6189144989185527, 0.5346184916866876, 0.8348888624532548, 0.6544834567840291,
0.2844062293389934, 0.28780026600883324, 0.5372272015684924, 0.6250226011503823, 0.28119106062279453, 0.49655812908420094, 0.6451488959145951,
0.7362580606834843, 0.44815578616664087, 0.6454760235835586, 0.6794062414265861, 0.045378883014935756, 0.9008388543865096, 0.7949752851269782,
0.4179928876222264, 0.28733419007048644, 0.996902319501908, 0.5690851338677467, 0.9511814013279738, 0.025323788678181636, 0.5594359732604794,
0.1213732595086251, 0.7172624313368294, 0.6759328959074691, 0.07252138454885071, 0.17557735158403442, 0.5988895455048769
};
float expected_output[1*3*4*2] = {
-0.556947, -0.42143887, -0.092070885, 0.27404794, -0.41886684, 0.0862887, -0.25001016, -0.342721, 0.020730592, 0.04016919, -0.69839877,
-0.06136704, 0.14186388, -0.11655602, -0.23489095, -0.3845829, -0.19017771, 0.1595885, -0.18308741, -0.3071209, -0.5848686, -0.22509028,
-0.6023201, -0.14448485
};
float *output;
float kernel[2*3*3*3] = {
-0.25291282, 0.22402048, 0.028642118, -0.14615723, -0.27362752, -0.34801802, -0.2759148, 0.19594926, -0.25029412, 0.34606284, 0.10376671,
-0.1015394, 0.23616093, 0.2134214, 0.35285157, 0.05893758, 0.0024731457, -0.17143056, 0.35758412, 0.2186206, -0.28384736, -0.21206513,
-0.20871592, 0.27070445, 0.25878823, 0.11136332, -0.33737376, 0.08353335, -0.34290665, 0.041805506, -0.09738535, 0.3284936, -0.16838405,
-0.032494456, -0.29193437, 0.033259362, -0.09272635, -0.2802651, -0.28648436, 0.3542878, 0.2432127, -0.24551713, 0.27813476, 0.21024024,
-0.013690501, -0.1350077, -0.07826337, -0.34563828, 0.3220685, -0.07571727, 0.19420576, 0.20783454, 0.18738335, 0.16672492
};
float bias[2] = { -0.4773722, -0.19620377 };
params.activation = TANH;
params.has_bias = 1;
params.biases = bias;
params.dilation = 1;
params.input_num = 3;
params.kernel = kernel;
params.kernel_size = 3;
params.output_num = 2;
params.padding_method = VALID;
operands[0].data = input;
operands[0].dims[0] = 1;
operands[0].dims[1] = 5;
operands[0].dims[2] = 6;
operands[0].dims[3] = 3;
operands[1].data = NULL;
input_indexes[0] = 0;
dnn_execute_layer_conv2d(operands, input_indexes, 1, &params);
output = operands[1].data;
for (int i = 0; i < sizeof(expected_output) / sizeof(float); i++) {
if (fabs(output[i] - expected_output[i]) > EPSON) {
printf("at index %d, output: %f, expected_output: %f\n", i, output[i], expected_output[i]);
av_freep(&output);
return 1;
}
}
av_freep(&output);
return 0;
}
int main(int argc, char **argv)
{
if (test_with_valid())
return 1;
if (test_with_same_dilate())
return 1;
return 0;
}

102
externals/ffmpeg/tests/dnn/dnn-layer-depth2space-test.c vendored
View File

@@ -1,102 +0,0 @@
/*
* Copyright (c) 2019 Guo Yejun
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "libavfilter/dnn/dnn_backend_native.h"
#include "libavfilter/dnn/dnn_backend_native_layer_depth2space.h"
#define EPSON 0.00001
static int test(void)
{
// the input data and expected data are generated with below python code.
/*
x = tf.placeholder(tf.float32, shape=[1, None, None, 4])
y = tf.depth_to_space(x, 2)
data = np.random.rand(1, 5, 3, 4);
sess=tf.Session()
sess.run(tf.global_variables_initializer())
output = sess.run(y, feed_dict={x: data})
print("input:")
print(data.shape)
print(list(data.flatten()))
print("output:")
print(output.shape)
print(list(output.flatten()))
*/
DepthToSpaceParams params;
DnnOperand operands[2];
int32_t input_indexes[1];
float input[1*5*3*4] = {
0.09771065121566602, 0.6336807372403175, 0.5142416549709786, 0.8027206567330333, 0.2154276025069397, 0.12112878462616772, 0.913936596765778,
0.38881443647542646, 0.5850447615898835, 0.9311499327398275, 0.3613660929428246, 0.5420722002125493, 0.6002131190230359, 0.44800665702299525,
0.7271322557896777, 0.3869293511885826, 0.5144404769364138, 0.6910844856987723, 0.6142102742269762, 0.6249991371621018, 0.45663376215836626,
0.19523477129943423, 0.2483895888532045, 0.64326768256278, 0.5485877602998981, 0.45442067849873546, 0.529374943304256, 0.30439850391811885,
0.11961343361340993, 0.2909643484561082, 0.9810970344127848, 0.8886928489786549, 0.6112237084436409, 0.8852482695156674, 0.9110868043114374,
0.21242780027585217, 0.7101536973207572, 0.9709717457443375, 0.2702666770969332, 0.7718295953780221, 0.3957005164588574, 0.24383544252475453,
0.040143453532367035, 0.26358051835323115, 0.013130251443791319, 0.3016550481482074, 0.03582340459943956, 0.718025513612361, 0.09844204177633753,
0.04433767496953056, 0.6221895044119757, 0.6190414032940228, 0.8963550834625371, 0.5642449700064629, 0.2482982014723497, 0.17824909294583013,
0.024401882408643272, 0.21742800875253465, 0.6794724473181843, 0.4814830479242237
};
float expected_output[1*10*6*1] = {
0.097710654, 0.63368076, 0.2154276, 0.12112878, 0.58504474, 0.93114996, 0.51424164, 0.80272067, 0.9139366, 0.38881445,
0.3613661, 0.5420722, 0.6002131, 0.44800666, 0.5144405, 0.6910845, 0.45663378, 0.19523478, 0.72713226, 0.38692936,
0.61421025, 0.62499917, 0.24838959, 0.6432677, 0.54858774, 0.4544207, 0.11961343, 0.29096434, 0.6112237, 0.88524824,
0.52937496, 0.3043985, 0.98109704, 0.88869286, 0.9110868, 0.2124278, 0.7101537, 0.97097176, 0.3957005, 0.24383545,
0.013130251, 0.30165505, 0.27026668, 0.7718296, 0.040143453, 0.26358053, 0.035823405, 0.7180255, 0.09844204,
0.044337675, 0.8963551, 0.564245, 0.024401883, 0.21742801, 0.6221895, 0.6190414, 0.2482982, 0.17824909, 0.67947245, 0.48148304
};
float *output;
operands[0].data = input;
operands[0].dims[0] = 1;
operands[0].dims[1] = 5;
operands[0].dims[2] = 3;
operands[0].dims[3] = 4;
operands[1].data = NULL;
input_indexes[0] = 0;
params.block_size = 2;
dnn_execute_layer_depth2space(operands, input_indexes, 1, &params);
output = operands[1].data;
for (int i = 0; i < sizeof(expected_output) / sizeof(float); i++) {
if (fabs(output[i] - expected_output[i]) > EPSON) {
printf("at index %d, output: %f, expected_output: %f\n", i, output[i], expected_output[i]);
av_freep(&output);
return 1;
}
}
av_freep(&output);
return 0;
}
int main(int argc, char **argv)
{
return test();
}

209
externals/ffmpeg/tests/dnn/dnn-layer-mathbinary-test.c vendored
View File

@@ -1,209 +0,0 @@
/*
* Copyright (c) 2020
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "libavfilter/dnn/dnn_backend_native_layer_mathbinary.h"
#include "libavutil/avassert.h"
#define EPSON 0.00005
static float get_expected(float f1, float f2, DNNMathBinaryOperation op)
{
switch (op)
{
case DMBO_SUB:
return f1 - f2;
case DMBO_ADD:
return f1 + f2;
case DMBO_MUL:
return f1 * f2;
case DMBO_REALDIV:
return f1 / f2;
case DMBO_MINIMUM:
return (f1 < f2) ? f1 : f2;
default:
av_assert0(!"not supported yet");
return 0.f;
}
}
static int test_broadcast_input0(DNNMathBinaryOperation op)
{
DnnLayerMathBinaryParams params;
DnnOperand operands[2];
int32_t input_indexes[1];
float input[1*1*2*3] = {
-3, 2.5, 2, -2.1, 7.8, 100
};
float *output;
params.bin_op = op;
params.input0_broadcast = 1;
params.input1_broadcast = 0;
params.v = 7.28;
operands[0].data = input;
operands[0].dims[0] = 1;
operands[0].dims[1] = 1;
operands[0].dims[2] = 2;
operands[0].dims[3] = 3;
operands[1].data = NULL;
input_indexes[0] = 0;
dnn_execute_layer_math_binary(operands, input_indexes, 1, &params);
output = operands[1].data;
for (int i = 0; i < sizeof(input) / sizeof(float); i++) {
float expected_output = get_expected(params.v, input[i], op);
if (fabs(output[i] - expected_output) > EPSON) {
printf("op %d, at index %d, output: %f, expected_output: %f (%s:%d)\n",
op, i, output[i], expected_output, __FILE__, __LINE__);
av_freep(&output);
return 1;
}
}
av_freep(&output);
return 0;
}
static int test_broadcast_input1(DNNMathBinaryOperation op)
{
DnnLayerMathBinaryParams params;
DnnOperand operands[2];
int32_t input_indexes[1];
float input[1*1*2*3] = {
-3, 2.5, 2, -2.1, 7.8, 100
};
float *output;
params.bin_op = op;
params.input0_broadcast = 0;
params.input1_broadcast = 1;
params.v = 7.28;
operands[0].data = input;
operands[0].dims[0] = 1;
operands[0].dims[1] = 1;
operands[0].dims[2] = 2;
operands[0].dims[3] = 3;
operands[1].data = NULL;
input_indexes[0] = 0;
dnn_execute_layer_math_binary(operands, input_indexes, 1, &params);
output = operands[1].data;
for (int i = 0; i < sizeof(input) / sizeof(float); i++) {
float expected_output = get_expected(input[i], params.v, op);
if (fabs(output[i] - expected_output) > EPSON) {
printf("op %d, at index %d, output: %f, expected_output: %f (%s:%d)\n",
op, i, output[i], expected_output, __FILE__, __LINE__);
av_freep(&output);
return 1;
}
}
av_freep(&output);
return 0;
}
static int test_no_broadcast(DNNMathBinaryOperation op)
{
DnnLayerMathBinaryParams params;
DnnOperand operands[3];
int32_t input_indexes[2];
float input0[1*1*2*3] = {
-3, 2.5, 2, -2.1, 7.8, 100
};
float input1[1*1*2*3] = {
-1, 2, 3, -21, 8, 10.0
};
float *output;
params.bin_op = op;
params.input0_broadcast = 0;
params.input1_broadcast = 0;
operands[0].data = input0;
operands[0].dims[0] = 1;
operands[0].dims[1] = 1;
operands[0].dims[2] = 2;
operands[0].dims[3] = 3;
operands[1].data = input1;
operands[1].dims[0] = 1;
operands[1].dims[1] = 1;
operands[1].dims[2] = 2;
operands[1].dims[3] = 3;
operands[2].data = NULL;
input_indexes[0] = 0;
input_indexes[1] = 1;
dnn_execute_layer_math_binary(operands, input_indexes, 2, &params);
output = operands[2].data;
for (int i = 0; i < sizeof(input0) / sizeof(float); i++) {
float expected_output = get_expected(input0[i], input1[i], op);
if (fabs(output[i] - expected_output) > EPSON) {
printf("op %d, at index %d, output: %f, expected_output: %f (%s:%d)\n",
op, i, output[i], expected_output, __FILE__, __LINE__);
av_freep(&output);
return 1;
}
}
av_freep(&output);
return 0;
}
static int test(DNNMathBinaryOperation op)
{
if (test_broadcast_input0(op))
return 1;
if (test_broadcast_input1(op))
return 1;
if (test_no_broadcast(op))
return 1;
return 0;
}
int main(int argc, char **argv)
{
if (test(DMBO_SUB))
return 1;
if (test(DMBO_ADD))
return 1;
if (test(DMBO_MUL))
return 1;
if (test(DMBO_REALDIV))
return 1;
if (test(DMBO_MINIMUM))
return 1;
return 0;
}

132
externals/ffmpeg/tests/dnn/dnn-layer-mathunary-test.c vendored
View File

@@ -1,132 +0,0 @@
/*
* Copyright (c) 2020
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "libavfilter/dnn/dnn_backend_native_layer_mathunary.h"
#include "libavutil/avassert.h"
#define EPS 0.00001
static float get_expected(float f, DNNMathUnaryOperation op)
{
switch (op)
{
case DMUO_ABS:
return (f >= 0) ? f : -f;
case DMUO_SIN:
return sin(f);
case DMUO_COS:
return cos(f);
case DMUO_TAN:
return tan(f);
case DMUO_ASIN:
return asin(f);
case DMUO_ACOS:
return acos(f);
case DMUO_ATAN:
return atan(f);
case DMUO_SINH:
return sinh(f);
case DMUO_COSH:
return cosh(f);
case DMUO_TANH:
return tanh(f);
case DMUO_ASINH:
return asinh(f);
case DMUO_ACOSH:
return acosh(f);
case DMUO_ATANH:
return atanh(f);
default:
av_assert0(!"not supported yet");
return 0.f;
}
}
static int test(DNNMathUnaryOperation op)
{
DnnLayerMathUnaryParams params;
DnnOperand operands[2];
int32_t input_indexes[1];
float input[1*1*3*3] = {
0.1, 0.5, 0.75, -3, 2.5, 2, -2.1, 7.8, 100};
float *output;
params.un_op = op;
operands[0].data = input;
operands[0].dims[0] = 1;
operands[0].dims[1] = 1;
operands[0].dims[2] = 3;
operands[0].dims[3] = 3;
operands[1].data = NULL;
input_indexes[0] = 0;
dnn_execute_layer_math_unary(operands, input_indexes, 1, &params);
output = operands[1].data;
for (int i = 0; i < sizeof(input) / sizeof(float); ++i) {
float expected_output = get_expected(input[i], op);
int output_nan = isnan(output[i]);
int expected_nan = isnan(expected_output);
if ((!output_nan && !expected_nan && fabs(output[i] - expected_output) > EPS) ||
(output_nan && !expected_nan) || (!output_nan && expected_nan)) {
printf("at index %d, output: %f, expected_output: %f\n", i, output[i], expected_output);
av_freep(&output);
return 1;
}
}
av_freep(&output);
return 0;
}
int main(int agrc, char **argv)
{
if (test(DMUO_ABS))
return 1;
if (test(DMUO_SIN))
return 1;
if (test(DMUO_COS))
return 1;
if (test(DMUO_TAN))
return 1;
if (test(DMUO_ASIN))
return 1;
if (test(DMUO_ACOS))
return 1;
if (test(DMUO_ATAN))
return 1;
if (test(DMUO_SINH))
return 1;
if (test(DMUO_COSH))
return 1;
if (test(DMUO_TANH))
return 1;
if (test(DMUO_ASINH))
return 1;
if (test(DMUO_ACOSH))
return 1;
if (test(DMUO_ATANH))
return 1;
return 0;
}

71
externals/ffmpeg/tests/dnn/dnn-layer-maximum-test.c vendored
View File

@@ -1,71 +0,0 @@
/*
* Copyright (c) 2019 Guo Yejun
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "libavfilter/dnn/dnn_backend_native_layer_maximum.h"
#define EPSON 0.00001
static int test(void)
{
DnnLayerMaximumParams params;
DnnOperand operands[2];
int32_t input_indexes[1];
float input[1*1*2*3] = {
-3, 2.5, 2, -2.1, 7.8, 100
};
float *output;
params.val.y = 2.3;
operands[0].data = input;
operands[0].dims[0] = 1;
operands[0].dims[1] = 1;
operands[0].dims[2] = 2;
operands[0].dims[3] = 3;
operands[1].data = NULL;
input_indexes[0] = 0;
dnn_execute_layer_maximum(operands, input_indexes, 1, &params);
output = operands[1].data;
for (int i = 0; i < sizeof(input) / sizeof(float); i++) {
float expected_output = input[i] > params.val.y ? input[i] : params.val.y;
if (fabs(output[i] - expected_output) > EPSON) {
printf("at index %d, output: %f, expected_output: %f\n", i, output[i], expected_output);
av_freep(&output);
return 1;
}
}
av_freep(&output);
return 0;
}
int main(int argc, char **argv)
{
if (test())
return 1;
return 0;
}

239
externals/ffmpeg/tests/dnn/dnn-layer-pad-test.c vendored
View File

@@ -1,239 +0,0 @@
/*
* Copyright (c) 2019 Guo Yejun
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "libavfilter/dnn/dnn_backend_native_layer_pad.h"
#define EPSON 0.00001
static int test_with_mode_symmetric(void)
{
// the input data and expected data are generated with below python code.
/*
x = tf.placeholder(tf.float32, shape=[1, None, None, 3])
y = tf.pad(x, [[0, 0], [2, 3], [3, 2], [0, 0]], 'SYMMETRIC')
data = np.arange(48).reshape(1, 4, 4, 3);
sess=tf.Session()
sess.run(tf.global_variables_initializer())
output = sess.run(y, feed_dict={x: data})
print(list(data.flatten()))
print(list(output.flatten()))
print(data.shape)
print(output.shape)
*/
LayerPadParams params;
DnnOperand operands[2];
int32_t input_indexes[1];
float input[1*4*4*3] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47
};
float expected_output[1*9*9*3] = {
18.0, 19.0, 20.0, 15.0, 16.0, 17.0, 12.0, 13.0, 14.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 21.0, 22.0, 23.0, 18.0, 19.0, 20.0, 6.0, 7.0, 8.0, 3.0,
4.0, 5.0, 0.0, 1.0, 2.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 9.0, 10.0, 11.0, 6.0, 7.0, 8.0, 6.0, 7.0, 8.0, 3.0, 4.0, 5.0, 0.0, 1.0, 2.0, 0.0, 1.0, 2.0, 3.0,
4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 9.0, 10.0, 11.0, 6.0, 7.0, 8.0, 18.0, 19.0, 20.0, 15.0, 16.0, 17.0, 12.0, 13.0, 14.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0,
21.0, 22.0, 23.0, 21.0, 22.0, 23.0, 18.0, 19.0, 20.0, 30.0, 31.0, 32.0, 27.0, 28.0, 29.0, 24.0, 25.0, 26.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 33.0,
34.0, 35.0, 30.0, 31.0, 32.0, 42.0, 43.0, 44.0, 39.0, 40.0, 41.0, 36.0, 37.0, 38.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 45.0, 46.0, 47.0, 42.0, 43.0,
44.0, 42.0, 43.0, 44.0, 39.0, 40.0, 41.0, 36.0, 37.0, 38.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 45.0, 46.0, 47.0, 42.0, 43.0, 44.0, 30.0, 31.0, 32.0,
27.0, 28.0, 29.0, 24.0, 25.0, 26.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 33.0, 34.0, 35.0, 30.0, 31.0, 32.0, 18.0, 19.0, 20.0, 15.0, 16.0, 17.0, 12.0,
13.0, 14.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 21.0, 22.0, 23.0, 18.0, 19.0, 20.0
};
float *output;
params.mode = LPMP_SYMMETRIC;
params.paddings[0][0] = 0;
params.paddings[0][1] = 0;
params.paddings[1][0] = 2;
params.paddings[1][1] = 3;
params.paddings[2][0] = 3;
params.paddings[2][1] = 2;
params.paddings[3][0] = 0;
params.paddings[3][1] = 0;
operands[0].data = input;
operands[0].dims[0] = 1;
operands[0].dims[1] = 4;
operands[0].dims[2] = 4;
operands[0].dims[3] = 3;
operands[1].data = NULL;
input_indexes[0] = 0;
dnn_execute_layer_pad(operands, input_indexes, 1, &params);
output = operands[1].data;
for (int i = 0; i < sizeof(expected_output) / sizeof(float); i++) {
if (fabs(output[i] - expected_output[i]) > EPSON) {
printf("at index %d, output: %f, expected_output: %f\n", i, output[i], expected_output[i]);
av_freep(&output);
return 1;
}
}
av_freep(&output);
return 0;
}
static int test_with_mode_reflect(void)
{
// the input data and expected data are generated with below python code.
/*
x = tf.placeholder(tf.float32, shape=[3, None, None, 3])
y = tf.pad(x, [[1, 2], [0, 0], [0, 0], [0, 0]], 'REFLECT')
data = np.arange(36).reshape(3, 2, 2, 3);
sess=tf.Session()
sess.run(tf.global_variables_initializer())
output = sess.run(y, feed_dict={x: data})
print(list(data.flatten()))
print(list(output.flatten()))
print(data.shape)
print(output.shape)
*/
LayerPadParams params;
DnnOperand operands[2];
int32_t input_indexes[1];
float input[3*2*2*3] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35
};
float expected_output[6*2*2*3] = {
12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0,
12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0, 33.0, 34.0,
35.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0
};
float *output;
params.mode = LPMP_REFLECT;
params.paddings[0][0] = 1;
params.paddings[0][1] = 2;
params.paddings[1][0] = 0;
params.paddings[1][1] = 0;
params.paddings[2][0] = 0;
params.paddings[2][1] = 0;
params.paddings[3][0] = 0;
params.paddings[3][1] = 0;
operands[0].data = input;
operands[0].dims[0] = 3;
operands[0].dims[1] = 2;
operands[0].dims[2] = 2;
operands[0].dims[3] = 3;
operands[1].data = NULL;
input_indexes[0] = 0;
dnn_execute_layer_pad(operands, input_indexes, 1, &params);
output = operands[1].data;
for (int i = 0; i < sizeof(expected_output) / sizeof(float); i++) {
if (fabs(output[i] - expected_output[i]) > EPSON) {
printf("at index %d, output: %f, expected_output: %f\n", i, output[i], expected_output[i]);
av_freep(&output);
return 1;
}
}
av_freep(&output);
return 0;
}
static int test_with_mode_constant(void)
{
// the input data and expected data are generated with below python code.
/*
x = tf.placeholder(tf.float32, shape=[1, None, None, 3])
y = tf.pad(x, [[0, 0], [1, 0], [0, 0], [1, 2]], 'CONSTANT', constant_values=728)
data = np.arange(12).reshape(1, 2, 2, 3);
sess=tf.Session()
sess.run(tf.global_variables_initializer())
output = sess.run(y, feed_dict={x: data})
print(list(data.flatten()))
print(list(output.flatten()))
print(data.shape)
print(output.shape)
*/
LayerPadParams params;
DnnOperand operands[2];
int32_t input_indexes[1];
float input[1*2*2*3] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
};
float expected_output[1*3*2*6] = {
728.0, 728.0, 728.0, 728.0, 728.0, 728.0, 728.0, 728.0, 728.0, 728.0, 728.0,
728.0, 728.0, 0.0, 1.0, 2.0, 728.0, 728.0, 728.0, 3.0, 4.0, 5.0, 728.0, 728.0,
728.0, 6.0, 7.0, 8.0, 728.0, 728.0, 728.0, 9.0, 10.0, 11.0, 728.0, 728.0
};
float *output;
params.mode = LPMP_CONSTANT;
params.constant_values = 728;
params.paddings[0][0] = 0;
params.paddings[0][1] = 0;
params.paddings[1][0] = 1;
params.paddings[1][1] = 0;
params.paddings[2][0] = 0;
params.paddings[2][1] = 0;
params.paddings[3][0] = 1;
params.paddings[3][1] = 2;
operands[0].data = input;
operands[0].dims[0] = 1;
operands[0].dims[1] = 2;
operands[0].dims[2] = 2;
operands[0].dims[3] = 3;
operands[1].data = NULL;
input_indexes[0] = 0;
dnn_execute_layer_pad(operands, input_indexes, 1, &params);
output = operands[1].data;
for (int i = 0; i < sizeof(expected_output) / sizeof(float); i++) {
if (fabs(output[i] - expected_output[i]) > EPSON) {
printf("at index %d, output: %f, expected_output: %f\n", i, output[i], expected_output[i]);
av_freep(&output);
return 1;
}
}
av_freep(&output);
return 0;
}
int main(int argc, char **argv)
{
if (test_with_mode_symmetric())
return 1;
if (test_with_mode_reflect())
return 1;
if (test_with_mode_constant())
return 1;
}

114
externals/ffmpeg/tests/extended.ffconcat vendored
View File

@@ -1,114 +0,0 @@
ffconcat version 1.0
file %SRCFILE%
file %SRCFILE%
duration 1
file_packet_metadata dummy=1
file %SRCFILE%
inpoint 00:00.00
outpoint 00:00.04
file %SRCFILE%
inpoint 00:00.04
outpoint 00:00.08
file %SRCFILE%
inpoint 00:00.08
outpoint 00:00.12
file %SRCFILE%
inpoint 00:00.12
outpoint 00:00.16
file %SRCFILE%
inpoint 00:00.16
outpoint 00:00.20
file %SRCFILE%
inpoint 00:00.20
outpoint 00:00.24
file %SRCFILE%
inpoint 00:00.24
outpoint 00:00.28
file %SRCFILE%
inpoint 00:00.28
outpoint 00:00.32
file %SRCFILE%
inpoint 00:00.32
outpoint 00:00.36
file %SRCFILE%
inpoint 00:00.36
outpoint 00:00.40
file %SRCFILE%
inpoint 00:00.40
outpoint 00:00.44
file %SRCFILE%
inpoint 00:00.44
outpoint 00:00.48
file %SRCFILE%
inpoint 00:00.48
outpoint 00:00.52
file %SRCFILE%
inpoint 00:00.52
outpoint 00:00.56
file %SRCFILE%
inpoint 00:00.56
outpoint 00:00.60
file %SRCFILE%
inpoint 00:00.60
outpoint 00:00.64
file %SRCFILE%
inpoint 00:00.64
outpoint 00:00.68
file %SRCFILE%
inpoint 00:00.68
outpoint 00:00.72
file %SRCFILE%
inpoint 00:00.72
outpoint 00:00.76
file %SRCFILE%
inpoint 00:00.76
outpoint 00:00.80
file %SRCFILE%
inpoint 00:00.80
outpoint 00:00.84
file %SRCFILE%
inpoint 00:00.84
outpoint 00:00.88
file %SRCFILE%
inpoint 00:00.88
outpoint 00:00.92
file %SRCFILE%
inpoint 00:00.92
outpoint 00:00.96
file %SRCFILE%
inpoint 00:00.96
outpoint 00:01.00
file %SRCFILE%
outpoint 00:00.40
file %SRCFILE%
inpoint 00:00.40

564
externals/ffmpeg/tests/fate-run.sh vendored
View File

@@ -1,564 +0,0 @@
#! /bin/sh
export LC_ALL=C
base=$(dirname $0)
. "${base}/md5.sh"
base64=tests/base64${HOSTEXECSUF}
test="${1#fate-}"
target_samples=$2
target_exec=$3
target_path=$4
command=$5
cmp=${6:-diff}
ref=${7:-"${base}/ref/fate/${test}"}
fuzz=${8:-1}
threads=${9:-1}
thread_type=${10:-frame+slice}
cpuflags=${11:-all}
cmp_shift=${12:-0}
cmp_target=${13:-0}
size_tolerance=${14:-0}
cmp_unit=${15:-2}
gen=${16:-no}
hwaccel=${17:-none}
report_type=${18:-standard}
keep=${19:-0}
outdir="tests/data/fate"
outfile="${outdir}/${test}"
errfile="${outdir}/${test}.err"
cmpfile="${outdir}/${test}.diff"
repfile="${outdir}/${test}.rep"
target_path(){
test ${1} = ${1#/} && p=${target_path}/
echo ${p}${1}
}
# $1=value1, $2=value2, $3=threshold
# prints 0 if absolute difference between value1 and value2 is <= threshold
compare(){
awk "BEGIN { v = $1 - $2; printf ((v < 0 ? -v : v) > $3) }"
}
do_tiny_psnr(){
psnr=$(tests/tiny_psnr${HOSTEXECSUF} "$1" "$2" $cmp_unit $cmp_shift 0) || return 1
val=$(expr "$psnr" : ".*$3: *\([0-9.]*\)")
size1=$(expr "$psnr" : '.*bytes: *\([0-9]*\)')
size2=$(expr "$psnr" : '.*bytes:[ 0-9]*/ *\([0-9]*\)')
val_cmp=$(compare $val $cmp_target $fuzz)
size_cmp=$(compare $size1 $size2 $size_tolerance)
if [ "$val_cmp" != 0 ] || [ "$size_cmp" != 0 ]; then
echo "$psnr"
if [ "$val_cmp" != 0 ]; then
echo "$3: |$val - $cmp_target| >= $fuzz"
fi
if [ "$size_cmp" != 0 ]; then
echo "size: |$size1 - $size2| >= $size_tolerance"
fi
return 1
fi
}
oneoff(){
do_tiny_psnr "$1" "$2" MAXDIFF
}
stddev(){
do_tiny_psnr "$1" "$2" stddev
}
oneline(){
printf '%s\n' "$1" | diff -u -b - "$2"
}
run(){
test "${V:-0}" -gt 0 && echo "$target_exec" $target_path/"$@" >&3
$target_exec $target_path/"$@"
}
runecho(){
test "${V:-0}" -gt 0 && echo "$target_exec" $target_path/"$@" >&3
$target_exec $target_path/"$@" >&3
}
probefmt(){
run ffprobe${PROGSUF}${EXECSUF} -show_entries format=format_name -print_format default=nw=1:nk=1 -v 0 "$@"
}
probeaudiostream(){
run ffprobe${PROGSUF}${EXECSUF} -show_entries stream=codec_name,codec_time_base,sample_fmt,channels,channel_layout -v 0 "$@"
}
probetags(){
run ffprobe${PROGSUF}${EXECSUF} -show_entries format_tags -v 0 "$@"
}
runlocal(){
test "${V:-0}" -gt 0 && echo ${base}/"$@" ${base} >&3
${base}/"$@" ${base}
}
probeframes(){
run ffprobe${PROGSUF}${EXECSUF} -show_frames -v 0 "$@"
}
probechapters(){
run ffprobe${PROGSUF}${EXECSUF} -show_chapters -v 0 "$@"
}
probegaplessinfo(){
filename="$1"
shift
run ffprobe${PROGSUF}${EXECSUF} -bitexact -select_streams a -show_entries format=start_time,duration:stream=index,start_pts,duration_ts -v 0 "$filename" "$@"
pktfile1="${outdir}/${test}.pkts"
framefile1="${outdir}/${test}.frames"
cleanfiles="$cleanfiles $pktfile1 $framefile1"
run ffprobe${PROGSUF}${EXECSUF} -bitexact -select_streams a -of compact -count_packets -show_entries packet=pts,dts,duration,flags:stream=nb_read_packets -v 0 "$filename" "$@" > "$pktfile1"
head -n 8 "$pktfile1"
tail -n 9 "$pktfile1"
run ffprobe${PROGSUF}${EXECSUF} -bitexact -select_streams a -of compact -count_frames -show_entries frame=pkt_pts,pkt_dts,best_effort_timestamp,pkt_duration,nb_samples:stream=nb_read_frames -v 0 "$filename" "$@" > "$framefile1"
head -n 8 "$framefile1"
tail -n 9 "$framefile1"
}
ffmpeg(){
dec_opts="-hwaccel $hwaccel -threads $threads -thread_type $thread_type"
ffmpeg_args="-nostdin -nostats -cpuflags $cpuflags"
for arg in $@; do
[ x${arg} = x-i ] && ffmpeg_args="${ffmpeg_args} ${dec_opts}"
ffmpeg_args="${ffmpeg_args} ${arg}"
done
run ffmpeg${PROGSUF}${EXECSUF} ${ffmpeg_args}
}
framecrc(){
ffmpeg "$@" -bitexact -f framecrc -
}
ffmetadata(){
ffmpeg "$@" -bitexact -f ffmetadata -
}
framemd5(){
ffmpeg "$@" -bitexact -f framemd5 -
}
crc(){
ffmpeg "$@" -f crc -
}
md5pipe(){
ffmpeg "$@" md5:
}
md5(){
encfile="${outdir}/${test}.out"
cleanfiles="$cleanfiles $encfile"
ffmpeg "$@" $(target_path $encfile)
do_md5sum $encfile | awk '{print $1}'
}
pcm(){
ffmpeg "$@" -vn -f s16le -
}
fmtstdout(){
fmt=$1
shift 1
ffmpeg -bitexact "$@" -f $fmt -
}
enc_dec_pcm(){
out_fmt=$1
dec_fmt=$2
pcm_fmt=$3
src_file=$(target_path $4)
shift 4
encfile="${outdir}/${test}.${out_fmt}"
cleanfiles=$encfile
encfile=$(target_path ${encfile})
ffmpeg -i $src_file "$@" -f $out_fmt -y ${encfile} || return
ffmpeg -bitexact -i ${encfile} -c:a pcm_${pcm_fmt} -fflags +bitexact -f ${dec_fmt} -
}
FLAGS="-flags +bitexact -sws_flags +accurate_rnd+bitexact -fflags +bitexact"
DEC_OPTS="-threads $threads -idct simple $FLAGS"
ENC_OPTS="-threads 1 -idct simple -dct fastint"
enc_dec(){
src_fmt=$1
srcfile=$2
enc_fmt=$3
enc_opt=$4
dec_fmt=$5
dec_opt=$6
ffprobe_opts=$9
encfile="${outdir}/${test}.${enc_fmt}"
decfile="${outdir}/${test}.out.${dec_fmt}"
cleanfiles="$cleanfiles $decfile"
test "$7" = -keep || cleanfiles="$cleanfiles $encfile"
tsrcfile=$(target_path $srcfile)
tencfile=$(target_path $encfile)
tdecfile=$(target_path $decfile)
ffmpeg -f $src_fmt $DEC_OPTS -i $tsrcfile $ENC_OPTS $enc_opt $FLAGS \
-f $enc_fmt -y $tencfile || return
do_md5sum $encfile
echo $(wc -c $encfile)
ffmpeg $8 $DEC_OPTS -i $tencfile $ENC_OPTS $dec_opt $FLAGS \
-f $dec_fmt -y $tdecfile || return
do_md5sum $decfile
tests/tiny_psnr${HOSTEXECSUF} $srcfile $decfile $cmp_unit $cmp_shift
test -z $ffprobe_opts || \
run ffprobe${PROGSUF}${EXECSUF} $ffprobe_opts -v 0 $tencfile || return
}
transcode(){
src_fmt=$1
srcfile=$2
enc_fmt=$3
enc_opt=$4
final_decode=$5
ffprobe_opts=$7
encfile="${outdir}/${test}.${enc_fmt}"
test "$6" = -keep || cleanfiles="$cleanfiles $encfile"
tsrcfile=$(target_path $srcfile)
tencfile=$(target_path $encfile)
ffmpeg -f $src_fmt $DEC_OPTS -i $tsrcfile $ENC_OPTS $enc_opt $FLAGS \
-f $enc_fmt -y $tencfile || return
do_md5sum $encfile
echo $(wc -c $encfile)
ffmpeg $DEC_OPTS -i $tencfile $ENC_OPTS $FLAGS $final_decode \
-f framecrc - || return
test -z $ffprobe_opts || \
run ffprobe${PROGSUF}${EXECSUF} $ffprobe_opts -v 0 $tencfile || return
}
stream_remux(){
src_fmt=$1
srcfile=$2
enc_fmt=$3
stream_maps=$4
final_decode=$5
ffprobe_opts=$7
encfile="${outdir}/${test}.${enc_fmt}"
test "$6" = -keep || cleanfiles="$cleanfiles $encfile"
tsrcfile=$(target_path $srcfile)
tencfile=$(target_path $encfile)
ffmpeg -f $src_fmt -i $tsrcfile $stream_maps -codec copy $FLAGS \
-f $enc_fmt -y $tencfile || return
ffmpeg $DEC_OPTS -i $tencfile $ENC_OPTS $FLAGS $final_decode \
-f framecrc - || return
test -z $ffprobe_opts || \
run ffprobe${PROGSUF}${EXECSUF} $ffprobe_opts -v 0 $tencfile || return
}
# FIXME: There is a certain duplication between the avconv-related helper
# functions above and below that should be refactored.
ffmpeg2="$target_exec ${target_path}/ffmpeg${PROGSUF}${EXECSUF}"
raw_src="${target_path}/tests/vsynth1/%02d.pgm"
pcm_src="${target_path}/tests/data/asynth1.sw"
crcfile="tests/data/$test.lavf.crc"
target_crcfile="${target_path}/$crcfile"
[ "${V-0}" -gt 0 ] && echov=echov || echov=:
echov(){
echo "$@" >&3
}
AVCONV_OPTS="-nostdin -nostats -y -cpuflags $cpuflags"
COMMON_OPTS="-flags +bitexact -idct simple -sws_flags +accurate_rnd+bitexact -fflags +bitexact"
DEC_OPTS="$COMMON_OPTS -threads $threads"
ENC_OPTS="$COMMON_OPTS -threads 1 -dct fastint"
run_avconv(){
$echov $ffmpeg2 $AVCONV_OPTS $*
$ffmpeg2 $AVCONV_OPTS $*
}
do_avconv(){
f="$1"
shift
set -- $* ${target_path}/$f
run_avconv $*
do_md5sum $f
echo $(wc -c $f)
}
do_avconv_crc(){
f="$1"
shift
run_avconv $* -f crc "$target_crcfile"
echo "$f $(cat $crcfile)"
}
lavf_audio(){
t="${test#lavf-}"
outdir="tests/data/lavf"
file=${outdir}/lavf.$t
do_avconv $file $DEC_OPTS $1 -ar 44100 -f s16le -i $pcm_src "$ENC_OPTS -metadata title=lavftest" -t 1 -qscale 10 $2
do_avconv_crc $file $DEC_OPTS $3 -i $target_path/$file
}
lavf_container(){
t="${test#lavf-}"
outdir="tests/data/lavf"
file=${outdir}/lavf.$t
do_avconv $file $DEC_OPTS -f image2 -c:v pgmyuv -i $raw_src $DEC_OPTS -ar 44100 -f s16le $1 -i $pcm_src "$ENC_OPTS -metadata title=lavftest" -b:a 64k -t 1 -qscale:v 10 $2
test "$3" = "disable_crc" ||
do_avconv_crc $file $DEC_OPTS -i $target_path/$file $3
}
lavf_container_attach() { lavf_container "" "$1 -attach ${raw_src%/*}/00.pgm -metadata:s:t mimetype=image/x-portable-greymap"; }
lavf_container_timecode_nodrop() { lavf_container "" "$1 -timecode 02:56:14:13"; }
lavf_container_timecode_drop() { lavf_container "" "$1 -timecode 02:56:14.13 -r 30000/1001"; }
lavf_container_timecode()
{
lavf_container_timecode_nodrop "$@"
lavf_container_timecode_drop "$@"
lavf_container "" "$1"
}
lavf_container_fate()
{
t="${test#lavf-fate-}"
outdir="tests/data/lavf-fate"
file=${outdir}/lavf.$t
input="${target_samples}/$1"
do_avconv $file $DEC_OPTS $2 -i "$input" "$ENC_OPTS -metadata title=lavftest" -vcodec copy -acodec copy
do_avconv_crc $file $DEC_OPTS -i $target_path/$file $3
}
lavf_image(){
t="${test#lavf-}"
outdir="tests/data/images/$t"
mkdir -p "$outdir"
file=${outdir}/%02d.$t
run_avconv $DEC_OPTS -f image2 -c:v pgmyuv -i $raw_src $1 "$ENC_OPTS -metadata title=lavftest" -frames 13 -y -qscale 10 $target_path/$file
do_md5sum ${outdir}/02.$t
do_avconv_crc $file $DEC_OPTS $2 -i $target_path/$file $2
echo $(wc -c ${outdir}/02.$t)
}
lavf_image2pipe(){
t="${test#lavf-}"
t="${t%pipe}"
outdir="tests/data/lavf"
file=${outdir}/${t}pipe.$t
do_avconv $file $DEC_OPTS -f image2 -c:v pgmyuv -i $raw_src -f image2pipe "$ENC_OPTS -metadata title=lavftest" -t 1 -qscale 10
do_avconv_crc $file $DEC_OPTS -f image2pipe -i $target_path/$file
}
lavf_video(){
t="${test#lavf-}"
outdir="tests/data/lavf"
file=${outdir}/lavf.$t
do_avconv $file $DEC_OPTS -f image2 -c:v pgmyuv -i $raw_src "$ENC_OPTS -metadata title=lavftest" -t 1 -qscale 10 $1 $2
do_avconv_crc $file $DEC_OPTS -i $target_path/$file $1
}
refcmp_metadata(){
refcmp=$1
pixfmt=$2
fuzz=${3:-0.001}
ffmpeg $FLAGS $ENC_OPTS \
-lavfi "testsrc2=size=300x200:rate=1:duration=5,format=${pixfmt},split[ref][tmp];[tmp]avgblur=4[enc];[enc][ref]${refcmp},metadata=print:file=-" \
-f null /dev/null | awk -v ref=${ref} -v fuzz=${fuzz} -f ${base}/refcmp-metadata.awk -
}
pixfmt_conversion(){
conversion="${test#pixfmt-}"
outdir="tests/data/pixfmt"
raw_dst="$outdir/$conversion.out.yuv"
file=${outdir}/${conversion}.yuv
run_avconv $DEC_OPTS -r 1 -f image2 -c:v pgmyuv -i $raw_src \
$ENC_OPTS -f rawvideo -t 1 -s 352x288 -pix_fmt $conversion $target_path/$raw_dst
do_avconv $file $DEC_OPTS -f rawvideo -s 352x288 -pix_fmt $conversion -i $target_path/$raw_dst \
$ENC_OPTS -f rawvideo -s 352x288 -pix_fmt yuv444p
}
video_filter(){
filters=$1
shift
label=${test#filter-}
raw_src="${target_path}/tests/vsynth1/%02d.pgm"
printf '%-20s' $label
ffmpeg $DEC_OPTS -f image2 -vcodec pgmyuv -i $raw_src \
$FLAGS $ENC_OPTS -vf "$filters" -vcodec rawvideo -frames:v 5 $* -f nut md5:
}
pixfmts(){
filter=${test#filter-pixfmts-}
filter=${filter%_*}
filter_args=$1
prefilter_chain=$2
nframes=${3:-1}
showfiltfmts="$target_exec $target_path/libavfilter/tests/filtfmts${EXECSUF}"
scale_exclude_fmts=${outfile}_scale_exclude_fmts
scale_in_fmts=${outfile}_scale_in_fmts
scale_out_fmts=${outfile}_scale_out_fmts
in_fmts=${outfile}_in_fmts
# exclude pixel formats which are not supported as input
$showfiltfmts scale | awk -F '[ \r]' '/^INPUT/{ fmt=substr($3, 5); print fmt }' | sort >$scale_in_fmts
$showfiltfmts scale | awk -F '[ \r]' '/^OUTPUT/{ fmt=substr($3, 5); print fmt }' | sort >$scale_out_fmts
comm -12 $scale_in_fmts $scale_out_fmts >$scale_exclude_fmts
$showfiltfmts $filter | awk -F '[ \r]' '/^INPUT/{ fmt=substr($3, 5); print fmt }' | sort >$in_fmts
pix_fmts=$(comm -12 $scale_exclude_fmts $in_fmts)
outertest=$test
for pix_fmt in $pix_fmts; do
test=$pix_fmt
video_filter "${prefilter_chain}format=$pix_fmt,$filter=$filter_args" -pix_fmt $pix_fmt -frames:v $nframes
done
rm $in_fmts $scale_in_fmts $scale_out_fmts $scale_exclude_fmts
test=$outertest
}
gapless(){
sample=$(target_path $1)
extra_args=$2
decfile1="${outdir}/${test}.out-1"
decfile2="${outdir}/${test}.out-2"
decfile3="${outdir}/${test}.out-3"
cleanfiles="$cleanfiles $decfile1 $decfile2 $decfile3"
# test packet data
ffmpeg $extra_args -i "$sample" -bitexact -c:a copy -f framecrc -y $(target_path $decfile1)
do_md5sum $decfile1
# test decoded (and cut) data
ffmpeg $extra_args -i "$sample" -bitexact -f wav md5:
# the same as above again, with seeking to the start
ffmpeg $extra_args -ss 0 -seek_timestamp 1 -i "$sample" -bitexact -c:a copy -f framecrc -y $(target_path $decfile2)
do_md5sum $decfile2
ffmpeg $extra_args -ss 0 -seek_timestamp 1 -i "$sample" -bitexact -f wav md5:
# test packet data, with seeking to a specific position
ffmpeg $extra_args -ss 5 -seek_timestamp 1 -i "$sample" -bitexact -c:a copy -f framecrc -y $(target_path $decfile3)
do_md5sum $decfile3
}
gaplessenc(){
sample=$(target_path $1)
format=$2
codec=$3
file1="${outdir}/${test}.out-1"
cleanfiles="$cleanfiles $file1"
# test data after reencoding
ffmpeg -i "$sample" -bitexact -map 0:a -c:a $codec -f $format -y "$(target_path "$file1")"
probegaplessinfo "$(target_path "$file1")"
}
audio_match(){
sample=$(target_path $1)
trefile=$2
extra_args=$3
decfile="${outdir}/${test}.wav"
cleanfiles="$cleanfiles $decfile"
ffmpeg -i "$sample" -bitexact $extra_args -y $(target_path $decfile)
tests/audiomatch${HOSTEXECSUF} $decfile $trefile
}
concat(){
template=$1
sample=$2
mode=$3
extra_args=$4
concatfile="${outdir}/${test}.ffconcat"
packetfile="${outdir}/${test}.ffprobe"
cleanfiles="$concatfile $packetfile"
awk "{gsub(/%SRCFILE%/, \"$sample\"); print}" $template > $concatfile
if [ "$mode" = "md5" ]; then
run ffprobe${PROGSUF}${EXECSUF} -bitexact -show_streams -show_packets -v 0 -safe 0 $extra_args $(target_path $concatfile) | tr -d '\r' > $packetfile
do_md5sum $packetfile
else
run ffprobe${PROGSUF}${EXECSUF} -bitexact -show_streams -show_packets -v 0 -of compact=p=0:nk=1 -safe 0 $extra_args $(target_path $concatfile)
fi
}
venc_data(){
file=$1
stream=$2
frames=$3
run tools/venc_data_dump${EXECSUF} ${file} ${stream} ${frames} ${threads} ${thread_type}
}
null(){
:
}
# Disable globbing: command arguments may contain globbing characters and
# must be kept verbatim
set -f
exec 3>&2
eval $command >"$outfile" 2>$errfile
err=$?
if [ $err -gt 128 ]; then
sig=$(kill -l $err 2>/dev/null)
test "${sig}" = "${sig%[!A-Za-z]*}" || unset sig
fi
if test -e "$ref" || test $cmp = "oneline" || test $cmp = "null" || test $cmp = "grep" ; then
case $cmp in
diff) diff -u -b "$ref" "$outfile" >$cmpfile ;;
rawdiff)diff -u "$ref" "$outfile" >$cmpfile ;;
oneoff) oneoff "$ref" "$outfile" >$cmpfile ;;
stddev) stddev "$ref" "$outfile" >$cmpfile ;;
oneline)oneline "$ref" "$outfile" >$cmpfile ;;
grep) grep "$ref" "$errfile" >$cmpfile ;;
null) cat "$outfile" >$cmpfile ;;
esac
cmperr=$?
test $err = 0 && err=$cmperr
if [ "$report_type" = "ignore" ]; then
test $err = 0 || echo "IGNORE\t${test}" && err=0 && unset sig
else
test $err = 0 || cat $cmpfile
fi
else
echo "reference file '$ref' not found"
err=1
fi
if [ $err -eq 0 ] && test $report_type = "standard" ; then
unset cmpo erro
else
cmpo="$($base64 <$cmpfile)"
erro="$($base64 <$errfile)"
fi
echo "${test}:${sig:-$err}:$cmpo:$erro" >$repfile
if test $err != 0 && test $gen != "no" ; then
echo "GEN $ref"
cp -f "$outfile" "$ref"
err=$?
fi
if test $err = 0; then
if test $keep = 0; then
rm -f $outfile $errfile $cmpfile $cleanfiles
fi
elif test $gen = "no"; then
echo "Test $test failed. Look at $errfile for details."
test "${V:-0}" -gt 0 && cat $errfile
else
echo "Updating reference failed, possibly no output file was generated."
fi
exit $err

31
externals/ffmpeg/tests/fate-valgrind.supp vendored
View File

@@ -1,31 +0,0 @@
# seems fixed in newer versions
# http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=577135
{
zlib-inflate
Memcheck:Cond
fun:inflateReset2
fun:inflateInit2_
}
# libc overreads on purpose
# http://sourceware.org/bugzilla/show_bug.cgi?id=12424
{
eval-strtod
Memcheck:Addr8
fun:__GI___strncasecmp_l
fun:____strtod_l_internal
fun:av_strtod
}
{
eval-strtod
Memcheck:Value8
fun:__GI___strncasecmp_l
fun:____strtod_l_internal
fun:av_strtod
}
{
eval-strtod
Memcheck:Cond
fun:__GI___strncasecmp_l
fun:____strtod_l_internal
fun:av_strtod
}

123
externals/ffmpeg/tests/fate.sh vendored
View File

@@ -1,123 +0,0 @@
#! /bin/sh
config=$1
die(){
echo "$@"
exit 1
}
test -r "$config" || die "usage: fate.sh <config>"
workdir=$(cd $(dirname $config) && pwd)
make=make
tar='tar c'
. "$config"
test -n "$slot" || die "slot not specified"
test -n "$repo" || die "repo not specified"
test -d "$samples" || die "samples location not specified"
: ${branch:=master}
lock(){
lock=$1/fate.lock
(set -C; exec >$lock) 2>/dev/null || return
trap 'rm $lock' EXIT
}
checkout(){
case "$repo" in
file:*|/*) src="${repo#file:}" ;;
git:*) git clone --quiet --branch "$branch" "$repo" "$src" ;;
esac
}
update()(
cd ${src} || return
case "$repo" in
git:*) git fetch --quiet --force && git reset --quiet --hard "origin/$branch" ;;
esac
)
configure()(
cd ${build} || return
${shell} ${src}/configure \
--prefix="${inst}" \
--samples="${samples}" \
--enable-gpl \
--enable-memory-poisoning \
--enable-avresample \
${ignore_tests:+--ignore-tests="$ignore_tests"} \
${arch:+--arch=$arch} \
${cpu:+--cpu="$cpu"} \
${toolchain:+--toolchain="$toolchain"} \
${cross_prefix:+--cross-prefix="$cross_prefix"} \
${as:+--as="$as"} \
${cc:+--cc="$cc"} \
${ld:+--ld="$ld"} \
${target_os:+--target-os="$target_os"} \
${sysroot:+--sysroot="$sysroot"} \
${target_exec:+--target-exec="$target_exec"} \
${target_path:+--target-path="$target_path"} \
${target_samples:+--target-samples="$target_samples"} \
${extra_cflags:+--extra-cflags="$extra_cflags"} \
${extra_ldflags:+--extra-ldflags="$extra_ldflags"} \
${extra_libs:+--extra-libs="$extra_libs"} \
${extra_conf}
)
compile()(
cd ${build} || return
${make} ${makeopts} && ${make} install
)
fate()(
test "$build_only" = "yes" && return
cd ${build} || return
${make} ${makeopts_fate-${makeopts}} -k fate
)
clean(){
rm -rf ${build} ${inst}
}
report(){
date=$(date -u +%Y%m%d%H%M%S)
echo "fate:1:${date}:${slot}:${version}:$1:$2:${branch}:${comment}" >report
cat ${build}/ffbuild/config.fate >>report
cat ${build}/tests/data/fate/*.rep >>report 2>/dev/null || for i in ${build}/tests/data/fate/*.rep ; do cat "$i" >>report 2>/dev/null; done
test -n "$fate_recv" && $tar report *.log | gzip | $fate_recv
}
fail(){
report "$@"
clean
exit
}
mkdir -p ${workdir} || die "Error creating ${workdir}"
lock ${workdir} || die "${workdir} locked"
cd ${workdir} || die "cd ${workdir} failed"
src=${workdir}/src
: ${build:=${workdir}/build}
: ${inst:=${workdir}/install}
test -d "$src" && update || checkout || die "Error fetching source"
cd ${workdir}
version=$(${src}/ffbuild/version.sh ${src})
test "$version" = "$(cat version-$slot 2>/dev/null)" && exit 0
echo ${version} >version-$slot
rm -rf "${build}" *.log
mkdir -p ${build}
configure >configure.log 2>&1 || fail 3 "error configuring"
compile >compile.log 2>&1 || fail 2 "error compiling"
fate >test.log 2>&1 || fail 1 "error testing"
report 0 success
clean

263
externals/ffmpeg/tests/fate/aac.mak vendored
View File

@@ -1,263 +0,0 @@
FATE_AAC += fate-aac-al04_44
fate-aac-al04_44: CMD = pcm -i $(TARGET_SAMPLES)/aac/al04_44.mp4
fate-aac-al04_44: REF = $(SAMPLES)/aac/al04_44.s16
FATE_AAC += fate-aac-al04sf_48
fate-aac-al04sf_48: CMD = pcm -i $(TARGET_SAMPLES)/aac/al04sf_48.mp4
fate-aac-al04sf_48: REF = $(SAMPLES)/aac/al04sf_48.s16
FATE_AAC += fate-aac-al05_44
fate-aac-al05_44: CMD = pcm -i $(TARGET_SAMPLES)/aac/al05_44.mp4
fate-aac-al05_44: REF = $(SAMPLES)/aac/al05_44.s16
FATE_AAC += fate-aac-al06_44
fate-aac-al06_44: CMD = pcm -i $(TARGET_SAMPLES)/aac/al06_44.mp4
fate-aac-al06_44: REF = $(SAMPLES)/aac/al06_44_reorder.s16
FATE_AAC += fate-aac-al07_96
fate-aac-al07_96: CMD = pcm -i $(TARGET_SAMPLES)/aac/al07_96.mp4
fate-aac-al07_96: REF = $(SAMPLES)/aac/al07_96_reorder.s16
FATE_AAC += fate-aac-al15_44
fate-aac-al15_44: CMD = pcm -i $(TARGET_SAMPLES)/aac/al15_44.mp4
fate-aac-al15_44: REF = $(SAMPLES)/aac/al15_44_reorder.s16
FATE_AAC += fate-aac-al17_44
fate-aac-al17_44: CMD = pcm -i $(TARGET_SAMPLES)/aac/al17_44.mp4
fate-aac-al17_44: REF = $(SAMPLES)/aac/al17_44.s16
FATE_AAC += fate-aac-al18_44
fate-aac-al18_44: CMD = pcm -i $(TARGET_SAMPLES)/aac/al18_44.mp4
fate-aac-al18_44: REF = $(SAMPLES)/aac/al18_44.s16
FATE_AAC += fate-aac-am00_88
fate-aac-am00_88: CMD = pcm -i $(TARGET_SAMPLES)/aac/am00_88.mp4
fate-aac-am00_88: REF = $(SAMPLES)/aac/am00_88.s16
FATE_AAC += fate-aac-am05_44
fate-aac-am05_44: CMD = pcm -i $(TARGET_SAMPLES)/aac/am05_44.mp4
fate-aac-am05_44: REF = $(SAMPLES)/aac/am05_44_reorder.s16
FATE_AAC += fate-aac-al_sbr_hq_cm_48_2
fate-aac-al_sbr_hq_cm_48_2: CMD = pcm -i $(TARGET_SAMPLES)/aac/al_sbr_cm_48_2.mp4
fate-aac-al_sbr_hq_cm_48_2: REF = $(SAMPLES)/aac/al_sbr_hq_cm_48_2.s16
FATE_AAC += fate-aac-al_sbr_hq_cm_48_5.1
fate-aac-al_sbr_hq_cm_48_5.1: CMD = pcm -i $(TARGET_SAMPLES)/aac/al_sbr_cm_48_5.1.mp4
fate-aac-al_sbr_hq_cm_48_5.1: REF = $(SAMPLES)/aac/al_sbr_hq_cm_48_5.1_reorder.s16
FATE_AAC += fate-aac-al_sbr_hq_sr_48_2_fsaac48
fate-aac-al_sbr_hq_sr_48_2_fsaac48: CMD = pcm -i $(TARGET_SAMPLES)/aac/al_sbr_sr_48_2_fsaac48.mp4
fate-aac-al_sbr_hq_sr_48_2_fsaac48: REF = $(SAMPLES)/aac/al_sbr_hq_sr_48_2_fsaac48.s16
FATE_AAC += fate-aac-al_sbr_ps_04_ur
fate-aac-al_sbr_ps_04_ur: CMD = pcm -i $(TARGET_SAMPLES)/aac/al_sbr_ps_04_new.mp4
fate-aac-al_sbr_ps_04_ur: REF = $(SAMPLES)/aac/al_sbr_ps_04_ur.s16
FATE_AAC += fate-aac-al_sbr_ps_06_ur
fate-aac-al_sbr_ps_06_ur: CMD = pcm -i $(TARGET_SAMPLES)/aac/al_sbr_ps_06_new.mp4
fate-aac-al_sbr_ps_06_ur: REF = $(SAMPLES)/aac/al_sbr_ps_06_ur.s16
FATE_AAC += fate-aac-ap05_48
fate-aac-ap05_48: CMD = pcm -i $(TARGET_SAMPLES)/aac/ap05_48.mp4
fate-aac-ap05_48: REF = $(SAMPLES)/aac/ap05_48.s16
FATE_AAC += fate-aac-er_ad6000np_44_ep0
fate-aac-er_ad6000np_44_ep0: CMD = pcm -i $(TARGET_SAMPLES)/aac/er_ad6000np_44_ep0.mp4
fate-aac-er_ad6000np_44_ep0: REF = $(SAMPLES)/aac/er_ad6000np_44.s16
FATE_AAC += fate-aac-er_eld1001np_44_ep0
fate-aac-er_eld1001np_44_ep0: CMD = pcm -i $(TARGET_SAMPLES)/aac/er_eld1001np_44_ep0.mp4
fate-aac-er_eld1001np_44_ep0: REF = $(SAMPLES)/aac/er_eld1001np_44.s16
FATE_AAC += fate-aac-er_eld2000np_48_ep0
fate-aac-er_eld2000np_48_ep0: CMD = pcm -i $(TARGET_SAMPLES)/aac/er_eld2000np_48_ep0.mp4
fate-aac-er_eld2000np_48_ep0: REF = $(SAMPLES)/aac/er_eld2000np_48_ep0.s16
FATE_AAC += fate-aac-er_eld2100np_48_ep0
fate-aac-er_eld2100np_48_ep0: CMD = pcm -i $(TARGET_SAMPLES)/aac/er_eld2100np_48_ep0.mp4
fate-aac-er_eld2100np_48_ep0: REF = $(SAMPLES)/aac/er_eld2100np_48.s16
FATE_AAC_FIXED += fate-aac-fixed-al04_44
fate-aac-fixed-al04_44: CMD = pcm -c aac_fixed -i $(TARGET_SAMPLES)/aac/al04_44.mp4
fate-aac-fixed-al04_44: REF = $(SAMPLES)/aac/al04_44.s16
FATE_AAC_FIXED += fate-aac-fixed-al05_44
fate-aac-fixed-al05_44: CMD = pcm -c aac_fixed -i $(TARGET_SAMPLES)/aac/al05_44.mp4
fate-aac-fixed-al05_44: REF = $(SAMPLES)/aac/al05_44.s16
FATE_AAC_FIXED += fate-aac-fixed-al06_44
fate-aac-fixed-al06_44: CMD = pcm -c aac_fixed -i $(TARGET_SAMPLES)/aac/al06_44.mp4
fate-aac-fixed-al06_44: REF = $(SAMPLES)/aac/al06_44_reorder.s16
FATE_AAC_FIXED += fate-aac-fixed-al15_44
fate-aac-fixed-al15_44: CMD = pcm -c aac_fixed -i $(TARGET_SAMPLES)/aac/al15_44.mp4
fate-aac-fixed-al15_44: REF = $(SAMPLES)/aac/al15_44_reorder.s16
FATE_AAC_FIXED += fate-aac-fixed-al17_44
fate-aac-fixed-al17_44: CMD = pcm -c aac_fixed -i $(TARGET_SAMPLES)/aac/al17_44.mp4
fate-aac-fixed-al17_44: REF = $(SAMPLES)/aac/al17_44.s16
FATE_AAC_FIXED += fate-aac-fixed-al18_44
fate-aac-fixed-al18_44: CMD = pcm -c aac_fixed -i $(TARGET_SAMPLES)/aac/al18_44.mp4
fate-aac-fixed-al18_44: REF = $(SAMPLES)/aac/al18_44.s16
FATE_AAC_FIXED += fate-aac-fixed-al_sbr_hq_cm_48_2
fate-aac-fixed-al_sbr_hq_cm_48_2: CMD = pcm -c aac_fixed -i $(TARGET_SAMPLES)/aac/al_sbr_cm_48_2.mp4
fate-aac-fixed-al_sbr_hq_cm_48_2: REF = $(SAMPLES)/aac/al_sbr_hq_cm_48_2.s16
FATE_AAC_FIXED += fate-aac-fixed-al_sbr_hq_cm_48_5.1
fate-aac-fixed-al_sbr_hq_cm_48_5.1: CMD = pcm -c aac_fixed -i $(TARGET_SAMPLES)/aac/al_sbr_cm_48_5.1.mp4
fate-aac-fixed-al_sbr_hq_cm_48_5.1: REF = $(SAMPLES)/aac/al_sbr_hq_cm_48_5.1_reorder.s16
FATE_AAC_FIXED += fate-aac-fixed-al_sbr_hq_sr_48_2_fsaac48
fate-aac-fixed-al_sbr_hq_sr_48_2_fsaac48: CMD = pcm -c aac_fixed -i $(TARGET_SAMPLES)/aac/al_sbr_sr_48_2_fsaac48.mp4
fate-aac-fixed-al_sbr_hq_sr_48_2_fsaac48: REF = $(SAMPLES)/aac/al_sbr_hq_sr_48_2_fsaac48.s16
#FATE_AAC_FIXED += fate-aac-fixed-al_sbr_ps_06_ur
#fate-aac-fixed-al_sbr_ps_06_ur: CMD = pcm -c aac_fixed-i $(TARGET_SAMPLES)/aac/al_sbr_ps_06_new.mp4
#fate-aac-fixed-al_sbr_ps_06_ur: REF = $(SAMPLES)/aac/al_sbr_ps_06_ur.s16
FATE_AAC_FIXED += fate-aac-fixed-ap05_48
fate-aac-fixed-ap05_48: CMD = pcm -c aac_fixed -i $(TARGET_SAMPLES)/aac/ap05_48.mp4
fate-aac-fixed-ap05_48: REF = $(SAMPLES)/aac/ap05_48.s16
FATE_AAC_FIXED += fate-aac-fixed-er_ad6000np_44_ep0
fate-aac-fixed-er_ad6000np_44_ep0: CMD = pcm -c aac_fixed -i $(TARGET_SAMPLES)/aac/er_ad6000np_44_ep0.mp4
fate-aac-fixed-er_ad6000np_44_ep0: REF = $(SAMPLES)/aac/er_ad6000np_44.s16
FATE_AAC_FIXED += fate-aac-fixed-er_eld1001np_44_ep0
fate-aac-fixed-er_eld1001np_44_ep0: CMD = pcm -c aac_fixed -i $(TARGET_SAMPLES)/aac/er_eld1001np_44_ep0.mp4
fate-aac-fixed-er_eld1001np_44_ep0: REF = $(SAMPLES)/aac/er_eld1001np_44.s16
FATE_AAC_FIXED += fate-aac-fixed-er_eld2000np_48_ep0
fate-aac-fixed-er_eld2000np_48_ep0: CMD = pcm -c aac_fixed -i $(TARGET_SAMPLES)/aac/er_eld2000np_48_ep0.mp4
fate-aac-fixed-er_eld2000np_48_ep0: REF = $(SAMPLES)/aac/er_eld2000np_48_ep0.s16
fate-aac-ct%: CMD = pcm -i $(TARGET_SAMPLES)/aac/CT_DecoderCheck/$(@:fate-aac-ct-%=%)
fate-aac-ct%: REF = $(SAMPLES)/aac/CT_DecoderCheck/aacPlusv2.wav
FATE_AAC_CT_RAW = fate-aac-ct-sbr_i-ps_i.aac
FATE_AAC_CT = sbr_bc-ps_i.3gp \
sbr_bic-ps_i.3gp \
sbr_bc-ps_bc.mp4 \
sbr_bc-ps_i.mp4 \
sbr_i-ps_bic.mp4 \
sbr_i-ps_i.mp4
FATE_AAC += $(FATE_AAC_CT:%=fate-aac-ct-%)
FATE_AAC_ENCODE += fate-aac-aref-encode
fate-aac-aref-encode: ./tests/data/asynth-44100-2.wav
fate-aac-aref-encode: CMD = enc_dec_pcm adts wav s16le $(REF) -c:a aac -aac_is 0 -aac_pns 0 -aac_ms 0 -aac_tns 0 -b:a 512k
fate-aac-aref-encode: CMP = stddev
fate-aac-aref-encode: REF = ./tests/data/asynth-44100-2.wav
fate-aac-aref-encode: CMP_SHIFT = -4096
fate-aac-aref-encode: CMP_TARGET = 596
fate-aac-aref-encode: SIZE_TOLERANCE = 2464
fate-aac-aref-encode: FUZZ = 89
FATE_AAC_ENCODE += fate-aac-ln-encode
fate-aac-ln-encode: CMD = enc_dec_pcm adts wav s16le $(TARGET_SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav -c:a aac -aac_is 0 -aac_pns 0 -aac_ms 0 -aac_tns 0 -b:a 512k
fate-aac-ln-encode: CMP = stddev
fate-aac-ln-encode: REF = $(SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav
fate-aac-ln-encode: CMP_SHIFT = -4096
fate-aac-ln-encode: CMP_TARGET = 72
fate-aac-ln-encode: SIZE_TOLERANCE = 3560
fate-aac-ln-encode: FUZZ = 30
FATE_AAC_ENCODE += fate-aac-ln-encode-128k
fate-aac-ln-encode-128k: CMD = enc_dec_pcm adts wav s16le $(TARGET_SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav -c:a aac -aac_is 0 -aac_pns 0 -aac_ms 0 -aac_tns 0 -b:a 128k -cutoff 22050
fate-aac-ln-encode-128k: CMP = stddev
fate-aac-ln-encode-128k: REF = $(SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav
fate-aac-ln-encode-128k: CMP_SHIFT = -4096
fate-aac-ln-encode-128k: CMP_TARGET = 622
fate-aac-ln-encode-128k: SIZE_TOLERANCE = 3560
fate-aac-ln-encode-128k: FUZZ = 5
FATE_AAC_ENCODE += fate-aac-pns-encode
fate-aac-pns-encode: CMD = enc_dec_pcm adts wav s16le $(TARGET_SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav -c:a aac -aac_pns 1 -aac_is 0 -aac_ms 0 -aac_tns 0 -b:a 128k -cutoff 22050 -fflags +bitexact -flags +bitexact
fate-aac-pns-encode: CMP = stddev
fate-aac-pns-encode: REF = $(SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav
fate-aac-pns-encode: CMP_SHIFT = -4096
fate-aac-pns-encode: CMP_TARGET = 655
fate-aac-pns-encode: SIZE_TOLERANCE = 3560
fate-aac-pns-encode: FUZZ = 74
FATE_AAC_ENCODE += fate-aac-tns-encode
fate-aac-tns-encode: CMD = enc_dec_pcm adts wav s16le $(TARGET_SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav -c:a aac -aac_tns 1 -aac_is 0 -aac_pns 0 -aac_ms 0 -b:a 128k -cutoff 22050 -fflags +bitexact -flags +bitexact
fate-aac-tns-encode: CMP = stddev
fate-aac-tns-encode: REF = $(SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav
fate-aac-tns-encode: CMP_SHIFT = -4096
fate-aac-tns-encode: CMP_TARGET = 637
fate-aac-tns-encode: FUZZ = 7
fate-aac-tns-encode: SIZE_TOLERANCE = 3560
FATE_AAC_ENCODE += fate-aac-is-encode
fate-aac-is-encode: CMD = enc_dec_pcm adts wav s16le $(TARGET_SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav -c:a aac -aac_pns 0 -aac_is 1 -aac_ms 0 -b:a 128k -aac_tns 0 -cutoff 22050
fate-aac-is-encode: CMP = stddev
fate-aac-is-encode: REF = $(SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav
fate-aac-is-encode: CMP_SHIFT = -4096
fate-aac-is-encode: CMP_TARGET = 514
fate-aac-is-encode: SIZE_TOLERANCE = 3560
fate-aac-is-encode: FUZZ = 10
FATE_AAC_ENCODE += fate-aac-ms-encode
fate-aac-ms-encode: CMD = enc_dec_pcm adts wav s16le $(TARGET_SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav -c:a aac -aac_pns 0 -aac_is 0 -aac_ms 1 -aac_tns 0 -b:a 128k -cutoff 22050
fate-aac-ms-encode: CMP = stddev
fate-aac-ms-encode: REF = $(SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav
fate-aac-ms-encode: CMP_SHIFT = -4096
fate-aac-ms-encode: CMP_TARGET = 558
fate-aac-ms-encode: SIZE_TOLERANCE = 3560
fate-aac-ms-encode: FUZZ = 15
#Ticket1784
FATE_AAC_ENCODE += fate-aac-yoraw-encode
fate-aac-yoraw-encode: CMD = enc_dec_pcm adts wav s16le $(TARGET_SAMPLES)/audio-reference/yo.raw-short.wav -c:a aac -fflags +bitexact -flags +bitexact
fate-aac-yoraw-encode: CMP = stddev
fate-aac-yoraw-encode: REF = $(SAMPLES)/audio-reference/yo.raw-short.wav
fate-aac-yoraw-encode: CMP_SHIFT = -12288
fate-aac-yoraw-encode: CMP_TARGET = 226
fate-aac-yoraw-encode: SIZE_TOLERANCE = 3560
fate-aac-yoraw-encode: FUZZ = 17
FATE_AAC_ENCODE += fate-aac-pred-encode
fate-aac-pred-encode: CMD = enc_dec_pcm adts wav s16le $(TARGET_SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav -profile:a aac_main -c:a aac -aac_is 0 -aac_pns 0 -aac_ms 0 -aac_tns 0 -b:a 128k -cutoff 22050
fate-aac-pred-encode: CMP = stddev
fate-aac-pred-encode: REF = $(SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav
fate-aac-pred-encode: CMP_SHIFT = -4096
fate-aac-pred-encode: CMP_TARGET = 662
fate-aac-pred-encode: FUZZ = 12
fate-aac-pred-encode: SIZE_TOLERANCE = 3560
FATE_AAC_LATM += fate-aac-latm_000000001180bc60
fate-aac-latm_000000001180bc60: CMD = pcm -i $(TARGET_SAMPLES)/aac/latm_000000001180bc60.mpg
fate-aac-latm_000000001180bc60: REF = $(SAMPLES)/aac/latm_000000001180bc60.s16
FATE_AAC_LATM += fate-aac-latm_stereo_to_51
fate-aac-latm_stereo_to_51: CMD = pcm -i $(TARGET_SAMPLES)/aac/latm_stereo_to_51.ts -channel_layout 5.1
fate-aac-latm_stereo_to_51: REF = $(SAMPLES)/aac/latm_stereo_to_51_ref.s16
fate-aac-autobsf-adtstoasc: CMD = transcode "aac" $(TARGET_SAMPLES)/audiomatch/tones_afconvert_16000_mono_aac_lc.adts \
matroska "-c:a copy" "-c:a copy"
FATE_AAC-$(call DEMDEC, AAC, AAC) += $(FATE_AAC_CT_RAW)
FATE_AAC-$(call DEMDEC, MOV, AAC) += $(FATE_AAC)
FATE_AAC_LATM-$(call DEMDEC, MPEGTS, AAC_LATM) += $(FATE_AAC_LATM)
FATE_AAC-$(call DEMDEC, AAC, AAC_FIXED)+= $(FATE_AAC_FIXED)
FATE_AAC_ALL = $(FATE_AAC-yes) $(FATE_AAC_LATM-yes) $(FATE_AAC_FIXED-yes)
$(FATE_AAC_ALL): CMP = oneoff
$(FATE_AAC_ALL): FUZZ = 2
FATE_AAC_ENCODE-$(call ENCMUX, AAC, ADTS) += $(FATE_AAC_ENCODE)
FATE_AAC_BSF-$(call ALLYES, AAC_DEMUXER AAC_ADTSTOASC_BSF MATROSKA_MUXER) += fate-aac-autobsf-adtstoasc
FATE_SAMPLES_FFMPEG += $(FATE_AAC_ALL) $(FATE_AAC_ENCODE-yes) $(FATE_AAC_BSF-yes)
fate-aac: $(FATE_AAC_ALL) $(FATE_AAC_ENCODE) $(FATE_AAC_BSF-yes)
fate-aac-latm: $(FATE_AAC_LATM-yes)

102
externals/ffmpeg/tests/fate/ac3.mak vendored
View File

@@ -1,102 +0,0 @@
FATE_AC3 += fate-ac3-2.0
fate-ac3-2.0: CMD = pcm -i $(TARGET_SAMPLES)/ac3/monsters_inc_2.0_192_small.ac3
fate-ac3-2.0: REF = $(SAMPLES)/ac3/monsters_inc_2.0_192_small_v2.pcm
FATE_AC3 += fate-ac3-4.0
fate-ac3-4.0: CMD = pcm -i $(TARGET_SAMPLES)/ac3/millers_crossing_4.0.ac3
fate-ac3-4.0: REF = $(SAMPLES)/ac3/millers_crossing_4.0_v2.pcm
#request_channel_layout 4 -> front channel
FATE_AC3 += fate-ac3-4.0-downmix-mono
fate-ac3-4.0-downmix-mono: CMD = pcm -request_channel_layout 4 -i $(TARGET_SAMPLES)/ac3/millers_crossing_4.0.ac3
fate-ac3-4.0-downmix-mono: REF = $(SAMPLES)/ac3/millers_crossing_4.0_mono_v2.pcm
#request_channel_layout 3 -> left channel + right channel
FATE_AC3 += fate-ac3-4.0-downmix-stereo
fate-ac3-4.0-downmix-stereo: CMD = pcm -request_channel_layout 3 -i $(TARGET_SAMPLES)/ac3/millers_crossing_4.0.ac3
fate-ac3-4.0-downmix-stereo: REF = $(SAMPLES)/ac3/millers_crossing_4.0_stereo_v2.pcm
FATE_AC3 += fate-ac3-5.1
fate-ac3-5.1: CMD = pcm -i $(TARGET_SAMPLES)/ac3/monsters_inc_5.1_448_small.ac3
fate-ac3-5.1: REF = $(SAMPLES)/ac3/monsters_inc_5.1_448_small_v2.pcm
FATE_AC3 += fate-ac3-5.1-downmix-mono
fate-ac3-5.1-downmix-mono: CMD = pcm -request_channel_layout 4 -i $(TARGET_SAMPLES)/ac3/monsters_inc_5.1_448_small.ac3
fate-ac3-5.1-downmix-mono: REF = $(SAMPLES)/ac3/monsters_inc_5.1_448_small_mono_v2.pcm
FATE_AC3 += fate-ac3-5.1-downmix-stereo
fate-ac3-5.1-downmix-stereo: CMD = pcm -request_channel_layout 3 -i $(TARGET_SAMPLES)/ac3/monsters_inc_5.1_448_small.ac3
fate-ac3-5.1-downmix-stereo: REF = $(SAMPLES)/ac3/monsters_inc_5.1_448_small_stereo_v2.pcm
FATE_AC3 += fate-ac3-fixed-2.0
fate-ac3-fixed-2.0: CMD = pcm -c ac3_fixed -i $(TARGET_SAMPLES)/ac3/monsters_inc_2.0_192_small.ac3
fate-ac3-fixed-2.0: REF = $(SAMPLES)/ac3/monsters_inc_2.0_192_small_v2.pcm
FATE_AC3 += fate-ac3-fixed-4.0-downmix-mono
fate-ac3-fixed-4.0-downmix-mono: CMD = pcm -c ac3_fixed -request_channel_layout 4 -i $(TARGET_SAMPLES)/ac3/millers_crossing_4.0.ac3
fate-ac3-fixed-4.0-downmix-mono: REF = $(SAMPLES)/ac3/millers_crossing_4.0_mono_v2.pcm
FATE_AC3 += fate-ac3-fixed-5.1-downmix-mono
fate-ac3-fixed-5.1-downmix-mono: CMD = pcm -c ac3_fixed -request_channel_layout 4 -i $(TARGET_SAMPLES)/ac3/monsters_inc_5.1_448_small.ac3
fate-ac3-fixed-5.1-downmix-mono: REF = $(SAMPLES)/ac3/monsters_inc_5.1_448_small_mono_v2.pcm
FATE_AC3 += fate-ac3-fixed-5.1-downmix-stereo
fate-ac3-fixed-5.1-downmix-stereo: CMD = pcm -c ac3_fixed -request_channel_layout 3 -i $(TARGET_SAMPLES)/ac3/monsters_inc_5.1_448_small.ac3
fate-ac3-fixed-5.1-downmix-stereo: REF = $(SAMPLES)/ac3/monsters_inc_5.1_448_small_stereo_v2.pcm
FATE_EAC3 += fate-eac3-1
fate-eac3-1: CMD = pcm -i $(TARGET_SAMPLES)/eac3/csi_miami_5.1_256_spx_small.eac3
fate-eac3-1: REF = $(SAMPLES)/eac3/csi_miami_5.1_256_spx_small_v2.pcm
FATE_EAC3 += fate-eac3-2
fate-eac3-2: CMD = pcm -i $(TARGET_SAMPLES)/eac3/csi_miami_stereo_128_spx_small.eac3
fate-eac3-2: REF = $(SAMPLES)/eac3/csi_miami_stereo_128_spx_small_v2.pcm
FATE_EAC3 += fate-eac3-3
fate-eac3-3: CMD = pcm -i $(TARGET_SAMPLES)/eac3/matrix2_commentary1_stereo_192_small.eac3
fate-eac3-3: REF = $(SAMPLES)/eac3/matrix2_commentary1_stereo_192_small_v2.pcm
FATE_EAC3 += fate-eac3-4
fate-eac3-4: CMD = pcm -i $(TARGET_SAMPLES)/eac3/serenity_english_5.1_1536_small.eac3
fate-eac3-4: REF = $(SAMPLES)/eac3/serenity_english_5.1_1536_small_v2.pcm
FATE_EAC3 += fate-eac3-5
fate-eac3-5: CMD = pcm -i $(TARGET_SAMPLES)/eac3/the_great_wall_7.1.eac3
fate-eac3-5: REF = $(SAMPLES)/eac3/the_great_wall_7.1.pcm
$(FATE_AC3) $(FATE_EAC3): CMP = oneoff
FATE_AC3-$(call DEMDEC, AC3, AC3) += $(FATE_AC3)
FATE_EAC3-$(call DEMDEC, EAC3, EAC3) += $(FATE_EAC3)
FATE_AC3-$(call ENCDEC, AC3, AC3) += fate-ac3-encode
fate-ac3-encode: CMD = enc_dec_pcm ac3 wav s16le $(subst $(SAMPLES),$(TARGET_SAMPLES),$(REF)) -c:a ac3 -b:a 128k
fate-ac3-encode: CMP_SHIFT = -1024
fate-ac3-encode: CMP_TARGET = 404.53
fate-ac3-encode: SIZE_TOLERANCE = 488
FATE_EAC3-$(call ENCDEC, EAC3, EAC3) += fate-eac3-encode
fate-eac3-encode: CMD = enc_dec_pcm eac3 wav s16le $(subst $(SAMPLES),$(TARGET_SAMPLES),$(REF)) -c:a eac3 -b:a 128k
fate-eac3-encode: CMP_SHIFT = -1024
fate-eac3-encode: CMP_TARGET = 516.94
fate-eac3-encode: SIZE_TOLERANCE = 488
fate-ac3-encode fate-eac3-encode: CMP = stddev
fate-ac3-encode fate-eac3-encode: REF = $(SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav
FATE_AC3-$(call ENCMUX, AC3_FIXED, AC3) += fate-ac3-fixed-encode
fate-ac3-fixed-encode: tests/data/asynth-44100-2.wav
fate-ac3-fixed-encode: SRC = $(TARGET_PATH)/tests/data/asynth-44100-2.wav
fate-ac3-fixed-encode: CMD = md5 -i $(SRC) -c ac3_fixed -ab 128k -f ac3 -flags +bitexact
fate-ac3-fixed-encode: CMP = oneline
fate-ac3-fixed-encode: REF = a1d1fc116463b771abf5aef7ed37d7b1
FATE_EAC3-$(call ALLYES, EAC3_DEMUXER EAC3_MUXER EAC3_CORE_BSF) += fate-eac3-core-bsf
fate-eac3-core-bsf: CMD = md5pipe -i $(TARGET_SAMPLES)/eac3/the_great_wall_7.1.eac3 -c:a copy -bsf:a eac3_core -fflags +bitexact -f eac3
fate-eac3-core-bsf: CMP = oneline
fate-eac3-core-bsf: REF = b704bf851e99b7442e9bed368b60e6ca
FATE_SAMPLES_AVCONV += $(FATE_AC3-yes) $(FATE_EAC3-yes)
fate-ac3: $(FATE_AC3-yes) $(FATE_EAC3-yes)

167
externals/ffmpeg/tests/fate/acodec.mak vendored
View File

@@ -1,167 +0,0 @@
fate-acodec-%: CODEC = $(@:fate-acodec-%=%)
fate-acodec-%: SRC = tests/data/asynth-44100-2.wav
fate-acodec-%: CMD = enc_dec wav $(SRC) $(FMT) "-b:a 128k -c $(CODEC) $(ENCOPTS)" wav "-c pcm_s16le $(DECOPTS)" -keep
fate-acodec-%: CMP_UNIT = 2
fate-acodec-%: REF = $(SRC_PATH)/tests/ref/acodec/$(@:fate-acodec-%=%)
FATE_ACODEC_PCM-$(call ENCDEC, PCM_ALAW, WAV) += alaw
FATE_ACODEC_PCM-$(call ENCDEC, PCM_MULAW, WAV) += mulaw
FATE_ACODEC_PCM-$(call ENCDEC, PCM_S8, MOV) += s8
FATE_ACODEC_PCM-$(call ENCDEC, PCM_U8, WAV) += u8
FATE_ACODEC_PCM-$(call ENCDEC, PCM_S16BE, MOV) += s16be
FATE_ACODEC_PCM-$(call ENCDEC, PCM_S16LE, WAV) += s16le
FATE_ACODEC_PCM-$(call ENCDEC, PCM_U16BE, NUT) += u16be
FATE_ACODEC_PCM-$(call ENCDEC, PCM_U16LE, NUT) += u16le
FATE_ACODEC_PCM-$(call ENCDEC, PCM_S24BE, MOV) += s24be
FATE_ACODEC_PCM-$(call ENCDEC, PCM_S24LE, WAV) += s24le
FATE_ACODEC_PCM-$(call ENCDEC, PCM_U24BE, NUT) += u24be
FATE_ACODEC_PCM-$(call ENCDEC, PCM_U24LE, NUT) += u24le
FATE_ACODEC_PCM-$(call ENCDEC, PCM_S32BE, MOV) += s32be
FATE_ACODEC_PCM-$(call ENCDEC, PCM_S32LE, WAV) += s32le
FATE_ACODEC_PCM-$(call ENCDEC, PCM_U32BE, NUT) += u32be
FATE_ACODEC_PCM-$(call ENCDEC, PCM_U32LE, NUT) += u32le
FATE_ACODEC_PCM-$(call ENCDEC, PCM_F32BE, AU) += f32be
FATE_ACODEC_PCM-$(call ENCDEC, PCM_F32LE, WAV) += f32le
FATE_ACODEC_PCM-$(call ENCDEC, PCM_F64BE, AU) += f64be
FATE_ACODEC_PCM-$(call ENCDEC, PCM_F64LE, WAV) += f64le
FATE_ACODEC_PCM-$(call ENCDEC, PCM_S8_PLANAR, NUT) += s8_planar
FATE_ACODEC_PCM-$(call ENCDEC, PCM_S16BE_PLANAR, NUT) += s16be_planar
FATE_ACODEC_PCM-$(call ENCDEC, PCM_S16LE_PLANAR, NUT) += s16le_planar
FATE_ACODEC_PCM-$(call ENCDEC, PCM_S24LE_PLANAR, NUT) += s24le_planar
FATE_ACODEC_PCM-$(call ENCDEC, PCM_S32LE_PLANAR, NUT) += s32le_planar
FATE_ACODEC_PCM := $(FATE_ACODEC_PCM-yes:%=fate-acodec-pcm-%)
FATE_ACODEC += $(FATE_ACODEC_PCM)
fate-acodec-pcm: $(FATE_ACODEC_PCM)
fate-acodec-pcm-%: FMT = wav
fate-acodec-pcm-%_planar: FMT = nut
fate-acodec-pcm-%: CODEC = pcm_$(@:fate-acodec-pcm-%=%)
fate-acodec-pcm-s8: FMT = mov
fate-acodec-pcm-s%be: FMT = mov
fate-acodec-pcm-u%be: FMT = nut
fate-acodec-pcm-u%le: FMT = nut
fate-acodec-pcm-f%be: FMT = au
FATE_ACODEC_ADPCM-$(call ENCDEC, ADPCM_ADX, ADX) += adx
FATE_ACODEC_ADPCM-$(call ENCDEC, ADPCM_IMA_QT, AIFF) += ima_qt
FATE_ACODEC_ADPCM-$(call ENCDEC, ADPCM_IMA_SSI, KVAG) += ima_ssi
FATE_ACODEC_ADPCM-$(call ENCDEC, ADPCM_IMA_WAV, WAV) += ima_wav
FATE_ACODEC_ADPCM-$(call ENCDEC, ADPCM_MS, WAV) += ms
FATE_ACODEC_ADPCM-$(call ENCDEC, ADPCM_SWF, FLV) += swf
FATE_ACODEC_ADPCM-$(call ENCDEC, ADPCM_YAMAHA, WAV) += yamaha
FATE_ACODEC_ADPCM := $(FATE_ACODEC_ADPCM-yes:%=fate-acodec-adpcm-%)
FATE_ACODEC += $(FATE_ACODEC_ADPCM)
fate-acodec-adpcm: $(FATE_ACODEC_ADPCM)
fate-acodec-adpcm-%: CODEC = adpcm_$(@:fate-acodec-adpcm-%=%)
fate-acodec-adpcm-adx: FMT = adx
fate-acodec-adpcm-ima_qt: FMT = aiff
fate-acodec-adpcm-ima_ssi: FMT = kvag
fate-acodec-adpcm-ima_wav: FMT = wav
fate-acodec-adpcm-ms: FMT = wav
fate-acodec-adpcm-swf: FMT = flv
fate-acodec-adpcm-yamaha: FMT = wav
FATE_ACODEC_ADPCM_TRELLIS-$(call ENCDEC, ADPCM_ADX, ADX) += adx
FATE_ACODEC_ADPCM_TRELLIS-$(call ENCDEC, ADPCM_IMA_QT, AIFF) += ima_qt
FATE_ACODEC_ADPCM_TRELLIS-$(call ENCDEC, ADPCM_IMA_WAV, WAV) += ima_wav
FATE_ACODEC_ADPCM_TRELLIS-$(call ENCDEC, ADPCM_MS, WAV) += ms
FATE_ACODEC_ADPCM_TRELLIS-$(call ENCDEC, ADPCM_SWF, FLV) += swf
FATE_ACODEC_ADPCM_TRELLIS-$(call ENCDEC, ADPCM_YAMAHA, WAV) += yamaha
FATE_ACODEC_ADPCM_TRELLIS := $(FATE_ACODEC_ADPCM_TRELLIS-yes:%=fate-acodec-adpcm-%-trellis)
FATE_ACODEC += $(FATE_ACODEC_ADPCM_TRELLIS)
fate-acodec-adpcm-trellis: $(FATE_ACODEC_ADPCM_TRELLIS)
fate-acodec-adpcm-%-trellis: CODEC = adpcm_$(@:fate-acodec-adpcm-%-trellis=%)
fate-acodec-adpcm-%-trellis: ENCOPTS = -trellis 5
fate-acodec-adpcm-adx-trellis: FMT = adx
fate-acodec-adpcm-ima_qt-trellis: FMT = aiff
fate-acodec-adpcm-ima_wav-trellis: FMT = wav
fate-acodec-adpcm-ms-trellis: FMT = wav
fate-acodec-adpcm-swf-trellis: FMT = flv
fate-acodec-adpcm-yamaha-trellis: FMT = wav
FATE_ACODEC-$(call ENCDEC, MP2, MP2 MP3) += fate-acodec-mp2
fate-acodec-mp2: FMT = mp2
fate-acodec-mp2: CMP_SHIFT = -1924
fate-acodec-mp2: ENCOPTS = -b:a 128k
FATE_ACODEC-$(call ENCDEC, MP2FIXED MP2 , MP2 MP3) += fate-acodec-mp2fixed
fate-acodec-mp2fixed: FMT = mp2
fate-acodec-mp2fixed: CMP_SHIFT = -1924
fate-acodec-mp2fixed: ENCOPTS = -b:a 384k
FATE_ACODEC-$(call ENCDEC, ALAC, MOV) += fate-acodec-alac
fate-acodec-alac: FMT = mov
fate-acodec-alac: CODEC = alac -compression_level 1
FATE_ACODEC-$(call ENCDEC, DCA, DTS) += fate-acodec-dca
fate-acodec-dca: tests/data/asynth-44100-2.wav
fate-acodec-dca: SRC = tests/data/asynth-44100-2.wav
fate-acodec-dca: CMD = md5 -i $(TARGET_PATH)/$(SRC) -c:a dca -strict -2 -f dts -flags +bitexact
fate-acodec-dca: CMP = oneline
fate-acodec-dca: REF = 2aa580ac67820fce4f581b96ebb34acc
FATE_ACODEC-$(call ENCDEC, DCA, WAV) += fate-acodec-dca2
fate-acodec-dca2: CMD = enc_dec_pcm dts wav s16le $(SRC) -c:a dca -strict -2 -flags +bitexact
fate-acodec-dca2: REF = $(SRC)
fate-acodec-dca2: CMP = stddev
fate-acodec-dca2: CMP_SHIFT = -2048
fate-acodec-dca2: CMP_TARGET = 535
fate-acodec-dca2: SIZE_TOLERANCE = 1632
FATE_ACODEC-$(call ENCDEC, FLAC, FLAC) += fate-acodec-flac fate-acodec-flac-exact-rice
fate-acodec-flac: FMT = flac
fate-acodec-flac: CODEC = flac -compression_level 2
fate-acodec-flac-exact-rice: FMT = flac
fate-acodec-flac-exact-rice: CODEC = flac -compression_level 2 -exact_rice_parameters 1
FATE_ACODEC-$(call ENCDEC, G723_1, G723_1) += fate-acodec-g723_1
fate-acodec-g723_1: tests/data/asynth-8000-1.wav
fate-acodec-g723_1: SRC = tests/data/asynth-8000-1.wav
fate-acodec-g723_1: FMT = g723_1
fate-acodec-g723_1: CODEC = g723_1
fate-acodec-g723_1: ENCOPTS = -b:a 6.3k
fate-acodec-g723_1: CMP_SHIFT = 8
FATE_ACODEC-$(call ENCDEC, RA_144, WAV) += fate-acodec-ra144
fate-acodec-ra144: tests/data/asynth-8000-1.wav
fate-acodec-ra144: SRC = tests/data/asynth-8000-1.wav
fate-acodec-ra144: CMD = enc_dec_pcm rm wav s16le $(SRC) -c:a real_144
fate-acodec-ra144: REF = $(SRC)
fate-acodec-ra144: CMP = stddev
fate-acodec-ra144: CMP_TARGET = 4777
fate-acodec-ra144: CMP_SHIFT = -320
FATE_ACODEC-$(call ENCDEC, ROQ_DPCM, ROQ) += fate-acodec-roqaudio
fate-acodec-roqaudio: FMT = roq
fate-acodec-roqaudio: CODEC = roq_dpcm
fate-acodec-roqaudio: ENCOPTS = -ar 22050
fate-acodec-roqaudio: DECOPTS = -ar 44100
FATE_ACODEC-$(call ENCDEC, S302M, MPEGTS) += fate-acodec-s302m
fate-acodec-s302m: FMT = mpegts
fate-acodec-s302m: CODEC = s302m
fate-acodec-s302m: ENCOPTS = -ar 48000 -strict -2
fate-acodec-s302m: DECOPTS = -ar 44100
FATE_ACODEC-$(call ENCDEC, WAVPACK, WV) += fate-acodec-wavpack
fate-acodec-wavpack: FMT = wv
fate-acodec-wavpack: CODEC = wavpack -compression_level 1
FATE_ACODEC-$(call ENCDEC, TTA, TTA) += fate-acodec-tta
fate-acodec-tta: FMT = tta
FATE_ACODEC += $(FATE_ACODEC-yes)
$(FATE_ACODEC): tests/data/asynth-44100-2.wav
FATE_AVCONV += $(FATE_ACODEC)
fate-acodec: $(FATE_ACODEC)

143
externals/ffmpeg/tests/fate/adpcm.mak vendored
View File

@@ -1,143 +0,0 @@
FATE_ADPCM-$(call DEMDEC, FOURXM, ADPCM_4XM) += fate-adpcm-4xm
fate-adpcm-4xm: CMD = framecrc -i $(TARGET_SAMPLES)/4xm/dracula.4xm -vn -map 0:6
FATE_ADPCM-$(call DEMDEC, AST, ADPCM_AFC) += fate-adpcm-afc
fate-adpcm-afc: CMD = framecrc -i $(TARGET_SAMPLES)/ast/demo11_02_partial.ast
FATE_ADPCM-$(call DEMDEC, WAV, ADPCM_CT) += fate-adpcm-creative
fate-adpcm-creative: CMD = md5 -i $(TARGET_SAMPLES)/creative/intro-partial.wav -f s16le
FATE_ADPCM-$(call DEMDEC, VOC, ADPCM_SBPRO_2) += fate-adpcm-creative-8-2bit
fate-adpcm-creative-8-2bit: CMD = md5 -i $(TARGET_SAMPLES)/creative/BBC_2BIT.VOC -f s16le
FATE_ADPCM-$(call DEMDEC, VOC, ADPCM_SBPRO_3) += fate-adpcm-creative-8-2.6bit
fate-adpcm-creative-8-2.6bit: CMD = md5 -i $(TARGET_SAMPLES)/creative/BBC_3BIT.VOC -f s16le
FATE_ADPCM-$(call DEMDEC, VOC, ADPCM_SBPRO_4) += fate-adpcm-creative-8-4bit
fate-adpcm-creative-8-4bit: CMD = md5 -i $(TARGET_SAMPLES)/creative/BBC_4BIT.VOC -f s16le
FATE_ADPCM-$(call DEMDEC, ADP, ADPCM_DTK) += fate-adpcm-dtk
fate-adpcm-dtk: CMD = framecrc -i $(TARGET_SAMPLES)/adp/shakespr_partial.adp -f s16le
FATE_ADPCM-$(call DEMDEC, EA, ADPCM_EA) += fate-adpcm-ea-1
fate-adpcm-ea-1: CMD = framecrc -i $(TARGET_SAMPLES)/ea-wve/networkBackbone-partial.wve -frames:a 26 -vn
FATE_ADPCM-$(call DEMDEC, EA, ADPCM_EA) += fate-adpcm-ea-2
fate-adpcm-ea-2: CMD = framecrc -i $(TARGET_SAMPLES)/ea-dct/NFS2Esprit-partial.dct -vn
FATE_ADPCM-$(call DEMDEC, XA, ADPCM_EA_MAXIS_XA) += fate-adpcm-ea-maxis-xa
fate-adpcm-ea-maxis-xa: CMD = framecrc -i $(TARGET_SAMPLES)/maxis-xa/SC2KBUG.XA -frames:a 30
FATE_ADPCM-$(call DEMDEC, EA, ADPCM_EA_R1) += fate-adpcm-ea-r1
fate-adpcm-ea-r1: CMD = framecrc -i $(TARGET_SAMPLES)/ea-mad/NFS6LogoE.mad -vn
FATE_ADPCM-$(call DEMDEC, EA, ADPCM_EA_R2) += fate-adpcm-ea-r2
fate-adpcm-ea-r2: CMD = crc -i $(TARGET_SAMPLES)/ea-mpc/THX_logo.mpc -vn
FATE_ADPCM-$(call DEMDEC, EA, ADPCM_EA_R3) += fate-adpcm-ea-r3
fate-adpcm-ea-r3: CMD = crc -i $(TARGET_SAMPLES)/ea-vp6/THX_logo.vp6 -vn
FATE_ADPCM-$(call DEMDEC, AVI, ADPCM_IMA_AMV) += fate-adpcm-ima-amv
fate-adpcm-ima-amv: CMD = framecrc -i $(TARGET_SAMPLES)/amv/MTV_high_res_320x240_sample_Penguin_Joke_MTV_from_WMV.amv -t 10 -vn
FATE_ADPCM-$(call DEMDEC, APC, ADPCM_IMA_APC) += fate-adpcm-ima-apc
fate-adpcm-ima-apc: CMD = md5 -i $(TARGET_SAMPLES)/cryo-apc/cine007.APC -f s16le
FATE_ADPCM-$(call DEMDEC, AVI, ADPCM_IMA_DK3) += fate-adpcm-ima-dk3
fate-adpcm-ima-dk3: CMD = md5 -i $(TARGET_SAMPLES)/duck/sop-audio-only.avi -f s16le
FATE_ADPCM-$(call DEMDEC, AVI, ADPCM_IMA_DK4) += fate-adpcm-ima-dk4
fate-adpcm-ima-dk4: CMD = md5 -i $(TARGET_SAMPLES)/duck/salsa-audio-only.avi -f s16le
FATE_ADPCM-$(call DEMDEC, EA, ADPCM_IMA_EA_EACS) += fate-adpcm-ima-ea-eacs
fate-adpcm-ima-ea-eacs: CMD = framecrc -i $(TARGET_SAMPLES)/ea-tgv/INTRO8K-partial.TGV -vn
FATE_ADPCM-$(call DEMDEC, EA, ADPCM_IMA_EA_SEAD) += fate-adpcm-ima-ea-sead
fate-adpcm-ima-ea-sead: CMD = framecrc -i $(TARGET_SAMPLES)/ea-tgv/INTEL_S.TGV -vn
FATE_ADPCM-$(call DEMDEC, ISS, ADPCM_IMA_ISS) += fate-adpcm-ima-iss
fate-adpcm-ima-iss: CMD = md5 -i $(TARGET_SAMPLES)/funcom-iss/0004010100.iss -f s16le
FATE_ADPCM-$(call DEMDEC, WAV, ADPCM_IMA_OKI) += fate-adpcm-ima-oki
fate-adpcm-ima-oki: CMD = md5 -i $(TARGET_SAMPLES)/oki/test.wav -f s16le
FATE_ADPCM-$(call DEMDEC, RSD, ADPCM_IMA_RAD) += fate-adpcm-ima-rad
fate-adpcm-ima-rad: CMD = md5 -i $(TARGET_SAMPLES)/rsd/hit_run_partial.rsd -f s16le
FATE_ADPCM-$(call DEMDEC, SMJPEG, ADPCM_IMA_SMJPEG) += fate-adpcm-ima-smjpeg
fate-adpcm-ima-smjpeg: CMD = framecrc -i $(TARGET_SAMPLES)/smjpeg/scenwin.mjpg -vn
FATE_ADPCM-$(call DEMDEC, MOV, ADPCM_IMA_WAV) += fate-adpcm-ima_wav-stereo
fate-adpcm-ima_wav-stereo: CMD = md5 -i $(TARGET_SAMPLES)/qt-surge-suite/surge-2-16-L-ms11.mov -f s16le
FATE_ADPCM-$(call DEMDEC, WSVQA, ADPCM_IMA_WS) += fate-adpcm-ima-ws
fate-adpcm-ima-ws: CMD = framecrc -i $(TARGET_SAMPLES)/vqa/cc-demo1-partial.vqa -vn
FATE_ADPCM-$(call DEMDEC, DXA, ADPCM_MS) += fate-adpcm-ms-mono
fate-adpcm-ms-mono: CMD = framecrc -i $(TARGET_SAMPLES)/dxa/meetsquid.dxa -t 2 -vn
FATE_ADPCM-$(call DEMDEC, MOV, ADPCM_MS) += fate-adpcm_ms-stereo
fate-adpcm_ms-stereo: CMD = md5 -i $(TARGET_SAMPLES)/qt-surge-suite/surge-2-16-L-ms02.mov -f s16le
FATE_ADPCM-$(call DEMDEC, THP, ADPCM_THP) += fate-adpcm-thp
fate-adpcm-thp: CMD = framecrc -i $(TARGET_SAMPLES)/thp/pikmin2-opening1-partial.thp -vn
FATE_ADPCM-$(call DEMDEC, SMUSH, ADPCM_VIMA) += fate-adpcm-vima
fate-adpcm-vima: CMD = framecrc -i $(TARGET_SAMPLES)/smush/ronin_part.znm -vn
FATE_ADPCM-$(call DEMDEC, STR, ADPCM_XA) += fate-adpcm-xa
fate-adpcm-xa: CMD = framecrc -i $(TARGET_SAMPLES)/psx-str/abc000_cut.str -vn
FATE_ADPCM-$(call DEMDEC, ARGO_ASF, ADPCM_ARGO) += fate-adpcm-argo-mono
fate-adpcm-argo-mono: CMD = md5 -i $(TARGET_SAMPLES)/argo-asf/PWIN22M.ASF -f s16le
FATE_ADPCM-$(call DEMDEC, ARGO_ASF, ADPCM_ARGO) += fate-adpcm-argo-stereo
fate-adpcm-argo-stereo: CMD = md5 -i $(TARGET_SAMPLES)/argo-asf/CBK2_cut.asf -f s16le
FATE_ADPCM-$(call DEMDEC, KVAG, ADPCM_IMA_SSI) += fate-adpcm-ima-ssi-mono
fate-adpcm-ima-ssi-mono: CMD = md5 -i $(TARGET_SAMPLES)/kvag/mull1_cut.vag -f s16le
FATE_ADPCM-$(call DEMDEC, KVAG, ADPCM_IMA_SSI) += fate-adpcm-ima-ssi-stereo
fate-adpcm-ima-ssi-stereo: CMD = md5 -i $(TARGET_SAMPLES)/kvag/credits_cut.vag -f s16le
FATE_ADPCM-$(call DEMDEC, APM, ADPCM_IMA_APM) += fate-adpcm-ima-apm-mono
fate-adpcm-ima-apm-mono: CMD = md5 -i $(TARGET_SAMPLES)/apm/outro1.apm -f s16le
FATE_ADPCM-$(call DEMDEC, APM, ADPCM_IMA_APM) += fate-adpcm-ima-apm-stereo
fate-adpcm-ima-apm-stereo: CMD = md5 -i $(TARGET_SAMPLES)/apm/AS01.apm -f s16le
FATE_ADPCM-$(call DEMDEC, ALP, ADPCM_IMA_ALP) += fate-adpcm-ima-alp-mono
fate-adpcm-ima-alp-mono: CMD = md5 -i $(TARGET_SAMPLES)/alp/AD_P11.PCM -f s16le
FATE_ADPCM-$(call DEMDEC, ALP, ADPCM_IMA_ALP) += fate-adpcm-ima-alp-stereo
fate-adpcm-ima-alp-stereo: CMD = md5 -i $(TARGET_SAMPLES)/alp/theme-cut.tun -f s16le
FATE_ADPCM-$(call DEMDEC, PP_BNK, ADPCM_IMA_CUNNING) += fate-adpcm-ima-cunning-single
fate-adpcm-ima-cunning-single: CMD = md5 -y -i $(TARGET_SAMPLES)/pp_bnk/GD-cut.5c -f s16le
FATE_ADPCM-$(call DEMDEC, PP_BNK, ADPCM_IMA_CUNNING) += fate-adpcm-ima-cunning-track0
fate-adpcm-ima-cunning-track0: CMD = md5 -y -i $(TARGET_SAMPLES)/pp_bnk/VIDEOMOD-cut.11c -map 0:a:0 -f s16le
FATE_ADPCM-$(call DEMDEC, PP_BNK, ADPCM_IMA_CUNNING) += fate-adpcm-ima-cunning-track1
fate-adpcm-ima-cunning-track1: CMD = md5 -y -i $(TARGET_SAMPLES)/pp_bnk/VIDEOMOD-cut.11c -map 0:a:1 -f s16le
FATE_ADPCM-$(call DEMDEC, PP_BNK, ADPCM_IMA_CUNNING) += fate-adpcm-ima-cunning-trunc-t1
fate-adpcm-ima-cunning-trunc-t1: CMD = md5 -y -i $(TARGET_SAMPLES)/pp_bnk/VIDEOMOD-trunc-t1.11c -map 0:a:0 -f s16le
FATE_ADPCM-$(call DEMDEC, PP_BNK, ADPCM_IMA_CUNNING) += fate-adpcm-ima-cunning-trunc-t2-track0
fate-adpcm-ima-cunning-trunc-t2-track0: CMD = md5 -y -i $(TARGET_SAMPLES)/pp_bnk/VIDEOMOD-trunc-t2.11c -map 0:a:0 -f s16le
FATE_ADPCM-$(call DEMDEC, PP_BNK, ADPCM_IMA_CUNNING) += fate-adpcm-ima-cunning-trunc-t2-track1
fate-adpcm-ima-cunning-trunc-t2-track1: CMD = md5 -y -i $(TARGET_SAMPLES)/pp_bnk/VIDEOMOD-trunc-t2.11c -map 0:a:1 -f s16le
FATE_ADPCM-$(call DEMDEC, PP_BNK, ADPCM_IMA_CUNNING) += fate-adpcm-ima-cunning-trunc-t2a-track0
fate-adpcm-ima-cunning-trunc-t2a-track0: CMD = md5 -y -i $(TARGET_SAMPLES)/pp_bnk/VIDEOMOD-trunc-t2a.11c -map 0:a:0 -f s16le
FATE_ADPCM-$(call DEMDEC, PP_BNK, ADPCM_IMA_CUNNING) += fate-adpcm-ima-cunning-trunc-t2a-track1
fate-adpcm-ima-cunning-trunc-t2a-track1: CMD = md5 -y -i $(TARGET_SAMPLES)/pp_bnk/VIDEOMOD-trunc-t2a.11c -map 0:a:1 -f s16le
FATE_ADPCM-$(call DEMDEC, PP_BNK, ADPCM_IMA_CUNNING) += fate-adpcm-ima-cunning-trunc-h2
fate-adpcm-ima-cunning-trunc-h2: CMD = md5 -y -i $(TARGET_SAMPLES)/pp_bnk/VIDEOMOD-trunc-h2.11c -map 0:a:0 -f s16le
FATE_SAMPLES_AVCONV += $(FATE_ADPCM-yes)
fate-adpcm: $(FATE_ADPCM-yes)

24
externals/ffmpeg/tests/fate/alac.mak vendored
View File

@@ -1,24 +0,0 @@
FATE_ALAC += fate-alac-16-level-0 \
fate-alac-16-level-1 \
fate-alac-16-level-2 \
fate-alac-16-lpc-orders \
fate-alac-24-level-0 \
fate-alac-24-level-1 \
fate-alac-24-level-2 \
fate-alac-24-lpc-orders \
fate-alac-16-level-%: OPTS = -compression_level $(@:fate-alac-16-level-%=%)
fate-alac-24-level-%: OPTS = -compression_level $(@:fate-alac-24-level-%=%)
fate-alac-%-lpc-orders: OPTS = -min_prediction_order 1 -max_prediction_order 30
fate-alac-16-%: REF = $(SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav
fate-alac-16-%: CMD = enc_dec_pcm mov wav s16le $(subst $(SAMPLES),$(TARGET_SAMPLES),$(REF)) -c alac $(OPTS)
fate-alac-24-%: REF = $(SAMPLES)/audio-reference/divertimenti_2ch_96kHz_s24.wav
fate-alac-24-%: CMD = enc_dec_pcm mov wav s24le $(subst $(SAMPLES),$(TARGET_SAMPLES),$(REF)) -c alac $(OPTS)
fate-alac-%: CMP = oneoff
fate-alac-%: FUZZ = 0
FATE_SAMPLES_AVCONV-$(call ENCDEC, ALAC, MOV) += $(FATE_ALAC)
fate-alac: $(FATE_ALAC)

15
externals/ffmpeg/tests/fate/als.mak vendored
View File

@@ -1,15 +0,0 @@
ALS_SUITE = 00 01 02 03 04 05
define FATE_ALS_SUITE
FATE_ALS += fate-mpeg4-als-conformance-$(1)
fate-mpeg4-als-conformance-$(1): CMD = crc -i $(TARGET_SAMPLES)/lossless-audio/als_$(1)_2ch48k16b.mp4
endef
$(foreach N,$(ALS_SUITE),$(eval $(call FATE_ALS_SUITE,$(N))))
FATE_ALS += fate-mpeg4-als-conformance-09
fate-mpeg4-als-conformance-09: CMD = crc -i $(TARGET_SAMPLES)/lossless-audio/als_09_512ch2k16b.mp4
FATE_SAMPLES_AVCONV-$(call DEMDEC, MOV, ALS) += $(FATE_ALS)
fate-als: $(FATE_ALS)

36
externals/ffmpeg/tests/fate/amrnb.mak vendored
View File

@@ -1,36 +0,0 @@
FATE_AMRNB += fate-amrnb-4k75
fate-amrnb-4k75: CMD = pcm -i $(TARGET_SAMPLES)/amrnb/4.75k.amr
fate-amrnb-4k75: REF = $(SAMPLES)/amrnb/4.75k.pcm
FATE_AMRNB += fate-amrnb-5k15
fate-amrnb-5k15: CMD = pcm -i $(TARGET_SAMPLES)/amrnb/5.15k.amr
fate-amrnb-5k15: REF = $(SAMPLES)/amrnb/5.15k.pcm
FATE_AMRNB += fate-amrnb-5k9
fate-amrnb-5k9: CMD = pcm -i $(TARGET_SAMPLES)/amrnb/5.9k.amr
fate-amrnb-5k9: REF = $(SAMPLES)/amrnb/5.9k.pcm
FATE_AMRNB += fate-amrnb-6k7
fate-amrnb-6k7: CMD = pcm -i $(TARGET_SAMPLES)/amrnb/6.7k.amr
fate-amrnb-6k7: REF = $(SAMPLES)/amrnb/6.7k.pcm
FATE_AMRNB += fate-amrnb-7k4
fate-amrnb-7k4: CMD = pcm -i $(TARGET_SAMPLES)/amrnb/7.4k.amr
fate-amrnb-7k4: REF = $(SAMPLES)/amrnb/7.4k.pcm
FATE_AMRNB += fate-amrnb-7k95
fate-amrnb-7k95: CMD = pcm -i $(TARGET_SAMPLES)/amrnb/7.95k.amr
fate-amrnb-7k95: REF = $(SAMPLES)/amrnb/7.95k.pcm
FATE_AMRNB += fate-amrnb-10k2
fate-amrnb-10k2: CMD = pcm -i $(TARGET_SAMPLES)/amrnb/10.2k.amr
fate-amrnb-10k2: REF = $(SAMPLES)/amrnb/10.2k.pcm
FATE_AMRNB += fate-amrnb-12k2
fate-amrnb-12k2: CMD = pcm -i $(TARGET_SAMPLES)/amrnb/12.2k.amr
fate-amrnb-12k2: REF = $(SAMPLES)/amrnb/12.2k.pcm
$(FATE_AMRNB): CMP = stddev
FATE_SAMPLES_AVCONV-$(call DEMDEC, AMR, AMRNB) += $(FATE_AMRNB)
fate-amrnb: $(FATE_AMRNB)

47
externals/ffmpeg/tests/fate/amrwb.mak vendored
View File

@@ -1,47 +0,0 @@
FATE_AMRWB += fate-amrwb-6k60
fate-amrwb-6k60: CMD = pcm -i $(TARGET_SAMPLES)/amrwb/seed-6k60.awb
fate-amrwb-6k60: REF = $(SAMPLES)/amrwb/seed-6k60.pcm
FATE_AMRWB += fate-amrwb-8k85
fate-amrwb-8k85: CMD = pcm -i $(TARGET_SAMPLES)/amrwb/seed-8k85.awb
fate-amrwb-8k85: REF = $(SAMPLES)/amrwb/seed-8k85.pcm
FATE_AMRWB += fate-amrwb-12k65
fate-amrwb-12k65: CMD = pcm -i $(TARGET_SAMPLES)/amrwb/seed-12k65.awb
fate-amrwb-12k65: REF = $(SAMPLES)/amrwb/seed-12k65.pcm
FATE_AMRWB += fate-amrwb-14k25
fate-amrwb-14k25: CMD = pcm -i $(TARGET_SAMPLES)/amrwb/seed-14k25.awb
fate-amrwb-14k25: REF = $(SAMPLES)/amrwb/seed-14k25.pcm
fate-amrwb-14k25: FUZZ = 2.6
FATE_AMRWB += fate-amrwb-15k85
fate-amrwb-15k85: CMD = pcm -i $(TARGET_SAMPLES)/amrwb/seed-15k85.awb
fate-amrwb-15k85: REF = $(SAMPLES)/amrwb/seed-15k85.pcm
FATE_AMRWB += fate-amrwb-18k25
fate-amrwb-18k25: CMD = pcm -i $(TARGET_SAMPLES)/amrwb/seed-18k25.awb
fate-amrwb-18k25: REF = $(SAMPLES)/amrwb/seed-18k25.pcm
FATE_AMRWB += fate-amrwb-19k85
fate-amrwb-19k85: CMD = pcm -i $(TARGET_SAMPLES)/amrwb/seed-19k85.awb
fate-amrwb-19k85: REF = $(SAMPLES)/amrwb/seed-19k85.pcm
FATE_AMRWB += fate-amrwb-23k05
fate-amrwb-23k05: CMD = pcm -i $(TARGET_SAMPLES)/amrwb/seed-23k05.awb
fate-amrwb-23k05: REF = $(SAMPLES)/amrwb/seed-23k05.pcm
fate-amrwb-23k05: FUZZ = 2
FATE_AMRWB += fate-amrwb-23k85
fate-amrwb-23k85: CMD = pcm -i $(TARGET_SAMPLES)/amrwb/seed-23k85.awb
fate-amrwb-23k85: REF = $(SAMPLES)/amrwb/seed-23k85.pcm
fate-amrwb-23k85: FUZZ = 2
FATE_AMRWB += fate-amrwb-23k85-2
fate-amrwb-23k85-2: CMD = pcm -i $(TARGET_SAMPLES)/amrwb/deus-23k85.awb
fate-amrwb-23k85-2: REF = $(SAMPLES)/amrwb/deus-23k85.pcm
$(FATE_AMRWB): CMP = stddev
FATE_SAMPLES_AVCONV-$(call DEMDEC, AMR, AMRWB) += $(FATE_AMRWB)
fate-amrwb: $(FATE_AMRWB)

49
externals/ffmpeg/tests/fate/api.mak vendored
View File

@@ -1,49 +0,0 @@
FATE_API_LIBAVCODEC-$(call ENCDEC, FLAC, FLAC) += fate-api-flac
fate-api-flac: $(APITESTSDIR)/api-flac-test$(EXESUF)
fate-api-flac: CMD = run $(APITESTSDIR)/api-flac-test$(EXESUF)
fate-api-flac: CMP = null
FATE_API_SAMPLES_LIBAVFORMAT-$(call DEMDEC, FLV, FLV) += fate-api-band
fate-api-band: $(APITESTSDIR)/api-band-test$(EXESUF)
fate-api-band: CMD = run $(APITESTSDIR)/api-band-test$(EXESUF) $(TARGET_SAMPLES)/mpeg4/resize_down-up.h263
fate-api-band: CMP = null
FATE_API_SAMPLES_LIBAVFORMAT-$(call DEMDEC, H264, H264) += fate-api-h264
fate-api-h264: $(APITESTSDIR)/api-h264-test$(EXESUF)
fate-api-h264: CMD = run $(APITESTSDIR)/api-h264-test$(EXESUF) $(TARGET_SAMPLES)/h264-conformance/SVA_NL2_E.264
FATE_API_SAMPLES_LIBAVFORMAT-$(call DEMDEC, H264, H264) += fate-api-h264-slice
fate-api-h264-slice: $(APITESTSDIR)/api-h264-slice-test$(EXESUF)
fate-api-h264-slice: CMD = run $(APITESTSDIR)/api-h264-slice-test$(EXESUF) 2 $(TARGET_SAMPLES)/h264/crew_cif.nal
FATE_API_LIBAVFORMAT-$(call DEMDEC, FLV, FLV) += fate-api-seek
fate-api-seek: $(APITESTSDIR)/api-seek-test$(EXESUF) fate-lavf-flv
fate-api-seek: CMD = run $(APITESTSDIR)/api-seek-test$(EXESUF) $(TARGET_PATH)/tests/data/lavf/lavf.flv 0 720
fate-api-seek: CMP = null
FATE_API_SAMPLES_LIBAVFORMAT-$(call DEMDEC, IMAGE2, PNG) += fate-api-png-codec-param
fate-api-png-codec-param: $(APITESTSDIR)/api-codec-param-test$(EXESUF)
fate-api-png-codec-param: CMD = run $(APITESTSDIR)/api-codec-param-test$(EXESUF) $(TARGET_SAMPLES)/png1/lena-rgba.png
FATE_API_SAMPLES_LIBAVFORMAT-$(call DEMDEC, IMAGE2, MJPEG) += fate-api-mjpeg-codec-param
fate-api-mjpeg-codec-param: $(APITESTSDIR)/api-codec-param-test$(EXESUF)
fate-api-mjpeg-codec-param: CMD = run $(APITESTSDIR)/api-codec-param-test$(EXESUF) $(TARGET_SAMPLES)/exif/image_small.jpg
FATE_API-$(HAVE_THREADS) += fate-api-threadmessage
fate-api-threadmessage: $(APITESTSDIR)/api-threadmessage-test$(EXESUF)
fate-api-threadmessage: CMD = run $(APITESTSDIR)/api-threadmessage-test$(EXESUF) 3 10 30 50 2 20 40
fate-api-threadmessage: CMP = null
FATE_API_SAMPLES-$(CONFIG_AVFORMAT) += $(FATE_API_SAMPLES_LIBAVFORMAT-yes)
ifdef SAMPLES
FATE_API_SAMPLES += $(FATE_API_SAMPLES-yes)
endif
FATE_API-$(CONFIG_AVCODEC) += $(FATE_API_LIBAVCODEC-yes)
FATE_API-$(CONFIG_AVFORMAT) += $(FATE_API_LIBAVFORMAT-yes)
FATE_API = $(FATE_API-yes)
FATE-yes += $(FATE_API) $(FATE_API_SAMPLES)
fate-api: $(FATE_API) $(FATE_API_SAMPLES)

10
externals/ffmpeg/tests/fate/apng.mak vendored
View File

@@ -1,10 +0,0 @@
FATE_APNG += fate-apng-clock
fate-apng-clock: CMD = framecrc -i $(TARGET_SAMPLES)/apng/clock.png
FATE_APNG += fate-apng-osample
fate-apng-osample: CMD = framecrc -i $(TARGET_SAMPLES)/apng/o_sample.png
FATE_APNG-$(call DEMDEC, APNG, APNG) += $(FATE_APNG)
FATE_SAMPLES_FFMPEG += $(FATE_APNG-yes)
fate-apng: $(FATE_APNG-yes)

44
externals/ffmpeg/tests/fate/atrac.mak vendored
View File

@@ -1,44 +0,0 @@
FATE_ATRAC1 += fate-atrac1-1
fate-atrac1-1: CMD = pcm -i $(TARGET_SAMPLES)/atrac1/test_tones_small.aea
fate-atrac1-1: REF = $(SAMPLES)/atrac1/test_tones_small_fixed_delay.pcm
FATE_ATRAC1 += fate-atrac1-2
fate-atrac1-2: CMD = pcm -i $(TARGET_SAMPLES)/atrac1/chirp_tone_10-16000.aea
fate-atrac1-2: REF = $(SAMPLES)/atrac1/chirp_tone_10-16000.pcm
fate-atrac1-2: FUZZ = 61
FATE_ATRAC1-$(call DEMDEC, AEA, ATRAC1) += $(FATE_ATRAC1)
FATE_ATRAC3 += fate-atrac3-1
fate-atrac3-1: CMD = pcm -i $(TARGET_SAMPLES)/atrac3/mc_sich_at3_066_small.wav
fate-atrac3-1: REF = $(SAMPLES)/atrac3/mc_sich_at3_066_small.pcm
FATE_ATRAC3 += fate-atrac3-2
fate-atrac3-2: CMD = pcm -i $(TARGET_SAMPLES)/atrac3/mc_sich_at3_105_small.wav
fate-atrac3-2: REF = $(SAMPLES)/atrac3/mc_sich_at3_105_small.pcm
FATE_ATRAC3 += fate-atrac3-3
fate-atrac3-3: CMD = pcm -i $(TARGET_SAMPLES)/atrac3/mc_sich_at3_132_small.wav
fate-atrac3-3: REF = $(SAMPLES)/atrac3/mc_sich_at3_132_small.pcm
FATE_ATRAC3-$(call DEMDEC, WAV, ATRAC3) += $(FATE_ATRAC3)
FATE_ATRAC3P += fate-atrac3p-1
fate-atrac3p-1: CMD = pcm -i $(TARGET_SAMPLES)/atrac3p/at3p_sample1.oma
fate-atrac3p-1: REF = $(SAMPLES)/atrac3p/at3p_sample1.pcm
FATE_ATRAC3P += fate-atrac3p-2
fate-atrac3p-2: CMD = pcm -i $(TARGET_SAMPLES)/atrac3p/sonateno14op27-2-cut.aa3
fate-atrac3p-2: REF = $(SAMPLES)/atrac3p/sonateno14op27-2-cut.pcm
FATE_ATRAC3P-$(call DEMDEC, OMA, ATRAC3P) += $(FATE_ATRAC3P)
FATE_ATRAC_ALL = $(FATE_ATRAC1-yes) $(FATE_ATRAC3-yes) $(FATE_ATRAC3P-yes)
$(FATE_ATRAC_ALL): CMP = oneoff
FATE_SAMPLES_AVCONV += $(FATE_ATRAC_ALL)
fate-atrac: $(FATE_ATRAC_ALL)
fate-atrac3: $(FATE_ATRAC3-yes)
fate-atrac3p: $(FATE_ATRAC3P-yes)

77
externals/ffmpeg/tests/fate/audio.mak vendored
View File

@@ -1,77 +0,0 @@
FATE_BINKAUDIO-$(call DEMDEC, BINK, BINKAUDIO_DCT) += fate-binkaudio-dct
fate-binkaudio-dct: CMD = pcm -i $(TARGET_SAMPLES)/bink/binkaudio_dct.bik
fate-binkaudio-dct: REF = $(SAMPLES)/bink/binkaudio_dct.pcm
fate-binkaudio-dct: FUZZ = 2
FATE_BINKAUDIO-$(call DEMDEC, BINK, BINKAUDIO_RDFT) += fate-binkaudio-rdft
fate-binkaudio-rdft: CMD = pcm -i $(TARGET_SAMPLES)/bink/binkaudio_rdft.bik
fate-binkaudio-rdft: REF = $(SAMPLES)/bink/binkaudio_rdft.pcm
fate-binkaudio-rdft: FUZZ = 2
$(FATE_BINKAUDIO-yes): CMP = oneoff
FATE_SAMPLES_AUDIO += $(FATE_BINKAUDIO-yes)
fate-binkaudio: $(FATE_BINKAUDIO-yes)
FATE_SAMPLES_AUDIO-$(call DEMDEC, BMV, BMV_AUDIO) += fate-bmv-audio
fate-bmv-audio: CMD = framecrc -i $(TARGET_SAMPLES)/bmv/SURFING-partial.BMV -vn
FATE_SAMPLES_AUDIO-$(call DEMDEC, DSICIN, DSICINAUDIO) += fate-delphine-cin-audio
fate-delphine-cin-audio: CMD = framecrc -i $(TARGET_SAMPLES)/delphine-cin/LOGO-partial.CIN -vn
FATE_SAMPLES_AUDIO-$(call DEMDEC, S337M, DOLBY_E) += fate-dolby-e
fate-dolby-e: CMD = pcm -i $(TARGET_SAMPLES)/dolby_e/16-11
fate-dolby-e: CMP = oneoff
fate-dolby-e: REF = $(SAMPLES)/dolby_e/16-11.pcm
FATE_SAMPLES_AUDIO-$(call DEMDEC, DSS, DSS_SP) += fate-dss-lp fate-dss-sp
fate-dss-lp: CMD = framecrc -i $(TARGET_SAMPLES)/dss/lp.dss -frames 30
fate-dss-sp: CMD = framecrc -i $(TARGET_SAMPLES)/dss/sp.dss -frames 30
FATE_SAMPLES_AUDIO-$(call DEMDEC, DSF, DST) += fate-dsf-dst
fate-dsf-dst: CMD = pcm -i $(TARGET_SAMPLES)/dst/dst-64fs44-2ch.dff
fate-dsf-dst: CMP = oneoff
fate-dsf-dst: REF = $(SAMPLES)/dst/dst-64fs44-2ch.pcm
FATE_SAMPLES_AUDIO-$(call DEMDEC, AVI, IMC) += fate-imc
fate-imc: CMD = pcm -i $(TARGET_SAMPLES)/imc/imc.avi
fate-imc: CMP = oneoff
fate-imc: REF = $(SAMPLES)/imc/imc-201706.pcm
FATE_SAMPLES_AUDIO-$(call DEMDEC, FLV, NELLYMOSER) += fate-nellymoser
fate-nellymoser: CMD = pcm -i $(TARGET_SAMPLES)/nellymoser/nellymoser.flv
fate-nellymoser: CMP = oneoff
fate-nellymoser: REF = $(SAMPLES)/nellymoser/nellymoser.pcm
FATE_SAMPLES_AUDIO-$(call ENCMUX, NELLYMOSER, FLV) += fate-nellymoser-aref-encode
fate-nellymoser-aref-encode: $(AREF) ./tests/data/asynth-16000-1.wav
fate-nellymoser-aref-encode: CMD = enc_dec_pcm flv wav s16le $(REF) -c:a nellymoser
fate-nellymoser-aref-encode: CMP = stddev
fate-nellymoser-aref-encode: REF = ./tests/data/asynth-16000-1.wav
fate-nellymoser-aref-encode: CMP_SHIFT = -256
fate-nellymoser-aref-encode: CMP_TARGET = 3863
fate-nellymoser-aref-encode: SIZE_TOLERANCE = 268
FATE_SAMPLES_AUDIO-$(call DEMDEC, AVI, ON2AVC) += fate-on2avc
fate-on2avc: CMD = framecrc -i $(TARGET_SAMPLES)/vp7/potter-40.vp7 -frames 30 -vn
FATE_SAMPLES_AUDIO-$(call DEMDEC, PAF, PAF_AUDIO) += fate-paf-audio
fate-paf-audio: CMD = framecrc -i $(TARGET_SAMPLES)/paf/hod1-partial.paf -vn
FATE_SAMPLES_AUDIO-$(call DEMDEC, VMD, VMDAUDIO) += fate-sierra-vmd-audio
fate-sierra-vmd-audio: CMD = framecrc -i $(TARGET_SAMPLES)/vmd/12.vmd -vn
FATE_SAMPLES_AUDIO-$(call DEMDEC, SMACKER, SMACKAUD) += fate-smacker-audio
fate-smacker-audio: CMD = framecrc -i $(TARGET_SAMPLES)/smacker/wetlogo.smk -vn
FATE_SAMPLES_AUDIO-$(call DEMDEC, WSVQA, WS_SND1) += fate-ws_snd
fate-ws_snd: CMD = md5 -i $(TARGET_SAMPLES)/vqa/ws_snd.vqa -f s16le
fate-flcl1905: CMD = run ffprobe$(PROGSSUF)$(EXESUF) -show_frames -show_packets -print_format compact $(TARGET_SAMPLES)/wav/FLCL_Ending_My-short.wav
FATE_SAMPLES_AUDIO += $(FATE_SAMPLES_AUDIO-yes)
FATE_SAMPLES_FFPROBE += fate-flcl1905
FATE_SAMPLES_FFMPEG += $(FATE_SAMPLES_AUDIO)
fate-audio: $(FATE_SAMPLES_AUDIO) fate-flcl1905

43
externals/ffmpeg/tests/fate/bmp.mak vendored
View File

@@ -1,43 +0,0 @@
FATE_BMP += fate-bmp-1bit
fate-bmp-1bit: CMD = framecrc -i $(TARGET_SAMPLES)/bmp/test1.bmp -pix_fmt rgb24
FATE_BMP += fate-bmp-4bit
fate-bmp-4bit: CMD = framecrc -i $(TARGET_SAMPLES)/bmp/test4.bmp -pix_fmt rgb24
FATE_BMP += fate-bmp-4bit-os2
fate-bmp-4bit-os2: CMD = framecrc -i $(TARGET_SAMPLES)/bmp/test4os2v2.bmp -pix_fmt rgb24
FATE_BMP += fate-bmp-8bit
fate-bmp-8bit: CMD = framecrc -i $(TARGET_SAMPLES)/bmp/test8.bmp -pix_fmt rgb24
FATE_BMP += fate-bmp-8bit-os2
fate-bmp-8bit-os2: CMD = framecrc -i $(TARGET_SAMPLES)/bmp/test8os2.bmp -pix_fmt rgb24
FATE_BMP += fate-bmp-15bit
fate-bmp-15bit: CMD = framecrc -i $(TARGET_SAMPLES)/bmp/test16.bmp -pix_fmt rgb555le
FATE_BMP += fate-bmp-15bit-mask
fate-bmp-15bit-mask: CMD = framecrc -i $(TARGET_SAMPLES)/bmp/test16bf555.bmp -pix_fmt rgb555le
FATE_BMP += fate-bmp-16bit-mask
fate-bmp-16bit-mask: CMD = framecrc -i $(TARGET_SAMPLES)/bmp/test16bf565.bmp -pix_fmt rgb565le
FATE_BMP += fate-bmp-24bit
fate-bmp-24bit: CMD = framecrc -i $(TARGET_SAMPLES)/bmp/test24.bmp
FATE_BMP += fate-bmp-32bit
fate-bmp-32bit: CMD = framecrc -i $(TARGET_SAMPLES)/bmp/test32.bmp -pix_fmt bgr24
FATE_BMP += fate-bmp-32bit-mask
fate-bmp-32bit-mask: CMD = framecrc -i $(TARGET_SAMPLES)/bmp/test32bf.bmp -pix_fmt bgr24
FATE_BMP += fate-bmp-rle4
fate-bmp-rle4: CMD = framecrc -i $(TARGET_SAMPLES)/bmp/testcompress4.bmp -pix_fmt rgb24
FATE_BMP += fate-bmp-rle8
fate-bmp-rle8: CMD = framecrc -i $(TARGET_SAMPLES)/bmp/testcompress8.bmp -pix_fmt rgb24
FATE_BMP-$(call DEMDEC, IMAGE2, BMP) += $(FATE_BMP)
FATE_SAMPLES_AVCONV += $(FATE_BMP-yes)
fate-bmp: $(FATE_BMP-yes)

17
externals/ffmpeg/tests/fate/build.mak vendored
View File

@@ -1,17 +0,0 @@
FATE_BUILD += fate-build-alltools
fate-build-alltools: alltools
FATE_BUILD += fate-build-checkheaders
fate-build-checkheaders: checkheaders
FATE_BUILD += fate-build-examples
fate-build-examples: examples
FATE_BUILD += fate-build-testprogs
fate-build-testprogs: testprogs
$(FATE_BUILD): CMD = null
$(FATE_BUILD): CMP = null
# FATE += $(FATE_BUILD)
fate-build: $(FATE_BUILD)

34
externals/ffmpeg/tests/fate/canopus.mak vendored
View File

@@ -1,34 +0,0 @@
#lossless
FATE_CANOPUS_CLLC += fate-canopus-cllc-argb
fate-canopus-cllc-argb: CMD = framecrc -i $(TARGET_SAMPLES)/cllc/sample-cllc-argb.avi
FATE_CANOPUS_CLLC += fate-canopus-cllc-rgb
fate-canopus-cllc-rgb: CMD = framecrc -i $(TARGET_SAMPLES)/cllc/sample-cllc-rgb.avi
FATE_CANOPUS_CLLC += fate-canopus-cllc-yuy2-noblock
fate-canopus-cllc-yuy2-noblock: CMD = framecrc -i $(TARGET_SAMPLES)/cllc/sample-cllc-yuy2-noblock.avi
FATE_SAMPLES_FFMPEG-$(call DEMDEC, AVI, CLLC) += $(FATE_CANOPUS_CLLC)
fate-canopus-cllc: $(FATE_CANOPUS_CLLC)
#lossy
FATE_CANOPUS_HQ_HQA += fate-canopus-hq_hqa-hq
fate-canopus-hq_hqa-hq: CMD = framecrc -i $(TARGET_SAMPLES)/canopus/hq.avi
FATE_CANOPUS_HQ_HQA += fate-canopus-hq_hqa-hqa
fate-canopus-hq_hqa-hqa: CMD = framecrc -i $(TARGET_SAMPLES)/canopus/hqa.avi
FATE_CANOPUS_HQ_HQA += fate-canopus-hq_hqa-inter
fate-canopus-hq_hqa-inter: CMD = framecrc -i $(TARGET_SAMPLES)/canopus/hq25i.avi
FATE_SAMPLES_FFMPEG-$(call DEMDEC, AVI, HQ_HQA) += $(FATE_CANOPUS_HQ_HQA)
fate-canopus-hq_hqa: $(FATE_CANOPUS_HQ_HQA)
FATE_CANOPUS_HQX += fate-canopus-hqx422
fate-canopus-hqx422: CMD = framecrc -i $(TARGET_SAMPLES)/canopus/hqx422.avi -pix_fmt yuv422p16be -an
FATE_CANOPUS_HQX += fate-canopus-hqx422a
fate-canopus-hqx422a: CMD = framecrc -i $(TARGET_SAMPLES)/canopus/hqx422a.avi -pix_fmt yuv422p16be -an
FATE_SAMPLES_FFMPEG-$(call DEMDEC, AVI, HQX) += $(FATE_CANOPUS_HQX)
fate-canopus-hqx: $(FATE_CANOPUS_HQX)

137
externals/ffmpeg/tests/fate/cbs.mak vendored
View File

@@ -1,137 +0,0 @@
# Read/write tests: this uses the codec metadata filter - with no
# arguments, it decomposes the stream fully and then recomposes it
# without making any changes.
fate-cbs: fate-cbs-av1 fate-cbs-h264 fate-cbs-hevc fate-cbs-mpeg2 fate-cbs-vp9
FATE_CBS_DEPS = $(call ALLYES, $(1)_DEMUXER $(2)_PARSER $(3)_METADATA_BSF $(4)_DECODER $(5)_MUXER)
define FATE_CBS_TEST
# (codec, test_name, sample_file, output_format)
FATE_CBS_$(1) += fate-cbs-$(1)-$(2)
fate-cbs-$(1)-$(2): CMD = md5 -i $(TARGET_SAMPLES)/$(3) -c:v copy -y -bsf:v $(1)_metadata -f $(4)
endef
# AV1 read/write
FATE_CBS_AV1_CONFORMANCE_SAMPLES = \
av1-1-b8-02-allintra.ivf \
av1-1-b8-03-sizedown.ivf \
av1-1-b8-03-sizeup.ivf \
av1-1-b8-04-cdfupdate.ivf \
av1-1-b8-05-mv.ivf \
av1-1-b8-06-mfmv.ivf \
av1-1-b8-22-svc-L1T2.ivf \
av1-1-b8-22-svc-L2T1.ivf \
av1-1-b8-22-svc-L2T2.ivf \
av1-1-b8-23-film_grain-50.ivf \
av1-1-b10-23-film_grain-50.ivf
FATE_CBS_AV1_SAMPLES = \
decode_model.ivf \
frames_refs_short_signaling.ivf \
non_uniform_tiling.ivf \
seq_hdr_op_param_info.ivf \
switch_frame.ivf
$(foreach N,$(FATE_CBS_AV1_CONFORMANCE_SAMPLES),$(eval $(call FATE_CBS_TEST,av1,$(basename $(N)),av1-test-vectors/$(N),rawvideo)))
$(foreach N,$(FATE_CBS_AV1_SAMPLES),$(eval $(call FATE_CBS_TEST,av1,$(basename $(N)),av1/$(N),rawvideo)))
FATE_CBS_AV1-$(call ALLYES, IVF_DEMUXER AV1_PARSER AV1_METADATA_BSF RAWVIDEO_MUXER) = $(FATE_CBS_av1)
FATE_SAMPLES_AVCONV += $(FATE_CBS_AV1-yes)
fate-cbs-av1: $(FATE_CBS_AV1-yes)
# H.264 read/write
FATE_CBS_H264_CONFORMANCE_SAMPLES = \
SVA_Base_B.264 \
BASQP1_Sony_C.jsv \
FM1_BT_B.h264 \
CVFC1_Sony_C.jsv \
AUD_MW_E.264 \
CVBS3_Sony_C.jsv \
MR1_BT_A.h264 \
CVWP1_TOSHIBA_E.264 \
CVNLFI1_Sony_C.jsv \
Sharp_MP_PAFF_1r2.jvt \
CVMANL1_TOSHIBA_B.264 \
sp1_bt_a.h264 \
CVSE2_Sony_B.jsv \
CABACI3_Sony_B.jsv
FATE_CBS_H264_SAMPLES = \
sei-1.h264
$(foreach N,$(FATE_CBS_H264_CONFORMANCE_SAMPLES),$(eval $(call FATE_CBS_TEST,h264,$(basename $(N)),h264-conformance/$(N),h264)))
$(foreach N,$(FATE_CBS_H264_SAMPLES),$(eval $(call FATE_CBS_TEST,h264,$(basename $(N)),h264/$(N),h264)))
FATE_CBS_H264-$(call FATE_CBS_DEPS, H264, H264, H264, H264, H264) = $(FATE_CBS_h264)
FATE_SAMPLES_AVCONV += $(FATE_CBS_H264-yes)
fate-cbs-h264: $(FATE_CBS_H264-yes)
# H.265 read/write
FATE_CBS_HEVC_SAMPLES = \
STRUCT_A_Samsung_5.bit \
WP_A_Toshiba_3.bit \
SLIST_A_Sony_4.bit \
SLIST_D_Sony_9.bit \
CAINIT_E_SHARP_3.bit \
CAINIT_H_SHARP_3.bit \
TILES_B_Cisco_1.bit \
WPP_A_ericsson_MAIN_2.bit \
WPP_F_ericsson_MAIN_2.bit \
ipcm_E_NEC_2.bit \
NUT_A_ericsson_5.bit \
PICSIZE_A_Bossen_1.bit \
PICSIZE_B_Bossen_1.bit \
RPS_A_docomo_4.bit \
RPS_E_qualcomm_5.bit \
LTRPSPS_A_Qualcomm_1.bit \
RPLM_A_qualcomm_4.bit \
CONFWIN_A_Sony_1.bit \
HRD_A_Fujitsu_2.bit \
SLPPLP_A_VIDYO_2.bit
$(foreach N,$(FATE_CBS_HEVC_SAMPLES),$(eval $(call FATE_CBS_TEST,hevc,$(basename $(N)),hevc-conformance/$(N),hevc)))
FATE_CBS_HEVC-$(call FATE_CBS_DEPS, HEVC, HEVC, HEVC, HEVC, HEVC) = $(FATE_CBS_hevc)
FATE_SAMPLES_AVCONV += $(FATE_CBS_HEVC-yes)
fate-cbs-hevc: $(FATE_CBS_HEVC-yes)
# MPEG-2 read/write
FATE_CBS_MPEG2_SAMPLES = \
hhi_burst_422_short.bits \
sony-ct3.bs \
tcela-6.bits
$(foreach N,$(FATE_CBS_MPEG2_SAMPLES),$(eval $(call FATE_CBS_TEST,mpeg2,$(basename $(N)),mpeg2/$(N),mpeg2video)))
FATE_CBS_MPEG2-$(call FATE_CBS_DEPS, MPEGVIDEO, MPEGVIDEO, MPEG2, MPEG2VIDEO, MPEG2VIDEO) = $(FATE_CBS_mpeg2)
FATE_SAMPLES_AVCONV += $(FATE_CBS_MPEG2-yes)
fate-cbs-mpeg2: $(FATE_CBS_MPEG2-yes)
# VP9 read/write
FATE_CBS_VP9_SAMPLES = \
vp90-2-03-deltaq.webm \
vp90-2-05-resize.ivf \
vp90-2-06-bilinear.webm \
vp90-2-09-lf_deltas.webm \
vp90-2-10-show-existing-frame.webm \
vp90-2-10-show-existing-frame2.webm \
vp90-2-segmentation-aq-akiyo.webm \
vp90-2-segmentation-sf-akiyo.webm \
vp90-2-tiling-pedestrian.webm \
vp91-2-04-yuv440.webm \
vp91-2-04-yuv444.webm \
vp92-2-20-10bit-yuv420.webm \
vp93-2-20-10bit-yuv422.webm \
vp93-2-20-12bit-yuv444.webm
$(foreach N,$(FATE_CBS_VP9_SAMPLES),$(eval $(call FATE_CBS_TEST,vp9,$(basename $(N)),vp9-test-vectors/$(N),ivf)))
FATE_CBS_VP9-$(call FATE_CBS_DEPS, IVF, VP9, VP9, VP9, IVF) = $(FATE_CBS_vp9)
FATE_SAMPLES_AVCONV += $(FATE_CBS_VP9-yes)
fate-cbs-vp9: $(FATE_CBS_VP9-yes)

19
externals/ffmpeg/tests/fate/cdxl.mak vendored
View File

@@ -1,19 +0,0 @@
FATE_CDXL += fate-cdxl-bitline-ham6
fate-cdxl-bitline-ham6: CMD = framecrc -i $(TARGET_SAMPLES)/cdxl/bitline.cdxl -frames:v 10
FATE_CDXL += fate-cdxl-ham6
fate-cdxl-ham6: CMD = framecrc -i $(TARGET_SAMPLES)/cdxl/cat.cdxl -an -frames:v 16
FATE_CDXL += fate-cdxl-ham8
fate-cdxl-ham8: CMD = framecrc -i $(TARGET_SAMPLES)/cdxl/mirage.cdxl -an -frames:v 1
FATE_CDXL += fate-cdxl-pal8
fate-cdxl-pal8: CMD = framecrc -i $(TARGET_SAMPLES)/cdxl/maku.cdxl -pix_fmt rgb24 -frames:v 11
FATE_CDXL += fate-cdxl-pal8-small
fate-cdxl-pal8-small: CMD = framecrc -i $(TARGET_SAMPLES)/cdxl/fruit.cdxl -an -pix_fmt rgb24 -frames:v 46
FATE_CDXL-$(call DEMDEC, CDXL, CDXL) += $(FATE_CDXL)
FATE_SAMPLES_AVCONV += $(FATE_CDXL-yes)
fate-cdxl: $(FATE_CDXL-yes)

45
externals/ffmpeg/tests/fate/checkasm.mak vendored
View File

@@ -1,45 +0,0 @@
FATE_CHECKASM = fate-checkasm-aacpsdsp \
fate-checkasm-af_afir \
fate-checkasm-alacdsp \
fate-checkasm-audiodsp \
fate-checkasm-blockdsp \
fate-checkasm-bswapdsp \
fate-checkasm-exrdsp \
fate-checkasm-fixed_dsp \
fate-checkasm-flacdsp \
fate-checkasm-float_dsp \
fate-checkasm-fmtconvert \
fate-checkasm-g722dsp \
fate-checkasm-h264dsp \
fate-checkasm-h264pred \
fate-checkasm-h264qpel \
fate-checkasm-hevc_add_res \
fate-checkasm-hevc_idct \
fate-checkasm-hevc_sao \
fate-checkasm-jpeg2000dsp \
fate-checkasm-llviddsp \
fate-checkasm-llviddspenc \
fate-checkasm-opusdsp \
fate-checkasm-pixblockdsp \
fate-checkasm-sbrdsp \
fate-checkasm-synth_filter \
fate-checkasm-sw_rgb \
fate-checkasm-sw_scale \
fate-checkasm-v210dec \
fate-checkasm-v210enc \
fate-checkasm-vf_blend \
fate-checkasm-vf_colorspace \
fate-checkasm-vf_eq \
fate-checkasm-vf_gblur \
fate-checkasm-vf_hflip \
fate-checkasm-vf_threshold \
fate-checkasm-videodsp \
fate-checkasm-vp8dsp \
fate-checkasm-vp9dsp \
$(FATE_CHECKASM): tests/checkasm/checkasm$(EXESUF)
$(FATE_CHECKASM): CMD = run tests/checkasm/checkasm$(EXESUF) --test=$(@:fate-checkasm-%=%)
$(FATE_CHECKASM): CMP = null
FATE += $(FATE_CHECKASM)
fate-checkasm: $(FATE_CHECKASM)

21
externals/ffmpeg/tests/fate/concatdec.mak vendored
View File

@@ -1,21 +0,0 @@
FATE_CONCAT_DEMUXER_SIMPLE1_LAVF-$(call ENCDEC2, MPEG2VIDEO, PCM_S16LE, MXF) += mxf
FATE_CONCAT_DEMUXER_SIMPLE1_LAVF-$(call ENCDEC2, MPEG2VIDEO, PCM_S16LE, MXF) += mxf_d10
FATE_CONCAT_DEMUXER_SIMPLE2_LAVF-$(call ENCDEC2, MPEG2VIDEO, MP2, MPEGTS) += ts
FATE_CONCAT_DEMUXER_EXTENDED_LAVF-$(call ENCDEC2, MPEG2VIDEO, PCM_S16LE, MXF) += mxf
FATE_CONCAT_DEMUXER_EXTENDED_LAVF-$(call ENCDEC2, MPEG2VIDEO, PCM_S16LE, MXF) += mxf_d10
$(foreach D,$(FATE_CONCAT_DEMUXER_SIMPLE1_LAVF-yes),$(eval fate-concat-demuxer-simple1-lavf-$(D): ffprobe$(PROGSSUF)$(EXESUF) fate-lavf-$(D)))
$(foreach D,$(FATE_CONCAT_DEMUXER_SIMPLE1_LAVF-yes),$(eval fate-concat-demuxer-simple1-lavf-$(D): CMD = concat $(SRC_PATH)/tests/simple1.ffconcat ../lavf/lavf.$(D)))
FATE_CONCAT_DEMUXER-$(CONFIG_CONCAT_DEMUXER) += $(FATE_CONCAT_DEMUXER_SIMPLE1_LAVF-yes:%=fate-concat-demuxer-simple1-lavf-%)
$(foreach D,$(FATE_CONCAT_DEMUXER_SIMPLE2_LAVF-yes),$(eval fate-concat-demuxer-simple2-lavf-$(D): ffprobe$(PROGSSUF)$(EXESUF) fate-lavf-$(D)))
$(foreach D,$(FATE_CONCAT_DEMUXER_SIMPLE2_LAVF-yes),$(eval fate-concat-demuxer-simple2-lavf-$(D): CMD = concat $(SRC_PATH)/tests/simple2.ffconcat ../lavf/lavf.$(D)))
FATE_CONCAT_DEMUXER-$(CONFIG_CONCAT_DEMUXER) += $(FATE_CONCAT_DEMUXER_SIMPLE2_LAVF-yes:%=fate-concat-demuxer-simple2-lavf-%)
$(foreach D,$(FATE_CONCAT_DEMUXER_EXTENDED_LAVF-yes),$(eval fate-concat-demuxer-extended-lavf-$(D): ffprobe$(PROGSSUF)$(EXESUF) fate-lavf-$(D)))
$(foreach D,$(FATE_CONCAT_DEMUXER_EXTENDED_LAVF-yes),$(eval fate-concat-demuxer-extended-lavf-$(D): CMD = concat $(SRC_PATH)/tests/extended.ffconcat ../lavf/lavf.$(D) md5))
FATE_CONCAT_DEMUXER-$(CONFIG_CONCAT_DEMUXER) += $(FATE_CONCAT_DEMUXER_EXTENDED_LAVF-yes:%=fate-concat-demuxer-extended-lavf-%)
FATE-$(CONFIG_FFPROBE) += $(FATE_CONCAT_DEMUXER-yes)

38
externals/ffmpeg/tests/fate/cover-art.mak vendored
View File

@@ -1,38 +0,0 @@
FATE_COVER_ART-$(CONFIG_APE_DEMUXER) += fate-cover-art-ape
fate-cover-art-ape: CMD = md5 -i $(TARGET_SAMPLES)/cover_art/luckynight_cover.ape -an -c:v copy -f rawvideo
fate-cover-art-ape: REF = 45333c983c45af54449dff10af144317
FATE_COVER_ART-$(CONFIG_FLAC_DEMUXER) += fate-cover-art-flac
fate-cover-art-flac: CMD = md5 -i $(TARGET_SAMPLES)/cover_art/cover_art.flac -an -c:v copy -f rawvideo
fate-cover-art-flac: REF = 0de1fc6200596fa32b8f7300a14c0261
FATE_COVER_ART-$(CONFIG_MOV_DEMUXER) += fate-cover-art-m4a
fate-cover-art-m4a: CMD = md5 -i $(TARGET_SAMPLES)/cover_art/Owner-iTunes_9.0.3.15.m4a -an -c:v copy -f rawvideo
fate-cover-art-m4a: REF = 08ba70a3b594ff6345a93965e96a9d3e
FATE_COVER_ART-$(CONFIG_OGG_DEMUXER) += fate-cover-art-ogg
fate-cover-art-ogg: CMD = md5 -i $(TARGET_SAMPLES)/cover_art/ogg_vorbiscomment_cover.opus -map 0:v -c:v copy -f rawvideo
fate-cover-art-ogg: REF = 7f117e073620eabb4ed02680cf70af41
FATE_COVER_ART-$(CONFIG_ASF_DEMUXER) += fate-cover-art-wma
fate-cover-art-wma: CMD = md5 -i $(TARGET_SAMPLES)/cover_art/Californication_cover.wma -an -c:v copy -f rawvideo
fate-cover-art-wma: REF = 0808bd0e1b61542a16e1906812dd924b
FATE_COVER_ART-$(CONFIG_ASF_DEMUXER) += fate-cover-art-wma-id3
fate-cover-art-wma-id3: CMD = md5 -i $(TARGET_SAMPLES)/cover_art/wma_with_ID3_APIC_trimmed.wma -an -c:v copy -f rawvideo
fate-cover-art-wma-id3: REF = e6a8dd03687d5178bc13fc7d3316696e
FATE_COVER_ART-$(CONFIG_ASF_DEMUXER) += fate-cover-art-wma-metadatalib
fate-cover-art-wma-metadatalib: CMD = md5 -i $(TARGET_SAMPLES)/cover_art/wma_with_metadata_library_object_tag_trimmed.wma -map 0:v -c:v copy -f rawvideo
fate-cover-art-wma-metadatalib: REF = 32e8bd4fad546f63d881a0256f083aea
FATE_COVER_ART-$(CONFIG_WV_DEMUXER) += fate-cover-art-wv
fate-cover-art-wv: CMD = md5 -i $(TARGET_SAMPLES)/cover_art/luckynight_cover.wv -an -c:v copy -f rawvideo
fate-cover-art-wv: REF = 45333c983c45af54449dff10af144317
FCA_TEMP-$(call ALLYES, RAWVIDEO_MUXER FILE_PROTOCOL) = $(FATE_COVER_ART-yes)
FATE_COVER_ART = $(FCA_TEMP-yes)
$(FATE_COVER_ART): CMP = oneline
FATE_SAMPLES_AVCONV += $(FATE_COVER_ART)
fate-cover-art: $(FATE_COVER_ART)

84
externals/ffmpeg/tests/fate/dca.mak vendored
View File

@@ -1,84 +0,0 @@
# dcadec test samples
DCADEC_SUITE_LOSSLESS_16 = xll_51_16_192_768_0 \
xll_51_16_192_768_1 \
DCADEC_SUITE_LOSSLESS_24 = xll_51_24_48_768 \
xll_51_24_48_none \
xll_71_24_48_768_0 \
xll_71_24_48_768_1 \
xll_71_24_96_768 \
xll_x96_51_24_96_1509 \
xll_xch_61_24_48_768 \
DCADEC_SUITE_LOSSY = core_51_24_48_768_0 \
core_51_24_48_768_1 \
x96_51_24_96_1509 \
x96_xch_61_24_96_3840 \
x96_xxch_71_24_96_3840 \
xbr_51_24_48_3840 \
xbr_xch_61_24_48_3840 \
xbr_xxch_71_24_48_3840 \
xch_61_24_48_768 \
xxch_71_24_48_2046 \
define FATE_DCADEC_LOSSLESS_SUITE
FATE_DCADEC_LOSSLESS += fate-dca-$(1) fate-dca-$(1)-dmix_2 fate-dca-$(1)-dmix_6
fate-dca-$(1): CMD = framemd5 -i $(TARGET_SAMPLES)/dts/dcadec-suite/$(1).dtshd -c:a pcm_$(2)
fate-dca-$(1)-dmix_2: CMD = framemd5 -request_channel_layout 0x3 -i $(TARGET_SAMPLES)/dts/dcadec-suite/$(1).dtshd -c:a pcm_$(2)
fate-dca-$(1)-dmix_6: CMD = framemd5 -request_channel_layout 0x60f -i $(TARGET_SAMPLES)/dts/dcadec-suite/$(1).dtshd -c:a pcm_$(2)
endef
define FATE_DCADEC_LOSSY_SUITE
FATE_DCADEC_LOSSY += fate-dca-$(1)
fate-dca-$(1): CMD = ffmpeg -i $(TARGET_SAMPLES)/dts/dcadec-suite/$(1).dtshd -f f32le -
fate-dca-$(1): REF = $(SAMPLES)/dts/dcadec-suite/$(1).f32
endef
$(foreach N,$(DCADEC_SUITE_LOSSLESS_16),$(eval $(call FATE_DCADEC_LOSSLESS_SUITE,$(N),s16le)))
$(foreach N,$(DCADEC_SUITE_LOSSLESS_24),$(eval $(call FATE_DCADEC_LOSSLESS_SUITE,$(N),s24le)))
$(foreach N,$(DCADEC_SUITE_LOSSY),$(eval $(call FATE_DCADEC_LOSSY_SUITE,$(N))))
# lossy downmix tests
FATE_DCADEC_LOSSY += fate-dca-core_51_24_48_768_1-dmix_2
fate-dca-core_51_24_48_768_1-dmix_2: CMD = ffmpeg -request_channel_layout 0x3 -i $(TARGET_SAMPLES)/dts/dcadec-suite/core_51_24_48_768_1.dtshd -f f32le -
fate-dca-core_51_24_48_768_1-dmix_2: REF = $(SAMPLES)/dts/dcadec-suite/core_51_24_48_768_1-dmix_2.f32
FATE_DCADEC_LOSSY += fate-dca-x96_xxch_71_24_96_3840-dmix_2
fate-dca-x96_xxch_71_24_96_3840-dmix_2: CMD = ffmpeg -request_channel_layout 0x3 -i $(TARGET_SAMPLES)/dts/dcadec-suite/x96_xxch_71_24_96_3840.dtshd -f f32le -
# intentionally uses the dmix_6 reference because the sample does not contain stereo downmix coefficients
fate-dca-x96_xxch_71_24_96_3840-dmix_2: REF = $(SAMPLES)/dts/dcadec-suite/x96_xxch_71_24_96_3840-dmix_6.f32
FATE_DCADEC_LOSSY += fate-dca-x96_xxch_71_24_96_3840-dmix_6
fate-dca-x96_xxch_71_24_96_3840-dmix_6: CMD = ffmpeg -request_channel_layout 0x60f -i $(TARGET_SAMPLES)/dts/dcadec-suite/x96_xxch_71_24_96_3840.dtshd -f f32le -
fate-dca-x96_xxch_71_24_96_3840-dmix_6: REF = $(SAMPLES)/dts/dcadec-suite/x96_xxch_71_24_96_3840-dmix_6.f32
FATE_DCADEC_LOSSY += fate-dca-xch_61_24_48_768-dmix_6
fate-dca-xch_61_24_48_768-dmix_6: CMD = ffmpeg -request_channel_layout 0x60f -i $(TARGET_SAMPLES)/dts/dcadec-suite/xch_61_24_48_768.dtshd -f f32le -
fate-dca-xch_61_24_48_768-dmix_6: REF = $(SAMPLES)/dts/dcadec-suite/xch_61_24_48_768-dmix_6.f32
$(FATE_DCADEC_LOSSY): CMP = oneoff
$(FATE_DCADEC_LOSSY): CMP_UNIT = f32
$(FATE_DCADEC_LOSSY): FUZZ = 9
FATE_DCA-$(call DEMDEC, DTSHD, DCA) += $(FATE_DCADEC_LOSSLESS) $(FATE_DCADEC_LOSSY)
FATE_DCA-$(call DEMDEC, MPEGTS, DCA) += fate-dca-core
fate-dca-core: CMD = pcm -i $(TARGET_SAMPLES)/dts/dts.ts
fate-dca-core: CMP = oneoff
fate-dca-core: REF = $(SAMPLES)/dts/dts.pcm
FATE_DCA-$(call DEMDEC, DTS, DCA) += fate-dca-xll
fate-dca-xll: CMD = md5 -i $(TARGET_SAMPLES)/dts/master_audio_7.1_24bit.dts -f s24le
FATE_DCA-$(call DEMDEC, DTS, DCA) += fate-dts_es
fate-dts_es: CMD = pcm -i $(TARGET_SAMPLES)/dts/dts_es.dts
fate-dts_es: CMP = oneoff
fate-dts_es: REF = $(SAMPLES)/dts/dts_es_2.pcm
FATE_DCA-$(call ALLYES, DTS_DEMUXER DTS_MUXER DCA_CORE_BSF) += fate-dca-core-bsf
fate-dca-core-bsf: CMD = md5pipe -i $(TARGET_SAMPLES)/dts/master_audio_7.1_24bit.dts -c:a copy -bsf:a dca_core -fflags +bitexact -f dts
fate-dca-core-bsf: CMP = oneline
fate-dca-core-bsf: REF = ca22b00d8c641cd168e2f7ca8d2f340e
FATE_SAMPLES_AUDIO += $(FATE_DCA-yes)
fate-dca: $(FATE_DCA-yes)

159
externals/ffmpeg/tests/fate/demux.mak vendored
View File

@@ -1,159 +0,0 @@
FATE_SAMPLES_DEMUX-$(call DEMDEC, AVI, FRAPS) += fate-avio-direct
fate-avio-direct: CMD = framecrc -avioflags direct -i $(TARGET_SAMPLES)/fraps/fraps-v5-bouncing-balls-partial.avi -avioflags direct
FATE_SAMPLES_DEMUX-$(call DEMDEC, AAC, AAC) += fate-adts-demux fate-adts-id3v1-demux fate-adts-id3v2-demux fate-adts-id3v2-two-tags-demux
fate-adts-demux: CMD = crc -i $(TARGET_SAMPLES)/aac/ct_faac-adts.aac -c:a copy
fate-adts-id3v1-demux: CMD = framecrc -f aac -i $(TARGET_SAMPLES)/aac/id3v1.aac -c:a copy
fate-adts-id3v2-demux: CMD = framecrc -f aac -i $(TARGET_SAMPLES)/aac/id3v2.aac -c:a copy
fate-adts-id3v2-two-tags-demux: CMD = framecrc -i $(TARGET_SAMPLES)/aac/id3v2_two_tags.aac -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_AEA_DEMUXER) += fate-aea-demux
fate-aea-demux: CMD = crc -i $(TARGET_SAMPLES)/aea/chirp.aea -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_AV1_DEMUXER) += fate-av1-annexb-demux
fate-av1-annexb-demux: CMD = framecrc -i $(TARGET_SAMPLES)/av1/annexb.obu -c:v copy
FATE_SAMPLES_DEMUX-$(CONFIG_AST_DEMUXER) += fate-ast
fate-ast: CMD = crc -i $(TARGET_SAMPLES)/ast/demo11_02_partial.ast -c copy
FATE_SAMPLES_DEMUX-$(CONFIG_BINK_DEMUXER) += fate-bink-demux
fate-bink-demux: CMD = crc -i $(TARGET_SAMPLES)/bink/Snd0a7d9b58.dee -vn -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_BFSTM_DEMUXER) += fate-bfstm fate-bcstm
fate-bfstm: CMD = crc -i $(TARGET_SAMPLES)/bfstm/spl-forest-day.bfstm -c:a copy
fate-bcstm: CMD = crc -i $(TARGET_SAMPLES)/bfstm/loz-mm-mikau.bcstm -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_BRSTM_DEMUXER) += fate-brstm
fate-brstm: CMD = crc -i $(TARGET_SAMPLES)/brstm/lozswd_partial.brstm -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_CAF_DEMUXER) += fate-caf
fate-caf: CMD = crc -i $(TARGET_SAMPLES)/caf/caf-pcm16.caf -c copy
FATE_SAMPLES_DEMUX-$(CONFIG_CDXL_DEMUXER) += fate-cdxl-demux
fate-cdxl-demux: CMD = framecrc -i $(TARGET_SAMPLES)/cdxl/mirage.cdxl -c:v copy -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_CINE_DEMUXER) += fate-cine-demux
fate-cine-demux: CMD = crc -i $(TARGET_SAMPLES)/cine/bayer_gbrg8.cine -c copy
FATE_SAMPLES_DEMUX-$(CONFIG_DAUD_DEMUXER) += fate-d-cinema-demux
fate-d-cinema-demux: CMD = framecrc -i $(TARGET_SAMPLES)/d-cinema/THX_Science_FLT_1920-partial.302 -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_EA_DEMUXER) += fate-d-eavp6-demux
fate-d-eavp6-demux: CMD = framecrc -i $(TARGET_SAMPLES)/ea-vp6/SmallRing.vp6 -map 0 -c:v copy
FATE_SAMPLES_DEMUX-$(call ALLYES, GIF_DEMUXER FITS_DEMUXER GIF_DECODER FITS_ENCODER FITS_MUXER) += fate-fits-demux
fate-fits-demux: tests/data/fits-multi.fits
fate-fits-demux: CMD = framecrc -i $(TARGET_PATH)/tests/data/fits-multi.fits -c:v copy
FATE_SAMPLES_DEMUX-$(CONFIG_FLV_DEMUXER) += fate-flv-demux
fate-flv-demux: CMD = framecrc -i $(TARGET_SAMPLES)/flv/Enigma_Principles_of_Lust-part.flv -codec copy
FATE_SAMPLES_DEMUX-$(CONFIG_GIF_DEMUXER) += fate-gif-demux
fate-gif-demux: CMD = framecrc -i $(TARGET_SAMPLES)/gif/Newtons_cradle_animation_book_2.gif -c:v copy
FATE_SAMPLES_DEMUX-$(call ALLYES, IV8_DEMUXER MPEG4VIDEO_PARSER) += fate-iv8-demux
fate-iv8-demux: CMD = framecrc -i $(TARGET_SAMPLES)/iv8/zzz-partial.mpg -c:v copy
FATE_SAMPLES_DEMUX-$(CONFIG_JV_DEMUXER) += fate-jv-demux
fate-jv-demux: CMD = framecrc -i $(TARGET_SAMPLES)/jv/intro.jv -c:v copy -c:a copy
FATE_SAMPLES_DEMUX-$(call ALLYES, LMLM4_DEMUXER MPEG4VIDEO_PARSER) += fate-lmlm4-demux
fate-lmlm4-demux: CMD = framecrc -i $(TARGET_SAMPLES)/lmlm4/LMLM4_CIFat30fps.divx -t 3 -c:a copy -c:v copy
FATE_SAMPLES_DEMUX-$(CONFIG_XA_DEMUXER) += fate-maxis-xa
fate-maxis-xa: CMD = framecrc -i $(TARGET_SAMPLES)/maxis-xa/SC2KBUG.XA -frames:a 30 -c:a copy
FATE_SAMPLES_DEMUX-$(call DEMDEC, MATROSKA, H264) += fate-mkv
fate-mkv: CMD = framecrc -i $(TARGET_SAMPLES)/mkv/test7_cut.mkv -c copy
#No dts errors or duplicate DTS should be in this
FATE_SAMPLES_DEMUX-$(call DEMDEC, MATROSKA, H264) += fate-mkv-1242
fate-mkv-1242: CMD = framecrc -i $(TARGET_SAMPLES)/mkv/1242-small.mkv -c copy -frames:v 11
FATE_SAMPLES_DEMUX-$(CONFIG_MLV_DEMUXER) += fate-mlv-demux
fate-mlv-demux: CMD = crc -i $(TARGET_SAMPLES)/mlv/M19-0333-cut.MLV -c copy
FATE_SAMPLES_DEMUX-$(CONFIG_MOV_DEMUXER) += fate-mov-mp3-demux
fate-mov-mp3-demux: CMD = framecrc -i $(TARGET_SAMPLES)/mpegaudio/packed_maindata.mp3.mp4 -c copy
FATE_SAMPLES_DEMUX-$(CONFIG_MPEGTS_DEMUXER) += fate-ts-opus-demux
fate-ts-opus-demux: CMD = framecrc -i $(TARGET_SAMPLES)/opus/test-8-7.1.opus-small.ts -c copy
FATE_SAMPLES_DEMUX-$(CONFIG_MPEGTS_DEMUXER) += fate-ts-small-demux
fate-ts-small-demux: CMD = framecrc -i $(TARGET_SAMPLES)/mpegts/h264small.ts -c copy
FATE_SAMPLES_DEMUX-$(CONFIG_MTV_DEMUXER) += fate-mtv
fate-mtv: CMD = framecrc -i $(TARGET_SAMPLES)/mtv/comedian_auto-partial.mtv -c copy
FATE_SAMPLES_DEMUX-$(call DEMDEC, MXF, MPEG4) += fate-mxf-demux
fate-mxf-demux: CMD = framecrc -i $(TARGET_SAMPLES)/mxf/C0023S01.mxf -c:a copy -c:v copy
FATE_SAMPLES_DEMUX-$(call ALLYES, NC_DEMUXER MPEG4VIDEO_PARSER) += fate-nc-demux
fate-nc-demux: CMD = framecrc -i $(TARGET_SAMPLES)/nc-camera/nc-sample-partial -c:v copy
FATE_SAMPLES_DEMUX-$(CONFIG_NISTSPHERE_DEMUXER) += fate-nistsphere-demux
fate-nistsphere-demux: CMD = crc -i $(TARGET_SAMPLES)/nistsphere/nist-ulaw.nist -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_NSV_DEMUXER) += fate-nsv-demux
fate-nsv-demux: CMD = framecrc -i $(TARGET_SAMPLES)/nsv/witchblade-51kbps.nsv -t 6 -c:v copy -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_OGG_DEMUXER) += fate-oggopus-demux
fate-oggopus-demux: CMD = framecrc -i $(TARGET_SAMPLES)/ogg/intro-partial.opus -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_OGG_DEMUXER) += fate-oggvp8-demux
fate-oggvp8-demux: CMD = framecrc -i $(TARGET_SAMPLES)/ogg/videotest.ogv -c:v copy
FATE_SAMPLES_DEMUX-$(CONFIG_OMA_DEMUXER) += fate-oma-demux
fate-oma-demux: CMD = crc -i $(TARGET_SAMPLES)/oma/01-Untitled-partial.oma -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_PAF_DEMUXER) += fate-paf-demux
fate-paf-demux: CMD = framecrc -i $(TARGET_SAMPLES)/paf/hod1-partial.paf -c:v copy -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_PMP_DEMUXER) += fate-pmp-demux
fate-pmp-demux: CMD = framecrc -i $(TARGET_SAMPLES)/pmp/demo.pmp -vn -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_RSD_DEMUXER) += fate-rsd-demux
fate-rsd-demux: CMD = crc -i $(TARGET_SAMPLES)/rsd/hum01_partial.rsd -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_REDSPARK_DEMUXER) += fate-redspark-demux
fate-redspark-demux: CMD = crc -i $(TARGET_SAMPLES)/redspark/jingle04_partial.rsd -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_STR_DEMUXER) += fate-psx-str-demux
fate-psx-str-demux: CMD = framecrc -i $(TARGET_SAMPLES)/psx-str/descent-partial.str -c copy
FATE_SAMPLES_DEMUX-$(CONFIG_PVA_DEMUXER) += fate-pva-demux
fate-pva-demux: CMD = framecrc -idct simple -i $(TARGET_SAMPLES)/pva/PVA_test-partial.pva -t 0.6 -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_QCP_DEMUXER) += fate-qcp-demux
fate-qcp-demux: CMD = crc -i $(TARGET_SAMPLES)/qcp/0036580847.QCP -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_R3D_DEMUXER) += fate-redcode-demux
fate-redcode-demux: CMD = framecrc -i $(TARGET_SAMPLES)/r3d/4MB-sample.r3d -c:v copy -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_SIFF_DEMUXER) += fate-siff-demux
fate-siff-demux: CMD = framecrc -i $(TARGET_SAMPLES)/SIFF/INTRO_B.VB -c copy
FATE_SAMPLES_DEMUX-$(CONFIG_SMJPEG_DEMUXER) += fate-smjpeg-demux
fate-smjpeg-demux: CMD = framecrc -i $(TARGET_SAMPLES)/smjpeg/scenwin.mjpg -c copy
FATE_SAMPLES_DEMUX-$(CONFIG_WAV_DEMUXER) += fate-wav-ac3
fate-wav-ac3: CMD = framecrc -i $(TARGET_SAMPLES)/ac3/diatonis_invisible_order_anfos_ac3-small.wav -c copy
FATE_SAMPLES_DEMUX-$(CONFIG_WSAUD_DEMUXER) += fate-westwood-aud
fate-westwood-aud: CMD = framecrc -i $(TARGET_SAMPLES)/westwood-aud/excellent.aud -c copy
FATE_SAMPLES_DEMUX-$(call ALLYES, WTV_DEMUXER MPEGVIDEO_PARSER) += fate-wtv-demux
fate-wtv-demux: CMD = framecrc -i $(TARGET_SAMPLES)/wtv/law-and-order-partial.wtv -c:v copy -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_XMV_DEMUXER) += fate-xmv-demux
fate-xmv-demux: CMD = framecrc -i $(TARGET_SAMPLES)/xmv/logos1p.fmv -c:v copy -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_XWMA_DEMUXER) += fate-xwma-demux
fate-xwma-demux: CMD = crc -i $(TARGET_SAMPLES)/xwma/ergon.xwma -c:a copy
FATE_SAMPLES_DEMUX-$(CONFIG_MPEGTS_DEMUXER) += fate-ts-demux
fate-ts-demux: CMD = framecrc -i $(TARGET_SAMPLES)/ac3/mp3ac325-4864-small.ts -codec copy
FATE_SAMPLES_DEMUX += $(FATE_SAMPLES_DEMUX-yes)
FATE_SAMPLES_FFMPEG += $(FATE_SAMPLES_DEMUX)
fate-demux: $(FATE_SAMPLES_DEMUX)

37
externals/ffmpeg/tests/fate/dfa.mak vendored
View File

@@ -1,37 +0,0 @@
FATE_DFA += fate-dfa1
fate-dfa1: CMD = framecrc -i $(TARGET_SAMPLES)/chronomaster-dfa/0000.dfa -pix_fmt rgb24
FATE_DFA += fate-dfa2
fate-dfa2: CMD = framecrc -i $(TARGET_SAMPLES)/chronomaster-dfa/0001.dfa -pix_fmt rgb24
FATE_DFA += fate-dfa3
fate-dfa3: CMD = framecrc -i $(TARGET_SAMPLES)/chronomaster-dfa/0002.dfa -pix_fmt rgb24
FATE_DFA += fate-dfa4
fate-dfa4: CMD = framecrc -i $(TARGET_SAMPLES)/chronomaster-dfa/0003.dfa -pix_fmt rgb24
FATE_DFA += fate-dfa5
fate-dfa5: CMD = framecrc -i $(TARGET_SAMPLES)/chronomaster-dfa/0004.dfa -pix_fmt rgb24
FATE_DFA += fate-dfa6
fate-dfa6: CMD = framecrc -i $(TARGET_SAMPLES)/chronomaster-dfa/0005.dfa -pix_fmt rgb24
FATE_DFA += fate-dfa7
fate-dfa7: CMD = framecrc -i $(TARGET_SAMPLES)/chronomaster-dfa/0006.dfa -pix_fmt rgb24
FATE_DFA += fate-dfa8
fate-dfa8: CMD = framecrc -i $(TARGET_SAMPLES)/chronomaster-dfa/0007.dfa -pix_fmt rgb24
FATE_DFA += fate-dfa9
fate-dfa9: CMD = framecrc -i $(TARGET_SAMPLES)/chronomaster-dfa/0008.dfa -pix_fmt rgb24
FATE_DFA += fate-dfa10
fate-dfa10: CMD = framecrc -i $(TARGET_SAMPLES)/chronomaster-dfa/0009.dfa -pix_fmt rgb24
FATE_DFA += fate-dfa11
fate-dfa11: CMD = framecrc -i $(TARGET_SAMPLES)/chronomaster-dfa/0010.dfa -pix_fmt rgb24
FATE_DFA-$(call DEMDEC, DFA, DFA) += $(FATE_DFA)
FATE_SAMPLES_AVCONV += $(FATE_DFA-yes)
fate-dfa: $(FATE_DFA-yes)

33
externals/ffmpeg/tests/fate/dnn.mak vendored
View File

@@ -1,33 +0,0 @@
FATE_DNN += fate-dnn-layer-pad
fate-dnn-layer-pad: $(DNNTESTSDIR)/dnn-layer-pad-test$(EXESUF)
fate-dnn-layer-pad: CMD = run $(DNNTESTSDIR)/dnn-layer-pad-test$(EXESUF)
fate-dnn-layer-pad: CMP = null
FATE_DNN += fate-dnn-layer-conv2d
fate-dnn-layer-conv2d: $(DNNTESTSDIR)/dnn-layer-conv2d-test$(EXESUF)
fate-dnn-layer-conv2d: CMD = run $(DNNTESTSDIR)/dnn-layer-conv2d-test$(EXESUF)
fate-dnn-layer-conv2d: CMP = null
FATE_DNN += fate-dnn-layer-depth2space
fate-dnn-layer-depth2space: $(DNNTESTSDIR)/dnn-layer-depth2space-test$(EXESUF)
fate-dnn-layer-depth2space: CMD = run $(DNNTESTSDIR)/dnn-layer-depth2space-test$(EXESUF)
fate-dnn-layer-depth2space: CMP = null
FATE_DNN += fate-dnn-layer-mathbinary
fate-dnn-layer-mathbinary: $(DNNTESTSDIR)/dnn-layer-mathbinary-test$(EXESUF)
fate-dnn-layer-mathbinary: CMD = run $(DNNTESTSDIR)/dnn-layer-mathbinary-test$(EXESUF)
fate-dnn-layer-mathbinary: CMP = null
FATE_DNN += fate-dnn-layer-maximum
fate-dnn-layer-maximum: $(DNNTESTSDIR)/dnn-layer-maximum-test$(EXESUF)
fate-dnn-layer-maximum: CMD = run $(DNNTESTSDIR)/dnn-layer-maximum-test$(EXESUF)
fate-dnn-layer-maximum: CMP = null
FATE_DNN += fate-dnn-layer-mathunary
fate-dnn-layer-mathunary: $(DNNTESTSDIR)/dnn-layer-mathunary-test$(EXESUF)
fate-dnn-layer-mathunary: CMD = run $(DNNTESTSDIR)/dnn-layer-mathunary-test$(EXESUF)
fate-dnn-layer-mathunary: CMP = null
FATE-yes += $(FATE_DNN)
fate-dnn: $(FATE_DNN)

22
externals/ffmpeg/tests/fate/dnxhd.mak vendored
View File

@@ -1,22 +0,0 @@
FATE_DNXHD = fate-dnxhd-mbaff \
fate-dnxhr-444 \
fate-dnxhr-12bit \
fate-dnxhr-parse \
fate-dnxhr-prefix1 \
fate-dnxhr-prefix2 \
fate-dnxhr-prefix3 \
fate-dnxhr-prefix4 \
fate-dnxhr-prefix5
FATE_SAMPLES_AVCONV-$(call DEMDEC, MOV, DNXHD) += $(FATE_DNXHD)
fate-dnxhd: $(FATE_DNXHD) $(FATE_VCODEC_DNXHD)
fate-dnxhd-mbaff: CMD = framecrc -flags +bitexact -idct simple -i $(TARGET_SAMPLES)/dnxhd/dnxhd100_cid1260.mov -pix_fmt yuv422p10le
fate-dnxhr-444: CMD = framecrc -flags +bitexact -idct simple -i $(TARGET_SAMPLES)/dnxhd/dnxhr444_cid1270.mov -pix_fmt yuv444p10le
fate-dnxhr-12bit: CMD = framecrc -flags +bitexact -idct simple -i $(TARGET_SAMPLES)/dnxhd/dnxhr_cid1271_12bit.mov -pix_fmt yuv422p12le
fate-dnxhr-parse: CMD = framecrc -flags +bitexact -idct simple -i $(TARGET_SAMPLES)/dnxhd/dnxhr_cid1274.dnxhr -pix_fmt yuv422p
fate-dnxhr-prefix1: CMD = framecrc -flags +bitexact -idct simple -i $(TARGET_SAMPLES)/dnxhd/prefix-256x1536.dnxhr -pix_fmt yuv422p
fate-dnxhr-prefix2: CMD = framecrc -flags +bitexact -idct simple -i $(TARGET_SAMPLES)/dnxhd/prefix-256x1716.dnxhr -pix_fmt yuv422p
fate-dnxhr-prefix3: CMD = framecrc -flags +bitexact -idct simple -i $(TARGET_SAMPLES)/dnxhd/prefix-256x2048.dnxhr -pix_fmt yuv422p
fate-dnxhr-prefix4: CMD = framecrc -flags +bitexact -idct simple -i $(TARGET_SAMPLES)/dnxhd/prefix-256x2160.dnxhr -pix_fmt yuv422p
fate-dnxhr-prefix5: CMD = framecrc -flags +bitexact -idct simple -i $(TARGET_SAMPLES)/dnxhd/prefix-256x3212.dnxhr -pix_fmt yuv422p

Some files were not shown because too many files have changed in this diff Show More