tequilaOS/platform_hardware_interfaces
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

soundtrigger: Apply clang-format to 2.0 default implementation

Browse source 
The implementation needs to be updated to become extensible.
The current coding style is not consistent with the style
required for hardware/interfaces.

Reformatted with:
   clang-format -style=file -i <...>/SoundTriggerHalImpl.*
No manual changes.

Bug: 68823037
Change-Id: I5f5cbb599190a515dec8afe9026ca835b8fd20fa
Test: make
This commit is contained in:
Mikhail Naganov 2017-12-22 13:23:08 -08:00
parent 882d2377ec
commit 0bbc4aa61f
2 changed files with 169 additions and 225 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

247
soundtrigger/2.0/default/SoundTriggerHalImpl.cpp
View file

@ -17,9 +17,8 @@
#define LOG_TAG "SoundTriggerHalImpl"
//#define LOG_NDEBUG 0
#include <android/log.h>
#include "SoundTriggerHalImpl.h"
#include <android/log.h>
namespace android {
namespace hardware {
@ -28,15 +27,14 @@ namespace V2_0 {
namespace implementation {
// static
void SoundTriggerHalImpl::soundModelCallback(struct sound_trigger_model_event *halEvent,
void *cookie)
{
void SoundTriggerHalImpl::soundModelCallback(struct sound_trigger_model_event* halEvent,
void* cookie) {
if (halEvent == NULL) {
ALOGW("soundModelCallback called with NULL event");
return;
}
sp<SoundModelClient> client =
wp<SoundModelClient>(static_cast<SoundModelClient *>(cookie)).promote();
wp<SoundModelClient>(static_cast<SoundModelClient*>(cookie)).promote();
if (client == 0) {
ALOGW("soundModelCallback called on stale client");
return;
@ -55,37 +53,33 @@ void SoundTriggerHalImpl::soundModelCallback(struct sound_trigger_model_event *h
}
// static
void SoundTriggerHalImpl::recognitionCallback(struct sound_trigger_recognition_event *halEvent,
void *cookie)
{
void SoundTriggerHalImpl::recognitionCallback(struct sound_trigger_recognition_event* halEvent,
void* cookie) {
if (halEvent == NULL) {
ALOGW("recognitionCallback call NULL event");
return;
}
sp<SoundModelClient> client =
wp<SoundModelClient>(static_cast<SoundModelClient *>(cookie)).promote();
wp<SoundModelClient>(static_cast<SoundModelClient*>(cookie)).promote();
if (client == 0) {
ALOGW("soundModelCallback called on stale client");
return;
}
ISoundTriggerHwCallback::RecognitionEvent *event = convertRecognitionEventFromHal(halEvent);
ISoundTriggerHwCallback::RecognitionEvent* event = convertRecognitionEventFromHal(halEvent);
event->model = client->mId;
if (halEvent->type == SOUND_MODEL_TYPE_KEYPHRASE) {
client->mCallback->phraseRecognitionCallback(
*(reinterpret_cast<ISoundTriggerHwCallback::PhraseRecognitionEvent *>(event)),
client->mCookie);
*(reinterpret_cast<ISoundTriggerHwCallback::PhraseRecognitionEvent*>(event)),
client->mCookie);
} else {
client->mCallback->recognitionCallback(*event, client->mCookie);
}
delete event;
}
// Methods from ::android::hardware::soundtrigger::V2_0::ISoundTriggerHw follow.
Return<void> SoundTriggerHalImpl::getProperties(getProperties_cb _hidl_cb)
{
Return<void> SoundTriggerHalImpl::getProperties(getProperties_cb _hidl_cb) {
ALOGV("getProperties() mHwDevice %p", mHwDevice);
int ret;
struct sound_trigger_properties halProperties;
@ -100,8 +94,8 @@ Return<void> SoundTriggerHalImpl::getProperties(getProperties_cb _hidl_cb)
convertPropertiesFromHal(&properties, &halProperties);
ALOGV("getProperties implementor %s recognitionModes %08x",
properties.implementor.c_str(), properties.recognitionModes);
ALOGV("getProperties implementor %s recognitionModes %08x", properties.implementor.c_str(),
properties.recognitionModes);
exit:
_hidl_cb(ret, properties);
@ -109,12 +103,11 @@ exit:
}
int SoundTriggerHalImpl::doLoadSoundModel(const ISoundTriggerHw::SoundModel& soundModel,
const sp<ISoundTriggerHwCallback>& callback,
ISoundTriggerHwCallback::CallbackCookie cookie,
uint32_t *modelId)
{
const sp<ISoundTriggerHwCallback>& callback,
ISoundTriggerHwCallback::CallbackCookie cookie,
uint32_t* modelId) {
int32_t ret = 0;
struct sound_trigger_sound_model *halSoundModel;
struct sound_trigger_sound_model* halSoundModel;
*modelId = 0;
sp<SoundModelClient> client;
@ -137,13 +130,13 @@ int SoundTriggerHalImpl::doLoadSoundModel(const ISoundTriggerHw::SoundModel& sou
*modelId = nextUniqueId();
} while (mClients.valueFor(*modelId) != 0 && *modelId != 0);
}
LOG_ALWAYS_FATAL_IF(*modelId == 0,
"wrap around in sound model IDs, num loaded models %zu", mClients.size());
LOG_ALWAYS_FATAL_IF(*modelId == 0, "wrap around in sound model IDs, num loaded models %zu",
mClients.size());
client = new SoundModelClient(*modelId, callback, cookie);
ret = mHwDevice->load_sound_model(mHwDevice, halSoundModel, soundModelCallback,
client.get(), &client->mHalHandle);
ret = mHwDevice->load_sound_model(mHwDevice, halSoundModel, soundModelCallback, client.get(),
&client->mHalHandle);
free(halSoundModel);
@ -163,8 +156,7 @@ exit:
Return<void> SoundTriggerHalImpl::loadSoundModel(const ISoundTriggerHw::SoundModel& soundModel,
const sp<ISoundTriggerHwCallback>& callback,
ISoundTriggerHwCallback::CallbackCookie cookie,
loadSoundModel_cb _hidl_cb)
{
loadSoundModel_cb _hidl_cb) {
uint32_t modelId = 0;
int32_t ret = doLoadSoundModel(soundModel, callback, cookie, &modelId);
@ -173,21 +165,18 @@ Return<void> SoundTriggerHalImpl::loadSoundModel(const ISoundTriggerHw::SoundMod
}
Return<void> SoundTriggerHalImpl::loadPhraseSoundModel(
const ISoundTriggerHw::PhraseSoundModel& soundModel,
const sp<ISoundTriggerHwCallback>& callback,
ISoundTriggerHwCallback::CallbackCookie cookie,
ISoundTriggerHw::loadPhraseSoundModel_cb _hidl_cb)
{
const ISoundTriggerHw::PhraseSoundModel& soundModel,
const sp<ISoundTriggerHwCallback>& callback, ISoundTriggerHwCallback::CallbackCookie cookie,
ISoundTriggerHw::loadPhraseSoundModel_cb _hidl_cb) {
uint32_t modelId = 0;
int32_t ret = doLoadSoundModel((const ISoundTriggerHw::SoundModel&)soundModel,
callback, cookie, &modelId);
int32_t ret = doLoadSoundModel((const ISoundTriggerHw::SoundModel&)soundModel, callback, cookie,
&modelId);
_hidl_cb(ret, modelId);
return Void();
}
Return<int32_t> SoundTriggerHalImpl::unloadSoundModel(SoundModelHandle modelHandle)
{
Return<int32_t> SoundTriggerHalImpl::unloadSoundModel(SoundModelHandle modelHandle) {
int32_t ret;
sp<SoundModelClient> client;
@ -213,14 +202,13 @@ exit:
return ret;
}
Return<int32_t> SoundTriggerHalImpl::startRecognition(SoundModelHandle modelHandle,
const ISoundTriggerHw::RecognitionConfig& config,
const sp<ISoundTriggerHwCallback>& callback __unused,
ISoundTriggerHwCallback::CallbackCookie cookie __unused)
{
Return<int32_t> SoundTriggerHalImpl::startRecognition(
SoundModelHandle modelHandle, const ISoundTriggerHw::RecognitionConfig& config,
const sp<ISoundTriggerHwCallback>& callback __unused,
ISoundTriggerHwCallback::CallbackCookie cookie __unused) {
int32_t ret;
sp<SoundModelClient> client;
struct sound_trigger_recognition_config *halConfig;
struct sound_trigger_recognition_config* halConfig;
if (mHwDevice == NULL) {
ret = -ENODEV;
@ -236,7 +224,6 @@ Return<int32_t> SoundTriggerHalImpl::startRecognition(SoundModelHandle modelHand
}
}
halConfig = convertRecognitionConfigToHal(&config);
if (halConfig == NULL) {
@ -244,7 +231,7 @@ Return<int32_t> SoundTriggerHalImpl::startRecognition(SoundModelHandle modelHand
goto exit;
}
ret = mHwDevice->start_recognition(mHwDevice, client->mHalHandle, halConfig,
recognitionCallback, client.get());
recognitionCallback, client.get());
free(halConfig);
@ -252,8 +239,7 @@ exit:
return ret;
}
Return<int32_t> SoundTriggerHalImpl::stopRecognition(SoundModelHandle modelHandle)
{
Return<int32_t> SoundTriggerHalImpl::stopRecognition(SoundModelHandle modelHandle) {
int32_t ret;
sp<SoundModelClient> client;
if (mHwDevice == NULL) {
@ -276,8 +262,7 @@ exit:
return ret;
}
Return<int32_t> SoundTriggerHalImpl::stopAllRecognitions()
{
Return<int32_t> SoundTriggerHalImpl::stopAllRecognitions() {
int32_t ret;
if (mHwDevice == NULL) {
ret = -ENODEV;
@ -285,7 +270,7 @@ Return<int32_t> SoundTriggerHalImpl::stopAllRecognitions()
}
if (mHwDevice->common.version >= SOUND_TRIGGER_DEVICE_API_VERSION_1_1 &&
mHwDevice->stop_all_recognitions) {
mHwDevice->stop_all_recognitions) {
ret = mHwDevice->stop_all_recognitions(mHwDevice);
} else {
ret = -ENOSYS;
@ -295,19 +280,16 @@ exit:
}
SoundTriggerHalImpl::SoundTriggerHalImpl()
: mModuleName("primary"), mHwDevice(NULL), mNextModelId(1)
{
}
: mModuleName("primary"), mHwDevice(NULL), mNextModelId(1) {}
void SoundTriggerHalImpl::onFirstRef()
{
const hw_module_t *mod;
void SoundTriggerHalImpl::onFirstRef() {
const hw_module_t* mod;
int rc;
rc = hw_get_module_by_class(SOUND_TRIGGER_HARDWARE_MODULE_ID, mModuleName, &mod);
if (rc != 0) {
ALOGE("couldn't load sound trigger module %s.%s (%s)",
SOUND_TRIGGER_HARDWARE_MODULE_ID, mModuleName, strerror(-rc));
ALOGE("couldn't load sound trigger module %s.%s (%s)", SOUND_TRIGGER_HARDWARE_MODULE_ID,
mModuleName, strerror(-rc));
return;
}
rc = sound_trigger_hw_device_open(mod, &mHwDevice);
@ -318,7 +300,7 @@ void SoundTriggerHalImpl::onFirstRef()
return;
}
if (mHwDevice->common.version < SOUND_TRIGGER_DEVICE_API_VERSION_1_0 ||
mHwDevice->common.version > SOUND_TRIGGER_DEVICE_API_VERSION_CURRENT) {
mHwDevice->common.version > SOUND_TRIGGER_DEVICE_API_VERSION_CURRENT) {
ALOGE("wrong sound trigger hw device version %04x", mHwDevice->common.version);
sound_trigger_hw_device_close(mHwDevice);
mHwDevice = NULL;
@ -328,22 +310,18 @@ void SoundTriggerHalImpl::onFirstRef()
ALOGI("onFirstRef() mModuleName %s mHwDevice %p", mModuleName, mHwDevice);
}
SoundTriggerHalImpl::~SoundTriggerHalImpl()
{
SoundTriggerHalImpl::~SoundTriggerHalImpl() {
if (mHwDevice != NULL) {
sound_trigger_hw_device_close(mHwDevice);
}
}
uint32_t SoundTriggerHalImpl::nextUniqueId()
{
return (uint32_t) atomic_fetch_add_explicit(&mNextModelId,
(uint_fast32_t) 1, memory_order_acq_rel);
uint32_t SoundTriggerHalImpl::nextUniqueId() {
return (uint32_t)atomic_fetch_add_explicit(&mNextModelId, (uint_fast32_t)1,
memory_order_acq_rel);
}
void SoundTriggerHalImpl::convertUuidFromHal(Uuid *uuid,
const sound_trigger_uuid_t *halUuid)
{
void SoundTriggerHalImpl::convertUuidFromHal(Uuid* uuid, const sound_trigger_uuid_t* halUuid) {
uuid->timeLow = halUuid->timeLow;
uuid->timeMid = halUuid->timeMid;
uuid->versionAndTimeHigh = halUuid->timeHiAndVersion;
@ -351,9 +329,7 @@ void SoundTriggerHalImpl::convertUuidFromHal(Uuid *uuid,
memcpy(&uuid->node[0], &halUuid->node[0], 6);
}
void SoundTriggerHalImpl::convertUuidToHal(sound_trigger_uuid_t *halUuid,
const Uuid *uuid)
{
void SoundTriggerHalImpl::convertUuidToHal(sound_trigger_uuid_t* halUuid, const Uuid* uuid) {
halUuid->timeLow = uuid->timeLow;
halUuid->timeMid = uuid->timeMid;
halUuid->timeHiAndVersion = uuid->versionAndTimeHigh;
@ -362,9 +338,7 @@ void SoundTriggerHalImpl::convertUuidToHal(sound_trigger_uuid_t *halUuid,
}
void SoundTriggerHalImpl::convertPropertiesFromHal(
ISoundTriggerHw::Properties *properties,
const struct sound_trigger_properties *halProperties)
{
ISoundTriggerHw::Properties* properties, const struct sound_trigger_properties* halProperties) {
properties->implementor = halProperties->implementor;
properties->description = halProperties->description;
properties->version = halProperties->version;
@ -378,13 +352,10 @@ void SoundTriggerHalImpl::convertPropertiesFromHal(
properties->concurrentCapture = halProperties->concurrent_capture;
properties->triggerInEvent = halProperties->trigger_in_event;
properties->powerConsumptionMw = halProperties->power_consumption_mw;
}
void SoundTriggerHalImpl::convertTriggerPhraseToHal(
struct sound_trigger_phrase *halTriggerPhrase,
const ISoundTriggerHw::Phrase *triggerPhrase)
{
void SoundTriggerHalImpl::convertTriggerPhraseToHal(struct sound_trigger_phrase* halTriggerPhrase,
const ISoundTriggerHw::Phrase* triggerPhrase) {
halTriggerPhrase->id = triggerPhrase->id;
halTriggerPhrase->recognition_mode = triggerPhrase->recognitionModes;
unsigned int i;
@ -395,39 +366,35 @@ void SoundTriggerHalImpl::convertTriggerPhraseToHal(
halTriggerPhrase->users[i] = triggerPhrase->users[i];
}
strlcpy(halTriggerPhrase->locale,
triggerPhrase->locale.c_str(), SOUND_TRIGGER_MAX_LOCALE_LEN);
strlcpy(halTriggerPhrase->text,
triggerPhrase->text.c_str(), SOUND_TRIGGER_MAX_STRING_LEN);
strlcpy(halTriggerPhrase->locale, triggerPhrase->locale.c_str(), SOUND_TRIGGER_MAX_LOCALE_LEN);
strlcpy(halTriggerPhrase->text, triggerPhrase->text.c_str(), SOUND_TRIGGER_MAX_STRING_LEN);
}
struct sound_trigger_sound_model *SoundTriggerHalImpl::convertSoundModelToHal(
const ISoundTriggerHw::SoundModel *soundModel)
{
struct sound_trigger_sound_model *halModel = NULL;
struct sound_trigger_sound_model* SoundTriggerHalImpl::convertSoundModelToHal(
const ISoundTriggerHw::SoundModel* soundModel) {
struct sound_trigger_sound_model* halModel = NULL;
if (soundModel->type == SoundModelType::KEYPHRASE) {
size_t allocSize =
sizeof(struct sound_trigger_phrase_sound_model) + soundModel->data.size();
struct sound_trigger_phrase_sound_model *halKeyPhraseModel =
static_cast<struct sound_trigger_phrase_sound_model *>(malloc(allocSize));
sizeof(struct sound_trigger_phrase_sound_model) + soundModel->data.size();
struct sound_trigger_phrase_sound_model* halKeyPhraseModel =
static_cast<struct sound_trigger_phrase_sound_model*>(malloc(allocSize));
LOG_ALWAYS_FATAL_IF(halKeyPhraseModel == NULL,
"malloc failed for size %zu in convertSoundModelToHal PHRASE", allocSize);
"malloc failed for size %zu in convertSoundModelToHal PHRASE",
allocSize);
const ISoundTriggerHw::PhraseSoundModel *keyPhraseModel =
reinterpret_cast<const ISoundTriggerHw::PhraseSoundModel *>(soundModel);
const ISoundTriggerHw::PhraseSoundModel* keyPhraseModel =
reinterpret_cast<const ISoundTriggerHw::PhraseSoundModel*>(soundModel);
size_t i;
for (i = 0; i < keyPhraseModel->phrases.size() && i < SOUND_TRIGGER_MAX_PHRASES; i++) {
convertTriggerPhraseToHal(&halKeyPhraseModel->phrases[i],
&keyPhraseModel->phrases[i]);
convertTriggerPhraseToHal(&halKeyPhraseModel->phrases[i], &keyPhraseModel->phrases[i]);
}
halKeyPhraseModel->num_phrases = (unsigned int)i;
halModel = reinterpret_cast<struct sound_trigger_sound_model *>(halKeyPhraseModel);
halModel = reinterpret_cast<struct sound_trigger_sound_model*>(halKeyPhraseModel);
halModel->data_offset = sizeof(struct sound_trigger_phrase_sound_model);
} else {
size_t allocSize =
sizeof(struct sound_trigger_sound_model) + soundModel->data.size();
halModel = static_cast<struct sound_trigger_sound_model *>(malloc(allocSize));
size_t allocSize = sizeof(struct sound_trigger_sound_model) + soundModel->data.size();
halModel = static_cast<struct sound_trigger_sound_model*>(malloc(allocSize));
LOG_ALWAYS_FATAL_IF(halModel == NULL,
"malloc failed for size %zu in convertSoundModelToHal GENERIC",
allocSize);
@ -438,17 +405,15 @@ struct sound_trigger_sound_model *SoundTriggerHalImpl::convertSoundModelToHal(
convertUuidToHal(&halModel->uuid, &soundModel->uuid);
convertUuidToHal(&halModel->vendor_uuid, &soundModel->vendorUuid);
halModel->data_size = soundModel->data.size();
uint8_t *dst = reinterpret_cast<uint8_t *>(halModel) + halModel->data_offset;
const uint8_t *src = reinterpret_cast<const uint8_t *>(&soundModel->data[0]);
uint8_t* dst = reinterpret_cast<uint8_t*>(halModel) + halModel->data_offset;
const uint8_t* src = reinterpret_cast<const uint8_t*>(&soundModel->data[0]);
memcpy(dst, src, soundModel->data.size());
return halModel;
}
void SoundTriggerHalImpl::convertPhraseRecognitionExtraToHal(
struct sound_trigger_phrase_recognition_extra *halExtra,
const PhraseRecognitionExtra *extra)
{
struct sound_trigger_phrase_recognition_extra* halExtra, const PhraseRecognitionExtra* extra) {
halExtra->id = extra->id;
halExtra->recognition_modes = extra->recognitionModes;
halExtra->confidence_level = extra->confidenceLevel;
@ -461,16 +426,14 @@ void SoundTriggerHalImpl::convertPhraseRecognitionExtraToHal(
halExtra->num_levels = i;
}
struct sound_trigger_recognition_config *SoundTriggerHalImpl::convertRecognitionConfigToHal(
const ISoundTriggerHw::RecognitionConfig *config)
{
struct sound_trigger_recognition_config* SoundTriggerHalImpl::convertRecognitionConfigToHal(
const ISoundTriggerHw::RecognitionConfig* config) {
size_t allocSize = sizeof(struct sound_trigger_recognition_config) + config->data.size();
struct sound_trigger_recognition_config *halConfig =
static_cast<struct sound_trigger_recognition_config *>(malloc(allocSize));
struct sound_trigger_recognition_config* halConfig =
static_cast<struct sound_trigger_recognition_config*>(malloc(allocSize));
LOG_ALWAYS_FATAL_IF(halConfig == NULL,
"malloc failed for size %zu in convertRecognitionConfigToHal",
allocSize);
"malloc failed for size %zu in convertRecognitionConfigToHal", allocSize);
halConfig->capture_handle = (audio_io_handle_t)config->captureHandle;
halConfig->capture_device = (audio_devices_t)config->captureDevice;
@ -478,44 +441,41 @@ struct sound_trigger_recognition_config *SoundTriggerHalImpl::convertRecognition
unsigned int i;
for (i = 0; i < config->phrases.size() && i < SOUND_TRIGGER_MAX_PHRASES; i++) {
convertPhraseRecognitionExtraToHal(&halConfig->phrases[i],
&config->phrases[i]);
convertPhraseRecognitionExtraToHal(&halConfig->phrases[i], &config->phrases[i]);
}
halConfig->num_phrases = i;
halConfig->data_offset = sizeof(struct sound_trigger_recognition_config);
halConfig->data_size = config->data.size();
uint8_t *dst = reinterpret_cast<uint8_t *>(halConfig) + halConfig->data_offset;
const uint8_t *src = reinterpret_cast<const uint8_t *>(&config->data[0]);
uint8_t* dst = reinterpret_cast<uint8_t*>(halConfig) + halConfig->data_offset;
const uint8_t* src = reinterpret_cast<const uint8_t*>(&config->data[0]);
memcpy(dst, src, config->data.size());
return halConfig;
}
// static
void SoundTriggerHalImpl::convertSoundModelEventFromHal(ISoundTriggerHwCallback::ModelEvent *event,
const struct sound_trigger_model_event *halEvent)
{
void SoundTriggerHalImpl::convertSoundModelEventFromHal(
ISoundTriggerHwCallback::ModelEvent* event, const struct sound_trigger_model_event* halEvent) {
event->status = (ISoundTriggerHwCallback::SoundModelStatus)halEvent->status;
// event->model to be remapped by called
event->data.setToExternal(
const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(halEvent)) + halEvent->data_offset,
halEvent->data_size);
const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(halEvent)) + halEvent->data_offset,
halEvent->data_size);
}
// static
ISoundTriggerHwCallback::RecognitionEvent *SoundTriggerHalImpl::convertRecognitionEventFromHal(
const struct sound_trigger_recognition_event *halEvent)
{
ISoundTriggerHwCallback::RecognitionEvent * event;
ISoundTriggerHwCallback::RecognitionEvent* SoundTriggerHalImpl::convertRecognitionEventFromHal(
const struct sound_trigger_recognition_event* halEvent) {
ISoundTriggerHwCallback::RecognitionEvent* event;
if (halEvent->type == SOUND_MODEL_TYPE_KEYPHRASE) {
const struct sound_trigger_phrase_recognition_event *halPhraseEvent =
reinterpret_cast<const struct sound_trigger_phrase_recognition_event *>(halEvent);
ISoundTriggerHwCallback::PhraseRecognitionEvent *phraseEvent =
new ISoundTriggerHwCallback::PhraseRecognitionEvent();
const struct sound_trigger_phrase_recognition_event* halPhraseEvent =
reinterpret_cast<const struct sound_trigger_phrase_recognition_event*>(halEvent);
ISoundTriggerHwCallback::PhraseRecognitionEvent* phraseEvent =
new ISoundTriggerHwCallback::PhraseRecognitionEvent();
PhraseRecognitionExtra *phraseExtras =
new PhraseRecognitionExtra[halPhraseEvent->num_phrases];
PhraseRecognitionExtra* phraseExtras =
new PhraseRecognitionExtra[halPhraseEvent->num_phrases];
for (unsigned int i = 0; i < halPhraseEvent->num_phrases; i++) {
convertPhraseRecognitionExtraFromHal(&phraseExtras[i],
&halPhraseEvent->phrase_extras[i]);
@ -524,7 +484,7 @@ ISoundTriggerHwCallback::RecognitionEvent *SoundTriggerHalImpl::convertRecogniti
// FIXME: transfer buffer ownership. should have a method for that in hidl_vec
phraseEvent->phraseExtras.resize(halPhraseEvent->num_phrases);
delete[] phraseExtras;
event = reinterpret_cast<ISoundTriggerHwCallback::RecognitionEvent *>(phraseEvent);
event = reinterpret_cast<ISoundTriggerHwCallback::RecognitionEvent*>(phraseEvent);
} else {
event = new ISoundTriggerHwCallback::RecognitionEvent();
}
@ -539,26 +499,23 @@ ISoundTriggerHwCallback::RecognitionEvent *SoundTriggerHalImpl::convertRecogniti
event->triggerInData = halEvent->trigger_in_data;
event->audioConfig.sampleRateHz = halEvent->audio_config.sample_rate;
event->audioConfig.channelMask =
(audio::common::V2_0::AudioChannelMask)halEvent->audio_config.channel_mask;
(audio::common::V2_0::AudioChannelMask)halEvent->audio_config.channel_mask;
event->audioConfig.format = (audio::common::V2_0::AudioFormat)halEvent->audio_config.format;
event->data.setToExternal(
const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(halEvent)) + halEvent->data_offset,
halEvent->data_size);
const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(halEvent)) + halEvent->data_offset,
halEvent->data_size);
return event;
}
// static
void SoundTriggerHalImpl::convertPhraseRecognitionExtraFromHal(
PhraseRecognitionExtra *extra,
const struct sound_trigger_phrase_recognition_extra *halExtra)
{
PhraseRecognitionExtra* extra, const struct sound_trigger_phrase_recognition_extra* halExtra) {
extra->id = halExtra->id;
extra->recognitionModes = halExtra->recognition_modes;
extra->confidenceLevel = halExtra->confidence_level;
ConfidenceLevel *levels =
new ConfidenceLevel[halExtra->num_levels];
ConfidenceLevel* levels = new ConfidenceLevel[halExtra->num_levels];
for (unsigned int i = 0; i < halExtra->num_levels; i++) {
levels[i].userId = halExtra->levels[i].user_id;
levels[i].levelPercent = halExtra->levels[i].level;
@ -569,15 +526,11 @@ void SoundTriggerHalImpl::convertPhraseRecognitionExtraFromHal(
delete[] levels;
}
ISoundTriggerHw *HIDL_FETCH_ISoundTriggerHw(const char* /* name */)
{
ISoundTriggerHw* HIDL_FETCH_ISoundTriggerHw(const char* /* name */) {
return new SoundTriggerHalImpl();
}
} // namespace implementation
} // namespace implementation
} // namespace V2_0
} // namespace soundtrigger
} // namespace hardware
} // namespace android

147
soundtrigger/2.0/default/SoundTriggerHalImpl.h
View file

@ -19,12 +19,12 @@
#include <android/hardware/soundtrigger/2.0/ISoundTriggerHw.h>
#include <android/hardware/soundtrigger/2.0/ISoundTriggerHwCallback.h>
#include <hardware/sound_trigger.h>
#include <hidl/Status.h>
#include <stdatomic.h>
#include <utils/threads.h>
#include <utils/KeyedVector.h>
#include <system/sound_trigger.h>
#include <hardware/sound_trigger.h>
#include <utils/KeyedVector.h>
#include <utils/threads.h>
namespace android {
namespace hardware {
@ -35,95 +35,87 @@ namespace implementation {
using ::android::hardware::audio::common::V2_0::Uuid;
using ::android::hardware::soundtrigger::V2_0::ISoundTriggerHwCallback;
class SoundTriggerHalImpl : public ISoundTriggerHw {
public:
SoundTriggerHalImpl();
public:
SoundTriggerHalImpl();
// Methods from ::android::hardware::soundtrigger::V2_0::ISoundTriggerHw follow.
Return<void> getProperties(getProperties_cb _hidl_cb) override;
Return<void> loadSoundModel(const ISoundTriggerHw::SoundModel& soundModel,
const sp<ISoundTriggerHwCallback>& callback,
ISoundTriggerHwCallback::CallbackCookie cookie,
loadSoundModel_cb _hidl_cb) override;
Return<void> loadPhraseSoundModel(const ISoundTriggerHw::PhraseSoundModel& soundModel,
const sp<ISoundTriggerHwCallback>& callback,
ISoundTriggerHwCallback::CallbackCookie cookie,
loadPhraseSoundModel_cb _hidl_cb) override;
Return<int32_t> unloadSoundModel(SoundModelHandle modelHandle) override;
Return<int32_t> startRecognition(SoundModelHandle modelHandle,
const ISoundTriggerHw::RecognitionConfig& config,
// Methods from ::android::hardware::soundtrigger::V2_0::ISoundTriggerHw follow.
Return<void> getProperties(getProperties_cb _hidl_cb) override;
Return<void> loadSoundModel(const ISoundTriggerHw::SoundModel& soundModel,
const sp<ISoundTriggerHwCallback>& callback,
ISoundTriggerHwCallback::CallbackCookie cookie,
loadSoundModel_cb _hidl_cb) override;
Return<void> loadPhraseSoundModel(const ISoundTriggerHw::PhraseSoundModel& soundModel,
const sp<ISoundTriggerHwCallback>& callback,
ISoundTriggerHwCallback::CallbackCookie cookie) override;
Return<int32_t> stopRecognition(SoundModelHandle modelHandle) override;
Return<int32_t> stopAllRecognitions() override;
ISoundTriggerHwCallback::CallbackCookie cookie,
loadPhraseSoundModel_cb _hidl_cb) override;
// RefBase
virtual void onFirstRef();
Return<int32_t> unloadSoundModel(SoundModelHandle modelHandle) override;
Return<int32_t> startRecognition(SoundModelHandle modelHandle,
const ISoundTriggerHw::RecognitionConfig& config,
const sp<ISoundTriggerHwCallback>& callback,
ISoundTriggerHwCallback::CallbackCookie cookie) override;
Return<int32_t> stopRecognition(SoundModelHandle modelHandle) override;
Return<int32_t> stopAllRecognitions() override;
static void soundModelCallback(struct sound_trigger_model_event *halEvent,
void *cookie);
static void recognitionCallback(struct sound_trigger_recognition_event *halEvent,
void *cookie);
// RefBase
virtual void onFirstRef();
private:
static void soundModelCallback(struct sound_trigger_model_event* halEvent, void* cookie);
static void recognitionCallback(struct sound_trigger_recognition_event* halEvent, void* cookie);
class SoundModelClient : public RefBase {
public:
SoundModelClient(uint32_t id, sp<ISoundTriggerHwCallback> callback,
ISoundTriggerHwCallback::CallbackCookie cookie)
: mId(id), mCallback(callback), mCookie(cookie) {}
virtual ~SoundModelClient() {}
private:
class SoundModelClient : public RefBase {
public:
SoundModelClient(uint32_t id, sp<ISoundTriggerHwCallback> callback,
ISoundTriggerHwCallback::CallbackCookie cookie)
: mId(id), mCallback(callback), mCookie(cookie) {}
virtual ~SoundModelClient() {}
uint32_t mId;
sound_model_handle_t mHalHandle;
sp<ISoundTriggerHwCallback> mCallback;
ISoundTriggerHwCallback::CallbackCookie mCookie;
};
uint32_t mId;
sound_model_handle_t mHalHandle;
sp<ISoundTriggerHwCallback> mCallback;
ISoundTriggerHwCallback::CallbackCookie mCookie;
};
uint32_t nextUniqueId();
void convertUuidFromHal(Uuid *uuid,
const sound_trigger_uuid_t *halUuid);
void convertUuidToHal(sound_trigger_uuid_t *halUuid,
const Uuid *uuid);
void convertPropertiesFromHal(ISoundTriggerHw::Properties *properties,
const struct sound_trigger_properties *halProperties);
void convertTriggerPhraseToHal(struct sound_trigger_phrase *halTriggerPhrase,
const ISoundTriggerHw::Phrase *triggerPhrase);
// returned HAL sound model must be freed by caller
struct sound_trigger_sound_model *convertSoundModelToHal(
const ISoundTriggerHw::SoundModel *soundModel);
void convertPhraseRecognitionExtraToHal(
struct sound_trigger_phrase_recognition_extra *halExtra,
const PhraseRecognitionExtra *extra);
// returned recognition config must be freed by caller
struct sound_trigger_recognition_config *convertRecognitionConfigToHal(
const ISoundTriggerHw::RecognitionConfig *config);
uint32_t nextUniqueId();
void convertUuidFromHal(Uuid* uuid, const sound_trigger_uuid_t* halUuid);
void convertUuidToHal(sound_trigger_uuid_t* halUuid, const Uuid* uuid);
void convertPropertiesFromHal(ISoundTriggerHw::Properties* properties,
const struct sound_trigger_properties* halProperties);
void convertTriggerPhraseToHal(struct sound_trigger_phrase* halTriggerPhrase,
const ISoundTriggerHw::Phrase* triggerPhrase);
// returned HAL sound model must be freed by caller
struct sound_trigger_sound_model* convertSoundModelToHal(
const ISoundTriggerHw::SoundModel* soundModel);
void convertPhraseRecognitionExtraToHal(struct sound_trigger_phrase_recognition_extra* halExtra,
const PhraseRecognitionExtra* extra);
// returned recognition config must be freed by caller
struct sound_trigger_recognition_config* convertRecognitionConfigToHal(
const ISoundTriggerHw::RecognitionConfig* config);
static void convertSoundModelEventFromHal(ISoundTriggerHwCallback::ModelEvent* event,
const struct sound_trigger_model_event* halEvent);
static ISoundTriggerHwCallback::RecognitionEvent* convertRecognitionEventFromHal(
const struct sound_trigger_recognition_event* halEvent);
static void convertPhraseRecognitionExtraFromHal(
PhraseRecognitionExtra* extra,
const struct sound_trigger_phrase_recognition_extra* halExtra);
static void convertSoundModelEventFromHal(ISoundTriggerHwCallback::ModelEvent *event,
const struct sound_trigger_model_event *halEvent);
static ISoundTriggerHwCallback::RecognitionEvent *convertRecognitionEventFromHal(
const struct sound_trigger_recognition_event *halEvent);
static void convertPhraseRecognitionExtraFromHal(PhraseRecognitionExtra *extra,
const struct sound_trigger_phrase_recognition_extra *halExtra);
int doLoadSoundModel(const ISoundTriggerHw::SoundModel& soundModel,
const sp<ISoundTriggerHwCallback>& callback,
ISoundTriggerHwCallback::CallbackCookie cookie, uint32_t* modelId);
int doLoadSoundModel(const ISoundTriggerHw::SoundModel& soundModel,
const sp<ISoundTriggerHwCallback>& callback,
ISoundTriggerHwCallback::CallbackCookie cookie,
uint32_t *modelId);
virtual ~SoundTriggerHalImpl();
virtual ~SoundTriggerHalImpl();
const char * mModuleName;
struct sound_trigger_hw_device* mHwDevice;
volatile atomic_uint_fast32_t mNextModelId;
DefaultKeyedVector<int32_t, sp<SoundModelClient> > mClients;
Mutex mLock;
const char* mModuleName;
struct sound_trigger_hw_device* mHwDevice;
volatile atomic_uint_fast32_t mNextModelId;
DefaultKeyedVector<int32_t, sp<SoundModelClient> > mClients;
Mutex mLock;
};
extern "C" ISoundTriggerHw *HIDL_FETCH_ISoundTriggerHw(const char *name);
extern "C" ISoundTriggerHw* HIDL_FETCH_ISoundTriggerHw(const char* name);
} // namespace implementation
} // namespace V2_0
@ -132,4 +124,3 @@ extern "C" ISoundTriggerHw *HIDL_FETCH_ISoundTriggerHw(const char *name);
} // namespace android
#endif // ANDROID_HARDWARE_SOUNDTRIGGER_V2_0_IMPLEMENTATION_H