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