namespace android_audio_legacy {
+class AudioHardwareInterface;
+
extern "C" {
struct legacy_audio_module {
struct legacy_audio_device {
struct audio_hw_device device;
- struct AudioHardwareInterface *hwif;
+ AudioHardwareInterface *hwif;
};
struct legacy_stream_out {
AudioStreamIn *legacy_in;
};
+
+enum {
+ HAL_API_REV_1_0,
+ HAL_API_REV_2_0,
+ HAL_API_REV_NUM
+} hal_api_rev;
+
+static uint32_t audio_device_conv_table[][HAL_API_REV_NUM] =
+{
+ /* output devices */
+ { AudioSystem::DEVICE_OUT_EARPIECE, AUDIO_DEVICE_OUT_EARPIECE },
+ { AudioSystem::DEVICE_OUT_SPEAKER, AUDIO_DEVICE_OUT_SPEAKER },
+ { AudioSystem::DEVICE_OUT_WIRED_HEADSET, AUDIO_DEVICE_OUT_WIRED_HEADSET },
+ { AudioSystem::DEVICE_OUT_WIRED_HEADPHONE, AUDIO_DEVICE_OUT_WIRED_HEADPHONE },
+ { AudioSystem::DEVICE_OUT_BLUETOOTH_SCO, AUDIO_DEVICE_OUT_BLUETOOTH_SCO },
+ { AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET, AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET },
+ { AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT, AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT },
+ { AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP },
+ { AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES },
+ { AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER },
+ { AudioSystem::DEVICE_OUT_AUX_DIGITAL, AUDIO_DEVICE_OUT_AUX_DIGITAL },
+ { AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET, AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET },
+ { AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET, AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET },
+ { AudioSystem::DEVICE_OUT_DEFAULT, AUDIO_DEVICE_OUT_DEFAULT },
+ /* input devices */
+ { AudioSystem::DEVICE_IN_COMMUNICATION, AUDIO_DEVICE_IN_COMMUNICATION },
+ { AudioSystem::DEVICE_IN_AMBIENT, AUDIO_DEVICE_IN_AMBIENT },
+ { AudioSystem::DEVICE_IN_BUILTIN_MIC, AUDIO_DEVICE_IN_BUILTIN_MIC },
+ { AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET, AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET },
+ { AudioSystem::DEVICE_IN_WIRED_HEADSET, AUDIO_DEVICE_IN_WIRED_HEADSET },
+ { AudioSystem::DEVICE_IN_AUX_DIGITAL, AUDIO_DEVICE_IN_AUX_DIGITAL },
+ { AudioSystem::DEVICE_IN_VOICE_CALL, AUDIO_DEVICE_IN_VOICE_CALL },
+ { AudioSystem::DEVICE_IN_BACK_MIC, AUDIO_DEVICE_IN_BACK_MIC },
+ { AudioSystem::DEVICE_IN_DEFAULT, AUDIO_DEVICE_IN_DEFAULT },
+};
+
+static uint32_t convert_audio_device(uint32_t from_device, int from_rev, int to_rev)
+{
+ const uint32_t k_num_devices = sizeof(audio_device_conv_table)/sizeof(uint32_t)/HAL_API_REV_NUM;
+ uint32_t to_device = AUDIO_DEVICE_NONE;
+ uint32_t in_bit = 0;
+
+ if (from_rev != HAL_API_REV_1_0) {
+ in_bit = from_device & AUDIO_DEVICE_BIT_IN;
+ from_device &= ~AUDIO_DEVICE_BIT_IN;
+ }
+
+ while (from_device) {
+ uint32_t i = 31 - __builtin_clz(from_device);
+ uint32_t cur_device = (1 << i) | in_bit;
+
+ for (i = 0; i < k_num_devices; i++) {
+ if (audio_device_conv_table[i][from_rev] == cur_device) {
+ to_device |= audio_device_conv_table[i][to_rev];
+ break;
+ }
+ }
+ from_device &= ~cur_device;
+ }
+ return to_device;
+}
+
+
/** audio_stream_out implementation **/
static uint32_t out_get_sample_rate(const struct audio_stream *stream)
{
return out->legacy_out->bufferSize();
}
-static uint32_t out_get_channels(const struct audio_stream *stream)
+static audio_channel_mask_t out_get_channels(const struct audio_stream *stream)
{
const struct legacy_stream_out *out =
reinterpret_cast<const struct legacy_stream_out *>(stream);
- return out->legacy_out->channels();
+ return (audio_channel_mask_t) out->legacy_out->channels();
}
static audio_format_t out_get_format(const struct audio_stream *stream)
{
struct legacy_stream_out *out =
reinterpret_cast<struct legacy_stream_out *>(stream);
- return out->legacy_out->setParameters(String8(kvpairs));
+ int val;
+ String8 s8 = String8(kvpairs);
+ AudioParameter parms = AudioParameter(String8(kvpairs));
+
+ if (parms.getInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val) == NO_ERROR) {
+ val = convert_audio_device(val, HAL_API_REV_2_0, HAL_API_REV_1_0);
+ parms.remove(String8(AUDIO_PARAMETER_STREAM_ROUTING));
+ parms.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val);
+ s8 = parms.toString();
+ }
+
+ return out->legacy_out->setParameters(s8);
}
static char * out_get_parameters(const struct audio_stream *stream, const char *keys)
const struct legacy_stream_out *out =
reinterpret_cast<const struct legacy_stream_out *>(stream);
String8 s8;
+ int val;
+
s8 = out->legacy_out->getParameters(String8(keys));
+
+ AudioParameter parms = AudioParameter(s8);
+ if (parms.getInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val) == NO_ERROR) {
+ val = convert_audio_device(val, HAL_API_REV_1_0, HAL_API_REV_2_0);
+ parms.remove(String8(AUDIO_PARAMETER_STREAM_ROUTING));
+ parms.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val);
+ s8 = parms.toString();
+ }
+
return strdup(s8.string());
}
return out->legacy_out->getRenderPosition(dsp_frames);
}
+static int out_get_next_write_timestamp(const struct audio_stream_out *stream,
+ int64_t *timestamp)
+{
+ const struct legacy_stream_out *out =
+ reinterpret_cast<const struct legacy_stream_out *>(stream);
+ return out->legacy_out->getNextWriteTimestamp(timestamp);
+}
+
static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
{
return 0;
return in->legacy_in->bufferSize();
}
-static uint32_t in_get_channels(const struct audio_stream *stream)
+static audio_channel_mask_t in_get_channels(const struct audio_stream *stream)
{
const struct legacy_stream_in *in =
reinterpret_cast<const struct legacy_stream_in *>(stream);
- return in->legacy_in->channels();
+ return (audio_channel_mask_t) in->legacy_in->channels();
}
static audio_format_t in_get_format(const struct audio_stream *stream)
{
struct legacy_stream_in *in =
reinterpret_cast<struct legacy_stream_in *>(stream);
- return in->legacy_in->setParameters(String8(kvpairs));
+ int val;
+ AudioParameter parms = AudioParameter(String8(kvpairs));
+ String8 s8 = String8(kvpairs);
+
+ if (parms.getInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val) == NO_ERROR) {
+ val = convert_audio_device(val, HAL_API_REV_2_0, HAL_API_REV_1_0);
+ parms.remove(String8(AUDIO_PARAMETER_STREAM_ROUTING));
+ parms.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val);
+ s8 = parms.toString();
+ }
+
+ return in->legacy_in->setParameters(s8);
}
static char * in_get_parameters(const struct audio_stream *stream,
const struct legacy_stream_in *in =
reinterpret_cast<const struct legacy_stream_in *>(stream);
String8 s8;
+ int val;
+
s8 = in->legacy_in->getParameters(String8(keys));
+
+ AudioParameter parms = AudioParameter(s8);
+ if (parms.getInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val) == NO_ERROR) {
+ val = convert_audio_device(val, HAL_API_REV_1_0, HAL_API_REV_2_0);
+ parms.remove(String8(AUDIO_PARAMETER_STREAM_ROUTING));
+ parms.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val);
+ s8 = parms.toString();
+ }
+
return strdup(s8.string());
}
return reinterpret_cast<const struct legacy_audio_device *>(dev);
}
-static uint32_t adev_get_supported_devices(const struct audio_hw_device *dev)
-{
- /* XXX: The old AudioHardwareInterface interface is not smart enough to
- * tell us this, so we'll lie and basically tell AF that we support the
- * below input/output devices and cross our fingers. To do things properly,
- * audio hardware interfaces that need advanced features (like this) should
- * convert to the new HAL interface and not use this wrapper. */
-
- return (/* OUT */
- AUDIO_DEVICE_OUT_EARPIECE |
- AUDIO_DEVICE_OUT_SPEAKER |
- AUDIO_DEVICE_OUT_WIRED_HEADSET |
- AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
- AUDIO_DEVICE_OUT_AUX_DIGITAL |
- AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET |
- AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET |
- AUDIO_DEVICE_OUT_ALL_SCO |
- AUDIO_DEVICE_OUT_DEFAULT |
- /* IN */
- AUDIO_DEVICE_IN_COMMUNICATION |
- AUDIO_DEVICE_IN_AMBIENT |
- AUDIO_DEVICE_IN_BUILTIN_MIC |
- AUDIO_DEVICE_IN_WIRED_HEADSET |
- AUDIO_DEVICE_IN_AUX_DIGITAL |
- AUDIO_DEVICE_IN_BACK_MIC |
- AUDIO_DEVICE_IN_ALL_SCO |
- AUDIO_DEVICE_IN_DEFAULT);
-}
-
static int adev_init_check(const struct audio_hw_device *dev)
{
const struct legacy_audio_device *ladev = to_cladev(dev);
}
static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
- uint32_t sample_rate, audio_format_t format,
- int channel_count)
+ const struct audio_config *config)
{
const struct legacy_audio_device *ladev = to_cladev(dev);
- return ladev->hwif->getInputBufferSize(sample_rate, (int) format, channel_count);
+ return ladev->hwif->getInputBufferSize(config->sample_rate, (int) config->format,
+ audio_channel_count_from_in_mask(config->channel_mask));
}
static int adev_open_output_stream(struct audio_hw_device *dev,
- uint32_t devices,
- audio_format_t *format,
- uint32_t *channels,
- uint32_t *sample_rate,
- struct audio_stream_out **stream_out)
+ 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 __unused)
{
struct legacy_audio_device *ladev = to_ladev(dev);
status_t status;
if (!out)
return -ENOMEM;
- out->legacy_out = ladev->hwif->openOutputStream(devices, (int *) format, channels,
- sample_rate, &status);
+ devices = convert_audio_device(devices, HAL_API_REV_2_0, HAL_API_REV_1_0);
+
+ out->legacy_out = ladev->hwif->openOutputStreamWithFlags(devices, flags,
+ (int *) &config->format,
+ &config->channel_mask,
+ &config->sample_rate, &status);
if (!out->legacy_out) {
ret = status;
goto err_open;
out->stream.set_volume = out_set_volume;
out->stream.write = out_write;
out->stream.get_render_position = out_get_render_position;
+ out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
*stream_out = &out->stream;
return 0;
/** This method creates and opens the audio hardware input stream */
static int adev_open_input_stream(struct audio_hw_device *dev,
- uint32_t devices, audio_format_t *format,
- uint32_t *channels, uint32_t *sample_rate,
- audio_in_acoustics_t acoustics,
- struct audio_stream_in **stream_in)
+ audio_io_handle_t handle,
+ audio_devices_t devices,
+ struct audio_config *config,
+ struct audio_stream_in **stream_in,
+ audio_input_flags_t flags __unused,
+ const char *address __unused,
+ audio_source_t source __unused)
{
struct legacy_audio_device *ladev = to_ladev(dev);
status_t status;
if (!in)
return -ENOMEM;
- in->legacy_in = ladev->hwif->openInputStream(devices, (int *) format, channels,
- sample_rate, &status,
- (AudioSystem::audio_in_acoustics)acoustics);
+ devices = convert_audio_device(devices, HAL_API_REV_2_0, HAL_API_REV_1_0);
+
+ in->legacy_in = ladev->hwif->openInputStream(devices, (int *) &config->format,
+ &config->channel_mask, &config->sample_rate,
+ &status, (AudioSystem::audio_in_acoustics)0);
if (!in->legacy_in) {
ret = status;
goto err_open;
return -ENOMEM;
ladev->device.common.tag = HARDWARE_DEVICE_TAG;
- ladev->device.common.version = 0;
+ ladev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
ladev->device.common.module = const_cast<hw_module_t*>(module);
ladev->device.common.close = legacy_adev_close;
- ladev->device.get_supported_devices = adev_get_supported_devices;
ladev->device.init_check = adev_init_check;
ladev->device.set_voice_volume = adev_set_voice_volume;
ladev->device.set_master_volume = adev_set_master_volume;
module: {
common: {
tag: HARDWARE_MODULE_TAG,
- version_major: 1,
- version_minor: 0,
+ module_api_version: AUDIO_MODULE_API_VERSION_0_1,
+ hal_api_version: HARDWARE_HAL_API_VERSION,
id: AUDIO_HARDWARE_MODULE_ID,
name: "LEGACY Audio HW HAL",
author: "The Android Open Source Project",
OSDN Git Service
