Home | History | Annotate | Download | only in impl 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #define LOG_TAG "EffectHalHidl"
     18 //#define LOG_NDEBUG 0
     19 
     20 #include <common/all-versions/VersionUtils.h>
     21 #include <cutils/native_handle.h>
     22 #include <hwbinder/IPCThreadState.h>
     23 #include <media/EffectsFactoryApi.h>
     24 #include <utils/Log.h>
     25 
     26 #include "EffectBufferHalHidl.h"
     27 #include "EffectHalHidl.h"
     28 #include "HidlUtils.h"
     29 
     30 using ::android::hardware::audio::common::CPP_VERSION::implementation::HidlUtils;
     31 using ::android::hardware::audio::common::utils::EnumBitfield;
     32 using ::android::hardware::hidl_vec;
     33 using ::android::hardware::MQDescriptorSync;
     34 using ::android::hardware::Return;
     35 
     36 namespace android {
     37 namespace effect {
     38 namespace CPP_VERSION {
     39 
     40 using namespace ::android::hardware::audio::common::CPP_VERSION;
     41 using namespace ::android::hardware::audio::effect::CPP_VERSION;
     42 
     43 EffectHalHidl::EffectHalHidl(const sp<IEffect>& effect, uint64_t effectId)
     44         : mEffect(effect), mEffectId(effectId), mBuffersChanged(true), mEfGroup(nullptr) {
     45 }
     46 
     47 EffectHalHidl::~EffectHalHidl() {
     48     if (mEffect != 0) {
     49         close();
     50         mEffect.clear();
     51         hardware::IPCThreadState::self()->flushCommands();
     52     }
     53     if (mEfGroup) {
     54         EventFlag::deleteEventFlag(&mEfGroup);
     55     }
     56 }
     57 
     58 // static
     59 void EffectHalHidl::effectDescriptorToHal(
     60         const EffectDescriptor& descriptor, effect_descriptor_t* halDescriptor) {
     61     HidlUtils::uuidToHal(descriptor.type, &halDescriptor->type);
     62     HidlUtils::uuidToHal(descriptor.uuid, &halDescriptor->uuid);
     63     halDescriptor->flags = static_cast<uint32_t>(descriptor.flags);
     64     halDescriptor->cpuLoad = descriptor.cpuLoad;
     65     halDescriptor->memoryUsage = descriptor.memoryUsage;
     66     memcpy(halDescriptor->name, descriptor.name.data(), descriptor.name.size());
     67     memcpy(halDescriptor->implementor,
     68             descriptor.implementor.data(), descriptor.implementor.size());
     69 }
     70 
     71 // TODO(mnaganov): These buffer conversion functions should be shared with Effect wrapper
     72 // via HidlUtils. Move them there when hardware/interfaces will get un-frozen again.
     73 
     74 // static
     75 void EffectHalHidl::effectBufferConfigFromHal(
     76         const buffer_config_t& halConfig, EffectBufferConfig* config) {
     77     config->samplingRateHz = halConfig.samplingRate;
     78     config->channels = EnumBitfield<AudioChannelMask>(halConfig.channels);
     79     config->format = AudioFormat(halConfig.format);
     80     config->accessMode = EffectBufferAccess(halConfig.accessMode);
     81     config->mask = EnumBitfield<EffectConfigParameters>(halConfig.mask);
     82 }
     83 
     84 // static
     85 void EffectHalHidl::effectBufferConfigToHal(
     86         const EffectBufferConfig& config, buffer_config_t* halConfig) {
     87     halConfig->buffer.frameCount = 0;
     88     halConfig->buffer.raw = NULL;
     89     halConfig->samplingRate = config.samplingRateHz;
     90     halConfig->channels = static_cast<uint32_t>(config.channels);
     91     halConfig->bufferProvider.cookie = NULL;
     92     halConfig->bufferProvider.getBuffer = NULL;
     93     halConfig->bufferProvider.releaseBuffer = NULL;
     94     halConfig->format = static_cast<uint8_t>(config.format);
     95     halConfig->accessMode = static_cast<uint8_t>(config.accessMode);
     96     halConfig->mask = static_cast<uint8_t>(config.mask);
     97 }
     98 
     99 // static
    100 void EffectHalHidl::effectConfigFromHal(const effect_config_t& halConfig, EffectConfig* config) {
    101     effectBufferConfigFromHal(halConfig.inputCfg, &config->inputCfg);
    102     effectBufferConfigFromHal(halConfig.outputCfg, &config->outputCfg);
    103 }
    104 
    105 // static
    106 void EffectHalHidl::effectConfigToHal(const EffectConfig& config, effect_config_t* halConfig) {
    107     effectBufferConfigToHal(config.inputCfg, &halConfig->inputCfg);
    108     effectBufferConfigToHal(config.outputCfg, &halConfig->outputCfg);
    109 }
    110 
    111 // static
    112 status_t EffectHalHidl::analyzeResult(const Result& result) {
    113     switch (result) {
    114         case Result::OK: return OK;
    115         case Result::INVALID_ARGUMENTS: return BAD_VALUE;
    116         case Result::INVALID_STATE: return NOT_ENOUGH_DATA;
    117         case Result::NOT_INITIALIZED: return NO_INIT;
    118         case Result::NOT_SUPPORTED: return INVALID_OPERATION;
    119         case Result::RESULT_TOO_BIG: return NO_MEMORY;
    120         default: return NO_INIT;
    121     }
    122 }
    123 
    124 status_t EffectHalHidl::setInBuffer(const sp<EffectBufferHalInterface>& buffer) {
    125     if (!mBuffersChanged) {
    126         if (buffer.get() == nullptr || mInBuffer.get() == nullptr) {
    127             mBuffersChanged = buffer.get() != mInBuffer.get();
    128         } else {
    129             mBuffersChanged = buffer->audioBuffer() != mInBuffer->audioBuffer();
    130         }
    131     }
    132     mInBuffer = buffer;
    133     return OK;
    134 }
    135 
    136 status_t EffectHalHidl::setOutBuffer(const sp<EffectBufferHalInterface>& buffer) {
    137     if (!mBuffersChanged) {
    138         if (buffer.get() == nullptr || mOutBuffer.get() == nullptr) {
    139             mBuffersChanged = buffer.get() != mOutBuffer.get();
    140         } else {
    141             mBuffersChanged = buffer->audioBuffer() != mOutBuffer->audioBuffer();
    142         }
    143     }
    144     mOutBuffer = buffer;
    145     return OK;
    146 }
    147 
    148 status_t EffectHalHidl::process() {
    149     return processImpl(static_cast<uint32_t>(MessageQueueFlagBits::REQUEST_PROCESS));
    150 }
    151 
    152 status_t EffectHalHidl::processReverse() {
    153     return processImpl(static_cast<uint32_t>(MessageQueueFlagBits::REQUEST_PROCESS_REVERSE));
    154 }
    155 
    156 status_t EffectHalHidl::prepareForProcessing() {
    157     std::unique_ptr<StatusMQ> tempStatusMQ;
    158     Result retval;
    159     Return<void> ret = mEffect->prepareForProcessing(
    160             [&](Result r, const MQDescriptorSync<Result>& statusMQ) {
    161                 retval = r;
    162                 if (retval == Result::OK) {
    163                     tempStatusMQ.reset(new StatusMQ(statusMQ));
    164                     if (tempStatusMQ->isValid() && tempStatusMQ->getEventFlagWord()) {
    165                         EventFlag::createEventFlag(tempStatusMQ->getEventFlagWord(), &mEfGroup);
    166                     }
    167                 }
    168             });
    169     if (!ret.isOk() || retval != Result::OK) {
    170         return ret.isOk() ? analyzeResult(retval) : FAILED_TRANSACTION;
    171     }
    172     if (!tempStatusMQ || !tempStatusMQ->isValid() || !mEfGroup) {
    173         ALOGE_IF(!tempStatusMQ, "Failed to obtain status message queue for effects");
    174         ALOGE_IF(tempStatusMQ && !tempStatusMQ->isValid(),
    175                 "Status message queue for effects is invalid");
    176         ALOGE_IF(!mEfGroup, "Event flag creation for effects failed");
    177         return NO_INIT;
    178     }
    179     mStatusMQ = std::move(tempStatusMQ);
    180     return OK;
    181 }
    182 
    183 bool EffectHalHidl::needToResetBuffers() {
    184     if (mBuffersChanged) return true;
    185     bool inBufferFrameCountUpdated = mInBuffer->checkFrameCountChange();
    186     bool outBufferFrameCountUpdated = mOutBuffer->checkFrameCountChange();
    187     return inBufferFrameCountUpdated || outBufferFrameCountUpdated;
    188 }
    189 
    190 status_t EffectHalHidl::processImpl(uint32_t mqFlag) {
    191     if (mEffect == 0 || mInBuffer == 0 || mOutBuffer == 0) return NO_INIT;
    192     status_t status;
    193     if (!mStatusMQ && (status = prepareForProcessing()) != OK) {
    194         return status;
    195     }
    196     if (needToResetBuffers() && (status = setProcessBuffers()) != OK) {
    197         return status;
    198     }
    199     // The data is already in the buffers, just need to flush it and wake up the server side.
    200     std::atomic_thread_fence(std::memory_order_release);
    201     mEfGroup->wake(mqFlag);
    202     uint32_t efState = 0;
    203 retry:
    204     status_t ret = mEfGroup->wait(
    205             static_cast<uint32_t>(MessageQueueFlagBits::DONE_PROCESSING), &efState);
    206     if (efState & static_cast<uint32_t>(MessageQueueFlagBits::DONE_PROCESSING)) {
    207         Result retval = Result::NOT_INITIALIZED;
    208         mStatusMQ->read(&retval);
    209         if (retval == Result::OK || retval == Result::INVALID_STATE) {
    210             // Sync back the changed contents of the buffer.
    211             std::atomic_thread_fence(std::memory_order_acquire);
    212         }
    213         return analyzeResult(retval);
    214     }
    215     if (ret == -EAGAIN || ret == -EINTR) {
    216         // Spurious wakeup. This normally retries no more than once.
    217         goto retry;
    218     }
    219     return ret;
    220 }
    221 
    222 status_t EffectHalHidl::setProcessBuffers() {
    223     Return<Result> ret = mEffect->setProcessBuffers(
    224             static_cast<EffectBufferHalHidl*>(mInBuffer.get())->hidlBuffer(),
    225             static_cast<EffectBufferHalHidl*>(mOutBuffer.get())->hidlBuffer());
    226     if (ret.isOk() && ret == Result::OK) {
    227         mBuffersChanged = false;
    228         return OK;
    229     }
    230     return ret.isOk() ? analyzeResult(ret) : FAILED_TRANSACTION;
    231 }
    232 
    233 status_t EffectHalHidl::command(uint32_t cmdCode, uint32_t cmdSize, void *pCmdData,
    234         uint32_t *replySize, void *pReplyData) {
    235     if (mEffect == 0) return NO_INIT;
    236 
    237     // Special cases.
    238     if (cmdCode == EFFECT_CMD_SET_CONFIG || cmdCode == EFFECT_CMD_SET_CONFIG_REVERSE) {
    239         return setConfigImpl(cmdCode, cmdSize, pCmdData, replySize, pReplyData);
    240     } else if (cmdCode == EFFECT_CMD_GET_CONFIG || cmdCode == EFFECT_CMD_GET_CONFIG_REVERSE) {
    241         return getConfigImpl(cmdCode, replySize, pReplyData);
    242     }
    243 
    244     // Common case.
    245     hidl_vec<uint8_t> hidlData;
    246     if (pCmdData != nullptr && cmdSize > 0) {
    247         hidlData.setToExternal(reinterpret_cast<uint8_t*>(pCmdData), cmdSize);
    248     }
    249     status_t status;
    250     uint32_t replySizeStub = 0;
    251     if (replySize == nullptr || pReplyData == nullptr) replySize = &replySizeStub;
    252     Return<void> ret = mEffect->command(cmdCode, hidlData, *replySize,
    253             [&](int32_t s, const hidl_vec<uint8_t>& result) {
    254                 status = s;
    255                 if (status == 0) {
    256                     if (*replySize > result.size()) *replySize = result.size();
    257                     if (pReplyData != nullptr && *replySize > 0) {
    258                         memcpy(pReplyData, &result[0], *replySize);
    259                     }
    260                 }
    261             });
    262     return ret.isOk() ? status : FAILED_TRANSACTION;
    263 }
    264 
    265 status_t EffectHalHidl::getDescriptor(effect_descriptor_t *pDescriptor) {
    266     if (mEffect == 0) return NO_INIT;
    267     Result retval = Result::NOT_INITIALIZED;
    268     Return<void> ret = mEffect->getDescriptor(
    269             [&](Result r, const EffectDescriptor& result) {
    270                 retval = r;
    271                 if (retval == Result::OK) {
    272                     effectDescriptorToHal(result, pDescriptor);
    273                 }
    274             });
    275     return ret.isOk() ? analyzeResult(retval) : FAILED_TRANSACTION;
    276 }
    277 
    278 status_t EffectHalHidl::close() {
    279     if (mEffect == 0) return NO_INIT;
    280     Return<Result> ret = mEffect->close();
    281     return ret.isOk() ? analyzeResult(ret) : FAILED_TRANSACTION;
    282 }
    283 
    284 status_t EffectHalHidl::dump(int fd) {
    285     if (mEffect == 0) return NO_INIT;
    286     native_handle_t* hidlHandle = native_handle_create(1, 0);
    287     hidlHandle->data[0] = fd;
    288     Return<void> ret = mEffect->debug(hidlHandle, {} /* options */);
    289     native_handle_delete(hidlHandle);
    290     return ret.isOk() ? OK : FAILED_TRANSACTION;
    291 }
    292 
    293 status_t EffectHalHidl::getConfigImpl(
    294         uint32_t cmdCode, uint32_t *replySize, void *pReplyData) {
    295     if (replySize == NULL || *replySize != sizeof(effect_config_t) || pReplyData == NULL) {
    296         return BAD_VALUE;
    297     }
    298     status_t result = FAILED_TRANSACTION;
    299     Return<void> ret;
    300     if (cmdCode == EFFECT_CMD_GET_CONFIG) {
    301         ret = mEffect->getConfig([&] (Result r, const EffectConfig &hidlConfig) {
    302             result = analyzeResult(r);
    303             if (r == Result::OK) {
    304                 effectConfigToHal(hidlConfig, static_cast<effect_config_t*>(pReplyData));
    305             }
    306         });
    307     } else {
    308         ret = mEffect->getConfigReverse([&] (Result r, const EffectConfig &hidlConfig) {
    309             result = analyzeResult(r);
    310             if (r == Result::OK) {
    311                 effectConfigToHal(hidlConfig, static_cast<effect_config_t*>(pReplyData));
    312             }
    313         });
    314     }
    315     if (!ret.isOk()) {
    316         result = FAILED_TRANSACTION;
    317     }
    318     return result;
    319 }
    320 
    321 status_t EffectHalHidl::setConfigImpl(
    322         uint32_t cmdCode, uint32_t cmdSize, void *pCmdData, uint32_t *replySize, void *pReplyData) {
    323     if (pCmdData == NULL || cmdSize != sizeof(effect_config_t) ||
    324             replySize == NULL || *replySize != sizeof(int32_t) || pReplyData == NULL) {
    325         return BAD_VALUE;
    326     }
    327     const effect_config_t *halConfig = static_cast<effect_config_t*>(pCmdData);
    328     if (halConfig->inputCfg.bufferProvider.getBuffer != NULL ||
    329             halConfig->inputCfg.bufferProvider.releaseBuffer != NULL ||
    330             halConfig->outputCfg.bufferProvider.getBuffer != NULL ||
    331             halConfig->outputCfg.bufferProvider.releaseBuffer != NULL) {
    332         ALOGE("Buffer provider callbacks are not supported");
    333     }
    334     EffectConfig hidlConfig;
    335     effectConfigFromHal(*halConfig, &hidlConfig);
    336     Return<Result> ret = cmdCode == EFFECT_CMD_SET_CONFIG ?
    337             mEffect->setConfig(hidlConfig, nullptr, nullptr) :
    338             mEffect->setConfigReverse(hidlConfig, nullptr, nullptr);
    339     status_t result = FAILED_TRANSACTION;
    340     if (ret.isOk()) {
    341         result = analyzeResult(ret);
    342         *static_cast<int32_t*>(pReplyData) = result;
    343     }
    344     return result;
    345 }
    346 
    347 } // namespace CPP_VERSION
    348 } // namespace effect
    349 } // namespace android
    350