Backups/ViPERFX_RE
1
0
Fork 0
mirror of https://github.com/AndroidAudioMods/ViPERFX_RE.git synced 2025-01-03 16:13:35 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
Martmists 2021-07-27 09:47:15 +02:00
commit bbcdf238a9
41 changed files with 5599 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
.gitignore vendored Normal file
View File

@ -0,0 +1,139 @@
### JetBrains template
# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
# User-specific stuff
.idea/
# Gradle and Maven with auto-import
# When using Gradle or Maven with auto-import, you should exclude module files,
# since they will be recreated, and may cause churn. Uncomment if using
# auto-import.
# .idea/artifacts
# .idea/compiler.xml
# .idea/jarRepositories.xml
# .idea/modules.xml
# .idea/*.iml
# .idea/modules
# *.iml
# *.ipr
# CMake
cmake-build-*/
# Mongo Explorer plugin
.idea/**/mongoSettings.xml
# File-based project format
*.iws
# IntelliJ
out/
# mpeltonen/sbt-idea plugin
.idea_modules/
# JIRA plugin
atlassian-ide-plugin.xml
# Cursive Clojure plugin
.idea/replstate.xml
# Crashlytics plugin (for Android Studio and IntelliJ)
com_crashlytics_export_strings.xml
crashlytics.properties
crashlytics-build.properties
fabric.properties
# Editor-based Rest Client
.idea/httpRequests
# Android studio 3.1+ serialized cache file
.idea/caches/build_file_checksums.ser
### C template
# Prerequisites
*.d
# Object files
*.o
*.ko
*.obj
*.elf
# Linker output
*.ilk
*.map
*.exp
# Precompiled Headers
*.gch
*.pch
# Libraries
*.lib
*.a
*.la
*.lo
# Shared objects (inc. Windows DLLs)
*.dll
*.so
*.so.*
*.dylib
# Executables
*.exe
*.out
*.app
*.i*86
*.x86_64
*.hex
# Debug files
*.dSYM/
*.su
*.idb
*.pdb
# Kernel Module Compile Results
*.mod*
*.cmd
.tmp_versions/
modules.order
Module.symvers
Mkfile.old
dkms.conf
### C++ template
# Prerequisites
# Compiled Object files
*.slo
# Precompiled Headers
# Compiled Dynamic libraries
# Fortran module files
*.mod
*.smod
# Compiled Static libraries
*.lai
# Executables
### CMake template
CMakeLists.txt.user
CMakeCache.txt
CMakeFiles
CMakeScripts
Testing
Makefile
cmake_install.cmake
install_manifest.txt
compile_commands.json
CTestTestfile.cmake
_deps
*.cbp

40
CMakeLists.txt Normal file
View File

@ -0,0 +1,40 @@
cmake_minimum_required(VERSION 3.19)
project("ViPER4Android Reworked")
set(CMAKE_CXX_COMPILER_VERSION 20)
include_directories("include/")
set(FILES
# Main
src/Effect.cpp
src/ProcessUnit_FX.cpp
src/viper.cpp
# Effects
src/effects/Cure.cpp
src/effects/TubeSimulator.cpp
# Utils
src/utils/CAllpassFilter.cpp
src/utils/Crossfeed.cpp
src/utils/FixedBiquad.cpp
src/utils/IIR_1st.cpp
src/utils/IIR_NOrder_BW_BP.cpp
src/utils/IIR_NOrder_BW_LH.cpp
src/utils/MultiBiquad.cpp
src/utils/PassFilter.cpp
src/utils/TimeConstDelay.cpp
)
add_library(
# Sets the name of the library.
v4afx_r
# Sets the library as a shared library.
SHARED
# Provides a relative path to your source file(s).
${FILES})

1026
include/hardware/audio_effect.h Normal file
View File

File diff suppressed because it is too large Load Diff

461
include/hardware/audio_policy.h Normal file
View File

@ -0,0 +1,461 @@
/*
* Copyright (C) 2011 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.
*/
#ifndef ANDROID_AUDIO_POLICY_INTERFACE_H
#define ANDROID_AUDIO_POLICY_INTERFACE_H
#include <stdint.h>
#include <sys/cdefs.h>
#include <sys/types.h>
#include <hardware/hardware.h>
#include "system/audio.h"
#include "system/audio_policy.h"
__BEGIN_DECLS
/**
* The id of this module
*/
#define AUDIO_POLICY_HARDWARE_MODULE_ID "audio_policy"
/**
* Name of the audio devices to open
*/
#define AUDIO_POLICY_INTERFACE "policy"
/* ---------------------------------------------------------------------------- */
/*
* The audio_policy and audio_policy_service_ops structs define the
* communication interfaces between the platform specific audio policy manager
* and Android generic audio policy manager.
* The platform specific audio policy manager must implement methods of the
* audio_policy struct.
* This implementation makes use of the audio_policy_service_ops to control
* the activity and configuration of audio input and output streams.
*
* The platform specific audio policy manager is in charge of the audio
* routing and volume control policies for a given platform.
* The main roles of this module are:
* - keep track of current system state (removable device connections, phone
* state, user requests...).
* System state changes and user actions are notified to audio policy
* manager with methods of the audio_policy.
*
* - process get_output() queries received when AudioTrack objects are
* created: Those queries return a handler on an output that has been
* selected, configured and opened by the audio policy manager and that
* must be used by the AudioTrack when registering to the AudioFlinger
* with the createTrack() method.
* When the AudioTrack object is released, a release_output() query
* is received and the audio policy manager can decide to close or
* reconfigure the output depending on other streams using this output and
* current system state.
*
* - similarly process get_input() and release_input() queries received from
* AudioRecord objects and configure audio inputs.
* - process volume control requests: the stream volume is converted from
* an index value (received from UI) to a float value applicable to each
* output as a function of platform specific settings and current output
* route (destination device). It also make sure that streams are not
* muted if not allowed (e.g. camera shutter sound in some countries).
*/
/* XXX: this should be defined OUTSIDE of frameworks/base */
struct effect_descriptor_s;
struct audio_policy
{
/*
* configuration functions
*/
/* indicate a change in device connection status */
int (*set_device_connection_state)(struct audio_policy *pol,
audio_devices_t device,
audio_policy_dev_state_t state,
const char *device_address);
/* retrieve a device connection status */
audio_policy_dev_state_t (*get_device_connection_state)(
const struct audio_policy *pol,
audio_devices_t device,
const char *device_address);
/* indicate a change in phone state. Valid phones states are defined
* by audio_mode_t */
void (*set_phone_state)(struct audio_policy *pol, audio_mode_t state);
/* deprecated, never called (was "indicate a change in ringer mode") */
void (*set_ringer_mode)(struct audio_policy *pol, uint32_t mode,
uint32_t mask);
/* force using a specific device category for the specified usage */
void (*set_force_use)(struct audio_policy *pol,
audio_policy_force_use_t usage,
audio_policy_forced_cfg_t config);
/* retrieve current device category forced for a given usage */
audio_policy_forced_cfg_t (*get_force_use)(const struct audio_policy *pol,
audio_policy_force_use_t usage);
/* if can_mute is true, then audio streams that are marked ENFORCED_AUDIBLE
* can still be muted. */
void (*set_can_mute_enforced_audible)(struct audio_policy *pol,
bool can_mute);
/* check proper initialization */
int (*init_check)(const struct audio_policy *pol);
/*
* Audio routing query functions
*/
/* request an output appropriate for playback of the supplied stream type and
* parameters */
audio_io_handle_t (*get_output)(struct audio_policy *pol,
audio_stream_type_t stream,
uint32_t samplingRate,
audio_format_t format,
audio_channel_mask_t channelMask,
audio_output_flags_t flags,
const audio_offload_info_t *offloadInfo);
/* indicates to the audio policy manager that the output starts being used
* by corresponding stream. */
int (*start_output)(struct audio_policy *pol,
audio_io_handle_t output,
audio_stream_type_t stream,
int session);
/* indicates to the audio policy manager that the output stops being used
* by corresponding stream. */
int (*stop_output)(struct audio_policy *pol,
audio_io_handle_t output,
audio_stream_type_t stream,
int session);
/* releases the output. */
void (*release_output)(struct audio_policy *pol, audio_io_handle_t output);
/* request an input appropriate for record from the supplied device with
* supplied parameters. */
audio_io_handle_t (*get_input)(struct audio_policy *pol, audio_source_t inputSource,
uint32_t samplingRate,
audio_format_t format,
audio_channel_mask_t channelMask,
audio_in_acoustics_t acoustics);
/* indicates to the audio policy manager that the input starts being used */
int (*start_input)(struct audio_policy *pol, audio_io_handle_t input);
/* indicates to the audio policy manager that the input stops being used. */
int (*stop_input)(struct audio_policy *pol, audio_io_handle_t input);
/* releases the input. */
void (*release_input)(struct audio_policy *pol, audio_io_handle_t input);
/*
* volume control functions
*/
/* initialises stream volume conversion parameters by specifying volume
* index range. The index range for each stream is defined by AudioService. */
void (*init_stream_volume)(struct audio_policy *pol,
audio_stream_type_t stream,
int index_min,
int index_max);
/* sets the new stream volume at a level corresponding to the supplied
* index. The index is within the range specified by init_stream_volume() */
int (*set_stream_volume_index)(struct audio_policy *pol,
audio_stream_type_t stream,
int index);
/* retrieve current volume index for the specified stream */
int (*get_stream_volume_index)(const struct audio_policy *pol,
audio_stream_type_t stream,
int *index);
/* sets the new stream volume at a level corresponding to the supplied
* index for the specified device.
* The index is within the range specified by init_stream_volume() */
int (*set_stream_volume_index_for_device)(struct audio_policy *pol,
audio_stream_type_t stream,
int index,
audio_devices_t device);
/* retrieve current volume index for the specified stream for the specified device */
int (*get_stream_volume_index_for_device)(const struct audio_policy *pol,
audio_stream_type_t stream,
int *index,
audio_devices_t device);
/* return the strategy corresponding to a given stream type */
uint32_t (*get_strategy_for_stream)(const struct audio_policy *pol,
audio_stream_type_t stream);
/* return the enabled output devices for the given stream type */
audio_devices_t (*get_devices_for_stream)(const struct audio_policy *pol,
audio_stream_type_t stream);
/* Audio effect management */
audio_io_handle_t (*get_output_for_effect)(struct audio_policy *pol,
const struct effect_descriptor_s *desc);
int (*register_effect)(struct audio_policy *pol,
const struct effect_descriptor_s *desc,
audio_io_handle_t output,
uint32_t strategy,
int session,
int id);
int (*unregister_effect)(struct audio_policy *pol, int id);
int (*set_effect_enabled)(struct audio_policy *pol, int id, bool enabled);
bool (*is_stream_active)(const struct audio_policy *pol,
audio_stream_type_t stream,
uint32_t in_past_ms);
bool (*is_stream_active_remotely)(const struct audio_policy *pol,
audio_stream_type_t stream,
uint32_t in_past_ms);
bool (*is_source_active)(const struct audio_policy *pol,
audio_source_t source);
/* dump state */
int (*dump)(const struct audio_policy *pol, int fd);
/* check if offload is possible for given sample rate, bitrate, duration, ... */
bool (*is_offload_supported)(const struct audio_policy *pol,
const audio_offload_info_t *info);
};
struct audio_policy_service_ops
{
/*
* Audio output Control functions
*/
/* Opens an audio output with the requested parameters.
*
* The parameter values can indicate to use the default values in case the
* audio policy manager has no specific requirements for the output being
* opened.
*
* When the function returns, the parameter values reflect the actual
* values used by the audio hardware output stream.
*
* The audio policy manager can check if the proposed parameters are
* suitable or not and act accordingly.
*/
audio_io_handle_t (*open_output)(void *service,
audio_devices_t *pDevices,
uint32_t *pSamplingRate,
audio_format_t *pFormat,
audio_channel_mask_t *pChannelMask,
uint32_t *pLatencyMs,
audio_output_flags_t flags);
/* creates a special output that is duplicated to the two outputs passed as
* arguments. The duplication is performed by
* a special mixer thread in the AudioFlinger.
*/
audio_io_handle_t (*open_duplicate_output)(void *service,
audio_io_handle_t output1,
audio_io_handle_t output2);
/* closes the output stream */
int (*close_output)(void *service, audio_io_handle_t output);
/* suspends the output.
*
* When an output is suspended, the corresponding audio hardware output
* stream is placed in standby and the AudioTracks attached to the mixer
* thread are still processed but the output mix is discarded.
*/
int (*suspend_output)(void *service, audio_io_handle_t output);
/* restores a suspended output. */
int (*restore_output)(void *service, audio_io_handle_t output);
/* */
/* Audio input Control functions */
/* */
/* opens an audio input
* deprecated - new implementations should use open_input_on_module,
* and the acoustics parameter is ignored
*/
audio_io_handle_t (*open_input)(void *service,
audio_devices_t *pDevices,
uint32_t *pSamplingRate,
audio_format_t *pFormat,
audio_channel_mask_t *pChannelMask,
audio_in_acoustics_t acoustics);
/* closes an audio input */
int (*close_input)(void *service, audio_io_handle_t input);
/* */
/* misc control functions */
/* */
/* set a stream volume for a particular output.
*
* For the same user setting, a given stream type can have different
* volumes for each output (destination device) it is attached to.
*/
int (*set_stream_volume)(void *service,
audio_stream_type_t stream,
float volume,
audio_io_handle_t output,
int delay_ms);
/* invalidate a stream type, causing a reroute to an unspecified new output */
int (*invalidate_stream)(void *service,
audio_stream_type_t stream);
/* function enabling to send proprietary informations directly from audio
* policy manager to audio hardware interface. */
void (*set_parameters)(void *service,
audio_io_handle_t io_handle,
const char *kv_pairs,
int delay_ms);
/* function enabling to receive proprietary informations directly from
* audio hardware interface to audio policy manager.
*
* Returns a pointer to a heap allocated string. The caller is responsible
* for freeing the memory for it using free().
*/
char * (*get_parameters)(void *service, audio_io_handle_t io_handle,
const char *keys);
/* request the playback of a tone on the specified stream.
* used for instance to replace notification sounds when playing over a
* telephony device during a phone call.
*/
int (*start_tone)(void *service,
audio_policy_tone_t tone,
audio_stream_type_t stream);
int (*stop_tone)(void *service);
/* set down link audio volume. */
int (*set_voice_volume)(void *service,
float volume,
int delay_ms);
/* move effect to the specified output */
int (*move_effects)(void *service,
int session,
audio_io_handle_t src_output,
audio_io_handle_t dst_output);
/* loads an audio hw module.
*
* The module name passed is the base name of the HW module library, e.g "primary" or "a2dp".
* The function returns a handle on the module that will be used to specify a particular
* module when calling open_output_on_module() or open_input_on_module()
*/
audio_module_handle_t (*load_hw_module)(void *service,
const char *name);
/* Opens an audio output on a particular HW module.
*
* Same as open_output() but specifying a specific HW module on which the output must be opened.
*/
audio_io_handle_t (*open_output_on_module)(void *service,
audio_module_handle_t module,
audio_devices_t *pDevices,
uint32_t *pSamplingRate,
audio_format_t *pFormat,
audio_channel_mask_t *pChannelMask,
uint32_t *pLatencyMs,
audio_output_flags_t flags,
const audio_offload_info_t *offloadInfo);
/* Opens an audio input on a particular HW module.
*
* Same as open_input() but specifying a specific HW module on which the input must be opened.
* Also removed deprecated acoustics parameter
*/
audio_io_handle_t (*open_input_on_module)(void *service,
audio_module_handle_t module,
audio_devices_t *pDevices,
uint32_t *pSamplingRate,
audio_format_t *pFormat,
audio_channel_mask_t *pChannelMask);
};
/**********************************************************************/
/**
* Every hardware module must have a data structure named HAL_MODULE_INFO_SYM
* and the fields of this data structure must begin with hw_module_t
* followed by module specific information.
*/
typedef struct audio_policy_module
{
struct hw_module_t common;
} audio_policy_module_t;
struct audio_policy_device
{
/**
* Common methods of the audio policy device. This *must* be the first member of
* audio_policy_device as users of this structure will cast a hw_device_t to
* audio_policy_device pointer in contexts where it's known the hw_device_t references an
* audio_policy_device.
*/
struct hw_device_t common;
int (*create_audio_policy)(const struct audio_policy_device *device,
struct audio_policy_service_ops *aps_ops,
void *service,
struct audio_policy **ap);
int (*destroy_audio_policy)(const struct audio_policy_device *device,
struct audio_policy *ap);
};
/** convenience API for opening and closing a supported device */
static inline int audio_policy_dev_open(const hw_module_t* module,
struct audio_policy_device** device)
{
return module->methods->open(module, AUDIO_POLICY_INTERFACE,
(hw_device_t**)device);
}
static inline int audio_policy_dev_close(struct audio_policy_device* device)
{
return device->common.close(&device->common);
}
__END_DECLS
#endif // ANDROID_AUDIO_POLICY_INTERFACE_H

