diff options
author | Mikhail Naganov <mnaganov@google.com> | 2017-12-28 11:02:10 -0800 |
---|---|---|
committer | Mikhail Naganov <mnaganov@google.com> | 2018-01-17 09:31:57 -0800 |
commit | 2b228bb37858a48df1a01754c24fa8a29bb2a6de (patch) | |
tree | 5773ba55e7a50da4e08a40f63fc2d51a95030a6e /soundtrigger | |
parent | dfdc3bbccdeb48a747b073a0825d1aa6277e9c1f (diff) | |
download | android_hardware_interfaces-2b228bb37858a48df1a01754c24fa8a29bb2a6de.tar.gz android_hardware_interfaces-2b228bb37858a48df1a01754c24fa8a29bb2a6de.tar.bz2 android_hardware_interfaces-2b228bb37858a48df1a01754c24fa8a29bb2a6de.zip |
soundtrigger: Default implementation for version 2.1
Wrapped around the 2.0 default implementation. Added functionality
for retrieving and sending the data via shared memory.
Bug: 68823037
Test: compiles
Change-Id: Ie38dd261dc8c635462a7e2ee26672a83af915e84
Diffstat (limited to 'soundtrigger')
-rw-r--r-- | soundtrigger/2.1/default/Android.mk | 49 | ||||
-rw-r--r-- | soundtrigger/2.1/default/SoundTriggerHw.cpp | 194 | ||||
-rw-r--r-- | soundtrigger/2.1/default/SoundTriggerHw.h | 152 |
3 files changed, 395 insertions, 0 deletions
diff --git a/soundtrigger/2.1/default/Android.mk b/soundtrigger/2.1/default/Android.mk new file mode 100644 index 000000000..5851d63ed --- /dev/null +++ b/soundtrigger/2.1/default/Android.mk @@ -0,0 +1,49 @@ +# +# Copyright (C) 2018 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. + + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) +LOCAL_MODULE := android.hardware.soundtrigger@2.1-impl +LOCAL_VENDOR_MODULE := true +LOCAL_MODULE_RELATIVE_PATH := hw +LOCAL_SRC_FILES := \ + SoundTriggerHw.cpp + +LOCAL_CFLAGS := -Wall -Werror + +LOCAL_SHARED_LIBRARIES := \ + libhardware \ + libhidlbase \ + libhidlmemory \ + libhidltransport \ + liblog \ + libutils \ + android.hardware.soundtrigger@2.1 \ + android.hardware.soundtrigger@2.0 \ + android.hardware.soundtrigger@2.0-core \ + android.hidl.allocator@1.0 \ + android.hidl.memory@1.0 + +LOCAL_C_INCLUDE_DIRS := $(LOCAL_PATH) + +ifeq ($(strip $(AUDIOSERVER_MULTILIB)),) +LOCAL_MULTILIB := 32 +else +LOCAL_MULTILIB := $(AUDIOSERVER_MULTILIB) +endif + +include $(BUILD_SHARED_LIBRARY) diff --git a/soundtrigger/2.1/default/SoundTriggerHw.cpp b/soundtrigger/2.1/default/SoundTriggerHw.cpp new file mode 100644 index 000000000..246d2bc66 --- /dev/null +++ b/soundtrigger/2.1/default/SoundTriggerHw.cpp @@ -0,0 +1,194 @@ +/* + * Copyright (C) 2018 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 "SoundTriggerHw" + +#include "SoundTriggerHw.h" + +#include <utility> + +#include <android/hidl/allocator/1.0/IAllocator.h> +#include <android/log.h> +#include <hidlmemory/mapping.h> + +using android::hardware::hidl_memory; +using android::hidl::allocator::V1_0::IAllocator; +using android::hidl::memory::V1_0::IMemory; + +namespace android { +namespace hardware { +namespace soundtrigger { +namespace V2_1 { +namespace implementation { + +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 + +Return<void> SoundTriggerHw::loadSoundModel_2_1( + const V2_1::ISoundTriggerHw::SoundModel& soundModel, + const sp<V2_1::ISoundTriggerHwCallback>& callback, int32_t cookie, + V2_1::ISoundTriggerHw::loadSoundModel_2_1_cb _hidl_cb) { + // It is assumed that legacy data vector is empty, thus making copy is cheap. + V2_0::ISoundTriggerHw::SoundModel soundModel_2_0(soundModel.header); + auto result = memoryAsVector(soundModel.data, &soundModel_2_0.data); + if (result.first) { + sp<SoundModelClient> client = + new SoundModelClient_2_1(nextUniqueModelId(), cookie, callback); + _hidl_cb(doLoadSoundModel(soundModel_2_0, client), client->getId()); + return Void(); + } + _hidl_cb(-ENOMEM, 0); + return Void(); +} + +Return<void> SoundTriggerHw::loadPhraseSoundModel_2_1( + const V2_1::ISoundTriggerHw::PhraseSoundModel& soundModel, + const sp<V2_1::ISoundTriggerHwCallback>& callback, int32_t cookie, + V2_1::ISoundTriggerHw::loadPhraseSoundModel_2_1_cb _hidl_cb) { + V2_0::ISoundTriggerHw::PhraseSoundModel soundModel_2_0; + // It is assumed that legacy data vector is empty, thus making copy is cheap. + soundModel_2_0.common = soundModel.common.header; + // Avoid copying phrases data. + soundModel_2_0.phrases.setToExternal( + const_cast<V2_0::ISoundTriggerHw::Phrase*>(soundModel.phrases.data()), + soundModel.phrases.size()); + auto result = memoryAsVector(soundModel.common.data, &soundModel_2_0.common.data); + if (result.first) { + sp<SoundModelClient> client = + new SoundModelClient_2_1(nextUniqueModelId(), cookie, callback); + _hidl_cb(doLoadSoundModel((const V2_0::ISoundTriggerHw::SoundModel&)soundModel_2_0, client), + client->getId()); + return Void(); + } + _hidl_cb(-ENOMEM, 0); + return Void(); +} + +Return<int32_t> SoundTriggerHw::startRecognition_2_1( + int32_t modelHandle, const V2_1::ISoundTriggerHw::RecognitionConfig& config) { + // It is assumed that legacy data vector is empty, thus making copy is cheap. + V2_0::ISoundTriggerHw::RecognitionConfig config_2_0(config.header); + auto result = memoryAsVector(config.data, &config_2_0.data); + return result.first ? startRecognition(modelHandle, config_2_0) : Return<int32_t>(-ENOMEM); +} + +void SoundTriggerHw::SoundModelClient_2_1::recognitionCallback( + struct sound_trigger_recognition_event* halEvent) { + if (halEvent->type == SOUND_MODEL_TYPE_KEYPHRASE) { + V2_0::ISoundTriggerHwCallback::PhraseRecognitionEvent event_2_0; + convertPhaseRecognitionEventFromHal( + &event_2_0, reinterpret_cast<sound_trigger_phrase_recognition_event*>(halEvent)); + event_2_0.common.model = mId; + V2_1::ISoundTriggerHwCallback::PhraseRecognitionEvent event; + event.phraseExtras.setToExternal(event_2_0.phraseExtras.data(), + event_2_0.phraseExtras.size()); + auto result = moveVectorToMemory(&event_2_0.common.data, &event.common.data); + if (result.first) { + // The data vector is now empty, thus copying is cheap. + event.common.header = event_2_0.common; + mCallback->phraseRecognitionCallback_2_1(event, mCookie); + } + } else { + V2_1::ISoundTriggerHwCallback::RecognitionEvent event; + convertRecognitionEventFromHal(&event.header, halEvent); + event.header.model = mId; + auto result = moveVectorToMemory(&event.header.data, &event.data); + if (result.first) { + mCallback->recognitionCallback_2_1(event, mCookie); + } + } +} + +void SoundTriggerHw::SoundModelClient_2_1::soundModelCallback( + struct sound_trigger_model_event* halEvent) { + V2_1::ISoundTriggerHwCallback::ModelEvent event; + convertSoundModelEventFromHal(&event.header, halEvent); + event.header.model = mId; + auto result = moveVectorToMemory(&event.header.data, &event.data); + if (result.first) { + mCallback->soundModelCallback_2_1(event, mCookie); + } +} + +ISoundTriggerHw* HIDL_FETCH_ISoundTriggerHw(const char* /* name */) { + return (new SoundTriggerHw())->getInterface(); +} + +} // namespace implementation +} // namespace V2_1 +} // namespace soundtrigger +} // namespace hardware +} // namespace android diff --git a/soundtrigger/2.1/default/SoundTriggerHw.h b/soundtrigger/2.1/default/SoundTriggerHw.h new file mode 100644 index 000000000..855d1a6f9 --- /dev/null +++ b/soundtrigger/2.1/default/SoundTriggerHw.h @@ -0,0 +1,152 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_HARDWARE_SOUNDTRIGGER_V2_1_SOUNDTRIGGERHW_H +#define ANDROID_HARDWARE_SOUNDTRIGGER_V2_1_SOUNDTRIGGERHW_H + +#include <SoundTriggerHalImpl.h> +#include <android/hardware/soundtrigger/2.1/ISoundTriggerHw.h> +#include <hidl/Status.h> + +namespace android { +namespace hardware { +namespace soundtrigger { +namespace V2_1 { +namespace implementation { + +using ::android::sp; +using ::android::hardware::hidl_string; +using ::android::hardware::hidl_vec; +using ::android::hardware::Return; +using ::android::hardware::Void; + +struct SoundTriggerHw : public V2_0::implementation::SoundTriggerHalImpl { + SoundTriggerHw() = default; + ISoundTriggerHw* getInterface() { return new TrampolineSoundTriggerHw_2_1(this); } + + protected: + virtual ~SoundTriggerHw() = default; + + Return<void> loadSoundModel_2_1(const V2_1::ISoundTriggerHw::SoundModel& soundModel, + const sp<V2_1::ISoundTriggerHwCallback>& callback, + int32_t cookie, + V2_1::ISoundTriggerHw::loadSoundModel_2_1_cb _hidl_cb); + Return<void> loadPhraseSoundModel_2_1( + const V2_1::ISoundTriggerHw::PhraseSoundModel& soundModel, + const sp<V2_1::ISoundTriggerHwCallback>& callback, int32_t cookie, + V2_1::ISoundTriggerHw::loadPhraseSoundModel_2_1_cb _hidl_cb); + Return<int32_t> startRecognition_2_1(int32_t modelHandle, + const V2_1::ISoundTriggerHw::RecognitionConfig& config); + + private: + struct TrampolineSoundTriggerHw_2_1 : public ISoundTriggerHw { + explicit TrampolineSoundTriggerHw_2_1(sp<SoundTriggerHw> impl) : mImpl(impl) {} + + // Methods from ::android::hardware::soundtrigger::V2_0::ISoundTriggerHw follow. + Return<void> getProperties(getProperties_cb _hidl_cb) override { + return mImpl->getProperties(_hidl_cb); + } + Return<void> loadSoundModel(const V2_0::ISoundTriggerHw::SoundModel& soundModel, + const sp<V2_0::ISoundTriggerHwCallback>& callback, + int32_t cookie, loadSoundModel_cb _hidl_cb) override { + return mImpl->loadSoundModel(soundModel, callback, cookie, _hidl_cb); + } + Return<void> loadPhraseSoundModel(const V2_0::ISoundTriggerHw::PhraseSoundModel& soundModel, + const sp<V2_0::ISoundTriggerHwCallback>& callback, + int32_t cookie, + loadPhraseSoundModel_cb _hidl_cb) override { + return mImpl->loadPhraseSoundModel(soundModel, callback, cookie, _hidl_cb); + } + Return<int32_t> unloadSoundModel(V2_0::SoundModelHandle modelHandle) override { + return mImpl->unloadSoundModel(modelHandle); + } + Return<int32_t> startRecognition(int32_t modelHandle, + const V2_0::ISoundTriggerHw::RecognitionConfig& config, + const sp<V2_0::ISoundTriggerHwCallback>& /*callback*/, + int32_t /*cookie*/) override { + return mImpl->startRecognition(modelHandle, config); + } + Return<int32_t> stopRecognition(V2_0::SoundModelHandle modelHandle) override { + return mImpl->stopRecognition(modelHandle); + } + Return<int32_t> stopAllRecognitions() override { return mImpl->stopAllRecognitions(); } + + // Methods from V2_1::ISoundTriggerHw follow. + Return<void> loadSoundModel_2_1(const V2_1::ISoundTriggerHw::SoundModel& soundModel, + const sp<V2_1::ISoundTriggerHwCallback>& callback, + int32_t cookie, loadSoundModel_2_1_cb _hidl_cb) override { + return mImpl->loadSoundModel_2_1(soundModel, callback, cookie, _hidl_cb); + } + Return<void> loadPhraseSoundModel_2_1( + const V2_1::ISoundTriggerHw::PhraseSoundModel& soundModel, + const sp<V2_1::ISoundTriggerHwCallback>& callback, int32_t cookie, + loadPhraseSoundModel_2_1_cb _hidl_cb) override { + return mImpl->loadPhraseSoundModel_2_1(soundModel, callback, cookie, _hidl_cb); + } + Return<int32_t> startRecognition_2_1(int32_t modelHandle, + const V2_1::ISoundTriggerHw::RecognitionConfig& config, + const sp<V2_1::ISoundTriggerHwCallback>& /*callback*/, + int32_t /*cookie*/) override { + return mImpl->startRecognition_2_1(modelHandle, config); + } + Return<void> getParameters(const hidl_vec<hidl_string>& /*keys*/, + getParameters_cb _hidl_cb) override { + _hidl_cb(-ENOSYS, hidl_vec<ParameterValue>()); + return Void(); + } + Return<int32_t> setParameters( + const hidl_vec<V2_1::ISoundTriggerHw::ParameterValue>& /*parameters*/) override { + return -ENOSYS; + } + Return<void> getSoundModelParameters(int32_t /*modelHandle*/, + const hidl_vec<hidl_string>& /*keys*/, + getSoundModelParameters_cb _hidl_cb) override { + _hidl_cb(-ENOSYS, hidl_vec<ParameterValue>()); + return Void(); + } + Return<int32_t> setSoundModelParameters( + int32_t /*modelHandle*/, + const hidl_vec<V2_1::ISoundTriggerHw::ParameterValue>& /*parameters*/) override { + return -ENOSYS; + } + + private: + sp<SoundTriggerHw> mImpl; + }; + + class SoundModelClient_2_1 : public SoundModelClient { + public: + SoundModelClient_2_1(uint32_t id, V2_1::ISoundTriggerHwCallback::CallbackCookie cookie, + sp<V2_1::ISoundTriggerHwCallback> callback) + : SoundModelClient(id, cookie), mCallback(callback) {} + + void recognitionCallback(struct sound_trigger_recognition_event* halEvent) override; + void soundModelCallback(struct sound_trigger_model_event* halEvent) override; + + private: + sp<V2_1::ISoundTriggerHwCallback> mCallback; + }; +}; + +extern "C" ISoundTriggerHw* HIDL_FETCH_ISoundTriggerHw(const char* name); + +} // namespace implementation +} // namespace V2_1 +} // namespace soundtrigger +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_SOUNDTRIGGER_V2_1_SOUNDTRIGGERHW_H |