mirror of
https://github.com/AndroidAudioMods/ViPERFX_RE.git
synced 2025-06-08 02:29:40 +08:00
362 lines
14 KiB
C++
362 lines
14 KiB
C++
#include <cstring>
|
|
#include <cerrno>
|
|
#include <ctime>
|
|
|
|
#include "viper/ViPER.h"
|
|
#include "essential.h"
|
|
#include "log.h"
|
|
#include "viper/constants.h"
|
|
|
|
#define VIPER_EFFECT_NAME "ViPER4Android"
|
|
|
|
static effect_descriptor_t viper_descriptor = {
|
|
// Identical type/uuid to original ViPER4Android
|
|
.type = {0x00000000, 0x0000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
|
|
.uuid = {0x41d3c987, 0xe6cf, 0x11e3, 0xa88a, {0x11, 0xab, 0xa5, 0xd5, 0xc5, 0x1b}},
|
|
.apiVersion = EFFECT_CONTROL_API_VERSION,
|
|
.flags = EFFECT_FLAG_OUTPUT_BOTH | EFFECT_FLAG_INPUT_BOTH | EFFECT_FLAG_INSERT_LAST | EFFECT_FLAG_TYPE_INSERT,
|
|
.cpuLoad = 8, // In 0.1 MIPS units as estimated on an ARM9E core (ARMv5TE) with 0 WS
|
|
.memoryUsage = 1, // In KB and includes only dynamically allocated memory
|
|
.name = VIPER_EFFECT_NAME,
|
|
.implementor = VIPER_AUTHORS
|
|
};
|
|
|
|
extern "C" {
|
|
struct ViperContext {
|
|
const struct effect_interface_s *interface; // Should always be the first struct member
|
|
effect_config_t config;
|
|
ViPER *viper;
|
|
};
|
|
|
|
static int32_t Viper_IProcess(effect_handle_t self, audio_buffer_t *inBuffer, audio_buffer_t *outBuffer) {
|
|
auto pContext = reinterpret_cast<ViperContext *>(self);
|
|
|
|
if (pContext == nullptr ||
|
|
inBuffer == nullptr || outBuffer == nullptr ||
|
|
inBuffer->raw == nullptr || outBuffer->raw == nullptr ||
|
|
inBuffer->frameCount != outBuffer->frameCount ||
|
|
inBuffer->frameCount == 0) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
float *inBufferPtr = inBuffer->f32;
|
|
float *outBufferPtr = outBuffer->f32;
|
|
|
|
if (inBufferPtr != outBufferPtr) {
|
|
memcpy(outBufferPtr, inBufferPtr, outBuffer->frameCount * 2 * sizeof(float));
|
|
}
|
|
|
|
/*return */pContext->viper->processBuffer(outBufferPtr, outBuffer->frameCount);
|
|
return 0; // TODO: Return code from processBuffer()
|
|
}
|
|
|
|
static int configure(ViperContext *pContext, effect_config_t *newConfig) {
|
|
VIPER_LOGI("Begin audio configure ...");
|
|
VIPER_LOGI("Checking input and output configuration ...");
|
|
|
|
if (newConfig->inputCfg.samplingRate != newConfig->outputCfg.samplingRate) {
|
|
VIPER_LOGE("ViPER4Android disabled, reason [in.SR = %d, out.SR = %d]",
|
|
newConfig->inputCfg.samplingRate, newConfig->outputCfg.samplingRate);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (newConfig->inputCfg.samplingRate > 48000) {
|
|
VIPER_LOGE("ViPER4Android disabled, reason [SR out of range]");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (newConfig->inputCfg.channels != newConfig->outputCfg.channels) {
|
|
VIPER_LOGE("ViPER4Android disabled, reason [in.CH = %d, out.CH = %d]",
|
|
newConfig->inputCfg.channels, newConfig->outputCfg.channels);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (newConfig->inputCfg.channels != AUDIO_CHANNEL_OUT_STEREO) {
|
|
VIPER_LOGE("ViPER4Android disabled, reason [CH != 2]");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (newConfig->inputCfg.format != AUDIO_FORMAT_PCM_FLOAT) {
|
|
VIPER_LOGE("ViPER4Android disabled, reason [in.FMT = %d]", newConfig->inputCfg.format);
|
|
VIPER_LOGE("We only accept f32 format");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (newConfig->outputCfg.format != AUDIO_FORMAT_PCM_FLOAT) {
|
|
VIPER_LOGE("ViPER4Android disabled, reason [out.FMT = %d]", newConfig->outputCfg.format);
|
|
VIPER_LOGE("We only accept f32 format");
|
|
return -EINVAL;
|
|
}
|
|
|
|
VIPER_LOGI("Input and output configuration checked.");
|
|
|
|
pContext->config = *newConfig;
|
|
|
|
VIPER_LOGI("Audio configure finished");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int32_t Viper_ICommand(effect_handle_t self,
|
|
uint32_t cmdCode, uint32_t cmdSize, void *pCmdData,
|
|
uint32_t *replySize, void *pReplyData) {
|
|
auto pContext = reinterpret_cast<ViperContext *>(self);
|
|
|
|
if (pContext == nullptr || pContext->viper == nullptr) {
|
|
VIPER_LOGE("Viper_ICommand: pContext or pContext->viper is null!");
|
|
return -EINVAL;
|
|
}
|
|
|
|
VIPER_LOGD("Viper_ICommand() called with cmdCode = %d", cmdCode);
|
|
switch (cmdCode) {
|
|
case EFFECT_CMD_INIT:
|
|
*((int *) pReplyData) = 0;
|
|
return 0;
|
|
case EFFECT_CMD_SET_CONFIG: {
|
|
auto currentSampleRate = pContext->viper->samplingRate;
|
|
|
|
*(int *) pReplyData = configure(pContext, (effect_config_t *) pCmdData);
|
|
if (*(int *) pReplyData == 0) {
|
|
if (currentSampleRate != pContext->viper->samplingRate) {
|
|
pContext->viper->ResetAllEffects();
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
case EFFECT_CMD_RESET: {
|
|
pContext->viper->ResetAllEffects();
|
|
break;
|
|
}
|
|
case EFFECT_CMD_ENABLE: {
|
|
if (!pContext->viper->enabled) {
|
|
pContext->viper->ResetAllEffects();
|
|
}
|
|
pContext->viper->enabled = true;
|
|
*((int *) pReplyData) = 0;
|
|
return 0;
|
|
}
|
|
case EFFECT_CMD_DISABLE: {
|
|
pContext->viper->enabled = false;
|
|
*((int *) pReplyData) = 0;
|
|
return 0;
|
|
}
|
|
case EFFECT_CMD_SET_PARAM: {
|
|
auto *pCmdParam = reinterpret_cast<effect_param_t *>(pCmdData);
|
|
// The value offset of an effect parameter is computed by rounding up
|
|
// the parameter size to the next 32 bit alignment.
|
|
uint32_t vOffset = ((pCmdParam->psize + sizeof(int32_t) - 1) / sizeof(int32_t)) * sizeof(int32_t);
|
|
|
|
int param = *(int *) (pCmdParam->data);
|
|
*(int *) pReplyData = 0;
|
|
|
|
int *intValues = (int *) (pCmdParam->data + vOffset);
|
|
if (pCmdParam->vsize == sizeof(int)) {
|
|
pContext->viper->DispatchCommand(param, intValues[0], 0, 0, 0, 0, nullptr);
|
|
return 0;
|
|
} else if (pCmdParam->vsize == sizeof(int) * 2) {
|
|
pContext->viper->DispatchCommand(param, intValues[0], intValues[1], 0, 0, 0, nullptr);
|
|
return 0;
|
|
} else if (pCmdParam->vsize == sizeof(int) * 3) {
|
|
pContext->viper->DispatchCommand(param, intValues[0], intValues[1], intValues[2], 0, 0, nullptr);
|
|
return 0;
|
|
} else if (pCmdParam->vsize == sizeof(int) * 4) {
|
|
pContext->viper->DispatchCommand(param, intValues[0], intValues[1], intValues[2], intValues[3], 0, nullptr);
|
|
return 0;
|
|
} else if (pCmdParam->vsize == 256 || pCmdParam->vsize == 1024) {
|
|
uint32_t arrSize = *(uint32_t *) (pCmdParam->data + vOffset);
|
|
signed char *arr = (signed char *) (pCmdParam->data + vOffset + sizeof(uint32_t));
|
|
pContext->viper->DispatchCommand(param, 0, 0, 0, 0, arrSize, arr);
|
|
return 0;
|
|
} else if (pCmdParam->vsize == 8192) {
|
|
int value1 = *(int *) (pCmdParam->data + vOffset);
|
|
uint32_t arrSize = *(uint32_t *) (pCmdParam->data + vOffset + sizeof(int));
|
|
signed char *arr = (signed char *) (pCmdParam->data + vOffset + sizeof(int) + sizeof(uint32_t));
|
|
pContext->viper->DispatchCommand(param, value1, 0, 0, 0, arrSize, arr);
|
|
return 0;
|
|
}
|
|
}
|
|
case EFFECT_CMD_GET_PARAM: {
|
|
auto *pCmdParam = reinterpret_cast<effect_param_t *>(pCmdData);
|
|
auto *pReplyParam = reinterpret_cast<effect_param_t *>(pReplyData);
|
|
// The value offset of an effect parameter is computed by rounding up
|
|
// the parameter size to the next 32 bit alignment.
|
|
uint32_t vOffset = ((pCmdParam->psize + sizeof(int32_t) - 1) / sizeof(int32_t)) * sizeof(int32_t);
|
|
|
|
memcpy(pReplyParam, pCmdParam, sizeof(effect_param_t) + pCmdParam->psize);
|
|
|
|
switch (*(uint32_t *) pCmdParam->data) {
|
|
case PARAM_GET_DRIVER_VERSION: {
|
|
pReplyParam->status = 0;
|
|
pReplyParam->vsize = sizeof(uint32_t);
|
|
*(uint32_t *) (pReplyParam->data + vOffset) = 0x2050004; // As original, change as needed
|
|
*replySize = sizeof(effect_param_t) + pReplyParam->psize + vOffset + pReplyParam->vsize;
|
|
return 0;
|
|
}
|
|
case PARAM_GET_ENABLED: {
|
|
pReplyParam->status = 0;
|
|
pReplyParam->vsize = sizeof(int32_t);
|
|
*(int32_t *) (pReplyParam->data + vOffset) = pContext->viper->enabled;
|
|
*replySize = sizeof(effect_param_t) + pReplyParam->psize + vOffset + pReplyParam->vsize;
|
|
return 0;
|
|
}
|
|
case PARAM_GET_CONFIGURE: {
|
|
pReplyParam->status = 0;
|
|
pReplyParam->vsize = sizeof(int32_t);
|
|
*(int32_t *) (pReplyParam->data + vOffset) = 1; // TODO?
|
|
*replySize = sizeof(effect_param_t) + pReplyParam->psize + vOffset + pReplyParam->vsize;
|
|
return 0;
|
|
}
|
|
case PARAM_GET_DRVCANWORK: {
|
|
pReplyParam->status = 0;
|
|
pReplyParam->vsize = sizeof(int32_t);
|
|
*(int32_t *) (pReplyParam->data + vOffset) = pContext->viper->init_ok;
|
|
*replySize = sizeof(effect_param_t) + pReplyParam->psize + vOffset + pReplyParam->vsize;
|
|
return 0;
|
|
}
|
|
case PARAM_GET_STREAMING: { // Is processing
|
|
struct timeval time{};
|
|
gettimeofday(&time, nullptr);
|
|
|
|
// TODO: Do some calculations
|
|
|
|
return 0;
|
|
}
|
|
case PARAM_GET_SAMPLINGRATE: {
|
|
pReplyParam->status = 0;
|
|
pReplyParam->vsize = sizeof(uint32_t);
|
|
*(uint32_t *) (pReplyParam->data + vOffset) = pContext->viper->samplingRate;
|
|
*replySize = sizeof(effect_param_t) + pReplyParam->psize + vOffset + pReplyParam->vsize;
|
|
return 0;
|
|
}
|
|
case PARAM_GET_CONVKNLID: {
|
|
pReplyParam->status = 0;
|
|
pReplyParam->vsize = sizeof(uint32_t);
|
|
*(uint32_t *) (pReplyParam->data + vOffset) = pContext->viper->convolver->GetKernelID();
|
|
*replySize = sizeof(effect_param_t) + pReplyParam->psize + vOffset + pReplyParam->vsize;
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
case EFFECT_CMD_GET_CONFIG: {
|
|
*(effect_config_t *) pReplyData = pContext->config;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int32_t Viper_IGetDescriptor(effect_handle_t self, effect_descriptor_t *pDescriptor) {
|
|
auto pContext = reinterpret_cast<ViperContext *>(self);
|
|
|
|
if (pContext == nullptr || pDescriptor == nullptr) {
|
|
VIPER_LOGE("Viper_IGetDescriptor: pContext or pDescriptor is null!");
|
|
return -EINVAL;
|
|
}
|
|
|
|
*pDescriptor = viper_descriptor;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const effect_interface_s viper_interface = {
|
|
.process = Viper_IProcess,
|
|
.command = Viper_ICommand,
|
|
.get_descriptor = Viper_IGetDescriptor
|
|
};
|
|
|
|
static void Viper_Init(ViperContext *pContext) {
|
|
pContext->interface = &viper_interface;
|
|
|
|
memset(&pContext->config, 0, sizeof(effect_config_t));
|
|
|
|
pContext->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
|
|
pContext->config.inputCfg.format = AUDIO_FORMAT_PCM_FLOAT;
|
|
pContext->config.inputCfg.samplingRate = DEFAULT_SAMPLERATE;
|
|
pContext->config.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
|
|
pContext->config.inputCfg.mask = AUDIO_PORT_CONFIG_ALL;
|
|
|
|
pContext->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_WRITE;
|
|
pContext->config.outputCfg.format = AUDIO_FORMAT_PCM_FLOAT;
|
|
pContext->config.outputCfg.samplingRate = DEFAULT_SAMPLERATE;
|
|
pContext->config.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
|
|
pContext->config.outputCfg.mask = AUDIO_PORT_CONFIG_ALL;
|
|
|
|
pContext->viper = new ViPER();
|
|
}
|
|
|
|
static int32_t
|
|
Viper_Create(const effect_uuid_t *uuid, int32_t sessionId __unused, int32_t ioId __unused, effect_handle_t *pHandle) {
|
|
VIPER_LOGI("Enter Viper_Create()");
|
|
|
|
if (uuid == nullptr || pHandle == nullptr) {
|
|
VIPER_LOGE("Viper_Create: uuid or pHandle is null!");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (memcmp(uuid, &viper_descriptor.uuid, sizeof(effect_uuid_t)) != 0) {
|
|
VIPER_LOGE("Viper_Create: uuid is not viper_descriptor.uuid!");
|
|
return -EINVAL;
|
|
}
|
|
|
|
VIPER_LOGI("Viper_Create: uuid matches, creating viper...");
|
|
|
|
auto *pContext = new ViperContext;
|
|
Viper_Init(pContext);
|
|
*pHandle = reinterpret_cast<effect_handle_t>(pContext);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int32_t Viper_Release(effect_handle_t handle) {
|
|
auto pContext = reinterpret_cast<ViperContext *>(handle);
|
|
|
|
VIPER_LOGI("Enter Viper_Release()");
|
|
|
|
if (pContext == nullptr) {
|
|
VIPER_LOGE("Viper_Release: pContext is null!");
|
|
return -EINVAL;
|
|
}
|
|
|
|
VIPER_LOGI("Viper_Release: deleting viper...");
|
|
|
|
delete pContext->viper;
|
|
delete pContext;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int32_t Viper_GetDescriptor(const effect_uuid_t *uuid, effect_descriptor_t *pDescriptor) {
|
|
VIPER_LOGI("Enter Viper_GetDescriptor()");
|
|
|
|
if (uuid == nullptr || pDescriptor == nullptr) {
|
|
VIPER_LOGE("Viper_GetDescriptor: uuid or pDescriptor is null!");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (memcmp(uuid, &viper_descriptor.uuid, sizeof(effect_uuid_t)) != 0) {
|
|
VIPER_LOGE("Viper_GetDescriptor: uuid is not viper_descriptor.uuid!");
|
|
return -EINVAL;
|
|
}
|
|
|
|
VIPER_LOGI("Viper_GetDescriptor: uuid matches, returning descriptor...");
|
|
|
|
*pDescriptor = viper_descriptor;
|
|
|
|
return 0;
|
|
}
|
|
|
|
__attribute__ ((visibility ("default")))
|
|
audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = {
|
|
.tag = AUDIO_EFFECT_LIBRARY_TAG,
|
|
.version = EFFECT_LIBRARY_API_VERSION,
|
|
.name = VIPER_EFFECT_NAME,
|
|
.implementor = VIPER_AUTHORS,
|
|
.create_effect = Viper_Create,
|
|
.release_effect = Viper_Release,
|
|
.get_descriptor = Viper_GetDescriptor,
|
|
};
|
|
|
|
} // extern "C"
|