241
include/hardware/hardware.h Normal file
View File

@ -0,0 +1,241 @@
/*
* Copyright (C) 2008 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.
*/
#ifndef ANDROID_INCLUDE_HARDWARE_HARDWARE_H
#define ANDROID_INCLUDE_HARDWARE_HARDWARE_H
#include <stdint.h>
#include <sys/cdefs.h>
#include "system/cutils/native_handle.h"
//#include "system/graphics.h"
__BEGIN_DECLS
/*
* Value for the hw_module_t.tag field
*/
#define MAKE_TAG_CONSTANT(A,B,C,D) (((A) << 24) | ((B) << 16) | ((C) << 8) | (D))
#define HARDWARE_MODULE_TAG MAKE_TAG_CONSTANT('H', 'W', 'M', 'T')
#define HARDWARE_DEVICE_TAG MAKE_TAG_CONSTANT('H', 'W', 'D', 'T')
#define HARDWARE_MAKE_API_VERSION(maj,min) \
((((maj) & 0xff) << 8) | ((min) & 0xff))
#define HARDWARE_MAKE_API_VERSION_2(maj,min,hdr) \
((((maj) & 0xff) << 24) | (((min) & 0xff) << 16) | ((hdr) & 0xffff))
#define HARDWARE_API_VERSION_2_MAJ_MIN_MASK 0xffff0000
#define HARDWARE_API_VERSION_2_HEADER_MASK 0x0000ffff
/*
* The current HAL API version.
*
* All module implementations must set the hw_module_t.hal_api_version field
* to this value when declaring the module with HAL_MODULE_INFO_SYM.
*
* Note that previous implementations have always set this field to 0.
* Therefore, libhardware HAL API will always consider versions 0.0 and 1.0
* to be 100% binary compatible.
*
*/
#define HARDWARE_HAL_API_VERSION HARDWARE_MAKE_API_VERSION(1, 0)
/*
* Helper macros for module implementors.
*
* The derived modules should provide convenience macros for supported
* versions so that implementations can explicitly specify module/device
* versions at definition time.
*
* Use this macro to set the hw_module_t.module_api_version field.
*/
#define HARDWARE_MODULE_API_VERSION(maj,min) HARDWARE_MAKE_API_VERSION(maj,min)
#define HARDWARE_MODULE_API_VERSION_2(maj,min,hdr) HARDWARE_MAKE_API_VERSION_2(maj,min,hdr)
/*
* Use this macro to set the hw_device_t.version field
*/
#define HARDWARE_DEVICE_API_VERSION(maj,min) HARDWARE_MAKE_API_VERSION(maj,min)
#define HARDWARE_DEVICE_API_VERSION_2(maj,min,hdr) HARDWARE_MAKE_API_VERSION_2(maj,min,hdr)
struct hw_module_t;
struct hw_module_methods_t;
struct hw_device_t;
/**
* Every hardware module must have a data structure named HAL_MODULE_INFO_SYM
* and the fields of this data structure must begin with hw_module_t
* followed by module specific information.
*/
typedef struct hw_module_t
{
/** tag must be initialized to HARDWARE_MODULE_TAG */
uint32_t tag;
/**
* The API version of the implemented module. The module owner is
* responsible for updating the version when a module interface has
* changed.
*
* The derived modules such as gralloc and audio own and manage this field.
* The module user must interpret the version field to decide whether or
* not to inter-operate with the supplied module implementation.
* For example, SurfaceFlinger is responsible for making sure that
* it knows how to manage different versions of the gralloc-module API,
* and AudioFlinger must know how to do the same for audio-module API.
*
* The module API version should include a major and a minor component.
* For example, version 1.0 could be represented as 0x0100. This format
* implies that versions 0x0100-0x01ff are all API-compatible.
*
* In the future, libhardware will expose a hw_get_module_version()
* (or equivalent) function that will take minimum/maximum supported
* versions as arguments and would be able to reject modules with
* versions outside of the supplied range.
*/
uint16_t module_api_version;
#define version_major module_api_version
/**
* version_major/version_minor defines are supplied here for temporary
* source code compatibility. They will be removed in the next version.
* ALL clients must convert to the new version format.
*/
/**
* The API version of the HAL module interface. This is meant to
* version the hw_module_t, hw_module_methods_t, and hw_device_t
* structures and definitions.
*
* The HAL interface owns this field. Module users/implementations
* must NOT rely on this value for version information.
*
* Presently, 0 is the only valid value.
*/
uint16_t hal_api_version;
#define version_minor hal_api_version
/** Identifier of module */
const char *id;
/** Name of this module */
const char *name;
/** Author/owner/implementor of the module */
const char *author;
/** Modules methods */
struct hw_module_methods_t* methods;
/** module's dso */
void* dso;
#ifdef __LP64__
uint64_t reserved[32-7];
#else
/** padding to 128 bytes, reserved for future use */
uint32_t reserved[32-7];
#endif
} hw_module_t;
typedef struct hw_module_methods_t
{
/** Open a specific device */
int (*open)(const struct hw_module_t* module, const char* id,
struct hw_device_t** device);
} hw_module_methods_t;
/**
* Every device data structure must begin with hw_device_t
* followed by module specific public methods and attributes.
*/
typedef struct hw_device_t
{
/** tag must be initialized to HARDWARE_DEVICE_TAG */
uint32_t tag;
/**
* Version of the module-specific device API. This value is used by
* the derived-module user to manage different device implementations.
*
* The module user is responsible for checking the module_api_version
* and device version fields to ensure that the user is capable of
* communicating with the specific module implementation.
*
* One module can support multiple devices with different versions. This
* can be useful when a device interface changes in an incompatible way
* but it is still necessary to support older implementations at the same
* time. One such example is the Camera 2.0 API.
*
* This field is interpreted by the module user and is ignored by the
* HAL interface itself.
*/
uint32_t version;
/** reference to the module this device belongs to */
struct hw_module_t* module;
/** padding reserved for future use */
#ifdef __LP64__
uint64_t reserved[12];
#else
uint32_t reserved[12];
#endif
/** Close this device */
int (*close)(struct hw_device_t* device);
} hw_device_t;
/**
* Name of the hal_module_info
*/
#define HAL_MODULE_INFO_SYM HMI
/**
* Name of the hal_module_info as a string
*/
#define HAL_MODULE_INFO_SYM_AS_STR "HMI"
/**
* Get the module info associated with a module by id.
*
* @return: 0 == success, <0 == error and *module == NULL
*/
int hw_get_module(const char *id, const struct hw_module_t **module);
/**
* Get the module info associated with a module instance by class 'class_id'
* and instance 'inst'.
*
* Some modules types necessitate multiple instances. For example audio supports
* multiple concurrent interfaces and thus 'audio' is the module class
* and 'primary' or 'a2dp' are module interfaces. This implies that the files
* providing these modules would be named audio.primary.<variant>.so and
* audio.a2dp.<variant>.so
*
* @return: 0 == success, <0 == error and *module == NULL
*/
int hw_get_module_by_class(const char *class_id, const char *inst,
const struct hw_module_t **module);
__END_DECLS
#endif /* ANDROID_INCLUDE_HARDWARE_HARDWARE_H */

177
include/hardware/system/audio-base-utils.h Normal file
View File

@ -0,0 +1,177 @@
/*
* Copyright (C) 2018 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.
*/
#ifndef ANDROID_AUDIO_BASE_UTILS_H
#define ANDROID_AUDIO_BASE_UTILS_H
#include "audio-base.h"
/** Define helper values to iterate over enum, extend them or checking value validity.
* Those values are compatible with the O corresponding enum values.
* They are not macro like similar values in audio.h to avoid conflicting
* with the libhardware_legacy audio.h.
*/
enum {
/** Number of audio stream available to vendors. */
AUDIO_STREAM_PUBLIC_CNT = AUDIO_STREAM_ACCESSIBILITY + 1,
#ifndef AUDIO_NO_SYSTEM_DECLARATIONS
/** Total number of stream handled by the policy*/
AUDIO_STREAM_FOR_POLICY_CNT= AUDIO_STREAM_REROUTING + 1,
#endif
/** Total number of stream. */
AUDIO_STREAM_CNT = AUDIO_STREAM_PATCH + 1,
AUDIO_SOURCE_MAX = AUDIO_SOURCE_UNPROCESSED,
AUDIO_SOURCE_CNT = AUDIO_SOURCE_MAX + 1,
AUDIO_MODE_MAX = AUDIO_MODE_IN_COMMUNICATION,
AUDIO_MODE_CNT = AUDIO_MODE_MAX + 1,
/** For retrocompatibility AUDIO_MODE_* and AUDIO_STREAM_* must be signed. */
AUDIO_DETAIL_NEGATIVE_VALUE = -1,
};
enum {
AUDIO_CHANNEL_OUT_ALL = AUDIO_CHANNEL_OUT_FRONT_LEFT |
AUDIO_CHANNEL_OUT_FRONT_RIGHT |
AUDIO_CHANNEL_OUT_FRONT_CENTER |
AUDIO_CHANNEL_OUT_LOW_FREQUENCY |
AUDIO_CHANNEL_OUT_BACK_LEFT |
AUDIO_CHANNEL_OUT_BACK_RIGHT |
AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER |
AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER |
AUDIO_CHANNEL_OUT_BACK_CENTER |
AUDIO_CHANNEL_OUT_SIDE_LEFT |
AUDIO_CHANNEL_OUT_SIDE_RIGHT |
AUDIO_CHANNEL_OUT_TOP_CENTER |
AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT |
AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER |
AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT |
AUDIO_CHANNEL_OUT_TOP_BACK_LEFT |
AUDIO_CHANNEL_OUT_TOP_BACK_CENTER |
AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT |
AUDIO_CHANNEL_OUT_TOP_SIDE_LEFT |
AUDIO_CHANNEL_OUT_TOP_SIDE_RIGHT,
AUDIO_CHANNEL_IN_ALL = AUDIO_CHANNEL_IN_LEFT |
AUDIO_CHANNEL_IN_RIGHT |
AUDIO_CHANNEL_IN_FRONT |
AUDIO_CHANNEL_IN_BACK|
AUDIO_CHANNEL_IN_LEFT_PROCESSED |
AUDIO_CHANNEL_IN_RIGHT_PROCESSED |
AUDIO_CHANNEL_IN_FRONT_PROCESSED |
AUDIO_CHANNEL_IN_BACK_PROCESSED|
AUDIO_CHANNEL_IN_PRESSURE |
AUDIO_CHANNEL_IN_X_AXIS |
AUDIO_CHANNEL_IN_Y_AXIS |
AUDIO_CHANNEL_IN_Z_AXIS |
AUDIO_CHANNEL_IN_VOICE_UPLINK |
AUDIO_CHANNEL_IN_VOICE_DNLINK |
AUDIO_CHANNEL_IN_BACK_LEFT |
AUDIO_CHANNEL_IN_BACK_RIGHT |
AUDIO_CHANNEL_IN_CENTER |
AUDIO_CHANNEL_IN_LOW_FREQUENCY |
AUDIO_CHANNEL_IN_TOP_LEFT |
AUDIO_CHANNEL_IN_TOP_RIGHT,
AUDIO_DEVICE_OUT_ALL = AUDIO_DEVICE_OUT_EARPIECE |
AUDIO_DEVICE_OUT_SPEAKER |
AUDIO_DEVICE_OUT_WIRED_HEADSET |
AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
AUDIO_DEVICE_OUT_BLUETOOTH_SCO |
AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET |
AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT |
AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER |
AUDIO_DEVICE_OUT_HDMI |
AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET |
AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET |
AUDIO_DEVICE_OUT_USB_ACCESSORY |
AUDIO_DEVICE_OUT_USB_DEVICE |
AUDIO_DEVICE_OUT_REMOTE_SUBMIX |
AUDIO_DEVICE_OUT_TELEPHONY_TX |
AUDIO_DEVICE_OUT_LINE |
AUDIO_DEVICE_OUT_HDMI_ARC |
AUDIO_DEVICE_OUT_SPDIF |
AUDIO_DEVICE_OUT_FM |
AUDIO_DEVICE_OUT_AUX_LINE |
AUDIO_DEVICE_OUT_SPEAKER_SAFE |
AUDIO_DEVICE_OUT_IP |
AUDIO_DEVICE_OUT_BUS |
AUDIO_DEVICE_OUT_PROXY |
AUDIO_DEVICE_OUT_USB_HEADSET |
AUDIO_DEVICE_OUT_HEARING_AID |
AUDIO_DEVICE_OUT_ECHO_CANCELLER |
AUDIO_DEVICE_OUT_DEFAULT,
AUDIO_DEVICE_OUT_ALL_A2DP = AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER,
AUDIO_DEVICE_OUT_ALL_SCO = AUDIO_DEVICE_OUT_BLUETOOTH_SCO |
AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET |
AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT,
AUDIO_DEVICE_OUT_ALL_USB = AUDIO_DEVICE_OUT_USB_ACCESSORY |
AUDIO_DEVICE_OUT_USB_DEVICE |
AUDIO_DEVICE_OUT_USB_HEADSET,
AUDIO_DEVICE_IN_ALL = AUDIO_DEVICE_IN_COMMUNICATION |
AUDIO_DEVICE_IN_AMBIENT |
AUDIO_DEVICE_IN_BUILTIN_MIC |
AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET |
AUDIO_DEVICE_IN_WIRED_HEADSET |
AUDIO_DEVICE_IN_HDMI |
AUDIO_DEVICE_IN_TELEPHONY_RX |
AUDIO_DEVICE_IN_BACK_MIC |
AUDIO_DEVICE_IN_REMOTE_SUBMIX |
AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET |
AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET |
AUDIO_DEVICE_IN_USB_ACCESSORY |
AUDIO_DEVICE_IN_USB_DEVICE |
AUDIO_DEVICE_IN_FM_TUNER |
AUDIO_DEVICE_IN_TV_TUNER |
AUDIO_DEVICE_IN_LINE |
AUDIO_DEVICE_IN_SPDIF |
AUDIO_DEVICE_IN_BLUETOOTH_A2DP |
AUDIO_DEVICE_IN_LOOPBACK |
AUDIO_DEVICE_IN_IP |
AUDIO_DEVICE_IN_BUS |
AUDIO_DEVICE_IN_PROXY |
AUDIO_DEVICE_IN_USB_HEADSET |
AUDIO_DEVICE_IN_BLUETOOTH_BLE |
AUDIO_DEVICE_IN_DEFAULT,
AUDIO_DEVICE_IN_ALL_SCO = AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET,
AUDIO_DEVICE_IN_ALL_USB = AUDIO_DEVICE_IN_USB_ACCESSORY |
AUDIO_DEVICE_IN_USB_DEVICE |
AUDIO_DEVICE_IN_USB_HEADSET,
AUDIO_USAGE_MAX = AUDIO_USAGE_ASSISTANT,
AUDIO_USAGE_CNT = AUDIO_USAGE_ASSISTANT + 1,
AUDIO_PORT_CONFIG_ALL = AUDIO_PORT_CONFIG_SAMPLE_RATE |
AUDIO_PORT_CONFIG_CHANNEL_MASK |
AUDIO_PORT_CONFIG_FORMAT |
AUDIO_PORT_CONFIG_GAIN,
}; // enum
#endif // ANDROID_AUDIO_BASE_UTILS_H

