Audio V4: Fix issues in the legacy wrapper raised by clang-format
This patch only contains cosmetic reformatting imposed by clang-format.
Bug: 38184704
Test: compile
Change-Id: I57545f2b8de1e982028ef4794328741d91682e0c
Signed-off-by: Kevin Rocard <krocard@google.com>
diff --git a/audio/2.0/default/Conversions.cpp b/audio/2.0/default/Conversions.cpp
index e669185..edd49c5 100644
--- a/audio/2.0/default/Conversions.cpp
+++ b/audio/2.0/default/Conversions.cpp
@@ -31,31 +31,25 @@
uint32_t halDevice = static_cast<uint32_t>(address.device);
const bool isInput = (halDevice & AUDIO_DEVICE_BIT_IN) != 0;
if (isInput) halDevice &= ~AUDIO_DEVICE_BIT_IN;
- if ((!isInput && (halDevice & AUDIO_DEVICE_OUT_ALL_A2DP) != 0)
- || (isInput && (halDevice & AUDIO_DEVICE_IN_BLUETOOTH_A2DP) != 0)) {
- snprintf(halAddress, sizeof(halAddress),
- "%02X:%02X:%02X:%02X:%02X:%02X",
- address.address.mac[0], address.address.mac[1], address.address.mac[2],
- address.address.mac[3], address.address.mac[4], address.address.mac[5]);
- } else if ((!isInput && (halDevice & AUDIO_DEVICE_OUT_IP) != 0)
- || (isInput && (halDevice & AUDIO_DEVICE_IN_IP) != 0)) {
- snprintf(halAddress, sizeof(halAddress),
- "%d.%d.%d.%d",
- address.address.ipv4[0], address.address.ipv4[1],
- address.address.ipv4[2], address.address.ipv4[3]);
- } else if ((!isInput && (halDevice & AUDIO_DEVICE_OUT_ALL_USB) != 0)
- || (isInput && (halDevice & AUDIO_DEVICE_IN_ALL_USB) != 0)) {
- snprintf(halAddress, sizeof(halAddress),
- "card=%d;device=%d",
- address.address.alsa.card, address.address.alsa.device);
- } else if ((!isInput && (halDevice & AUDIO_DEVICE_OUT_BUS) != 0)
- || (isInput && (halDevice & AUDIO_DEVICE_IN_BUS) != 0)) {
- snprintf(halAddress, sizeof(halAddress),
- "%s", address.busAddress.c_str());
- } else if ((!isInput && (halDevice & AUDIO_DEVICE_OUT_REMOTE_SUBMIX)) != 0
- || (isInput && (halDevice & AUDIO_DEVICE_IN_REMOTE_SUBMIX) != 0)) {
- snprintf(halAddress, sizeof(halAddress),
- "%s", address.rSubmixAddress.c_str());
+ if ((!isInput && (halDevice & AUDIO_DEVICE_OUT_ALL_A2DP) != 0) ||
+ (isInput && (halDevice & AUDIO_DEVICE_IN_BLUETOOTH_A2DP) != 0)) {
+ snprintf(halAddress, sizeof(halAddress), "%02X:%02X:%02X:%02X:%02X:%02X",
+ address.address.mac[0], address.address.mac[1], address.address.mac[2],
+ address.address.mac[3], address.address.mac[4], address.address.mac[5]);
+ } else if ((!isInput && (halDevice & AUDIO_DEVICE_OUT_IP) != 0) ||
+ (isInput && (halDevice & AUDIO_DEVICE_IN_IP) != 0)) {
+ snprintf(halAddress, sizeof(halAddress), "%d.%d.%d.%d", address.address.ipv4[0],
+ address.address.ipv4[1], address.address.ipv4[2], address.address.ipv4[3]);
+ } else if ((!isInput && (halDevice & AUDIO_DEVICE_OUT_ALL_USB) != 0) ||
+ (isInput && (halDevice & AUDIO_DEVICE_IN_ALL_USB) != 0)) {
+ snprintf(halAddress, sizeof(halAddress), "card=%d;device=%d", address.address.alsa.card,
+ address.address.alsa.device);
+ } else if ((!isInput && (halDevice & AUDIO_DEVICE_OUT_BUS) != 0) ||
+ (isInput && (halDevice & AUDIO_DEVICE_IN_BUS) != 0)) {
+ snprintf(halAddress, sizeof(halAddress), "%s", address.busAddress.c_str());
+ } else if ((!isInput && (halDevice & AUDIO_DEVICE_OUT_REMOTE_SUBMIX)) != 0 ||
+ (isInput && (halDevice & AUDIO_DEVICE_IN_REMOTE_SUBMIX) != 0)) {
+ snprintf(halAddress, sizeof(halAddress), "%s", address.rSubmixAddress.c_str());
}
return halAddress;
}
diff --git a/audio/2.0/default/Device.cpp b/audio/2.0/default/Device.cpp
index c392f65..dae07ab 100644
--- a/audio/2.0/default/Device.cpp
+++ b/audio/2.0/default/Device.cpp
@@ -1,25 +1,25 @@
/*
-* 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.
-*/
+ * 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.
+ */
#define LOG_TAG "DeviceHAL"
//#define LOG_NDEBUG 0
-#include <algorithm>
#include <memory.h>
#include <string.h>
+#include <algorithm>
#include <android/log.h>
@@ -38,14 +38,11 @@
namespace V2_0 {
namespace implementation {
-Device::Device(audio_hw_device_t* device)
- : mDevice(device) {
-}
+Device::Device(audio_hw_device_t* device) : mDevice(device) {}
Device::~Device() {
int status = audio_hw_device_close(mDevice);
- ALOGW_IF(status, "Error closing audio hw device %p: %s", mDevice,
- strerror(-status));
+ ALOGW_IF(status, "Error closing audio hw device %p: %s", mDevice, strerror(-status));
mDevice = nullptr;
}
@@ -98,16 +95,14 @@
ALOGW("Can not set a master volume (%f) outside [0,1]", volume);
return Result::INVALID_ARGUMENTS;
}
- return analyzeStatus("set_master_volume",
- mDevice->set_master_volume(mDevice, volume));
+ return analyzeStatus("set_master_volume", mDevice->set_master_volume(mDevice, volume));
}
Return<void> Device::getMasterVolume(getMasterVolume_cb _hidl_cb) {
Result retval(Result::NOT_SUPPORTED);
float volume = 0;
if (mDevice->get_master_volume != NULL) {
- retval = analyzeStatus("get_master_volume",
- mDevice->get_master_volume(mDevice, &volume));
+ retval = analyzeStatus("get_master_volume", mDevice->get_master_volume(mDevice, &volume));
}
_hidl_cb(retval, volume);
return Void();
@@ -119,8 +114,7 @@
Return<void> Device::getMicMute(getMicMute_cb _hidl_cb) {
bool mute = false;
- Result retval =
- analyzeStatus("get_mic_mute", mDevice->get_mic_mute(mDevice, &mute));
+ Result retval = analyzeStatus("get_mic_mute", mDevice->get_mic_mute(mDevice, &mute));
_hidl_cb(retval, mute);
return Void();
}
@@ -128,8 +122,7 @@
Return<Result> Device::setMasterMute(bool mute) {
Result retval(Result::NOT_SUPPORTED);
if (mDevice->set_master_mute != NULL) {
- retval = analyzeStatus("set_master_mute",
- mDevice->set_master_mute(mDevice, mute));
+ retval = analyzeStatus("set_master_mute", mDevice->set_master_mute(mDevice, mute));
}
return retval;
}
@@ -138,15 +131,13 @@
Result retval(Result::NOT_SUPPORTED);
bool mute = false;
if (mDevice->get_master_mute != NULL) {
- retval = analyzeStatus("get_master_mute",
- mDevice->get_master_mute(mDevice, &mute));
+ retval = analyzeStatus("get_master_mute", mDevice->get_master_mute(mDevice, &mute));
}
_hidl_cb(retval, mute);
return Void();
}
-Return<void> Device::getInputBufferSize(const AudioConfig& config,
- getInputBufferSize_cb _hidl_cb) {
+Return<void> Device::getInputBufferSize(const AudioConfig& config, getInputBufferSize_cb _hidl_cb) {
audio_config_t halConfig;
HidlUtils::audioConfigToHal(config, &halConfig);
size_t halBufferSize = mDevice->get_input_buffer_size(mDevice, &halConfig);
@@ -160,10 +151,8 @@
return Void();
}
-Return<void> Device::openOutputStream(int32_t ioHandle,
- const DeviceAddress& device,
- const AudioConfig& config,
- AudioOutputFlag flags,
+Return<void> Device::openOutputStream(int32_t ioHandle, const DeviceAddress& device,
+ const AudioConfig& config, AudioOutputFlag flags,
openOutputStream_cb _hidl_cb) {
audio_config_t halConfig;
HidlUtils::audioConfigToHal(config, &halConfig);
@@ -172,13 +161,12 @@
"open_output_stream handle: %d devices: %x flags: %#x "
"srate: %d format %#x channels %x address %s",
ioHandle, static_cast<audio_devices_t>(device.device),
- static_cast<audio_output_flags_t>(flags), halConfig.sample_rate,
- halConfig.format, halConfig.channel_mask,
- deviceAddressToHal(device).c_str());
- int status = mDevice->open_output_stream(
- mDevice, ioHandle, static_cast<audio_devices_t>(device.device),
- static_cast<audio_output_flags_t>(flags), &halConfig, &halStream,
- deviceAddressToHal(device).c_str());
+ static_cast<audio_output_flags_t>(flags), halConfig.sample_rate, halConfig.format,
+ halConfig.channel_mask, deviceAddressToHal(device).c_str());
+ int status =
+ mDevice->open_output_stream(mDevice, ioHandle, static_cast<audio_devices_t>(device.device),
+ static_cast<audio_output_flags_t>(flags), &halConfig,
+ &halStream, deviceAddressToHal(device).c_str());
ALOGV("open_output_stream status %d stream %p", status, halStream);
sp<IStreamOut> streamOut;
if (status == OK) {
@@ -186,16 +174,13 @@
}
AudioConfig suggestedConfig;
HidlUtils::audioConfigFromHal(halConfig, &suggestedConfig);
- _hidl_cb(analyzeStatus("open_output_stream", status), streamOut,
- suggestedConfig);
+ _hidl_cb(analyzeStatus("open_output_stream", status), streamOut, suggestedConfig);
return Void();
}
-Return<void> Device::openInputStream(int32_t ioHandle,
- const DeviceAddress& device,
- const AudioConfig& config,
- AudioInputFlag flags, AudioSource source,
- openInputStream_cb _hidl_cb) {
+Return<void> Device::openInputStream(int32_t ioHandle, const DeviceAddress& device,
+ const AudioConfig& config, AudioInputFlag flags,
+ AudioSource source, openInputStream_cb _hidl_cb) {
audio_config_t halConfig;
HidlUtils::audioConfigToHal(config, &halConfig);
audio_stream_in_t* halStream;
@@ -203,14 +188,12 @@
"open_input_stream handle: %d devices: %x flags: %#x "
"srate: %d format %#x channels %x address %s source %d",
ioHandle, static_cast<audio_devices_t>(device.device),
- static_cast<audio_input_flags_t>(flags), halConfig.sample_rate,
- halConfig.format, halConfig.channel_mask,
- deviceAddressToHal(device).c_str(),
+ static_cast<audio_input_flags_t>(flags), halConfig.sample_rate, halConfig.format,
+ halConfig.channel_mask, deviceAddressToHal(device).c_str(),
static_cast<audio_source_t>(source));
int status = mDevice->open_input_stream(
- mDevice, ioHandle, static_cast<audio_devices_t>(device.device),
- &halConfig, &halStream, static_cast<audio_input_flags_t>(flags),
- deviceAddressToHal(device).c_str(),
+ mDevice, ioHandle, static_cast<audio_devices_t>(device.device), &halConfig, &halStream,
+ static_cast<audio_input_flags_t>(flags), deviceAddressToHal(device).c_str(),
static_cast<audio_source_t>(source));
ALOGV("open_input_stream status %d stream %p", status, halStream);
sp<IStreamIn> streamIn;
@@ -219,8 +202,7 @@
}
AudioConfig suggestedConfig;
HidlUtils::audioConfigFromHal(halConfig, &suggestedConfig);
- _hidl_cb(analyzeStatus("open_input_stream", status), streamIn,
- suggestedConfig);
+ _hidl_cb(analyzeStatus("open_input_stream", status), streamIn, suggestedConfig);
return Void();
}
@@ -234,15 +216,12 @@
Result retval(Result::NOT_SUPPORTED);
AudioPatchHandle patch = 0;
if (version() >= AUDIO_DEVICE_API_VERSION_3_0) {
- std::unique_ptr<audio_port_config[]> halSources(
- HidlUtils::audioPortConfigsToHal(sources));
- std::unique_ptr<audio_port_config[]> halSinks(
- HidlUtils::audioPortConfigsToHal(sinks));
+ std::unique_ptr<audio_port_config[]> halSources(HidlUtils::audioPortConfigsToHal(sources));
+ std::unique_ptr<audio_port_config[]> halSinks(HidlUtils::audioPortConfigsToHal(sinks));
audio_patch_handle_t halPatch = AUDIO_PATCH_HANDLE_NONE;
- retval = analyzeStatus(
- "create_audio_patch",
- mDevice->create_audio_patch(mDevice, sources.size(), &halSources[0],
- sinks.size(), &halSinks[0], &halPatch));
+ retval = analyzeStatus("create_audio_patch",
+ mDevice->create_audio_patch(mDevice, sources.size(), &halSources[0],
+ sinks.size(), &halSinks[0], &halPatch));
if (retval == Result::OK) {
patch = static_cast<AudioPatchHandle>(halPatch);
}
@@ -255,18 +234,15 @@
if (version() >= AUDIO_DEVICE_API_VERSION_3_0) {
return analyzeStatus(
"release_audio_patch",
- mDevice->release_audio_patch(
- mDevice, static_cast<audio_patch_handle_t>(patch)));
+ mDevice->release_audio_patch(mDevice, static_cast<audio_patch_handle_t>(patch)));
}
return Result::NOT_SUPPORTED;
}
-Return<void> Device::getAudioPort(const AudioPort& port,
- getAudioPort_cb _hidl_cb) {
+Return<void> Device::getAudioPort(const AudioPort& port, getAudioPort_cb _hidl_cb) {
audio_port halPort;
HidlUtils::audioPortToHal(port, &halPort);
- Result retval = analyzeStatus("get_audio_port",
- mDevice->get_audio_port(mDevice, &halPort));
+ Result retval = analyzeStatus("get_audio_port", mDevice->get_audio_port(mDevice, &halPort));
AudioPort resultPort = port;
if (retval == Result::OK) {
HidlUtils::audioPortFromHal(halPort, &resultPort);
@@ -279,9 +255,8 @@
if (version() >= AUDIO_DEVICE_API_VERSION_3_0) {
struct audio_port_config halPortConfig;
HidlUtils::audioPortConfigToHal(config, &halPortConfig);
- return analyzeStatus(
- "set_audio_port_config",
- mDevice->set_audio_port_config(mDevice, &halPortConfig));
+ return analyzeStatus("set_audio_port_config",
+ mDevice->set_audio_port_config(mDevice, &halPortConfig));
}
return Result::NOT_SUPPORTED;
}
@@ -296,14 +271,12 @@
return setParam(AudioParameter::keyScreenState, turnedOn);
}
-Return<void> Device::getParameters(const hidl_vec<hidl_string>& keys,
- getParameters_cb _hidl_cb) {
+Return<void> Device::getParameters(const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb) {
getParametersImpl(keys, _hidl_cb);
return Void();
}
-Return<Result> Device::setParameters(
- const hidl_vec<ParameterValue>& parameters) {
+Return<Result> Device::setParameters(const hidl_vec<ParameterValue>& parameters) {
return setParametersImpl(parameters);
}
diff --git a/audio/2.0/default/Device.h b/audio/2.0/default/Device.h
index 7738361..b62e696 100644
--- a/audio/2.0/default/Device.h
+++ b/audio/2.0/default/Device.h
@@ -19,8 +19,8 @@
#include <memory>
-#include <media/AudioParameter.h>
#include <hardware/audio.h>
+#include <media/AudioParameter.h>
#include <android/hardware/audio/2.0/IDevice.h>
#include <hidl/Status.h>
@@ -59,42 +59,34 @@
explicit Device(audio_hw_device_t* device);
// Methods from ::android::hardware::audio::V2_0::IDevice follow.
- Return<Result> initCheck() override;
- Return<Result> setMasterVolume(float volume) override;
- Return<void> getMasterVolume(getMasterVolume_cb _hidl_cb) override;
- Return<Result> setMicMute(bool mute) override;
- Return<void> getMicMute(getMicMute_cb _hidl_cb) override;
- Return<Result> setMasterMute(bool mute) override;
- Return<void> getMasterMute(getMasterMute_cb _hidl_cb) override;
- Return<void> getInputBufferSize(
- const AudioConfig& config, getInputBufferSize_cb _hidl_cb) override;
- Return<void> openOutputStream(
- int32_t ioHandle,
- const DeviceAddress& device,
- const AudioConfig& config,
- AudioOutputFlag flags,
- openOutputStream_cb _hidl_cb) override;
- Return<void> openInputStream(
- int32_t ioHandle,
- const DeviceAddress& device,
- const AudioConfig& config,
- AudioInputFlag flags,
- AudioSource source,
- openInputStream_cb _hidl_cb) override;
- Return<bool> supportsAudioPatches() override;
- Return<void> createAudioPatch(
- const hidl_vec<AudioPortConfig>& sources,
- const hidl_vec<AudioPortConfig>& sinks,
- createAudioPatch_cb _hidl_cb) override;
- Return<Result> releaseAudioPatch(int32_t patch) override;
- Return<void> getAudioPort(const AudioPort& port, getAudioPort_cb _hidl_cb) override;
- Return<Result> setAudioPortConfig(const AudioPortConfig& config) override;
- Return<AudioHwSync> getHwAvSync() override;
- Return<Result> setScreenState(bool turnedOn) override;
- Return<void> getParameters(
- const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb) override;
- Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters) override;
- Return<void> debugDump(const hidl_handle& fd) override;
+ Return<Result> initCheck() override;
+ Return<Result> setMasterVolume(float volume) override;
+ Return<void> getMasterVolume(getMasterVolume_cb _hidl_cb) override;
+ Return<Result> setMicMute(bool mute) override;
+ Return<void> getMicMute(getMicMute_cb _hidl_cb) override;
+ Return<Result> setMasterMute(bool mute) override;
+ Return<void> getMasterMute(getMasterMute_cb _hidl_cb) override;
+ Return<void> getInputBufferSize(const AudioConfig& config,
+ getInputBufferSize_cb _hidl_cb) override;
+ Return<void> openOutputStream(int32_t ioHandle, const DeviceAddress& device,
+ const AudioConfig& config, AudioOutputFlag flags,
+ openOutputStream_cb _hidl_cb) override;
+ Return<void> openInputStream(int32_t ioHandle, const DeviceAddress& device,
+ const AudioConfig& config, AudioInputFlag flags,
+ AudioSource source, openInputStream_cb _hidl_cb) override;
+ Return<bool> supportsAudioPatches() override;
+ Return<void> createAudioPatch(const hidl_vec<AudioPortConfig>& sources,
+ const hidl_vec<AudioPortConfig>& sinks,
+ createAudioPatch_cb _hidl_cb) override;
+ Return<Result> releaseAudioPatch(int32_t patch) override;
+ Return<void> getAudioPort(const AudioPort& port, getAudioPort_cb _hidl_cb) override;
+ Return<Result> setAudioPortConfig(const AudioPortConfig& config) override;
+ Return<AudioHwSync> getHwAvSync() override;
+ Return<Result> setScreenState(bool turnedOn) override;
+ Return<void> getParameters(const hidl_vec<hidl_string>& keys,
+ getParameters_cb _hidl_cb) override;
+ Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters) override;
+ Return<void> debugDump(const hidl_handle& fd) override;
// Utility methods for extending interfaces.
Result analyzeStatus(const char* funcName, int status);
@@ -102,8 +94,8 @@
void closeOutputStream(audio_stream_out_t* stream);
audio_hw_device_t* device() const { return mDevice; }
- private:
- audio_hw_device_t *mDevice;
+ private:
+ audio_hw_device_t* mDevice;
virtual ~Device();
diff --git a/audio/2.0/default/DevicesFactory.cpp b/audio/2.0/default/DevicesFactory.cpp
index b913bc7..2625ac7 100644
--- a/audio/2.0/default/DevicesFactory.cpp
+++ b/audio/2.0/default/DevicesFactory.cpp
@@ -33,31 +33,35 @@
// static
const char* DevicesFactory::deviceToString(IDevicesFactory::Device device) {
switch (device) {
- case IDevicesFactory::Device::PRIMARY: return AUDIO_HARDWARE_MODULE_ID_PRIMARY;
- case IDevicesFactory::Device::A2DP: return AUDIO_HARDWARE_MODULE_ID_A2DP;
- case IDevicesFactory::Device::USB: return AUDIO_HARDWARE_MODULE_ID_USB;
- case IDevicesFactory::Device::R_SUBMIX: return AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX;
- case IDevicesFactory::Device::STUB: return AUDIO_HARDWARE_MODULE_ID_STUB;
+ case IDevicesFactory::Device::PRIMARY:
+ return AUDIO_HARDWARE_MODULE_ID_PRIMARY;
+ case IDevicesFactory::Device::A2DP:
+ return AUDIO_HARDWARE_MODULE_ID_A2DP;
+ case IDevicesFactory::Device::USB:
+ return AUDIO_HARDWARE_MODULE_ID_USB;
+ case IDevicesFactory::Device::R_SUBMIX:
+ return AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX;
+ case IDevicesFactory::Device::STUB:
+ return AUDIO_HARDWARE_MODULE_ID_STUB;
}
return nullptr;
}
// static
-int DevicesFactory::loadAudioInterface(const char *if_name, audio_hw_device_t **dev)
-{
- const hw_module_t *mod;
+int DevicesFactory::loadAudioInterface(const char* if_name, audio_hw_device_t** dev) {
+ const hw_module_t* mod;
int rc;
rc = hw_get_module_by_class(AUDIO_HARDWARE_MODULE_ID, if_name, &mod);
if (rc) {
- ALOGE("%s couldn't load audio hw module %s.%s (%s)", __func__,
- AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc));
+ ALOGE("%s couldn't load audio hw module %s.%s (%s)", __func__, AUDIO_HARDWARE_MODULE_ID,
+ if_name, strerror(-rc));
goto out;
}
rc = audio_hw_device_open(mod, dev);
if (rc) {
- ALOGE("%s couldn't open audio hw device in %s.%s (%s)", __func__,
- AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc));
+ ALOGE("%s couldn't open audio hw device in %s.%s (%s)", __func__, AUDIO_HARDWARE_MODULE_ID,
+ if_name, strerror(-rc));
goto out;
}
if ((*dev)->common.version < AUDIO_DEVICE_API_VERSION_MIN) {
@@ -74,8 +78,8 @@
}
// Methods from ::android::hardware::audio::V2_0::IDevicesFactory follow.
-Return<void> DevicesFactory::openDevice(IDevicesFactory::Device device, openDevice_cb _hidl_cb) {
- audio_hw_device_t *halDevice;
+Return<void> DevicesFactory::openDevice(IDevicesFactory::Device device, openDevice_cb _hidl_cb) {
+ audio_hw_device_t* halDevice;
Result retval(Result::INVALID_ARGUMENTS);
sp<IDevice> result;
const char* moduleName = deviceToString(device);
@@ -85,8 +89,7 @@
if (device == IDevicesFactory::Device::PRIMARY) {
result = new PrimaryDevice(halDevice);
} else {
- result = new ::android::hardware::audio::V2_0::implementation::
- Device(halDevice);
+ result = new ::android::hardware::audio::V2_0::implementation::Device(halDevice);
}
retval = Result::OK;
} else if (halStatus == -EINVAL) {
diff --git a/audio/2.0/default/DevicesFactory.h b/audio/2.0/default/DevicesFactory.h
index b046f9f..39437c1 100644
--- a/audio/2.0/default/DevicesFactory.h
+++ b/audio/2.0/default/DevicesFactory.h
@@ -40,12 +40,11 @@
struct DevicesFactory : public IDevicesFactory {
// Methods from ::android::hardware::audio::V2_0::IDevicesFactory follow.
- Return<void> openDevice(IDevicesFactory::Device device, openDevice_cb _hidl_cb) override;
+ Return<void> openDevice(IDevicesFactory::Device device, openDevice_cb _hidl_cb) override;
- private:
+ private:
static const char* deviceToString(IDevicesFactory::Device device);
- static int loadAudioInterface(const char *if_name, audio_hw_device_t **dev);
-
+ static int loadAudioInterface(const char* if_name, audio_hw_device_t** dev);
};
extern "C" IDevicesFactory* HIDL_FETCH_IDevicesFactory(const char* name);
diff --git a/audio/2.0/default/ParametersUtil.cpp b/audio/2.0/default/ParametersUtil.cpp
index c113ac7..75b672d 100644
--- a/audio/2.0/default/ParametersUtil.cpp
+++ b/audio/2.0/default/ParametersUtil.cpp
@@ -72,17 +72,14 @@
void ParametersUtil::getParametersImpl(
const hidl_vec<hidl_string>& keys,
- std::function<void(Result retval,
- const hidl_vec<ParameterValue>& parameters)>
- cb) {
+ std::function<void(Result retval, const hidl_vec<ParameterValue>& parameters)> cb) {
AudioParameter halKeys;
for (size_t i = 0; i < keys.size(); ++i) {
halKeys.addKey(String8(keys[i].c_str()));
}
std::unique_ptr<AudioParameter> halValues = getParams(halKeys);
- Result retval = (keys.size() == 0 || halValues->size() != 0)
- ? Result::OK
- : Result::NOT_SUPPORTED;
+ Result retval =
+ (keys.size() == 0 || halValues->size() != 0) ? Result::OK : Result::NOT_SUPPORTED;
hidl_vec<ParameterValue> result;
result.resize(halValues->size());
String8 halKey, halValue;
@@ -99,8 +96,7 @@
cb(retval, result);
}
-std::unique_ptr<AudioParameter> ParametersUtil::getParams(
- const AudioParameter& keys) {
+std::unique_ptr<AudioParameter> ParametersUtil::getParams(const AudioParameter& keys) {
String8 paramsAndValues;
char* halValues = halGetParameters(keys.keysToString().string());
if (halValues != NULL) {
@@ -114,8 +110,7 @@
Result ParametersUtil::setParam(const char* name, bool value) {
AudioParameter param;
- param.add(String8(name), String8(value ? AudioParameter::valueOn
- : AudioParameter::valueOff));
+ param.add(String8(name), String8(value ? AudioParameter::valueOn : AudioParameter::valueOff));
return setParams(param);
}
@@ -131,12 +126,10 @@
return setParams(param);
}
-Result ParametersUtil::setParametersImpl(
- const hidl_vec<ParameterValue>& parameters) {
+Result ParametersUtil::setParametersImpl(const hidl_vec<ParameterValue>& parameters) {
AudioParameter params;
for (size_t i = 0; i < parameters.size(); ++i) {
- params.add(String8(parameters[i].key.c_str()),
- String8(parameters[i].value.c_str()));
+ params.add(String8(parameters[i].key.c_str()), String8(parameters[i].value.c_str()));
}
return setParams(params);
}
@@ -144,18 +137,24 @@
Result ParametersUtil::setParams(const AudioParameter& param) {
int halStatus = halSetParameters(param.toString().string());
switch (halStatus) {
- case OK: return Result::OK;
- case -EINVAL: return Result::INVALID_ARGUMENTS;
- case -ENODATA: return Result::INVALID_STATE;
- case -ENODEV: return Result::NOT_INITIALIZED;
+ case OK:
+ return Result::OK;
+ case -EINVAL:
+ return Result::INVALID_ARGUMENTS;
+ case -ENODATA:
+ return Result::INVALID_STATE;
+ case -ENODEV:
+ return Result::NOT_INITIALIZED;
// The rest of the API (*::analyseStatus) returns NOT_SUPPORTED
// when the legacy API returns -ENOSYS
// However the legacy API explicitly state that for get_paramers,
// -ENOSYS should be returned if
// "the implementation does not accept a parameter change while the
// output is active but the parameter is acceptable otherwise"
- case -ENOSYS: return Result::INVALID_STATE;
- default: return Result::INVALID_ARGUMENTS;
+ case -ENOSYS:
+ return Result::INVALID_STATE;
+ default:
+ return Result::INVALID_ARGUMENTS;
}
}
diff --git a/audio/2.0/default/ParametersUtil.h b/audio/2.0/default/ParametersUtil.h
index 49036dc..671c9e3 100644
--- a/audio/2.0/default/ParametersUtil.h
+++ b/audio/2.0/default/ParametersUtil.h
@@ -36,13 +36,13 @@
using ::android::hardware::hidl_vec;
class ParametersUtil {
- public:
+ public:
Result getParam(const char* name, bool* value);
Result getParam(const char* name, int* value);
Result getParam(const char* name, String8* value);
void getParametersImpl(
- const hidl_vec<hidl_string>& keys,
- std::function<void(Result retval, const hidl_vec<ParameterValue>& parameters)> cb);
+ const hidl_vec<hidl_string>& keys,
+ std::function<void(Result retval, const hidl_vec<ParameterValue>& parameters)> cb);
std::unique_ptr<AudioParameter> getParams(const AudioParameter& keys);
Result setParam(const char* name, bool value);
Result setParam(const char* name, int value);
@@ -50,7 +50,7 @@
Result setParametersImpl(const hidl_vec<ParameterValue>& parameters);
Result setParams(const AudioParameter& param);
- protected:
+ protected:
virtual ~ParametersUtil() {}
virtual char* halGetParameters(const char* keys) = 0;
diff --git a/audio/2.0/default/PrimaryDevice.cpp b/audio/2.0/default/PrimaryDevice.cpp
index a4a8206..2c02a71 100644
--- a/audio/2.0/default/PrimaryDevice.cpp
+++ b/audio/2.0/default/PrimaryDevice.cpp
@@ -25,9 +25,7 @@
namespace V2_0 {
namespace implementation {
-PrimaryDevice::PrimaryDevice(audio_hw_device_t* device)
- : mDevice(new Device(device)) {
-}
+PrimaryDevice::PrimaryDevice(audio_hw_device_t* device) : mDevice(new Device(device)) {}
PrimaryDevice::~PrimaryDevice() {}
@@ -65,28 +63,25 @@
return mDevice->getInputBufferSize(config, _hidl_cb);
}
-Return<void> PrimaryDevice::openOutputStream(int32_t ioHandle,
- const DeviceAddress& device,
- const AudioConfig& config,
- AudioOutputFlag flags,
+Return<void> PrimaryDevice::openOutputStream(int32_t ioHandle, const DeviceAddress& device,
+ const AudioConfig& config, AudioOutputFlag flags,
openOutputStream_cb _hidl_cb) {
return mDevice->openOutputStream(ioHandle, device, config, flags, _hidl_cb);
}
-Return<void> PrimaryDevice::openInputStream(
- int32_t ioHandle, const DeviceAddress& device, const AudioConfig& config,
- AudioInputFlag flags, AudioSource source, openInputStream_cb _hidl_cb) {
- return mDevice->openInputStream(ioHandle, device, config, flags, source,
- _hidl_cb);
+Return<void> PrimaryDevice::openInputStream(int32_t ioHandle, const DeviceAddress& device,
+ const AudioConfig& config, AudioInputFlag flags,
+ AudioSource source, openInputStream_cb _hidl_cb) {
+ return mDevice->openInputStream(ioHandle, device, config, flags, source, _hidl_cb);
}
Return<bool> PrimaryDevice::supportsAudioPatches() {
return mDevice->supportsAudioPatches();
}
-Return<void> PrimaryDevice::createAudioPatch(
- const hidl_vec<AudioPortConfig>& sources,
- const hidl_vec<AudioPortConfig>& sinks, createAudioPatch_cb _hidl_cb) {
+Return<void> PrimaryDevice::createAudioPatch(const hidl_vec<AudioPortConfig>& sources,
+ const hidl_vec<AudioPortConfig>& sinks,
+ createAudioPatch_cb _hidl_cb) {
return mDevice->createAudioPatch(sources, sinks, _hidl_cb);
}
@@ -94,13 +89,11 @@
return mDevice->releaseAudioPatch(patch);
}
-Return<void> PrimaryDevice::getAudioPort(const AudioPort& port,
- getAudioPort_cb _hidl_cb) {
+Return<void> PrimaryDevice::getAudioPort(const AudioPort& port, getAudioPort_cb _hidl_cb) {
return mDevice->getAudioPort(port, _hidl_cb);
}
-Return<Result> PrimaryDevice::setAudioPortConfig(
- const AudioPortConfig& config) {
+Return<Result> PrimaryDevice::setAudioPortConfig(const AudioPortConfig& config) {
return mDevice->setAudioPortConfig(config);
}
@@ -117,8 +110,7 @@
return mDevice->getParameters(keys, _hidl_cb);
}
-Return<Result> PrimaryDevice::setParameters(
- const hidl_vec<ParameterValue>& parameters) {
+Return<Result> PrimaryDevice::setParameters(const hidl_vec<ParameterValue>& parameters) {
return mDevice->setParameters(parameters);
}
@@ -132,9 +124,8 @@
ALOGW("Can not set a voice volume (%f) outside [0,1]", volume);
return Result::INVALID_ARGUMENTS;
}
- return mDevice->analyzeStatus(
- "set_voice_volume",
- mDevice->device()->set_voice_volume(mDevice->device(), volume));
+ return mDevice->analyzeStatus("set_voice_volume",
+ mDevice->device()->set_voice_volume(mDevice->device(), volume));
}
Return<Result> PrimaryDevice::setMode(AudioMode mode) {
@@ -151,12 +142,11 @@
};
return mDevice->analyzeStatus(
- "set_mode", mDevice->device()->set_mode(
- mDevice->device(), static_cast<audio_mode_t>(mode)));
+ "set_mode",
+ mDevice->device()->set_mode(mDevice->device(), static_cast<audio_mode_t>(mode)));
}
-Return<void> PrimaryDevice::getBtScoNrecEnabled(
- getBtScoNrecEnabled_cb _hidl_cb) {
+Return<void> PrimaryDevice::getBtScoNrecEnabled(getBtScoNrecEnabled_cb _hidl_cb) {
bool enabled;
Result retval = mDevice->getParam(AudioParameter::keyBtNrec, &enabled);
_hidl_cb(retval, enabled);
@@ -167,8 +157,7 @@
return mDevice->setParam(AudioParameter::keyBtNrec, enabled);
}
-Return<void> PrimaryDevice::getBtScoWidebandEnabled(
- getBtScoWidebandEnabled_cb _hidl_cb) {
+Return<void> PrimaryDevice::getBtScoWidebandEnabled(getBtScoWidebandEnabled_cb _hidl_cb) {
bool enabled;
Result retval = mDevice->getParam(AUDIO_PARAMETER_KEY_BT_SCO_WB, &enabled);
_hidl_cb(retval, enabled);
@@ -188,8 +177,7 @@
}
Return<Result> PrimaryDevice::setTtyMode(IPrimaryDevice::TtyMode mode) {
- return mDevice->setParam(AUDIO_PARAMETER_KEY_TTY_MODE,
- static_cast<int>(mode));
+ return mDevice->setParam(AUDIO_PARAMETER_KEY_TTY_MODE, static_cast<int>(mode));
}
Return<void> PrimaryDevice::getHacEnabled(getHacEnabled_cb _hidl_cb) {
diff --git a/audio/2.0/default/PrimaryDevice.h b/audio/2.0/default/PrimaryDevice.h
index d95511b..6b5accc 100644
--- a/audio/2.0/default/PrimaryDevice.h
+++ b/audio/2.0/default/PrimaryDevice.h
@@ -54,56 +54,48 @@
explicit PrimaryDevice(audio_hw_device_t* device);
// Methods from ::android::hardware::audio::V2_0::IDevice follow.
- Return<Result> initCheck() override;
- Return<Result> setMasterVolume(float volume) override;
- Return<void> getMasterVolume(getMasterVolume_cb _hidl_cb) override;
- Return<Result> setMicMute(bool mute) override;
- Return<void> getMicMute(getMicMute_cb _hidl_cb) override;
- Return<Result> setMasterMute(bool mute) override;
- Return<void> getMasterMute(getMasterMute_cb _hidl_cb) override;
- Return<void> getInputBufferSize(
- const AudioConfig& config, getInputBufferSize_cb _hidl_cb) override;
- Return<void> openOutputStream(
- int32_t ioHandle,
- const DeviceAddress& device,
- const AudioConfig& config,
- AudioOutputFlag flags,
- openOutputStream_cb _hidl_cb) override;
- Return<void> openInputStream(
- int32_t ioHandle,
- const DeviceAddress& device,
- const AudioConfig& config,
- AudioInputFlag flags,
- AudioSource source,
- openInputStream_cb _hidl_cb) override;
- Return<bool> supportsAudioPatches() override;
- Return<void> createAudioPatch(
- const hidl_vec<AudioPortConfig>& sources,
- const hidl_vec<AudioPortConfig>& sinks,
- createAudioPatch_cb _hidl_cb) override;
- Return<Result> releaseAudioPatch(int32_t patch) override;
- Return<void> getAudioPort(const AudioPort& port, getAudioPort_cb _hidl_cb) override;
- Return<Result> setAudioPortConfig(const AudioPortConfig& config) override;
- Return<AudioHwSync> getHwAvSync() override;
- Return<Result> setScreenState(bool turnedOn) override;
- Return<void> getParameters(
- const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb) override;
- Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters) override;
- Return<void> debugDump(const hidl_handle& fd) override;
+ Return<Result> initCheck() override;
+ Return<Result> setMasterVolume(float volume) override;
+ Return<void> getMasterVolume(getMasterVolume_cb _hidl_cb) override;
+ Return<Result> setMicMute(bool mute) override;
+ Return<void> getMicMute(getMicMute_cb _hidl_cb) override;
+ Return<Result> setMasterMute(bool mute) override;
+ Return<void> getMasterMute(getMasterMute_cb _hidl_cb) override;
+ Return<void> getInputBufferSize(const AudioConfig& config,
+ getInputBufferSize_cb _hidl_cb) override;
+ Return<void> openOutputStream(int32_t ioHandle, const DeviceAddress& device,
+ const AudioConfig& config, AudioOutputFlag flags,
+ openOutputStream_cb _hidl_cb) override;
+ Return<void> openInputStream(int32_t ioHandle, const DeviceAddress& device,
+ const AudioConfig& config, AudioInputFlag flags,
+ AudioSource source, openInputStream_cb _hidl_cb) override;
+ Return<bool> supportsAudioPatches() override;
+ Return<void> createAudioPatch(const hidl_vec<AudioPortConfig>& sources,
+ const hidl_vec<AudioPortConfig>& sinks,
+ createAudioPatch_cb _hidl_cb) override;
+ Return<Result> releaseAudioPatch(int32_t patch) override;
+ Return<void> getAudioPort(const AudioPort& port, getAudioPort_cb _hidl_cb) override;
+ Return<Result> setAudioPortConfig(const AudioPortConfig& config) override;
+ Return<AudioHwSync> getHwAvSync() override;
+ Return<Result> setScreenState(bool turnedOn) override;
+ Return<void> getParameters(const hidl_vec<hidl_string>& keys,
+ getParameters_cb _hidl_cb) override;
+ Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters) override;
+ Return<void> debugDump(const hidl_handle& fd) override;
// Methods from ::android::hardware::audio::V2_0::IPrimaryDevice follow.
- Return<Result> setVoiceVolume(float volume) override;
- Return<Result> setMode(AudioMode mode) override;
- Return<void> getBtScoNrecEnabled(getBtScoNrecEnabled_cb _hidl_cb) override;
- Return<Result> setBtScoNrecEnabled(bool enabled) override;
- Return<void> getBtScoWidebandEnabled(getBtScoWidebandEnabled_cb _hidl_cb) override;
- Return<Result> setBtScoWidebandEnabled(bool enabled) override;
- Return<void> getTtyMode(getTtyMode_cb _hidl_cb) override;
- Return<Result> setTtyMode(IPrimaryDevice::TtyMode mode) override;
- Return<void> getHacEnabled(getHacEnabled_cb _hidl_cb) override;
- Return<Result> setHacEnabled(bool enabled) override;
+ Return<Result> setVoiceVolume(float volume) override;
+ Return<Result> setMode(AudioMode mode) override;
+ Return<void> getBtScoNrecEnabled(getBtScoNrecEnabled_cb _hidl_cb) override;
+ Return<Result> setBtScoNrecEnabled(bool enabled) override;
+ Return<void> getBtScoWidebandEnabled(getBtScoWidebandEnabled_cb _hidl_cb) override;
+ Return<Result> setBtScoWidebandEnabled(bool enabled) override;
+ Return<void> getTtyMode(getTtyMode_cb _hidl_cb) override;
+ Return<Result> setTtyMode(IPrimaryDevice::TtyMode mode) override;
+ Return<void> getHacEnabled(getHacEnabled_cb _hidl_cb) override;
+ Return<Result> setHacEnabled(bool enabled) override;
- private:
+ private:
sp<Device> mDevice;
virtual ~PrimaryDevice();
diff --git a/audio/2.0/default/Stream.cpp b/audio/2.0/default/Stream.cpp
index 2fb47ef..0833123 100644
--- a/audio/2.0/default/Stream.cpp
+++ b/audio/2.0/default/Stream.cpp
@@ -18,10 +18,10 @@
#define LOG_TAG "StreamHAL"
+#include <android/log.h>
#include <hardware/audio.h>
#include <hardware/audio_effect.h>
#include <media/TypeConverter.h>
-#include <android/log.h>
#include <utils/SortedVector.h>
#include <utils/Vector.h>
@@ -35,9 +35,7 @@
namespace V2_0 {
namespace implementation {
-Stream::Stream(audio_stream_t* stream)
- : mStream(stream) {
-}
+Stream::Stream(audio_stream_t* stream) : mStream(stream) {}
Stream::~Stream() {
mStream = nullptr;
@@ -61,12 +59,18 @@
ALOGW("Error from HAL stream in function %s: %s", funcName, strerror(-status));
}
switch (status) {
- case 0: return Result::OK;
- case -EINVAL: return Result::INVALID_ARGUMENTS;
- case -ENODATA: return Result::INVALID_STATE;
- case -ENODEV: return Result::NOT_INITIALIZED;
- case -ENOSYS: return Result::NOT_SUPPORTED;
- default: return Result::INVALID_STATE;
+ case 0:
+ return Result::OK;
+ case -EINVAL:
+ return Result::INVALID_ARGUMENTS;
+ case -ENODATA:
+ return Result::INVALID_STATE;
+ case -ENODEV:
+ return Result::NOT_INITIALIZED;
+ case -ENOSYS:
+ return Result::NOT_SUPPORTED;
+ default:
+ return Result::INVALID_STATE;
}
}
@@ -79,75 +83,75 @@
}
// Methods from ::android::hardware::audio::V2_0::IStream follow.
-Return<uint64_t> Stream::getFrameSize() {
+Return<uint64_t> Stream::getFrameSize() {
// Needs to be implemented by interface subclasses. But can't be declared as pure virtual,
// since interface subclasses implementation do not inherit from this class.
LOG_ALWAYS_FATAL("Stream::getFrameSize is pure abstract");
- return uint64_t {};
+ return uint64_t{};
}
-Return<uint64_t> Stream::getFrameCount() {
+Return<uint64_t> Stream::getFrameCount() {
int halFrameCount;
Result retval = getParam(AudioParameter::keyFrameCount, &halFrameCount);
return retval == Result::OK ? halFrameCount : 0;
}
-Return<uint64_t> Stream::getBufferSize() {
+Return<uint64_t> Stream::getBufferSize() {
return mStream->get_buffer_size(mStream);
}
-Return<uint32_t> Stream::getSampleRate() {
+Return<uint32_t> Stream::getSampleRate() {
return mStream->get_sample_rate(mStream);
}
-Return<void> Stream::getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb) {
+Return<void> Stream::getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb) {
String8 halListValue;
Result result = getParam(AudioParameter::keyStreamSupportedSamplingRates, &halListValue);
hidl_vec<uint32_t> sampleRates;
SortedVector<uint32_t> halSampleRates;
if (result == Result::OK) {
- halSampleRates = samplingRatesFromString(
- halListValue.string(), AudioParameter::valueListSeparator);
+ halSampleRates =
+ samplingRatesFromString(halListValue.string(), AudioParameter::valueListSeparator);
sampleRates.setToExternal(halSampleRates.editArray(), halSampleRates.size());
}
_hidl_cb(sampleRates);
return Void();
}
-Return<Result> Stream::setSampleRate(uint32_t sampleRateHz) {
+Return<Result> Stream::setSampleRate(uint32_t sampleRateHz) {
return setParam(AudioParameter::keySamplingRate, static_cast<int>(sampleRateHz));
}
-Return<AudioChannelMask> Stream::getChannelMask() {
+Return<AudioChannelMask> Stream::getChannelMask() {
return AudioChannelMask(mStream->get_channels(mStream));
}
-Return<void> Stream::getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb) {
+Return<void> Stream::getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb) {
String8 halListValue;
Result result = getParam(AudioParameter::keyStreamSupportedChannels, &halListValue);
hidl_vec<AudioChannelMask> channelMasks;
SortedVector<audio_channel_mask_t> halChannelMasks;
if (result == Result::OK) {
- halChannelMasks = channelMasksFromString(
- halListValue.string(), AudioParameter::valueListSeparator);
+ halChannelMasks =
+ channelMasksFromString(halListValue.string(), AudioParameter::valueListSeparator);
channelMasks.resize(halChannelMasks.size());
for (size_t i = 0; i < halChannelMasks.size(); ++i) {
channelMasks[i] = AudioChannelMask(halChannelMasks[i]);
}
}
- _hidl_cb(channelMasks);
+ _hidl_cb(channelMasks);
return Void();
}
-Return<Result> Stream::setChannelMask(AudioChannelMask mask) {
+Return<Result> Stream::setChannelMask(AudioChannelMask mask) {
return setParam(AudioParameter::keyChannels, static_cast<int>(mask));
}
-Return<AudioFormat> Stream::getFormat() {
+Return<AudioFormat> Stream::getFormat() {
return AudioFormat(mStream->get_format(mStream));
}
-Return<void> Stream::getSupportedFormats(getSupportedFormats_cb _hidl_cb) {
+Return<void> Stream::getSupportedFormats(getSupportedFormats_cb _hidl_cb) {
String8 halListValue;
Result result = getParam(AudioParameter::keyStreamSupportedFormats, &halListValue);
hidl_vec<AudioFormat> formats;
@@ -159,15 +163,15 @@
formats[i] = AudioFormat(halFormats[i]);
}
}
- _hidl_cb(formats);
+ _hidl_cb(formats);
return Void();
}
-Return<Result> Stream::setFormat(AudioFormat format) {
+Return<Result> Stream::setFormat(AudioFormat format) {
return setParam(AudioParameter::keyFormat, static_cast<int>(format));
}
-Return<void> Stream::getAudioProperties(getAudioProperties_cb _hidl_cb) {
+Return<void> Stream::getAudioProperties(getAudioProperties_cb _hidl_cb) {
uint32_t halSampleRate = mStream->get_sample_rate(mStream);
audio_channel_mask_t halMask = mStream->get_channels(mStream);
audio_format_t halFormat = mStream->get_format(mStream);
@@ -175,7 +179,7 @@
return Void();
}
-Return<Result> Stream::addEffect(uint64_t effectId) {
+Return<Result> Stream::addEffect(uint64_t effectId) {
effect_handle_t halEffect = EffectMap::getInstance().get(effectId);
if (halEffect != NULL) {
return analyzeStatus("add_audio_effect", mStream->add_audio_effect(mStream, halEffect));
@@ -185,93 +189,91 @@
}
}
-Return<Result> Stream::removeEffect(uint64_t effectId) {
+Return<Result> Stream::removeEffect(uint64_t effectId) {
effect_handle_t halEffect = EffectMap::getInstance().get(effectId);
if (halEffect != NULL) {
- return analyzeStatus(
- "remove_audio_effect", mStream->remove_audio_effect(mStream, halEffect));
+ return analyzeStatus("remove_audio_effect",
+ mStream->remove_audio_effect(mStream, halEffect));
} else {
ALOGW("Invalid effect ID passed from client: %" PRIu64, effectId);
return Result::INVALID_ARGUMENTS;
}
}
-Return<Result> Stream::standby() {
+Return<Result> Stream::standby() {
return analyzeStatus("standby", mStream->standby(mStream));
}
-Return<AudioDevice> Stream::getDevice() {
+Return<AudioDevice> Stream::getDevice() {
int device;
Result retval = getParam(AudioParameter::keyRouting, &device);
return retval == Result::OK ? static_cast<AudioDevice>(device) : AudioDevice::NONE;
}
-Return<Result> Stream::setDevice(const DeviceAddress& address) {
- char* halDeviceAddress =
- audio_device_address_to_parameter(
- static_cast<audio_devices_t>(address.device),
- deviceAddressToHal(address).c_str());
+Return<Result> Stream::setDevice(const DeviceAddress& address) {
+ char* halDeviceAddress = audio_device_address_to_parameter(
+ static_cast<audio_devices_t>(address.device), deviceAddressToHal(address).c_str());
AudioParameter params((String8(halDeviceAddress)));
free(halDeviceAddress);
- params.addInt(
- String8(AudioParameter::keyRouting), static_cast<audio_devices_t>(address.device));
+ params.addInt(String8(AudioParameter::keyRouting),
+ static_cast<audio_devices_t>(address.device));
return setParams(params);
}
-Return<Result> Stream::setConnectedState(const DeviceAddress& address, bool connected) {
+Return<Result> Stream::setConnectedState(const DeviceAddress& address, bool connected) {
return setParam(
- connected ? AudioParameter::keyStreamConnect : AudioParameter::keyStreamDisconnect,
- deviceAddressToHal(address).c_str());
+ connected ? AudioParameter::keyStreamConnect : AudioParameter::keyStreamDisconnect,
+ deviceAddressToHal(address).c_str());
}
-Return<Result> Stream::setHwAvSync(uint32_t hwAvSync) {
+Return<Result> Stream::setHwAvSync(uint32_t hwAvSync) {
return setParam(AudioParameter::keyStreamHwAvSync, static_cast<int>(hwAvSync));
}
-Return<void> Stream::getParameters(const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb) {
+Return<void> Stream::getParameters(const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb) {
getParametersImpl(keys, _hidl_cb);
return Void();
}
-Return<Result> Stream::setParameters(const hidl_vec<ParameterValue>& parameters) {
+Return<Result> Stream::setParameters(const hidl_vec<ParameterValue>& parameters) {
return setParametersImpl(parameters);
}
-Return<void> Stream::debugDump(const hidl_handle& fd) {
+Return<void> Stream::debugDump(const hidl_handle& fd) {
if (fd.getNativeHandle() != nullptr && fd->numFds == 1) {
analyzeStatus("dump", mStream->dump(mStream, fd->data[0]));
}
return Void();
}
-Return<Result> Stream::start() {
+Return<Result> Stream::start() {
return Result::NOT_SUPPORTED;
}
-Return<Result> Stream::stop() {
+Return<Result> Stream::stop() {
return Result::NOT_SUPPORTED;
}
-Return<void> Stream::createMmapBuffer(int32_t minSizeFrames __unused,
- createMmapBuffer_cb _hidl_cb) {
+Return<void> Stream::createMmapBuffer(int32_t minSizeFrames __unused,
+ createMmapBuffer_cb _hidl_cb) {
Result retval(Result::NOT_SUPPORTED);
MmapBufferInfo info;
_hidl_cb(retval, info);
return Void();
}
-Return<void> Stream::getMmapPosition(getMmapPosition_cb _hidl_cb) {
+Return<void> Stream::getMmapPosition(getMmapPosition_cb _hidl_cb) {
Result retval(Result::NOT_SUPPORTED);
MmapPosition position;
_hidl_cb(retval, position);
return Void();
}
-Return<Result> Stream::close() {
+Return<Result> Stream::close() {
return Result::NOT_SUPPORTED;
}
-} // namespace implementation
+} // namespace implementation
} // namespace V2_0
} // namespace audio
} // namespace hardware
diff --git a/audio/2.0/default/Stream.h b/audio/2.0/default/Stream.h
index e29af53..17e5c39 100644
--- a/audio/2.0/default/Stream.h
+++ b/audio/2.0/default/Stream.h
@@ -57,35 +57,35 @@
static constexpr uint32_t MAX_BUFFER_SIZE = 2 << 30 /* == 1GiB */;
// Methods from ::android::hardware::audio::V2_0::IStream follow.
- Return<uint64_t> getFrameSize() override;
- Return<uint64_t> getFrameCount() override;
- Return<uint64_t> getBufferSize() override;
- Return<uint32_t> getSampleRate() override;
- Return<void> getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb) override;
- Return<Result> setSampleRate(uint32_t sampleRateHz) override;
- Return<AudioChannelMask> getChannelMask() override;
- Return<void> getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb) override;
- Return<Result> setChannelMask(AudioChannelMask mask) override;
- Return<AudioFormat> getFormat() override;
- Return<void> getSupportedFormats(getSupportedFormats_cb _hidl_cb) override;
- Return<Result> setFormat(AudioFormat format) override;
- Return<void> getAudioProperties(getAudioProperties_cb _hidl_cb) override;
- Return<Result> addEffect(uint64_t effectId) override;
- Return<Result> removeEffect(uint64_t effectId) override;
- Return<Result> standby() override;
- Return<AudioDevice> getDevice() override;
- Return<Result> setDevice(const DeviceAddress& address) override;
- Return<Result> setConnectedState(const DeviceAddress& address, bool connected) override;
- Return<Result> setHwAvSync(uint32_t hwAvSync) override;
- Return<void> getParameters(
- const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb) override;
- Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters) override;
- Return<void> debugDump(const hidl_handle& fd) override;
+ Return<uint64_t> getFrameSize() override;
+ Return<uint64_t> getFrameCount() override;
+ Return<uint64_t> getBufferSize() override;
+ Return<uint32_t> getSampleRate() override;
+ Return<void> getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb) override;
+ Return<Result> setSampleRate(uint32_t sampleRateHz) override;
+ Return<AudioChannelMask> getChannelMask() override;
+ Return<void> getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb) override;
+ Return<Result> setChannelMask(AudioChannelMask mask) override;
+ Return<AudioFormat> getFormat() override;
+ Return<void> getSupportedFormats(getSupportedFormats_cb _hidl_cb) override;
+ Return<Result> setFormat(AudioFormat format) override;
+ Return<void> getAudioProperties(getAudioProperties_cb _hidl_cb) override;
+ Return<Result> addEffect(uint64_t effectId) override;
+ Return<Result> removeEffect(uint64_t effectId) override;
+ Return<Result> standby() override;
+ Return<AudioDevice> getDevice() override;
+ Return<Result> setDevice(const DeviceAddress& address) override;
+ Return<Result> setConnectedState(const DeviceAddress& address, bool connected) override;
+ Return<Result> setHwAvSync(uint32_t hwAvSync) override;
+ Return<void> getParameters(const hidl_vec<hidl_string>& keys,
+ getParameters_cb _hidl_cb) override;
+ Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters) override;
+ Return<void> debugDump(const hidl_handle& fd) override;
Return<Result> start() override;
Return<Result> stop() override;
Return<void> createMmapBuffer(int32_t minSizeFrames, createMmapBuffer_cb _hidl_cb) override;
Return<void> getMmapPosition(getMmapPosition_cb _hidl_cb) override;
- Return<Result> close() override;
+ Return<Result> close() override;
// Utility methods for extending interfaces.
static Result analyzeStatus(const char* funcName, int status);
@@ -93,7 +93,7 @@
const std::vector<int>& ignoreErrors);
private:
- audio_stream_t *mStream;
+ audio_stream_t* mStream;
virtual ~Stream();
@@ -102,21 +102,20 @@
int halSetParameters(const char* keysAndValues) override;
};
-
template <typename T>
struct StreamMmap : public RefBase {
explicit StreamMmap(T* stream) : mStream(stream) {}
Return<Result> start();
Return<Result> stop();
- Return<void> createMmapBuffer(
- int32_t minSizeFrames, size_t frameSize, IStream::createMmapBuffer_cb _hidl_cb);
+ Return<void> createMmapBuffer(int32_t minSizeFrames, size_t frameSize,
+ IStream::createMmapBuffer_cb _hidl_cb);
Return<void> getMmapPosition(IStream::getMmapPosition_cb _hidl_cb);
- private:
- StreamMmap() {}
+ private:
+ StreamMmap() {}
- T *mStream;
+ T* mStream;
};
template <typename T>
@@ -143,13 +142,12 @@
if (mStream->create_mmap_buffer != NULL) {
struct audio_mmap_buffer_info halInfo;
retval = Stream::analyzeStatus(
- "create_mmap_buffer",
- mStream->create_mmap_buffer(mStream, minSizeFrames, &halInfo));
+ "create_mmap_buffer", mStream->create_mmap_buffer(mStream, minSizeFrames, &halInfo));
if (retval == Result::OK) {
hidlHandle = native_handle_create(1, 0);
hidlHandle->data[0] = halInfo.shared_memory_fd;
- info.sharedMemory = hidl_memory("audio_buffer", hidlHandle,
- frameSize *halInfo.buffer_size_frames);
+ info.sharedMemory =
+ hidl_memory("audio_buffer", hidlHandle, frameSize * halInfo.buffer_size_frames);
info.bufferSizeFrames = halInfo.buffer_size_frames;
info.burstSizeFrames = halInfo.burst_size_frames;
}
@@ -168,9 +166,8 @@
if (mStream->get_mmap_position != NULL) {
struct audio_mmap_position halPosition;
- retval = Stream::analyzeStatus(
- "get_mmap_position",
- mStream->get_mmap_position(mStream, &halPosition));
+ retval = Stream::analyzeStatus("get_mmap_position",
+ mStream->get_mmap_position(mStream, &halPosition));
if (retval == Result::OK) {
position.timeNanoseconds = halPosition.time_nanoseconds;
position.positionFrames = halPosition.position_frames;
diff --git a/audio/2.0/default/StreamIn.cpp b/audio/2.0/default/StreamIn.cpp
index 61d5d8e..7c87202 100644
--- a/audio/2.0/default/StreamIn.cpp
+++ b/audio/2.0/default/StreamIn.cpp
@@ -41,9 +41,8 @@
class ReadThread : public Thread {
public:
// ReadThread's lifespan never exceeds StreamIn's lifespan.
- ReadThread(std::atomic<bool>* stop, audio_stream_in_t* stream,
- StreamIn::CommandMQ* commandMQ, StreamIn::DataMQ* dataMQ,
- StreamIn::StatusMQ* statusMQ, EventFlag* efGroup)
+ ReadThread(std::atomic<bool>* stop, audio_stream_in_t* stream, StreamIn::CommandMQ* commandMQ,
+ StreamIn::DataMQ* dataMQ, StreamIn::StatusMQ* statusMQ, EventFlag* efGroup)
: Thread(false /*canCallJava*/),
mStop(stop),
mStream(stream),
@@ -99,8 +98,7 @@
void ReadThread::doGetCapturePosition() {
mStatus.retval = StreamIn::getCapturePositionImpl(
- mStream, &mStatus.reply.capturePosition.frames,
- &mStatus.reply.capturePosition.time);
+ mStream, &mStatus.reply.capturePosition.frames, &mStatus.reply.capturePosition.time);
}
bool ReadThread::threadLoop() {
@@ -109,10 +107,8 @@
// as the Thread uses mutexes, and this can lead to priority inversion.
while (!std::atomic_load_explicit(mStop, std::memory_order_acquire)) {
uint32_t efState = 0;
- mEfGroup->wait(static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL),
- &efState);
- if (!(efState &
- static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL))) {
+ mEfGroup->wait(static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL), &efState);
+ if (!(efState & static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL))) {
continue; // Nothing to do.
}
if (!mCommandMQ->read(&mParameters)) {
@@ -127,8 +123,7 @@
doGetCapturePosition();
break;
default:
- ALOGE("Unknown read thread command code %d",
- mParameters.command);
+ ALOGE("Unknown read thread command code %d", mParameters.command);
mStatus.retval = Result::NOT_SUPPORTED;
break;
}
@@ -162,8 +157,7 @@
}
if (mEfGroup) {
status_t status = EventFlag::deleteEventFlag(&mEfGroup);
- ALOGE_IF(status, "read MQ event flag deletion error: %s",
- strerror(-status));
+ ALOGE_IF(status, "read MQ event flag deletion error: %s", strerror(-status));
}
mDevice->closeInputStream(mStream);
mStream = nullptr;
@@ -186,8 +180,7 @@
return mStreamCommon->getSampleRate();
}
-Return<void> StreamIn::getSupportedSampleRates(
- getSupportedSampleRates_cb _hidl_cb) {
+Return<void> StreamIn::getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb) {
return mStreamCommon->getSupportedSampleRates(_hidl_cb);
}
@@ -199,8 +192,7 @@
return mStreamCommon->getChannelMask();
}
-Return<void> StreamIn::getSupportedChannelMasks(
- getSupportedChannelMasks_cb _hidl_cb) {
+Return<void> StreamIn::getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb) {
return mStreamCommon->getSupportedChannelMasks(_hidl_cb);
}
@@ -244,8 +236,7 @@
return mStreamCommon->setDevice(address);
}
-Return<Result> StreamIn::setConnectedState(const DeviceAddress& address,
- bool connected) {
+Return<Result> StreamIn::setConnectedState(const DeviceAddress& address, bool connected) {
return mStreamCommon->setConnectedState(address, connected);
}
@@ -253,13 +244,11 @@
return mStreamCommon->setHwAvSync(hwAvSync);
}
-Return<void> StreamIn::getParameters(const hidl_vec<hidl_string>& keys,
- getParameters_cb _hidl_cb) {
+Return<void> StreamIn::getParameters(const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb) {
return mStreamCommon->getParameters(keys, _hidl_cb);
}
-Return<Result> StreamIn::setParameters(
- const hidl_vec<ParameterValue>& parameters) {
+Return<Result> StreamIn::setParameters(const hidl_vec<ParameterValue>& parameters) {
return mStreamCommon->setParameters(parameters);
}
@@ -275,10 +264,9 @@
return mStreamMmap->stop();
}
-Return<void> StreamIn::createMmapBuffer(int32_t minSizeFrames,
- createMmapBuffer_cb _hidl_cb) {
- return mStreamMmap->createMmapBuffer(
- minSizeFrames, audio_stream_in_frame_size(mStream), _hidl_cb);
+Return<void> StreamIn::createMmapBuffer(int32_t minSizeFrames, createMmapBuffer_cb _hidl_cb) {
+ return mStreamMmap->createMmapBuffer(minSizeFrames, audio_stream_in_frame_size(mStream),
+ _hidl_cb);
}
Return<void> StreamIn::getMmapPosition(getMmapPosition_cb _hidl_cb) {
@@ -300,8 +288,7 @@
// Methods from ::android::hardware::audio::V2_0::IStreamIn follow.
Return<void> StreamIn::getAudioSource(getAudioSource_cb _hidl_cb) {
int halSource;
- Result retval =
- mStreamCommon->getParam(AudioParameter::keyInputSource, &halSource);
+ Result retval = mStreamCommon->getParam(AudioParameter::keyInputSource, &halSource);
AudioSource source(AudioSource::DEFAULT);
if (retval == Result::OK) {
source = AudioSource(halSource);
@@ -318,16 +305,15 @@
return Stream::analyzeStatus("set_gain", mStream->set_gain(mStream, gain));
}
-Return<void> StreamIn::prepareForReading(uint32_t frameSize,
- uint32_t framesCount,
+Return<void> StreamIn::prepareForReading(uint32_t frameSize, uint32_t framesCount,
prepareForReading_cb _hidl_cb) {
status_t status;
ThreadInfo threadInfo = {0, 0};
// Wrap the _hidl_cb to return an error
auto sendError = [&threadInfo, &_hidl_cb](Result result) {
- _hidl_cb(result, CommandMQ::Descriptor(), DataMQ::Descriptor(),
- StatusMQ::Descriptor(), threadInfo);
+ _hidl_cb(result, CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(),
+ threadInfo);
};
@@ -341,8 +327,7 @@
// Check frameSize and framesCount
if (frameSize == 0 || framesCount == 0) {
- ALOGE("Null frameSize (%u) or framesCount (%u)", frameSize,
- framesCount);
+ ALOGE("Null frameSize (%u) or framesCount (%u)", frameSize, framesCount);
sendError(Result::INVALID_ARGUMENTS);
return Void();
}
@@ -353,12 +338,10 @@
sendError(Result::INVALID_ARGUMENTS);
return Void();
}
- std::unique_ptr<DataMQ> tempDataMQ(
- new DataMQ(frameSize * framesCount, true /* EventFlag */));
+ std::unique_ptr<DataMQ> tempDataMQ(new DataMQ(frameSize * framesCount, true /* EventFlag */));
std::unique_ptr<StatusMQ> tempStatusMQ(new StatusMQ(1));
- if (!tempCommandMQ->isValid() || !tempDataMQ->isValid() ||
- !tempStatusMQ->isValid()) {
+ if (!tempCommandMQ->isValid() || !tempDataMQ->isValid() || !tempStatusMQ->isValid()) {
ALOGE_IF(!tempCommandMQ->isValid(), "command MQ is invalid");
ALOGE_IF(!tempDataMQ->isValid(), "data MQ is invalid");
ALOGE_IF(!tempStatusMQ->isValid(), "status MQ is invalid");
@@ -366,8 +349,7 @@
return Void();
}
EventFlag* tempRawEfGroup{};
- status = EventFlag::createEventFlag(tempDataMQ->getEventFlagWord(),
- &tempRawEfGroup);
+ status = EventFlag::createEventFlag(tempDataMQ->getEventFlagWord(), &tempRawEfGroup);
std::unique_ptr<EventFlag, void (*)(EventFlag*)> tempElfGroup(
tempRawEfGroup, [](auto* ef) { EventFlag::deleteEventFlag(&ef); });
if (status != OK || !tempElfGroup) {
@@ -377,9 +359,9 @@
}
// Create and launch the thread.
- auto tempReadThread = std::make_unique<ReadThread>(
- &mStopReadThread, mStream, tempCommandMQ.get(), tempDataMQ.get(),
- tempStatusMQ.get(), tempElfGroup.get());
+ auto tempReadThread =
+ std::make_unique<ReadThread>(&mStopReadThread, mStream, tempCommandMQ.get(),
+ tempDataMQ.get(), tempStatusMQ.get(), tempElfGroup.get());
if (!tempReadThread->init()) {
ALOGW("failed to start reader thread: %s", strerror(-status));
sendError(Result::INVALID_ARGUMENTS);
@@ -399,8 +381,8 @@
mEfGroup = tempElfGroup.release();
threadInfo.pid = getpid();
threadInfo.tid = mReadThread->getTid();
- _hidl_cb(Result::OK, *mCommandMQ->getDesc(), *mDataMQ->getDesc(),
- *mStatusMQ->getDesc(), threadInfo);
+ _hidl_cb(Result::OK, *mCommandMQ->getDesc(), *mDataMQ->getDesc(), *mStatusMQ->getDesc(),
+ threadInfo);
return Void();
}
@@ -409,8 +391,8 @@
}
// static
-Result StreamIn::getCapturePositionImpl(audio_stream_in_t* stream,
- uint64_t* frames, uint64_t* time) {
+Result StreamIn::getCapturePositionImpl(audio_stream_in_t* stream, uint64_t* frames,
+ uint64_t* time) {
// HAL may have a stub function, always returning ENOSYS, don't
// spam the log in this case.
static const std::vector<int> ignoredErrors{ENOSYS};
diff --git a/audio/2.0/default/StreamIn.h b/audio/2.0/default/StreamIn.h
index 950d68f..dfb806a 100644
--- a/audio/2.0/default/StreamIn.h
+++ b/audio/2.0/default/StreamIn.h
@@ -21,9 +21,9 @@
#include <memory>
#include <android/hardware/audio/2.0/IStreamIn.h>
-#include <hidl/MQDescriptor.h>
#include <fmq/EventFlag.h>
#include <fmq/MessageQueue.h>
+#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
#include <utils/Thread.h>
@@ -59,51 +59,51 @@
StreamIn(const sp<Device>& device, audio_stream_in_t* stream);
// Methods from ::android::hardware::audio::V2_0::IStream follow.
- Return<uint64_t> getFrameSize() override;
- Return<uint64_t> getFrameCount() override;
- Return<uint64_t> getBufferSize() override;
- Return<uint32_t> getSampleRate() override;
- Return<void> getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb) override;
- Return<Result> setSampleRate(uint32_t sampleRateHz) override;
- Return<AudioChannelMask> getChannelMask() override;
- Return<void> getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb) override;
- Return<Result> setChannelMask(AudioChannelMask mask) override;
- Return<AudioFormat> getFormat() override;
- Return<void> getSupportedFormats(getSupportedFormats_cb _hidl_cb) override;
- Return<Result> setFormat(AudioFormat format) override;
- Return<void> getAudioProperties(getAudioProperties_cb _hidl_cb) override;
- Return<Result> addEffect(uint64_t effectId) override;
- Return<Result> removeEffect(uint64_t effectId) override;
- Return<Result> standby() override;
- Return<AudioDevice> getDevice() override;
- Return<Result> setDevice(const DeviceAddress& address) override;
- Return<Result> setConnectedState(const DeviceAddress& address, bool connected) override;
- Return<Result> setHwAvSync(uint32_t hwAvSync) override;
- Return<void> getParameters(
- const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb) override;
- Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters) override;
- Return<void> debugDump(const hidl_handle& fd) override;
- Return<Result> close() override;
+ Return<uint64_t> getFrameSize() override;
+ Return<uint64_t> getFrameCount() override;
+ Return<uint64_t> getBufferSize() override;
+ Return<uint32_t> getSampleRate() override;
+ Return<void> getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb) override;
+ Return<Result> setSampleRate(uint32_t sampleRateHz) override;
+ Return<AudioChannelMask> getChannelMask() override;
+ Return<void> getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb) override;
+ Return<Result> setChannelMask(AudioChannelMask mask) override;
+ Return<AudioFormat> getFormat() override;
+ Return<void> getSupportedFormats(getSupportedFormats_cb _hidl_cb) override;
+ Return<Result> setFormat(AudioFormat format) override;
+ Return<void> getAudioProperties(getAudioProperties_cb _hidl_cb) override;
+ Return<Result> addEffect(uint64_t effectId) override;
+ Return<Result> removeEffect(uint64_t effectId) override;
+ Return<Result> standby() override;
+ Return<AudioDevice> getDevice() override;
+ Return<Result> setDevice(const DeviceAddress& address) override;
+ Return<Result> setConnectedState(const DeviceAddress& address, bool connected) override;
+ Return<Result> setHwAvSync(uint32_t hwAvSync) override;
+ Return<void> getParameters(const hidl_vec<hidl_string>& keys,
+ getParameters_cb _hidl_cb) override;
+ Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters) override;
+ Return<void> debugDump(const hidl_handle& fd) override;
+ Return<Result> close() override;
// Methods from ::android::hardware::audio::V2_0::IStreamIn follow.
- Return<void> getAudioSource(getAudioSource_cb _hidl_cb) override;
- Return<Result> setGain(float gain) override;
- Return<void> prepareForReading(
- uint32_t frameSize, uint32_t framesCount, prepareForReading_cb _hidl_cb) override;
- Return<uint32_t> getInputFramesLost() override;
- Return<void> getCapturePosition(getCapturePosition_cb _hidl_cb) override;
+ Return<void> getAudioSource(getAudioSource_cb _hidl_cb) override;
+ Return<Result> setGain(float gain) override;
+ Return<void> prepareForReading(uint32_t frameSize, uint32_t framesCount,
+ prepareForReading_cb _hidl_cb) override;
+ Return<uint32_t> getInputFramesLost() override;
+ Return<void> getCapturePosition(getCapturePosition_cb _hidl_cb) override;
Return<Result> start() override;
Return<Result> stop() override;
Return<void> createMmapBuffer(int32_t minSizeFrames, createMmapBuffer_cb _hidl_cb) override;
Return<void> getMmapPosition(getMmapPosition_cb _hidl_cb) override;
- static Result getCapturePositionImpl(
- audio_stream_in_t *stream, uint64_t *frames, uint64_t *time);
+ static Result getCapturePositionImpl(audio_stream_in_t* stream, uint64_t* frames,
+ uint64_t* time);
- private:
+ private:
bool mIsClosed;
const sp<Device> mDevice;
- audio_stream_in_t *mStream;
+ audio_stream_in_t* mStream;
const sp<Stream> mStreamCommon;
const sp<StreamMmap<audio_stream_in_t>> mStreamMmap;
std::unique_ptr<CommandMQ> mCommandMQ;
diff --git a/audio/2.0/default/StreamOut.cpp b/audio/2.0/default/StreamOut.cpp
index 49a6b12..d811a40 100644
--- a/audio/2.0/default/StreamOut.cpp
+++ b/audio/2.0/default/StreamOut.cpp
@@ -89,9 +89,9 @@
}
void WriteThread::doGetPresentationPosition() {
- mStatus.retval = StreamOut::getPresentationPositionImpl(
- mStream, &mStatus.reply.presentationPosition.frames,
- &mStatus.reply.presentationPosition.timeStamp);
+ mStatus.retval =
+ StreamOut::getPresentationPositionImpl(mStream, &mStatus.reply.presentationPosition.frames,
+ &mStatus.reply.presentationPosition.timeStamp);
}
void WriteThread::doGetLatency() {
@@ -105,10 +105,8 @@
// as the Thread uses mutexes, and this can lead to priority inversion.
while (!std::atomic_load_explicit(mStop, std::memory_order_acquire)) {
uint32_t efState = 0;
- mEfGroup->wait(static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY),
- &efState);
- if (!(efState &
- static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY))) {
+ mEfGroup->wait(static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY), &efState);
+ if (!(efState & static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY))) {
continue; // Nothing to do.
}
if (!mCommandMQ->read(&mStatus.replyTo)) {
@@ -159,8 +157,7 @@
}
if (mEfGroup) {
status_t status = EventFlag::deleteEventFlag(&mEfGroup);
- ALOGE_IF(status, "write MQ event flag deletion error: %s",
- strerror(-status));
+ ALOGE_IF(status, "write MQ event flag deletion error: %s", strerror(-status));
}
mCallback.clear();
mDevice->closeOutputStream(mStream);
@@ -187,8 +184,7 @@
return mStreamCommon->getSampleRate();
}
-Return<void> StreamOut::getSupportedSampleRates(
- getSupportedSampleRates_cb _hidl_cb) {
+Return<void> StreamOut::getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb) {
return mStreamCommon->getSupportedSampleRates(_hidl_cb);
}
@@ -200,8 +196,7 @@
return mStreamCommon->getChannelMask();
}
-Return<void> StreamOut::getSupportedChannelMasks(
- getSupportedChannelMasks_cb _hidl_cb) {
+Return<void> StreamOut::getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb) {
return mStreamCommon->getSupportedChannelMasks(_hidl_cb);
}
@@ -245,8 +240,7 @@
return mStreamCommon->setDevice(address);
}
-Return<Result> StreamOut::setConnectedState(const DeviceAddress& address,
- bool connected) {
+Return<Result> StreamOut::setConnectedState(const DeviceAddress& address, bool connected) {
return mStreamCommon->setConnectedState(address, connected);
}
@@ -259,8 +253,7 @@
return mStreamCommon->getParameters(keys, _hidl_cb);
}
-Return<Result> StreamOut::setParameters(
- const hidl_vec<ParameterValue>& parameters) {
+Return<Result> StreamOut::setParameters(const hidl_vec<ParameterValue>& parameters) {
return mStreamCommon->setParameters(parameters);
}
@@ -290,24 +283,21 @@
return Result::NOT_SUPPORTED;
}
if (!isGainNormalized(left)) {
- ALOGW("Can not set a stream output volume {%f, %f} outside [0,1]", left,
- right);
+ ALOGW("Can not set a stream output volume {%f, %f} outside [0,1]", left, right);
return Result::INVALID_ARGUMENTS;
}
- return Stream::analyzeStatus("set_volume",
- mStream->set_volume(mStream, left, right));
+ return Stream::analyzeStatus("set_volume", mStream->set_volume(mStream, left, right));
}
-Return<void> StreamOut::prepareForWriting(uint32_t frameSize,
- uint32_t framesCount,
+Return<void> StreamOut::prepareForWriting(uint32_t frameSize, uint32_t framesCount,
prepareForWriting_cb _hidl_cb) {
status_t status;
ThreadInfo threadInfo = {0, 0};
// Wrap the _hidl_cb to return an error
auto sendError = [&threadInfo, &_hidl_cb](Result result) {
- _hidl_cb(result, CommandMQ::Descriptor(), DataMQ::Descriptor(),
- StatusMQ::Descriptor(), threadInfo);
+ _hidl_cb(result, CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(),
+ threadInfo);
};
@@ -321,8 +311,7 @@
// Check frameSize and framesCount
if (frameSize == 0 || framesCount == 0) {
- ALOGE("Null frameSize (%u) or framesCount (%u)", frameSize,
- framesCount);
+ ALOGE("Null frameSize (%u) or framesCount (%u)", frameSize, framesCount);
sendError(Result::INVALID_ARGUMENTS);
return Void();
}
@@ -332,12 +321,10 @@
sendError(Result::INVALID_ARGUMENTS);
return Void();
}
- std::unique_ptr<DataMQ> tempDataMQ(
- new DataMQ(frameSize * framesCount, true /* EventFlag */));
+ std::unique_ptr<DataMQ> tempDataMQ(new DataMQ(frameSize * framesCount, true /* EventFlag */));
std::unique_ptr<StatusMQ> tempStatusMQ(new StatusMQ(1));
- if (!tempCommandMQ->isValid() || !tempDataMQ->isValid() ||
- !tempStatusMQ->isValid()) {
+ if (!tempCommandMQ->isValid() || !tempDataMQ->isValid() || !tempStatusMQ->isValid()) {
ALOGE_IF(!tempCommandMQ->isValid(), "command MQ is invalid");
ALOGE_IF(!tempDataMQ->isValid(), "data MQ is invalid");
ALOGE_IF(!tempStatusMQ->isValid(), "status MQ is invalid");
@@ -345,8 +332,7 @@
return Void();
}
EventFlag* tempRawEfGroup{};
- status = EventFlag::createEventFlag(tempDataMQ->getEventFlagWord(),
- &tempRawEfGroup);
+ status = EventFlag::createEventFlag(tempDataMQ->getEventFlagWord(), &tempRawEfGroup);
std::unique_ptr<EventFlag, void (*)(EventFlag*)> tempElfGroup(
tempRawEfGroup, [](auto* ef) { EventFlag::deleteEventFlag(&ef); });
if (status != OK || !tempElfGroup) {
@@ -356,9 +342,9 @@
}
// Create and launch the thread.
- auto tempWriteThread = std::make_unique<WriteThread>(
- &mStopWriteThread, mStream, tempCommandMQ.get(), tempDataMQ.get(),
- tempStatusMQ.get(), tempElfGroup.get());
+ auto tempWriteThread =
+ std::make_unique<WriteThread>(&mStopWriteThread, mStream, tempCommandMQ.get(),
+ tempDataMQ.get(), tempStatusMQ.get(), tempElfGroup.get());
if (!tempWriteThread->init()) {
ALOGW("failed to start writer thread: %s", strerror(-status));
sendError(Result::INVALID_ARGUMENTS);
@@ -378,28 +364,25 @@
mEfGroup = tempElfGroup.release();
threadInfo.pid = getpid();
threadInfo.tid = mWriteThread->getTid();
- _hidl_cb(Result::OK, *mCommandMQ->getDesc(), *mDataMQ->getDesc(),
- *mStatusMQ->getDesc(), threadInfo);
+ _hidl_cb(Result::OK, *mCommandMQ->getDesc(), *mDataMQ->getDesc(), *mStatusMQ->getDesc(),
+ threadInfo);
return Void();
}
Return<void> StreamOut::getRenderPosition(getRenderPosition_cb _hidl_cb) {
uint32_t halDspFrames;
- Result retval = Stream::analyzeStatus(
- "get_render_position",
- mStream->get_render_position(mStream, &halDspFrames));
+ Result retval = Stream::analyzeStatus("get_render_position",
+ mStream->get_render_position(mStream, &halDspFrames));
_hidl_cb(retval, halDspFrames);
return Void();
}
-Return<void> StreamOut::getNextWriteTimestamp(
- getNextWriteTimestamp_cb _hidl_cb) {
+Return<void> StreamOut::getNextWriteTimestamp(getNextWriteTimestamp_cb _hidl_cb) {
Result retval(Result::NOT_SUPPORTED);
int64_t timestampUs = 0;
if (mStream->get_next_write_timestamp != NULL) {
- retval = Stream::analyzeStatus(
- "get_next_write_timestamp",
- mStream->get_next_write_timestamp(mStream, ×tampUs));
+ retval = Stream::analyzeStatus("get_next_write_timestamp",
+ mStream->get_next_write_timestamp(mStream, ×tampUs));
}
_hidl_cb(retval, timestampUs);
return Void();
@@ -423,14 +406,13 @@
}
// static
-int StreamOut::asyncCallback(stream_callback_event_t event, void*,
- void* cookie) {
+int StreamOut::asyncCallback(stream_callback_event_t event, void*, void* cookie) {
// It is guaranteed that the callback thread is joined prior
// to exiting from StreamOut's destructor. Must *not* use sp<StreamOut>
// here because it can make this code the last owner of StreamOut,
// and an attempt to run the destructor on the callback thread
// will cause a deadlock in the legacy HAL code.
- StreamOut *self = reinterpret_cast<StreamOut*>(cookie);
+ StreamOut* self = reinterpret_cast<StreamOut*>(cookie);
// It's correct to hold an sp<> to callback because the reference
// in the StreamOut instance can be cleared in the meantime. There is
// no difference on which thread to run IStreamOutCallback's destructor.
@@ -454,22 +436,19 @@
return 0;
}
-Return<void> StreamOut::supportsPauseAndResume(
- supportsPauseAndResume_cb _hidl_cb) {
+Return<void> StreamOut::supportsPauseAndResume(supportsPauseAndResume_cb _hidl_cb) {
_hidl_cb(mStream->pause != NULL, mStream->resume != NULL);
return Void();
}
Return<Result> StreamOut::pause() {
- return mStream->pause != NULL
- ? Stream::analyzeStatus("pause", mStream->pause(mStream))
- : Result::NOT_SUPPORTED;
+ return mStream->pause != NULL ? Stream::analyzeStatus("pause", mStream->pause(mStream))
+ : Result::NOT_SUPPORTED;
}
Return<Result> StreamOut::resume() {
- return mStream->resume != NULL
- ? Stream::analyzeStatus("resume", mStream->resume(mStream))
- : Result::NOT_SUPPORTED;
+ return mStream->resume != NULL ? Stream::analyzeStatus("resume", mStream->resume(mStream))
+ : Result::NOT_SUPPORTED;
}
Return<bool> StreamOut::supportsDrain() {
@@ -479,21 +458,17 @@
Return<Result> StreamOut::drain(AudioDrain type) {
return mStream->drain != NULL
? Stream::analyzeStatus(
- "drain",
- mStream->drain(mStream,
- static_cast<audio_drain_type_t>(type)))
+ "drain", mStream->drain(mStream, static_cast<audio_drain_type_t>(type)))
: Result::NOT_SUPPORTED;
}
Return<Result> StreamOut::flush() {
- return mStream->flush != NULL
- ? Stream::analyzeStatus("flush", mStream->flush(mStream))
- : Result::NOT_SUPPORTED;
+ return mStream->flush != NULL ? Stream::analyzeStatus("flush", mStream->flush(mStream))
+ : Result::NOT_SUPPORTED;
}
// static
-Result StreamOut::getPresentationPositionImpl(audio_stream_out_t* stream,
- uint64_t* frames,
+Result StreamOut::getPresentationPositionImpl(audio_stream_out_t* stream, uint64_t* frames,
TimeSpec* timeStamp) {
// Don't logspam on EINVAL--it's normal for get_presentation_position
// to return it sometimes. EAGAIN may be returned by A2DP audio HAL
@@ -513,8 +488,7 @@
return retval;
}
-Return<void> StreamOut::getPresentationPosition(
- getPresentationPosition_cb _hidl_cb) {
+Return<void> StreamOut::getPresentationPosition(getPresentationPosition_cb _hidl_cb) {
uint64_t frames = 0;
TimeSpec timeStamp = {0, 0};
Result retval = getPresentationPositionImpl(mStream, &frames, &timeStamp);
@@ -530,10 +504,9 @@
return mStreamMmap->stop();
}
-Return<void> StreamOut::createMmapBuffer(int32_t minSizeFrames,
- createMmapBuffer_cb _hidl_cb) {
- return mStreamMmap->createMmapBuffer(
- minSizeFrames, audio_stream_out_frame_size(mStream), _hidl_cb);
+Return<void> StreamOut::createMmapBuffer(int32_t minSizeFrames, createMmapBuffer_cb _hidl_cb) {
+ return mStreamMmap->createMmapBuffer(minSizeFrames, audio_stream_out_frame_size(mStream),
+ _hidl_cb);
}
Return<void> StreamOut::getMmapPosition(getMmapPosition_cb _hidl_cb) {
diff --git a/audio/2.0/default/StreamOut.h b/audio/2.0/default/StreamOut.h
index 99352bc..35960c5 100644
--- a/audio/2.0/default/StreamOut.h
+++ b/audio/2.0/default/StreamOut.h
@@ -21,10 +21,10 @@
#include <memory>
#include <android/hardware/audio/2.0/IStreamOut.h>
-#include <hidl/MQDescriptor.h>
-#include <hidl/Status.h>
#include <fmq/EventFlag.h>
#include <fmq/MessageQueue.h>
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
#include <utils/Thread.h>
#include "Device.h"
@@ -61,60 +61,60 @@
StreamOut(const sp<Device>& device, audio_stream_out_t* stream);
// Methods from ::android::hardware::audio::V2_0::IStream follow.
- Return<uint64_t> getFrameSize() override;
- Return<uint64_t> getFrameCount() override;
- Return<uint64_t> getBufferSize() override;
- Return<uint32_t> getSampleRate() override;
- Return<void> getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb) override;
- Return<Result> setSampleRate(uint32_t sampleRateHz) override;
- Return<AudioChannelMask> getChannelMask() override;
- Return<void> getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb) override;
- Return<Result> setChannelMask(AudioChannelMask mask) override;
- Return<AudioFormat> getFormat() override;
- Return<void> getSupportedFormats(getSupportedFormats_cb _hidl_cb) override;
- Return<Result> setFormat(AudioFormat format) override;
- Return<void> getAudioProperties(getAudioProperties_cb _hidl_cb) override;
- Return<Result> addEffect(uint64_t effectId) override;
- Return<Result> removeEffect(uint64_t effectId) override;
- Return<Result> standby() override;
- Return<AudioDevice> getDevice() override;
- Return<Result> setDevice(const DeviceAddress& address) override;
- Return<Result> setConnectedState(const DeviceAddress& address, bool connected) override;
- Return<Result> setHwAvSync(uint32_t hwAvSync) override;
- Return<void> getParameters(
- const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb) override;
- Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters) override;
- Return<void> debugDump(const hidl_handle& fd) override;
- Return<Result> close() override;
+ Return<uint64_t> getFrameSize() override;
+ Return<uint64_t> getFrameCount() override;
+ Return<uint64_t> getBufferSize() override;
+ Return<uint32_t> getSampleRate() override;
+ Return<void> getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb) override;
+ Return<Result> setSampleRate(uint32_t sampleRateHz) override;
+ Return<AudioChannelMask> getChannelMask() override;
+ Return<void> getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb) override;
+ Return<Result> setChannelMask(AudioChannelMask mask) override;
+ Return<AudioFormat> getFormat() override;
+ Return<void> getSupportedFormats(getSupportedFormats_cb _hidl_cb) override;
+ Return<Result> setFormat(AudioFormat format) override;
+ Return<void> getAudioProperties(getAudioProperties_cb _hidl_cb) override;
+ Return<Result> addEffect(uint64_t effectId) override;
+ Return<Result> removeEffect(uint64_t effectId) override;
+ Return<Result> standby() override;
+ Return<AudioDevice> getDevice() override;
+ Return<Result> setDevice(const DeviceAddress& address) override;
+ Return<Result> setConnectedState(const DeviceAddress& address, bool connected) override;
+ Return<Result> setHwAvSync(uint32_t hwAvSync) override;
+ Return<void> getParameters(const hidl_vec<hidl_string>& keys,
+ getParameters_cb _hidl_cb) override;
+ Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters) override;
+ Return<void> debugDump(const hidl_handle& fd) override;
+ Return<Result> close() override;
// Methods from ::android::hardware::audio::V2_0::IStreamOut follow.
- Return<uint32_t> getLatency() override;
- Return<Result> setVolume(float left, float right) override;
- Return<void> prepareForWriting(
- uint32_t frameSize, uint32_t framesCount, prepareForWriting_cb _hidl_cb) override;
- Return<void> getRenderPosition(getRenderPosition_cb _hidl_cb) override;
- Return<void> getNextWriteTimestamp(getNextWriteTimestamp_cb _hidl_cb) override;
- Return<Result> setCallback(const sp<IStreamOutCallback>& callback) override;
- Return<Result> clearCallback() override;
- Return<void> supportsPauseAndResume(supportsPauseAndResume_cb _hidl_cb) override;
- Return<Result> pause() override;
- Return<Result> resume() override;
- Return<bool> supportsDrain() override;
- Return<Result> drain(AudioDrain type) override;
- Return<Result> flush() override;
- Return<void> getPresentationPosition(getPresentationPosition_cb _hidl_cb) override;
+ Return<uint32_t> getLatency() override;
+ Return<Result> setVolume(float left, float right) override;
+ Return<void> prepareForWriting(uint32_t frameSize, uint32_t framesCount,
+ prepareForWriting_cb _hidl_cb) override;
+ Return<void> getRenderPosition(getRenderPosition_cb _hidl_cb) override;
+ Return<void> getNextWriteTimestamp(getNextWriteTimestamp_cb _hidl_cb) override;
+ Return<Result> setCallback(const sp<IStreamOutCallback>& callback) override;
+ Return<Result> clearCallback() override;
+ Return<void> supportsPauseAndResume(supportsPauseAndResume_cb _hidl_cb) override;
+ Return<Result> pause() override;
+ Return<Result> resume() override;
+ Return<bool> supportsDrain() override;
+ Return<Result> drain(AudioDrain type) override;
+ Return<Result> flush() override;
+ Return<void> getPresentationPosition(getPresentationPosition_cb _hidl_cb) override;
Return<Result> start() override;
Return<Result> stop() override;
Return<void> createMmapBuffer(int32_t minSizeFrames, createMmapBuffer_cb _hidl_cb) override;
Return<void> getMmapPosition(getMmapPosition_cb _hidl_cb) override;
- static Result getPresentationPositionImpl(
- audio_stream_out_t *stream, uint64_t *frames, TimeSpec *timeStamp);
+ static Result getPresentationPositionImpl(audio_stream_out_t* stream, uint64_t* frames,
+ TimeSpec* timeStamp);
- private:
+ private:
bool mIsClosed;
const sp<Device> mDevice;
- audio_stream_out_t *mStream;
+ audio_stream_out_t* mStream;
const sp<Stream> mStreamCommon;
const sp<StreamMmap<audio_stream_out_t>> mStreamMmap;
sp<IStreamOutCallback> mCallback;
@@ -127,7 +127,7 @@
virtual ~StreamOut();
- static int asyncCallback(stream_callback_event_t event, void *param, void *cookie);
+ static int asyncCallback(stream_callback_event_t event, void* param, void* cookie);
};
} // namespace implementation