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