450
include/hardware/system/audio-base.h Normal file
View File

@ -0,0 +1,450 @@
// This file is autogenerated by hidl-gen
// then manualy edited for retrocompatiblity
// Source: android.hardware.audio.common@4.0
// Root: android.hardware:hardware/interfaces
#ifndef HIDL_GENERATED_ANDROID_HARDWARE_AUDIO_COMMON_V4_0_EXPORTED_CONSTANTS_H_
#define HIDL_GENERATED_ANDROID_HARDWARE_AUDIO_COMMON_V4_0_EXPORTED_CONSTANTS_H_
#ifdef __cplusplus
extern "C" {
#endif
enum {
AUDIO_IO_HANDLE_NONE = 0,
AUDIO_MODULE_HANDLE_NONE = 0,
AUDIO_PORT_HANDLE_NONE = 0,
AUDIO_PATCH_HANDLE_NONE = 0,
};
typedef enum {
AUDIO_STREAM_DEFAULT = -1, // (-1)
AUDIO_STREAM_MIN = 0,
AUDIO_STREAM_VOICE_CALL = 0,
AUDIO_STREAM_SYSTEM = 1,
AUDIO_STREAM_RING = 2,
AUDIO_STREAM_MUSIC = 3,
AUDIO_STREAM_ALARM = 4,
AUDIO_STREAM_NOTIFICATION = 5,
AUDIO_STREAM_BLUETOOTH_SCO = 6,
AUDIO_STREAM_ENFORCED_AUDIBLE = 7,
AUDIO_STREAM_DTMF = 8,
AUDIO_STREAM_TTS = 9,
AUDIO_STREAM_ACCESSIBILITY = 10,
#ifndef AUDIO_NO_SYSTEM_DECLARATIONS
/** For dynamic policy output mixes. Only used by the audio policy */
AUDIO_STREAM_REROUTING = 11,
/** For audio flinger tracks volume. Only used by the audioflinger */
AUDIO_STREAM_PATCH = 12,
#endif // AUDIO_NO_SYSTEM_DECLARATIONS
} audio_stream_type_t;
typedef enum {
AUDIO_SOURCE_DEFAULT = 0,
AUDIO_SOURCE_MIC = 1,
AUDIO_SOURCE_VOICE_UPLINK = 2,
AUDIO_SOURCE_VOICE_DOWNLINK = 3,
AUDIO_SOURCE_VOICE_CALL = 4,
AUDIO_SOURCE_CAMCORDER = 5,
AUDIO_SOURCE_VOICE_RECOGNITION = 6,
AUDIO_SOURCE_VOICE_COMMUNICATION = 7,
AUDIO_SOURCE_REMOTE_SUBMIX = 8,
AUDIO_SOURCE_UNPROCESSED = 9,
AUDIO_SOURCE_FM_TUNER = 1998,
#ifndef AUDIO_NO_SYSTEM_DECLARATIONS
/**
* A low-priority, preemptible audio source for for background software
* hotword detection. Same tuning as VOICE_RECOGNITION.
* Used only internally by the framework.
*/
AUDIO_SOURCE_HOTWORD = 1999,
#endif // AUDIO_NO_SYSTEM_DECLARATIONS
} audio_source_t;
typedef enum {
AUDIO_SESSION_OUTPUT_STAGE = -1, // (-1)
AUDIO_SESSION_OUTPUT_MIX = 0,
AUDIO_SESSION_ALLOCATE = 0,
AUDIO_SESSION_NONE = 0,
} audio_session_t;
typedef enum {
AUDIO_FORMAT_INVALID = 0xFFFFFFFFu,
AUDIO_FORMAT_DEFAULT = 0,
AUDIO_FORMAT_PCM = 0x00000000u,
AUDIO_FORMAT_MP3 = 0x01000000u,
AUDIO_FORMAT_AMR_NB = 0x02000000u,
AUDIO_FORMAT_AMR_WB = 0x03000000u,
AUDIO_FORMAT_AAC = 0x04000000u,
AUDIO_FORMAT_HE_AAC_V1 = 0x05000000u,
AUDIO_FORMAT_HE_AAC_V2 = 0x06000000u,
AUDIO_FORMAT_VORBIS = 0x07000000u,
AUDIO_FORMAT_OPUS = 0x08000000u,
AUDIO_FORMAT_AC3 = 0x09000000u,
AUDIO_FORMAT_E_AC3 = 0x0A000000u,
AUDIO_FORMAT_DTS = 0x0B000000u,
AUDIO_FORMAT_DTS_HD = 0x0C000000u,
AUDIO_FORMAT_IEC61937 = 0x0D000000u,
AUDIO_FORMAT_DOLBY_TRUEHD = 0x0E000000u,
AUDIO_FORMAT_EVRC = 0x10000000u,
AUDIO_FORMAT_EVRCB = 0x11000000u,
AUDIO_FORMAT_EVRCWB = 0x12000000u,
AUDIO_FORMAT_EVRCNW = 0x13000000u,
AUDIO_FORMAT_AAC_ADIF = 0x14000000u,
AUDIO_FORMAT_WMA = 0x15000000u,
AUDIO_FORMAT_WMA_PRO = 0x16000000u,
AUDIO_FORMAT_AMR_WB_PLUS = 0x17000000u,
AUDIO_FORMAT_MP2 = 0x18000000u,
AUDIO_FORMAT_QCELP = 0x19000000u,
AUDIO_FORMAT_DSD = 0x1A000000u,
AUDIO_FORMAT_FLAC = 0x1B000000u,
AUDIO_FORMAT_ALAC = 0x1C000000u,
AUDIO_FORMAT_APE = 0x1D000000u,
AUDIO_FORMAT_AAC_ADTS = 0x1E000000u,
AUDIO_FORMAT_SBC = 0x1F000000u,
AUDIO_FORMAT_APTX = 0x20000000u,
AUDIO_FORMAT_APTX_HD = 0x21000000u,
AUDIO_FORMAT_AC4 = 0x22000000u,
AUDIO_FORMAT_LDAC = 0x23000000u,
AUDIO_FORMAT_MAT = 0x24000000u,
AUDIO_FORMAT_MAIN_MASK = 0xFF000000u,
AUDIO_FORMAT_SUB_MASK = 0x00FFFFFFu,
/* Subformats */
AUDIO_FORMAT_PCM_SUB_16_BIT = 0x1u,
AUDIO_FORMAT_PCM_SUB_8_BIT = 0x2u,
AUDIO_FORMAT_PCM_SUB_32_BIT = 0x3u,
AUDIO_FORMAT_PCM_SUB_8_24_BIT = 0x4u,
AUDIO_FORMAT_PCM_SUB_FLOAT = 0x5u,
AUDIO_FORMAT_PCM_SUB_24_BIT_PACKED = 0x6u,
AUDIO_FORMAT_MP3_SUB_NONE = 0x0u,
AUDIO_FORMAT_AMR_SUB_NONE = 0x0u,
AUDIO_FORMAT_AAC_SUB_MAIN = 0x1u,
AUDIO_FORMAT_AAC_SUB_LC = 0x2u,
AUDIO_FORMAT_AAC_SUB_SSR = 0x4u,
AUDIO_FORMAT_AAC_SUB_LTP = 0x8u,
AUDIO_FORMAT_AAC_SUB_HE_V1 = 0x10u,
AUDIO_FORMAT_AAC_SUB_SCALABLE = 0x20u,
AUDIO_FORMAT_AAC_SUB_ERLC = 0x40u,
AUDIO_FORMAT_AAC_SUB_LD = 0x80u,
AUDIO_FORMAT_AAC_SUB_HE_V2 = 0x100u,
AUDIO_FORMAT_AAC_SUB_ELD = 0x200u,
AUDIO_FORMAT_AAC_SUB_XHE = 0x300u,
AUDIO_FORMAT_VORBIS_SUB_NONE = 0x0u,
AUDIO_FORMAT_E_AC3_SUB_JOC = 0x1u,
AUDIO_FORMAT_MAT_SUB_1_0 = 0x1u,
AUDIO_FORMAT_MAT_SUB_2_0 = 0x2u,
AUDIO_FORMAT_MAT_SUB_2_1 = 0x3u,
/* Aliases */
AUDIO_FORMAT_PCM_16_BIT = 0x1u, // (PCM | PCM_SUB_16_BIT)
AUDIO_FORMAT_PCM_8_BIT = 0x2u, // (PCM | PCM_SUB_8_BIT)
AUDIO_FORMAT_PCM_32_BIT = 0x3u, // (PCM | PCM_SUB_32_BIT)
AUDIO_FORMAT_PCM_8_24_BIT = 0x4u, // (PCM | PCM_SUB_8_24_BIT)
AUDIO_FORMAT_PCM_FLOAT = 0x5u, // (PCM | PCM_SUB_FLOAT)
AUDIO_FORMAT_PCM_24_BIT_PACKED = 0x6u, // (PCM | PCM_SUB_24_BIT_PACKED)
AUDIO_FORMAT_AAC_MAIN = 0x4000001u, // (AAC | AAC_SUB_MAIN)
AUDIO_FORMAT_AAC_LC = 0x4000002u, // (AAC | AAC_SUB_LC)
AUDIO_FORMAT_AAC_SSR = 0x4000004u, // (AAC | AAC_SUB_SSR)
AUDIO_FORMAT_AAC_LTP = 0x4000008u, // (AAC | AAC_SUB_LTP)
AUDIO_FORMAT_AAC_HE_V1 = 0x4000010u, // (AAC | AAC_SUB_HE_V1)
AUDIO_FORMAT_AAC_SCALABLE = 0x4000020u, // (AAC | AAC_SUB_SCALABLE)
AUDIO_FORMAT_AAC_ERLC = 0x4000040u, // (AAC | AAC_SUB_ERLC)
AUDIO_FORMAT_AAC_LD = 0x4000080u, // (AAC | AAC_SUB_LD)
AUDIO_FORMAT_AAC_HE_V2 = 0x4000100u, // (AAC | AAC_SUB_HE_V2)
AUDIO_FORMAT_AAC_ELD = 0x4000200u, // (AAC | AAC_SUB_ELD)
AUDIO_FORMAT_AAC_XHE = 0x4000300u, // (AAC | AAC_SUB_XHE)
AUDIO_FORMAT_AAC_ADTS_MAIN = 0x1e000001u, // (AAC_ADTS | AAC_SUB_MAIN)
AUDIO_FORMAT_AAC_ADTS_LC = 0x1e000002u, // (AAC_ADTS | AAC_SUB_LC)
AUDIO_FORMAT_AAC_ADTS_SSR = 0x1e000004u, // (AAC_ADTS | AAC_SUB_SSR)
AUDIO_FORMAT_AAC_ADTS_LTP = 0x1e000008u, // (AAC_ADTS | AAC_SUB_LTP)
AUDIO_FORMAT_AAC_ADTS_HE_V1 = 0x1e000010u, // (AAC_ADTS | AAC_SUB_HE_V1)
AUDIO_FORMAT_AAC_ADTS_SCALABLE = 0x1e000020u, // (AAC_ADTS | AAC_SUB_SCALABLE)
AUDIO_FORMAT_AAC_ADTS_ERLC = 0x1e000040u, // (AAC_ADTS | AAC_SUB_ERLC)
AUDIO_FORMAT_AAC_ADTS_LD = 0x1e000080u, // (AAC_ADTS | AAC_SUB_LD)
AUDIO_FORMAT_AAC_ADTS_HE_V2 = 0x1e000100u, // (AAC_ADTS | AAC_SUB_HE_V2)
AUDIO_FORMAT_AAC_ADTS_ELD = 0x1e000200u, // (AAC_ADTS | AAC_SUB_ELD)
AUDIO_FORMAT_AAC_ADTS_XHE = 0x1e000300u, // (AAC_ADTS | AAC_SUB_XHE)
AUDIO_FORMAT_E_AC3_JOC = 0xA000001u, // (E_AC3 | E_AC3_SUB_JOC)
AUDIO_FORMAT_MAT_1_0 = 0x24000001u, // (MAT | MAT_SUB_1_0)
AUDIO_FORMAT_MAT_2_0 = 0x24000002u, // (MAT | MAT_SUB_2_0)
AUDIO_FORMAT_MAT_2_1 = 0x24000003u, // (MAT | MAT_SUB_2_1)
} audio_format_t;
enum {
FCC_2 = 2,
FCC_8 = 8,
};
enum {
AUDIO_CHANNEL_REPRESENTATION_POSITION = 0x0u,
AUDIO_CHANNEL_REPRESENTATION_INDEX = 0x2u,
AUDIO_CHANNEL_NONE = 0x0u,
AUDIO_CHANNEL_INVALID = 0xC0000000u,
AUDIO_CHANNEL_OUT_FRONT_LEFT = 0x1u,
AUDIO_CHANNEL_OUT_FRONT_RIGHT = 0x2u,
AUDIO_CHANNEL_OUT_FRONT_CENTER = 0x4u,
AUDIO_CHANNEL_OUT_LOW_FREQUENCY = 0x8u,
AUDIO_CHANNEL_OUT_BACK_LEFT = 0x10u,
AUDIO_CHANNEL_OUT_BACK_RIGHT = 0x20u,
AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER = 0x40u,
AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = 0x80u,
AUDIO_CHANNEL_OUT_BACK_CENTER = 0x100u,
AUDIO_CHANNEL_OUT_SIDE_LEFT = 0x200u,
AUDIO_CHANNEL_OUT_SIDE_RIGHT = 0x400u,
AUDIO_CHANNEL_OUT_TOP_CENTER = 0x800u,
AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT = 0x1000u,
AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER = 0x2000u,
AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT = 0x4000u,
AUDIO_CHANNEL_OUT_TOP_BACK_LEFT = 0x8000u,
AUDIO_CHANNEL_OUT_TOP_BACK_CENTER = 0x10000u,
AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT = 0x20000u,
AUDIO_CHANNEL_OUT_TOP_SIDE_LEFT = 0x40000u,
AUDIO_CHANNEL_OUT_TOP_SIDE_RIGHT = 0x80000u,
AUDIO_CHANNEL_OUT_MONO = 0x1u, // OUT_FRONT_LEFT
AUDIO_CHANNEL_OUT_STEREO = 0x3u, // OUT_FRONT_LEFT | OUT_FRONT_RIGHT
AUDIO_CHANNEL_OUT_2POINT1 = 0xBu, // OUT_FRONT_LEFT | OUT_FRONT_RIGHT | OUT_LOW_FREQUENCY
AUDIO_CHANNEL_OUT_2POINT0POINT2 = 0xC0003u, // OUT_FRONT_LEFT | OUT_FRONT_RIGHT | OUT_TOP_SIDE_LEFT | OUT_TOP_SIDE_RIGHT
AUDIO_CHANNEL_OUT_2POINT1POINT2 = 0xC000Bu, // OUT_FRONT_LEFT | OUT_FRONT_RIGHT | OUT_TOP_SIDE_LEFT | OUT_TOP_SIDE_RIGHT | OUT_LOW_FREQUENCY
AUDIO_CHANNEL_OUT_3POINT0POINT2 = 0xC0007u, // OUT_FRONT_LEFT | OUT_FRONT_CENTER | OUT_FRONT_RIGHT | OUT_TOP_SIDE_LEFT | OUT_TOP_SIDE_RIGHT
AUDIO_CHANNEL_OUT_3POINT1POINT2 = 0xC000Fu, // OUT_FRONT_LEFT | OUT_FRONT_CENTER | OUT_FRONT_RIGHT | OUT_TOP_SIDE_LEFT | OUT_TOP_SIDE_RIGHT | OUT_LOW_FREQUENCY
AUDIO_CHANNEL_OUT_QUAD = 0x33u, // OUT_FRONT_LEFT | OUT_FRONT_RIGHT | OUT_BACK_LEFT | OUT_BACK_RIGHT
AUDIO_CHANNEL_OUT_QUAD_BACK = 0x33u, // OUT_QUAD
AUDIO_CHANNEL_OUT_QUAD_SIDE = 0x603u, // OUT_FRONT_LEFT | OUT_FRONT_RIGHT | OUT_SIDE_LEFT | OUT_SIDE_RIGHT
AUDIO_CHANNEL_OUT_SURROUND = 0x107u, // OUT_FRONT_LEFT | OUT_FRONT_RIGHT | OUT_FRONT_CENTER | OUT_BACK_CENTER
AUDIO_CHANNEL_OUT_PENTA = 0x37u, // OUT_QUAD | OUT_FRONT_CENTER
AUDIO_CHANNEL_OUT_5POINT1 = 0x3Fu, // OUT_FRONT_LEFT | OUT_FRONT_RIGHT | OUT_FRONT_CENTER | OUT_LOW_FREQUENCY | OUT_BACK_LEFT | OUT_BACK_RIGHT
AUDIO_CHANNEL_OUT_5POINT1_BACK = 0x3Fu, // OUT_5POINT1
AUDIO_CHANNEL_OUT_5POINT1_SIDE = 0x60Fu, // OUT_FRONT_LEFT | OUT_FRONT_RIGHT | OUT_FRONT_CENTER | OUT_LOW_FREQUENCY | OUT_SIDE_LEFT | OUT_SIDE_RIGHT
AUDIO_CHANNEL_OUT_5POINT1POINT2 = 0xC003Fu, // OUT_5POINT1 | OUT_TOP_SIDE_LEFT | OUT_TOP_SIDE_RIGHT
AUDIO_CHANNEL_OUT_5POINT1POINT4 = 0x2D03Fu, // OUT_5POINT1 | OUT_TOP_FRONT_LEFT | OUT_TOP_FRONT_RIGHT | OUT_TOP_BACK_LEFT | OUT_TOP_BACK_RIGHT
AUDIO_CHANNEL_OUT_6POINT1 = 0x13Fu, // OUT_FRONT_LEFT | OUT_FRONT_RIGHT | OUT_FRONT_CENTER | OUT_LOW_FREQUENCY | OUT_BACK_LEFT | OUT_BACK_RIGHT | OUT_BACK_CENTER
AUDIO_CHANNEL_OUT_7POINT1 = 0x63Fu, // OUT_FRONT_LEFT | OUT_FRONT_RIGHT | OUT_FRONT_CENTER | OUT_LOW_FREQUENCY | OUT_BACK_LEFT | OUT_BACK_RIGHT | OUT_SIDE_LEFT | OUT_SIDE_RIGHT
AUDIO_CHANNEL_OUT_7POINT1POINT2 = 0xC063Fu, // OUT_7POINT1 | OUT_TOP_SIDE_LEFT | OUT_TOP_SIDE_RIGHT
AUDIO_CHANNEL_OUT_7POINT1POINT4 = 0x2D63Fu, // OUT_7POINT1 | OUT_TOP_FRONT_LEFT | OUT_TOP_FRONT_RIGHT | OUT_TOP_BACK_LEFT | OUT_TOP_BACK_RIGHT
AUDIO_CHANNEL_IN_LEFT = 0x4u,
AUDIO_CHANNEL_IN_RIGHT = 0x8u,
AUDIO_CHANNEL_IN_FRONT = 0x10u,
AUDIO_CHANNEL_IN_BACK = 0x20u,
AUDIO_CHANNEL_IN_LEFT_PROCESSED = 0x40u,
AUDIO_CHANNEL_IN_RIGHT_PROCESSED = 0x80u,
AUDIO_CHANNEL_IN_FRONT_PROCESSED = 0x100u,
AUDIO_CHANNEL_IN_BACK_PROCESSED = 0x200u,
AUDIO_CHANNEL_IN_PRESSURE = 0x400u,
AUDIO_CHANNEL_IN_X_AXIS = 0x800u,
AUDIO_CHANNEL_IN_Y_AXIS = 0x1000u,
AUDIO_CHANNEL_IN_Z_AXIS = 0x2000u,
AUDIO_CHANNEL_IN_BACK_LEFT = 0x10000u,
AUDIO_CHANNEL_IN_BACK_RIGHT = 0x20000u,
AUDIO_CHANNEL_IN_CENTER = 0x40000u,
AUDIO_CHANNEL_IN_LOW_FREQUENCY = 0x100000u,
AUDIO_CHANNEL_IN_TOP_LEFT = 0x200000u,
AUDIO_CHANNEL_IN_TOP_RIGHT = 0x400000u,
AUDIO_CHANNEL_IN_VOICE_UPLINK = 0x4000u,
AUDIO_CHANNEL_IN_VOICE_DNLINK = 0x8000u,
AUDIO_CHANNEL_IN_MONO = 0x10u, // IN_FRONT
AUDIO_CHANNEL_IN_STEREO = 0xCu, // IN_LEFT | IN_RIGHT
AUDIO_CHANNEL_IN_FRONT_BACK = 0x30u, // IN_FRONT | IN_BACK
AUDIO_CHANNEL_IN_6 = 0xFCu, // IN_LEFT | IN_RIGHT | IN_FRONT | IN_BACK | IN_LEFT_PROCESSED | IN_RIGHT_PROCESSED
AUDIO_CHANNEL_IN_2POINT0POINT2 = 0x60000Cu, // IN_LEFT | IN_RIGHT | IN_TOP_LEFT | IN_TOP_RIGHT
AUDIO_CHANNEL_IN_2POINT1POINT2 = 0x70000Cu, // IN_LEFT | IN_RIGHT | IN_TOP_LEFT | IN_TOP_RIGHT | IN_LOW_FREQUENCY
AUDIO_CHANNEL_IN_3POINT0POINT2 = 0x64000Cu, // IN_LEFT | IN_CENTER | IN_RIGHT | IN_TOP_LEFT | IN_TOP_RIGHT
AUDIO_CHANNEL_IN_3POINT1POINT2 = 0x74000Cu, // IN_LEFT | IN_CENTER | IN_RIGHT | IN_TOP_LEFT | IN_TOP_RIGHT | IN_LOW_FREQUENCY
AUDIO_CHANNEL_IN_5POINT1 = 0x17000Cu, // IN_LEFT | IN_CENTER | IN_RIGHT | IN_BACK_LEFT | IN_BACK_RIGHT | IN_LOW_FREQUENCY
AUDIO_CHANNEL_IN_VOICE_UPLINK_MONO = 0x4010u, // IN_VOICE_UPLINK | IN_MONO
AUDIO_CHANNEL_IN_VOICE_DNLINK_MONO = 0x8010u, // IN_VOICE_DNLINK | IN_MONO
AUDIO_CHANNEL_IN_VOICE_CALL_MONO = 0xC010u, // IN_VOICE_UPLINK_MONO | IN_VOICE_DNLINK_MONO
AUDIO_CHANNEL_COUNT_MAX = 30u,
AUDIO_CHANNEL_INDEX_HDR = 0x80000000u, // REPRESENTATION_INDEX << COUNT_MAX
AUDIO_CHANNEL_INDEX_MASK_1 = 0x80000001u, // INDEX_HDR | (1 << 1) - 1
AUDIO_CHANNEL_INDEX_MASK_2 = 0x80000003u, // INDEX_HDR | (1 << 2) - 1
AUDIO_CHANNEL_INDEX_MASK_3 = 0x80000007u, // INDEX_HDR | (1 << 3) - 1
AUDIO_CHANNEL_INDEX_MASK_4 = 0x8000000Fu, // INDEX_HDR | (1 << 4) - 1
AUDIO_CHANNEL_INDEX_MASK_5 = 0x8000001Fu, // INDEX_HDR | (1 << 5) - 1
AUDIO_CHANNEL_INDEX_MASK_6 = 0x8000003Fu, // INDEX_HDR | (1 << 6) - 1
AUDIO_CHANNEL_INDEX_MASK_7 = 0x8000007Fu, // INDEX_HDR | (1 << 7) - 1
AUDIO_CHANNEL_INDEX_MASK_8 = 0x800000FFu, // INDEX_HDR | (1 << 8) - 1
};
typedef enum {
#ifndef AUDIO_NO_SYSTEM_DECLARATIONS
AUDIO_MODE_INVALID = -2, // (-2)
AUDIO_MODE_CURRENT = -1, // (-1)
#endif // AUDIO_NO_SYSTEM_DECLARATIONS
AUDIO_MODE_NORMAL = 0,
AUDIO_MODE_RINGTONE = 1,
AUDIO_MODE_IN_CALL = 2,
AUDIO_MODE_IN_COMMUNICATION = 3,
} audio_mode_t;
enum {
AUDIO_DEVICE_NONE = 0x0u,
AUDIO_DEVICE_BIT_IN = 0x80000000u,
AUDIO_DEVICE_BIT_DEFAULT = 0x40000000u,
AUDIO_DEVICE_OUT_EARPIECE = 0x1u,
AUDIO_DEVICE_OUT_SPEAKER = 0x2u,
AUDIO_DEVICE_OUT_WIRED_HEADSET = 0x4u,
AUDIO_DEVICE_OUT_WIRED_HEADPHONE = 0x8u,
AUDIO_DEVICE_OUT_BLUETOOTH_SCO = 0x10u,
AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20u,
AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT = 0x40u,
AUDIO_DEVICE_OUT_BLUETOOTH_A2DP = 0x80u,
AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100u,
AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200u,
AUDIO_DEVICE_OUT_AUX_DIGITAL = 0x400u,
AUDIO_DEVICE_OUT_HDMI = 0x400u, // OUT_AUX_DIGITAL
AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET = 0x800u,
AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET = 0x1000u,
AUDIO_DEVICE_OUT_USB_ACCESSORY = 0x2000u,
AUDIO_DEVICE_OUT_USB_DEVICE = 0x4000u,
AUDIO_DEVICE_OUT_REMOTE_SUBMIX = 0x8000u,
AUDIO_DEVICE_OUT_TELEPHONY_TX = 0x10000u,
AUDIO_DEVICE_OUT_LINE = 0x20000u,
AUDIO_DEVICE_OUT_HDMI_ARC = 0x40000u,
AUDIO_DEVICE_OUT_SPDIF = 0x80000u,
AUDIO_DEVICE_OUT_FM = 0x100000u,
AUDIO_DEVICE_OUT_AUX_LINE = 0x200000u,
AUDIO_DEVICE_OUT_SPEAKER_SAFE = 0x400000u,
AUDIO_DEVICE_OUT_IP = 0x800000u,
AUDIO_DEVICE_OUT_BUS = 0x1000000u,
AUDIO_DEVICE_OUT_PROXY = 0x2000000u,
AUDIO_DEVICE_OUT_USB_HEADSET = 0x4000000u,
AUDIO_DEVICE_OUT_HEARING_AID = 0x8000000u,
AUDIO_DEVICE_OUT_ECHO_CANCELLER = 0x10000000u,
AUDIO_DEVICE_OUT_DEFAULT = 0x40000000u, // BIT_DEFAULT
AUDIO_DEVICE_IN_COMMUNICATION = 0x80000001u, // BIT_IN | 0x1
AUDIO_DEVICE_IN_AMBIENT = 0x80000002u, // BIT_IN | 0x2
AUDIO_DEVICE_IN_BUILTIN_MIC = 0x80000004u, // BIT_IN | 0x4
AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET = 0x80000008u, // BIT_IN | 0x8
AUDIO_DEVICE_IN_WIRED_HEADSET = 0x80000010u, // BIT_IN | 0x10
AUDIO_DEVICE_IN_AUX_DIGITAL = 0x80000020u, // BIT_IN | 0x20
AUDIO_DEVICE_IN_HDMI = 0x80000020u, // IN_AUX_DIGITAL
AUDIO_DEVICE_IN_VOICE_CALL = 0x80000040u, // BIT_IN | 0x40
AUDIO_DEVICE_IN_TELEPHONY_RX = 0x80000040u, // IN_VOICE_CALL
AUDIO_DEVICE_IN_BACK_MIC = 0x80000080u, // BIT_IN | 0x80
AUDIO_DEVICE_IN_REMOTE_SUBMIX = 0x80000100u, // BIT_IN | 0x100
AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET = 0x80000200u, // BIT_IN | 0x200
AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET = 0x80000400u, // BIT_IN | 0x400
AUDIO_DEVICE_IN_USB_ACCESSORY = 0x80000800u, // BIT_IN | 0x800
AUDIO_DEVICE_IN_USB_DEVICE = 0x80001000u, // BIT_IN | 0x1000
AUDIO_DEVICE_IN_FM_TUNER = 0x80002000u, // BIT_IN | 0x2000
AUDIO_DEVICE_IN_TV_TUNER = 0x80004000u, // BIT_IN | 0x4000
AUDIO_DEVICE_IN_LINE = 0x80008000u, // BIT_IN | 0x8000
AUDIO_DEVICE_IN_SPDIF = 0x80010000u, // BIT_IN | 0x10000
AUDIO_DEVICE_IN_BLUETOOTH_A2DP = 0x80020000u, // BIT_IN | 0x20000
AUDIO_DEVICE_IN_LOOPBACK = 0x80040000u, // BIT_IN | 0x40000
AUDIO_DEVICE_IN_IP = 0x80080000u, // BIT_IN | 0x80000
AUDIO_DEVICE_IN_BUS = 0x80100000u, // BIT_IN | 0x100000
AUDIO_DEVICE_IN_PROXY = 0x81000000u, // BIT_IN | 0x1000000
AUDIO_DEVICE_IN_USB_HEADSET = 0x82000000u, // BIT_IN | 0x2000000
AUDIO_DEVICE_IN_BLUETOOTH_BLE = 0x84000000u, // BIT_IN | 0x4000000
AUDIO_DEVICE_IN_DEFAULT = 0xC0000000u, // BIT_IN | BIT_DEFAULT
};
typedef enum {
AUDIO_OUTPUT_FLAG_NONE = 0x0,
AUDIO_OUTPUT_FLAG_DIRECT = 0x1,
AUDIO_OUTPUT_FLAG_PRIMARY = 0x2,
AUDIO_OUTPUT_FLAG_FAST = 0x4,
AUDIO_OUTPUT_FLAG_DEEP_BUFFER = 0x8,
AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD = 0x10,
AUDIO_OUTPUT_FLAG_NON_BLOCKING = 0x20,
AUDIO_OUTPUT_FLAG_HW_AV_SYNC = 0x40,
AUDIO_OUTPUT_FLAG_TTS = 0x80,
AUDIO_OUTPUT_FLAG_RAW = 0x100,
AUDIO_OUTPUT_FLAG_SYNC = 0x200,
AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO = 0x400,
AUDIO_OUTPUT_FLAG_DIRECT_PCM = 0x2000,
AUDIO_OUTPUT_FLAG_MMAP_NOIRQ = 0x4000,
AUDIO_OUTPUT_FLAG_VOIP_RX = 0x8000,
AUDIO_OUTPUT_FLAG_INCALL_MUSIC = 0x10000,
} audio_output_flags_t;
typedef enum {
AUDIO_INPUT_FLAG_NONE = 0x0,
AUDIO_INPUT_FLAG_FAST = 0x1,
AUDIO_INPUT_FLAG_HW_HOTWORD = 0x2,
AUDIO_INPUT_FLAG_RAW = 0x4,
AUDIO_INPUT_FLAG_SYNC = 0x8,
AUDIO_INPUT_FLAG_MMAP_NOIRQ = 0x10,
AUDIO_INPUT_FLAG_VOIP_TX = 0x20,
AUDIO_INPUT_FLAG_HW_AV_SYNC = 0x40,
} audio_input_flags_t;
typedef enum {
AUDIO_USAGE_UNKNOWN = 0,
AUDIO_USAGE_MEDIA = 1,
AUDIO_USAGE_VOICE_COMMUNICATION = 2,
AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING = 3,
AUDIO_USAGE_ALARM = 4,
AUDIO_USAGE_NOTIFICATION = 5,
AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE = 6,
#ifndef AUDIO_NO_SYSTEM_DECLARATIONS
AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST = 7,
AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT = 8,
AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED = 9,
AUDIO_USAGE_NOTIFICATION_EVENT = 10,
#endif // AUDIO_NO_SYSTEM_DECLARATIONS
AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY = 11,
AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE = 12,
AUDIO_USAGE_ASSISTANCE_SONIFICATION = 13,
AUDIO_USAGE_GAME = 14,
AUDIO_USAGE_VIRTUAL_SOURCE = 15,
AUDIO_USAGE_ASSISTANT = 16,
} audio_usage_t;
typedef enum {
AUDIO_CONTENT_TYPE_UNKNOWN = 0u,
AUDIO_CONTENT_TYPE_SPEECH = 1u,
AUDIO_CONTENT_TYPE_MUSIC = 2u,
AUDIO_CONTENT_TYPE_MOVIE = 3u,
AUDIO_CONTENT_TYPE_SONIFICATION = 4u,
} audio_content_type_t;
enum {
AUDIO_GAIN_MODE_JOINT = 0x1u,
AUDIO_GAIN_MODE_CHANNELS = 0x2u,
AUDIO_GAIN_MODE_RAMP = 0x4u,
};
typedef enum {
AUDIO_PORT_ROLE_NONE = 0,
AUDIO_PORT_ROLE_SOURCE = 1, // (::android::hardware::audio::common::V4_0::AudioPortRole.NONE implicitly + 1)
AUDIO_PORT_ROLE_SINK = 2, // (::android::hardware::audio::common::V4_0::AudioPortRole.SOURCE implicitly + 1)
} audio_port_role_t;
typedef enum {
AUDIO_PORT_TYPE_NONE = 0,
AUDIO_PORT_TYPE_DEVICE = 1, // (::android::hardware::audio::common::V4_0::AudioPortType.NONE implicitly + 1)
AUDIO_PORT_TYPE_MIX = 2, // (::android::hardware::audio::common::V4_0::AudioPortType.DEVICE implicitly + 1)
AUDIO_PORT_TYPE_SESSION = 3, // (::android::hardware::audio::common::V4_0::AudioPortType.MIX implicitly + 1)
} audio_port_type_t;
enum {
AUDIO_PORT_CONFIG_SAMPLE_RATE = 0x1u,
AUDIO_PORT_CONFIG_CHANNEL_MASK = 0x2u,
AUDIO_PORT_CONFIG_FORMAT = 0x4u,
AUDIO_PORT_CONFIG_GAIN = 0x8u,
};
typedef enum {
AUDIO_LATENCY_LOW = 0,
AUDIO_LATENCY_NORMAL = 1, // (::android::hardware::audio::common::V4_0::AudioMixLatencyClass.LOW implicitly + 1)
} audio_mix_latency_class_t;
#ifdef __cplusplus
}
#endif
#endif // HIDL_GENERATED_ANDROID_HARDWARE_AUDIO_COMMON_V4_0_EXPORTED_CONSTANTS_H_

