1 /*
2 **
3 ** Copyright 2010, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18
19 //#define LOG_NDEBUG 0
20 #define LOG_TAG "AudioEffect"
21
22 #include <stdint.h>
23 #include <sys/types.h>
24 #include <limits.h>
25
26 #include <private/media/AudioEffectShared.h>
27 #include <media/AudioEffect.h>
28
29 #include <utils/Log.h>
30 #include <cutils/atomic.h>
31 #include <binder/IPCThreadState.h>
32
33
34
35 namespace android {
36
37 // ---------------------------------------------------------------------------
38
AudioEffect()39 AudioEffect::AudioEffect()
40 : mStatus(NO_INIT)
41 {
42 }
43
44
AudioEffect(const effect_uuid_t * type,const effect_uuid_t * uuid,int32_t priority,effect_callback_t cbf,void * user,int sessionId,audio_io_handle_t output)45 AudioEffect::AudioEffect(const effect_uuid_t *type,
46 const effect_uuid_t *uuid,
47 int32_t priority,
48 effect_callback_t cbf,
49 void* user,
50 int sessionId,
51 audio_io_handle_t output
52 )
53 : mStatus(NO_INIT)
54 {
55 mStatus = set(type, uuid, priority, cbf, user, sessionId, output);
56 }
57
AudioEffect(const char * typeStr,const char * uuidStr,int32_t priority,effect_callback_t cbf,void * user,int sessionId,audio_io_handle_t output)58 AudioEffect::AudioEffect(const char *typeStr,
59 const char *uuidStr,
60 int32_t priority,
61 effect_callback_t cbf,
62 void* user,
63 int sessionId,
64 audio_io_handle_t output
65 )
66 : mStatus(NO_INIT)
67 {
68 effect_uuid_t type;
69 effect_uuid_t *pType = NULL;
70 effect_uuid_t uuid;
71 effect_uuid_t *pUuid = NULL;
72
73 LOGV("Constructor string\n - type: %s\n - uuid: %s", typeStr, uuidStr);
74
75 if (typeStr != NULL) {
76 if (stringToGuid(typeStr, &type) == NO_ERROR) {
77 pType = &type;
78 }
79 }
80
81 if (uuidStr != NULL) {
82 if (stringToGuid(uuidStr, &uuid) == NO_ERROR) {
83 pUuid = &uuid;
84 }
85 }
86
87 mStatus = set(pType, pUuid, priority, cbf, user, sessionId, output);
88 }
89
set(const effect_uuid_t * type,const effect_uuid_t * uuid,int32_t priority,effect_callback_t cbf,void * user,int sessionId,audio_io_handle_t output)90 status_t AudioEffect::set(const effect_uuid_t *type,
91 const effect_uuid_t *uuid,
92 int32_t priority,
93 effect_callback_t cbf,
94 void* user,
95 int sessionId,
96 audio_io_handle_t output)
97 {
98 sp<IEffect> iEffect;
99 sp<IMemory> cblk;
100 int enabled;
101
102 LOGV("set %p mUserData: %p", this, user);
103
104 if (mIEffect != 0) {
105 LOGW("Effect already in use");
106 return INVALID_OPERATION;
107 }
108
109 const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
110 if (audioFlinger == 0) {
111 LOGE("set(): Could not get audioflinger");
112 return NO_INIT;
113 }
114
115 if (type == NULL && uuid == NULL) {
116 LOGW("Must specify at least type or uuid");
117 return BAD_VALUE;
118 }
119
120 mPriority = priority;
121 mCbf = cbf;
122 mUserData = user;
123 mSessionId = sessionId;
124
125 memset(&mDescriptor, 0, sizeof(effect_descriptor_t));
126 memcpy(&mDescriptor.type, EFFECT_UUID_NULL, sizeof(effect_uuid_t));
127 memcpy(&mDescriptor.uuid, EFFECT_UUID_NULL, sizeof(effect_uuid_t));
128
129 if (type != NULL) {
130 memcpy(&mDescriptor.type, type, sizeof(effect_uuid_t));
131 }
132 if (uuid != NULL) {
133 memcpy(&mDescriptor.uuid, uuid, sizeof(effect_uuid_t));
134 }
135
136 mIEffectClient = new EffectClient(this);
137
138 iEffect = audioFlinger->createEffect(getpid(), (effect_descriptor_t *)&mDescriptor,
139 mIEffectClient, priority, output, mSessionId, &mStatus, &mId, &enabled);
140
141 if (iEffect == 0 || (mStatus != NO_ERROR && mStatus != ALREADY_EXISTS)) {
142 LOGE("set(): AudioFlinger could not create effect, status: %d", mStatus);
143 return mStatus;
144 }
145
146 mEnabled = (volatile int32_t)enabled;
147
148 mIEffect = iEffect;
149 cblk = iEffect->getCblk();
150 if (cblk == 0) {
151 mStatus = NO_INIT;
152 LOGE("Could not get control block");
153 return mStatus;
154 }
155
156 mIEffect = iEffect;
157 mCblkMemory = cblk;
158 mCblk = static_cast<effect_param_cblk_t*>(cblk->pointer());
159 int bufOffset = ((sizeof(effect_param_cblk_t) - 1) / sizeof(int) + 1) * sizeof(int);
160 mCblk->buffer = (uint8_t *)mCblk + bufOffset;
161
162 iEffect->asBinder()->linkToDeath(mIEffectClient);
163 LOGV("set() %p OK effect: %s id: %d status %d enabled %d, ", this, mDescriptor.name, mId, mStatus, mEnabled);
164
165 return mStatus;
166 }
167
168
~AudioEffect()169 AudioEffect::~AudioEffect()
170 {
171 LOGV("Destructor %p", this);
172
173 if (mStatus == NO_ERROR || mStatus == ALREADY_EXISTS) {
174 setEnabled(false);
175 if (mIEffect != NULL) {
176 mIEffect->disconnect();
177 mIEffect->asBinder()->unlinkToDeath(mIEffectClient);
178 }
179 IPCThreadState::self()->flushCommands();
180 }
181 mIEffect.clear();
182 mIEffectClient.clear();
183 mCblkMemory.clear();
184 }
185
186
initCheck() const187 status_t AudioEffect::initCheck() const
188 {
189 return mStatus;
190 }
191
192 // -------------------------------------------------------------------------
193
descriptor() const194 effect_descriptor_t AudioEffect::descriptor() const
195 {
196 return mDescriptor;
197 }
198
getEnabled() const199 bool AudioEffect::getEnabled() const
200 {
201 return (mEnabled != 0);
202 }
203
setEnabled(bool enabled)204 status_t AudioEffect::setEnabled(bool enabled)
205 {
206 if (mStatus != NO_ERROR) {
207 return INVALID_OPERATION;
208 }
209
210 if (enabled) {
211 LOGV("enable %p", this);
212 if (android_atomic_or(1, &mEnabled) == 0) {
213 return mIEffect->enable();
214 }
215 } else {
216 LOGV("disable %p", this);
217 if (android_atomic_and(~1, &mEnabled) == 1) {
218 return mIEffect->disable();
219 }
220 }
221 return NO_ERROR;
222 }
223
command(uint32_t cmdCode,uint32_t cmdSize,void * cmdData,uint32_t * replySize,void * replyData)224 status_t AudioEffect::command(uint32_t cmdCode,
225 uint32_t cmdSize,
226 void *cmdData,
227 uint32_t *replySize,
228 void *replyData)
229 {
230 if (mStatus != NO_ERROR && mStatus != ALREADY_EXISTS) {
231 LOGV("command() bad status %d", mStatus);
232 return INVALID_OPERATION;
233 }
234
235 if ((cmdCode == EFFECT_CMD_ENABLE || cmdCode == EFFECT_CMD_DISABLE) &&
236 (replySize == NULL || *replySize != sizeof(status_t) || replyData == NULL)) {
237 return BAD_VALUE;
238 }
239
240 status_t status = mIEffect->command(cmdCode, cmdSize, cmdData, replySize, replyData);
241 if (status != NO_ERROR) {
242 return status;
243 }
244
245 if (cmdCode == EFFECT_CMD_ENABLE || cmdCode == EFFECT_CMD_DISABLE) {
246 status = *(status_t *)replyData;
247 if (status != NO_ERROR) {
248 return status;
249 }
250 if (cmdCode == EFFECT_CMD_ENABLE) {
251 android_atomic_or(1, &mEnabled);
252 } else {
253 android_atomic_and(~1, &mEnabled);
254 }
255 }
256
257 return status;
258 }
259
260
setParameter(effect_param_t * param)261 status_t AudioEffect::setParameter(effect_param_t *param)
262 {
263 if (mStatus != NO_ERROR) {
264 return INVALID_OPERATION;
265 }
266
267 if (param == NULL || param->psize == 0 || param->vsize == 0) {
268 return BAD_VALUE;
269 }
270
271 uint32_t size = sizeof(int);
272 uint32_t psize = ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) + param->vsize;
273
274 LOGV("setParameter: param: %d, param2: %d", *(int *)param->data, (param->psize == 8) ? *((int *)param->data + 1): -1);
275
276 return mIEffect->command(EFFECT_CMD_SET_PARAM, sizeof (effect_param_t) + psize, param, &size, ¶m->status);
277 }
278
setParameterDeferred(effect_param_t * param)279 status_t AudioEffect::setParameterDeferred(effect_param_t *param)
280 {
281 if (mStatus != NO_ERROR) {
282 return INVALID_OPERATION;
283 }
284
285 if (param == NULL || param->psize == 0 || param->vsize == 0) {
286 return BAD_VALUE;
287 }
288
289 Mutex::Autolock _l(mCblk->lock);
290
291 int psize = ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) + param->vsize;
292 int size = ((sizeof(effect_param_t) + psize - 1) / sizeof(int) + 1) * sizeof(int);
293
294 if (mCblk->clientIndex + size > EFFECT_PARAM_BUFFER_SIZE) {
295 return NO_MEMORY;
296 }
297 int *p = (int *)(mCblk->buffer + mCblk->clientIndex);
298 *p++ = size;
299 memcpy(p, param, sizeof(effect_param_t) + psize);
300 mCblk->clientIndex += size;
301
302 return NO_ERROR;
303 }
304
setParameterCommit()305 status_t AudioEffect::setParameterCommit()
306 {
307 if (mStatus != NO_ERROR) {
308 return INVALID_OPERATION;
309 }
310
311 Mutex::Autolock _l(mCblk->lock);
312 if (mCblk->clientIndex == 0) {
313 return INVALID_OPERATION;
314 }
315 uint32_t size = 0;
316 return mIEffect->command(EFFECT_CMD_SET_PARAM_COMMIT, 0, NULL, &size, NULL);
317 }
318
getParameter(effect_param_t * param)319 status_t AudioEffect::getParameter(effect_param_t *param)
320 {
321 if (mStatus != NO_ERROR && mStatus != ALREADY_EXISTS) {
322 return INVALID_OPERATION;
323 }
324
325 if (param == NULL || param->psize == 0 || param->vsize == 0) {
326 return BAD_VALUE;
327 }
328
329 LOGV("getParameter: param: %d, param2: %d", *(int *)param->data, (param->psize == 8) ? *((int *)param->data + 1): -1);
330
331 uint32_t psize = sizeof(effect_param_t) + ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) + param->vsize;
332
333 return mIEffect->command(EFFECT_CMD_GET_PARAM, sizeof(effect_param_t) + param->psize, param, &psize, param);
334 }
335
336
337 // -------------------------------------------------------------------------
338
binderDied()339 void AudioEffect::binderDied()
340 {
341 LOGW("IEffect died");
342 mStatus = NO_INIT;
343 if (mCbf) {
344 status_t status = DEAD_OBJECT;
345 mCbf(EVENT_ERROR, mUserData, &status);
346 }
347 mIEffect.clear();
348 }
349
350 // -------------------------------------------------------------------------
351
controlStatusChanged(bool controlGranted)352 void AudioEffect::controlStatusChanged(bool controlGranted)
353 {
354 LOGV("controlStatusChanged %p control %d callback %p mUserData %p", this, controlGranted, mCbf, mUserData);
355 if (controlGranted) {
356 if (mStatus == ALREADY_EXISTS) {
357 mStatus = NO_ERROR;
358 }
359 } else {
360 if (mStatus == NO_ERROR) {
361 mStatus = ALREADY_EXISTS;
362 }
363 }
364 if (mCbf) {
365 mCbf(EVENT_CONTROL_STATUS_CHANGED, mUserData, &controlGranted);
366 }
367 }
368
enableStatusChanged(bool enabled)369 void AudioEffect::enableStatusChanged(bool enabled)
370 {
371 LOGV("enableStatusChanged %p enabled %d mCbf %p", this, enabled, mCbf);
372 if (mStatus == ALREADY_EXISTS) {
373 if (enabled) {
374 android_atomic_or(1, &mEnabled);
375 } else {
376 android_atomic_and(~1, &mEnabled);
377 }
378 if (mCbf) {
379 mCbf(EVENT_ENABLE_STATUS_CHANGED, mUserData, &enabled);
380 }
381 }
382 }
383
commandExecuted(uint32_t cmdCode,uint32_t cmdSize,void * cmdData,uint32_t replySize,void * replyData)384 void AudioEffect::commandExecuted(uint32_t cmdCode,
385 uint32_t cmdSize,
386 void *cmdData,
387 uint32_t replySize,
388 void *replyData)
389 {
390 if (cmdData == NULL || replyData == NULL) {
391 return;
392 }
393
394 if (mCbf && cmdCode == EFFECT_CMD_SET_PARAM) {
395 effect_param_t *cmd = (effect_param_t *)cmdData;
396 cmd->status = *(int32_t *)replyData;
397 mCbf(EVENT_PARAMETER_CHANGED, mUserData, cmd);
398 }
399 }
400
401 // -------------------------------------------------------------------------
402
loadEffectLibrary(const char * libPath,int * handle)403 status_t AudioEffect::loadEffectLibrary(const char *libPath, int *handle)
404 {
405 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
406 if (af == 0) return PERMISSION_DENIED;
407 return af->loadEffectLibrary(libPath, handle);
408 }
409
unloadEffectLibrary(int handle)410 status_t AudioEffect::unloadEffectLibrary(int handle)
411 {
412 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
413 if (af == 0) return PERMISSION_DENIED;
414 return af->unloadEffectLibrary(handle);
415 }
416
queryNumberEffects(uint32_t * numEffects)417 status_t AudioEffect::queryNumberEffects(uint32_t *numEffects)
418 {
419 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
420 if (af == 0) return PERMISSION_DENIED;
421 return af->queryNumberEffects(numEffects);
422 }
423
queryEffect(uint32_t index,effect_descriptor_t * descriptor)424 status_t AudioEffect::queryEffect(uint32_t index, effect_descriptor_t *descriptor)
425 {
426 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
427 if (af == 0) return PERMISSION_DENIED;
428 return af->queryEffect(index, descriptor);
429 }
430
getEffectDescriptor(effect_uuid_t * uuid,effect_descriptor_t * descriptor)431 status_t AudioEffect::getEffectDescriptor(effect_uuid_t *uuid, effect_descriptor_t *descriptor)
432 {
433 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
434 if (af == 0) return PERMISSION_DENIED;
435 return af->getEffectDescriptor(uuid, descriptor);
436 }
437
438 // -------------------------------------------------------------------------
439
stringToGuid(const char * str,effect_uuid_t * guid)440 status_t AudioEffect::stringToGuid(const char *str, effect_uuid_t *guid)
441 {
442 if (str == NULL || guid == NULL) {
443 return BAD_VALUE;
444 }
445
446 int tmp[10];
447
448 if (sscanf(str, "%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x",
449 tmp, tmp+1, tmp+2, tmp+3, tmp+4, tmp+5, tmp+6, tmp+7, tmp+8, tmp+9) < 10) {
450 return BAD_VALUE;
451 }
452 guid->timeLow = (uint32_t)tmp[0];
453 guid->timeMid = (uint16_t)tmp[1];
454 guid->timeHiAndVersion = (uint16_t)tmp[2];
455 guid->clockSeq = (uint16_t)tmp[3];
456 guid->node[0] = (uint8_t)tmp[4];
457 guid->node[1] = (uint8_t)tmp[5];
458 guid->node[2] = (uint8_t)tmp[6];
459 guid->node[3] = (uint8_t)tmp[7];
460 guid->node[4] = (uint8_t)tmp[8];
461 guid->node[5] = (uint8_t)tmp[9];
462
463 return NO_ERROR;
464 }
465
guidToString(const effect_uuid_t * guid,char * str,size_t maxLen)466 status_t AudioEffect::guidToString(const effect_uuid_t *guid, char *str, size_t maxLen)
467 {
468 if (guid == NULL || str == NULL) {
469 return BAD_VALUE;
470 }
471
472 snprintf(str, maxLen, "%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x",
473 guid->timeLow,
474 guid->timeMid,
475 guid->timeHiAndVersion,
476 guid->clockSeq,
477 guid->node[0],
478 guid->node[1],
479 guid->node[2],
480 guid->node[3],
481 guid->node[4],
482 guid->node[5]);
483
484 return NO_ERROR;
485 }
486
487
488 }; // namespace android
489
490