1 /*
2 * Copyright (C) 2013 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 "EffectProxy"
18 //#define LOG_NDEBUG 0
19
20 #include <cutils/log.h>
21 #include <assert.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <new>
25 #include <EffectProxy.h>
26 #include <utils/threads.h>
27 #include <media/EffectsFactoryApi.h>
28
29 namespace android {
30 // This is a dummy proxy descriptor just to return to Factory during the initial
31 // GetDescriptor call. Later in the factory, it is replaced with the
32 // SW sub effect descriptor
33 // proxy UUID af8da7e0-2ca1-11e3-b71d-0002a5d5c51b
34 const effect_descriptor_t gProxyDescriptor = {
35 EFFECT_UUID_INITIALIZER, // type
36 {0xaf8da7e0, 0x2ca1, 0x11e3, 0xb71d, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b }}, // uuid
37 EFFECT_CONTROL_API_VERSION, //version of effect control API
38 (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_LAST |
39 EFFECT_FLAG_VOLUME_CTRL), // effect capability flags
40 0, // CPU load
41 1, // Data memory
42 "Proxy", //effect name
43 "AOSP", //implementor name
44 };
45
46
47 static const effect_descriptor_t *const gDescriptors[] =
48 {
49 &gProxyDescriptor,
50 };
51
52
EffectProxyCreate(const effect_uuid_t * uuid,int32_t sessionId,int32_t ioId,effect_handle_t * pHandle)53 int EffectProxyCreate(const effect_uuid_t *uuid,
54 int32_t sessionId,
55 int32_t ioId,
56 effect_handle_t *pHandle) {
57
58 effect_descriptor_t* desc;
59 audio_effect_library_t** aeli;
60 sub_effect_entry_t** sube;
61 EffectContext* pContext;
62 if (pHandle == NULL || uuid == NULL) {
63 ALOGE("EffectProxyCreate() called with NULL pointer");
64 return -EINVAL;
65 }
66 ALOGV("EffectProxyCreate start..");
67 pContext = new EffectContext;
68 pContext->sessionId = sessionId;
69 pContext->ioId = ioId;
70 pContext->uuid = *uuid;
71 pContext->common_itfe = &gEffectInterface;
72
73 // The sub effects will be created in effect_command when the first command
74 // for the effect is received
75 pContext->eHandle[SUB_FX_HOST] = pContext->eHandle[SUB_FX_OFFLOAD] = NULL;
76
77 // Get the HW and SW sub effect descriptors from the effects factory
78 desc = new effect_descriptor_t[SUB_FX_COUNT];
79 aeli = new audio_effect_library_t*[SUB_FX_COUNT];
80 sube = new sub_effect_entry_t*[SUB_FX_COUNT];
81 pContext->sube = new sub_effect_entry_t*[SUB_FX_COUNT];
82 pContext->desc = new effect_descriptor_t[SUB_FX_COUNT];
83 pContext->aeli = new audio_effect_library_t*[SUB_FX_COUNT];
84 int retValue = EffectGetSubEffects(uuid, sube, SUB_FX_COUNT);
85 // EffectGetSubEffects returns the number of sub-effects copied.
86 if (retValue != SUB_FX_COUNT) {
87 ALOGE("EffectCreate() could not get the sub effects");
88 delete[] sube;
89 delete[] desc;
90 delete[] aeli;
91 delete[] pContext->sube;
92 delete[] pContext->desc;
93 delete[] pContext->aeli;
94 return -EINVAL;
95 }
96 // Check which is the HW descriptor and copy the descriptors
97 // to the Context desc array
98 // Also check if there is only one HW and one SW descriptor.
99 // HW descriptor alone has the HW_TUNNEL flag.
100 desc[0] = *(effect_descriptor_t*)(sube[0])->object;
101 desc[1] = *(effect_descriptor_t*)(sube[1])->object;
102 aeli[0] = sube[0]->lib->desc;
103 aeli[1] = sube[1]->lib->desc;
104 if ((desc[0].flags & EFFECT_FLAG_HW_ACC_TUNNEL) &&
105 !(desc[1].flags & EFFECT_FLAG_HW_ACC_TUNNEL)) {
106 pContext->sube[SUB_FX_OFFLOAD] = sube[0];
107 pContext->desc[SUB_FX_OFFLOAD] = desc[0];
108 pContext->aeli[SUB_FX_OFFLOAD] = aeli[0];
109 pContext->sube[SUB_FX_HOST] = sube[1];
110 pContext->desc[SUB_FX_HOST] = desc[1];
111 pContext->aeli[SUB_FX_HOST] = aeli[1];
112 }
113 else if ((desc[1].flags & EFFECT_FLAG_HW_ACC_TUNNEL) &&
114 !(desc[0].flags & EFFECT_FLAG_HW_ACC_TUNNEL)) {
115 pContext->sube[SUB_FX_HOST] = sube[0];
116 pContext->desc[SUB_FX_HOST] = desc[0];
117 pContext->aeli[SUB_FX_HOST] = aeli[0];
118 pContext->sube[SUB_FX_OFFLOAD] = sube[1];
119 pContext->desc[SUB_FX_OFFLOAD] = desc[1];
120 pContext->aeli[SUB_FX_OFFLOAD] = aeli[1];
121 }
122 delete[] desc;
123 delete[] aeli;
124 delete[] sube;
125 #if (LOG_NDEBUG == 0)
126 effect_uuid_t uuid_print = pContext->desc[SUB_FX_HOST].uuid;
127 ALOGV("EffectCreate() UUID of HOST: %08X-%04X-%04X-%04X-%02X%02X%02X%02X"
128 "%02X%02X\n",uuid_print.timeLow, uuid_print.timeMid,
129 uuid_print.timeHiAndVersion, uuid_print.clockSeq, uuid_print.node[0],
130 uuid_print.node[1], uuid_print.node[2], uuid_print.node[3],
131 uuid_print.node[4], uuid_print.node[5]);
132 ALOGV("EffectCreate() UUID of OFFLOAD: %08X-%04X-%04X-%04X-%02X%02X%02X%02X"
133 "%02X%02X\n", uuid_print.timeLow, uuid_print.timeMid,
134 uuid_print.timeHiAndVersion, uuid_print.clockSeq, uuid_print.node[0],
135 uuid_print.node[1], uuid_print.node[2], uuid_print.node[3],
136 uuid_print.node[4], uuid_print.node[5]);
137 #endif
138
139 pContext->replySize = PROXY_REPLY_SIZE_DEFAULT;
140 pContext->replyData = (char *)malloc(PROXY_REPLY_SIZE_DEFAULT);
141
142 *pHandle = (effect_handle_t)pContext;
143 ALOGV("EffectCreate end");
144 return 0;
145 } //end EffectProxyCreate
146
EffectProxyRelease(effect_handle_t handle)147 int EffectProxyRelease(effect_handle_t handle) {
148 EffectContext * pContext = (EffectContext *)handle;
149 if (pContext == NULL) {
150 ALOGV("ERROR : EffectRelease called with NULL pointer");
151 return -EINVAL;
152 }
153 ALOGV("EffectRelease");
154 delete[] pContext->desc;
155 free(pContext->replyData);
156
157 if (pContext->eHandle[SUB_FX_HOST])
158 pContext->aeli[SUB_FX_HOST]->release_effect(pContext->eHandle[SUB_FX_HOST]);
159 if (pContext->eHandle[SUB_FX_OFFLOAD])
160 pContext->aeli[SUB_FX_OFFLOAD]->release_effect(pContext->eHandle[SUB_FX_OFFLOAD]);
161 delete[] pContext->aeli;
162 delete[] pContext->sube;
163 delete pContext;
164 pContext = NULL;
165 return 0;
166 } /*end EffectProxyRelease */
167
EffectProxyGetDescriptor(const effect_uuid_t * uuid,effect_descriptor_t * pDescriptor)168 int EffectProxyGetDescriptor(const effect_uuid_t *uuid,
169 effect_descriptor_t *pDescriptor) {
170 const effect_descriptor_t *desc = NULL;
171
172 if (pDescriptor == NULL || uuid == NULL) {
173 ALOGV("EffectGetDescriptor() called with NULL pointer");
174 return -EINVAL;
175 }
176 desc = &gProxyDescriptor;
177 *pDescriptor = *desc;
178 return 0;
179 } /* end EffectProxyGetDescriptor */
180
181 /* Effect Control Interface Implementation: Process */
Effect_process(effect_handle_t self,audio_buffer_t * inBuffer,audio_buffer_t * outBuffer)182 int Effect_process(effect_handle_t self,
183 audio_buffer_t *inBuffer,
184 audio_buffer_t *outBuffer) {
185
186 EffectContext *pContext = (EffectContext *) self;
187 int ret = 0;
188 if (pContext != NULL) {
189 int index = pContext->index;
190 // if the index refers to HW , do not do anything. Just return.
191 if (index == SUB_FX_HOST) {
192 ret = (*pContext->eHandle[index])->process(pContext->eHandle[index],
193 inBuffer, outBuffer);
194 }
195 }
196 return ret;
197 } /* end Effect_process */
198
199 /* Effect Control Interface Implementation: Command */
Effect_command(effect_handle_t self,uint32_t cmdCode,uint32_t cmdSize,void * pCmdData,uint32_t * replySize,void * pReplyData)200 int Effect_command(effect_handle_t self,
201 uint32_t cmdCode,
202 uint32_t cmdSize,
203 void *pCmdData,
204 uint32_t *replySize,
205 void *pReplyData) {
206
207 EffectContext *pContext = (EffectContext *) self;
208 int status = 0;
209 if (pContext == NULL) {
210 ALOGV("Effect_command() Proxy context is NULL");
211 return -EINVAL;
212 }
213 if (pContext->eHandle[SUB_FX_HOST] == NULL) {
214 ALOGV("Effect_command() Calling HOST EffectCreate");
215 status = pContext->aeli[SUB_FX_HOST]->create_effect(
216 &pContext->desc[SUB_FX_HOST].uuid,
217 pContext->sessionId, pContext->ioId,
218 &(pContext->eHandle[SUB_FX_HOST]));
219 if (status != NO_ERROR || (pContext->eHandle[SUB_FX_HOST] == NULL)) {
220 ALOGV("Effect_command() Error creating SW sub effect");
221 return status;
222 }
223 }
224 if (pContext->eHandle[SUB_FX_OFFLOAD] == NULL) {
225 ALOGV("Effect_command() Calling OFFLOAD EffectCreate");
226 status = pContext->aeli[SUB_FX_OFFLOAD]->create_effect(
227 &pContext->desc[SUB_FX_OFFLOAD].uuid,
228 pContext->sessionId, pContext->ioId,
229 &(pContext->eHandle[SUB_FX_OFFLOAD]));
230 if (status != NO_ERROR || (pContext->eHandle[SUB_FX_OFFLOAD] == NULL)) {
231 ALOGV("Effect_command() Error creating HW effect");
232 pContext->eHandle[SUB_FX_OFFLOAD] = NULL;
233 // Do not return error here as SW effect is created
234 // Return error if the CMD_OFFLOAD sends the index as OFFLOAD
235 }
236 pContext->index = SUB_FX_HOST;
237 }
238 // EFFECT_CMD_OFFLOAD used to (1) send whether the thread is offload or not
239 // (2) Send the ioHandle of the effectThread when the effect
240 // is moved from one type of thread to another.
241 // pCmdData points to a memory holding effect_offload_param_t structure
242 if (cmdCode == EFFECT_CMD_OFFLOAD) {
243 ALOGV("Effect_command() cmdCode = EFFECT_CMD_OFFLOAD");
244 if (cmdSize == 0 || pCmdData == NULL) {
245 ALOGV("effectsOffload: Effect_command: CMD_OFFLOAD has no data");
246 *(int*)pReplyData = FAILED_TRANSACTION;
247 return FAILED_TRANSACTION;
248 }
249 effect_offload_param_t* offloadParam = (effect_offload_param_t*)pCmdData;
250 // Assign the effect context index based on isOffload field of the structure
251 pContext->index = offloadParam->isOffload ? SUB_FX_OFFLOAD : SUB_FX_HOST;
252 // if the index is HW and the HW effect is unavailable, return error
253 // and reset the index to SW
254 if (pContext->eHandle[pContext->index] == NULL) {
255 ALOGV("Effect_command()CMD_OFFLOAD sub effect unavailable");
256 *(int*)pReplyData = FAILED_TRANSACTION;
257 return FAILED_TRANSACTION;
258 }
259 pContext->ioId = offloadParam->ioHandle;
260 ALOGV("Effect_command()CMD_OFFLOAD index:%d io %d", pContext->index, pContext->ioId);
261 // Update the DSP wrapper with the new ioHandle.
262 // Pass the OFFLOAD command to the wrapper.
263 // The DSP wrapper needs to handle this CMD
264 if (pContext->eHandle[SUB_FX_OFFLOAD]) {
265 ALOGV("Effect_command: Calling OFFLOAD command");
266 return (*pContext->eHandle[SUB_FX_OFFLOAD])->command(
267 pContext->eHandle[SUB_FX_OFFLOAD], cmdCode, cmdSize,
268 pCmdData, replySize, pReplyData);
269 }
270 *(int*)pReplyData = NO_ERROR;
271 ALOGV("Effect_command OFFLOAD return 0, replyData %d",
272 *(int*)pReplyData);
273
274 return NO_ERROR;
275 }
276
277 int index = pContext->index;
278 if (index != SUB_FX_HOST && index != SUB_FX_OFFLOAD) {
279 ALOGV("Effect_command: effect index is neither offload nor host");
280 return -EINVAL;
281 }
282
283 // Getter commands are only sent to the active sub effect.
284 int *subStatus[SUB_FX_COUNT];
285 uint32_t *subReplySize[SUB_FX_COUNT];
286 void *subReplyData[SUB_FX_COUNT];
287 uint32_t tmpSize;
288 int tmpStatus;
289
290 // grow temp reply buffer if needed
291 if (replySize != NULL) {
292 tmpSize = pContext->replySize;
293 while (tmpSize < *replySize && tmpSize < PROXY_REPLY_SIZE_MAX) {
294 tmpSize *= 2;
295 }
296 if (tmpSize > pContext->replySize) {
297 ALOGV("Effect_command grow reply buf to %d", tmpSize);
298 pContext->replyData = (char *)realloc(pContext->replyData, tmpSize);
299 pContext->replySize = tmpSize;
300 }
301 if (tmpSize > *replySize) {
302 tmpSize = *replySize;
303 }
304 } else {
305 tmpSize = 0;
306 }
307 // tmpSize is now the actual reply size for the non active sub effect
308
309 // Send command to sub effects. The command is sent to all sub effects so that their internal
310 // state is kept in sync.
311 // Only the reply from the active sub effect is returned to the caller. The reply from the
312 // other sub effect is lost in pContext->replyData
313 for (int i = 0; i < SUB_FX_COUNT; i++) {
314 if (pContext->eHandle[i] == NULL) {
315 continue;
316 }
317 if (i == index) {
318 subStatus[i] = &status;
319 subReplySize[i] = replySize;
320 subReplyData[i] = pReplyData;
321 } else {
322 subStatus[i] = &tmpStatus;
323 subReplySize[i] = replySize == NULL ? NULL : &tmpSize;
324 subReplyData[i] = pReplyData == NULL ? NULL : pContext->replyData;
325 }
326 *subStatus[i] = (*pContext->eHandle[i])->command(
327 pContext->eHandle[i], cmdCode, cmdSize,
328 pCmdData, subReplySize[i], subReplyData[i]);
329 }
330
331 return status;
332 } /* end Effect_command */
333
334
335 /* Effect Control Interface Implementation: get_descriptor */
Effect_getDescriptor(effect_handle_t self,effect_descriptor_t * pDescriptor)336 int Effect_getDescriptor(effect_handle_t self,
337 effect_descriptor_t *pDescriptor) {
338
339 EffectContext * pContext = (EffectContext *) self;
340 const effect_descriptor_t *desc;
341
342 ALOGV("Effect_getDescriptor");
343 if (pContext == NULL || pDescriptor == NULL) {
344 ALOGV("Effect_getDescriptor() invalid param");
345 return -EINVAL;
346 }
347 if (pContext->desc == NULL) {
348 ALOGV("Effect_getDescriptor() could not get descriptor");
349 return -EINVAL;
350 }
351 desc = &pContext->desc[SUB_FX_HOST];
352 *pDescriptor = *desc;
353 pDescriptor->uuid = pContext->uuid; // Replace the uuid with the Proxy UUID
354 // Also set/clear the EFFECT_FLAG_OFFLOAD_SUPPORTED flag based on the sub effects availability
355 if (pContext->eHandle[SUB_FX_OFFLOAD] != NULL)
356 pDescriptor->flags |= EFFECT_FLAG_OFFLOAD_SUPPORTED;
357 else
358 pDescriptor->flags &= ~EFFECT_FLAG_OFFLOAD_SUPPORTED;
359 return 0;
360 } /* end Effect_getDescriptor */
361
362 } // namespace android
363
364 __attribute__ ((visibility ("default")))
365 audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = {
366 .tag = AUDIO_EFFECT_LIBRARY_TAG,
367 .version = EFFECT_LIBRARY_API_VERSION,
368 .name = "Effect Proxy",
369 .implementor = "AOSP",
370 .create_effect = android::EffectProxyCreate,
371 .release_effect = android::EffectProxyRelease,
372 .get_descriptor = android::EffectProxyGetDescriptor,
373 };
374