1230
include/hardware/system/audio.h Normal file
View File

File diff suppressed because it is too large Load Diff

108
include/hardware/system/audio_policy.h Normal file
View File

@ -0,0 +1,108 @@
/*
* Copyright (C) 2011 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.
*/
#ifndef ANDROID_AUDIO_POLICY_CORE_H
#define ANDROID_AUDIO_POLICY_CORE_H
#include <stdint.h>
#include <sys/cdefs.h>
#include <sys/types.h>
#include "cutils/bitops.h"
__BEGIN_DECLS
/* The enums were moved here mostly from
* frameworks/base/include/media/AudioSystem.h
*/
/* device categories used for audio_policy->set_force_use() */
typedef enum
{
AUDIO_POLICY_FORCE_NONE,
AUDIO_POLICY_FORCE_SPEAKER,
AUDIO_POLICY_FORCE_HEADPHONES,
AUDIO_POLICY_FORCE_BT_SCO,
AUDIO_POLICY_FORCE_BT_A2DP,
AUDIO_POLICY_FORCE_WIRED_ACCESSORY,
AUDIO_POLICY_FORCE_BT_CAR_DOCK,
AUDIO_POLICY_FORCE_BT_DESK_DOCK,
AUDIO_POLICY_FORCE_ANALOG_DOCK,
AUDIO_POLICY_FORCE_DIGITAL_DOCK,
AUDIO_POLICY_FORCE_NO_BT_A2DP, /* A2DP sink is not preferred to speaker or wired HS */
AUDIO_POLICY_FORCE_SYSTEM_ENFORCED,
AUDIO_POLICY_FORCE_HDMI_SYSTEM_AUDIO_ENFORCED,
AUDIO_POLICY_FORCE_CFG_CNT,
AUDIO_POLICY_FORCE_CFG_MAX = AUDIO_POLICY_FORCE_CFG_CNT - 1,
AUDIO_POLICY_FORCE_DEFAULT = AUDIO_POLICY_FORCE_NONE,
} audio_policy_forced_cfg_t;
/* usages used for audio_policy->set_force_use() */
typedef enum
{
AUDIO_POLICY_FORCE_FOR_COMMUNICATION,
AUDIO_POLICY_FORCE_FOR_MEDIA,
AUDIO_POLICY_FORCE_FOR_RECORD,
AUDIO_POLICY_FORCE_FOR_DOCK,
AUDIO_POLICY_FORCE_FOR_SYSTEM,
AUDIO_POLICY_FORCE_FOR_HDMI_SYSTEM_AUDIO,
AUDIO_POLICY_FORCE_USE_CNT,
AUDIO_POLICY_FORCE_USE_MAX = AUDIO_POLICY_FORCE_USE_CNT - 1,
} audio_policy_force_use_t;
/* device connection states used for audio_policy->set_device_connection_state()
*/
typedef enum
{
AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
AUDIO_POLICY_DEVICE_STATE_CNT,
AUDIO_POLICY_DEVICE_STATE_MAX = AUDIO_POLICY_DEVICE_STATE_CNT - 1,
} audio_policy_dev_state_t;
typedef enum
{
/* Used to generate a tone to notify the user of a
* notification/alarm/ringtone while they are in a call. */
AUDIO_POLICY_TONE_IN_CALL_NOTIFICATION = 0,
AUDIO_POLICY_TONE_CNT,
AUDIO_POLICY_TONE_MAX = AUDIO_POLICY_TONE_CNT - 1,
} audio_policy_tone_t;
static inline bool audio_is_low_visibility(audio_stream_type_t stream)
{
switch (stream)
{
case AUDIO_STREAM_SYSTEM:
case AUDIO_STREAM_NOTIFICATION:
case AUDIO_STREAM_RING:
return true;
default:
return false;
}
}
__END_DECLS
#endif // ANDROID_AUDIO_POLICY_CORE_H

