Merge "Reverb benchmark: Initial version" am: 980553b0b6 am: 342afc4ea5 am: ab1673777f (346778c2) · Commits · e / os / android_frameworks_av

media/libeffects/lvm/benchmarks/Android.bp

+21 −0

Original line number	Diff line number	Diff line
		@@ -14,3 +14,24 @@ cc_benchmark {
		"libhardware_headers",
		],
		}

		cc_benchmark {
		name: "reverb_benchmark",
		vendor: true,
		include_dirs: [
		"frameworks/av/media/libeffects/lvm/wrapper/Reverb",
		],
		srcs: ["reverb_benchmark.cpp"],
		static_libs: [
		"libreverb",
		"libreverbwrapper",
		],
		shared_libs: [
		"libaudioutils",
		"liblog",
		],
		header_libs: [
		"libaudioeffects",
		"libhardware_headers",
		],
		}

media/libeffects/lvm/benchmarks/reverb_benchmark.cpp

0 → 100644

+180 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2020 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include <array>
		#include <climits>
		#include <cstdlib>
		#include <random>
		#include <vector>
		#include <log/log.h>
		#include <benchmark/benchmark.h>
		#include <hardware/audio_effect.h>
		#include <system/audio.h>
		#include "EffectReverb.h"

		extern audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM;
		constexpr effect_uuid_t kEffectUuids[] = {
		{0x172cdf00,
		0xa3bc,
		0x11df,
		0xa72f,
		{0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // preset-insert mode
		{0xf29a1400,
		0xa3bb,
		0x11df,
		0x8ddc,
		{0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // preset-aux mode
		};

		constexpr size_t kNumEffectUuids = std::size(kEffectUuids);

		constexpr size_t kFrameCount = 2048;

		constexpr int kPresets[] = {
		REVERB_PRESET_NONE, REVERB_PRESET_SMALLROOM, REVERB_PRESET_MEDIUMROOM,
		REVERB_PRESET_LARGEROOM, REVERB_PRESET_MEDIUMHALL, REVERB_PRESET_LARGEHALL,
		REVERB_PRESET_PLATE,
		};

		constexpr size_t kNumPresets = std::size(kPresets);

		constexpr int kSampleRate = 44100;

		int reverbSetConfigParam(uint32_t paramType, uint32_t paramValue, effect_handle_t effectHandle) {
		int reply = 0;
		uint32_t replySize = sizeof(reply);
		uint32_t paramData[2] = {paramType, paramValue};
		auto effectParam = (effect_param_t*)malloc(sizeof(effect_param_t) + sizeof(paramData));
		memcpy(&effectParam->data[0], &paramData[0], sizeof(paramData));
		effectParam->psize = sizeof(paramData[0]);
		effectParam->vsize = sizeof(paramData[1]);
		int status = (*effectHandle)
		->command(effectHandle, EFFECT_CMD_SET_PARAM,
		sizeof(effect_param_t) + sizeof(paramData), effectParam,
		&replySize, &reply);
		free(effectParam);
		if (status != 0) {
		ALOGE("Reverb set config returned an error = %d\n", status);
		return status;
		}
		return reply;
		}

		/*******************************************************************
		* A test result running on Pixel 3 with for comparison.
		* The first parameter indicates the preset level id.
		* The second parameter indicates the effect.
		* 0: preset-insert mode, 1: preset-aux mode
		* --------------------------------------------------------
		* Benchmark Time CPU Iterations
		* --------------------------------------------------------
		* BM_REVERB/0/0 19312 ns 19249 ns 36282
		* BM_REVERB/0/1 5613 ns 5596 ns 125032
		* BM_REVERB/1/0 605453 ns 603714 ns 1131
		* BM_REVERB/1/1 589421 ns 587758 ns 1161
		* BM_REVERB/2/0 605760 ns 604006 ns 1131
		* BM_REVERB/2/1 589434 ns 587777 ns 1161
		* BM_REVERB/3/0 605574 ns 603828 ns 1131
		* BM_REVERB/3/1 589566 ns 587862 ns 1162
		* BM_REVERB/4/0 605634 ns 603894 ns 1131
		* BM_REVERB/4/1 589506 ns 587856 ns 1161
		* BM_REVERB/5/0 605644 ns 603929 ns 1131
		* BM_REVERB/5/1 589592 ns 587863 ns 1161
		* BM_REVERB/6/0 610544 ns 608561 ns 1131
		* BM_REVERB/6/1 589686 ns 587871 ns 1161
		*******************************************************************/

		static void BM_REVERB(benchmark::State& state) {
		const size_t chMask = AUDIO_CHANNEL_OUT_STEREO;
		const size_t preset = kPresets[state.range(0)];
		const effect_uuid_t uuid = kEffectUuids[state.range(1)];
		const size_t channelCount = audio_channel_count_from_out_mask(chMask);

		// Initialize input buffer with deterministic pseudo-random values
		std::minstd_rand gen(chMask);
		std::uniform_real_distribution<> dis(-1.0f, 1.0f);
		std::vector<float> input(kFrameCount * channelCount);
		std::vector<float> output(kFrameCount * channelCount);
		for (auto& in : input) {
		in = dis(gen);
		}

		effect_handle_t effectHandle = nullptr;
		if (int status = AUDIO_EFFECT_LIBRARY_INFO_SYM.create_effect(&uuid, 1, 1, &effectHandle);
		status != 0) {
		ALOGE("create_effect returned an error = %d\n", status);
		return;
		}

		effect_config_t config{};
		config.inputCfg.samplingRate = config.outputCfg.samplingRate = kSampleRate;
		config.inputCfg.channels = config.outputCfg.channels = chMask;
		config.inputCfg.format = config.outputCfg.format = AUDIO_FORMAT_PCM_FLOAT;

		int reply = 0;
		uint32_t replySize = sizeof(reply);
		if (int status = (*effectHandle)
		->command(effectHandle, EFFECT_CMD_SET_CONFIG, sizeof(effect_config_t),
		&config, &replySize, &reply);
		status != 0) {
		ALOGE("command returned an error = %d\n", status);
		return;
		}

		if (int status =
		(*effectHandle)
		->command(effectHandle, EFFECT_CMD_ENABLE, 0, nullptr, &replySize, &reply);
		status != 0) {
		ALOGE("Command enable call returned error %d\n", reply);
		return;
		}

		if (int status = reverbSetConfigParam(REVERB_PARAM_PRESET, preset, effectHandle); status != 0) {
		ALOGE("Invalid reverb preset. Error %d\n", status);
		return;
		}

		// Run the test
		for (auto _ : state) {
		benchmark::DoNotOptimize(input.data());
		benchmark::DoNotOptimize(output.data());

		audio_buffer_t inBuffer = {.frameCount = kFrameCount, .f32 = input.data()};
		audio_buffer_t outBuffer = {.frameCount = kFrameCount, .f32 = output.data()};
		(*effectHandle)->process(effectHandle, &inBuffer, &outBuffer);

		benchmark::ClobberMemory();
		}

		state.SetComplexityN(state.range(0));

		if (int status = AUDIO_EFFECT_LIBRARY_INFO_SYM.release_effect(effectHandle); status != 0) {
		ALOGE("release_effect returned an error = %d\n", status);
		return;
		}
		}

		static void REVERBArgs(benchmark::internal::Benchmark* b) {
		for (int i = 0; i < kNumPresets; i++) {
		for (int j = 0; j < kNumEffectUuids; ++j) {
		b->Args({i, j});
		}
		}
		}

		BENCHMARK(BM_REVERB)->Apply(REVERBArgs);

		BENCHMARK_MAIN();