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 <android/media/IAudioPolicyService.h>
27 #include <binder/IPCThreadState.h>
28 #include <media/AidlConversion.h>
29 #include <media/AudioEffect.h>
30 #include <media/PolicyAidlConversion.h>
31 #include <media/ShmemCompat.h>
32 #include <private/media/AudioEffectShared.h>
33 #include <utils/Log.h>
34
35 namespace android {
36 using aidl_utils::statusTFromBinderStatus;
37 using binder::Status;
38 using media::IAudioPolicyService;
39 using media::audio::common::AudioSource;
40 using media::audio::common::AudioUuid;
41
42 namespace {
43
44 // Copy from a raw pointer + size into a vector of bytes.
appendToBuffer(const void * data,size_t size,std::vector<uint8_t> * buffer)45 void appendToBuffer(const void* data,
46 size_t size,
47 std::vector<uint8_t>* buffer) {
48 const uint8_t* p = reinterpret_cast<const uint8_t*>(data);
49 buffer->insert(buffer->end(), p, p + size);
50 }
51
52 } // namespace
53
54 // ---------------------------------------------------------------------------
55
AudioEffect(const android::content::AttributionSourceState & attributionSource)56 AudioEffect::AudioEffect(const android::content::AttributionSourceState& attributionSource)
57 : mClientAttributionSource(attributionSource)
58 {
59 }
60
set(const effect_uuid_t * type,const effect_uuid_t * uuid,int32_t priority,const wp<IAudioEffectCallback> & callback,audio_session_t sessionId,audio_io_handle_t io,const AudioDeviceTypeAddr & device,bool probe,bool notifyFramesProcessed)61 status_t AudioEffect::set(const effect_uuid_t *type,
62 const effect_uuid_t *uuid,
63 int32_t priority,
64 const wp<IAudioEffectCallback>& callback,
65 audio_session_t sessionId,
66 audio_io_handle_t io,
67 const AudioDeviceTypeAddr& device,
68 bool probe,
69 bool notifyFramesProcessed)
70 {
71 sp<media::IEffect> iEffect;
72 sp<IMemory> cblk;
73 int enabled;
74
75 ALOGV("set %p uuid: %p timeLow %08x", this, type, type ? type->timeLow : 0);
76
77 if (mIEffect != 0) {
78 ALOGW("Effect already in use");
79 return INVALID_OPERATION;
80 }
81
82 if (sessionId == AUDIO_SESSION_DEVICE && io != AUDIO_IO_HANDLE_NONE) {
83 ALOGW("IO handle should not be specified for device effect");
84 return BAD_VALUE;
85 }
86 const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
87 if (audioFlinger == 0) {
88 ALOGE("set(): Could not get audioflinger");
89 return NO_INIT;
90 }
91
92 if (type == NULL && uuid == NULL) {
93 ALOGW("Must specify at least type or uuid");
94 return BAD_VALUE;
95 }
96 mProbe = probe;
97 mPriority = priority;
98 mSessionId = sessionId;
99 mCallback = callback;
100
101 memset(&mDescriptor, 0, sizeof(effect_descriptor_t));
102 mDescriptor.type = *(type != NULL ? type : EFFECT_UUID_NULL);
103 mDescriptor.uuid = *(uuid != NULL ? uuid : EFFECT_UUID_NULL);
104
105 // TODO b/182392769: use attribution source util
106 mIEffectClient = new EffectClient(this);
107 pid_t pid = IPCThreadState::self()->getCallingPid();
108 mClientAttributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(pid));
109 pid_t uid = IPCThreadState::self()->getCallingUid();
110 mClientAttributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
111
112 media::CreateEffectRequest request;
113 request.desc = VALUE_OR_RETURN_STATUS(
114 legacy2aidl_effect_descriptor_t_EffectDescriptor(mDescriptor));
115 request.client = mIEffectClient;
116 request.priority = priority;
117 request.output = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(io));
118 request.sessionId = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(mSessionId));
119 request.device = VALUE_OR_RETURN_STATUS(legacy2aidl_AudioDeviceTypeAddress(device));
120 request.attributionSource = mClientAttributionSource;
121 request.probe = probe;
122 request.notifyFramesProcessed = notifyFramesProcessed;
123
124 media::CreateEffectResponse response;
125
126 mStatus = audioFlinger->createEffect(request, &response);
127
128 if (mStatus == OK) {
129 if (response.alreadyExists) {
130 mStatus = ALREADY_EXISTS;
131 }
132 mId = response.id;
133 enabled = response.enabled;
134 iEffect = response.effect;
135 mDescriptor = VALUE_OR_RETURN_STATUS(
136 aidl2legacy_EffectDescriptor_effect_descriptor_t(response.desc));
137 }
138
139 // In probe mode, we stop here and return the status: the IEffect interface to
140 // audio flinger will not be retained. initCheck() will return the creation status
141 // but all other APIs will return invalid operation.
142 if (probe || iEffect == 0 || (mStatus != NO_ERROR && mStatus != ALREADY_EXISTS)) {
143 char typeBuffer[64] = {}, uuidBuffer[64] = {};
144 guidToString(type, typeBuffer, sizeof(typeBuffer));
145 guidToString(uuid, uuidBuffer, sizeof(uuidBuffer));
146 ALOGE_IF(!probe, "set(): AudioFlinger could not create effect %s / %s, status: %d",
147 type != nullptr ? typeBuffer : "NULL",
148 uuid != nullptr ? uuidBuffer : "NULL",
149 mStatus);
150 if (!probe && iEffect == 0) {
151 mStatus = NO_INIT;
152 }
153 return mStatus;
154 }
155
156 mEnabled = (volatile int32_t)enabled;
157
158 if (media::SharedFileRegion shmem;
159 !iEffect->getCblk(&shmem).isOk()
160 || !convertSharedFileRegionToIMemory(shmem, &cblk)
161 || cblk == 0) {
162 mStatus = NO_INIT;
163 ALOGE("Could not get control block");
164 return mStatus;
165 }
166
167 mIEffect = iEffect;
168 mCblkMemory = cblk;
169 // TODO: Using unsecurePointer() has some associated security pitfalls
170 // (see declaration for details).
171 // Either document why it is safe in this case or address the
172 // issue (e.g. by copying).
173 mCblk = static_cast<effect_param_cblk_t*>(cblk->unsecurePointer());
174 int bufOffset = ((sizeof(effect_param_cblk_t) - 1) / sizeof(int) + 1) * sizeof(int);
175 mCblk->buffer = (uint8_t *)mCblk + bufOffset;
176
177 IInterface::asBinder(iEffect)->linkToDeath(mIEffectClient);
178 ALOGV("set() %p OK effect: %s id: %d status %d enabled %d pid %d", this, mDescriptor.name, mId,
179 mStatus, mEnabled, mClientAttributionSource.pid);
180
181 if (!audio_is_global_session(mSessionId)) {
182 AudioSystem::acquireAudioSessionId(mSessionId, pid, uid);
183 }
184
185 return mStatus;
186 }
187
188 namespace {
189 class LegacyCallbackWrapper : public AudioEffect::IAudioEffectCallback {
190 public:
LegacyCallbackWrapper(AudioEffect::legacy_callback_t callback,void * user)191 LegacyCallbackWrapper(AudioEffect::legacy_callback_t callback, void* user):
192 mCallback(callback), mUser(user) {}
193 private:
onControlStatusChanged(bool isGranted)194 void onControlStatusChanged(bool isGranted) override {
195 mCallback(AudioEffect::EVENT_CONTROL_STATUS_CHANGED, mUser, &isGranted);
196 }
197
onEnableStatusChanged(bool isEnabled)198 void onEnableStatusChanged(bool isEnabled) override {
199 mCallback(AudioEffect::EVENT_ENABLE_STATUS_CHANGED, mUser, &isEnabled);
200 }
201
onParameterChanged(std::vector<uint8_t> param)202 void onParameterChanged(std::vector<uint8_t> param) override {
203 mCallback(AudioEffect::EVENT_PARAMETER_CHANGED, mUser, param.data());
204 }
205
onError(status_t errorCode)206 void onError(status_t errorCode) override {
207 mCallback(AudioEffect::EVENT_ERROR, mUser, &errorCode);
208 }
209
onFramesProcessed(int32_t framesProcessed)210 void onFramesProcessed(int32_t framesProcessed) override {
211 mCallback(AudioEffect::EVENT_FRAMES_PROCESSED, mUser, &framesProcessed);
212 }
213
214 const AudioEffect::legacy_callback_t mCallback;
215 void* const mUser;
216 };
217 } // namespace
218
set(const effect_uuid_t * type,const effect_uuid_t * uuid,int32_t priority,legacy_callback_t cbf,void * user,audio_session_t sessionId,audio_io_handle_t io,const AudioDeviceTypeAddr & device,bool probe,bool notifyFramesProcessed)219 status_t AudioEffect::set(const effect_uuid_t *type,
220 const effect_uuid_t *uuid,
221 int32_t priority,
222 legacy_callback_t cbf,
223 void* user,
224 audio_session_t sessionId,
225 audio_io_handle_t io,
226 const AudioDeviceTypeAddr& device,
227 bool probe,
228 bool notifyFramesProcessed)
229 {
230 if (cbf != nullptr) {
231 mLegacyWrapper = sp<LegacyCallbackWrapper>::make(cbf, user);
232 } else if (user != nullptr) {
233 LOG_ALWAYS_FATAL("%s: User provided without callback", __func__);
234 }
235 return set(type, uuid, priority, mLegacyWrapper, sessionId, io, device, probe,
236 notifyFramesProcessed);
237 }
set(const char * typeStr,const char * uuidStr,int32_t priority,const wp<IAudioEffectCallback> & callback,audio_session_t sessionId,audio_io_handle_t io,const AudioDeviceTypeAddr & device,bool probe,bool notifyFramesProcessed)238 status_t AudioEffect::set(const char *typeStr,
239 const char *uuidStr,
240 int32_t priority,
241 const wp<IAudioEffectCallback>& callback,
242 audio_session_t sessionId,
243 audio_io_handle_t io,
244 const AudioDeviceTypeAddr& device,
245 bool probe,
246 bool notifyFramesProcessed)
247 {
248 effect_uuid_t type;
249 effect_uuid_t *pType = nullptr;
250 effect_uuid_t uuid;
251 effect_uuid_t *pUuid = nullptr;
252
253 ALOGV("AudioEffect::set string\n - type: %s\n - uuid: %s",
254 typeStr ? typeStr : "nullptr", uuidStr ? uuidStr : "nullptr");
255
256 if (stringToGuid(typeStr, &type) == NO_ERROR) {
257 pType = &type;
258 }
259 if (stringToGuid(uuidStr, &uuid) == NO_ERROR) {
260 pUuid = &uuid;
261 }
262
263 return set(pType, pUuid, priority, callback, sessionId, io,
264 device, probe, notifyFramesProcessed);
265 }
266
set(const char * typeStr,const char * uuidStr,int32_t priority,legacy_callback_t cbf,void * user,audio_session_t sessionId,audio_io_handle_t io,const AudioDeviceTypeAddr & device,bool probe,bool notifyFramesProcessed)267 status_t AudioEffect::set(const char *typeStr,
268 const char *uuidStr,
269 int32_t priority,
270 legacy_callback_t cbf,
271 void* user,
272 audio_session_t sessionId,
273 audio_io_handle_t io,
274 const AudioDeviceTypeAddr& device,
275 bool probe,
276 bool notifyFramesProcessed)
277 {
278 if (cbf != nullptr) {
279 mLegacyWrapper = sp<LegacyCallbackWrapper>::make(cbf, user);
280 } else if (user != nullptr) {
281 LOG_ALWAYS_FATAL("%s: User provided without callback", __func__);
282 }
283 return set(typeStr, uuidStr, priority, mLegacyWrapper, sessionId, io, device, probe,
284 notifyFramesProcessed);
285 }
~AudioEffect()286 AudioEffect::~AudioEffect()
287 {
288 ALOGV("Destructor %p", this);
289
290 if (!mProbe && (mStatus == NO_ERROR || mStatus == ALREADY_EXISTS)) {
291 if (!audio_is_global_session(mSessionId)) {
292 AudioSystem::releaseAudioSessionId(mSessionId,
293 VALUE_OR_FATAL(aidl2legacy_int32_t_pid_t(mClientAttributionSource.pid)));
294 }
295 if (mIEffect != NULL) {
296 mIEffect->disconnect();
297 IInterface::asBinder(mIEffect)->unlinkToDeath(mIEffectClient);
298 }
299 mIEffect.clear();
300 mCblkMemory.clear();
301 }
302 mIEffectClient.clear();
303 IPCThreadState::self()->flushCommands();
304 }
305
306
initCheck() const307 status_t AudioEffect::initCheck() const
308 {
309 return mStatus;
310 }
311
312 // -------------------------------------------------------------------------
313
descriptor() const314 effect_descriptor_t AudioEffect::descriptor() const
315 {
316 return mDescriptor;
317 }
318
getEnabled() const319 bool AudioEffect::getEnabled() const
320 {
321 return (mEnabled != 0);
322 }
323
setEnabled(bool enabled)324 status_t AudioEffect::setEnabled(bool enabled)
325 {
326 if (mProbe) {
327 return INVALID_OPERATION;
328 }
329 if (mStatus != NO_ERROR) {
330 return (mStatus == ALREADY_EXISTS) ? (status_t) INVALID_OPERATION : mStatus;
331 }
332
333 status_t status = NO_ERROR;
334 AutoMutex lock(mLock);
335 if (enabled != mEnabled) {
336 Status bs;
337
338 if (enabled) {
339 ALOGV("enable %p", this);
340 bs = mIEffect->enable(&status);
341 } else {
342 ALOGV("disable %p", this);
343 bs = mIEffect->disable(&status);
344 }
345 if (!bs.isOk()) {
346 status = statusTFromBinderStatus(bs);
347 }
348 if (status == NO_ERROR) {
349 mEnabled = enabled;
350 }
351 }
352 return status;
353 }
354
command(uint32_t cmdCode,uint32_t cmdSize,void * cmdData,uint32_t * replySize,void * replyData)355 status_t AudioEffect::command(uint32_t cmdCode,
356 uint32_t cmdSize,
357 void *cmdData,
358 uint32_t *replySize,
359 void *replyData)
360 {
361 if (mProbe) {
362 return INVALID_OPERATION;
363 }
364 if (mStatus != NO_ERROR && mStatus != ALREADY_EXISTS) {
365 ALOGV("command() bad status %d", mStatus);
366 return mStatus;
367 }
368
369 if (cmdCode == EFFECT_CMD_ENABLE || cmdCode == EFFECT_CMD_DISABLE) {
370 if (mEnabled == (cmdCode == EFFECT_CMD_ENABLE)) {
371 return NO_ERROR;
372 }
373 if (replySize == NULL || *replySize != sizeof(status_t) || replyData == NULL) {
374 return BAD_VALUE;
375 }
376 mLock.lock();
377 }
378
379 std::vector<uint8_t> data;
380 appendToBuffer(cmdData, cmdSize, &data);
381
382 status_t status;
383 std::vector<uint8_t> response;
384
385 Status bs = mIEffect->command(cmdCode, data, *replySize, &response, &status);
386 if (!bs.isOk()) {
387 status = statusTFromBinderStatus(bs);
388 }
389 if (status == NO_ERROR) {
390 memcpy(replyData, response.data(), response.size());
391 *replySize = response.size();
392 }
393
394 if (cmdCode == EFFECT_CMD_ENABLE || cmdCode == EFFECT_CMD_DISABLE) {
395 if (status == NO_ERROR) {
396 status = *(status_t *)replyData;
397 }
398 if (status == NO_ERROR) {
399 mEnabled = (cmdCode == EFFECT_CMD_ENABLE);
400 }
401 mLock.unlock();
402 }
403
404 return status;
405 }
406
setParameter(effect_param_t * param)407 status_t AudioEffect::setParameter(effect_param_t *param)
408 {
409 if (mProbe) {
410 return INVALID_OPERATION;
411 }
412 if (mStatus != NO_ERROR) {
413 return (mStatus == ALREADY_EXISTS) ? (status_t) INVALID_OPERATION : mStatus;
414 }
415
416 if (param == NULL || param->psize == 0 || param->vsize == 0) {
417 return BAD_VALUE;
418 }
419
420 uint32_t psize = ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) + param->vsize;
421
422 ALOGV("setParameter: param: %d, param2: %d", *(int *)param->data,
423 (param->psize == 8) ? *((int *)param->data + 1): -1);
424
425 std::vector<uint8_t> cmd;
426 appendToBuffer(param, sizeof(effect_param_t) + psize, &cmd);
427 std::vector<uint8_t> response;
428 status_t status;
429 Status bs = mIEffect->command(EFFECT_CMD_SET_PARAM,
430 cmd,
431 sizeof(int),
432 &response,
433 &status);
434 if (!bs.isOk()) {
435 status = statusTFromBinderStatus(bs);
436 return status;
437 }
438 assert(response.size() == sizeof(int));
439 memcpy(¶m->status, response.data(), response.size());
440 return status;
441 }
442
setParameterDeferred(effect_param_t * param)443 status_t AudioEffect::setParameterDeferred(effect_param_t *param)
444 {
445 if (mProbe) {
446 return INVALID_OPERATION;
447 }
448 if (mStatus != NO_ERROR) {
449 return (mStatus == ALREADY_EXISTS) ? (status_t) INVALID_OPERATION : mStatus;
450 }
451
452 if (param == NULL || param->psize == 0 || param->vsize == 0) {
453 return BAD_VALUE;
454 }
455
456 Mutex::Autolock _l(mCblk->lock);
457
458 int psize = ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) + param->vsize;
459 int size = ((sizeof(effect_param_t) + psize - 1) / sizeof(int) + 1) * sizeof(int);
460
461 if (mCblk->clientIndex + size > EFFECT_PARAM_BUFFER_SIZE) {
462 return NO_MEMORY;
463 }
464 int *p = (int *)(mCblk->buffer + mCblk->clientIndex);
465 *p++ = size;
466 memcpy(p, param, sizeof(effect_param_t) + psize);
467 mCblk->clientIndex += size;
468
469 return NO_ERROR;
470 }
471
setParameterCommit()472 status_t AudioEffect::setParameterCommit()
473 {
474 if (mProbe) {
475 return INVALID_OPERATION;
476 }
477 if (mStatus != NO_ERROR) {
478 return (mStatus == ALREADY_EXISTS) ? (status_t) INVALID_OPERATION : mStatus;
479 }
480
481 Mutex::Autolock _l(mCblk->lock);
482 if (mCblk->clientIndex == 0) {
483 return INVALID_OPERATION;
484 }
485 std::vector<uint8_t> cmd;
486 std::vector<uint8_t> response;
487 status_t status;
488 Status bs = mIEffect->command(EFFECT_CMD_SET_PARAM_COMMIT,
489 cmd,
490 0,
491 &response,
492 &status);
493 if (!bs.isOk()) {
494 status = statusTFromBinderStatus(bs);
495 }
496 return status;
497 }
498
getParameter(effect_param_t * param)499 status_t AudioEffect::getParameter(effect_param_t *param)
500 {
501 if (mProbe) {
502 return INVALID_OPERATION;
503 }
504 if (mStatus != NO_ERROR && mStatus != ALREADY_EXISTS) {
505 return mStatus;
506 }
507
508 if (param == NULL || param->psize == 0 || param->vsize == 0) {
509 return BAD_VALUE;
510 }
511
512 ALOGV("getParameter: param: %d, param2: %d", *(int *)param->data,
513 (param->psize == 8) ? *((int *)param->data + 1): -1);
514
515 uint32_t psize = sizeof(effect_param_t) + ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) +
516 param->vsize;
517
518 status_t status;
519 std::vector<uint8_t> cmd;
520 std::vector<uint8_t> response;
521 appendToBuffer(param, sizeof(effect_param_t) + param->psize, &cmd);
522
523 Status bs = mIEffect->command(EFFECT_CMD_GET_PARAM, cmd, psize, &response, &status);
524 if (!bs.isOk()) {
525 status = statusTFromBinderStatus(bs);
526 return status;
527 }
528 memcpy(param, response.data(), response.size());
529 return status;
530 }
531
532
533 // -------------------------------------------------------------------------
534
binderDied()535 void AudioEffect::binderDied()
536 {
537 ALOGW("IEffect died");
538 mStatus = DEAD_OBJECT;
539 auto cb = mCallback.promote();
540 if (cb != nullptr) {
541 cb->onError(mStatus);
542 }
543 }
544
545 // -------------------------------------------------------------------------
546
controlStatusChanged(bool controlGranted)547 void AudioEffect::controlStatusChanged(bool controlGranted)
548 {
549 auto cb = mCallback.promote();
550 ALOGV("controlStatusChanged %p control %d callback %p", this, controlGranted, cb.get());
551 if (controlGranted) {
552 if (mStatus == ALREADY_EXISTS) {
553 mStatus = NO_ERROR;
554 }
555 } else {
556 if (mStatus == NO_ERROR) {
557 mStatus = ALREADY_EXISTS;
558 }
559 }
560 if (cb != nullptr) {
561 cb->onControlStatusChanged(controlGranted);
562 }
563 }
564
enableStatusChanged(bool enabled)565 void AudioEffect::enableStatusChanged(bool enabled)
566 {
567 auto cb = mCallback.promote();
568 ALOGV("enableStatusChanged %p enabled %d mCallback %p", this, enabled, cb.get());
569 if (mStatus == ALREADY_EXISTS) {
570 mEnabled = enabled;
571 if (cb != nullptr) {
572 cb->onEnableStatusChanged(enabled);
573 }
574 }
575 }
576
commandExecuted(int32_t cmdCode,const std::vector<uint8_t> & cmdData,const std::vector<uint8_t> & replyData)577 void AudioEffect::commandExecuted(int32_t cmdCode,
578 const std::vector<uint8_t>& cmdData,
579 const std::vector<uint8_t>& replyData)
580 {
581 if (cmdData.empty() || replyData.empty()) {
582 return;
583 }
584 auto cb = mCallback.promote();
585 if (cb != nullptr && cmdCode == EFFECT_CMD_SET_PARAM) {
586 std::vector<uint8_t> cmdDataCopy(cmdData);
587 effect_param_t* cmd = reinterpret_cast<effect_param_t *>(cmdDataCopy.data());
588 cmd->status = *reinterpret_cast<const int32_t *>(replyData.data());
589 cb->onParameterChanged(std::move(cmdDataCopy));
590 }
591 }
592
framesProcessed(int32_t frames)593 void AudioEffect::framesProcessed(int32_t frames)
594 {
595 auto cb = mCallback.promote();
596 if (cb != nullptr) {
597 cb->onFramesProcessed(frames);
598 }
599 }
600
601 // -------------------------------------------------------------------------
602
queryNumberEffects(uint32_t * numEffects)603 status_t AudioEffect::queryNumberEffects(uint32_t *numEffects)
604 {
605 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
606 if (af == 0) return PERMISSION_DENIED;
607 return af->queryNumberEffects(numEffects);
608 }
609
queryEffect(uint32_t index,effect_descriptor_t * descriptor)610 status_t AudioEffect::queryEffect(uint32_t index, effect_descriptor_t *descriptor)
611 {
612 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
613 if (af == 0) return PERMISSION_DENIED;
614 return af->queryEffect(index, descriptor);
615 }
616
getEffectDescriptor(const effect_uuid_t * uuid,const effect_uuid_t * type,uint32_t preferredTypeFlag,effect_descriptor_t * descriptor)617 status_t AudioEffect::getEffectDescriptor(const effect_uuid_t *uuid,
618 const effect_uuid_t *type,
619 uint32_t preferredTypeFlag,
620 effect_descriptor_t *descriptor)
621 {
622 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
623 if (af == 0) return PERMISSION_DENIED;
624 return af->getEffectDescriptor(uuid, type, preferredTypeFlag, descriptor);
625 }
626
queryDefaultPreProcessing(audio_session_t audioSession,effect_descriptor_t * descriptors,uint32_t * count)627 status_t AudioEffect::queryDefaultPreProcessing(audio_session_t audioSession,
628 effect_descriptor_t *descriptors,
629 uint32_t *count)
630 {
631 if (descriptors == nullptr || count == nullptr) {
632 return BAD_VALUE;
633 }
634 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
635 if (aps == 0) return PERMISSION_DENIED;
636
637 int32_t audioSessionAidl = VALUE_OR_RETURN_STATUS(
638 legacy2aidl_audio_session_t_int32_t(audioSession));
639 media::audio::common::Int countAidl;
640 countAidl.value = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*count));
641 std::vector<media::EffectDescriptor> retAidl;
642 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
643 aps->queryDefaultPreProcessing(audioSessionAidl, &countAidl, &retAidl)));
644 *count = VALUE_OR_RETURN_STATUS(convertIntegral<uint32_t>(countAidl.value));
645 RETURN_STATUS_IF_ERROR(convertRange(retAidl.begin(), retAidl.end(), descriptors,
646 aidl2legacy_EffectDescriptor_effect_descriptor_t));
647 return OK;
648 }
649
newEffectUniqueId(audio_unique_id_t * id)650 status_t AudioEffect::newEffectUniqueId(audio_unique_id_t* id)
651 {
652 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
653 if (af == 0) return PERMISSION_DENIED;
654 *id = af->newAudioUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT);
655 return NO_ERROR;
656 }
657
addSourceDefaultEffect(const char * typeStr,const String16 & opPackageName,const char * uuidStr,int32_t priority,audio_source_t source,audio_unique_id_t * id)658 status_t AudioEffect::addSourceDefaultEffect(const char *typeStr,
659 const String16& opPackageName,
660 const char *uuidStr,
661 int32_t priority,
662 audio_source_t source,
663 audio_unique_id_t *id)
664 {
665 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
666 if (aps == 0) return PERMISSION_DENIED;
667
668 if (typeStr == NULL && uuidStr == NULL) return BAD_VALUE;
669
670 // Convert type & uuid from string to effect_uuid_t.
671 effect_uuid_t type;
672 if (typeStr != NULL) {
673 status_t res = stringToGuid(typeStr, &type);
674 if (res != OK) return res;
675 } else {
676 type = *EFFECT_UUID_NULL;
677 }
678
679 effect_uuid_t uuid;
680 if (uuidStr != NULL) {
681 status_t res = stringToGuid(uuidStr, &uuid);
682 if (res != OK) return res;
683 } else {
684 uuid = *EFFECT_UUID_NULL;
685 }
686
687 AudioUuid typeAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_uuid_t_AudioUuid(type));
688 AudioUuid uuidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_uuid_t_AudioUuid(uuid));
689 std::string opPackageNameAidl = VALUE_OR_RETURN_STATUS(
690 legacy2aidl_String16_string(opPackageName));
691 AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
692 legacy2aidl_audio_source_t_AudioSource(source));
693 int32_t retAidl;
694 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
695 aps->addSourceDefaultEffect(typeAidl, opPackageNameAidl, uuidAidl, priority, sourceAidl,
696 &retAidl)));
697 *id = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_unique_id_t(retAidl));
698 return OK;
699 }
700
addStreamDefaultEffect(const char * typeStr,const String16 & opPackageName,const char * uuidStr,int32_t priority,audio_usage_t usage,audio_unique_id_t * id)701 status_t AudioEffect::addStreamDefaultEffect(const char *typeStr,
702 const String16& opPackageName,
703 const char *uuidStr,
704 int32_t priority,
705 audio_usage_t usage,
706 audio_unique_id_t *id)
707 {
708 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
709 if (aps == 0) return PERMISSION_DENIED;
710
711 if (typeStr == NULL && uuidStr == NULL) return BAD_VALUE;
712
713 // Convert type & uuid from string to effect_uuid_t.
714 effect_uuid_t type;
715 if (typeStr != NULL) {
716 status_t res = stringToGuid(typeStr, &type);
717 if (res != OK) return res;
718 } else {
719 type = *EFFECT_UUID_NULL;
720 }
721
722 effect_uuid_t uuid;
723 if (uuidStr != NULL) {
724 status_t res = stringToGuid(uuidStr, &uuid);
725 if (res != OK) return res;
726 } else {
727 uuid = *EFFECT_UUID_NULL;
728 }
729
730 AudioUuid typeAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_uuid_t_AudioUuid(type));
731 AudioUuid uuidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_uuid_t_AudioUuid(uuid));
732 std::string opPackageNameAidl = VALUE_OR_RETURN_STATUS(
733 legacy2aidl_String16_string(opPackageName));
734 media::audio::common::AudioUsage usageAidl = VALUE_OR_RETURN_STATUS(
735 legacy2aidl_audio_usage_t_AudioUsage(usage));
736 int32_t retAidl;
737 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
738 aps->addStreamDefaultEffect(typeAidl, opPackageNameAidl, uuidAidl, priority, usageAidl,
739 &retAidl)));
740 *id = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_unique_id_t(retAidl));
741 return OK;
742 }
743
removeSourceDefaultEffect(audio_unique_id_t id)744 status_t AudioEffect::removeSourceDefaultEffect(audio_unique_id_t id)
745 {
746 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
747 if (aps == 0) return PERMISSION_DENIED;
748
749 int32_t idAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));
750 return statusTFromBinderStatus(aps->removeSourceDefaultEffect(idAidl));
751 }
752
removeStreamDefaultEffect(audio_unique_id_t id)753 status_t AudioEffect::removeStreamDefaultEffect(audio_unique_id_t id)
754 {
755 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
756 if (aps == 0) return PERMISSION_DENIED;
757
758 int32_t idAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));
759 return statusTFromBinderStatus(aps->removeStreamDefaultEffect(idAidl));
760 }
761
762 // -------------------------------------------------------------------------
763
stringToGuid(const char * str,effect_uuid_t * guid)764 status_t AudioEffect::stringToGuid(const char *str, effect_uuid_t *guid)
765 {
766 if (str == NULL || guid == NULL) {
767 return BAD_VALUE;
768 }
769
770 int tmp[10];
771
772 if (sscanf(str, "%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x",
773 tmp, tmp+1, tmp+2, tmp+3, tmp+4, tmp+5, tmp+6, tmp+7, tmp+8, tmp+9) < 10) {
774 return BAD_VALUE;
775 }
776 guid->timeLow = (uint32_t)tmp[0];
777 guid->timeMid = (uint16_t)tmp[1];
778 guid->timeHiAndVersion = (uint16_t)tmp[2];
779 guid->clockSeq = (uint16_t)tmp[3];
780 guid->node[0] = (uint8_t)tmp[4];
781 guid->node[1] = (uint8_t)tmp[5];
782 guid->node[2] = (uint8_t)tmp[6];
783 guid->node[3] = (uint8_t)tmp[7];
784 guid->node[4] = (uint8_t)tmp[8];
785 guid->node[5] = (uint8_t)tmp[9];
786
787 return NO_ERROR;
788 }
789
guidToString(const effect_uuid_t * guid,char * str,size_t maxLen)790 status_t AudioEffect::guidToString(const effect_uuid_t *guid, char *str, size_t maxLen)
791 {
792 if (guid == NULL || str == NULL) {
793 return BAD_VALUE;
794 }
795
796 snprintf(str, maxLen, "%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x",
797 guid->timeLow,
798 guid->timeMid,
799 guid->timeHiAndVersion,
800 guid->clockSeq,
801 guid->node[0],
802 guid->node[1],
803 guid->node[2],
804 guid->node[3],
805 guid->node[4],
806 guid->node[5]);
807
808 return NO_ERROR;
809 }
810
811
812 } // namespace android
813