152
include/hardware/system/cutils/atomic.h Normal file
View File

@ -0,0 +1,152 @@
/*
* Copyright (C) 2007 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.
*/
#ifndef ANDROID_CUTILS_ATOMIC_H
#define ANDROID_CUTILS_ATOMIC_H
#include <stdint.h>
#include <sys/types.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* A handful of basic atomic operations.
* THESE ARE HERE FOR LEGACY REASONS ONLY. AVOID.
*
* PREFERRED ALTERNATIVES:
* - Use C++/C/pthread locks/mutexes whenever there is not a
* convincing reason to do otherwise. Note that very clever and
* complicated, but correct, lock-free code is often slower than
* using locks, especially where nontrivial data structures
* are involved.
* - C11 stdatomic.h.
* - Where supported, C++11 std::atomic<T> .
*
* PLEASE STOP READING HERE UNLESS YOU ARE TRYING TO UNDERSTAND
* OR UPDATE OLD CODE.
*
* The "acquire" and "release" terms can be defined intuitively in terms
* of the placement of memory barriers in a simple lock implementation:
* - wait until compare-and-swap(lock-is-free --> lock-is-held) succeeds
* - barrier
* - [do work]
* - barrier
* - store(lock-is-free)
* In very crude terms, the initial (acquire) barrier prevents any of the
* "work" from happening before the lock is held, and the later (release)
* barrier ensures that all of the work happens before the lock is released.
* (Think of cached writes, cache read-ahead, and instruction reordering
* around the CAS and store instructions.)
*
* The barriers must apply to both the compiler and the CPU. Note it is
* legal for instructions that occur before an "acquire" barrier to be
* moved down below it, and for instructions that occur after a "release"
* barrier to be moved up above it.
*
* The ARM-driven implementation we use here is short on subtlety,
* and actually requests a full barrier from the compiler and the CPU.
* The only difference between acquire and release is in whether they
* are issued before or after the atomic operation with which they
* are associated. To ease the transition to C/C++ atomic intrinsics,
* you should not rely on this, and instead assume that only the minimal
* acquire/release protection is provided.
*
* NOTE: all int32_t* values are expected to be aligned on 32-bit boundaries.
* If they are not, atomicity is not guaranteed.
*/
/*
* Basic arithmetic and bitwise operations. These all provide a
* barrier with "release" ordering, and return the previous value.
*
* These have the same characteristics (e.g. what happens on overflow)
* as the equivalent non-atomic C operations.
*/
int32_t android_atomic_inc(volatile int32_t* addr);
int32_t android_atomic_dec(volatile int32_t* addr);
int32_t android_atomic_add(int32_t value, volatile int32_t* addr);
int32_t android_atomic_and(int32_t value, volatile int32_t* addr);
int32_t android_atomic_or(int32_t value, volatile int32_t* addr);
/*
* Perform an atomic load with "acquire" or "release" ordering.
*
* Note that the notion of a "release" ordering for a load does not
* really fit into the C11 or C++11 memory model. The extra ordering
* is normally observable only by code using memory_order_relaxed
* atomics, or data races. In the rare cases in which such ordering
* is called for, use memory_order_relaxed atomics and a leading
* atomic_thread_fence (typically with memory_order_acquire,
* not memory_order_release!) instead. If you do not understand
* this comment, you are in the vast majority, and should not be
* using release loads or replacing them with anything other than
* locks or default sequentially consistent atomics.
*
* This is only necessary if you need the memory barrier. A 32-bit read
* from a 32-bit aligned address is atomic on all supported platforms.
*/
int32_t android_atomic_acquire_load(volatile const int32_t* addr);
int32_t android_atomic_release_load(volatile const int32_t* addr);
/*
* Perform an atomic store with "acquire" or "release" ordering.
*
* Note that the notion of a "acquire" ordering for a store does not
* really fit into the C11 or C++11 memory model. The extra ordering
* is normally observable only by code using memory_order_relaxed
* atomics, or data races. In the rare cases in which such ordering
* is called for, use memory_order_relaxed atomics and a trailing
* atomic_thread_fence (typically with memory_order_release,
* not memory_order_acquire!) instead.
*
* This is only necessary if you need the memory barrier. A 32-bit write
* to a 32-bit aligned address is atomic on all supported platforms.
*/
void android_atomic_acquire_store(int32_t value, volatile int32_t* addr);
void android_atomic_release_store(int32_t value, volatile int32_t* addr);
/*
* Compare-and-set operation with "acquire" or "release" ordering.
*
* This returns zero if the new value was successfully stored, which will
* only happen when *addr == oldvalue.
*
* (The return value is inverted from implementations on other platforms,
* but matches the ARM ldrex/strex result.)
*
* Implementations that use the release CAS in a loop may be less efficient
* than possible, because we re-issue the memory barrier on each iteration.
*/
int android_atomic_acquire_cas(int32_t oldvalue, int32_t newvalue,
volatile int32_t* addr);
int android_atomic_release_cas(int32_t oldvalue, int32_t newvalue,
volatile int32_t* addr);
/*
* Aliases for code using an older version of this header. These are now
* deprecated and should not be used. The definitions will be removed
* in a future release.
*/
#define android_atomic_write android_atomic_release_store
#define android_atomic_cmpxchg android_atomic_release_cas
#ifdef __cplusplus
} // extern "C"
#endif
#endif // ANDROID_CUTILS_ATOMIC_H

120
include/hardware/system/cutils/bitops.h Normal file
View File

@ -0,0 +1,120 @@
/*
* Copyright (C) 2011 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.
*/
#ifndef __CUTILS_BITOPS_H
#define __CUTILS_BITOPS_H
#include <stdbool.h>
#include <string.h>
#include <strings.h>
#include <sys/cdefs.h>
__BEGIN_DECLS
/*
* Bitmask Operations
*
* Note this doesn't provide any locking/exclusion, and isn't atomic.
* Additionally no bounds checking is done on the bitmask array.
*
* Example:
*
* int num_resources;
* unsigned int resource_bits[BITS_TO_WORDS(num_resources)];
* bitmask_init(resource_bits, num_resources);
* ...
* int bit = bitmask_ffz(resource_bits, num_resources);
* bitmask_set(resource_bits, bit);
* ...
* if (bitmask_test(resource_bits, bit)) { ... }
* ...
* bitmask_clear(resource_bits, bit);
*
*/
#define BITS_PER_WORD (sizeof(unsigned int) * 8)
#define BITS_TO_WORDS(x) (((x) + BITS_PER_WORD - 1) / BITS_PER_WORD)
#define BIT_IN_WORD(x) ((x) % BITS_PER_WORD)
#define BIT_WORD(x) ((x) / BITS_PER_WORD)
#define BIT_MASK(x) (1 << BIT_IN_WORD(x))
static inline void bitmask_init(unsigned int *bitmask, int num_bits)
{
memset(bitmask, 0, BITS_TO_WORDS(num_bits)*sizeof(unsigned int));
}
static inline int bitmask_ffz(unsigned int *bitmask, int num_bits)
{
int bit, result;
size_t i;
for (i = 0; i < BITS_TO_WORDS(num_bits); i++)
{
bit = ffs(~bitmask[i]);
if (bit)
{
// ffs is 1-indexed, return 0-indexed result
bit--;
result = BITS_PER_WORD * i + bit;
if (result >= num_bits)
return -1;
return result;
}
}
return -1;
}
static inline int bitmask_weight(unsigned int *bitmask, int num_bits)
{
size_t i;
int weight = 0;
for (i = 0; i < BITS_TO_WORDS(num_bits); i++)
weight += __builtin_popcount(bitmask[i]);
return weight;
}
static inline void bitmask_set(unsigned int *bitmask, int bit)
{
bitmask[BIT_WORD(bit)] |= BIT_MASK(bit);
}
static inline void bitmask_clear(unsigned int *bitmask, int bit)
{
bitmask[BIT_WORD(bit)] &= ~BIT_MASK(bit);
}
static inline bool bitmask_test(unsigned int *bitmask, int bit)
{
return bitmask[BIT_WORD(bit)] & BIT_MASK(bit);
}
static inline int popcount(unsigned int x)
{
return __builtin_popcount(x);
}
static inline int popcountl(unsigned long x)
{
return __builtin_popcountl(x);
}
static inline int popcountll(unsigned long long x)
{
return __builtin_popcountll(x);
}
__END_DECLS
#endif /* __CUTILS_BITOPS_H */

69
include/hardware/system/cutils/native_handle.h Normal file
View File

