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