| /* |
| * 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 "SoundTriggerHalHidl" |
| //#define LOG_NDEBUG 0 |
| |
| #include <android/hidl/allocator/1.0/IAllocator.h> |
| #include <media/audiohal/hidl/HalDeathHandler.h> |
| #include <utils/Log.h> |
| #include "SoundTriggerHalHidl.h" |
| #include <hidlmemory/mapping.h> |
| #include <hwbinder/IPCThreadState.h> |
| #include <hwbinder/ProcessState.h> |
| |
| namespace android { |
| |
| using ::android::hardware::ProcessState; |
| using ::android::hardware::Return; |
| using ::android::hardware::Status; |
| using ::android::hardware::Void; |
| using ::android::hardware::audio::common::V2_0::AudioDevice; |
| using ::android::hardware::hidl_memory; |
| using ::android::hidl::allocator::V1_0::IAllocator; |
| using ::android::hidl::memory::V1_0::IMemory; |
| |
| namespace { |
| |
| // Backs up by the vector with the contents of shared memory. |
| // It is assumed that the passed hidl_vector is empty, so it's |
| // not cleared if the memory is a null object. |
| // The caller needs to keep the returned sp<IMemory> as long as |
| // the data is needed. |
| std::pair<bool, sp<IMemory>> memoryAsVector(const hidl_memory& m, hidl_vec<uint8_t>* vec) { |
| sp<IMemory> memory; |
| if (m.size() == 0) { |
| return std::make_pair(true, memory); |
| } |
| memory = mapMemory(m); |
| if (memory != nullptr) { |
| memory->read(); |
| vec->setToExternal(static_cast<uint8_t*>(static_cast<void*>(memory->getPointer())), |
| memory->getSize()); |
| return std::make_pair(true, memory); |
| } |
| ALOGE("%s: Could not map HIDL memory to IMemory", __func__); |
| return std::make_pair(false, memory); |
| } |
| |
| // Moves the data from the vector into allocated shared memory, |
| // emptying the vector. |
| // It is assumed that the passed hidl_memory is a null object, so it's |
| // not reset if the vector is empty. |
| // The caller needs to keep the returned sp<IMemory> as long as |
| // the data is needed. |
| std::pair<bool, sp<IMemory>> moveVectorToMemory(hidl_vec<uint8_t>* v, hidl_memory* mem) { |
| sp<IMemory> memory; |
| if (v->size() == 0) { |
| return std::make_pair(true, memory); |
| } |
| sp<IAllocator> ashmem = IAllocator::getService("ashmem"); |
| if (ashmem == 0) { |
| ALOGE("Failed to retrieve ashmem allocator service"); |
| return std::make_pair(false, memory); |
| } |
| bool success = false; |
| Return<void> r = ashmem->allocate(v->size(), [&](bool s, const hidl_memory& m) { |
| success = s; |
| if (success) *mem = m; |
| }); |
| if (r.isOk() && success) { |
| memory = hardware::mapMemory(*mem); |
| if (memory != 0) { |
| memory->update(); |
| memcpy(memory->getPointer(), v->data(), v->size()); |
| memory->commit(); |
| v->resize(0); |
| return std::make_pair(true, memory); |
| } else { |
| ALOGE("Failed to map allocated ashmem"); |
| } |
| } else { |
| ALOGE("Failed to allocate %llu bytes from ashmem", (unsigned long long)v->size()); |
| } |
| return std::make_pair(false, memory); |
| } |
| |
| } // namespace |
| |
| /* static */ |
| sp<SoundTriggerHalInterface> SoundTriggerHalInterface::connectModule(const char *moduleName) |
| { |
| return new SoundTriggerHalHidl(moduleName); |
| } |
| |
| int SoundTriggerHalHidl::getProperties(struct sound_trigger_properties *properties) |
| { |
| sp<ISoundTriggerHw> soundtrigger = getService(); |
| if (soundtrigger == 0) { |
| return -ENODEV; |
| } |
| |
| ISoundTriggerHw::Properties halProperties; |
| Return<void> hidlReturn; |
| int ret; |
| { |
| AutoMutex lock(mHalLock); |
| hidlReturn = soundtrigger->getProperties([&](int rc, auto res) { |
| ret = rc; |
| halProperties = res; |
| ALOGI("getProperties res implementor %s", res.implementor.c_str()); |
| }); |
| } |
| |
| if (hidlReturn.isOk()) { |
| if (ret == 0) { |
| convertPropertiesFromHal(properties, &halProperties); |
| } |
| } else { |
| ALOGE("getProperties error %s", hidlReturn.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| ALOGI("getProperties ret %d", ret); |
| return ret; |
| } |
| |
| int SoundTriggerHalHidl::loadSoundModel(struct sound_trigger_sound_model *sound_model, |
| sound_model_callback_t callback, |
| void *cookie, |
| sound_model_handle_t *handle) |
| { |
| if (handle == NULL) { |
| return -EINVAL; |
| } |
| |
| sp<ISoundTriggerHw> soundtrigger = getService(); |
| if (soundtrigger == 0) { |
| return -ENODEV; |
| } |
| |
| uint32_t modelId; |
| { |
| AutoMutex lock(mLock); |
| do { |
| modelId = nextUniqueId(); |
| ALOGI("loadSoundModel modelId %u", modelId); |
| sp<SoundModel> model = mSoundModels.valueFor(modelId); |
| ALOGI("loadSoundModel model %p", model.get()); |
| } while (mSoundModels.valueFor(modelId) != 0 && modelId != 0); |
| } |
| LOG_ALWAYS_FATAL_IF(modelId == 0, |
| "loadSoundModel(): wrap around in sound model IDs, num loaded models %zd", |
| mSoundModels.size()); |
| |
| Return<void> hidlReturn; |
| int ret; |
| SoundModelHandle halHandle; |
| sp<V2_1_ISoundTriggerHw> soundtrigger_2_1 = toService2_1(soundtrigger); |
| if (sound_model->type == SOUND_MODEL_TYPE_KEYPHRASE) { |
| if (!soundtrigger_2_1) { |
| ISoundTriggerHw::PhraseSoundModel halSoundModel; |
| convertPhraseSoundModelToHal(&halSoundModel, sound_model); |
| AutoMutex lock(mHalLock); |
| hidlReturn = soundtrigger->loadPhraseSoundModel( |
| halSoundModel, |
| this, modelId, [&](int32_t retval, auto res) { |
| ret = retval; |
| halHandle = res; |
| }); |
| } else { |
| V2_1_ISoundTriggerHw::PhraseSoundModel halSoundModel; |
| auto result = convertPhraseSoundModelToHal(&halSoundModel, sound_model); |
| if (result.first) { |
| AutoMutex lock(mHalLock); |
| hidlReturn = soundtrigger_2_1->loadPhraseSoundModel_2_1( |
| halSoundModel, |
| this, modelId, [&](int32_t retval, auto res) { |
| ret = retval; |
| halHandle = res; |
| }); |
| } else { |
| return NO_MEMORY; |
| } |
| } |
| } else { |
| if (!soundtrigger_2_1) { |
| ISoundTriggerHw::SoundModel halSoundModel; |
| convertSoundModelToHal(&halSoundModel, sound_model); |
| AutoMutex lock(mHalLock); |
| hidlReturn = soundtrigger->loadSoundModel(halSoundModel, |
| this, modelId, [&](int32_t retval, auto res) { |
| ret = retval; |
| halHandle = res; |
| }); |
| } else { |
| V2_1_ISoundTriggerHw::SoundModel halSoundModel; |
| auto result = convertSoundModelToHal(&halSoundModel, sound_model); |
| if (result.first) { |
| AutoMutex lock(mHalLock); |
| hidlReturn = soundtrigger_2_1->loadSoundModel_2_1(halSoundModel, |
| this, modelId, [&](int32_t retval, auto res) { |
| ret = retval; |
| halHandle = res; |
| }); |
| } else { |
| return NO_MEMORY; |
| } |
| } |
| } |
| |
| if (hidlReturn.isOk()) { |
| if (ret == 0) { |
| AutoMutex lock(mLock); |
| *handle = (sound_model_handle_t)modelId; |
| sp<SoundModel> model = new SoundModel(*handle, callback, cookie, halHandle); |
| mSoundModels.add(*handle, model); |
| } |
| } else { |
| ALOGE("loadSoundModel error %s", hidlReturn.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| |
| return ret; |
| } |
| |
| int SoundTriggerHalHidl::unloadSoundModel(sound_model_handle_t handle) |
| { |
| sp<ISoundTriggerHw> soundtrigger = getService(); |
| if (soundtrigger == 0) { |
| return -ENODEV; |
| } |
| |
| sp<SoundModel> model = removeModel(handle); |
| if (model == 0) { |
| ALOGE("unloadSoundModel model not found for handle %u", handle); |
| return -EINVAL; |
| } |
| |
| Return<int32_t> hidlReturn(0); |
| { |
| AutoMutex lock(mHalLock); |
| hidlReturn = soundtrigger->unloadSoundModel(model->mHalHandle); |
| } |
| |
| if (!hidlReturn.isOk()) { |
| ALOGE("unloadSoundModel error %s", hidlReturn.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| |
| return hidlReturn; |
| } |
| |
| int SoundTriggerHalHidl::startRecognition(sound_model_handle_t handle, |
| const struct sound_trigger_recognition_config *config, |
| recognition_callback_t callback, |
| void *cookie) |
| { |
| sp<ISoundTriggerHw> soundtrigger = getService(); |
| if (soundtrigger == 0) { |
| return -ENODEV; |
| } |
| |
| sp<SoundModel> model = getModel(handle); |
| if (model == 0) { |
| ALOGE("startRecognition model not found for handle %u", handle); |
| return -EINVAL; |
| } |
| |
| model->mRecognitionCallback = callback; |
| model->mRecognitionCookie = cookie; |
| |
| sp<V2_1_ISoundTriggerHw> soundtrigger_2_1 = toService2_1(soundtrigger); |
| Return<int32_t> hidlReturn(0); |
| |
| if (!soundtrigger_2_1) { |
| ISoundTriggerHw::RecognitionConfig halConfig; |
| convertRecognitionConfigToHal(&halConfig, config); |
| { |
| AutoMutex lock(mHalLock); |
| hidlReturn = soundtrigger->startRecognition(model->mHalHandle, halConfig, this, handle); |
| } |
| } else { |
| V2_1_ISoundTriggerHw::RecognitionConfig halConfig; |
| auto result = convertRecognitionConfigToHal(&halConfig, config); |
| if (result.first) { |
| AutoMutex lock(mHalLock); |
| hidlReturn = soundtrigger_2_1->startRecognition_2_1( |
| model->mHalHandle, halConfig, this, handle); |
| } else { |
| return NO_MEMORY; |
| } |
| } |
| |
| if (!hidlReturn.isOk()) { |
| ALOGE("startRecognition error %s", hidlReturn.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| return hidlReturn; |
| } |
| |
| int SoundTriggerHalHidl::stopRecognition(sound_model_handle_t handle) |
| { |
| sp<ISoundTriggerHw> soundtrigger = getService(); |
| if (soundtrigger == 0) { |
| return -ENODEV; |
| } |
| |
| sp<SoundModel> model = getModel(handle); |
| if (model == 0) { |
| ALOGE("stopRecognition model not found for handle %u", handle); |
| return -EINVAL; |
| } |
| |
| Return<int32_t> hidlReturn(0); |
| { |
| AutoMutex lock(mHalLock); |
| hidlReturn = soundtrigger->stopRecognition(model->mHalHandle); |
| } |
| |
| if (!hidlReturn.isOk()) { |
| ALOGE("stopRecognition error %s", hidlReturn.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| return hidlReturn; |
| } |
| |
| int SoundTriggerHalHidl::stopAllRecognitions() |
| { |
| sp<ISoundTriggerHw> soundtrigger = getService(); |
| if (soundtrigger == 0) { |
| return -ENODEV; |
| } |
| |
| Return<int32_t> hidlReturn(0); |
| { |
| AutoMutex lock(mHalLock); |
| hidlReturn = soundtrigger->stopAllRecognitions(); |
| } |
| |
| if (!hidlReturn.isOk()) { |
| ALOGE("stopAllRecognitions error %s", hidlReturn.description().c_str()); |
| return FAILED_TRANSACTION; |
| } |
| return hidlReturn; |
| } |
| |
| SoundTriggerHalHidl::SoundTriggerHalHidl(const char *moduleName) |
| : mModuleName(moduleName), mNextUniqueId(1) |
| { |
| LOG_ALWAYS_FATAL_IF(strcmp(mModuleName, "primary") != 0, |
| "Treble soundtrigger only supports primary module"); |
| } |
| |
| SoundTriggerHalHidl::~SoundTriggerHalHidl() |
| { |
| } |
| |
| sp<ISoundTriggerHw> SoundTriggerHalHidl::getService() |
| { |
| AutoMutex lock(mLock); |
| if (mISoundTrigger == 0) { |
| if (mModuleName == NULL) { |
| mModuleName = "primary"; |
| } |
| mISoundTrigger = ISoundTriggerHw::getService(); |
| if (mISoundTrigger != 0) { |
| mISoundTrigger->linkToDeath(HalDeathHandler::getInstance(), 0 /*cookie*/); |
| } |
| } |
| return mISoundTrigger; |
| } |
| |
| sp<V2_1_ISoundTriggerHw> SoundTriggerHalHidl::toService2_1(const sp<ISoundTriggerHw>& s) |
| { |
| auto castResult_2_1 = V2_1_ISoundTriggerHw::castFrom(s); |
| return castResult_2_1.isOk() ? static_cast<sp<V2_1_ISoundTriggerHw>>(castResult_2_1) : nullptr; |
| } |
| |
| sp<SoundTriggerHalHidl::SoundModel> SoundTriggerHalHidl::getModel(sound_model_handle_t handle) |
| { |
| AutoMutex lock(mLock); |
| return mSoundModels.valueFor(handle); |
| } |
| |
| sp<SoundTriggerHalHidl::SoundModel> SoundTriggerHalHidl::removeModel(sound_model_handle_t handle) |
| { |
| AutoMutex lock(mLock); |
| sp<SoundModel> model = mSoundModels.valueFor(handle); |
| mSoundModels.removeItem(handle); |
| return model; |
| } |
| |
| uint32_t SoundTriggerHalHidl::nextUniqueId() |
| { |
| return (uint32_t) atomic_fetch_add_explicit(&mNextUniqueId, |
| (uint_fast32_t) 1, memory_order_acq_rel); |
| } |
| |
| void SoundTriggerHalHidl::convertUuidToHal(Uuid *halUuid, |
| const sound_trigger_uuid_t *uuid) |
| { |
| halUuid->timeLow = uuid->timeLow; |
| halUuid->timeMid = uuid->timeMid; |
| halUuid->versionAndTimeHigh = uuid->timeHiAndVersion; |
| halUuid->variantAndClockSeqHigh = uuid->clockSeq; |
| memcpy(halUuid->node.data(), &uuid->node[0], sizeof(uuid->node)); |
| } |
| |
| void SoundTriggerHalHidl::convertUuidFromHal(sound_trigger_uuid_t *uuid, |
| const Uuid *halUuid) |
| { |
| uuid->timeLow = halUuid->timeLow; |
| uuid->timeMid = halUuid->timeMid; |
| uuid->timeHiAndVersion = halUuid->versionAndTimeHigh; |
| uuid->clockSeq = halUuid->variantAndClockSeqHigh; |
| memcpy(&uuid->node[0], halUuid->node.data(), sizeof(uuid->node)); |
| } |
| |
| void SoundTriggerHalHidl::convertPropertiesFromHal( |
| struct sound_trigger_properties *properties, |
| const ISoundTriggerHw::Properties *halProperties) |
| { |
| strlcpy(properties->implementor, |
| halProperties->implementor.c_str(), SOUND_TRIGGER_MAX_STRING_LEN); |
| strlcpy(properties->description, |
| halProperties->description.c_str(), SOUND_TRIGGER_MAX_STRING_LEN); |
| properties->version = halProperties->version; |
| convertUuidFromHal(&properties->uuid, &halProperties->uuid); |
| properties->max_sound_models = halProperties->maxSoundModels; |
| properties->max_key_phrases = halProperties->maxKeyPhrases; |
| properties->max_users = halProperties->maxUsers; |
| properties->recognition_modes = halProperties->recognitionModes; |
| properties->capture_transition = (bool)halProperties->captureTransition; |
| properties->max_buffer_ms = halProperties->maxBufferMs; |
| properties->concurrent_capture = (bool)halProperties->concurrentCapture; |
| properties->trigger_in_event = (bool)halProperties->triggerInEvent; |
| properties->power_consumption_mw = halProperties->powerConsumptionMw; |
| } |
| |
| void SoundTriggerHalHidl::convertTriggerPhraseToHal( |
| ISoundTriggerHw::Phrase *halTriggerPhrase, |
| const struct sound_trigger_phrase *triggerPhrase) |
| { |
| halTriggerPhrase->id = triggerPhrase->id; |
| halTriggerPhrase->recognitionModes = triggerPhrase->recognition_mode; |
| halTriggerPhrase->users.setToExternal((uint32_t *)&triggerPhrase->users[0], triggerPhrase->num_users); |
| halTriggerPhrase->locale = triggerPhrase->locale; |
| halTriggerPhrase->text = triggerPhrase->text; |
| } |
| |
| |
| void SoundTriggerHalHidl::convertTriggerPhrasesToHal( |
| hidl_vec<ISoundTriggerHw::Phrase> *halTriggerPhrases, |
| struct sound_trigger_phrase_sound_model *keyPhraseModel) |
| { |
| halTriggerPhrases->resize(keyPhraseModel->num_phrases); |
| for (unsigned int i = 0; i < keyPhraseModel->num_phrases; i++) { |
| convertTriggerPhraseToHal(&(*halTriggerPhrases)[i], &keyPhraseModel->phrases[i]); |
| } |
| } |
| |
| void SoundTriggerHalHidl::convertSoundModelToHal(ISoundTriggerHw::SoundModel *halModel, |
| const struct sound_trigger_sound_model *soundModel) |
| { |
| halModel->type = (SoundModelType)soundModel->type; |
| convertUuidToHal(&halModel->uuid, &soundModel->uuid); |
| convertUuidToHal(&halModel->vendorUuid, &soundModel->vendor_uuid); |
| halModel->data.setToExternal((uint8_t *)soundModel + soundModel->data_offset, soundModel->data_size); |
| } |
| |
| std::pair<bool, sp<IMemory>> SoundTriggerHalHidl::convertSoundModelToHal( |
| V2_1_ISoundTriggerHw::SoundModel *halModel, |
| const struct sound_trigger_sound_model *soundModel) |
| { |
| convertSoundModelToHal(&halModel->header, soundModel); |
| return moveVectorToMemory(&halModel->header.data, &halModel->data); |
| } |
| |
| void SoundTriggerHalHidl::convertPhraseSoundModelToHal( |
| ISoundTriggerHw::PhraseSoundModel *halKeyPhraseModel, |
| const struct sound_trigger_sound_model *soundModel) |
| { |
| struct sound_trigger_phrase_sound_model *keyPhraseModel = |
| (struct sound_trigger_phrase_sound_model *)soundModel; |
| convertTriggerPhrasesToHal(&halKeyPhraseModel->phrases, keyPhraseModel); |
| convertSoundModelToHal(&halKeyPhraseModel->common, soundModel); |
| } |
| |
| std::pair<bool, sp<IMemory>> SoundTriggerHalHidl::convertPhraseSoundModelToHal( |
| V2_1_ISoundTriggerHw::PhraseSoundModel *halKeyPhraseModel, |
| const struct sound_trigger_sound_model *soundModel) |
| { |
| struct sound_trigger_phrase_sound_model *keyPhraseModel = |
| (struct sound_trigger_phrase_sound_model *)soundModel; |
| convertTriggerPhrasesToHal(&halKeyPhraseModel->phrases, keyPhraseModel); |
| return convertSoundModelToHal(&halKeyPhraseModel->common, soundModel); |
| } |
| |
| void SoundTriggerHalHidl::convertPhraseRecognitionExtraToHal( |
| PhraseRecognitionExtra *halExtra, |
| const struct sound_trigger_phrase_recognition_extra *extra) |
| { |
| halExtra->id = extra->id; |
| halExtra->recognitionModes = extra->recognition_modes; |
| halExtra->confidenceLevel = extra->confidence_level; |
| halExtra->levels.resize(extra->num_levels); |
| for (unsigned int i = 0; i < extra->num_levels; i++) { |
| halExtra->levels[i].userId = extra->levels[i].user_id; |
| halExtra->levels[i].levelPercent = extra->levels[i].level; |
| } |
| } |
| |
| void SoundTriggerHalHidl::convertRecognitionConfigToHal( |
| ISoundTriggerHw::RecognitionConfig *halConfig, |
| const struct sound_trigger_recognition_config *config) |
| { |
| halConfig->captureHandle = config->capture_handle; |
| halConfig->captureDevice = (AudioDevice)config->capture_device; |
| halConfig->captureRequested = (uint32_t)config->capture_requested; |
| |
| halConfig->phrases.resize(config->num_phrases); |
| for (unsigned int i = 0; i < config->num_phrases; i++) { |
| convertPhraseRecognitionExtraToHal(&halConfig->phrases[i], |
| &config->phrases[i]); |
| } |
| |
| halConfig->data.setToExternal((uint8_t *)config + config->data_offset, config->data_size); |
| } |
| |
| std::pair<bool, sp<IMemory>> SoundTriggerHalHidl::convertRecognitionConfigToHal( |
| V2_1_ISoundTriggerHw::RecognitionConfig *halConfig, |
| const struct sound_trigger_recognition_config *config) |
| { |
| convertRecognitionConfigToHal(&halConfig->header, config); |
| return moveVectorToMemory(&halConfig->header.data, &halConfig->data); |
| } |
| |
| |
| // ISoundTriggerHwCallback |
| ::android::hardware::Return<void> SoundTriggerHalHidl::recognitionCallback( |
| const V2_0_ISoundTriggerHwCallback::RecognitionEvent& halEvent, |
| CallbackCookie cookie) |
| { |
| sp<SoundModel> model; |
| { |
| AutoMutex lock(mLock); |
| model = mSoundModels.valueFor((SoundModelHandle)cookie); |
| if (model == 0) { |
| return Return<void>(); |
| } |
| } |
| struct sound_trigger_recognition_event *event = convertRecognitionEventFromHal(&halEvent); |
| if (event == NULL) { |
| return Return<void>(); |
| } |
| event->model = model->mHandle; |
| model->mRecognitionCallback(event, model->mRecognitionCookie); |
| |
| free(event); |
| |
| return Return<void>(); |
| } |
| |
| ::android::hardware::Return<void> SoundTriggerHalHidl::phraseRecognitionCallback( |
| const V2_0_ISoundTriggerHwCallback::PhraseRecognitionEvent& halEvent, |
| CallbackCookie cookie) |
| { |
| sp<SoundModel> model; |
| { |
| AutoMutex lock(mLock); |
| model = mSoundModels.valueFor((SoundModelHandle)cookie); |
| if (model == 0) { |
| return Return<void>(); |
| } |
| } |
| |
| struct sound_trigger_phrase_recognition_event *event = |
| convertPhraseRecognitionEventFromHal(&halEvent); |
| if (event == NULL) { |
| return Return<void>(); |
| } |
| event->common.model = model->mHandle; |
| model->mRecognitionCallback(&event->common, model->mRecognitionCookie); |
| |
| free(event); |
| |
| return Return<void>(); |
| } |
| |
| ::android::hardware::Return<void> SoundTriggerHalHidl::soundModelCallback( |
| const V2_0_ISoundTriggerHwCallback::ModelEvent& halEvent, |
| CallbackCookie cookie) |
| { |
| sp<SoundModel> model; |
| { |
| AutoMutex lock(mLock); |
| model = mSoundModels.valueFor((SoundModelHandle)cookie); |
| if (model == 0) { |
| return Return<void>(); |
| } |
| } |
| |
| struct sound_trigger_model_event *event = convertSoundModelEventFromHal(&halEvent); |
| if (event == NULL) { |
| return Return<void>(); |
| } |
| |
| event->model = model->mHandle; |
| model->mSoundModelCallback(event, model->mSoundModelCookie); |
| |
| free(event); |
| |
| return Return<void>(); |
| } |
| |
| ::android::hardware::Return<void> SoundTriggerHalHidl::recognitionCallback_2_1( |
| const ISoundTriggerHwCallback::RecognitionEvent& event, CallbackCookie cookie) { |
| // The data vector in the 'header' part of V2.1 structure is empty, thus copying is cheap. |
| V2_0_ISoundTriggerHwCallback::RecognitionEvent event_2_0 = event.header; |
| auto result = memoryAsVector(event.data, &event_2_0.data); |
| return result.first ? recognitionCallback(event_2_0, cookie) : Void(); |
| } |
| |
| ::android::hardware::Return<void> SoundTriggerHalHidl::phraseRecognitionCallback_2_1( |
| const ISoundTriggerHwCallback::PhraseRecognitionEvent& event, int32_t cookie) { |
| V2_0_ISoundTriggerHwCallback::PhraseRecognitionEvent event_2_0; |
| // The data vector in the 'header' part of V2.1 structure is empty, thus copying is cheap. |
| event_2_0.common = event.common.header; |
| event_2_0.phraseExtras.setToExternal( |
| const_cast<PhraseRecognitionExtra*>(event.phraseExtras.data()), |
| event.phraseExtras.size()); |
| auto result = memoryAsVector(event.common.data, &event_2_0.common.data); |
| return result.first ? phraseRecognitionCallback(event_2_0, cookie) : Void(); |
| } |
| |
| ::android::hardware::Return<void> SoundTriggerHalHidl::soundModelCallback_2_1( |
| const ISoundTriggerHwCallback::ModelEvent& event, CallbackCookie cookie) { |
| // The data vector in the 'header' part of V2.1 structure is empty, thus copying is cheap. |
| V2_0_ISoundTriggerHwCallback::ModelEvent event_2_0 = event.header; |
| auto result = memoryAsVector(event.data, &event_2_0.data); |
| return result.first ? soundModelCallback(event_2_0, cookie) : Void(); |
| } |
| |
| |
| struct sound_trigger_model_event *SoundTriggerHalHidl::convertSoundModelEventFromHal( |
| const V2_0_ISoundTriggerHwCallback::ModelEvent *halEvent) |
| { |
| struct sound_trigger_model_event *event = (struct sound_trigger_model_event *)malloc( |
| sizeof(struct sound_trigger_model_event) + |
| halEvent->data.size()); |
| if (event == NULL) { |
| return NULL; |
| } |
| |
| event->status = (int)halEvent->status; |
| // event->model to be set by caller |
| event->data_offset = sizeof(struct sound_trigger_model_event); |
| event->data_size = halEvent->data.size(); |
| uint8_t *dst = (uint8_t *)event + event->data_offset; |
| uint8_t *src = (uint8_t *)&halEvent->data[0]; |
| memcpy(dst, src, halEvent->data.size()); |
| |
| return event; |
| } |
| |
| void SoundTriggerHalHidl::convertPhraseRecognitionExtraFromHal( |
| struct sound_trigger_phrase_recognition_extra *extra, |
| const PhraseRecognitionExtra *halExtra) |
| { |
| extra->id = halExtra->id; |
| extra->recognition_modes = halExtra->recognitionModes; |
| extra->confidence_level = halExtra->confidenceLevel; |
| |
| size_t i; |
| for (i = 0; i < halExtra->levels.size() && i < SOUND_TRIGGER_MAX_USERS; i++) { |
| extra->levels[i].user_id = halExtra->levels[i].userId; |
| extra->levels[i].level = halExtra->levels[i].levelPercent; |
| } |
| extra->num_levels = (unsigned int)i; |
| } |
| |
| |
| struct sound_trigger_phrase_recognition_event* SoundTriggerHalHidl::convertPhraseRecognitionEventFromHal( |
| const V2_0_ISoundTriggerHwCallback::PhraseRecognitionEvent *halPhraseEvent) |
| { |
| if (halPhraseEvent->common.type != SoundModelType::KEYPHRASE) { |
| ALOGE("Received non-keyphrase event type as PhraseRecognitionEvent"); |
| return NULL; |
| } |
| struct sound_trigger_phrase_recognition_event *phraseEvent = |
| (struct sound_trigger_phrase_recognition_event *)malloc( |
| sizeof(struct sound_trigger_phrase_recognition_event) + |
| halPhraseEvent->common.data.size()); |
| if (phraseEvent == NULL) { |
| return NULL; |
| } |
| phraseEvent->common.data_offset = sizeof(sound_trigger_phrase_recognition_event); |
| |
| for (unsigned int i = 0; i < halPhraseEvent->phraseExtras.size(); i++) { |
| convertPhraseRecognitionExtraFromHal(&phraseEvent->phrase_extras[i], |
| &halPhraseEvent->phraseExtras[i]); |
| } |
| phraseEvent->num_phrases = halPhraseEvent->phraseExtras.size(); |
| |
| fillRecognitionEventFromHal(&phraseEvent->common, &halPhraseEvent->common); |
| return phraseEvent; |
| } |
| |
| struct sound_trigger_recognition_event *SoundTriggerHalHidl::convertRecognitionEventFromHal( |
| const V2_0_ISoundTriggerHwCallback::RecognitionEvent *halEvent) |
| { |
| if (halEvent->type == SoundModelType::KEYPHRASE) { |
| ALOGE("Received keyphrase event type as RecognitionEvent"); |
| return NULL; |
| } |
| struct sound_trigger_recognition_event *event; |
| event = (struct sound_trigger_recognition_event *)malloc( |
| sizeof(struct sound_trigger_recognition_event) + halEvent->data.size()); |
| if (event == NULL) { |
| return NULL; |
| } |
| event->data_offset = sizeof(sound_trigger_recognition_event); |
| |
| fillRecognitionEventFromHal(event, halEvent); |
| return event; |
| } |
| |
| void SoundTriggerHalHidl::fillRecognitionEventFromHal( |
| struct sound_trigger_recognition_event *event, |
| const V2_0_ISoundTriggerHwCallback::RecognitionEvent *halEvent) |
| { |
| event->status = (int)halEvent->status; |
| event->type = (sound_trigger_sound_model_type_t)halEvent->type; |
| // event->model to be set by caller |
| event->capture_available = (bool)halEvent->captureAvailable; |
| event->capture_session = halEvent->captureSession; |
| event->capture_delay_ms = halEvent->captureDelayMs; |
| event->capture_preamble_ms = halEvent->capturePreambleMs; |
| event->trigger_in_data = (bool)halEvent->triggerInData; |
| event->audio_config.sample_rate = halEvent->audioConfig.sampleRateHz; |
| event->audio_config.channel_mask = (audio_channel_mask_t)halEvent->audioConfig.channelMask; |
| event->audio_config.format = (audio_format_t)halEvent->audioConfig.format; |
| |
| event->data_size = halEvent->data.size(); |
| uint8_t *dst = (uint8_t *)event + event->data_offset; |
| uint8_t *src = (uint8_t *)&halEvent->data[0]; |
| memcpy(dst, src, halEvent->data.size()); |
| } |
| |
| } // namespace android |