@ -0,0 +1,69 @@
/*
* Copyright (C) 2009 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.
*/
#ifndef NATIVE_HANDLE_H_
#define NATIVE_HANDLE_H_
#ifdef __cplusplus
extern "C" {
#endif
typedef struct native_handle
{
int version; /* sizeof(native_handle_t) */
int numFds; /* number of file-descriptors at &data[0] */
int numInts; /* number of ints at &data[numFds] */
int data[0]; /* numFds + numInts ints */
} native_handle_t;
/*
* native_handle_close
*
* closes the file descriptors contained in this native_handle_t
*
* return 0 on success, or a negative error code on failure
*
*/
int native_handle_close(const native_handle_t* h);
/*
* native_handle_create
*
* creates a native_handle_t and initializes it. must be destroyed with
* native_handle_delete().
*
*/
native_handle_t* native_handle_create(int numFds, int numInts);
/*
* native_handle_delete
*
* frees a native_handle_t allocated with native_handle_create().
* This ONLY frees the memory allocated for the native_handle_t, but doesn't
* close the file descriptors; which can be achieved with native_handle_close().
*
* return 0 on success, or a negative error code on failure
*
*/
int native_handle_delete(native_handle_t* h);
#ifdef __cplusplus
}
#endif
#endif /* NATIVE_HANDLE_H_ */

116
src/Effect.cpp Normal file
View File

@ -0,0 +1,116 @@
//
// Created by mart on 7/25/21.
//
#include <cstdlib>
#include "Effect.h"
#include "constants.h"
Effect::Effect() {
this->enabled = false;
this->configureOk = false;
this->sampleRate = DEFAULT_SAMPLERATE;
memset(&this->config, 0, sizeof(effect_config_t));
this->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
this->config.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT; // TODO: Try to use PCM_FLOAT instead
this->config.inputCfg.samplingRate = DEFAULT_SAMPLERATE;
this->config.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
this->config.inputCfg.mask = AUDIO_PORT_CONFIG_ALL;
this->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_WRITE;
this->config.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT; // TODO: Try to use PCM_FLOAT instead
this->config.outputCfg.samplingRate = DEFAULT_SAMPLERATE;
this->config.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
this->config.outputCfg.mask = AUDIO_PORT_CONFIG_ALL;
this->buffer = nullptr;
this->bufferSize = 0;
this->instance = nullptr;
}
Effect::~Effect() {
if (this->buffer != nullptr) {
free(this->buffer);
}
}
int32_t Effect::process(audio_buffer_s *in, audio_buffer_s *out) {
// TODO
return -1;
}
int32_t Effect::command(uint32_t cmdCode, uint32_t cmdSize, void *pCmdData, uint32_t *replySize, void *pReplyData) {
switch(cmdCode) {
case EFFECT_CMD_INIT:
case EFFECT_CMD_SET_CONFIG:
case EFFECT_CMD_SET_PARAM:
case EFFECT_CMD_SET_PARAM_COMMIT:
*((int*)pReplyData) = 0;
case EFFECT_CMD_RESET:
case EFFECT_CMD_SET_PARAM_DEFERRED:
case EFFECT_CMD_SET_DEVICE:
case EFFECT_CMD_SET_VOLUME:
case EFFECT_CMD_SET_AUDIO_MODE:
case EFFECT_CMD_SET_INPUT_DEVICE:
case EFFECT_CMD_SET_AUDIO_SOURCE:
break;
case EFFECT_CMD_SET_CONFIG_REVERSE:
*((int*)pReplyData) = -EINVAL;
default:
return -EINVAL;
case EFFECT_CMD_GET_CONFIG:
memcpy(pReplyData, &this->config, sizeof(effect_config_t));
break;
case EFFECT_CMD_OFFLOAD:
// TODO: Figure this out
return -1;
}
return 0;
}
#define ERROR this->configureOk = false;\
return -EINVAL;
int32_t Effect::configure(effect_config_t *newConfig) {
if (newConfig->inputCfg.samplingRate != newConfig->outputCfg.samplingRate) {
// __android_log_print(4,"ViPER4Android_v2","ViPER4Android disabled, reason [in.SR = %d, out.SR = %d]",inSamplingRate,outSamplingRate);
ERROR
}
if (newConfig->inputCfg.samplingRate > 48000) {
// __android_log_print(4,"ViPER4Android_v2","ViPER4Android disabled, reason [SR out of range]");
ERROR
}
if (newConfig->inputCfg.channels != newConfig->outputCfg.channels) {
// __android_log_print(4,"ViPER4Android_v2","ViPER4Android disabled, reason [in.CH = %d, out.CH = %d]",inChannels,outChannels);
ERROR
}
if (newConfig->inputCfg.channels != AUDIO_CHANNEL_OUT_STEREO) {
// __android_log_print(4,"ViPER4Android_v2","ViPER4Android disabled, reason [CH != 2]");
ERROR
}
// if (((inFormat & 0x80000) != 0) && ((outFormat & 0x80000) != 0)) {
// if ((inFormat & 0xfd) != 1) {
// __android_log_print(4,"ViPER4Android_v2","ViPER4Android disabled, reason [in.FMT = %d]");
// __android_log_print(4,"ViPER4Android_v2","We only accept s16 and fixed.31 format");
// this->configureOk = false;
// return 0xffffffea;
// }
// if ((outFormat & 0xfd) != 1) {
// __android_log_print(4,"ViPER4Android_v2","ViPER4Android disabled, reason [out.FMT = %d]");
// __android_log_print(4,"ViPER4Android_v2","We only accept s16 and fixed.31 format");
// this->configureOk = false;
// return 0xffffffea;
// }
// }
memcpy(&this->config, newConfig, sizeof(effect_config_t));
this->configureOk = true;
return 0;
}

29
src/Effect.h Normal file
View File

@ -0,0 +1,29 @@
//
// Created by mart on 7/25/21.
//
#pragma once
#include <cstdint>
#include <hardware/audio_effect.h>
class Effect {
public:
Effect();
~Effect();
virtual int32_t command(uint32_t cmdCode, uint32_t cmdSize, void* pCmdData, uint32_t* replySize, void* pReplyData);
int32_t process(audio_buffer_s *in, audio_buffer_s *out);
int32_t configure(effect_config_t* config);
bool enabled;
bool configureOk;
uint32_t sampleRate;
effect_config_t config{};
// Misc data here?
// TODO: Figure out what buffer is used for
float* buffer;
uint32_t bufferSize;
void* instance; // type: ProcessUnit_FX
};

32
src/ProcessUnit_FX.cpp Normal file
View File

@ -0,0 +1,32 @@
//
// Created by mart on 7/25/21.
//
#include "ProcessUnit_FX.h"
#include "Effect.h"
ProcessUnit_FX::ProcessUnit_FX() {
}
ProcessUnit_FX::~ProcessUnit_FX() {
}
int32_t ProcessUnit_FX::command(uint32_t cmdCode, uint32_t cmdSize, void *pCmdData, uint32_t *replySize, void *pReplyData) {
// TODO
return -1;
}
void ProcessUnit_FX::processBuffer(float *buffer, int frameSize) {
// TODO
}
void ProcessUnit_FX::DispatchCommand(int param_1, int param_2, int param_3, int param_4, int param_5, int param_6,
int param_7) {
// TODO
}
void ProcessUnit_FX::ResetAllEffects() {
// TODO
}

20
src/ProcessUnit_FX.h Normal file
View File

@ -0,0 +1,20 @@
//
// Created by mart on 7/25/21.
//
#pragma once
#include "Effect.h"
class ProcessUnit_FX : public Effect {
public:
ProcessUnit_FX();
~ProcessUnit_FX();
int32_t command(uint32_t cmdCode, uint32_t cmdSize, void* pCmdData, uint32_t* replySize, void* pReplyData) override;
void processBuffer(float* buffer, int frameSize);
// TODO: Parameter types/names
void DispatchCommand(int param_1, int param_2,int param_3, int param_4,int param_5, int param_6,int param_7);
void ResetAllEffects();
};

7
src/constants.h Normal file
View File

@ -0,0 +1,7 @@
//
// Created by mart on 7/25/21.
//
#pragma once
#define DEFAULT_SAMPLERATE 44100

27
src/effects/Cure.cpp Normal file
View File

@ -0,0 +1,27 @@
//
// Created by mart on 7/26/21.
//
#include "Cure.h"
Cure::Cure() {
this->enabled = false;
Reset();
}
void Cure::Process(float *buffer, uint32_t size) {
if (this->enabled) {
Crossfeed::ProcessFrames(buffer, size);
this->pass.ProcessFrames(buffer, size);
}
}
void Cure::Reset() {
Crossfeed::Reset();
this->pass.Reset();
}
void Cure::SetSamplingRate(uint32_t samplerate) {
Crossfeed::SetSamplingRate(samplerate);
this->pass.SetSamplingRate(samplerate);
}

21
src/effects/Cure.h Normal file
View File

@ -0,0 +1,21 @@
//
// Created by mart on 7/26/21.
//
#pragma once
#include "../utils/Crossfeed.h"
#include "../utils/PassFilter.h"
class Cure : public Crossfeed {
public:
Cure();
void Process(float* buffer, uint32_t size);
void Reset();
void SetSamplingRate(uint32_t samplerate);
PassFilter pass;
bool enabled;
};

28
src/effects/TubeSimulator.cpp Normal file
View File

@ -0,0 +1,28 @@
//
// Created by mart on 7/26/21.
//
#include "TubeSimulator.h"
TubeSimulator::TubeSimulator() {
this->acc[0] = 0.f;
this->acc[1] = 0.f;
this->enabled = false;
}
void TubeSimulator::Reset() {
this->acc[0] = 0.f;
this->acc[1] = 0.f;
this->enabled = false;
}
void TubeSimulator::TubeProcess(float *buffer, uint32_t size) {
if (this->enabled && size > 0) {
for (int x = 0; x < size; x++) {
this->acc[0] = (this->acc[0] + buffer[2*x]) / 2.f;
this->acc[1] = (this->acc[1] + buffer[2*x+1]) / 2.f;
buffer[2*x] = this->acc[0];
buffer[2*x+1] = this->acc[1];
}
}
}

19
src/effects/TubeSimulator.h Normal file
View File

@ -0,0 +1,19 @@
//
// Created by mart on 7/26/21.
//
#pragma once
#include <cstdint>
class TubeSimulator {
public:
TubeSimulator();
void Reset();
void TubeProcess(float* buffer, uint32_t size);
float acc[2];
bool enabled;
};

40
src/utils/CAllpassFilter.cpp Normal file
View File

@ -0,0 +1,40 @@
//
// Created by mart on 7/26/21.
//
#include <cstring>
#include "CAllpassFilter.h"
CAllpassFilter::CAllpassFilter() {
this->buffer = nullptr;
this->bufidx = 0;
this->bufsize = 0;
this->feedback = 0;
}
void CAllpassFilter::Mute() {
memset(this->buffer, 0, this->bufsize * sizeof(float))
}
float CAllpassFilter::Process(float sample) {
float outSample = this->buffer[this->bufidx];
this->buffer[this->bufidx] = sample + (outSample * this->feedback);
this->bufidx++;
if (this->bufidx >= this->bufsize) {
this->bufidx = 0;
}
return outSample - sample;
}
float CAllpassFilter::GetFeedback() {
return this->feedback;
}
void CAllpassFilter::SetBuffer(float *buffer, uint32_t size) {
this->buffer = buffer;
this->bufsize = size;
}
void CAllpassFilter::SetFeedback(float feedback) {
this->feedback = feedback;
}

24
src/utils/CAllpassFilter.h Normal file
View File

@ -0,0 +1,24 @@
//
// Created by mart on 7/26/21.
//
#pragma once
#include <cstdint>
class CAllpassFilter {
public:
CAllpassFilter();
void Mute();
float Process(float sample);
float GetFeedback();
void SetBuffer(float* buffer, uint32_t size);
void SetFeedback(float feedback);
float* buffer;
uint32_t bufidx;
uint32_t bufsize;
float feedback;
};

110
src/utils/Crossfeed.cpp Normal file
View File

@ -0,0 +1,110 @@
//
// Created by mart on 7/26/21.
//
#include <cstring>
#include <cmath>
#include "Crossfeed.h"
#include "../constants.h"
// Basically Bauer-to-Stereophonic Binaural filter
// See: http://bs2b.sourceforge.net/
Crossfeed::Crossfeed() {
this->a0_lo = 0.f;
this->b1_lo = 0.f;
this->a0_hi = 0.f;
this->a1_hi = 0.f;
this->b1_hi = 0.f;
this->gain = 0.f;
memset(&this->lfs, 0, 6*sizeof(float));
this->samplerate = DEFAULT_SAMPLERATE;
this->preset.cutoff = 700;
this->preset.feedback = 45;
}
void Crossfeed::Reset() {
uint16_t cutoff = this->preset.cutoff;
uint16_t level = this->preset.feedback;
level /= 10.0;
double GB_lo = level * -5.0 / 6.0 - 3.0;
double GB_hi = level / 6.0 - 3.0;
double G_lo = pow( 10, GB_lo / 20.0 );
double G_hi = 1.0 - pow( 10, GB_hi / 20.0 );
double Fc_hi = cutoff * pow( 2.0, ( GB_lo - 20.0 * log10( G_hi ) ) / 12.0 );
double x = exp( -2.0 * M_PI * cutoff / this->samplerate );
this->b1_lo = (float)x;
this->a0_lo = (float)(G_lo * ( 1.0 - x ));
x = exp( -2.0 * M_PI * Fc_hi / this->samplerate );
this->b1_hi = (float)x;
this->a0_hi = (float)(1.0 - G_hi * ( 1.0 - x ));
this->a1_hi = (float)-x;
this->gain = (float)(1.0 / ( 1.0 - G_hi + G_lo ));
memset(&this->lfs, 0, 6*sizeof(float));
}
void Crossfeed::ProcessFrames(float* buffer, uint32_t size) {
for (int x = 0; x < size; x+=2) {
FilterSample(&buffer[x])
}
}
#define lo_filter(in, out_1) (this->a0_lo * (in) + this->b1_lo * (out_1))
#define hi_filter(in, in_1, out_1) (this->a0_hi * (in) + this->a1_hi * (in_1) + this->b1_hi * (out_1))
void Crossfeed::FilterSample(float *sample) {
this->lfs.lo[0] = lo_filter(sample[0], this->lfs.lo[0]);
this->lfs.lo[1] = lo_filter(sample[1], this->lfs.lo[1]);
this->lfs.hi[0] = hi_filter(sample[0], this->lfs.asis[0], this->lfs.hi[0]);
this->lfs.hi[1] = hi_filter(sample[1], this->lfs.asis[1], this->lfs.hi[1]);
this->lfs.asis[0] = sample[0];
this->lfs.asis[1] = sample[1];
sample[0] = (this->lfs.hi[0] + this->lfs.lo[1]) * this->gain;
sample[1] = (this->lfs.hi[1] + this->lfs.lo[0]) * this->gain;
}
uint16_t Crossfeed::GetCutoff() {
return this->preset.cutoff;
}
float Crossfeed::GetFeedback() {
return (float)this->preset.feedback / 10.f;
}
float Crossfeed::GetLevelDelay() {
if (this->preset.cutoff <= 1800) {
return (18700.f / (float)this->preset.cutoff) * 10.f;
} else {
return 0.f;
}
}
preset_t Crossfeed::GetPreset() {
return this->preset;
}
void Crossfeed::SetCutoff(uint16_t cutoff) {
this->preset.cutoff = cutoff;
Reset();
}
void Crossfeed::SetFeedback(float feedback) {
this->preset.feedback = (uint16_t)(feedback * 10);
Reset();
}
void Crossfeed::SetPreset(preset_t preset) {
this->preset = preset;
Reset();
}
void Crossfeed::SetSamplingRate(uint32_t samplerate) {
this->samplerate = samplerate;
Reset();
}

40
src/utils/Crossfeed.h Normal file
View File

@ -0,0 +1,40 @@
//
// Created by mart on 7/26/21.
//
#pragma once
#include <cstdint>
typedef struct {
uint16_t cutoff;
uint16_t feedback;
} preset_t;
class Crossfeed {
public:
Crossfeed();
void Reset();
void ProcessFrames(float* buffer, uint32_t size);
void FilterSample(float* sample);
uint16_t GetCutoff();
float GetFeedback();
float GetLevelDelay();
preset_t GetPreset();
void SetCutoff(uint16_t cutoff);
void SetFeedback(float feedback);
void SetPreset(preset_t preset);
void SetSamplingRate(uint32_t samplerate);
uint32_t samplerate;
float a0_lo, b1_lo;
float a0_hi, b1_hi, a1_hi;
float gain;
struct {
float asis[2], lo[2], hi[2];
} lfs;
preset_t preset;
};

