Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 11:36:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge "Revert "Audio V4: Split system and vendor Audio.h""

Browse Source
This commit is contained in:
Kevin Rocard
2018-01-24 06:26:16 +00:00
committed by Android (Google) Code Review
parent 2414a91a36 8bdafc1b5c
commit 72993ce086
57 changed files with 27 additions and 5983 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
audio/README
View File

@@ -7,18 +7,15 @@ audio
|-- common <== code common to audio core and effect API
| |-- 2.0
| | |-- default <== code that wraps the legacy API
| | |-- legacy <== legacy API compatible with 2.0
| | `-- vts <== vts of 2.0 core and effect API common code
| |-- 4.0
| | |-- default
| | |-- legacy
| | `-- vts
| |-- ... <== The future versions should continue this structure
| | |-- default
| | `-- vts
| `-- all_versions <== code common to all version of both core and effect API
| |-- default
| | |-- legacy <== legacy API compatible with all versions
| `-- vts <== vts of core and effect API common version independent code
|
|-- core <== code relative to the core API
@@ -38,17 +35,13 @@ audio
`-- effect <== idem for the effect API
|-- 2.0
| |-- default
| |-- legacy <== legacy effect API compatible with 2.0
| `-- vts
|-- 4.0
| |-- default
| |-- legacy
| `-- vts
|-- ...
| |-- default
| |-- default
| `-- vts
`-- all_versions
|-- default
|-- legacy
`-- vts

7
audio/common/2.0/default/Android.bp
View File

@@ -16,7 +16,10 @@
cc_library_shared {
name: "android.hardware.audio.common@2.0-util",
defaults: ["hidl_defaults"],
vendor: true,
vendor_available: true,
vndk: {
enabled: true,
},
srcs: [
"HidlUtils.cpp",
],
@@ -38,7 +41,7 @@ cc_library_shared {
],
header_libs: [
"android.hardware.audio.common.legacy@2.0",
"libaudio_system_headers",
"libhardware_headers",
],
}

15
audio/common/2.0/legacy/Android.bp
View File

@@ -1,15 +0,0 @@
cc_library_headers {
name: "android.hardware.audio.common.legacy@2.0",
vendor: true,
header_libs: [
"libhardware_headers",
"android.hardware.audio.common.legacy@all-versions",
],
export_header_lib_headers: [
"libhardware_headers",
"android.hardware.audio.common.legacy@all-versions",
],
export_include_dirs: ["include"],
}

3
audio/common/2.0/legacy/OWNERS
View File

@@ -1,3 +0,0 @@
elaurent@google.com
krocard@google.com
mnaganov@google.com

709
audio/common/2.0/legacy/include/hardware/audio.h
View File

@@ -1,709 +0,0 @@
/*
* 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_HAL_INTERFACE_H
#define ANDROID_AUDIO_HAL_INTERFACE_H
#include <stdint.h>
#include <strings.h>
#include <sys/cdefs.h>
#include <sys/types.h>
#include <time.h>
#include <cutils/bitops.h>
#include <hardware/audio_effect.h>
#include <hardware/hardware.h>
#include <system/audio.h>
__BEGIN_DECLS
/**
* The id of this module
*/
#define AUDIO_HARDWARE_MODULE_ID "audio"
/**
* Name of the audio devices to open
*/
#define AUDIO_HARDWARE_INTERFACE "audio_hw_if"
/* Use version 0.1 to be compatible with first generation of audio hw module with version_major
* hardcoded to 1. No audio module API change.
*/
#define AUDIO_MODULE_API_VERSION_0_1 HARDWARE_MODULE_API_VERSION(0, 1)
#define AUDIO_MODULE_API_VERSION_CURRENT AUDIO_MODULE_API_VERSION_0_1
/* First generation of audio devices had version hardcoded to 0. all devices with versions < 1.0
* will be considered of first generation API.
*/
#define AUDIO_DEVICE_API_VERSION_0_0 HARDWARE_DEVICE_API_VERSION(0, 0)
#define AUDIO_DEVICE_API_VERSION_1_0 HARDWARE_DEVICE_API_VERSION(1, 0)
#define AUDIO_DEVICE_API_VERSION_2_0 HARDWARE_DEVICE_API_VERSION(2, 0)
#define AUDIO_DEVICE_API_VERSION_3_0 HARDWARE_DEVICE_API_VERSION(3, 0)
#define AUDIO_DEVICE_API_VERSION_CURRENT AUDIO_DEVICE_API_VERSION_3_0
/* Minimal audio HAL version supported by the audio framework */
#define AUDIO_DEVICE_API_VERSION_MIN AUDIO_DEVICE_API_VERSION_2_0
/**************************************/
/**
* standard audio parameters that the HAL may need to handle
*/
/**
* audio device parameters
*/
/* TTY mode selection */
#define AUDIO_PARAMETER_KEY_TTY_MODE "tty_mode"
#define AUDIO_PARAMETER_VALUE_TTY_OFF "tty_off"
#define AUDIO_PARAMETER_VALUE_TTY_VCO "tty_vco"
#define AUDIO_PARAMETER_VALUE_TTY_HCO "tty_hco"
#define AUDIO_PARAMETER_VALUE_TTY_FULL "tty_full"
/* Hearing Aid Compatibility - Telecoil (HAC-T) mode on/off */
#define AUDIO_PARAMETER_KEY_HAC "HACSetting"
#define AUDIO_PARAMETER_VALUE_HAC_ON "ON"
#define AUDIO_PARAMETER_VALUE_HAC_OFF "OFF"
/* A2DP sink address set by framework */
#define AUDIO_PARAMETER_A2DP_SINK_ADDRESS "a2dp_sink_address"
/* A2DP source address set by framework */
#define AUDIO_PARAMETER_A2DP_SOURCE_ADDRESS "a2dp_source_address"
/* Bluetooth SCO wideband */
#define AUDIO_PARAMETER_KEY_BT_SCO_WB "bt_wbs"
/**
* audio stream parameters
*/
/* Enable AANC */
#define AUDIO_PARAMETER_KEY_AANC "aanc_enabled"
/**************************************/
/* common audio stream parameters and operations */
struct audio_stream {
/**
* Return the sampling rate in Hz - eg. 44100.
*/
uint32_t (*get_sample_rate)(const struct audio_stream* stream);
/* currently unused - use set_parameters with key
* AUDIO_PARAMETER_STREAM_SAMPLING_RATE
*/
int (*set_sample_rate)(struct audio_stream* stream, uint32_t rate);
/**
* Return size of input/output buffer in bytes for this stream - eg. 4800.
* It should be a multiple of the frame size. See also get_input_buffer_size.
*/
size_t (*get_buffer_size)(const struct audio_stream* stream);
/**
* Return the channel mask -
* e.g. AUDIO_CHANNEL_OUT_STEREO or AUDIO_CHANNEL_IN_STEREO
*/
audio_channel_mask_t (*get_channels)(const struct audio_stream* stream);
/**
* Return the audio format - e.g. AUDIO_FORMAT_PCM_16_BIT
*/
audio_format_t (*get_format)(const struct audio_stream* stream);
/* currently unused - use set_parameters with key
* AUDIO_PARAMETER_STREAM_FORMAT
*/
int (*set_format)(struct audio_stream* stream, audio_format_t format);
/**
* Put the audio hardware input/output into standby mode.
* Driver should exit from standby mode at the next I/O operation.
* Returns 0 on success and <0 on failure.
*/
int (*standby)(struct audio_stream* stream);
/** dump the state of the audio input/output device */
int (*dump)(const struct audio_stream* stream, int fd);
/** Return the set of device(s) which this stream is connected to */
audio_devices_t (*get_device)(const struct audio_stream* stream);
/**
* Currently unused - set_device() corresponds to set_parameters() with key
* AUDIO_PARAMETER_STREAM_ROUTING for both input and output.
* AUDIO_PARAMETER_STREAM_INPUT_SOURCE is an additional information used by
* input streams only.
*/
int (*set_device)(struct audio_stream* stream, audio_devices_t device);
/**
* set/get audio stream parameters. The function accepts a list of
* parameter key value pairs in the form: key1=value1;key2=value2;...
*
* Some keys are reserved for standard parameters (See AudioParameter class)
*
* If the implementation does not accept a parameter change while
* the output is active but the parameter is acceptable otherwise, it must
* return -ENOSYS.
*
* The audio flinger will put the stream in standby and then change the
* parameter value.
*/
int (*set_parameters)(struct audio_stream* stream, const char* kv_pairs);
/*
* Returns a pointer to a heap allocated string. The caller is responsible
* for freeing the memory for it using free().
*/
char* (*get_parameters)(const struct audio_stream* stream, const char* keys);
int (*add_audio_effect)(const struct audio_stream* stream, effect_handle_t effect);
int (*remove_audio_effect)(const struct audio_stream* stream, effect_handle_t effect);
};
typedef struct audio_stream audio_stream_t;
/* type of asynchronous write callback events. Mutually exclusive */
typedef enum {
STREAM_CBK_EVENT_WRITE_READY, /* non blocking write completed */
STREAM_CBK_EVENT_DRAIN_READY, /* drain completed */
STREAM_CBK_EVENT_ERROR, /* stream hit some error, let AF take action */
} stream_callback_event_t;
typedef int (*stream_callback_t)(stream_callback_event_t event, void* param, void* cookie);
/* type of drain requested to audio_stream_out->drain(). Mutually exclusive */
typedef enum {
AUDIO_DRAIN_ALL, /* drain() returns when all data has been played */
AUDIO_DRAIN_EARLY_NOTIFY /* drain() returns a short time before all data
from the current track has been played to
give time for gapless track switch */
} audio_drain_type_t;
/**
* audio_stream_out is the abstraction interface for the audio output hardware.
*
* It provides information about various properties of the audio output
* hardware driver.
*/
struct audio_stream_out {
/**
* Common methods of the audio stream out. This *must* be the first member of audio_stream_out
* as users of this structure will cast a audio_stream to audio_stream_out pointer in contexts
* where it's known the audio_stream references an audio_stream_out.
*/
struct audio_stream common;
/**
* Return the audio hardware driver estimated latency in milliseconds.
*/
uint32_t (*get_latency)(const struct audio_stream_out* stream);
/**
* Use this method in situations where audio mixing is done in the
* hardware. This method serves as a direct interface with hardware,
* allowing you to directly set the volume as apposed to via the framework.
* This method might produce multiple PCM outputs or hardware accelerated
* codecs, such as MP3 or AAC.
*/
int (*set_volume)(struct audio_stream_out* stream, float left, float right);
/**
* Write audio buffer to driver. Returns number of bytes written, or a
* negative status_t. If at least one frame was written successfully prior to the error,
* it is suggested that the driver return that successful (short) byte count
* and then return an error in the subsequent call.
*
* If set_callback() has previously been called to enable non-blocking mode
* the write() is not allowed to block. It must write only the number of
* bytes that currently fit in the driver/hardware buffer and then return
* this byte count. If this is less than the requested write size the
* callback function must be called when more space is available in the
* driver/hardware buffer.
*/
ssize_t (*write)(struct audio_stream_out* stream, const void* buffer, size_t bytes);
/* return the number of audio frames written by the audio dsp to DAC since
* the output has exited standby
*/
int (*get_render_position)(const struct audio_stream_out* stream, uint32_t* dsp_frames);
/**
* get the local time at which the next write to the audio driver will be presented.
* The units are microseconds, where the epoch is decided by the local audio HAL.
*/
int (*get_next_write_timestamp)(const struct audio_stream_out* stream, int64_t* timestamp);
/**
* set the callback function for notifying completion of non-blocking
* write and drain.
* Calling this function implies that all future write() and drain()
* must be non-blocking and use the callback to signal completion.
*/
int (*set_callback)(struct audio_stream_out* stream, stream_callback_t callback, void* cookie);
/**
* Notifies to the audio driver to stop playback however the queued buffers are
* retained by the hardware. Useful for implementing pause/resume. Empty implementation
* if not supported however should be implemented for hardware with non-trivial
* latency. In the pause state audio hardware could still be using power. User may
* consider calling suspend after a timeout.
*
* Implementation of this function is mandatory for offloaded playback.
*/
int (*pause)(struct audio_stream_out* stream);
/**
* Notifies to the audio driver to resume playback following a pause.
* Returns error if called without matching pause.
*
* Implementation of this function is mandatory for offloaded playback.
*/
int (*resume)(struct audio_stream_out* stream);
/**
* Requests notification when data buffered by the driver/hardware has
* been played. If set_callback() has previously been called to enable
* non-blocking mode, the drain() must not block, instead it should return
* quickly and completion of the drain is notified through the callback.
* If set_callback() has not been called, the drain() must block until
* completion.
* If type==AUDIO_DRAIN_ALL, the drain completes when all previously written
* data has been played.
* If type==AUDIO_DRAIN_EARLY_NOTIFY, the drain completes shortly before all
* data for the current track has played to allow time for the framework
* to perform a gapless track switch.
*
* Drain must return immediately on stop() and flush() call
*
* Implementation of this function is mandatory for offloaded playback.
*/
int (*drain)(struct audio_stream_out* stream, audio_drain_type_t type);
/**
* Notifies to the audio driver to flush the queued data. Stream must already
* be paused before calling flush().
*
* Implementation of this function is mandatory for offloaded playback.
*/
int (*flush)(struct audio_stream_out* stream);
/**
* Return a recent count of the number of audio frames presented to an external observer.
* This excludes frames which have been written but are still in the pipeline.
* The count is not reset to zero when output enters standby.
* Also returns the value of CLOCK_MONOTONIC as of this presentation count.
* The returned count is expected to be 'recent',
* but does not need to be the most recent possible value.
* However, the associated time should correspond to whatever count is returned.
* Example: assume that N+M frames have been presented, where M is a 'small' number.
* Then it is permissible to return N instead of N+M,
* and the timestamp should correspond to N rather than N+M.
* The terms 'recent' and 'small' are not defined.
* They reflect the quality of the implementation.
*
* 3.0 and higher only.
*/
int (*get_presentation_position)(const struct audio_stream_out* stream, uint64_t* frames,
struct timespec* timestamp);
/**
* Called by the framework to start a stream operating in mmap mode.
* create_mmap_buffer must be called before calling start()
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \return 0 in case of success.
* -ENOSYS if called out of sequence or on non mmap stream
*/
int (*start)(const struct audio_stream_out* stream);
/**
* Called by the framework to stop a stream operating in mmap mode.
* Must be called after start()
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \return 0 in case of success.
* -ENOSYS if called out of sequence or on non mmap stream
*/
int (*stop)(const struct audio_stream_out* stream);
/**
* Called by the framework to retrieve information on the mmap buffer used for audio
* samples transfer.
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \param[in] min_size_frames minimum buffer size requested. The actual buffer
* size returned in struct audio_mmap_buffer_info can be larger.
* \param[out] info address at which the mmap buffer information should be returned.
*
* \return 0 if the buffer was allocated.
* -ENODEV in case of initialization error
* -EINVAL if the requested buffer size is too large
* -ENOSYS if called out of sequence (e.g. buffer already allocated)
*/
int (*create_mmap_buffer)(const struct audio_stream_out* stream, int32_t min_size_frames,
struct audio_mmap_buffer_info* info);
/**
* Called by the framework to read current read/write position in the mmap buffer
* with associated time stamp.
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \param[out] position address at which the mmap read/write position should be returned.
*
* \return 0 if the position is successfully returned.
* -ENODATA if the position cannot be retrieved
* -ENOSYS if called before create_mmap_buffer()
*/
int (*get_mmap_position)(const struct audio_stream_out* stream,
struct audio_mmap_position* position);
};
typedef struct audio_stream_out audio_stream_out_t;
struct audio_stream_in {
/**
* Common methods of the audio stream in. This *must* be the first member of audio_stream_in
* as users of this structure will cast a audio_stream to audio_stream_in pointer in contexts
* where it's known the audio_stream references an audio_stream_in.
*/
struct audio_stream common;
/** set the input gain for the audio driver. This method is for
* for future use */
int (*set_gain)(struct audio_stream_in* stream, float gain);
/** Read audio buffer in from audio driver. Returns number of bytes read, or a
* negative status_t. If at least one frame was read prior to the error,
* read should return that byte count and then return an error in the subsequent call.
*/
ssize_t (*read)(struct audio_stream_in* stream, void* buffer, size_t bytes);
/**
* Return the amount of input frames lost in the audio driver since the
* last call of this function.
* Audio driver is expected to reset the value to 0 and restart counting
* upon returning the current value by this function call.
* Such loss typically occurs when the user space process is blocked
* longer than the capacity of audio driver buffers.
*
* Unit: the number of input audio frames
*/
uint32_t (*get_input_frames_lost)(struct audio_stream_in* stream);
/**
* Return a recent count of the number of audio frames received and
* the clock time associated with that frame count.
*
* frames is the total frame count received. This should be as early in
* the capture pipeline as possible. In general,
* frames should be non-negative and should not go "backwards".
*
* time is the clock MONOTONIC time when frames was measured. In general,
* time should be a positive quantity and should not go "backwards".
*
* The status returned is 0 on success, -ENOSYS if the device is not
* ready/available, or -EINVAL if the arguments are null or otherwise invalid.
*/
int (*get_capture_position)(const struct audio_stream_in* stream, int64_t* frames,
int64_t* time);
/**
* Called by the framework to start a stream operating in mmap mode.
* create_mmap_buffer must be called before calling start()
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \return 0 in case off success.
* -ENOSYS if called out of sequence or on non mmap stream
*/
int (*start)(const struct audio_stream_in* stream);
/**
* Called by the framework to stop a stream operating in mmap mode.
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \return 0 in case of success.
* -ENOSYS if called out of sequence or on non mmap stream
*/
int (*stop)(const struct audio_stream_in* stream);
/**
* Called by the framework to retrieve information on the mmap buffer used for audio
* samples transfer.
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \param[in] min_size_frames minimum buffer size requested. The actual buffer
* size returned in struct audio_mmap_buffer_info can be larger.
* \param[out] info address at which the mmap buffer information should be returned.
*
* \return 0 if the buffer was allocated.
* -ENODEV in case of initialization error
* -EINVAL if the requested buffer size is too large
* -ENOSYS if called out of sequence (e.g. buffer already allocated)
*/
int (*create_mmap_buffer)(const struct audio_stream_in* stream, int32_t min_size_frames,
struct audio_mmap_buffer_info* info);
/**
* Called by the framework to read current read/write position in the mmap buffer
* with associated time stamp.
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \param[out] position address at which the mmap read/write position should be returned.
*
* \return 0 if the position is successfully returned.
* -ENODATA if the position cannot be retreived
* -ENOSYS if called before mmap_read_position()
*/
int (*get_mmap_position)(const struct audio_stream_in* stream,
struct audio_mmap_position* position);
};
typedef struct audio_stream_in audio_stream_in_t;
/**
* return the frame size (number of bytes per sample).
*
* Deprecated: use audio_stream_out_frame_size() or audio_stream_in_frame_size() instead.
*/
__attribute__((__deprecated__)) static inline size_t audio_stream_frame_size(
const struct audio_stream* s) {
size_t chan_samp_sz;
audio_format_t format = s->get_format(s);
if (audio_has_proportional_frames(format)) {
chan_samp_sz = audio_bytes_per_sample(format);
return popcount(s->get_channels(s)) * chan_samp_sz;
}
return sizeof(int8_t);
}
/**
* return the frame size (number of bytes per sample) of an output stream.
*/
static inline size_t audio_stream_out_frame_size(const struct audio_stream_out* s) {
size_t chan_samp_sz;
audio_format_t format = s->common.get_format(&s->common);
if (audio_has_proportional_frames(format)) {
chan_samp_sz = audio_bytes_per_sample(format);
return audio_channel_count_from_out_mask(s->common.get_channels(&s->common)) * chan_samp_sz;
}
return sizeof(int8_t);
}
/**
* return the frame size (number of bytes per sample) of an input stream.
*/
static inline size_t audio_stream_in_frame_size(const struct audio_stream_in* s) {
size_t chan_samp_sz;
audio_format_t format = s->common.get_format(&s->common);
if (audio_has_proportional_frames(format)) {
chan_samp_sz = audio_bytes_per_sample(format);
return audio_channel_count_from_in_mask(s->common.get_channels(&s->common)) * chan_samp_sz;
}
return sizeof(int8_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.
*/
struct audio_module {
struct hw_module_t common;
};
struct audio_hw_device {
/**
* Common methods of the audio device. This *must* be the first member of audio_hw_device
* as users of this structure will cast a hw_device_t to audio_hw_device pointer in contexts
* where it's known the hw_device_t references an audio_hw_device.
*/
struct hw_device_t common;
/**
* used by audio flinger to enumerate what devices are supported by
* each audio_hw_device implementation.
*
* Return value is a bitmask of 1 or more values of audio_devices_t
*
* NOTE: audio HAL implementations starting with
* AUDIO_DEVICE_API_VERSION_2_0 do not implement this function.
* All supported devices should be listed in audio_policy.conf
* file and the audio policy manager must choose the appropriate
* audio module based on information in this file.
*/
uint32_t (*get_supported_devices)(const struct audio_hw_device* dev);
/**
* check to see if the audio hardware interface has been initialized.
* returns 0 on success, -ENODEV on failure.
*/
int (*init_check)(const struct audio_hw_device* dev);
/** set the audio volume of a voice call. Range is between 0.0 and 1.0 */
int (*set_voice_volume)(struct audio_hw_device* dev, float volume);
/**
* set the audio volume for all audio activities other than voice call.
* Range between 0.0 and 1.0. If any value other than 0 is returned,
* the software mixer will emulate this capability.
*/
int (*set_master_volume)(struct audio_hw_device* dev, float volume);
/**
* Get the current master volume value for the HAL, if the HAL supports
* master volume control. AudioFlinger will query this value from the
* primary audio HAL when the service starts and use the value for setting
* the initial master volume across all HALs. HALs which do not support
* this method may leave it set to NULL.
*/
int (*get_master_volume)(struct audio_hw_device* dev, float* volume);
/**
* set_mode is called when the audio mode changes. AUDIO_MODE_NORMAL mode
* is for standard audio playback, AUDIO_MODE_RINGTONE when a ringtone is
* playing, and AUDIO_MODE_IN_CALL when a call is in progress.
*/
int (*set_mode)(struct audio_hw_device* dev, audio_mode_t mode);
/* mic mute */
int (*set_mic_mute)(struct audio_hw_device* dev, bool state);
int (*get_mic_mute)(const struct audio_hw_device* dev, bool* state);
/* set/get global audio parameters */
int (*set_parameters)(struct audio_hw_device* dev, const char* kv_pairs);
/*
* Returns a pointer to a heap allocated string. The caller is responsible
* for freeing the memory for it using free().
*/
char* (*get_parameters)(const struct audio_hw_device* dev, const char* keys);
/* Returns audio input buffer size according to parameters passed or
* 0 if one of the parameters is not supported.
* See also get_buffer_size which is for a particular stream.
*/
size_t (*get_input_buffer_size)(const struct audio_hw_device* dev,
const struct audio_config* config);
/** This method creates and opens the audio hardware output stream.
* The "address" parameter qualifies the "devices" audio device type if needed.
* The format format depends on the device type:
* - Bluetooth devices use the MAC address of the device in the form "00:11:22:AA:BB:CC"
* - USB devices use the ALSA card and device numbers in the form "card=X;device=Y"
* - Other devices may use a number or any other string.
*/
int (*open_output_stream)(struct audio_hw_device* dev, audio_io_handle_t handle,
audio_devices_t devices, audio_output_flags_t flags,
struct audio_config* config, struct audio_stream_out** stream_out,
const char* address);
void (*close_output_stream)(struct audio_hw_device* dev, struct audio_stream_out* stream_out);
/** This method creates and opens the audio hardware input stream */
int (*open_input_stream)(struct audio_hw_device* dev, audio_io_handle_t handle,
audio_devices_t devices, struct audio_config* config,
struct audio_stream_in** stream_in, audio_input_flags_t flags,
const char* address, audio_source_t source);
void (*close_input_stream)(struct audio_hw_device* dev, struct audio_stream_in* stream_in);
/** This method dumps the state of the audio hardware */
int (*dump)(const struct audio_hw_device* dev, int fd);
/**
* set the audio mute status for all audio activities. If any value other
* than 0 is returned, the software mixer will emulate this capability.
*/
int (*set_master_mute)(struct audio_hw_device* dev, bool mute);
/**
* Get the current master mute status for the HAL, if the HAL supports
* master mute control. AudioFlinger will query this value from the primary
* audio HAL when the service starts and use the value for setting the
* initial master mute across all HALs. HALs which do not support this
* method may leave it set to NULL.
*/
int (*get_master_mute)(struct audio_hw_device* dev, bool* mute);
/**
* Routing control
*/
/* Creates an audio patch between several source and sink ports.
* The handle is allocated by the HAL and should be unique for this
* audio HAL module. */
int (*create_audio_patch)(struct audio_hw_device* dev, unsigned int num_sources,
const struct audio_port_config* sources, unsigned int num_sinks,
const struct audio_port_config* sinks, audio_patch_handle_t* handle);
/* Release an audio patch */
int (*release_audio_patch)(struct audio_hw_device* dev, audio_patch_handle_t handle);
/* Fills the list of supported attributes for a given audio port.
* As input, "port" contains the information (type, role, address etc...)
* needed by the HAL to identify the port.
* As output, "port" contains possible attributes (sampling rates, formats,
* channel masks, gain controllers...) for this port.
*/
int (*get_audio_port)(struct audio_hw_device* dev, struct audio_port* port);
/* Set audio port configuration */
int (*set_audio_port_config)(struct audio_hw_device* dev,
const struct audio_port_config* config);
};
typedef struct audio_hw_device audio_hw_device_t;
/** convenience API for opening and closing a supported device */
static inline int audio_hw_device_open(const struct hw_module_t* module,
struct audio_hw_device** device) {
return module->methods->open(module, AUDIO_HARDWARE_INTERFACE, TO_HW_DEVICE_T_OPEN(device));
}
static inline int audio_hw_device_close(struct audio_hw_device* device) {
return device->common.close(&device->common);
}
__END_DECLS
#endif // ANDROID_AUDIO_INTERFACE_H

434
audio/common/2.0/legacy/include/system/audio-base.h
View File

@@ -1,434 +0,0 @@
// This file is autogenerated by hidl-gen. Do not edit manually.
// Source: android.hardware.audio.common@2.0
// Root: android.hardware:hardware/interfaces
#ifndef HIDL_GENERATED_ANDROID_HARDWARE_AUDIO_COMMON_V2_0_EXPORTED_CONSTANTS_H_
#define HIDL_GENERATED_ANDROID_HARDWARE_AUDIO_COMMON_V2_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,
AUDIO_STREAM_REROUTING = 11,
AUDIO_STREAM_PATCH = 12,
AUDIO_STREAM_PUBLIC_CNT = 11, // (ACCESSIBILITY + 1)
AUDIO_STREAM_FOR_POLICY_CNT = 12, // PATCH
AUDIO_STREAM_CNT = 13, // (PATCH + 1)
} 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_CNT = 10,
AUDIO_SOURCE_MAX = 9, // (CNT - 1)
AUDIO_SOURCE_FM_TUNER = 1998,
AUDIO_SOURCE_HOTWORD = 1999,
} 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 = 4294967295u, // 0xFFFFFFFFUL
AUDIO_FORMAT_DEFAULT = 0u, // 0
AUDIO_FORMAT_PCM = 0u, // 0x00000000UL
AUDIO_FORMAT_MP3 = 16777216u, // 0x01000000UL
AUDIO_FORMAT_AMR_NB = 33554432u, // 0x02000000UL
AUDIO_FORMAT_AMR_WB = 50331648u, // 0x03000000UL
AUDIO_FORMAT_AAC = 67108864u, // 0x04000000UL
AUDIO_FORMAT_HE_AAC_V1 = 83886080u, // 0x05000000UL
AUDIO_FORMAT_HE_AAC_V2 = 100663296u, // 0x06000000UL
AUDIO_FORMAT_VORBIS = 117440512u, // 0x07000000UL
AUDIO_FORMAT_OPUS = 134217728u, // 0x08000000UL
AUDIO_FORMAT_AC3 = 150994944u, // 0x09000000UL
AUDIO_FORMAT_E_AC3 = 167772160u, // 0x0A000000UL
AUDIO_FORMAT_DTS = 184549376u, // 0x0B000000UL
AUDIO_FORMAT_DTS_HD = 201326592u, // 0x0C000000UL
AUDIO_FORMAT_IEC61937 = 218103808u, // 0x0D000000UL
AUDIO_FORMAT_DOLBY_TRUEHD = 234881024u, // 0x0E000000UL
AUDIO_FORMAT_EVRC = 268435456u, // 0x10000000UL
AUDIO_FORMAT_EVRCB = 285212672u, // 0x11000000UL
AUDIO_FORMAT_EVRCWB = 301989888u, // 0x12000000UL
AUDIO_FORMAT_EVRCNW = 318767104u, // 0x13000000UL
AUDIO_FORMAT_AAC_ADIF = 335544320u, // 0x14000000UL
AUDIO_FORMAT_WMA = 352321536u, // 0x15000000UL
AUDIO_FORMAT_WMA_PRO = 369098752u, // 0x16000000UL
AUDIO_FORMAT_AMR_WB_PLUS = 385875968u, // 0x17000000UL
AUDIO_FORMAT_MP2 = 402653184u, // 0x18000000UL
AUDIO_FORMAT_QCELP = 419430400u, // 0x19000000UL
AUDIO_FORMAT_DSD = 436207616u, // 0x1A000000UL
AUDIO_FORMAT_FLAC = 452984832u, // 0x1B000000UL
AUDIO_FORMAT_ALAC = 469762048u, // 0x1C000000UL
AUDIO_FORMAT_APE = 486539264u, // 0x1D000000UL
AUDIO_FORMAT_AAC_ADTS = 503316480u, // 0x1E000000UL
AUDIO_FORMAT_SBC = 520093696u, // 0x1F000000UL
AUDIO_FORMAT_APTX = 536870912u, // 0x20000000UL
AUDIO_FORMAT_APTX_HD = 553648128u, // 0x21000000UL
AUDIO_FORMAT_AC4 = 570425344u, // 0x22000000UL
AUDIO_FORMAT_LDAC = 587202560u, // 0x23000000UL
AUDIO_FORMAT_MAIN_MASK = 4278190080u, // 0xFF000000UL
AUDIO_FORMAT_SUB_MASK = 16777215u, // 0x00FFFFFFUL
AUDIO_FORMAT_PCM_SUB_16_BIT = 1u, // 0x1
AUDIO_FORMAT_PCM_SUB_8_BIT = 2u, // 0x2
AUDIO_FORMAT_PCM_SUB_32_BIT = 3u, // 0x3
AUDIO_FORMAT_PCM_SUB_8_24_BIT = 4u, // 0x4
AUDIO_FORMAT_PCM_SUB_FLOAT = 5u, // 0x5
AUDIO_FORMAT_PCM_SUB_24_BIT_PACKED = 6u, // 0x6
AUDIO_FORMAT_MP3_SUB_NONE = 0u, // 0x0
AUDIO_FORMAT_AMR_SUB_NONE = 0u, // 0x0
AUDIO_FORMAT_AAC_SUB_MAIN = 1u, // 0x1
AUDIO_FORMAT_AAC_SUB_LC = 2u, // 0x2
AUDIO_FORMAT_AAC_SUB_SSR = 4u, // 0x4
AUDIO_FORMAT_AAC_SUB_LTP = 8u, // 0x8
AUDIO_FORMAT_AAC_SUB_HE_V1 = 16u, // 0x10
AUDIO_FORMAT_AAC_SUB_SCALABLE = 32u, // 0x20
AUDIO_FORMAT_AAC_SUB_ERLC = 64u, // 0x40
AUDIO_FORMAT_AAC_SUB_LD = 128u, // 0x80
AUDIO_FORMAT_AAC_SUB_HE_V2 = 256u, // 0x100
AUDIO_FORMAT_AAC_SUB_ELD = 512u, // 0x200
AUDIO_FORMAT_VORBIS_SUB_NONE = 0u, // 0x0
AUDIO_FORMAT_PCM_16_BIT = 1u, // (PCM | PCM_SUB_16_BIT)
AUDIO_FORMAT_PCM_8_BIT = 2u, // (PCM | PCM_SUB_8_BIT)
AUDIO_FORMAT_PCM_32_BIT = 3u, // (PCM | PCM_SUB_32_BIT)
AUDIO_FORMAT_PCM_8_24_BIT = 4u, // (PCM | PCM_SUB_8_24_BIT)
AUDIO_FORMAT_PCM_FLOAT = 5u, // (PCM | PCM_SUB_FLOAT)
AUDIO_FORMAT_PCM_24_BIT_PACKED = 6u, // (PCM | PCM_SUB_24_BIT_PACKED)
AUDIO_FORMAT_AAC_MAIN = 67108865u, // (AAC | AAC_SUB_MAIN)
AUDIO_FORMAT_AAC_LC = 67108866u, // (AAC | AAC_SUB_LC)
AUDIO_FORMAT_AAC_SSR = 67108868u, // (AAC | AAC_SUB_SSR)
AUDIO_FORMAT_AAC_LTP = 67108872u, // (AAC | AAC_SUB_LTP)
AUDIO_FORMAT_AAC_HE_V1 = 67108880u, // (AAC | AAC_SUB_HE_V1)
AUDIO_FORMAT_AAC_SCALABLE = 67108896u, // (AAC | AAC_SUB_SCALABLE)
AUDIO_FORMAT_AAC_ERLC = 67108928u, // (AAC | AAC_SUB_ERLC)
AUDIO_FORMAT_AAC_LD = 67108992u, // (AAC | AAC_SUB_LD)
AUDIO_FORMAT_AAC_HE_V2 = 67109120u, // (AAC | AAC_SUB_HE_V2)
AUDIO_FORMAT_AAC_ELD = 67109376u, // (AAC | AAC_SUB_ELD)
AUDIO_FORMAT_AAC_ADTS_MAIN = 503316481u, // (AAC_ADTS | AAC_SUB_MAIN)
AUDIO_FORMAT_AAC_ADTS_LC = 503316482u, // (AAC_ADTS | AAC_SUB_LC)
AUDIO_FORMAT_AAC_ADTS_SSR = 503316484u, // (AAC_ADTS | AAC_SUB_SSR)
AUDIO_FORMAT_AAC_ADTS_LTP = 503316488u, // (AAC_ADTS | AAC_SUB_LTP)
AUDIO_FORMAT_AAC_ADTS_HE_V1 = 503316496u, // (AAC_ADTS | AAC_SUB_HE_V1)
AUDIO_FORMAT_AAC_ADTS_SCALABLE = 503316512u, // (AAC_ADTS | AAC_SUB_SCALABLE)
AUDIO_FORMAT_AAC_ADTS_ERLC = 503316544u, // (AAC_ADTS | AAC_SUB_ERLC)
AUDIO_FORMAT_AAC_ADTS_LD = 503316608u, // (AAC_ADTS | AAC_SUB_LD)
AUDIO_FORMAT_AAC_ADTS_HE_V2 = 503316736u, // (AAC_ADTS | AAC_SUB_HE_V2)
AUDIO_FORMAT_AAC_ADTS_ELD = 503316992u, // (AAC_ADTS | AAC_SUB_ELD)
} audio_format_t;
enum {
FCC_2 = 2,
FCC_8 = 8,
};
enum {
AUDIO_CHANNEL_REPRESENTATION_POSITION = 0u, // 0
AUDIO_CHANNEL_REPRESENTATION_INDEX = 2u, // 2
AUDIO_CHANNEL_NONE = 0u, // 0x0
AUDIO_CHANNEL_INVALID = 3221225472u, // 0xC0000000
AUDIO_CHANNEL_OUT_FRONT_LEFT = 1u, // 0x1
AUDIO_CHANNEL_OUT_FRONT_RIGHT = 2u, // 0x2
AUDIO_CHANNEL_OUT_FRONT_CENTER = 4u, // 0x4
AUDIO_CHANNEL_OUT_LOW_FREQUENCY = 8u, // 0x8
AUDIO_CHANNEL_OUT_BACK_LEFT = 16u, // 0x10
AUDIO_CHANNEL_OUT_BACK_RIGHT = 32u, // 0x20
AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER = 64u, // 0x40
AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = 128u, // 0x80
AUDIO_CHANNEL_OUT_BACK_CENTER = 256u, // 0x100
AUDIO_CHANNEL_OUT_SIDE_LEFT = 512u, // 0x200
AUDIO_CHANNEL_OUT_SIDE_RIGHT = 1024u, // 0x400
AUDIO_CHANNEL_OUT_TOP_CENTER = 2048u, // 0x800
AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT = 4096u, // 0x1000
AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER = 8192u, // 0x2000
AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT = 16384u, // 0x4000
AUDIO_CHANNEL_OUT_TOP_BACK_LEFT = 32768u, // 0x8000
AUDIO_CHANNEL_OUT_TOP_BACK_CENTER = 65536u, // 0x10000
AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT = 131072u, // 0x20000
AUDIO_CHANNEL_OUT_MONO = 1u, // OUT_FRONT_LEFT
AUDIO_CHANNEL_OUT_STEREO = 3u, // (OUT_FRONT_LEFT | OUT_FRONT_RIGHT)
AUDIO_CHANNEL_OUT_2POINT1 = 11u, // ((OUT_FRONT_LEFT | OUT_FRONT_RIGHT) | OUT_LOW_FREQUENCY)
AUDIO_CHANNEL_OUT_QUAD =
51u, // (((OUT_FRONT_LEFT | OUT_FRONT_RIGHT) | OUT_BACK_LEFT) | OUT_BACK_RIGHT)
AUDIO_CHANNEL_OUT_QUAD_BACK = 51u, // OUT_QUAD
AUDIO_CHANNEL_OUT_QUAD_SIDE =
1539u, // (((OUT_FRONT_LEFT | OUT_FRONT_RIGHT) | OUT_SIDE_LEFT) | OUT_SIDE_RIGHT)
AUDIO_CHANNEL_OUT_SURROUND =
263u, // (((OUT_FRONT_LEFT | OUT_FRONT_RIGHT) | OUT_FRONT_CENTER) | OUT_BACK_CENTER)
AUDIO_CHANNEL_OUT_PENTA = 55u, // (OUT_QUAD | OUT_FRONT_CENTER)
AUDIO_CHANNEL_OUT_5POINT1 = 63u, // (((((OUT_FRONT_LEFT | OUT_FRONT_RIGHT) | OUT_FRONT_CENTER)
// | OUT_LOW_FREQUENCY) | OUT_BACK_LEFT) | OUT_BACK_RIGHT)
AUDIO_CHANNEL_OUT_5POINT1_BACK = 63u, // OUT_5POINT1
AUDIO_CHANNEL_OUT_5POINT1_SIDE = 1551u, // (((((OUT_FRONT_LEFT | OUT_FRONT_RIGHT) |
// OUT_FRONT_CENTER) | OUT_LOW_FREQUENCY) |
// OUT_SIDE_LEFT) | OUT_SIDE_RIGHT)
AUDIO_CHANNEL_OUT_6POINT1 = 319u, // ((((((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 = 1599u, // (((((((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_ALL =
262143u, // (((((((((((((((((OUT_FRONT_LEFT | OUT_FRONT_RIGHT) | OUT_FRONT_CENTER) |
// OUT_LOW_FREQUENCY) | OUT_BACK_LEFT) | OUT_BACK_RIGHT) |
// OUT_FRONT_LEFT_OF_CENTER) | OUT_FRONT_RIGHT_OF_CENTER) | OUT_BACK_CENTER) |
// OUT_SIDE_LEFT) | OUT_SIDE_RIGHT) | OUT_TOP_CENTER) | OUT_TOP_FRONT_LEFT) |
// OUT_TOP_FRONT_CENTER) | OUT_TOP_FRONT_RIGHT) | OUT_TOP_BACK_LEFT) |
// OUT_TOP_BACK_CENTER) | OUT_TOP_BACK_RIGHT)
AUDIO_CHANNEL_IN_LEFT = 4u, // 0x4
AUDIO_CHANNEL_IN_RIGHT = 8u, // 0x8
AUDIO_CHANNEL_IN_FRONT = 16u, // 0x10
AUDIO_CHANNEL_IN_BACK = 32u, // 0x20
AUDIO_CHANNEL_IN_LEFT_PROCESSED = 64u, // 0x40
AUDIO_CHANNEL_IN_RIGHT_PROCESSED = 128u, // 0x80
AUDIO_CHANNEL_IN_FRONT_PROCESSED = 256u, // 0x100
AUDIO_CHANNEL_IN_BACK_PROCESSED = 512u, // 0x200
AUDIO_CHANNEL_IN_PRESSURE = 1024u, // 0x400
AUDIO_CHANNEL_IN_X_AXIS = 2048u, // 0x800
AUDIO_CHANNEL_IN_Y_AXIS = 4096u, // 0x1000
AUDIO_CHANNEL_IN_Z_AXIS = 8192u, // 0x2000
AUDIO_CHANNEL_IN_VOICE_UPLINK = 16384u, // 0x4000
AUDIO_CHANNEL_IN_VOICE_DNLINK = 32768u, // 0x8000
AUDIO_CHANNEL_IN_MONO = 16u, // IN_FRONT
AUDIO_CHANNEL_IN_STEREO = 12u, // (IN_LEFT | IN_RIGHT)
AUDIO_CHANNEL_IN_FRONT_BACK = 48u, // (IN_FRONT | IN_BACK)
AUDIO_CHANNEL_IN_6 = 252u, // (((((IN_LEFT | IN_RIGHT) | IN_FRONT) | IN_BACK) |
// IN_LEFT_PROCESSED) | IN_RIGHT_PROCESSED)
AUDIO_CHANNEL_IN_VOICE_UPLINK_MONO = 16400u, // (IN_VOICE_UPLINK | IN_MONO)
AUDIO_CHANNEL_IN_VOICE_DNLINK_MONO = 32784u, // (IN_VOICE_DNLINK | IN_MONO)
AUDIO_CHANNEL_IN_VOICE_CALL_MONO = 49168u, // (IN_VOICE_UPLINK_MONO | IN_VOICE_DNLINK_MONO)
AUDIO_CHANNEL_IN_ALL =
65532u, // (((((((((((((IN_LEFT | IN_RIGHT) | IN_FRONT) | IN_BACK) | IN_LEFT_PROCESSED) |
// IN_RIGHT_PROCESSED) | IN_FRONT_PROCESSED) | IN_BACK_PROCESSED) | IN_PRESSURE) |
// IN_X_AXIS) | IN_Y_AXIS) | IN_Z_AXIS) | IN_VOICE_UPLINK) | IN_VOICE_DNLINK)
AUDIO_CHANNEL_COUNT_MAX = 30u, // 30
AUDIO_CHANNEL_INDEX_HDR = 2147483648u, // (REPRESENTATION_INDEX << COUNT_MAX)
AUDIO_CHANNEL_INDEX_MASK_1 = 2147483649u, // (INDEX_HDR | ((1 << 1) - 1))
AUDIO_CHANNEL_INDEX_MASK_2 = 2147483651u, // (INDEX_HDR | ((1 << 2) - 1))
AUDIO_CHANNEL_INDEX_MASK_3 = 2147483655u, // (INDEX_HDR | ((1 << 3) - 1))
AUDIO_CHANNEL_INDEX_MASK_4 = 2147483663u, // (INDEX_HDR | ((1 << 4) - 1))
AUDIO_CHANNEL_INDEX_MASK_5 = 2147483679u, // (INDEX_HDR | ((1 << 5) - 1))
AUDIO_CHANNEL_INDEX_MASK_6 = 2147483711u, // (INDEX_HDR | ((1 << 6) - 1))
AUDIO_CHANNEL_INDEX_MASK_7 = 2147483775u, // (INDEX_HDR | ((1 << 7) - 1))
AUDIO_CHANNEL_INDEX_MASK_8 = 2147483903u, // (INDEX_HDR | ((1 << 8) - 1))
};
enum {
AUDIO_INTERLEAVE_LEFT = 0,
AUDIO_INTERLEAVE_RIGHT = 1,
};
typedef enum {
AUDIO_MODE_INVALID = -2, // (-2)
AUDIO_MODE_CURRENT = -1, // (-1)
AUDIO_MODE_NORMAL = 0,
AUDIO_MODE_RINGTONE = 1,
AUDIO_MODE_IN_CALL = 2,
AUDIO_MODE_IN_COMMUNICATION = 3,
AUDIO_MODE_CNT = 4,
AUDIO_MODE_MAX = 3, // (CNT - 1)
} audio_mode_t;
enum {
AUDIO_DEVICE_NONE = 0u, // 0x0
AUDIO_DEVICE_BIT_IN = 2147483648u, // 0x80000000
AUDIO_DEVICE_BIT_DEFAULT = 1073741824u, // 0x40000000
AUDIO_DEVICE_OUT_EARPIECE = 1u, // 0x1
AUDIO_DEVICE_OUT_SPEAKER = 2u, // 0x2
AUDIO_DEVICE_OUT_WIRED_HEADSET = 4u, // 0x4
AUDIO_DEVICE_OUT_WIRED_HEADPHONE = 8u, // 0x8
AUDIO_DEVICE_OUT_BLUETOOTH_SCO = 16u, // 0x10
AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 32u, // 0x20
AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT = 64u, // 0x40
AUDIO_DEVICE_OUT_BLUETOOTH_A2DP = 128u, // 0x80
AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 256u, // 0x100
AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 512u, // 0x200
AUDIO_DEVICE_OUT_AUX_DIGITAL = 1024u, // 0x400
AUDIO_DEVICE_OUT_HDMI = 1024u, // OUT_AUX_DIGITAL
AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET = 2048u, // 0x800
AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET = 4096u, // 0x1000
AUDIO_DEVICE_OUT_USB_ACCESSORY = 8192u, // 0x2000
AUDIO_DEVICE_OUT_USB_DEVICE = 16384u, // 0x4000
AUDIO_DEVICE_OUT_REMOTE_SUBMIX = 32768u, // 0x8000
AUDIO_DEVICE_OUT_TELEPHONY_TX = 65536u, // 0x10000
AUDIO_DEVICE_OUT_LINE = 131072u, // 0x20000
AUDIO_DEVICE_OUT_HDMI_ARC = 262144u, // 0x40000
AUDIO_DEVICE_OUT_SPDIF = 524288u, // 0x80000
AUDIO_DEVICE_OUT_FM = 1048576u, // 0x100000
AUDIO_DEVICE_OUT_AUX_LINE = 2097152u, // 0x200000
AUDIO_DEVICE_OUT_SPEAKER_SAFE = 4194304u, // 0x400000
AUDIO_DEVICE_OUT_IP = 8388608u, // 0x800000
AUDIO_DEVICE_OUT_BUS = 16777216u, // 0x1000000
AUDIO_DEVICE_OUT_PROXY = 33554432u, // 0x2000000
AUDIO_DEVICE_OUT_USB_HEADSET = 67108864u, // 0x4000000
AUDIO_DEVICE_OUT_DEFAULT = 1073741824u, // BIT_DEFAULT
AUDIO_DEVICE_OUT_ALL =
1207959551u, // (((((((((((((((((((((((((((OUT_EARPIECE | OUT_SPEAKER) | OUT_WIRED_HEADSET)
// | OUT_WIRED_HEADPHONE) | OUT_BLUETOOTH_SCO) | OUT_BLUETOOTH_SCO_HEADSET) |
// OUT_BLUETOOTH_SCO_CARKIT) | OUT_BLUETOOTH_A2DP) |
// OUT_BLUETOOTH_A2DP_HEADPHONES) | OUT_BLUETOOTH_A2DP_SPEAKER) | OUT_HDMI) |
// OUT_ANLG_DOCK_HEADSET) | OUT_DGTL_DOCK_HEADSET) | OUT_USB_ACCESSORY) |
// OUT_USB_DEVICE) | OUT_REMOTE_SUBMIX) | OUT_TELEPHONY_TX) | OUT_LINE) |
// OUT_HDMI_ARC) | OUT_SPDIF) | OUT_FM) | OUT_AUX_LINE) | OUT_SPEAKER_SAFE) |
// OUT_IP) | OUT_BUS) | OUT_PROXY) | OUT_USB_HEADSET) | OUT_DEFAULT)
AUDIO_DEVICE_OUT_ALL_A2DP = 896u, // ((OUT_BLUETOOTH_A2DP | OUT_BLUETOOTH_A2DP_HEADPHONES) |
// OUT_BLUETOOTH_A2DP_SPEAKER)
AUDIO_DEVICE_OUT_ALL_SCO =
112u, // ((OUT_BLUETOOTH_SCO | OUT_BLUETOOTH_SCO_HEADSET) | OUT_BLUETOOTH_SCO_CARKIT)
AUDIO_DEVICE_OUT_ALL_USB =
67133440u, // ((OUT_USB_ACCESSORY | OUT_USB_DEVICE) | OUT_USB_HEADSET)
AUDIO_DEVICE_IN_COMMUNICATION = 2147483649u, // (BIT_IN | 0x1)
AUDIO_DEVICE_IN_AMBIENT = 2147483650u, // (BIT_IN | 0x2)
AUDIO_DEVICE_IN_BUILTIN_MIC = 2147483652u, // (BIT_IN | 0x4)
AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET = 2147483656u, // (BIT_IN | 0x8)
AUDIO_DEVICE_IN_WIRED_HEADSET = 2147483664u, // (BIT_IN | 0x10)
AUDIO_DEVICE_IN_AUX_DIGITAL = 2147483680u, // (BIT_IN | 0x20)
AUDIO_DEVICE_IN_HDMI = 2147483680u, // IN_AUX_DIGITAL
AUDIO_DEVICE_IN_VOICE_CALL = 2147483712u, // (BIT_IN | 0x40)
AUDIO_DEVICE_IN_TELEPHONY_RX = 2147483712u, // IN_VOICE_CALL
AUDIO_DEVICE_IN_BACK_MIC = 2147483776u, // (BIT_IN | 0x80)
AUDIO_DEVICE_IN_REMOTE_SUBMIX = 2147483904u, // (BIT_IN | 0x100)
AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET = 2147484160u, // (BIT_IN | 0x200)
AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET = 2147484672u, // (BIT_IN | 0x400)
AUDIO_DEVICE_IN_USB_ACCESSORY = 2147485696u, // (BIT_IN | 0x800)
AUDIO_DEVICE_IN_USB_DEVICE = 2147487744u, // (BIT_IN | 0x1000)
AUDIO_DEVICE_IN_FM_TUNER = 2147491840u, // (BIT_IN | 0x2000)
AUDIO_DEVICE_IN_TV_TUNER = 2147500032u, // (BIT_IN | 0x4000)
AUDIO_DEVICE_IN_LINE = 2147516416u, // (BIT_IN | 0x8000)
AUDIO_DEVICE_IN_SPDIF = 2147549184u, // (BIT_IN | 0x10000)
AUDIO_DEVICE_IN_BLUETOOTH_A2DP = 2147614720u, // (BIT_IN | 0x20000)
AUDIO_DEVICE_IN_LOOPBACK = 2147745792u, // (BIT_IN | 0x40000)
AUDIO_DEVICE_IN_IP = 2148007936u, // (BIT_IN | 0x80000)
AUDIO_DEVICE_IN_BUS = 2148532224u, // (BIT_IN | 0x100000)
AUDIO_DEVICE_IN_PROXY = 2164260864u, // (BIT_IN | 0x1000000)
AUDIO_DEVICE_IN_USB_HEADSET = 2181038080u, // (BIT_IN | 0x2000000)
AUDIO_DEVICE_IN_DEFAULT = 3221225472u, // (BIT_IN | BIT_DEFAULT)
AUDIO_DEVICE_IN_ALL =
3273654271u, // (((((((((((((((((((((((IN_COMMUNICATION | IN_AMBIENT) | IN_BUILTIN_MIC) |
// IN_BLUETOOTH_SCO_HEADSET) | IN_WIRED_HEADSET) | IN_HDMI) | IN_TELEPHONY_RX)
// | IN_BACK_MIC) | IN_REMOTE_SUBMIX) | IN_ANLG_DOCK_HEADSET) |
// IN_DGTL_DOCK_HEADSET) | IN_USB_ACCESSORY) | IN_USB_DEVICE) | IN_FM_TUNER) |
// IN_TV_TUNER) | IN_LINE) | IN_SPDIF) | IN_BLUETOOTH_A2DP) | IN_LOOPBACK) |
// IN_IP) | IN_BUS) | IN_PROXY) | IN_USB_HEADSET) | IN_DEFAULT)
AUDIO_DEVICE_IN_ALL_SCO = 2147483656u, // IN_BLUETOOTH_SCO_HEADSET
AUDIO_DEVICE_IN_ALL_USB = 2181044224u, // ((IN_USB_ACCESSORY | IN_USB_DEVICE) | IN_USB_HEADSET)
};
typedef enum {
AUDIO_OUTPUT_FLAG_NONE = 0, // 0x0
AUDIO_OUTPUT_FLAG_DIRECT = 1, // 0x1
AUDIO_OUTPUT_FLAG_PRIMARY = 2, // 0x2
AUDIO_OUTPUT_FLAG_FAST = 4, // 0x4
AUDIO_OUTPUT_FLAG_DEEP_BUFFER = 8, // 0x8
AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD = 16, // 0x10
AUDIO_OUTPUT_FLAG_NON_BLOCKING = 32, // 0x20
AUDIO_OUTPUT_FLAG_HW_AV_SYNC = 64, // 0x40
AUDIO_OUTPUT_FLAG_TTS = 128, // 0x80
AUDIO_OUTPUT_FLAG_RAW = 256, // 0x100
AUDIO_OUTPUT_FLAG_SYNC = 512, // 0x200
AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO = 1024, // 0x400
AUDIO_OUTPUT_FLAG_DIRECT_PCM = 8192, // 0x2000
AUDIO_OUTPUT_FLAG_MMAP_NOIRQ = 16384, // 0x4000
AUDIO_OUTPUT_FLAG_VOIP_RX = 32768, // 0x8000
} audio_output_flags_t;
typedef enum {
AUDIO_INPUT_FLAG_NONE = 0, // 0x0
AUDIO_INPUT_FLAG_FAST = 1, // 0x1
AUDIO_INPUT_FLAG_HW_HOTWORD = 2, // 0x2
AUDIO_INPUT_FLAG_RAW = 4, // 0x4
AUDIO_INPUT_FLAG_SYNC = 8, // 0x8
AUDIO_INPUT_FLAG_MMAP_NOIRQ = 16, // 0x10
AUDIO_INPUT_FLAG_VOIP_TX = 32, // 0x20
} 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,
AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST = 7,
AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT = 8,
AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED = 9,
AUDIO_USAGE_NOTIFICATION_EVENT = 10,
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_CNT = 17,
AUDIO_USAGE_MAX = 16, // (CNT - 1)
} audio_usage_t;
enum {
AUDIO_GAIN_MODE_JOINT = 1u, // 0x1
AUDIO_GAIN_MODE_CHANNELS = 2u, // 0x2
AUDIO_GAIN_MODE_RAMP = 4u, // 0x4
};
typedef enum {
AUDIO_PORT_ROLE_NONE = 0,
AUDIO_PORT_ROLE_SOURCE = 1,
AUDIO_PORT_ROLE_SINK = 2,
} audio_port_role_t;
typedef enum {
AUDIO_PORT_TYPE_NONE = 0,
AUDIO_PORT_TYPE_DEVICE = 1,
AUDIO_PORT_TYPE_MIX = 2,
AUDIO_PORT_TYPE_SESSION = 3,
} audio_port_type_t;
enum {
AUDIO_PORT_CONFIG_SAMPLE_RATE = 1u, // 0x1
AUDIO_PORT_CONFIG_CHANNEL_MASK = 2u, // 0x2
AUDIO_PORT_CONFIG_FORMAT = 4u, // 0x4
AUDIO_PORT_CONFIG_GAIN = 8u, // 0x8
AUDIO_PORT_CONFIG_ALL = 15u, // (((SAMPLE_RATE | CHANNEL_MASK) | FORMAT) | GAIN)
};
typedef enum {
AUDIO_LATENCY_LOW = 0,
AUDIO_LATENCY_NORMAL = 1,
} audio_mix_latency_class_t;
#ifdef __cplusplus
}
#endif
#endif // HIDL_GENERATED_ANDROID_HARDWARE_AUDIO_COMMON_V2_0_EXPORTED_CONSTANTS_H_

101
audio/common/2.0/legacy/include/system/audio_effect-base.h
View File

@@ -1,101 +0,0 @@
// This file is autogenerated by hidl-gen. Do not edit manually.
// Source: android.hardware.audio.effect@2.0
// Root: android.hardware:hardware/interfaces
#ifndef HIDL_GENERATED_ANDROID_HARDWARE_AUDIO_EFFECT_V2_0_EXPORTED_CONSTANTS_H_
#define HIDL_GENERATED_ANDROID_HARDWARE_AUDIO_EFFECT_V2_0_EXPORTED_CONSTANTS_H_
#ifdef __cplusplus
extern "C" {
#endif
enum {
EFFECT_FLAG_TYPE_SHIFT = 0,
EFFECT_FLAG_TYPE_SIZE = 3,
EFFECT_FLAG_TYPE_MASK = 7, // (((1 << TYPE_SIZE) - 1) << TYPE_SHIFT)
EFFECT_FLAG_TYPE_INSERT = 0, // (0 << TYPE_SHIFT)
EFFECT_FLAG_TYPE_AUXILIARY = 1, // (1 << TYPE_SHIFT)
EFFECT_FLAG_TYPE_REPLACE = 2, // (2 << TYPE_SHIFT)
EFFECT_FLAG_TYPE_PRE_PROC = 3, // (3 << TYPE_SHIFT)
EFFECT_FLAG_TYPE_POST_PROC = 4, // (4 << TYPE_SHIFT)
EFFECT_FLAG_INSERT_SHIFT = 3, // (TYPE_SHIFT + TYPE_SIZE)
EFFECT_FLAG_INSERT_SIZE = 3,
EFFECT_FLAG_INSERT_MASK = 56, // (((1 << INSERT_SIZE) - 1) << INSERT_SHIFT)
EFFECT_FLAG_INSERT_ANY = 0, // (0 << INSERT_SHIFT)
EFFECT_FLAG_INSERT_FIRST = 8, // (1 << INSERT_SHIFT)
EFFECT_FLAG_INSERT_LAST = 16, // (2 << INSERT_SHIFT)
EFFECT_FLAG_INSERT_EXCLUSIVE = 24, // (3 << INSERT_SHIFT)
EFFECT_FLAG_VOLUME_SHIFT = 6, // (INSERT_SHIFT + INSERT_SIZE)
EFFECT_FLAG_VOLUME_SIZE = 3,
EFFECT_FLAG_VOLUME_MASK = 448, // (((1 << VOLUME_SIZE) - 1) << VOLUME_SHIFT)
EFFECT_FLAG_VOLUME_CTRL = 64, // (1 << VOLUME_SHIFT)
EFFECT_FLAG_VOLUME_IND = 128, // (2 << VOLUME_SHIFT)
EFFECT_FLAG_VOLUME_NONE = 0, // (0 << VOLUME_SHIFT)
EFFECT_FLAG_DEVICE_SHIFT = 9, // (VOLUME_SHIFT + VOLUME_SIZE)
EFFECT_FLAG_DEVICE_SIZE = 3,
EFFECT_FLAG_DEVICE_MASK = 3584, // (((1 << DEVICE_SIZE) - 1) << DEVICE_SHIFT)
EFFECT_FLAG_DEVICE_IND = 512, // (1 << DEVICE_SHIFT)
EFFECT_FLAG_DEVICE_NONE = 0, // (0 << DEVICE_SHIFT)
EFFECT_FLAG_INPUT_SHIFT = 12, // (DEVICE_SHIFT + DEVICE_SIZE)
EFFECT_FLAG_INPUT_SIZE = 2,
EFFECT_FLAG_INPUT_MASK = 12288, // (((1 << INPUT_SIZE) - 1) << INPUT_SHIFT)
EFFECT_FLAG_INPUT_DIRECT = 4096, // (1 << INPUT_SHIFT)
EFFECT_FLAG_INPUT_PROVIDER = 8192, // (2 << INPUT_SHIFT)
EFFECT_FLAG_INPUT_BOTH = 12288, // (3 << INPUT_SHIFT)
EFFECT_FLAG_OUTPUT_SHIFT = 14, // (INPUT_SHIFT + INPUT_SIZE)
EFFECT_FLAG_OUTPUT_SIZE = 2,
EFFECT_FLAG_OUTPUT_MASK = 49152, // (((1 << OUTPUT_SIZE) - 1) << OUTPUT_SHIFT)
EFFECT_FLAG_OUTPUT_DIRECT = 16384, // (1 << OUTPUT_SHIFT)
EFFECT_FLAG_OUTPUT_PROVIDER = 32768, // (2 << OUTPUT_SHIFT)
EFFECT_FLAG_OUTPUT_BOTH = 49152, // (3 << OUTPUT_SHIFT)
EFFECT_FLAG_HW_ACC_SHIFT = 16, // (OUTPUT_SHIFT + OUTPUT_SIZE)
EFFECT_FLAG_HW_ACC_SIZE = 2,
EFFECT_FLAG_HW_ACC_MASK = 196608, // (((1 << HW_ACC_SIZE) - 1) << HW_ACC_SHIFT)
EFFECT_FLAG_HW_ACC_SIMPLE = 65536, // (1 << HW_ACC_SHIFT)
EFFECT_FLAG_HW_ACC_TUNNEL = 131072, // (2 << HW_ACC_SHIFT)
EFFECT_FLAG_AUDIO_MODE_SHIFT = 18, // (HW_ACC_SHIFT + HW_ACC_SIZE)
EFFECT_FLAG_AUDIO_MODE_SIZE = 2,
EFFECT_FLAG_AUDIO_MODE_MASK = 786432, // (((1 << AUDIO_MODE_SIZE) - 1) << AUDIO_MODE_SHIFT)
EFFECT_FLAG_AUDIO_MODE_IND = 262144, // (1 << AUDIO_MODE_SHIFT)
EFFECT_FLAG_AUDIO_MODE_NONE = 0, // (0 << AUDIO_MODE_SHIFT)
EFFECT_FLAG_AUDIO_SOURCE_SHIFT = 20, // (AUDIO_MODE_SHIFT + AUDIO_MODE_SIZE)
EFFECT_FLAG_AUDIO_SOURCE_SIZE = 2,
EFFECT_FLAG_AUDIO_SOURCE_MASK =
3145728, // (((1 << AUDIO_SOURCE_SIZE) - 1) << AUDIO_SOURCE_SHIFT)
EFFECT_FLAG_AUDIO_SOURCE_IND = 1048576, // (1 << AUDIO_SOURCE_SHIFT)
EFFECT_FLAG_AUDIO_SOURCE_NONE = 0, // (0 << AUDIO_SOURCE_SHIFT)
EFFECT_FLAG_OFFLOAD_SHIFT = 22, // (AUDIO_SOURCE_SHIFT + AUDIO_SOURCE_SIZE)
EFFECT_FLAG_OFFLOAD_SIZE = 1,
EFFECT_FLAG_OFFLOAD_MASK = 4194304, // (((1 << OFFLOAD_SIZE) - 1) << OFFLOAD_SHIFT)
EFFECT_FLAG_OFFLOAD_SUPPORTED = 4194304, // (1 << OFFLOAD_SHIFT)
EFFECT_FLAG_NO_PROCESS_SHIFT = 23, // (OFFLOAD_SHIFT + OFFLOAD_SIZE)
EFFECT_FLAG_NO_PROCESS_SIZE = 1,
EFFECT_FLAG_NO_PROCESS_MASK = 8388608, // (((1 << NO_PROCESS_SIZE) - 1) << NO_PROCESS_SHIFT)
EFFECT_FLAG_NO_PROCESS = 8388608, // (1 << NO_PROCESS_SHIFT)
};
typedef enum {
EFFECT_BUFFER_ACCESS_WRITE = 0,
EFFECT_BUFFER_ACCESS_READ = 1,
EFFECT_BUFFER_ACCESS_ACCUMULATE = 2,
} effect_buffer_access_e;
enum {
EFFECT_CONFIG_BUFFER = 1, // 0x0001
EFFECT_CONFIG_SMP_RATE = 2, // 0x0002
EFFECT_CONFIG_CHANNELS = 4, // 0x0004
EFFECT_CONFIG_FORMAT = 8, // 0x0008
EFFECT_CONFIG_ACC_MODE = 16, // 0x0010
EFFECT_CONFIG_ALL = 31, // ((((BUFFER | SMP_RATE) | CHANNELS) | FORMAT) | ACC_MODE)
};
typedef enum {
EFFECT_FEATURE_AUX_CHANNELS = 0,
EFFECT_FEATURE_CNT = 1,
} effect_feature_e;
#ifdef __cplusplus
}
#endif
#endif // HIDL_GENERATED_ANDROID_HARDWARE_AUDIO_EFFECT_V2_0_EXPORTED_CONSTANTS_H_

7
audio/common/all-versions/default/Android.bp
View File

@@ -16,7 +16,10 @@
cc_library_shared {
name: "android.hardware.audio.common-util",
defaults: ["hidl_defaults"],
vendor: true,
vendor_available: true,
vndk: {
enabled: true,
},
srcs: [
"EffectMap.cpp",
],
@@ -30,7 +33,7 @@ cc_library_shared {
],
header_libs: [
"android.hardware.audio.common.legacy@2.0",
"libaudio_system_headers",
"libhardware_headers",
],
}

8
audio/common/all-versions/legacy/Android.bp
View File

@@ -1,8 +0,0 @@
cc_library_headers {
name: "android.hardware.audio.common.legacy@all-versions",
vendor: true,
export_include_dirs: ["include"],
header_libs: ["libcutils_headers"],
export_header_lib_headers: ["libcutils_headers"],
}

3
audio/common/all-versions/legacy/OWNERS
View File

@@ -1,3 +0,0 @@
elaurent@google.com
krocard@google.com
mnaganov@google.com

709
audio/common/all-versions/legacy/include/hardware/audio.h
View File

@@ -1,709 +0,0 @@
/*
* 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_HAL_INTERFACE_H
#define ANDROID_AUDIO_HAL_INTERFACE_H
#include <stdint.h>
#include <strings.h>
#include <sys/cdefs.h>
#include <sys/types.h>
#include <time.h>
#include <cutils/bitops.h>
#include <hardware/audio_effect.h>
#include <hardware/hardware.h>
#include <system/audio.h>
__BEGIN_DECLS
/**
* The id of this module
*/
#define AUDIO_HARDWARE_MODULE_ID "audio"
/**
* Name of the audio devices to open
*/
#define AUDIO_HARDWARE_INTERFACE "audio_hw_if"
/* Use version 0.1 to be compatible with first generation of audio hw module with version_major
* hardcoded to 1. No audio module API change.
*/
#define AUDIO_MODULE_API_VERSION_0_1 HARDWARE_MODULE_API_VERSION(0, 1)
#define AUDIO_MODULE_API_VERSION_CURRENT AUDIO_MODULE_API_VERSION_0_1
/* First generation of audio devices had version hardcoded to 0. all devices with versions < 1.0
* will be considered of first generation API.
*/
#define AUDIO_DEVICE_API_VERSION_0_0 HARDWARE_DEVICE_API_VERSION(0, 0)
#define AUDIO_DEVICE_API_VERSION_1_0 HARDWARE_DEVICE_API_VERSION(1, 0)
#define AUDIO_DEVICE_API_VERSION_2_0 HARDWARE_DEVICE_API_VERSION(2, 0)
#define AUDIO_DEVICE_API_VERSION_3_0 HARDWARE_DEVICE_API_VERSION(3, 0)
#define AUDIO_DEVICE_API_VERSION_CURRENT AUDIO_DEVICE_API_VERSION_3_0
/* Minimal audio HAL version supported by the audio framework */
#define AUDIO_DEVICE_API_VERSION_MIN AUDIO_DEVICE_API_VERSION_2_0
/**************************************/
/**
* standard audio parameters that the HAL may need to handle
*/
/**
* audio device parameters
*/
/* TTY mode selection */
#define AUDIO_PARAMETER_KEY_TTY_MODE "tty_mode"
#define AUDIO_PARAMETER_VALUE_TTY_OFF "tty_off"
#define AUDIO_PARAMETER_VALUE_TTY_VCO "tty_vco"
#define AUDIO_PARAMETER_VALUE_TTY_HCO "tty_hco"
#define AUDIO_PARAMETER_VALUE_TTY_FULL "tty_full"
/* Hearing Aid Compatibility - Telecoil (HAC-T) mode on/off */
#define AUDIO_PARAMETER_KEY_HAC "HACSetting"
#define AUDIO_PARAMETER_VALUE_HAC_ON "ON"
#define AUDIO_PARAMETER_VALUE_HAC_OFF "OFF"
/* A2DP sink address set by framework */
#define AUDIO_PARAMETER_A2DP_SINK_ADDRESS "a2dp_sink_address"
/* A2DP source address set by framework */
#define AUDIO_PARAMETER_A2DP_SOURCE_ADDRESS "a2dp_source_address"
/* Bluetooth SCO wideband */
#define AUDIO_PARAMETER_KEY_BT_SCO_WB "bt_wbs"
/**
* audio stream parameters
*/
/* Enable AANC */
#define AUDIO_PARAMETER_KEY_AANC "aanc_enabled"
/**************************************/
/* common audio stream parameters and operations */
struct audio_stream {
/**
* Return the sampling rate in Hz - eg. 44100.
*/
uint32_t (*get_sample_rate)(const struct audio_stream* stream);
/* currently unused - use set_parameters with key
* AUDIO_PARAMETER_STREAM_SAMPLING_RATE
*/
int (*set_sample_rate)(struct audio_stream* stream, uint32_t rate);
/**
* Return size of input/output buffer in bytes for this stream - eg. 4800.
* It should be a multiple of the frame size. See also get_input_buffer_size.
*/
size_t (*get_buffer_size)(const struct audio_stream* stream);
/**
* Return the channel mask -
* e.g. AUDIO_CHANNEL_OUT_STEREO or AUDIO_CHANNEL_IN_STEREO
*/
audio_channel_mask_t (*get_channels)(const struct audio_stream* stream);
/**
* Return the audio format - e.g. AUDIO_FORMAT_PCM_16_BIT
*/
audio_format_t (*get_format)(const struct audio_stream* stream);
/* currently unused - use set_parameters with key
* AUDIO_PARAMETER_STREAM_FORMAT
*/
int (*set_format)(struct audio_stream* stream, audio_format_t format);
/**
* Put the audio hardware input/output into standby mode.
* Driver should exit from standby mode at the next I/O operation.
* Returns 0 on success and <0 on failure.
*/
int (*standby)(struct audio_stream* stream);
/** dump the state of the audio input/output device */
int (*dump)(const struct audio_stream* stream, int fd);
/** Return the set of device(s) which this stream is connected to */
audio_devices_t (*get_device)(const struct audio_stream* stream);
/**
* Currently unused - set_device() corresponds to set_parameters() with key
* AUDIO_PARAMETER_STREAM_ROUTING for both input and output.
* AUDIO_PARAMETER_STREAM_INPUT_SOURCE is an additional information used by
* input streams only.
*/
int (*set_device)(struct audio_stream* stream, audio_devices_t device);
/**
* set/get audio stream parameters. The function accepts a list of
* parameter key value pairs in the form: key1=value1;key2=value2;...
*
* Some keys are reserved for standard parameters (See AudioParameter class)
*
* If the implementation does not accept a parameter change while
* the output is active but the parameter is acceptable otherwise, it must
* return -ENOSYS.
*
* The audio flinger will put the stream in standby and then change the
* parameter value.
*/
int (*set_parameters)(struct audio_stream* stream, const char* kv_pairs);
/*
* Returns a pointer to a heap allocated string. The caller is responsible
* for freeing the memory for it using free().
*/
char* (*get_parameters)(const struct audio_stream* stream, const char* keys);
int (*add_audio_effect)(const struct audio_stream* stream, effect_handle_t effect);
int (*remove_audio_effect)(const struct audio_stream* stream, effect_handle_t effect);
};
typedef struct audio_stream audio_stream_t;
/* type of asynchronous write callback events. Mutually exclusive */
typedef enum {
STREAM_CBK_EVENT_WRITE_READY, /* non blocking write completed */
STREAM_CBK_EVENT_DRAIN_READY, /* drain completed */
STREAM_CBK_EVENT_ERROR, /* stream hit some error, let AF take action */
} stream_callback_event_t;
typedef int (*stream_callback_t)(stream_callback_event_t event, void* param, void* cookie);
/* type of drain requested to audio_stream_out->drain(). Mutually exclusive */
typedef enum {
AUDIO_DRAIN_ALL, /* drain() returns when all data has been played */
AUDIO_DRAIN_EARLY_NOTIFY /* drain() returns a short time before all data
from the current track has been played to
give time for gapless track switch */
} audio_drain_type_t;
/**
* audio_stream_out is the abstraction interface for the audio output hardware.
*
* It provides information about various properties of the audio output
* hardware driver.
*/
struct audio_stream_out {
/**
* Common methods of the audio stream out. This *must* be the first member of audio_stream_out
* as users of this structure will cast a audio_stream to audio_stream_out pointer in contexts
* where it's known the audio_stream references an audio_stream_out.
*/
struct audio_stream common;
/**
* Return the audio hardware driver estimated latency in milliseconds.
*/
uint32_t (*get_latency)(const struct audio_stream_out* stream);
/**
* Use this method in situations where audio mixing is done in the
* hardware. This method serves as a direct interface with hardware,
* allowing you to directly set the volume as apposed to via the framework.
* This method might produce multiple PCM outputs or hardware accelerated
* codecs, such as MP3 or AAC.
*/
int (*set_volume)(struct audio_stream_out* stream, float left, float right);
/**
* Write audio buffer to driver. Returns number of bytes written, or a
* negative status_t. If at least one frame was written successfully prior to the error,
* it is suggested that the driver return that successful (short) byte count
* and then return an error in the subsequent call.
*
* If set_callback() has previously been called to enable non-blocking mode
* the write() is not allowed to block. It must write only the number of
* bytes that currently fit in the driver/hardware buffer and then return
* this byte count. If this is less than the requested write size the
* callback function must be called when more space is available in the
* driver/hardware buffer.
*/
ssize_t (*write)(struct audio_stream_out* stream, const void* buffer, size_t bytes);
/* return the number of audio frames written by the audio dsp to DAC since
* the output has exited standby
*/
int (*get_render_position)(const struct audio_stream_out* stream, uint32_t* dsp_frames);
/**
* get the local time at which the next write to the audio driver will be presented.
* The units are microseconds, where the epoch is decided by the local audio HAL.
*/
int (*get_next_write_timestamp)(const struct audio_stream_out* stream, int64_t* timestamp);
/**
* set the callback function for notifying completion of non-blocking
* write and drain.
* Calling this function implies that all future write() and drain()
* must be non-blocking and use the callback to signal completion.
*/
int (*set_callback)(struct audio_stream_out* stream, stream_callback_t callback, void* cookie);
/**
* Notifies to the audio driver to stop playback however the queued buffers are
* retained by the hardware. Useful for implementing pause/resume. Empty implementation
* if not supported however should be implemented for hardware with non-trivial
* latency. In the pause state audio hardware could still be using power. User may
* consider calling suspend after a timeout.
*
* Implementation of this function is mandatory for offloaded playback.
*/
int (*pause)(struct audio_stream_out* stream);
/**
* Notifies to the audio driver to resume playback following a pause.
* Returns error if called without matching pause.
*
* Implementation of this function is mandatory for offloaded playback.
*/
int (*resume)(struct audio_stream_out* stream);
/**
* Requests notification when data buffered by the driver/hardware has
* been played. If set_callback() has previously been called to enable
* non-blocking mode, the drain() must not block, instead it should return
* quickly and completion of the drain is notified through the callback.
* If set_callback() has not been called, the drain() must block until
* completion.
* If type==AUDIO_DRAIN_ALL, the drain completes when all previously written
* data has been played.
* If type==AUDIO_DRAIN_EARLY_NOTIFY, the drain completes shortly before all
* data for the current track has played to allow time for the framework
* to perform a gapless track switch.
*
* Drain must return immediately on stop() and flush() call
*
* Implementation of this function is mandatory for offloaded playback.
*/
int (*drain)(struct audio_stream_out* stream, audio_drain_type_t type);
/**
* Notifies to the audio driver to flush the queued data. Stream must already
* be paused before calling flush().
*
* Implementation of this function is mandatory for offloaded playback.
*/
int (*flush)(struct audio_stream_out* stream);
/**
* Return a recent count of the number of audio frames presented to an external observer.
* This excludes frames which have been written but are still in the pipeline.
* The count is not reset to zero when output enters standby.
* Also returns the value of CLOCK_MONOTONIC as of this presentation count.
* The returned count is expected to be 'recent',
* but does not need to be the most recent possible value.
* However, the associated time should correspond to whatever count is returned.
* Example: assume that N+M frames have been presented, where M is a 'small' number.
* Then it is permissible to return N instead of N+M,
* and the timestamp should correspond to N rather than N+M.
* The terms 'recent' and 'small' are not defined.
* They reflect the quality of the implementation.
*
* 3.0 and higher only.
*/
int (*get_presentation_position)(const struct audio_stream_out* stream, uint64_t* frames,
struct timespec* timestamp);
/**
* Called by the framework to start a stream operating in mmap mode.
* create_mmap_buffer must be called before calling start()
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \return 0 in case of success.
* -ENOSYS if called out of sequence or on non mmap stream
*/
int (*start)(const struct audio_stream_out* stream);
/**
* Called by the framework to stop a stream operating in mmap mode.
* Must be called after start()
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \return 0 in case of success.
* -ENOSYS if called out of sequence or on non mmap stream
*/
int (*stop)(const struct audio_stream_out* stream);
/**
* Called by the framework to retrieve information on the mmap buffer used for audio
* samples transfer.
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \param[in] min_size_frames minimum buffer size requested. The actual buffer
* size returned in struct audio_mmap_buffer_info can be larger.
* \param[out] info address at which the mmap buffer information should be returned.
*
* \return 0 if the buffer was allocated.
* -ENODEV in case of initialization error
* -EINVAL if the requested buffer size is too large
* -ENOSYS if called out of sequence (e.g. buffer already allocated)
*/
int (*create_mmap_buffer)(const struct audio_stream_out* stream, int32_t min_size_frames,
struct audio_mmap_buffer_info* info);
/**
* Called by the framework to read current read/write position in the mmap buffer
* with associated time stamp.
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \param[out] position address at which the mmap read/write position should be returned.
*
* \return 0 if the position is successfully returned.
* -ENODATA if the position cannot be retrieved
* -ENOSYS if called before create_mmap_buffer()
*/
int (*get_mmap_position)(const struct audio_stream_out* stream,
struct audio_mmap_position* position);
};
typedef struct audio_stream_out audio_stream_out_t;
struct audio_stream_in {
/**
* Common methods of the audio stream in. This *must* be the first member of audio_stream_in
* as users of this structure will cast a audio_stream to audio_stream_in pointer in contexts
* where it's known the audio_stream references an audio_stream_in.
*/
struct audio_stream common;
/** set the input gain for the audio driver. This method is for
* for future use */
int (*set_gain)(struct audio_stream_in* stream, float gain);
/** Read audio buffer in from audio driver. Returns number of bytes read, or a
* negative status_t. If at least one frame was read prior to the error,
* read should return that byte count and then return an error in the subsequent call.
*/
ssize_t (*read)(struct audio_stream_in* stream, void* buffer, size_t bytes);
/**
* Return the amount of input frames lost in the audio driver since the
* last call of this function.
* Audio driver is expected to reset the value to 0 and restart counting
* upon returning the current value by this function call.
* Such loss typically occurs when the user space process is blocked
* longer than the capacity of audio driver buffers.
*
* Unit: the number of input audio frames
*/
uint32_t (*get_input_frames_lost)(struct audio_stream_in* stream);
/**
* Return a recent count of the number of audio frames received and
* the clock time associated with that frame count.
*
* frames is the total frame count received. This should be as early in
* the capture pipeline as possible. In general,
* frames should be non-negative and should not go "backwards".
*
* time is the clock MONOTONIC time when frames was measured. In general,
* time should be a positive quantity and should not go "backwards".
*
* The status returned is 0 on success, -ENOSYS if the device is not
* ready/available, or -EINVAL if the arguments are null or otherwise invalid.
*/
int (*get_capture_position)(const struct audio_stream_in* stream, int64_t* frames,
int64_t* time);
/**
* Called by the framework to start a stream operating in mmap mode.
* create_mmap_buffer must be called before calling start()
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \return 0 in case off success.
* -ENOSYS if called out of sequence or on non mmap stream
*/
int (*start)(const struct audio_stream_in* stream);
/**
* Called by the framework to stop a stream operating in mmap mode.
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \return 0 in case of success.
* -ENOSYS if called out of sequence or on non mmap stream
*/
int (*stop)(const struct audio_stream_in* stream);
/**
* Called by the framework to retrieve information on the mmap buffer used for audio
* samples transfer.
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \param[in] min_size_frames minimum buffer size requested. The actual buffer
* size returned in struct audio_mmap_buffer_info can be larger.
* \param[out] info address at which the mmap buffer information should be returned.
*
* \return 0 if the buffer was allocated.
* -ENODEV in case of initialization error
* -EINVAL if the requested buffer size is too large
* -ENOSYS if called out of sequence (e.g. buffer already allocated)
*/
int (*create_mmap_buffer)(const struct audio_stream_in* stream, int32_t min_size_frames,
struct audio_mmap_buffer_info* info);
/**
* Called by the framework to read current read/write position in the mmap buffer
* with associated time stamp.
*
* \note Function only implemented by streams operating in mmap mode.
*
* \param[in] stream the stream object.
* \param[out] position address at which the mmap read/write position should be returned.
*
* \return 0 if the position is successfully returned.
* -ENODATA if the position cannot be retreived
* -ENOSYS if called before mmap_read_position()
*/
int (*get_mmap_position)(const struct audio_stream_in* stream,
struct audio_mmap_position* position);
};
typedef struct audio_stream_in audio_stream_in_t;
/**
* return the frame size (number of bytes per sample).
*
* Deprecated: use audio_stream_out_frame_size() or audio_stream_in_frame_size() instead.
*/
__attribute__((__deprecated__)) static inline size_t audio_stream_frame_size(
const struct audio_stream* s) {
size_t chan_samp_sz;
audio_format_t format = s->get_format(s);
if (audio_has_proportional_frames(format)) {
chan_samp_sz = audio_bytes_per_sample(format);
return popcount(s->get_channels(s)) * chan_samp_sz;
}
return sizeof(int8_t);
}
/**
* return the frame size (number of bytes per sample) of an output stream.
*/
static inline size_t audio_stream_out_frame_size(const struct audio_stream_out* s) {
size_t chan_samp_sz;
audio_format_t format = s->common.get_format(&s->common);
if (audio_has_proportional_frames(format)) {
chan_samp_sz = audio_bytes_per_sample(format);
return audio_channel_count_from_out_mask(s->common.get_channels(&s->common)) * chan_samp_sz;
}
return sizeof(int8_t);
}
/**
* return the frame size (number of bytes per sample) of an input stream.
*/
static inline size_t audio_stream_in_frame_size(const struct audio_stream_in* s) {
size_t chan_samp_sz;
audio_format_t format = s->common.get_format(&s->common);
if (audio_has_proportional_frames(format)) {
chan_samp_sz = audio_bytes_per_sample(format);
return audio_channel_count_from_in_mask(s->common.get_channels(&s->common)) * chan_samp_sz;
}
return sizeof(int8_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.
*/
struct audio_module {
struct hw_module_t common;
};
struct audio_hw_device {
/**
* Common methods of the audio device. This *must* be the first member of audio_hw_device
* as users of this structure will cast a hw_device_t to audio_hw_device pointer in contexts
* where it's known the hw_device_t references an audio_hw_device.
*/
struct hw_device_t common;
/**
* used by audio flinger to enumerate what devices are supported by
* each audio_hw_device implementation.
*
* Return value is a bitmask of 1 or more values of audio_devices_t
*
* NOTE: audio HAL implementations starting with
* AUDIO_DEVICE_API_VERSION_2_0 do not implement this function.
* All supported devices should be listed in audio_policy.conf
* file and the audio policy manager must choose the appropriate
* audio module based on information in this file.
*/
uint32_t (*get_supported_devices)(const struct audio_hw_device* dev);
/**
* check to see if the audio hardware interface has been initialized.
* returns 0 on success, -ENODEV on failure.
*/
int (*init_check)(const struct audio_hw_device* dev);
/** set the audio volume of a voice call. Range is between 0.0 and 1.0 */
int (*set_voice_volume)(struct audio_hw_device* dev, float volume);
/**
* set the audio volume for all audio activities other than voice call.
* Range between 0.0 and 1.0. If any value other than 0 is returned,
* the software mixer will emulate this capability.
*/
int (*set_master_volume)(struct audio_hw_device* dev, float volume);
/**
* Get the current master volume value for the HAL, if the HAL supports
* master volume control. AudioFlinger will query this value from the
* primary audio HAL when the service starts and use the value for setting
* the initial master volume across all HALs. HALs which do not support
* this method may leave it set to NULL.
*/
int (*get_master_volume)(struct audio_hw_device* dev, float* volume);
/**
* set_mode is called when the audio mode changes. AUDIO_MODE_NORMAL mode
* is for standard audio playback, AUDIO_MODE_RINGTONE when a ringtone is
* playing, and AUDIO_MODE_IN_CALL when a call is in progress.
*/
int (*set_mode)(struct audio_hw_device* dev, audio_mode_t mode);
/* mic mute */
int (*set_mic_mute)(struct audio_hw_device* dev, bool state);
int (*get_mic_mute)(const struct audio_hw_device* dev, bool* state);
/* set/get global audio parameters */
int (*set_parameters)(struct audio_hw_device* dev, const char* kv_pairs);
/*
* Returns a pointer to a heap allocated string. The caller is responsible
* for freeing the memory for it using free().
*/
char* (*get_parameters)(const struct audio_hw_device* dev, const char* keys);
/* Returns audio input buffer size according to parameters passed or
* 0 if one of the parameters is not supported.
* See also get_buffer_size which is for a particular stream.
*/
size_t (*get_input_buffer_size)(const struct audio_hw_device* dev,
const struct audio_config* config);
/** This method creates and opens the audio hardware output stream.
* The "address" parameter qualifies the "devices" audio device type if needed.
* The format format depends on the device type:
* - Bluetooth devices use the MAC address of the device in the form "00:11:22:AA:BB:CC"
* - USB devices use the ALSA card and device numbers in the form "card=X;device=Y"
* - Other devices may use a number or any other string.
*/
int (*open_output_stream)(struct audio_hw_device* dev, audio_io_handle_t handle,
audio_devices_t devices, audio_output_flags_t flags,
struct audio_config* config, struct audio_stream_out** stream_out,
const char* address);
void (*close_output_stream)(struct audio_hw_device* dev, struct audio_stream_out* stream_out);
/** This method creates and opens the audio hardware input stream */
int (*open_input_stream)(struct audio_hw_device* dev, audio_io_handle_t handle,
audio_devices_t devices, struct audio_config* config,
struct audio_stream_in** stream_in, audio_input_flags_t flags,
const char* address, audio_source_t source);
void (*close_input_stream)(struct audio_hw_device* dev, struct audio_stream_in* stream_in);
/** This method dumps the state of the audio hardware */
int (*dump)(const struct audio_hw_device* dev, int fd);
/**
* set the audio mute status for all audio activities. If any value other
* than 0 is returned, the software mixer will emulate this capability.
*/
int (*set_master_mute)(struct audio_hw_device* dev, bool mute);
/**
* Get the current master mute status for the HAL, if the HAL supports
* master mute control. AudioFlinger will query this value from the primary
* audio HAL when the service starts and use the value for setting the
* initial master mute across all HALs. HALs which do not support this
* method may leave it set to NULL.
*/
int (*get_master_mute)(struct audio_hw_device* dev, bool* mute);
/**
* Routing control
*/
/* Creates an audio patch between several source and sink ports.
* The handle is allocated by the HAL and should be unique for this
* audio HAL module. */
int (*create_audio_patch)(struct audio_hw_device* dev, unsigned int num_sources,
const struct audio_port_config* sources, unsigned int num_sinks,
const struct audio_port_config* sinks, audio_patch_handle_t* handle);
/* Release an audio patch */
int (*release_audio_patch)(struct audio_hw_device* dev, audio_patch_handle_t handle);
/* Fills the list of supported attributes for a given audio port.
* As input, "port" contains the information (type, role, address etc...)
* needed by the HAL to identify the port.
* As output, "port" contains possible attributes (sampling rates, formats,
* channel masks, gain controllers...) for this port.
*/
int (*get_audio_port)(struct audio_hw_device* dev, struct audio_port* port);
/* Set audio port configuration */
int (*set_audio_port_config)(struct audio_hw_device* dev,
const struct audio_port_config* config);
};
typedef struct audio_hw_device audio_hw_device_t;
/** convenience API for opening and closing a supported device */
static inline int audio_hw_device_open(const struct hw_module_t* module,
struct audio_hw_device** device) {
return module->methods->open(module, AUDIO_HARDWARE_INTERFACE, TO_HW_DEVICE_T_OPEN(device));
}
static inline int audio_hw_device_close(struct audio_hw_device* device) {
return device->common.close(&device->common);
}
__END_DECLS
#endif // ANDROID_AUDIO_INTERFACE_H

101
audio/common/all-versions/legacy/include/hardware/audio_alsaops.h
View File

@@ -1,101 +0,0 @@
/*
* Copyright (C) 2014 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.
*/
/* This file contains shared utility functions to handle the tinyalsa
* implementation for Android internal audio, generally in the hardware layer.
* Some routines may log a fatal error on failure, as noted.
*/
#ifndef ANDROID_AUDIO_ALSAOPS_H
#define ANDROID_AUDIO_ALSAOPS_H
#include <log/log.h>
#include <system/audio.h>
#include <tinyalsa/asoundlib.h>
__BEGIN_DECLS
/* Converts audio_format to pcm_format.
* Parameters:
* format the audio_format_t to convert
*
* Logs a fatal error if format is not a valid convertible audio_format_t.
*/
static inline enum pcm_format pcm_format_from_audio_format(audio_format_t format) {
switch (format) {
#if HAVE_BIG_ENDIAN
case AUDIO_FORMAT_PCM_16_BIT:
return PCM_FORMAT_S16_BE;
case AUDIO_FORMAT_PCM_24_BIT_PACKED:
return PCM_FORMAT_S24_3BE;
case AUDIO_FORMAT_PCM_32_BIT:
return PCM_FORMAT_S32_BE;
case AUDIO_FORMAT_PCM_8_24_BIT:
return PCM_FORMAT_S24_BE;
#else
case AUDIO_FORMAT_PCM_16_BIT:
return PCM_FORMAT_S16_LE;
case AUDIO_FORMAT_PCM_24_BIT_PACKED:
return PCM_FORMAT_S24_3LE;
case AUDIO_FORMAT_PCM_32_BIT:
return PCM_FORMAT_S32_LE;
case AUDIO_FORMAT_PCM_8_24_BIT:
return PCM_FORMAT_S24_LE;
#endif
case AUDIO_FORMAT_PCM_FLOAT: /* there is no equivalent for float */
default:
LOG_ALWAYS_FATAL("pcm_format_from_audio_format: invalid audio format %#x", format);
return 0;
}
}
/* Converts pcm_format to audio_format.
* Parameters:
* format the pcm_format to convert
*
* Logs a fatal error if format is not a valid convertible pcm_format.
*/
static inline audio_format_t audio_format_from_pcm_format(enum pcm_format format) {
switch (format) {
#if HAVE_BIG_ENDIAN
case PCM_FORMAT_S16_BE:
return AUDIO_FORMAT_PCM_16_BIT;
case PCM_FORMAT_S24_3BE:
return AUDIO_FORMAT_PCM_24_BIT_PACKED;
case PCM_FORMAT_S24_BE:
return AUDIO_FORMAT_PCM_8_24_BIT;
case PCM_FORMAT_S32_BE:
return AUDIO_FORMAT_PCM_32_BIT;
#else
case PCM_FORMAT_S16_LE:
return AUDIO_FORMAT_PCM_16_BIT;
case PCM_FORMAT_S24_3LE:
return AUDIO_FORMAT_PCM_24_BIT_PACKED;
case PCM_FORMAT_S24_LE:
return AUDIO_FORMAT_PCM_8_24_BIT;
case PCM_FORMAT_S32_LE:
return AUDIO_FORMAT_PCM_32_BIT;
#endif
default:
LOG_ALWAYS_FATAL("audio_format_from_pcm_format: invalid pcm format %#x", format);
return 0;
}
}
__END_DECLS
#endif /* ANDROID_AUDIO_ALSAOPS_H */

295
audio/common/all-versions/legacy/include/hardware/audio_effect.h
View File

@@ -1,295 +0,0 @@
/*
* 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_EFFECT_H
#define ANDROID_AUDIO_EFFECT_H
#include <errno.h>
#include <stdint.h>
#include <strings.h>
#include <sys/cdefs.h>
#include <sys/types.h>
#include <cutils/bitops.h>
#include <system/audio_effect.h>
__BEGIN_DECLS
/////////////////////////////////////////////////
// Common Definitions
/////////////////////////////////////////////////
#define EFFECT_MAKE_API_VERSION(M, m) (((M) << 16) | ((m)&0xFFFF))
#define EFFECT_API_VERSION_MAJOR(v) ((v) >> 16)
#define EFFECT_API_VERSION_MINOR(v) ((m)&0xFFFF)
/////////////////////////////////////////////////
// Effect control interface
/////////////////////////////////////////////////
// Effect control interface version 2.0
#define EFFECT_CONTROL_API_VERSION EFFECT_MAKE_API_VERSION(2, 0)
// Effect control interface structure: effect_interface_s
// The effect control interface is exposed by each effect engine implementation. It consists of
// a set of functions controlling the configuration, activation and process of the engine.
// The functions are grouped in a structure of type effect_interface_s.
//
// Effect control interface handle: effect_handle_t
// The effect_handle_t serves two purposes regarding the implementation of the effect engine:
// - 1 it is the address of a pointer to an effect_interface_s structure where the functions
// of the effect control API for a particular effect are located.
// - 2 it is the address of the context of a particular effect instance.
// A typical implementation in the effect library would define a structure as follows:
// struct effect_module_s {
// const struct effect_interface_s *itfe;
// effect_config_t config;
// effect_context_t context;
// }
// The implementation of EffectCreate() function would then allocate a structure of this
// type and return its address as effect_handle_t
typedef struct effect_interface_s** effect_handle_t;
// Effect control interface definition
struct effect_interface_s {
////////////////////////////////////////////////////////////////////////////////
//
// Function: process
//
// Description: Effect process function. Takes input samples as specified
// (count and location) in input buffer descriptor and output processed
// samples as specified in output buffer descriptor. If the buffer descriptor
// is not specified the function must use either the buffer or the
// buffer provider function installed by the EFFECT_CMD_SET_CONFIG command.
// The effect framework will call the process() function after the EFFECT_CMD_ENABLE
// command is received and until the EFFECT_CMD_DISABLE is received. When the engine
// receives the EFFECT_CMD_DISABLE command it should turn off the effect gracefully
// and when done indicate that it is OK to stop calling the process() function by
// returning the -ENODATA status.
//
// NOTE: the process() function implementation should be "real-time safe" that is
// it should not perform blocking calls: malloc/free, sleep, read/write/open/close,
// pthread_cond_wait/pthread_mutex_lock...
//
// Input:
// self: handle to the effect interface this function
// is called on.
// inBuffer: buffer descriptor indicating where to read samples to process.
// If NULL, use the configuration passed by EFFECT_CMD_SET_CONFIG command.
//
// outBuffer: buffer descriptor indicating where to write processed samples.
// If NULL, use the configuration passed by EFFECT_CMD_SET_CONFIG command.
//
// Output:
// returned value: 0 successful operation
// -ENODATA the engine has finished the disable phase and the framework
// can stop calling process()
// -EINVAL invalid interface handle or
// invalid input/output buffer description
////////////////////////////////////////////////////////////////////////////////
int32_t (*process)(effect_handle_t self, audio_buffer_t* inBuffer, audio_buffer_t* outBuffer);
////////////////////////////////////////////////////////////////////////////////
//
// Function: command
//
// Description: Send a command and receive a response to/from effect engine.
//
// Input:
// self: handle to the effect interface this function
// is called on.
// cmdCode: command code: the command can be a standardized command defined in
// effect_command_e (see below) or a proprietary command.
// cmdSize: size of command in bytes
// pCmdData: pointer to command data
// pReplyData: pointer to reply data
//
// Input/Output:
// replySize: maximum size of reply data as input
// actual size of reply data as output
//
// Output:
// returned value: 0 successful operation
// -EINVAL invalid interface handle or
// invalid command/reply size or format according to
// command code
// The return code should be restricted to indicate problems related to this API
// specification. Status related to the execution of a particular command should be
// indicated as part of the reply field.
//
// *pReplyData updated with command response
//
////////////////////////////////////////////////////////////////////////////////
int32_t (*command)(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize, void* pCmdData,
uint32_t* replySize, void* pReplyData);
////////////////////////////////////////////////////////////////////////////////
//
// Function: get_descriptor
//
// Description: Returns the effect descriptor
//
// Input:
// self: handle to the effect interface this function
// is called on.
//
// Input/Output:
// pDescriptor: address where to return the effect descriptor.
//
// Output:
// returned value: 0 successful operation.
// -EINVAL invalid interface handle or invalid pDescriptor
// *pDescriptor: updated with the effect descriptor.
//
////////////////////////////////////////////////////////////////////////////////
int32_t (*get_descriptor)(effect_handle_t self, effect_descriptor_t* pDescriptor);
////////////////////////////////////////////////////////////////////////////////
//
// Function: process_reverse
//
// Description: Process reverse stream function. This function is used to pass
// a reference stream to the effect engine. If the engine does not need a reference
// stream, this function pointer can be set to NULL.
// This function would typically implemented by an Echo Canceler.
//
// Input:
// self: handle to the effect interface this function
// is called on.
// inBuffer: buffer descriptor indicating where to read samples to process.
// If NULL, use the configuration passed by EFFECT_CMD_SET_CONFIG_REVERSE command.
//
// outBuffer: buffer descriptor indicating where to write processed samples.
// If NULL, use the configuration passed by EFFECT_CMD_SET_CONFIG_REVERSE command.
// If the buffer and buffer provider in the configuration received by
// EFFECT_CMD_SET_CONFIG_REVERSE are also NULL, do not return modified reverse
// stream data
//
// Output:
// returned value: 0 successful operation
// -ENODATA the engine has finished the disable phase and the framework
// can stop calling process_reverse()
// -EINVAL invalid interface handle or
// invalid input/output buffer description
////////////////////////////////////////////////////////////////////////////////
int32_t (*process_reverse)(effect_handle_t self, audio_buffer_t* inBuffer,
audio_buffer_t* outBuffer);
};
/////////////////////////////////////////////////
// Effect library interface
/////////////////////////////////////////////////
// Effect library interface version 3.0
// Note that EffectsFactory.c only checks the major version component, so changes to the minor
// number can only be used for fully backwards compatible changes
#define EFFECT_LIBRARY_API_VERSION EFFECT_MAKE_API_VERSION(3, 0)
#define AUDIO_EFFECT_LIBRARY_TAG ((('A') << 24) | (('E') << 16) | (('L') << 8) | ('T'))
// Every effect library must have a data structure named AUDIO_EFFECT_LIBRARY_INFO_SYM
// and the fields of this data structure must begin with audio_effect_library_t
typedef struct audio_effect_library_s {
// tag must be initialized to AUDIO_EFFECT_LIBRARY_TAG
uint32_t tag;
// Version of the effect library API : 0xMMMMmmmm MMMM: Major, mmmm: minor
uint32_t version;
// Name of this library
const char* name;
// Author/owner/implementor of the library
const char* implementor;
////////////////////////////////////////////////////////////////////////////////
//
// Function: create_effect
//
// Description: Creates an effect engine of the specified implementation uuid and
// returns an effect control interface on this engine. The function will allocate the
// resources for an instance of the requested effect engine and return
// a handle on the effect control interface.
//
// Input:
// uuid: pointer to the effect uuid.
// sessionId: audio session to which this effect instance will be attached.
// All effects created with the same session ID are connected in series and process
// the same signal stream. Knowing that two effects are part of the same effect
// chain can help the library implement some kind of optimizations.
// ioId: identifies the output or input stream this effect is directed to in
// audio HAL.
// For future use especially with tunneled HW accelerated effects
//
// Input/Output:
// pHandle: address where to return the effect interface handle.
//
// Output:
// returned value: 0 successful operation.
// -ENODEV library failed to initialize
// -EINVAL invalid pEffectUuid or pHandle
// -ENOENT no effect with this uuid found
// *pHandle: updated with the effect interface handle.
//
////////////////////////////////////////////////////////////////////////////////
int32_t (*create_effect)(const effect_uuid_t* uuid, int32_t sessionId, int32_t ioId,
effect_handle_t* pHandle);
////////////////////////////////////////////////////////////////////////////////
//
// Function: release_effect
//
// Description: Releases the effect engine whose handle is given as argument.
// All resources allocated to this particular instance of the effect are
// released.
//
// Input:
// handle: handle on the effect interface to be released.
//
// Output:
// returned value: 0 successful operation.
// -ENODEV library failed to initialize
// -EINVAL invalid interface handle
//
////////////////////////////////////////////////////////////////////////////////
int32_t (*release_effect)(effect_handle_t handle);
////////////////////////////////////////////////////////////////////////////////
//
// Function: get_descriptor
//
// Description: Returns the descriptor of the effect engine which implementation UUID is
// given as argument.
//
// Input/Output:
// uuid: pointer to the effect uuid.
// pDescriptor: address where to return the effect descriptor.
//
// Output:
// returned value: 0 successful operation.
// -ENODEV library failed to initialize
// -EINVAL invalid pDescriptor or uuid
// *pDescriptor: updated with the effect descriptor.
//
////////////////////////////////////////////////////////////////////////////////
int32_t (*get_descriptor)(const effect_uuid_t* uuid, effect_descriptor_t* pDescriptor);
} audio_effect_library_t;
// Name of the hal_module_info
#define AUDIO_EFFECT_LIBRARY_INFO_SYM AELI
// Name of the hal_module_info as a string
#define AUDIO_EFFECT_LIBRARY_INFO_SYM_AS_STR "AELI"
__END_DECLS
#endif // ANDROID_AUDIO_EFFECT_H

391
audio/common/all-versions/legacy/include/hardware/audio_policy.h
View File

@@ -1,391 +0,0 @@
/*
* 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, audio_session_t 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, audio_session_t 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, audio_session_t 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, audio_session_t 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

1038
audio/common/all-versions/legacy/include/system/audio.h
View File

File diff suppressed because it is too large Load Diff

528
audio/common/all-versions/legacy/include/system/audio_effect.h
View File

@@ -1,528 +0,0 @@
/*
* Copyright (C) 2016 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_EFFECT_CORE_H
#define ANDROID_AUDIO_EFFECT_CORE_H
#include "system/audio.h"
#include "system/audio_effect-base.h"
__BEGIN_DECLS
/////////////////////////////////////////////////
// Common Definitions
/////////////////////////////////////////////////
//
//--- Effect descriptor structure effect_descriptor_t
//
// This format is used for both "type" and "uuid" fields of the effect descriptor structure.
// - When used for effect type and the engine is implementing and effect corresponding to a standard
// OpenSL ES interface, this ID must be the one defined in OpenSLES_IID.h for that interface.
// - When used as uuid, it should be a unique UUID for this particular implementation.
typedef audio_uuid_t effect_uuid_t;
// Maximum length of character strings in structures defines by this API.
#define EFFECT_STRING_LEN_MAX 64
// NULL UUID definition (matches SL_IID_NULL_)
#define EFFECT_UUID_INITIALIZER \
{ \
0xec7178ec, 0xe5e1, 0x4432, 0xa3f4, { 0x46, 0x57, 0xe6, 0x79, 0x52, 0x10 } \
}
static const effect_uuid_t EFFECT_UUID_NULL_ = EFFECT_UUID_INITIALIZER;
static const effect_uuid_t* const EFFECT_UUID_NULL = &EFFECT_UUID_NULL_;
static const char* const EFFECT_UUID_NULL_STR = "ec7178ec-e5e1-4432-a3f4-4657e6795210";
// The effect descriptor contains necessary information to facilitate the enumeration of the effect
// engines present in a library.
typedef struct effect_descriptor_s {
effect_uuid_t type; // UUID of to the OpenSL ES interface implemented by this effect
effect_uuid_t uuid; // UUID for this particular implementation
uint32_t apiVersion; // Version of the effect control API implemented
uint32_t flags; // effect engine capabilities/requirements flags (see below)
uint16_t cpuLoad; // CPU load indication (see below)
uint16_t memoryUsage; // Data Memory usage (see below)
char name[EFFECT_STRING_LEN_MAX]; // human readable effect name
char implementor[EFFECT_STRING_LEN_MAX]; // human readable effect implementor name
} effect_descriptor_t;
/////////////////////////////////////////////////
// Effect control interface
/////////////////////////////////////////////////
//
//--- Standardized command codes for command() function
//
enum effect_command_e {
EFFECT_CMD_INIT, // initialize effect engine
EFFECT_CMD_SET_CONFIG, // configure effect engine (see effect_config_t)
EFFECT_CMD_RESET, // reset effect engine
EFFECT_CMD_ENABLE, // enable effect process
EFFECT_CMD_DISABLE, // disable effect process
EFFECT_CMD_SET_PARAM, // set parameter immediately (see effect_param_t)
EFFECT_CMD_SET_PARAM_DEFERRED, // set parameter deferred
EFFECT_CMD_SET_PARAM_COMMIT, // commit previous set parameter deferred
EFFECT_CMD_GET_PARAM, // get parameter
EFFECT_CMD_SET_DEVICE, // set audio device (see audio.h, audio_devices_t)
EFFECT_CMD_SET_VOLUME, // set volume
EFFECT_CMD_SET_AUDIO_MODE, // set the audio mode (normal, ring, ...)
EFFECT_CMD_SET_CONFIG_REVERSE, // configure effect engine reverse stream(see effect_config_t)
EFFECT_CMD_SET_INPUT_DEVICE, // set capture device (see audio.h, audio_devices_t)
EFFECT_CMD_GET_CONFIG, // read effect engine configuration
EFFECT_CMD_GET_CONFIG_REVERSE, // read configure effect engine reverse stream configuration
EFFECT_CMD_GET_FEATURE_SUPPORTED_CONFIGS, // get all supported configurations for a feature.
EFFECT_CMD_GET_FEATURE_CONFIG, // get current feature configuration
EFFECT_CMD_SET_FEATURE_CONFIG, // set current feature configuration
EFFECT_CMD_SET_AUDIO_SOURCE, // set the audio source (see audio.h, audio_source_t)
EFFECT_CMD_OFFLOAD, // set if effect thread is an offload one,
// send the ioHandle of the effect thread
EFFECT_CMD_FIRST_PROPRIETARY = 0x10000 // first proprietary command code
};
//==================================================================================================
// command: EFFECT_CMD_INIT
//--------------------------------------------------------------------------------------------------
// description:
// Initialize effect engine: All configurations return to default
//--------------------------------------------------------------------------------------------------
// command format:
// size: 0
// data: N/A
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(int)
// data: status
//==================================================================================================
// command: EFFECT_CMD_SET_CONFIG
//--------------------------------------------------------------------------------------------------
// description:
// Apply new audio parameters configurations for input and output buffers
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(effect_config_t)
// data: effect_config_t
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(int)
// data: status
//==================================================================================================
// command: EFFECT_CMD_RESET
//--------------------------------------------------------------------------------------------------
// description:
// Reset the effect engine. Keep configuration but resets state and buffer content
//--------------------------------------------------------------------------------------------------
// command format:
// size: 0
// data: N/A
//--------------------------------------------------------------------------------------------------
// reply format:
// size: 0
// data: N/A
//==================================================================================================
// command: EFFECT_CMD_ENABLE
//--------------------------------------------------------------------------------------------------
// description:
// Enable the process. Called by the framework before the first call to process()
//--------------------------------------------------------------------------------------------------
// command format:
// size: 0
// data: N/A
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(int)
// data: status
//==================================================================================================
// command: EFFECT_CMD_DISABLE
//--------------------------------------------------------------------------------------------------
// description:
// Disable the process. Called by the framework after the last call to process()
//--------------------------------------------------------------------------------------------------
// command format:
// size: 0
// data: N/A
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(int)
// data: status
//==================================================================================================
// command: EFFECT_CMD_SET_PARAM
//--------------------------------------------------------------------------------------------------
// description:
// Set a parameter and apply it immediately
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(effect_param_t) + size of param and value
// data: effect_param_t + param + value. See effect_param_t definition below for value offset
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(int)
// data: status
//==================================================================================================
// command: EFFECT_CMD_SET_PARAM_DEFERRED
//--------------------------------------------------------------------------------------------------
// description:
// Set a parameter but apply it only when receiving EFFECT_CMD_SET_PARAM_COMMIT command
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(effect_param_t) + size of param and value
// data: effect_param_t + param + value. See effect_param_t definition below for value offset
//--------------------------------------------------------------------------------------------------
// reply format:
// size: 0
// data: N/A
//==================================================================================================
// command: EFFECT_CMD_SET_PARAM_COMMIT
//--------------------------------------------------------------------------------------------------
// description:
// Apply all previously received EFFECT_CMD_SET_PARAM_DEFERRED commands
//--------------------------------------------------------------------------------------------------
// command format:
// size: 0
// data: N/A
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(int)
// data: status
//==================================================================================================
// command: EFFECT_CMD_GET_PARAM
//--------------------------------------------------------------------------------------------------
// description:
// Get a parameter value
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(effect_param_t) + size of param
// data: effect_param_t + param
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(effect_param_t) + size of param and value
// data: effect_param_t + param + value. See effect_param_t definition below for value offset
//==================================================================================================
// command: EFFECT_CMD_SET_DEVICE
//--------------------------------------------------------------------------------------------------
// description:
// Set the rendering device the audio output path is connected to. See audio.h, audio_devices_t
// for device values.
// The effect implementation must set EFFECT_FLAG_DEVICE_IND flag in its descriptor to receive this
// command when the device changes
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(uint32_t)
// data: uint32_t
//--------------------------------------------------------------------------------------------------
// reply format:
// size: 0
// data: N/A
//==================================================================================================
// command: EFFECT_CMD_SET_VOLUME
//--------------------------------------------------------------------------------------------------
// description:
// Set and get volume. Used by audio framework to delegate volume control to effect engine.
// The effect implementation must set EFFECT_FLAG_VOLUME_IND or EFFECT_FLAG_VOLUME_CTRL flag in
// its descriptor to receive this command before every call to process() function
// If EFFECT_FLAG_VOLUME_CTRL flag is set in the effect descriptor, the effect engine must return
// the volume that should be applied before the effect is processed. The overall volume (the volume
// actually applied by the effect engine multiplied by the returned value) should match the value
// indicated in the command.
//--------------------------------------------------------------------------------------------------
// command format:
// size: n * sizeof(uint32_t)
// data: volume for each channel defined in effect_config_t for output buffer expressed in
// 8.24 fixed point format
//--------------------------------------------------------------------------------------------------
// reply format:
// size: n * sizeof(uint32_t) / 0
// data: - if EFFECT_FLAG_VOLUME_CTRL is set in effect descriptor:
// volume for each channel defined in effect_config_t for output buffer expressed in
// 8.24 fixed point format
// - if EFFECT_FLAG_VOLUME_CTRL is not set in effect descriptor:
// N/A
// It is legal to receive a null pointer as pReplyData in which case the effect framework has
// delegated volume control to another effect
//==================================================================================================
// command: EFFECT_CMD_SET_AUDIO_MODE
//--------------------------------------------------------------------------------------------------
// description:
// Set the audio mode. The effect implementation must set EFFECT_FLAG_AUDIO_MODE_IND flag in its
// descriptor to receive this command when the audio mode changes.
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(uint32_t)
// data: audio_mode_t
//--------------------------------------------------------------------------------------------------
// reply format:
// size: 0
// data: N/A
//==================================================================================================
// command: EFFECT_CMD_SET_CONFIG_REVERSE
//--------------------------------------------------------------------------------------------------
// description:
// Apply new audio parameters configurations for input and output buffers of reverse stream.
// An example of reverse stream is the echo reference supplied to an Acoustic Echo Canceler.
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(effect_config_t)
// data: effect_config_t
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(int)
// data: status
//==================================================================================================
// command: EFFECT_CMD_SET_INPUT_DEVICE
//--------------------------------------------------------------------------------------------------
// description:
// Set the capture device the audio input path is connected to. See audio.h, audio_devices_t
// for device values.
// The effect implementation must set EFFECT_FLAG_DEVICE_IND flag in its descriptor to receive this
// command when the device changes
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(uint32_t)
// data: uint32_t
//--------------------------------------------------------------------------------------------------
// reply format:
// size: 0
// data: N/A
//==================================================================================================
// command: EFFECT_CMD_GET_CONFIG
//--------------------------------------------------------------------------------------------------
// description:
// Read audio parameters configurations for input and output buffers
//--------------------------------------------------------------------------------------------------
// command format:
// size: 0
// data: N/A
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(effect_config_t)
// data: effect_config_t
//==================================================================================================
// command: EFFECT_CMD_GET_CONFIG_REVERSE
//--------------------------------------------------------------------------------------------------
// description:
// Read audio parameters configurations for input and output buffers of reverse stream
//--------------------------------------------------------------------------------------------------
// command format:
// size: 0
// data: N/A
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(effect_config_t)
// data: effect_config_t
//==================================================================================================
// command: EFFECT_CMD_GET_FEATURE_SUPPORTED_CONFIGS
//--------------------------------------------------------------------------------------------------
// description:
// Queries for supported configurations for a particular feature (e.g. get the supported
// combinations of main and auxiliary channels for a noise suppressor).
// The command parameter is the feature identifier (See effect_feature_e for a list of defined
// features) followed by the maximum number of configuration descriptor to return.
// The reply is composed of:
// - status (uint32_t):
// - 0 if feature is supported
// - -ENOSYS if the feature is not supported,
// - -ENOMEM if the feature is supported but the total number of supported configurations
// exceeds the maximum number indicated by the caller.
// - total number of supported configurations (uint32_t)
// - an array of configuration descriptors.
// The actual number of descriptors returned must not exceed the maximum number indicated by
// the caller.
//--------------------------------------------------------------------------------------------------
// command format:
// size: 2 x sizeof(uint32_t)
// data: effect_feature_e + maximum number of configurations to return
//--------------------------------------------------------------------------------------------------
// reply format:
// size: 2 x sizeof(uint32_t) + n x sizeof (<config descriptor>)
// data: status + total number of configurations supported + array of n config descriptors
//==================================================================================================
// command: EFFECT_CMD_GET_FEATURE_CONFIG
//--------------------------------------------------------------------------------------------------
// description:
// Retrieves current configuration for a given feature.
// The reply status is:
// - 0 if feature is supported
// - -ENOSYS if the feature is not supported,
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(uint32_t)
// data: effect_feature_e
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(uint32_t) + sizeof (<config descriptor>)
// data: status + config descriptor
//==================================================================================================
// command: EFFECT_CMD_SET_FEATURE_CONFIG
//--------------------------------------------------------------------------------------------------
// description:
// Sets current configuration for a given feature.
// The reply status is:
// - 0 if feature is supported
// - -ENOSYS if the feature is not supported,
// - -EINVAL if the configuration is invalid
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(uint32_t) + sizeof (<config descriptor>)
// data: effect_feature_e + config descriptor
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(uint32_t)
// data: status
//==================================================================================================
// command: EFFECT_CMD_SET_AUDIO_SOURCE
//--------------------------------------------------------------------------------------------------
// description:
// Set the audio source the capture path is configured for (Camcorder, voice recognition...).
// See audio.h, audio_source_t for values.
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(uint32_t)
// data: uint32_t
//--------------------------------------------------------------------------------------------------
// reply format:
// size: 0
// data: N/A
//==================================================================================================
// command: EFFECT_CMD_OFFLOAD
//--------------------------------------------------------------------------------------------------
// description:
// 1.indicate if the playback thread the effect is attached to is offloaded or not
// 2.update the io handle of the playback thread the effect is attached to
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(effect_offload_param_t)
// data: effect_offload_param_t
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(uint32_t)
// data: uint32_t
//--------------------------------------------------------------------------------------------------
// command: EFFECT_CMD_FIRST_PROPRIETARY
//--------------------------------------------------------------------------------------------------
// description:
// All proprietary effect commands must use command codes above this value. The size and format of
// command and response fields is free in this case
//==================================================================================================
// Audio buffer descriptor used by process(), bufferProvider() functions and buffer_config_t
// structure. Multi-channel audio is always interleaved. The channel order is from LSB to MSB with
// regard to the channel mask definition in audio.h, audio_channel_mask_t e.g :
// Stereo: left, right
// 5 point 1: front left, front right, front center, low frequency, back left, back right
// The buffer size is expressed in frame count, a frame being composed of samples for all
// channels at a given time. Frame size for unspecified format (AUDIO_FORMAT_OTHER) is 8 bit by
// definition
typedef struct audio_buffer_s {
size_t frameCount; // number of frames in buffer
union {
void* raw; // raw pointer to start of buffer
float* f32; // pointer to float 32 bit data at start of buffer
int32_t* s32; // pointer to signed 32 bit data at start of buffer
int16_t* s16; // pointer to signed 16 bit data at start of buffer
uint8_t* u8; // pointer to unsigned 8 bit data at start of buffer
};
} audio_buffer_t;
// The buffer_provider_s structure contains functions that can be used
// by the effect engine process() function to query and release input
// or output audio buffer.
// The getBuffer() function is called to retrieve a buffer where data
// should read from or written to by process() function.
// The releaseBuffer() function MUST be called when the buffer retrieved
// with getBuffer() is not needed anymore.
// The process function should use the buffer provider mechanism to retrieve
// input or output buffer if the inBuffer or outBuffer passed as argument is NULL
// and the buffer configuration (buffer_config_t) given by the EFFECT_CMD_SET_CONFIG
// command did not specify an audio buffer.
typedef int32_t (*buffer_function_t)(void* cookie, audio_buffer_t* buffer);
typedef struct buffer_provider_s {
buffer_function_t getBuffer; // retrieve next buffer
buffer_function_t releaseBuffer; // release used buffer
void* cookie; // for use by client of buffer provider functions
} buffer_provider_t;
// The buffer_config_s structure specifies the input or output audio format
// to be used by the effect engine.
typedef struct buffer_config_s {
audio_buffer_t buffer; // buffer for use by process() function if not passed explicitly
uint32_t samplingRate; // sampling rate
uint32_t channels; // channel mask (see audio_channel_mask_t in audio.h)
buffer_provider_t bufferProvider; // buffer provider
uint8_t format; // Audio format (see audio_format_t in audio.h)
uint8_t accessMode; // read/write or accumulate in buffer (effect_buffer_access_e)
uint16_t mask; // indicates which of the above fields is valid
} buffer_config_t;
// EFFECT_FEATURE_AUX_CHANNELS feature configuration descriptor. Describe a combination
// of main and auxiliary channels supported
typedef struct channel_config_s {
audio_channel_mask_t main_channels; // channel mask for main channels
audio_channel_mask_t aux_channels; // channel mask for auxiliary channels
} channel_config_t;
// effect_config_s structure is used to configure audio parameters and buffers for effect engine
// input and output.
typedef struct effect_config_s {
buffer_config_t inputCfg;
buffer_config_t outputCfg;
} effect_config_t;
// effect_param_s structure describes the format of the pCmdData argument of EFFECT_CMD_SET_PARAM
// command and pCmdData and pReplyData of EFFECT_CMD_GET_PARAM command.
// psize and vsize represent the actual size of parameter and value.
//
// NOTE: the start of value field inside the data field is always on a 32 bit boundary:
//
// +-----------+
// | status | sizeof(int)
// +-----------+
// | psize | sizeof(int)
// +-----------+
// | vsize | sizeof(int)
// +-----------+
// | | | |
// ~ parameter ~ > psize |
// | | | > ((psize - 1)/sizeof(int) + 1) * sizeof(int)
// +-----------+ |
// | padding | |
// +-----------+
// | | |
// ~ value ~ > vsize
// | | |
// +-----------+
typedef struct effect_param_s {
int32_t status; // Transaction status (unused for command, used for reply)
uint32_t psize; // Parameter size
uint32_t vsize; // Value size
char data[]; // Start of Parameter + Value data
} effect_param_t;
// Maximum effect_param_t size
#define EFFECT_PARAM_SIZE_MAX 65536
// structure used by EFFECT_CMD_OFFLOAD command
typedef struct effect_offload_param_s {
bool isOffload; // true if the playback thread the effect is attached to is offloaded
int ioHandle; // io handle of the playback thread the effect is attached to
} effect_offload_param_t;
__END_DECLS
#endif // ANDROID_AUDIO_EFFECT_CORE_H

5
audio/common/all-versions/util/Android.bp
View File

@@ -1,7 +1,10 @@
cc_library_headers {
name: "android.hardware.audio.common.util@all-versions",
defaults: ["hidl_defaults"],
vendor: true,
vendor_available: true,
vndk: {
enabled: true,
},
export_include_dirs: ["include"],
}

4
audio/core/2.0/default/Android.bp
View File

@@ -37,13 +37,13 @@ cc_library_shared {
"android.hardware.audio.common.util@all-versions",
"android.hardware.audio.core@all-versions-impl",
"libaudioclient_headers",
"android.hardware.audio.common.legacy@2.0",
"libaudio_system_headers",
"libhardware_headers",
"libmedia_headers",
],
whole_static_libs: [
"libmedia_helper@2.0",
"libmedia_helper",
],
}

2
audio/core/all-versions/default/Android.bp
View File

@@ -22,7 +22,7 @@ cc_library_headers {
header_libs: [
"libaudioclient_headers",
"android.hardware.audio.common.legacy@2.0",
"libaudio_system_headers",
"libhardware_headers",
"libmedia_headers",
"android.hardware.audio.common.util@all-versions",

4
audio/effect/2.0/default/Android.bp
View File

@@ -41,9 +41,9 @@ cc_library_shared {
header_libs: [
"android.hardware.audio.common.util@all-versions",
"android.hardware.audio.effect@all-versions-impl",
"android.hardware.audio.common.legacy@2.0",
"android.hardware.audio.effect.legacy@2.0",
"libaudio_system_headers",
"libaudioclient_headers",
"libeffects_headers",
"libhardware_headers",
"libmedia_headers",
],

12
audio/effect/2.0/legacy/Android.bp
View File

@@ -1,12 +0,0 @@
cc_library_headers {
name: "android.hardware.audio.effect.legacy@2.0",
vendor: true,
header_libs: [
"android.hardware.audio.common.legacy@2.0",
"android.hardware.audio.effect.legacy@all-versions",
],
export_header_lib_headers: [
"android.hardware.audio.common.legacy@2.0",
"android.hardware.audio.effect.legacy@all-versions",
],
}

3
audio/effect/2.0/legacy/OWNERS
View File

@@ -1,3 +0,0 @@
elaurent@google.com
krocard@google.com
mnaganov@google.com

3
audio/effect/all-versions/default/Android.bp
View File

@@ -9,6 +9,7 @@ cc_library_headers {
shared_libs: [
"libbase",
"libcutils",
"libeffects",
"libfmq",
"libhidlbase",
"libhidlmemory",
@@ -20,7 +21,9 @@ cc_library_headers {
],
header_libs: [
"libaudio_system_headers",
"libaudioclient_headers",
"libeffects_headers",
"libhardware_headers",
"libmedia_headers",
"android.hardware.audio.common.util@all-versions",

11
audio/effect/all-versions/legacy/Android.bp
View File

@@ -1,11 +0,0 @@
cc_library_headers {
name: "android.hardware.audio.effect.legacy@all-versions",
vendor: true,
export_include_dirs: ["include"],
header_libs: [
"android.hardware.audio.common.legacy@all-versions",
],
export_header_lib_headers: [
"android.hardware.audio.common.legacy@all-versions",
],
}

3
audio/effect/all-versions/legacy/OWNERS
View File

@@ -1,3 +0,0 @@
elaurent@google.com
krocard@google.com
mnaganov@google.com

33
audio/effect/all-versions/legacy/include/audio_effects/effect_aec.h
View File

@@ -1,33 +0,0 @@
/*
* 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.
*/
/*
* USAGE NOTE: Only include this header when _implementing_ a particular
* effect. When access to UUID and properties is enough, include the
* corresponding header from system/audio_effects/, which doesn't include
* hardware/audio_effect.h.
*
* Only code that immediately calls into HAL or implements an effect
* can import hardware/audio_effect.h.
*/
#ifndef ANDROID_EFFECT_AEC_H_
#define ANDROID_EFFECT_AEC_H_
#include <hardware/audio_effect.h>
#include <system/audio_effects/effect_aec.h>
#endif /*ANDROID_EFFECT_AEC_H_*/

33
audio/effect/all-versions/legacy/include/audio_effects/effect_agc.h
View File

@@ -1,33 +0,0 @@
/*
* 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.
*/
/*
* USAGE NOTE: Only include this header when _implementing_ a particular
* effect. When access to UUID and properties is enough, include the
* corresponding header from system/audio_effects/, which doesn't include
* hardware/audio_effect.h.
*
* Only code that immediately calls into HAL or implements an effect
* can import hardware/audio_effect.h.
*/
#ifndef ANDROID_EFFECT_AGC_H_
#define ANDROID_EFFECT_AGC_H_
#include <hardware/audio_effect.h>
#include <system/audio_effects/effect_agc.h>
#endif /*ANDROID_EFFECT_AGC_H_*/

33
audio/effect/all-versions/legacy/include/audio_effects/effect_bassboost.h
View File

@@ -1,33 +0,0 @@
/*
* 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.
*/
/*
* USAGE NOTE: Only include this header when _implementing_ a particular
* effect. When access to UUID and properties is enough, include the
* corresponding header from system/audio_effects/, which doesn't include
* hardware/audio_effect.h.
*
* Only code that immediately calls into HAL or implements an effect
* can import hardware/audio_effect.h.
*/
#ifndef ANDROID_EFFECT_BASSBOOST_H_
#define ANDROID_EFFECT_BASSBOOST_H_
#include <hardware/audio_effect.h>
#include <system/audio_effects/effect_bassboost.h>
#endif /*ANDROID_EFFECT_BASSBOOST_H_*/

33
audio/effect/all-versions/legacy/include/audio_effects/effect_downmix.h
View File

@@ -1,33 +0,0 @@
/*
* Copyright (C) 2012 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.
*/
/*
* USAGE NOTE: Only include this header when _implementing_ a particular
* effect. When access to UUID and properties is enough, include the
* corresponding header from system/audio_effects/, which doesn't include
* hardware/audio_effect.h.
*
* Only code that immediately calls into HAL or implements an effect
* can import hardware/audio_effect.h.
*/
#ifndef ANDROID_EFFECT_DOWNMIX_H_
#define ANDROID_EFFECT_DOWNMIX_H_
#include <hardware/audio_effect.h>
#include <system/audio_effects/effect_downmix.h>
#endif /*ANDROID_EFFECT_DOWNMIX_H_*/

33
audio/effect/all-versions/legacy/include/audio_effects/effect_environmentalreverb.h
View File

@@ -1,33 +0,0 @@
/*
* 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.
*/
/*
* USAGE NOTE: Only include this header when _implementing_ a particular
* effect. When access to UUID and properties is enough, include the
* corresponding header from system/audio_effects/, which doesn't include
* hardware/audio_effect.h.
*
* Only code that immediately calls into HAL or implements an effect
* can import hardware/audio_effect.h.
*/
#ifndef ANDROID_EFFECT_ENVIRONMENTALREVERB_H_
#define ANDROID_EFFECT_ENVIRONMENTALREVERB_H_
#include <hardware/audio_effect.h>
#include <system/audio_effects/effect_environmentalreverb.h>
#endif /*ANDROID_EFFECT_ENVIRONMENTALREVERB_H_*/

33
audio/effect/all-versions/legacy/include/audio_effects/effect_equalizer.h
View File

@@ -1,33 +0,0 @@
/*
* 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.
*/
/*
* USAGE NOTE: Only include this header when _implementing_ a particular
* effect. When access to UUID and properties is enough, include the
* corresponding header from system/audio_effects/, which doesn't include
* hardware/audio_effect.h.
*
* Only code that immediately calls into HAL or implements an effect
* can import hardware/audio_effect.h.
*/
#ifndef ANDROID_EFFECT_EQUALIZER_H_
#define ANDROID_EFFECT_EQUALIZER_H_
#include <hardware/audio_effect.h>
#include <system/audio_effects/effect_equalizer.h>
#endif /*ANDROID_EFFECT_EQUALIZER_H_*/

33
audio/effect/all-versions/legacy/include/audio_effects/effect_loudnessenhancer.h
View File

@@ -1,33 +0,0 @@
/*
* Copyright (C) 2013 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.
*/
/*
* USAGE NOTE: Only include this header when _implementing_ a particular
* effect. When access to UUID and properties is enough, include the
* corresponding header from system/audio_effects/, which doesn't include
* hardware/audio_effect.h.
*
* Only code that immediately calls into HAL or implements an effect
* can import hardware/audio_effect.h.
*/
#ifndef ANDROID_EFFECT_LOUDNESS_ENHANCER_H_
#define ANDROID_EFFECT_LOUDNESS_ENHANCER_H_
#include <hardware/audio_effect.h>
#include <system/audio_effects/effect_loudnessenhancer.h>
#endif /*ANDROID_EFFECT_LOUDNESS_ENHANCER_H_*/

33
audio/effect/all-versions/legacy/include/audio_effects/effect_ns.h
View File

@@ -1,33 +0,0 @@
/*
* 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.
*/
/*
* USAGE NOTE: Only include this header when _implementing_ a particular
* effect. When access to UUID and properties is enough, include the
* corresponding header from system/audio_effects/, which doesn't include
* hardware/audio_effect.h.
*
* Only code that immediately calls into HAL or implements an effect
* can import hardware/audio_effect.h.
*/
#ifndef ANDROID_EFFECT_NS_H_
#define ANDROID_EFFECT_NS_H_
#include <hardware/audio_effect.h>
#include <system/audio_effects/effect_ns.h>
#endif /*ANDROID_EFFECT_NS_H_*/

33
audio/effect/all-versions/legacy/include/audio_effects/effect_presetreverb.h
View File

@@ -1,33 +0,0 @@
/*
* 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.
*/
/*
* USAGE NOTE: Only include this header when _implementing_ a particular
* effect. When access to UUID and properties is enough, include the
* corresponding header from system/audio_effects/, which doesn't include
* hardware/audio_effect.h.
*
* Only code that immediately calls into HAL or implements an effect
* can import hardware/audio_effect.h.
*/
#ifndef ANDROID_EFFECT_PRESETREVERB_H_
#define ANDROID_EFFECT_PRESETREVERB_H_
#include <hardware/audio_effect.h>
#include <system/audio_effects/effect_presetreverb.h>
#endif /*ANDROID_EFFECT_PRESETREVERB_H_*/

33
audio/effect/all-versions/legacy/include/audio_effects/effect_virtualizer.h
View File

@@ -1,33 +0,0 @@
/*
* 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.
*/
/*
* USAGE NOTE: Only include this header when _implementing_ a particular
* effect. When access to UUID and properties is enough, include the
* corresponding header from system/audio_effects/, which doesn't include
* hardware/audio_effect.h.
*
* Only code that immediately calls into HAL or implements an effect
* can import hardware/audio_effect.h.
*/
#ifndef ANDROID_EFFECT_VIRTUALIZER_H_
#define ANDROID_EFFECT_VIRTUALIZER_H_
#include <hardware/audio_effect.h>
#include <system/audio_effects/effect_virtualizer.h>
#endif /*ANDROID_EFFECT_VIRTUALIZER_H_*/

33
audio/effect/all-versions/legacy/include/audio_effects/effect_visualizer.h
View File

@@ -1,33 +0,0 @@
/*
* 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.
*/
/*
* USAGE NOTE: Only include this header when _implementing_ a particular
* effect. When access to UUID and properties is enough, include the
* corresponding header from system/audio_effects/, which doesn't include
* hardware/audio_effect.h.
*
* Only code that immediately calls into HAL or implements an effect
* can import hardware/audio_effect.h.
*/
#ifndef ANDROID_EFFECT_VISUALIZER_H_
#define ANDROID_EFFECT_VISUALIZER_H_
#include <hardware/audio_effect.h>
#include <system/audio_effects/effect_visualizer.h>
#endif /*ANDROID_EFFECT_VISUALIZER_H_*/

188
audio/effect/all-versions/legacy/include/media/EffectsFactoryApi.h
View File

@@ -1,188 +0,0 @@
/*
* Copyright (C) 2010 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_EFFECTSFACTORYAPI_H_
#define ANDROID_EFFECTSFACTORYAPI_H_
#include <cutils/compiler.h>
#include <errno.h>
#include <hardware/audio_effect.h>
#include <stdint.h>
#include <sys/types.h>
#if __cplusplus
extern "C" {
#endif
/////////////////////////////////////////////////
// Effect factory interface
/////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
// Function: EffectQueryNumberEffects
//
// Description: Returns the number of different effects in all loaded libraries.
// Each effect must have a different effect uuid (see
// effect_descriptor_t). This function together with EffectQueryEffect()
// is used to enumerate all effects present in all loaded libraries.
// Each time EffectQueryNumberEffects() is called, the factory must
// reset the index of the effect descriptor returned by next call to
// EffectQueryEffect() to restart enumeration from the beginning.
//
// Input/Output:
// pNumEffects: address where the number of effects should be returned.
//
// Output:
// returned value: 0 successful operation.
// -ENODEV factory failed to initialize
// -EINVAL invalid pNumEffects
// *pNumEffects: updated with number of effects in factory
//
////////////////////////////////////////////////////////////////////////////////
ANDROID_API
int EffectQueryNumberEffects(uint32_t* pNumEffects);
////////////////////////////////////////////////////////////////////////////////
//
// Function: EffectQueryEffect
//
// Description: Returns a descriptor of the next available effect.
// See effect_descriptor_t for a details on effect descriptor.
// This function together with EffectQueryNumberEffects() is used to enumerate all
// effects present in all loaded libraries. The enumeration sequence is:
// EffectQueryNumberEffects(&num_effects);
// for (i = 0; i < num_effects; i++)
// EffectQueryEffect(i,...);
//
// Input/Output:
// pDescriptor: address where to return the effect descriptor.
//
// Output:
// returned value: 0 successful operation.
// -ENOENT no more effect available
// -ENODEV factory failed to initialize
// -EINVAL invalid pDescriptor
// -ENOSYS effect list has changed since last execution of
// EffectQueryNumberEffects()
// *pDescriptor: updated with the effect descriptor.
//
////////////////////////////////////////////////////////////////////////////////
ANDROID_API
int EffectQueryEffect(uint32_t index, effect_descriptor_t* pDescriptor);
////////////////////////////////////////////////////////////////////////////////
//
// Function: EffectCreate
//
// Description: Creates an effect engine of the specified type and returns an
// effect control interface on this engine. The function will allocate the
// resources for an instance of the requested effect engine and return
// a handle on the effect control interface.
//
// Input:
// pEffectUuid: pointer to the effect uuid.
// sessionId: audio session to which this effect instance will be attached. All effects
// created with the same session ID are connected in series and process the same signal
// stream. Knowing that two effects are part of the same effect chain can help the
// library implement some kind of optimizations.
// ioId: identifies the output or input stream this effect is directed to at audio HAL.
// For future use especially with tunneled HW accelerated effects
//
// Input/Output:
// pHandle: address where to return the effect handle.
//
// Output:
// returned value: 0 successful operation.
// -ENODEV factory failed to initialize
// -EINVAL invalid pEffectUuid or pHandle
// -ENOENT no effect with this uuid found
// *pHandle: updated with the effect handle.
//
////////////////////////////////////////////////////////////////////////////////
ANDROID_API
int EffectCreate(const effect_uuid_t* pEffectUuid, int32_t sessionId, int32_t ioId,
effect_handle_t* pHandle);
////////////////////////////////////////////////////////////////////////////////
//
// Function: EffectRelease
//
// Description: Releases the effect engine whose handle is given as argument.
// All resources allocated to this particular instance of the effect are
// released.
//
// Input:
// handle: handle on the effect interface to be released.
//
// Output:
// returned value: 0 successful operation.
// -ENODEV factory failed to initialize
// -EINVAL invalid interface handle
//
////////////////////////////////////////////////////////////////////////////////
ANDROID_API
int EffectRelease(effect_handle_t handle);
////////////////////////////////////////////////////////////////////////////////
//
// Function: EffectGetDescriptor
//
// Description: Returns the descriptor of the effect which uuid is pointed
// to by first argument.
//
// Input:
// pEffectUuid: pointer to the effect uuid.
//
// Input/Output:
// pDescriptor: address where to return the effect descriptor.
//
// Output:
// returned value: 0 successful operation.
// -ENODEV factory failed to initialize
// -EINVAL invalid pEffectUuid or pDescriptor
// -ENOENT no effect with this uuid found
// *pDescriptor: updated with the effect descriptor.
//
////////////////////////////////////////////////////////////////////////////////
ANDROID_API
int EffectGetDescriptor(const effect_uuid_t* pEffectUuid, effect_descriptor_t* pDescriptor);
////////////////////////////////////////////////////////////////////////////////
//
// Function: EffectIsNullUuid
//
// Description: Helper function to compare effect uuid to EFFECT_UUID_NULL
//
// Input:
// pEffectUuid: pointer to effect uuid to compare to EFFECT_UUID_NULL.
//
// Output:
// returned value: 0 if uuid is different from EFFECT_UUID_NULL.
// 1 if uuid is equal to EFFECT_UUID_NULL.
//
////////////////////////////////////////////////////////////////////////////////
ANDROID_API
int EffectIsNullUuid(const effect_uuid_t* pEffectUuid);
ANDROID_API
int EffectDumpEffects(int fd);
#if __cplusplus
} // extern "C"
#endif
#endif /*ANDROID_EFFECTSFACTORYAPI_H_*/

67
audio/effect/all-versions/legacy/include/system/audio_effects/audio_effects_conf.h
View File

@@ -1,67 +0,0 @@
/*
* 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_EFFECTS_CONF_H
#define ANDROID_AUDIO_EFFECTS_CONF_H
/////////////////////////////////////////////////
// Definitions for effects configuration file (audio_effects.conf)
/////////////////////////////////////////////////
#define AUDIO_EFFECT_DEFAULT_CONFIG_FILE "/system/etc/audio_effects.conf"
#define AUDIO_EFFECT_VENDOR_CONFIG_FILE "/vendor/etc/audio_effects.conf"
#define LIBRARIES_TAG "libraries"
#define PATH_TAG "path"
#define EFFECTS_TAG "effects"
#define LIBRARY_TAG "library"
#define UUID_TAG "uuid"
#define PREPROCESSING_TAG "pre_processing"
#define OUTPUT_SESSION_PROCESSING_TAG "output_session_processing"
#define PARAM_TAG "param"
#define VALUE_TAG "value"
#define INT_TAG "int"
#define SHORT_TAG "short"
#define FLOAT_TAG "float"
#define BOOL_TAG "bool"
#define STRING_TAG "string"
// audio_source_t
#define MIC_SRC_TAG "mic" // AUDIO_SOURCE_MIC
#define VOICE_UL_SRC_TAG "voice_uplink" // AUDIO_SOURCE_VOICE_UPLINK
#define VOICE_DL_SRC_TAG "voice_downlink" // AUDIO_SOURCE_VOICE_DOWNLINK
#define VOICE_CALL_SRC_TAG "voice_call" // AUDIO_SOURCE_VOICE_CALL
#define CAMCORDER_SRC_TAG "camcorder" // AUDIO_SOURCE_CAMCORDER
#define VOICE_REC_SRC_TAG "voice_recognition" // AUDIO_SOURCE_VOICE_RECOGNITION
#define VOICE_COMM_SRC_TAG "voice_communication" // AUDIO_SOURCE_VOICE_COMMUNICATION
#define UNPROCESSED_SRC_TAG "unprocessed" // AUDIO_SOURCE_UNPROCESSED
// audio_stream_type_t
#define AUDIO_STREAM_DEFAULT_TAG "default"
#define AUDIO_STREAM_VOICE_CALL_TAG "voice_call"
#define AUDIO_STREAM_SYSTEM_TAG "system"
#define AUDIO_STREAM_RING_TAG "ring"
#define AUDIO_STREAM_MUSIC_TAG "music"
#define AUDIO_STREAM_ALARM_TAG "alarm"
#define AUDIO_STREAM_NOTIFICATION_TAG "notification"
#define AUDIO_STREAM_BLUETOOTH_SCO_TAG "bluetooth_sco"
#define AUDIO_STREAM_ENFORCED_AUDIBLE_TAG "enforced_audible"
#define AUDIO_STREAM_DTMF_TAG "dtmf"
#define AUDIO_STREAM_TTS_TAG "tts"
#endif // ANDROID_AUDIO_EFFECTS_CONF_H

44
audio/effect/all-versions/legacy/include/system/audio_effects/effect_aec.h
View File

@@ -1,44 +0,0 @@
/*
* Copyright (C) 2016 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_EFFECT_AEC_CORE_H_
#define ANDROID_EFFECT_AEC_CORE_H_
#include <system/audio_effect.h>
#if __cplusplus
extern "C" {
#endif
// The AEC type UUID is not defined by OpenSL ES and has been generated from
// http://www.itu.int/ITU-T/asn1/uuid.html
static const effect_uuid_t FX_IID_AEC_ = {
0x7b491460, 0x8d4d, 0x11e0, 0xbd61, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};
const effect_uuid_t* const FX_IID_AEC = &FX_IID_AEC_;
typedef enum {
AEC_PARAM_ECHO_DELAY, // echo delay in microseconds
AEC_PARAM_PROPERTIES
} t_aec_params;
// t_equalizer_settings groups all current aec settings for backup and restore.
typedef struct s_aec_settings { uint32_t echoDelay; } t_aec_settings;
#if __cplusplus
} // extern "C"
#endif
#endif /*ANDROID_EFFECT_AEC_CORE_H_*/

50
audio/effect/all-versions/legacy/include/system/audio_effects/effect_agc.h
View File

@@ -1,50 +0,0 @@
/*
* Copyright (C) 2016 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_EFFECT_AGC_CORE_H_
#define ANDROID_EFFECT_AGC_CORE_H_
#include <system/audio_effect.h>
#if __cplusplus
extern "C" {
#endif
// The AGC type UUID is not defined by OpenSL ES and has been generated from
// http://www.itu.int/ITU-T/asn1/uuid.html
static const effect_uuid_t FX_IID_AGC_ = {
0x0a8abfe0, 0x654c, 0x11e0, 0xba26, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};
const effect_uuid_t* const FX_IID_AGC = &FX_IID_AGC_;
typedef enum {
AGC_PARAM_TARGET_LEVEL, // target output level in millibel
AGC_PARAM_COMP_GAIN, // gain in the compression range in millibel
AGC_PARAM_LIMITER_ENA, // enable or disable limiter (boolean)
AGC_PARAM_PROPERTIES
} t_agc_params;
// t_agc_settings groups all current agc settings for backup and restore.
typedef struct s_agc_settings {
int16_t targetLevel;
int16_t compGain;
bool limiterEnabled;
} t_agc_settings;
#if __cplusplus
} // extern "C"
#endif
#endif /*ANDROID_EFFECT_AGC_CORE_H_*/

39
audio/effect/all-versions/legacy/include/system/audio_effects/effect_bassboost.h
View File

@@ -1,39 +0,0 @@
/*
* Copyright (C) 2016 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_EFFECT_BASSBOOST_CORE_H_
#define ANDROID_EFFECT_BASSBOOST_CORE_H_
#include <system/audio_effect.h>
#if __cplusplus
extern "C" {
#endif
#ifndef OPENSL_ES_H_
static const effect_uuid_t SL_IID_BASSBOOST_ = {
0x0634f220, 0xddd4, 0x11db, 0xa0fc, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};
const effect_uuid_t* const SL_IID_BASSBOOST = &SL_IID_BASSBOOST_;
#endif // OPENSL_ES_H_
/* enumerated parameter settings for BassBoost effect */
typedef enum { BASSBOOST_PARAM_STRENGTH_SUPPORTED, BASSBOOST_PARAM_STRENGTH } t_bassboost_params;
#if __cplusplus
} // extern "C"
#endif
#endif /*ANDROID_EFFECT_BASSBOOST_CORE_H_*/

50
audio/effect/all-versions/legacy/include/system/audio_effects/effect_downmix.h
View File

@@ -1,50 +0,0 @@
/*
* Copyright (C) 2016 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_EFFECT_DOWNMIX_CORE_H_
#define ANDROID_EFFECT_DOWNMIX_CORE_H_
#include <system/audio_effect.h>
#if __cplusplus
extern "C" {
#endif
#define EFFECT_UIID_DOWNMIX__ \
{ \
0x381e49cc, 0xa858, 0x4aa2, 0x87f6, { 0xe8, 0x38, 0x8e, 0x76, 0x01, 0xb2 } \
}
static const effect_uuid_t EFFECT_UIID_DOWNMIX_ = EFFECT_UIID_DOWNMIX__;
const effect_uuid_t* const EFFECT_UIID_DOWNMIX = &EFFECT_UIID_DOWNMIX_;
/* enumerated parameter settings for downmix effect */
typedef enum { DOWNMIX_PARAM_TYPE } downmix_params_t;
typedef enum {
DOWNMIX_TYPE_INVALID = -1,
// throw away the extra channels
DOWNMIX_TYPE_STRIP = 0,
// mix the extra channels with FL/FR
DOWNMIX_TYPE_FOLD = 1,
DOWNMIX_TYPE_CNT,
DOWNMIX_TYPE_LAST = DOWNMIX_TYPE_CNT - 1
} downmix_type_t;
#if __cplusplus
} // extern "C"
#endif
#endif /*ANDROID_EFFECT_DOWNMIX_CORE_H_*/

67
audio/effect/all-versions/legacy/include/system/audio_effects/effect_environmentalreverb.h
View File

@@ -1,67 +0,0 @@
/*
* Copyright (C) 2016 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_EFFECT_ENVIRONMENTALREVERB_CORE_H_
#define ANDROID_EFFECT_ENVIRONMENTALREVERB_CORE_H_
#include <system/audio_effect.h>
#if __cplusplus
extern "C" {
#endif
#ifndef OPENSL_ES_H_
static const effect_uuid_t SL_IID_ENVIRONMENTALREVERB_ = {
0xc2e5d5f0, 0x94bd, 0x4763, 0x9cac, {0x4e, 0x23, 0x4d, 0x6, 0x83, 0x9e}};
const effect_uuid_t* const SL_IID_ENVIRONMENTALREVERB = &SL_IID_ENVIRONMENTALREVERB_;
#endif // OPENSL_ES_H_
/* enumerated parameter settings for environmental reverb effect */
typedef enum {
// Parameters below are as defined in OpenSL ES specification for environmental reverb interface
REVERB_PARAM_ROOM_LEVEL, // in millibels, range -6000 to 0
REVERB_PARAM_ROOM_HF_LEVEL, // in millibels, range -4000 to 0
REVERB_PARAM_DECAY_TIME, // in milliseconds, range 100 to 20000
REVERB_PARAM_DECAY_HF_RATIO, // in permilles, range 100 to 1000
REVERB_PARAM_REFLECTIONS_LEVEL, // in millibels, range -6000 to 0
REVERB_PARAM_REFLECTIONS_DELAY, // in milliseconds, range 0 to 65
REVERB_PARAM_REVERB_LEVEL, // in millibels, range -6000 to 0
REVERB_PARAM_REVERB_DELAY, // in milliseconds, range 0 to 65
REVERB_PARAM_DIFFUSION, // in permilles, range 0 to 1000
REVERB_PARAM_DENSITY, // in permilles, range 0 to 1000
REVERB_PARAM_PROPERTIES,
REVERB_PARAM_BYPASS
} t_env_reverb_params;
// t_reverb_settings is equal to SLEnvironmentalReverbSettings defined in OpenSL ES specification.
typedef struct s_reverb_settings {
int16_t roomLevel;
int16_t roomHFLevel;
uint32_t decayTime;
int16_t decayHFRatio;
int16_t reflectionsLevel;
uint32_t reflectionsDelay;
int16_t reverbLevel;
uint32_t reverbDelay;
int16_t diffusion;
int16_t density;
} __attribute__((packed)) t_reverb_settings;
#if __cplusplus
} // extern "C"
#endif
#endif /*ANDROID_EFFECT_ENVIRONMENTALREVERB_CORE_H_*/

59
audio/effect/all-versions/legacy/include/system/audio_effects/effect_equalizer.h
View File

@@ -1,59 +0,0 @@
/*
* Copyright (C) 2016 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_EFFECT_EQUALIZER_CORE_H_
#define ANDROID_EFFECT_EQUALIZER_CORE_H_
#include <system/audio_effect.h>
#ifndef OPENSL_ES_H_
static const effect_uuid_t SL_IID_EQUALIZER_ = {
0x0bed4300, 0xddd6, 0x11db, 0x8f34, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};
const effect_uuid_t* const SL_IID_EQUALIZER = &SL_IID_EQUALIZER_;
#endif // OPENSL_ES_H_
#if __cplusplus
extern "C" {
#endif
/* enumerated parameters for Equalizer effect */
typedef enum {
EQ_PARAM_NUM_BANDS, // Gets the number of frequency bands that the equalizer
// supports.
EQ_PARAM_LEVEL_RANGE, // Returns the minimum and maximum band levels supported.
EQ_PARAM_BAND_LEVEL, // Gets/Sets the gain set for the given equalizer band.
EQ_PARAM_CENTER_FREQ, // Gets the center frequency of the given band.
EQ_PARAM_BAND_FREQ_RANGE, // Gets the frequency range of the given frequency band.
EQ_PARAM_GET_BAND, // Gets the band that has the most effect on the given
// frequency.
EQ_PARAM_CUR_PRESET, // Gets/Sets the current preset.
EQ_PARAM_GET_NUM_OF_PRESETS, // Gets the total number of presets the equalizer supports.
EQ_PARAM_GET_PRESET_NAME, // Gets the preset name based on the index.
EQ_PARAM_PROPERTIES // Gets/Sets all parameters at a time.
} t_equalizer_params;
// t_equalizer_settings groups all current equalizer setting for backup and restore.
typedef struct s_equalizer_settings {
uint16_t curPreset;
uint16_t numBands;
uint16_t bandLevels[];
} t_equalizer_settings;
#if __cplusplus
} // extern "C"
#endif
#endif /*ANDROID_EFFECT_EQUALIZER_CORE_H_*/

43
audio/effect/all-versions/legacy/include/system/audio_effects/effect_loudnessenhancer.h
View File

@@ -1,43 +0,0 @@
/*
* Copyright (C) 2016 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_EFFECT_LOUDNESS_ENHANCER_CORE_H_
#define ANDROID_EFFECT_LOUDNESS_ENHANCER_CORE_H_
#include <system/audio_effect.h>
#if __cplusplus
extern "C" {
#endif
// this effect is not defined in OpenSL ES as one of the standard effects
static const effect_uuid_t FX_IID_LOUDNESS_ENHANCER_ = {
0xfe3199be, 0xaed0, 0x413f, 0x87bb, {0x11, 0x26, 0x0e, 0xb6, 0x3c, 0xf1}};
const effect_uuid_t* const FX_IID_LOUDNESS_ENHANCER = &FX_IID_LOUDNESS_ENHANCER_;
#define LOUDNESS_ENHANCER_DEFAULT_TARGET_GAIN_MB 0 // mB
// enumerated parameters for DRC effect
// to keep in sync with frameworks/base/media/java/android/media/audiofx/LoudnessEnhancer.java
typedef enum {
LOUDNESS_ENHANCER_PARAM_TARGET_GAIN_MB = 0, // target gain expressed in mB
} t_level_monitor_params;
#if __cplusplus
} // extern "C"
#endif
#endif /*ANDROID_EFFECT_LOUDNESS_ENHANCER_CORE_H_*/

54
audio/effect/all-versions/legacy/include/system/audio_effects/effect_ns.h
View File

@@ -1,54 +0,0 @@
/*
* Copyright (C) 2016 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_EFFECT_NS_CORE_H_
#define ANDROID_EFFECT_NS_CORE_H_
#include <system/audio_effect.h>
#if __cplusplus
extern "C" {
#endif
// The NS type UUID is not defined by OpenSL ES and has been generated from
// http://www.itu.int/ITU-T/asn1/uuid.html
static const effect_uuid_t FX_IID_NS_ = {
0x58b4b260, 0x8e06, 0x11e0, 0xaa8e, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};
const effect_uuid_t* const FX_IID_NS = &FX_IID_NS_;
typedef enum {
NS_PARAM_LEVEL, // noise suppression level (t_ns_level)
NS_PARAM_PROPERTIES,
NS_PARAM_TYPE // noise suppression type (t_ns_type)
} t_ns_params;
// noise suppression level
typedef enum { NS_LEVEL_LOW, NS_LEVEL_MEDIUM, NS_LEVEL_HIGH } t_ns_level;
// noise suppression type
typedef enum { NS_TYPE_SINGLE_CHANNEL, NS_TYPE_MULTI_CHANNEL } t_ns_type;
// s_ns_settings groups all current ns settings for backup and restore.
typedef struct s_ns_settings {
uint32_t level;
uint32_t type;
} t_ns_settings;
#if __cplusplus
} // extern "C"
#endif
#endif /*ANDROID_EFFECT_NS_CORE_H_*/

50
audio/effect/all-versions/legacy/include/system/audio_effects/effect_presetreverb.h
View File

@@ -1,50 +0,0 @@
/*
* Copyright (C) 2016 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_EFFECT_PRESETREVERB_CORE_H_
#define ANDROID_EFFECT_PRESETREVERB_CORE_H_
#include <system/audio_effect.h>
#if __cplusplus
extern "C" {
#endif
#ifndef OPENSL_ES_H_
static const effect_uuid_t SL_IID_PRESETREVERB_ = {
0x47382d60, 0xddd8, 0x11db, 0xbf3a, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};
const effect_uuid_t* const SL_IID_PRESETREVERB = &SL_IID_PRESETREVERB_;
#endif // OPENSL_ES_H_
/* enumerated parameter settings for preset reverb effect */
typedef enum { REVERB_PARAM_PRESET } t_preset_reverb_params;
typedef enum {
REVERB_PRESET_NONE,
REVERB_PRESET_SMALLROOM,
REVERB_PRESET_MEDIUMROOM,
REVERB_PRESET_LARGEROOM,
REVERB_PRESET_MEDIUMHALL,
REVERB_PRESET_LARGEHALL,
REVERB_PRESET_PLATE,
REVERB_PRESET_LAST = REVERB_PRESET_PLATE
} t_reverb_presets;
#if __cplusplus
} // extern "C"
#endif
#endif /*ANDROID_EFFECT_PRESETREVERB_CORE_H_*/

77
audio/effect/all-versions/legacy/include/system/audio_effects/effect_virtualizer.h
View File

@@ -1,77 +0,0 @@
/*
* Copyright (C) 2016 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_EFFECT_VIRTUALIZER_CORE_H_
#define ANDROID_EFFECT_VIRTUALIZER_CORE_H_
#include <system/audio_effect.h>
#if __cplusplus
extern "C" {
#endif
#ifndef OPENSL_ES_H_
static const effect_uuid_t SL_IID_VIRTUALIZER_ = {
0x37cc2c00, 0xdddd, 0x11db, 0x8577, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};
const effect_uuid_t* const SL_IID_VIRTUALIZER = &SL_IID_VIRTUALIZER_;
#endif // OPENSL_ES_H_
/* enumerated parameter settings for virtualizer effect */
/* to keep in sync with frameworks/base/media/java/android/media/audiofx/Virtualizer.java */
typedef enum {
VIRTUALIZER_PARAM_STRENGTH_SUPPORTED,
VIRTUALIZER_PARAM_STRENGTH,
// used with EFFECT_CMD_GET_PARAM
// format:
// parameters int32_t VIRTUALIZER_PARAM_VIRTUAL_SPEAKER_ANGLES
// audio_channel_mask_t input channel mask
// audio_devices_t audio output device
// output int32_t* an array of length 3 * the number of channels in the mask
// where entries are the succession of the channel mask
// of each speaker (i.e. a single bit is selected in the
// channel mask) followed by the azimuth and the
// elevation angles.
// status int -EINVAL if configuration is not supported or invalid or not forcing
// 0 if configuration is supported and the mode is forced
// notes:
// - all angles are expressed in degrees and are relative to the listener,
// - for azimuth: 0 is the direction the listener faces, 180 is behind the listener, and
// -90 is to her/his left,
// - for elevation: 0 is the horizontal plane, +90 is above the listener, -90 is below.
VIRTUALIZER_PARAM_VIRTUAL_SPEAKER_ANGLES,
// used with EFFECT_CMD_SET_PARAM
// format:
// parameters int32_t VIRTUALIZER_PARAM_FORCE_VIRTUALIZATION_MODE
// audio_devices_t audio output device
// status int -EINVAL if the device is not supported or invalid
// 0 if the device is supported and the mode is forced, or forcing
// was disabled for the AUDIO_DEVICE_NONE audio device.
VIRTUALIZER_PARAM_FORCE_VIRTUALIZATION_MODE,
// used with EFFECT_CMD_GET_PARAM
// format:
// parameters int32_t VIRTUALIZER_PARAM_VIRTUALIZATION_MODE
// output audio_device_t audio device reflecting the current virtualization mode,
// AUDIO_DEVICE_NONE when not virtualizing
// status int -EINVAL if an error occurred
// 0 if the output value is successfully retrieved
VIRTUALIZER_PARAM_VIRTUALIZATION_MODE
} t_virtualizer_params;
#if __cplusplus
} // extern "C"
#endif
#endif /*ANDROID_EFFECT_VIRTUALIZER_CORE_H_*/

71
audio/effect/all-versions/legacy/include/system/audio_effects/effect_visualizer.h
View File

@@ -1,71 +0,0 @@
/*
* Copyright (C) 2016 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_EFFECT_VISUALIZER_CORE_H_
#define ANDROID_EFFECT_VISUALIZER_CORE_H_
#include <system/audio_effect.h>
#if __cplusplus
extern "C" {
#endif
#ifndef OPENSL_ES_H_
static const effect_uuid_t SL_IID_VISUALIZATION_ = {
0xe46b26a0, 0xdddd, 0x11db, 0x8afd, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};
const effect_uuid_t* const SL_IID_VISUALIZATION = &SL_IID_VISUALIZATION_;
#endif // OPENSL_ES_H_
#define VISUALIZER_CAPTURE_SIZE_MAX 1024 // maximum capture size in samples
#define VISUALIZER_CAPTURE_SIZE_MIN 128 // minimum capture size in samples
// to keep in sync with frameworks/base/media/java/android/media/audiofx/Visualizer.java
#define VISUALIZER_SCALING_MODE_NORMALIZED 0
#define VISUALIZER_SCALING_MODE_AS_PLAYED 1
#define MEASUREMENT_MODE_NONE 0x0
#define MEASUREMENT_MODE_PEAK_RMS 0x1
#define MEASUREMENT_IDX_PEAK 0
#define MEASUREMENT_IDX_RMS 1
#define MEASUREMENT_COUNT 2
/* enumerated parameters for Visualizer effect */
typedef enum {
VISUALIZER_PARAM_CAPTURE_SIZE, // Sets the number PCM samples in the capture.
VISUALIZER_PARAM_SCALING_MODE, // Sets the way the captured data is scaled
VISUALIZER_PARAM_LATENCY, // Informs the visualizer about the downstream latency
VISUALIZER_PARAM_MEASUREMENT_MODE, // Sets which measurements are to be made
} t_visualizer_params;
/* commands */
typedef enum {
VISUALIZER_CMD_CAPTURE = EFFECT_CMD_FIRST_PROPRIETARY, // Gets the latest PCM capture.
VISUALIZER_CMD_MEASURE, // Gets the current measurements
} t_visualizer_cmds;
// VISUALIZER_CMD_CAPTURE retrieves the latest PCM snapshot captured by the visualizer engine.
// It returns the number of samples specified by VISUALIZER_PARAM_CAPTURE_SIZE
// in 8 bit unsigned format (0 = 0x80)
// VISUALIZER_CMD_MEASURE retrieves the lastest measurements as int32_t saved in the
// MEASUREMENT_IDX_* array index order.
#if __cplusplus
} // extern "C"
#endif
#endif /*ANDROID_EFFECT_VISUALIZER_CORE_H_*/

7
soundtrigger/2.0/default/Android.bp
View File

@@ -16,7 +16,10 @@
cc_library_shared {
name: "android.hardware.soundtrigger@2.0-core",
defaults: ["hidl_defaults"],
vendor: true,
vendor_available: true,
vndk: {
enabled: true,
},
srcs: [
"SoundTriggerHalImpl.cpp",
],
@@ -34,7 +37,7 @@ cc_library_shared {
],
header_libs: [
"android.hardware.soundtrigger.legacy@2.0",
"libaudio_system_headers",
"libhardware_headers",
],
}

1
soundtrigger/2.0/default/Android.mk
View File

@@ -32,7 +32,6 @@ LOCAL_SHARED_LIBRARIES := \
android.hardware.soundtrigger@2.0-core
LOCAL_C_INCLUDE_DIRS := $(LOCAL_PATH)
LOCAL_HEADER_LIBRARIES += android.hardware.soundtrigger.legacy@2.0
ifeq ($(strip $(AUDIOSERVER_MULTILIB)),)
LOCAL_MULTILIB := 32

11
soundtrigger/2.0/legacy/Android.bp
View File

@@ -1,11 +0,0 @@
cc_library_headers {
name: "android.hardware.soundtrigger.legacy@2.0",
vendor: true,
export_include_dirs: ["include"],
header_libs: [
"android.hardware.audio.common.legacy@2.0",
],
export_header_lib_headers: [
"android.hardware.audio.common.legacy@2.0",
],
}

3
soundtrigger/2.0/legacy/OWNERS
View File

@@ -1,3 +0,0 @@
elaurent@google.com
krocard@google.com
mnaganov@google.com

130
soundtrigger/2.0/legacy/include/hardware/sound_trigger.h
View File

@@ -1,130 +0,0 @@
/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <hardware/hardware.h>
#include <system/audio.h>
#include <system/sound_trigger.h>
#ifndef ANDROID_SOUND_TRIGGER_HAL_H
#define ANDROID_SOUND_TRIGGER_HAL_H
__BEGIN_DECLS
/**
* The id of this module
*/
#define SOUND_TRIGGER_HARDWARE_MODULE_ID "sound_trigger"
/**
* Name of the audio devices to open
*/
#define SOUND_TRIGGER_HARDWARE_INTERFACE "sound_trigger_hw_if"
#define SOUND_TRIGGER_MODULE_API_VERSION_1_0 HARDWARE_MODULE_API_VERSION(1, 0)
#define SOUND_TRIGGER_MODULE_API_VERSION_CURRENT SOUND_TRIGGER_MODULE_API_VERSION_1_0
#define SOUND_TRIGGER_DEVICE_API_VERSION_1_0 HARDWARE_DEVICE_API_VERSION(1, 0)
#define SOUND_TRIGGER_DEVICE_API_VERSION_1_1 HARDWARE_DEVICE_API_VERSION(1, 1)
#define SOUND_TRIGGER_DEVICE_API_VERSION_CURRENT SOUND_TRIGGER_DEVICE_API_VERSION_1_1
/**
* List of known sound trigger HAL modules. This is the base name of the sound_trigger HAL
* library composed of the "sound_trigger." prefix, one of the base names below and
* a suffix specific to the device.
* e.g: sondtrigger.primary.goldfish.so or sound_trigger.primary.default.so
*/
#define SOUND_TRIGGER_HARDWARE_MODULE_ID_PRIMARY "primary"
/**
* 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.
*/
struct sound_trigger_module {
struct hw_module_t common;
};
typedef void (*recognition_callback_t)(struct sound_trigger_recognition_event* event, void* cookie);
typedef void (*sound_model_callback_t)(struct sound_trigger_model_event* event, void* cookie);
struct sound_trigger_hw_device {
struct hw_device_t common;
/*
* Retrieve implementation properties.
*/
int (*get_properties)(const struct sound_trigger_hw_device* dev,
struct sound_trigger_properties* properties);
/*
* Load a sound model. Once loaded, recognition of this model can be started and stopped.
* Only one active recognition per model at a time. The SoundTrigger service will handle
* concurrent recognition requests by different users/applications on the same model.
* The implementation returns a unique handle used by other functions (unload_sound_model(),
* start_recognition(), etc...
*/
int (*load_sound_model)(const struct sound_trigger_hw_device* dev,
struct sound_trigger_sound_model* sound_model,
sound_model_callback_t callback, void* cookie,
sound_model_handle_t* handle);
/*
* Unload a sound model. A sound model can be unloaded to make room for a new one to overcome
* implementation limitations.
*/
int (*unload_sound_model)(const struct sound_trigger_hw_device* dev,
sound_model_handle_t handle);
/* Start recognition on a given model. Only one recognition active at a time per model.
* Once recognition succeeds of fails, the callback is called.
* TODO: group recognition configuration parameters into one struct and add key phrase options.
*/
int (*start_recognition)(const struct sound_trigger_hw_device* dev,
sound_model_handle_t sound_model_handle,
const struct sound_trigger_recognition_config* config,
recognition_callback_t callback, void* cookie);
/* Stop recognition on a given model.
* The implementation does not have to call the callback when stopped via this method.
*/
int (*stop_recognition)(const struct sound_trigger_hw_device* dev,
sound_model_handle_t sound_model_handle);
/* Stop recognition on all models.
* Only supported for device api versions SOUND_TRIGGER_DEVICE_API_VERSION_1_1 or above.
* If no implementation is provided, stop_recognition will be called for each running model.
*/
int (*stop_all_recognitions)(const struct sound_trigger_hw_device* dev);
};
typedef struct sound_trigger_hw_device sound_trigger_hw_device_t;
/** convenience API for opening and closing a supported device */
static inline int sound_trigger_hw_device_open(const struct hw_module_t* module,
struct sound_trigger_hw_device** device) {
return module->methods->open(module, SOUND_TRIGGER_HARDWARE_INTERFACE,
TO_HW_DEVICE_T_OPEN(device));
}
static inline int sound_trigger_hw_device_close(struct sound_trigger_hw_device* device) {
return device->common.close(&device->common);
}
__END_DECLS
#endif // ANDROID_SOUND_TRIGGER_HAL_H

228
soundtrigger/2.0/legacy/include/system/sound_trigger.h
View File

@@ -1,228 +0,0 @@
/*
* Copyright (C) 2014 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_SOUND_TRIGGER_H
#define ANDROID_SOUND_TRIGGER_H
#include <stdbool.h>
#include <system/audio.h>
#define SOUND_TRIGGER_MAX_STRING_LEN 64 // max length of strings in properties & descriptor structs
#define SOUND_TRIGGER_MAX_LOCALE_LEN 6 // max length of locale string. e.g en_US
#define SOUND_TRIGGER_MAX_USERS 10 // max number of concurrent users
#define SOUND_TRIGGER_MAX_PHRASES 10 // max number of concurrent phrases
typedef enum {
SOUND_TRIGGER_STATE_NO_INIT = -1, /* The sound trigger service is not initialized */
SOUND_TRIGGER_STATE_ENABLED = 0, /* The sound trigger service is enabled */
SOUND_TRIGGER_STATE_DISABLED = 1 /* The sound trigger service is disabled */
} sound_trigger_service_state_t;
#define RECOGNITION_MODE_VOICE_TRIGGER 0x1 // simple voice trigger
#define RECOGNITION_MODE_USER_IDENTIFICATION 0x2 // trigger only if one user in model identified
#define RECOGNITION_MODE_USER_AUTHENTICATION 0x4 // trigger only if one user in mode authenticated
#define RECOGNITION_MODE_GENERIC_TRIGGER 0x8 // generic sound trigger
#define RECOGNITION_STATUS_SUCCESS 0
#define RECOGNITION_STATUS_ABORT 1
#define RECOGNITION_STATUS_FAILURE 2
#define SOUND_MODEL_STATUS_UPDATED 0
typedef enum {
SOUND_MODEL_TYPE_UNKNOWN = -1, /* use for unspecified sound model type */
SOUND_MODEL_TYPE_KEYPHRASE = 0, /* use for key phrase sound models */
SOUND_MODEL_TYPE_GENERIC = 1 /* use for all models other than keyphrase */
} sound_trigger_sound_model_type_t;
typedef audio_uuid_t sound_trigger_uuid_t;
/*
* sound trigger implementation descriptor read by the framework via get_properties().
* Used by SoundTrigger service to report to applications and manage concurrency and policy.
*/
struct sound_trigger_properties {
char implementor[SOUND_TRIGGER_MAX_STRING_LEN]; /* implementor name */
char description[SOUND_TRIGGER_MAX_STRING_LEN]; /* implementation description */
unsigned int version; /* implementation version */
sound_trigger_uuid_t uuid; /* unique implementation ID.
Must change with version each version */
unsigned int max_sound_models; /* maximum number of concurrent sound models
loaded */
unsigned int max_key_phrases; /* maximum number of key phrases */
unsigned int max_users; /* maximum number of concurrent users detected */
unsigned int recognition_modes; /* all supported modes.
e.g RECOGNITION_MODE_VOICE_TRIGGER */
bool capture_transition; /* supports seamless transition from detection
to capture */
unsigned int max_buffer_ms; /* maximum buffering capacity in ms if
capture_transition is true*/
bool concurrent_capture; /* supports capture by other use cases while
detection is active */
bool trigger_in_event; /* returns the trigger capture in event */
unsigned int power_consumption_mw; /* Rated power consumption when detection is active
with TDB silence/sound/speech ratio */
};
typedef int sound_trigger_module_handle_t;
struct sound_trigger_module_descriptor {
sound_trigger_module_handle_t handle;
struct sound_trigger_properties properties;
};
typedef int sound_model_handle_t;
/*
* Base sound model descriptor. This struct is the header of a larger block passed to
* load_sound_model() and containing the binary data of the sound model.
* Proprietary representation of users in binary data must match information indicated
* by users field
*/
struct sound_trigger_sound_model {
sound_trigger_sound_model_type_t type; /* model type. e.g. SOUND_MODEL_TYPE_KEYPHRASE */
sound_trigger_uuid_t uuid; /* unique sound model ID. */
sound_trigger_uuid_t vendor_uuid; /* unique vendor ID. Identifies the engine the
sound model was build for */
unsigned int data_size; /* size of opaque model data */
unsigned int data_offset; /* offset of opaque data start from head of struct
(e.g sizeof struct sound_trigger_sound_model) */
};
/* key phrase descriptor */
struct sound_trigger_phrase {
unsigned int id; /* keyphrase ID */
unsigned int recognition_mode; /* recognition modes supported by this key phrase */
unsigned int num_users; /* number of users in the key phrase */
unsigned int users[SOUND_TRIGGER_MAX_USERS]; /* users ids: (not uid_t but sound trigger
specific IDs */
char locale[SOUND_TRIGGER_MAX_LOCALE_LEN]; /* locale - JAVA Locale style (e.g. en_US) */
char text[SOUND_TRIGGER_MAX_STRING_LEN]; /* phrase text in UTF-8 format. */
};
/*
* Specialized sound model for key phrase detection.
* Proprietary representation of key phrases in binary data must match information indicated
* by phrases field
*/
struct sound_trigger_phrase_sound_model {
struct sound_trigger_sound_model common;
unsigned int num_phrases; /* number of key phrases in model */
struct sound_trigger_phrase phrases[SOUND_TRIGGER_MAX_PHRASES];
};
/*
* Generic sound model, used for all cases except key phrase detection.
*/
struct sound_trigger_generic_sound_model {
struct sound_trigger_sound_model common;
};
/*
* Generic recognition event sent via recognition callback
* Must be aligned to transmit as raw memory through Binder.
*/
struct __attribute__((aligned(8))) sound_trigger_recognition_event {
int status; /* recognition status e.g.
RECOGNITION_STATUS_SUCCESS */
sound_trigger_sound_model_type_t type; /* event type, same as sound model type.
e.g. SOUND_MODEL_TYPE_KEYPHRASE */
sound_model_handle_t model; /* loaded sound model that triggered the
event */
bool capture_available; /* it is possible to capture audio from this
utterance buffered by the
implementation */
int capture_session; /* audio session ID. framework use */
int capture_delay_ms; /* delay in ms between end of model
detection and start of audio available
for capture. A negative value is possible
(e.g. if key phrase is also available for
capture */
int capture_preamble_ms; /* duration in ms of audio captured
before the start of the trigger.
0 if none. */
bool trigger_in_data; /* the opaque data is the capture of
the trigger sound */
audio_config_t audio_config; /* audio format of either the trigger in
event data or to use for capture of the
rest of the utterance */
unsigned int data_size; /* size of opaque event data */
unsigned int data_offset; /* offset of opaque data start from start of
this struct (e.g sizeof struct
sound_trigger_phrase_recognition_event) */
};
/*
* Confidence level for each user in struct sound_trigger_phrase_recognition_extra
*/
struct sound_trigger_confidence_level {
unsigned int user_id; /* user ID */
unsigned int level; /* confidence level in percent (0 - 100).
- min level for recognition configuration
- detected level for recognition event */
};
/*
* Specialized recognition event for key phrase detection
*/
struct sound_trigger_phrase_recognition_extra {
unsigned int id; /* keyphrase ID */
unsigned int recognition_modes; /* recognition modes used for this keyphrase */
unsigned int confidence_level; /* confidence level for mode RECOGNITION_MODE_VOICE_TRIGGER */
unsigned int num_levels; /* number of user confidence levels */
struct sound_trigger_confidence_level levels[SOUND_TRIGGER_MAX_USERS];
};
struct sound_trigger_phrase_recognition_event {
struct sound_trigger_recognition_event common;
unsigned int num_phrases;
struct sound_trigger_phrase_recognition_extra phrase_extras[SOUND_TRIGGER_MAX_PHRASES];
};
struct sound_trigger_generic_recognition_event {
struct sound_trigger_recognition_event common;
};
/*
* configuration for sound trigger capture session passed to start_recognition()
*/
struct sound_trigger_recognition_config {
audio_io_handle_t capture_handle; /* IO handle that will be used for capture.
N/A if capture_requested is false */
audio_devices_t capture_device; /* input device requested for detection capture */
bool capture_requested; /* capture and buffer audio for this recognition
instance */
unsigned int num_phrases; /* number of key phrases recognition extras */
struct sound_trigger_phrase_recognition_extra phrases[SOUND_TRIGGER_MAX_PHRASES];
/* configuration for each key phrase */
unsigned int data_size; /* size of opaque capture configuration data */
unsigned int data_offset; /* offset of opaque data start from start of this struct
(e.g sizeof struct sound_trigger_recognition_config) */
};
/*
* Event sent via load sound model callback
*/
struct sound_trigger_model_event {
int status; /* sound model status e.g. SOUND_MODEL_STATUS_UPDATED */
sound_model_handle_t model; /* loaded sound model that triggered the event */
unsigned int data_size; /* size of event data if any. Size of updated sound model if
status is SOUND_MODEL_STATUS_UPDATED */
unsigned int data_offset; /* offset of data start from start of this struct
(e.g sizeof struct sound_trigger_model_event) */
};
#endif // ANDROID_SOUND_TRIGGER_H

2
soundtrigger/2.1/default/Android.mk
View File

@@ -38,8 +38,6 @@ LOCAL_SHARED_LIBRARIES := \
android.hidl.allocator@1.0 \
android.hidl.memory@1.0
LOCAL_HEADER_LIBRARIES := android.hardware.soundtrigger.legacy@2.0
LOCAL_C_INCLUDE_DIRS := $(LOCAL_PATH)
ifeq ($(strip $(AUDIOSERVER_MULTILIB)),)

3
tv/input/1.0/default/Android.bp
View File

@@ -16,9 +16,6 @@ cc_library_shared {
"android.hardware.tv.input@1.0",
],
header_libs: [
"android.hardware.audio.common.legacy@2.0",
],
}
cc_binary {