83
src/utils/FixedBiquad.cpp Normal file
View File

@ -0,0 +1,83 @@
//
// Created by mart on 7/26/21.
//
#include <cmath>
#include "FixedBiquad.h"
FixedBiquad::FixedBiquad() {
Reset();
SetCoeffs(1.f, 0.f, 0.f, 1.f, 0.f, 0.f);
}
float FixedBiquad::ProcessSample(float sample) {
float out = sample * this->b0 + this->x_1 * this->b1 + this->x_2 * this->b2 + this->y_1 * this->a1 + this->y_2 * this->a2;
this->y_2 = this->y_1;
this->y_1 = out;
this->x_2 = this->x_1;
this->x_1 = sample;
return out;
}
void FixedBiquad::Reset() {
this->y_2 = 0;
this->y_1 = 0;
this->x_2 = 0;
this->x_1 = 0;
this->b0 = 0;
this->b1 = 0;
this->b2 = 0;
this->a1 = 0;
this->a2 = 0;
}
void FixedBiquad::SetCoeffs(float a0, float a1, float a2, float b0, float b1, float b2) {
this->y_2 = 0;
this->y_1 = 0;
this->x_2 = 0;
this->x_1 = 0;
this->b0 = b0 / a0;
this->b1 = b1 / a0;
this->b2 = b2 / a0;
this->a1 = -a1 / a0;
this->a2 = -a2 / a0;
}
void FixedBiquad::SetBandPassParameter(float frequency, uint32_t samplerate, float qFactor) {
float x = (2.f * frequency * (float)M_PI / (float)samplerate);
float sinX = sinf(x);
float cosX = cosf(x);
float y = x / (2.f * qFactor);
SetCoeffs(y + 1.f, -2.f * cosX, 1.f - y, sinX / 2.f, 0.f, -sinX / 2.f);
}
void FixedBiquad::SetHighPassParameter(float frequency, uint32_t samplerate, float param_4, float qFactor, float param_6) {
// TODO: Cleanup and named params
float fVar12 = (frequency * 2.f * (float)M_PI) / (float)samplerate;
float x = powf(10.f, param_4 / 40.f);
float fVar5 = (1.f / x + x) * (1.f / qFactor - 1.f) + 2.f;
float fVar7 = sqrtf(x);
float fVar8 = x - 1.f;
float fVar10 = x + 1.f;
float fVar6 = sinf(fVar12) * 0.f * sqrtf(fVar5);
fVar5 = cosf(fVar12);
fVar12 = fVar10 + fVar8 * fVar5;
float fVar11 = fVar10 - fVar8 * fVar5;
float fVar2 = powf(10.f,param_6 / 20.f);
float fVar9 = fVar8 - fVar10 * fVar5;
SetCoeffs(fVar11 + (fVar7 + fVar7) * fVar6,
fVar9 + fVar9,
fVar11 - (fVar7 + fVar7) * fVar6,
(fVar12 + (fVar7 + fVar7) * fVar6) * x * fVar2,
x * -2.0 * (fVar8 + fVar10 * fVar5) * fVar2,
(fVar12 - (fVar7 + fVar7) * fVar6) * x * fVar2);
}
void FixedBiquad::SetLowPassParameter(float frequency, uint32_t samplerate, float qFactor) {
float x = (frequency * 2.f * (float)M_PI) / (float)samplerate;
float sinX = sinf(x);
float y = sinX / (qFactor * 2.f);
float cosX = cosf(x);
float z = (1.f - cosX) / 2.f;
SetCoeffs(y + 1.f, cosX * -2.f, 1.f - y, z, 1.f - cosX, z);
}

24
src/utils/FixedBiquad.h Normal file
View File

@ -0,0 +1,24 @@
//
// Created by mart on 7/26/21.
//
#pragma once
#include <cstdint>
class FixedBiquad {
public:
FixedBiquad();
float ProcessSample(float sample);
void Reset();
void SetCoeffs(float a0, float a1, float a2, float b0, float b1, float b2);
void SetBandPassParameter(float frequency, uint32_t samplerate, float qFactor);
void SetHighPassParameter(float frequency, uint32_t samplerate, float param_4, float qFactor, float param_6);
void SetLowPassParameter(float frequency, uint32_t samplerate, float qFactor);
float y_2, y_1, x_2, x_1;
float b0, b1, b2, a1, a2;
};

154
src/utils/IIR_1st.cpp Normal file
View File

@ -0,0 +1,154 @@
//
// Created by mart on 7/26/21.
//
#include <cmath>
#include "IIR_1st.h"
// Seems to be taken from https://github.com/michaelwillis/dragonfly-reverb/blob/master/common/freeverb/efilter.cpp
// Or similar sources
IIR_1st::IIR_1st() {
this->b0 = 0.f;
this->b1 = 0.f;
this->a1 = 0.f;
Mute()
}
void IIR_1st::Mute() {
this->prevSample = 0.f;
}
void IIR_1st::SetCoefficients(float b0, float b1, float a1) {
this->b0 = b0;
this->b1 = b1;
this->a1 = a1;
}
#define angle(freq, samplerate) (expf(-1*(float)M_PI*(freq)/((float)(samplerate)/2.f)))
#define omega() (2.f * (float)M_PI * frequency / (float)samplerate)
#define omega_2() ((float)M_PI * frequency / (float)samplerate)
void IIR_1st::setHPF_A(float frequency, uint32_t samplerate) {
this->a1 = angle(frequency, samplerate);
float norm = (1+a1)/2.f;
this->b0 = norm;
this->b1 = -norm;
}
void IIR_1st::setHPF_BW(float frequency, uint32_t samplerate) {
float omega_2 = omega_2();
float tan_omega_2 = tanf(omega_2);
this->b0 = 1/(1+tan_omega_2);
this->b1 = -this->b0;
this->a1 = (1-tan_omega_2)/(1+tan_omega_2);
}
void IIR_1st::setHPF_C(float frequency, uint32_t samplerate) {
this->b0 = (float)samplerate/((float)samplerate+frequency);
this->b1 = -1 * this->b0;
this->a1 = ((float)samplerate-frequency)/((float)samplerate+frequency);
}
void IIR_1st::setHPFwLPS_A(float frequency, uint32_t samplerate) {
this->a1 = -0.12f;
this->b0 = -1.f;
this->b1 = angle(frequency, samplerate);
float norm = (1-this->a1) / fabsf(this->b0 + this->b1);
this->b0 *= norm;
this->b1 *= norm;;
}
void IIR_1st::setHSF_A(float f1, float f2, uint32_t samplerate) {
this->a1 = angle(f1, samplerate);
this->b0 = -1.f;
this->b1 = angle(f2, samplerate);
float norm = (1-this->a1)/(this->b0 + this->b1);
this->b0 *= norm;
this->b1 *= norm;
}
void IIR_1st::setLPF_A(float frequency, uint32_t samplerate) {
this->a1 = angle(frequency, samplerate);
this->b0 = 1.f;
this->b1 = 0.12f;
float norm = (1+this->a1)/(this->b0 + this->b1);
this->b0 *= norm;
this->b1 *= norm;
}
void IIR_1st::setLPF_BW(float frequency, uint32_t samplerate) {
float omega_2 = omega_2();
float tan_omega_2 = tanf(omega_2);
this->a1 = (1-tan_omega_2)/(1+tan_omega_2);
this->b0 = tan_omega_2/(1+tan_omega_2);
this->b1 = this->b0;
}
void IIR_1st::setLPF_C(float frequency, uint32_t samplerate) {
this->b0 = frequency/((float)samplerate+frequency);
this->b1 = this->b0;
this->a1 = ((float)samplerate-frequency)/((float)samplerate+frequency);
}
void IIR_1st::setLSF_A(float f1, float f2, uint32_t samplerate) {
this->a1 = angle(f1, samplerate);
this->b0 = -1.f;
this->b1 = angle(f2, samplerate);
}
void IIR_1st::setPole(float a1) {
this->a1 = a1;
this->b0 = 1.f-fabsf(a1);
this->b1 = 0.f;
}
void IIR_1st::setPoleHPF(float frequency, uint32_t samplerate) {
float omega = omega();
float cos_omega = cosf(omega);
float tmp = (2.f + cos_omega);
float coeff = tmp-sqrtf(tmp*tmp-1.f);
this->a1 = -coeff;
this->b0 = 1.f - coeff;
this->b1 = 0;
}
void IIR_1st::setPoleLPF(float frequency, uint32_t samplerate) {
float omega = omega();
float cos_omega = cosf(omega);
float tmp = (2.f - cos_omega);
float coeff = tmp-sqrtf(tmp*tmp-1.f);
this->a1 = coeff;
this->b0 = 1.f - coeff;
this->b1 = 0.f;
}
void IIR_1st::setZero(float b1) {
this->a1 = 0;
this->b0 = -1;
this->b1 = b1;
float norm = fabsf(this->b0) + fabsf(this->b1);
this->b0 *= norm;
this->b1 *= norm;
}
void IIR_1st::setZeroHPF(float frequency, uint32_t samplerate) {
float omega = omega();
float cos_omega = cosf(omega);
float tmp = (1.f - 2.f * cos_omega);
float coeff = tmp-sqrtf(tmp*tmp-1.f);
this->a1 = 0.f;
this->b0 = 1.f/(1.f+coeff);
this->b1 = -coeff/(1.f+coeff);
}
void IIR_1st::setZeroLPF(float frequency, uint32_t samplerate) {
float omega = omega();
float cos_omega = cosf(omega);
float tmp = (1.f + 2.f * cos_omega);
float coeff = tmp-sqrtf(tmp*tmp-1.f);
this->a1 = 0.f;
this->b0 = 1.f/(1.f+coeff);
this->b1 = coeff/(1.f+coeff);
}

32
src/utils/IIR_1st.h Normal file
View File

@ -0,0 +1,32 @@
//
// Created by mart on 7/26/21.
//
#pragma once
#include <cstdint>
class IIR_1st {
public:
IIR_1st();
void Mute();
void SetCoefficients(float b0, float b1, float a1);
void setHPF_A(float frequency, uint32_t samplerate);
void setHPF_BW(float frequency, uint32_t samplerate);
void setHPF_C(float frequency, uint32_t samplerate);
void setHPFwLPS_A(float frequency, uint32_t samplerate);
void setHSF_A(float f1, float f2, uint32_t samplerate);
void setLPF_A(float frequency, uint32_t samplerate);
void setLPF_BW(float frequency, uint32_t samplerate);
void setLPF_C(float frequency, uint32_t samplerate);
void setLSF_A(float f1, float f2, uint32_t samplerate);
void setPole(float a1);
void setPoleHPF(float frequency, uint32_t samplerate);
void setPoleLPF(float frequency, uint32_t samplerate);
void setZero(float b1);
void setZeroHPF(float frequency, uint32_t samplerate);
void setZeroLPF(float frequency, uint32_t samplerate);
float b0, b1, a1;
float prevSample;
};

35
src/utils/IIR_NOrder_BW_BP.cpp Normal file
View File

@ -0,0 +1,35 @@
//
// Created by mart on 7/26/21.
//
#include "IIR_NOrder_BW_BP.h"
IIR_NOrder_BW_BP::IIR_NOrder_BW_BP(uint32_t order) {
this->lowpass = new IIR_1st[order];
this->highpass = new IIR_1st[order];
this->order = order;
for (int x = 0; x < order; x++) {
this->lowpass[x].Mute();
this->highpass[x].Mute();
}
}
IIR_NOrder_BW_BP::~IIR_NOrder_BW_BP() {
delete[] this->lowpass;
delete[] this->highpass;
}
void IIR_NOrder_BW_BP::Mute() {
for (int x = 0; x < this->order; x++) {
this->lowpass[x].Mute();
this->highpass[x].Mute();
}
}
void IIR_NOrder_BW_BP::setBPF(float highCut, float lowCut, uint32_t samplerate) {
for (int x = 0; x < this->order; x++) {
this->lowpass[x].setLPF_BW(lowCut, samplerate);
this->highpass[x].setHPF_BW(highCut, samplerate);
}
}

21
src/utils/IIR_NOrder_BW_BP.h Normal file
View File

@ -0,0 +1,21 @@
//
// Created by mart on 7/26/21.
//
#pragma once
#include "IIR_1st.h"
class IIR_NOrder_BW_BP {
public:
explicit IIR_NOrder_BW_BP(uint32_t order);
~IIR_NOrder_BW_BP();
void Mute();
void setBPF(float highCut, float lowCut, uint32_t samplerate);
IIR_1st* lowpass;
IIR_1st* highpass;
uint32_t order;
};

36
src/utils/IIR_NOrder_BW_LH.cpp Normal file
View File

@ -0,0 +1,36 @@
//
// Created by mart on 7/26/21.
//
#include "IIR_NOrder_BW_LH.h"
IIR_NOrder_BW_LH::IIR_NOrder_BW_LH(uint32_t order) {
this->filters = new IIR_1st[order];
this->order = order;
for (int x = 0; x < order; x++) {
this->filters[x].Mute();
}
}
IIR_NOrder_BW_LH::~IIR_NOrder_BW_LH() {
delete[] this->filters;
}
void IIR_NOrder_BW_LH::Mute() {
for (int x = 0; x < this->order; x++) {
this->filters[x].Mute();
}
}
void IIR_NOrder_BW_LH::setLPF(float frequency, uint32_t samplerate) {
for (int x = 0; x < this->order; x++) {
this->filters[x].setLPF_BW(frequency, samplerate);
}
}
void IIR_NOrder_BW_LH::setHPF(float frequency, uint32_t samplerate) {
for (int x = 0; x < this->order; x++) {
this->filters[x].setHPF_BW(frequency, samplerate);
}
}

20
src/utils/IIR_NOrder_BW_LH.h Normal file
View File

@ -0,0 +1,20 @@
//
// Created by mart on 7/26/21.
//
#pragma once
#include "IIR_1st.h"
class IIR_NOrder_BW_LH {
public:
explicit IIR_NOrder_BW_LH(uint32_t order);
~IIR_NOrder_BW_LH();
void Mute();
void setLPF(float frequency, uint32_t samplerate);
void setHPF(float frequency, uint32_t samplerate);
IIR_1st* filters;
uint32_t order;
};

35
src/utils/MultiBiquad.cpp Normal file
View File

@ -0,0 +1,35 @@
//
// Created by mart on 7/27/21.
//
#include "MultiBiquad.h"
MultiBiquad::MultiBiquad() {
this->y_2 = 0;
this->y_1 = 0;
this->x_2 = 0;
this->x_1 = 0;
this->b0 = 0;
this->b1 = 0;
this->b2 = 0;
this->a1 = 0;
this->a2 = 0;
}
float MultiBiquad::ProcessSample(float sample) {
float out = sample * this->b0 + this->x_1 * this->b1 + this->x_2 * this->b2 + this->y_1 * this->a1 + this->y_2 * this->a2;
this->y_2 = this->y_1;
this->y_1 = out;
this->x_2 = this->x_1;
this->x_1 = sample;
return out;
}
void MultiBiquad::RefreshFilter(FilterType type, float gainAmp, float freq, float samplerate, float qFactor, bool param_7) {
// TODO
this->y_2 = 0.f;
this->y_1 = 0.f;
this->x_2 = 0.f;
this->x_1 = 0.f;
}

25
src/utils/MultiBiquad.h Normal file
View File

@ -0,0 +1,25 @@
//
// Created by mart on 7/27/21.
//
#pragma once
enum FilterType {
};
class MultiBiquad {
public:
MultiBiquad();
float ProcessSample(float sample);
void RefreshFilter(FilterType type, float gainAmp, float freq, float samplerate, float qFactor, bool param_7);
float y_2, y_1, x_2, x_1;
float b0, b1, b2, a1, a2;
};

69
src/utils/PassFilter.cpp Normal file
View File

@ -0,0 +1,69 @@
//
// Created by mart on 7/26/21.
//
#include "PassFilter.h"
#include "../constants.h"
PassFilter::PassFilter() {
this->filters[0] = new IIR_NOrder_BW_LH(3);
this->filters[1] = new IIR_NOrder_BW_LH(3);
this->filters[2] = new IIR_NOrder_BW_LH(1);
this->filters[3] = new IIR_NOrder_BW_LH(1);
this->samplerate = DEFAULT_SAMPLERATE;
Reset();
}
PassFilter::~PassFilter() {
delete this->filters[0];
delete this->filters[1];
delete this->filters[2];
delete this->filters[3];
}
void PassFilter::Reset() {
uint32_t cutoff;
if (this->samplerate < 44100) {
cutoff = this->samplerate - 100;
} else {
cutoff = 18000;
}
this->filters[0]->setLPF((float)cutoff, this->samplerate);
this->filters[1]->setLPF((float)cutoff, this->samplerate);
this->filters[2]->setLPF(10.f, cutoff);
this->filters[3]->setLPF(10.f, cutoff);
this->filters[0]->Mute();
this->filters[1]->Mute();
this->filters[2]->Mute();
this->filters[3]->Mute();
}
#define do_filter(filt, sample) \
for (int idx = 0; idx < (filt)->order; idx++) {\
IIR_1st filter = this->filters[2]->filters[idx];\
float hist = (sample) * filter.b1;\
left = filter.prevSample + (sample) * filter.b0;\
filter.prevSample = (sample) * filter.a1 + hist;\
}
void PassFilter::ProcessFrames(float *buffer, uint32_t size) {
for (int x = 0; x < size; x++) {
float left = buffer[2*x];
float right = buffer[2*x+1];
do_filter(this->filters[2], left)
do_filter(this->filters[0], left)
do_filter(this->filters[3], right)
do_filter(this->filters[1], right)
buffer[2*x] = left;
buffer[2*x+1] = right;
}
}
void PassFilter::SetSamplingRate(uint32_t samplerate) {
this->samplerate = samplerate;
Reset();
}

21
src/utils/PassFilter.h Normal file
View File

@ -0,0 +1,21 @@
//
// Created by mart on 7/26/21.
//
#pragma once
#include <cstdint>
#include "IIR_NOrder_BW_LH.h"
class PassFilter {
public:
PassFilter();
~PassFilter();
void Reset();
void ProcessFrames(float* buffer, uint32_t size);
void SetSamplingRate(uint32_t samplerate);
IIR_NOrder_BW_LH* filters[4];
uint32_t samplerate;
};

40
src/utils/TimeConstDelay.cpp Normal file
View File

@ -0,0 +1,40 @@
//
// Created by mart on 7/26/21.
//
#include <cstdlib>
#include <cstring>
#include "TimeConstDelay.h"
TimeConstDelay::TimeConstDelay() {
this->samples = nullptr;
this->offset = 0;
this->sampleCount = 0;
}
TimeConstDelay::~TimeConstDelay() {
if (this->samples != nullptr) {
free(this->samples);
this->samples = nullptr;
}
}
float TimeConstDelay::ProcessSample(float sample) {
if (this->samples != nullptr) {
float val = this->samples[this->offset];
this->samples[this->offset] = sample;
this->offset = (int)modf((float)this->offset + 1, (float*)&this->sampleCount);
return val;
}
return 0.f;
}
void TimeConstDelay::SetParameters(uint32_t samplerate, float delay) {
this->sampleCount = (int)((float)samplerate * delay * 0.5f);
if (this->samples != nullptr) {
free(this->samples);
}
this->samples = new float[this->sampleCount * sizeof(float)];
this->offset = 0;
memset(this->samples, 0, this->sampleCount * sizeof(float));
}

19
src/utils/TimeConstDelay.h Normal file
View File

@ -0,0 +1,19 @@
//
// Created by mart on 7/26/21.
//
#pragma once
#include <cstdint>
class TimeConstDelay {
public:
TimeConstDelay();
~TimeConstDelay();
float ProcessSample(float sample);
void SetParameters(uint32_t samplerate, float delay);
float* samples;
uint32_t offset;
uint32_t sampleCount;
};

94
src/viper.cpp Normal file
View File

@ -0,0 +1,94 @@
#include <cstring>
#include <hardware/audio_effect.h>
#include <cstdlib>
#include "Effect.h"
#include "ProcessUnit_FX.h"
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 = 0x20000,
.flags = 0xf010,
.cpuLoad = 0x08,
.memoryUsage = 0x01,
};
extern "C" {
typedef struct {
const struct effect_interface_s* interface;
Effect* effect;
effect_descriptor_t* descriptor;
} handle;
static int32_t generic_process(effect_handle_t self, audio_buffer_t *in, audio_buffer_t *out) {
auto e = (handle *) self;
return e->effect->process(in, out);
}
static int32_t generic_command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize, void *pCmdData, uint32_t *replySize, void *pReplyData) {
auto e = (handle *) self;
return e->effect->command(cmdCode, cmdSize, pCmdData, replySize, pReplyData);
}
static int32_t generic_getDescriptor(effect_handle_t self, effect_descriptor_t *pDescriptor) {
auto e = (handle *) self;
strcpy(viper_descriptor.name, "ViPER4Android Reworked [1.0.0.0]");
strcpy(viper_descriptor.implementor, "ViPER.WYF, Martmists, Iscle");
memcpy(pDescriptor, e->descriptor, sizeof(effect_descriptor_t));
return 0;
}
const effect_interface_s viper_interface = {
.process = generic_process,
.command = generic_command,
.get_descriptor = generic_getDescriptor,
.process_reverse = nullptr
};
int32_t EffectCreate(const effect_uuid_t *uuid, int32_t sessionId, int32_t ioId, effect_handle_t *pEffect) {
if (memcmp(uuid, &viper_descriptor.uuid, sizeof(effect_uuid_t)) == 0) {
// UUID matches
strcpy(viper_descriptor.name, "ViPER4Android Reworked [1.0.0.0]");
strcpy(viper_descriptor.implementor, "ViPER.WYF, Martmists, Iscle");
auto ptr = (handle*)calloc(1, sizeof(handle));
ptr->interface = &viper_interface;
ptr->effect = new ProcessUnit_FX();
ptr->descriptor = &viper_descriptor;
*pEffect = (effect_handle_t)ptr;
} else {
return -ENOENT;
}
return 0;
}
int32_t EffectRelease(effect_handle_t ei) {
auto ptr = (handle*)ei;
delete ptr->effect;
free(ptr);
return 0;
}
int32_t EffectGetDescriptor(const effect_uuid_t *uuid, effect_descriptor_t *pDescriptor) {
if (memcmp(uuid, &viper_descriptor.uuid, sizeof(effect_uuid_t)) == 0) {
strcpy(viper_descriptor.name, "ViPER4Android Reworked [1.0.0.0]");
strcpy(viper_descriptor.implementor, "ViPER.WYF, Martmists, Iscle");
memcpy(pDescriptor, &viper_descriptor, sizeof(effect_descriptor_t));
} else {
return -EINVAL;
}
return 0;
}
audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = {
.tag = ((('A') << 24) | (('E') << 16) | (('L') << 8) | ('I')),
.version = 0x30000,
.name = "ViPER4Android FX Reworked",
.implementor = "ViPER.WYF, Martmists, Iscle",
.create_effect = EffectCreate,
.release_effect = EffectRelease,
.get_descriptor = EffectGetDescriptor,
};
}

165
src/viper.h Normal file
View File

@ -0,0 +1,165 @@
//
// Created by mart on 7/26/21.
//
#pragma once
// Source: https://github.com/vipersaudio/viperfx_core_binary/blob/master/viperfx_intf.h
extern "C" {
enum
{
COMMAND_CODE_GET = 0x01,
COMMAND_CODE_SET,
};
enum
{
PARAM_GET_STATUS_BEGIN = 0x08000,
PARAM_GET_DRIVER_VERSION,
PARAM_GET_NEONENABLED,
PARAM_GET_ENABLED,
PARAM_GET_DRVCANWORK,
PARAM_GET_EFFECT_TYPE,
PARAM_GET_SAMPLINGRATE,
PARAM_GET_CONVKNLID,
PARAM_GET_STATUS_END
};
enum
{
PARAM_SET_STATUS_BEGIN = 0x09000,
PARAM_SET_RESET_STATUS,
PARAM_SET_SAMPLINGRATE,
PARAM_SET_DOPROCESS_STATUS,
PARAM_SET_STATUS_END
};
enum
{
PARAM_PROCESSUNIT_FX_BEGIN = 0x10000,
PARAM_FX_TYPE_SWITCH,
PARAM_HPFX_CONV_PROCESS_ENABLED,
PARAM_HPFX_CONV_UPDATEKERNEL,
/*****************************************/
// Please use PARAM_HPFX_CONV_UPDATEKERNEL instead
PARAM_HPFX_CONV_PREPAREBUFFER,
PARAM_HPFX_CONV_SETBUFFER,
PARAM_HPFX_CONV_COMMITBUFFER,
/*****************************************/
PARAM_HPFX_CONV_CROSSCHANNEL,
PARAM_HPFX_VHE_PROCESS_ENABLED,
PARAM_HPFX_VHE_EFFECT_LEVEL,
PARAM_HPFX_VDDC_PROCESS_ENABLED,
PARAM_HPFX_VDDC_COEFFS,
PARAM_HPFX_VSE_PROCESS_ENABLED,
PARAM_HPFX_VSE_REFERENCE_BARK,
PARAM_HPFX_VSE_BARK_RECONSTRUCT,
PARAM_HPFX_FIREQ_PROCESS_ENABLED,
PARAM_HPFX_FIREQ_BANDLEVEL,
PARAM_HPFX_COLM_PROCESS_ENABLED,
PARAM_HPFX_COLM_WIDENING,
PARAM_HPFX_COLM_MIDIMAGE,
PARAM_HPFX_COLM_DEPTH,
PARAM_HPFX_DIFFSURR_PROCESS_ENABLED,
PARAM_HPFX_DIFFSURR_DELAYTIME,
PARAM_HPFX_REVB_PROCESS_ENABLED,
PARAM_HPFX_REVB_ROOMSIZE,
PARAM_HPFX_REVB_WIDTH,
PARAM_HPFX_REVB_DAMP,
PARAM_HPFX_REVB_WET,
PARAM_HPFX_REVB_DRY,
PARAM_HPFX_AGC_PROCESS_ENABLED,
PARAM_HPFX_AGC_RATIO,
PARAM_HPFX_AGC_VOLUME,
PARAM_HPFX_AGC_MAXSCALER,
PARAM_HPFX_DYNSYS_PROCESS_ENABLED,
PARAM_HPFX_DYNSYS_XCOEFFS,
PARAM_HPFX_DYNSYS_YCOEFFS,
PARAM_HPFX_DYNSYS_SIDEGAIN,
PARAM_HPFX_DYNSYS_BASSGAIN,
PARAM_HPFX_VIPERBASS_PROCESS_ENABLED,
PARAM_HPFX_VIPERBASS_MODE,
PARAM_HPFX_VIPERBASS_SPEAKER,
PARAM_HPFX_VIPERBASS_BASSGAIN,
PARAM_HPFX_VIPERCLARITY_PROCESS_ENABLED,
PARAM_HPFX_VIPERCLARITY_MODE,
PARAM_HPFX_VIPERCLARITY_CLARITY,
PARAM_HPFX_CURE_PROCESS_ENABLED,
PARAM_HPFX_CURE_CROSSFEED,
PARAM_HPFX_TUBE_PROCESS_ENABLED,
PARAM_HPFX_ANALOGX_PROCESS_ENABLED,
PARAM_HPFX_ANALOGX_MODE,
PARAM_HPFX_OUTPUT_VOLUME,
PARAM_HPFX_OUTPUT_PAN,
PARAM_HPFX_LIMITER_THRESHOLD,
PARAM_SPKFX_CONV_PROCESS_ENABLED,
PARAM_SPKFX_CONV_UPDATEKERNEL,
PARAM_SPKFX_CONV_PREPAREBUFFER,
PARAM_SPKFX_CONV_SETBUFFER,
PARAM_SPKFX_CONV_COMMITBUFFER,
PARAM_SPKFX_CONV_CROSSCHANNEL,
PARAM_SPKFX_FIREQ_PROCESS_ENABLED,
PARAM_SPKFX_FIREQ_BANDLEVEL,
PARAM_SPKFX_REVB_PROCESS_ENABLED,
PARAM_SPKFX_REVB_ROOMSIZE,
PARAM_SPKFX_REVB_WIDTH,
PARAM_SPKFX_REVB_DAMP,
PARAM_SPKFX_REVB_WET,
PARAM_SPKFX_REVB_DRY,
PARAM_SPKFX_AGC_PROCESS_ENABLED,
PARAM_SPKFX_AGC_RATIO,
PARAM_SPKFX_AGC_VOLUME,
PARAM_SPKFX_AGC_MAXSCALER,
PARAM_SPKFX_OUTPUT_VOLUME,
PARAM_SPKFX_LIMITER_THRESHOLD,
PARAM_HPFX_FETCOMP_PROCESS_ENABLED,
PARAM_HPFX_FETCOMP_THRESHOLD,
PARAM_HPFX_FETCOMP_RATIO,
PARAM_HPFX_FETCOMP_KNEEWIDTH,
PARAM_HPFX_FETCOMP_AUTOKNEE_ENABLED,
PARAM_HPFX_FETCOMP_GAIN,
PARAM_HPFX_FETCOMP_AUTOGAIN_ENABLED,
PARAM_HPFX_FETCOMP_ATTACK,
PARAM_HPFX_FETCOMP_AUTOATTACK_ENABLED,
PARAM_HPFX_FETCOMP_RELEASE,
PARAM_HPFX_FETCOMP_AUTORELEASE_ENABLED,
PARAM_HPFX_FETCOMP_META_KNEEMULTI,
PARAM_HPFX_FETCOMP_META_MAXATTACK,
PARAM_HPFX_FETCOMP_META_MAXRELEASE,
PARAM_HPFX_FETCOMP_META_CREST,
PARAM_HPFX_FETCOMP_META_ADAPT,
PARAM_HPFX_FETCOMP_META_NOCLIP_ENABLED,
PARAM_SPKFX_FETCOMP_PROCESS_ENABLED,
PARAM_SPKFX_FETCOMP_THRESHOLD,
PARAM_SPKFX_FETCOMP_RATIO,
PARAM_SPKFX_FETCOMP_KNEEWIDTH,
PARAM_SPKFX_FETCOMP_AUTOKNEE_ENABLED,
PARAM_SPKFX_FETCOMP_GAIN,
PARAM_SPKFX_FETCOMP_AUTOGAIN_ENABLED,
PARAM_SPKFX_FETCOMP_ATTACK,
PARAM_SPKFX_FETCOMP_AUTOATTACK_ENABLED,
PARAM_SPKFX_FETCOMP_RELEASE,
PARAM_SPKFX_FETCOMP_AUTORELEASE_ENABLED,
PARAM_SPKFX_FETCOMP_META_KNEEMULTI,
PARAM_SPKFX_FETCOMP_META_MAXATTACK,
PARAM_SPKFX_FETCOMP_META_MAXRELEASE,
PARAM_SPKFX_FETCOMP_META_CREST,
PARAM_SPKFX_FETCOMP_META_ADAPT,
PARAM_SPKFX_FETCOMP_META_NOCLIP_ENABLED,
PARAM_PROCESSUNIT_FX_END
};
enum
{
ViPER_FX_TYPE_NONE = 0,
ViPER_FX_TYPE_HEADPHONE = 1,
ViPER_FX_TYPE_SPEAKER = 2,
ViPER_FX_TYPE_COUNT
};
}