1 /*
2 * Copyright (C) 2010 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 "EffectVisualizer"
18 //#define LOG_NDEBUG 0
19 #include <log/log.h>
20 #include <assert.h>
21 #include <inttypes.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <new>
25 #include <time.h>
26 #include <math.h>
27 #include <audio_effects/effect_visualizer.h>
28 #include <cutils/log.h>
29
30
31 extern "C" {
32
33 // effect_handle_t interface implementation for visualizer effect
34 extern const struct effect_interface_s gVisualizerInterface;
35
36 // Google Visualizer UUID: d069d9e0-8329-11df-9168-0002a5d5c51b
37 const effect_descriptor_t gVisualizerDescriptor = {
38 {0xe46b26a0, 0xdddd, 0x11db, 0x8afd, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // type
39 {0xd069d9e0, 0x8329, 0x11df, 0x9168, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // uuid
40 EFFECT_CONTROL_API_VERSION,
41 (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_FIRST),
42 0, // TODO
43 1,
44 "Visualizer",
45 "The Android Open Source Project",
46 };
47
48 enum visualizer_state_e {
49 VISUALIZER_STATE_UNINITIALIZED,
50 VISUALIZER_STATE_INITIALIZED,
51 VISUALIZER_STATE_ACTIVE,
52 };
53
54 // maximum time since last capture buffer update before resetting capture buffer. This means
55 // that the framework has stopped playing audio and we must start returning silence
56 #define MAX_STALL_TIME_MS 1000
57
58 #define CAPTURE_BUF_SIZE 65536 // "64k should be enough for everyone"
59
60 #define DISCARD_MEASUREMENTS_TIME_MS 2000 // discard measurements older than this number of ms
61
62 // maximum number of buffers for which we keep track of the measurements
63 #define MEASUREMENT_WINDOW_MAX_SIZE_IN_BUFFERS 25 // note: buffer index is stored in uint8_t
64
65
66 struct BufferStats {
67 bool mIsValid;
68 uint16_t mPeakU16; // the positive peak of the absolute value of the samples in a buffer
69 float mRmsSquared; // the average square of the samples in a buffer
70 };
71
72 struct VisualizerContext {
73 const struct effect_interface_s *mItfe;
74 effect_config_t mConfig;
75 uint32_t mCaptureIdx;
76 uint32_t mCaptureSize;
77 uint32_t mScalingMode;
78 uint8_t mState;
79 uint32_t mLastCaptureIdx;
80 uint32_t mLatency;
81 struct timespec mBufferUpdateTime;
82 uint8_t mCaptureBuf[CAPTURE_BUF_SIZE];
83 // for measurements
84 uint8_t mChannelCount; // to avoid recomputing it every time a buffer is processed
85 uint32_t mMeasurementMode;
86 uint8_t mMeasurementWindowSizeInBuffers;
87 uint8_t mMeasurementBufferIdx;
88 BufferStats mPastMeasurements[MEASUREMENT_WINDOW_MAX_SIZE_IN_BUFFERS];
89 };
90
91 //
92 //--- Local functions
93 //
Visualizer_getDeltaTimeMsFromUpdatedTime(VisualizerContext * pContext)94 uint32_t Visualizer_getDeltaTimeMsFromUpdatedTime(VisualizerContext* pContext) {
95 uint32_t deltaMs = 0;
96 if (pContext->mBufferUpdateTime.tv_sec != 0) {
97 struct timespec ts;
98 if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
99 time_t secs = ts.tv_sec - pContext->mBufferUpdateTime.tv_sec;
100 long nsec = ts.tv_nsec - pContext->mBufferUpdateTime.tv_nsec;
101 if (nsec < 0) {
102 --secs;
103 nsec += 1000000000;
104 }
105 deltaMs = secs * 1000 + nsec / 1000000;
106 }
107 }
108 return deltaMs;
109 }
110
111
Visualizer_reset(VisualizerContext * pContext)112 void Visualizer_reset(VisualizerContext *pContext)
113 {
114 pContext->mCaptureIdx = 0;
115 pContext->mLastCaptureIdx = 0;
116 pContext->mBufferUpdateTime.tv_sec = 0;
117 pContext->mLatency = 0;
118 memset(pContext->mCaptureBuf, 0x80, CAPTURE_BUF_SIZE);
119 }
120
121 //----------------------------------------------------------------------------
122 // Visualizer_setConfig()
123 //----------------------------------------------------------------------------
124 // Purpose: Set input and output audio configuration.
125 //
126 // Inputs:
127 // pContext: effect engine context
128 // pConfig: pointer to effect_config_t structure holding input and output
129 // configuration parameters
130 //
131 // Outputs:
132 //
133 //----------------------------------------------------------------------------
134
Visualizer_setConfig(VisualizerContext * pContext,effect_config_t * pConfig)135 int Visualizer_setConfig(VisualizerContext *pContext, effect_config_t *pConfig)
136 {
137 ALOGV("Visualizer_setConfig start");
138
139 if (pConfig->inputCfg.samplingRate != pConfig->outputCfg.samplingRate) return -EINVAL;
140 if (pConfig->inputCfg.channels != pConfig->outputCfg.channels) return -EINVAL;
141 if (pConfig->inputCfg.format != pConfig->outputCfg.format) return -EINVAL;
142 if (pConfig->inputCfg.channels != AUDIO_CHANNEL_OUT_STEREO) return -EINVAL;
143 if (pConfig->outputCfg.accessMode != EFFECT_BUFFER_ACCESS_WRITE &&
144 pConfig->outputCfg.accessMode != EFFECT_BUFFER_ACCESS_ACCUMULATE) return -EINVAL;
145 if (pConfig->inputCfg.format != AUDIO_FORMAT_PCM_16_BIT) return -EINVAL;
146
147 pContext->mConfig = *pConfig;
148
149 Visualizer_reset(pContext);
150
151 return 0;
152 }
153
154
155 //----------------------------------------------------------------------------
156 // Visualizer_getConfig()
157 //----------------------------------------------------------------------------
158 // Purpose: Get input and output audio configuration.
159 //
160 // Inputs:
161 // pContext: effect engine context
162 // pConfig: pointer to effect_config_t structure holding input and output
163 // configuration parameters
164 //
165 // Outputs:
166 //
167 //----------------------------------------------------------------------------
168
Visualizer_getConfig(VisualizerContext * pContext,effect_config_t * pConfig)169 void Visualizer_getConfig(VisualizerContext *pContext, effect_config_t *pConfig)
170 {
171 *pConfig = pContext->mConfig;
172 }
173
174
175 //----------------------------------------------------------------------------
176 // Visualizer_init()
177 //----------------------------------------------------------------------------
178 // Purpose: Initialize engine with default configuration.
179 //
180 // Inputs:
181 // pContext: effect engine context
182 //
183 // Outputs:
184 //
185 //----------------------------------------------------------------------------
186
Visualizer_init(VisualizerContext * pContext)187 int Visualizer_init(VisualizerContext *pContext)
188 {
189 pContext->mConfig.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
190 pContext->mConfig.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
191 pContext->mConfig.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
192 pContext->mConfig.inputCfg.samplingRate = 44100;
193 pContext->mConfig.inputCfg.bufferProvider.getBuffer = NULL;
194 pContext->mConfig.inputCfg.bufferProvider.releaseBuffer = NULL;
195 pContext->mConfig.inputCfg.bufferProvider.cookie = NULL;
196 pContext->mConfig.inputCfg.mask = EFFECT_CONFIG_ALL;
197 pContext->mConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
198 pContext->mConfig.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
199 pContext->mConfig.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
200 pContext->mConfig.outputCfg.samplingRate = 44100;
201 pContext->mConfig.outputCfg.bufferProvider.getBuffer = NULL;
202 pContext->mConfig.outputCfg.bufferProvider.releaseBuffer = NULL;
203 pContext->mConfig.outputCfg.bufferProvider.cookie = NULL;
204 pContext->mConfig.outputCfg.mask = EFFECT_CONFIG_ALL;
205
206 // visualization initialization
207 pContext->mCaptureSize = VISUALIZER_CAPTURE_SIZE_MAX;
208 pContext->mScalingMode = VISUALIZER_SCALING_MODE_NORMALIZED;
209
210 // measurement initialization
211 pContext->mChannelCount =
212 audio_channel_count_from_out_mask(pContext->mConfig.inputCfg.channels);
213 pContext->mMeasurementMode = MEASUREMENT_MODE_NONE;
214 pContext->mMeasurementWindowSizeInBuffers = MEASUREMENT_WINDOW_MAX_SIZE_IN_BUFFERS;
215 pContext->mMeasurementBufferIdx = 0;
216 for (uint32_t i=0 ; i<pContext->mMeasurementWindowSizeInBuffers ; i++) {
217 pContext->mPastMeasurements[i].mIsValid = false;
218 pContext->mPastMeasurements[i].mPeakU16 = 0;
219 pContext->mPastMeasurements[i].mRmsSquared = 0;
220 }
221
222 Visualizer_setConfig(pContext, &pContext->mConfig);
223
224 return 0;
225 }
226
227 //
228 //--- Effect Library Interface Implementation
229 //
230
VisualizerLib_Create(const effect_uuid_t * uuid,int32_t,int32_t,effect_handle_t * pHandle)231 int VisualizerLib_Create(const effect_uuid_t *uuid,
232 int32_t /*sessionId*/,
233 int32_t /*ioId*/,
234 effect_handle_t *pHandle) {
235 int ret;
236 int i;
237
238 if (pHandle == NULL || uuid == NULL) {
239 return -EINVAL;
240 }
241
242 if (memcmp(uuid, &gVisualizerDescriptor.uuid, sizeof(effect_uuid_t)) != 0) {
243 return -EINVAL;
244 }
245
246 VisualizerContext *pContext = new VisualizerContext;
247
248 pContext->mItfe = &gVisualizerInterface;
249 pContext->mState = VISUALIZER_STATE_UNINITIALIZED;
250
251 ret = Visualizer_init(pContext);
252 if (ret < 0) {
253 ALOGW("VisualizerLib_Create() init failed");
254 delete pContext;
255 return ret;
256 }
257
258 *pHandle = (effect_handle_t)pContext;
259
260 pContext->mState = VISUALIZER_STATE_INITIALIZED;
261
262 ALOGV("VisualizerLib_Create %p", pContext);
263
264 return 0;
265
266 }
267
VisualizerLib_Release(effect_handle_t handle)268 int VisualizerLib_Release(effect_handle_t handle) {
269 VisualizerContext * pContext = (VisualizerContext *)handle;
270
271 ALOGV("VisualizerLib_Release %p", handle);
272 if (pContext == NULL) {
273 return -EINVAL;
274 }
275 pContext->mState = VISUALIZER_STATE_UNINITIALIZED;
276 delete pContext;
277
278 return 0;
279 }
280
VisualizerLib_GetDescriptor(const effect_uuid_t * uuid,effect_descriptor_t * pDescriptor)281 int VisualizerLib_GetDescriptor(const effect_uuid_t *uuid,
282 effect_descriptor_t *pDescriptor) {
283
284 if (pDescriptor == NULL || uuid == NULL){
285 ALOGV("VisualizerLib_GetDescriptor() called with NULL pointer");
286 return -EINVAL;
287 }
288
289 if (memcmp(uuid, &gVisualizerDescriptor.uuid, sizeof(effect_uuid_t)) == 0) {
290 *pDescriptor = gVisualizerDescriptor;
291 return 0;
292 }
293
294 return -EINVAL;
295 } /* end VisualizerLib_GetDescriptor */
296
297 //
298 //--- Effect Control Interface Implementation
299 //
300
clamp16(int32_t sample)301 static inline int16_t clamp16(int32_t sample)
302 {
303 if ((sample>>15) ^ (sample>>31))
304 sample = 0x7FFF ^ (sample>>31);
305 return sample;
306 }
307
Visualizer_process(effect_handle_t self,audio_buffer_t * inBuffer,audio_buffer_t * outBuffer)308 int Visualizer_process(
309 effect_handle_t self,audio_buffer_t *inBuffer, audio_buffer_t *outBuffer)
310 {
311 VisualizerContext * pContext = (VisualizerContext *)self;
312
313 if (pContext == NULL) {
314 return -EINVAL;
315 }
316
317 if (inBuffer == NULL || inBuffer->raw == NULL ||
318 outBuffer == NULL || outBuffer->raw == NULL ||
319 inBuffer->frameCount != outBuffer->frameCount ||
320 inBuffer->frameCount == 0) {
321 return -EINVAL;
322 }
323
324 // perform measurements if needed
325 if (pContext->mMeasurementMode & MEASUREMENT_MODE_PEAK_RMS) {
326 // find the peak and RMS squared for the new buffer
327 uint32_t inIdx;
328 int16_t maxSample = 0;
329 float rmsSqAcc = 0;
330 for (inIdx = 0 ; inIdx < inBuffer->frameCount * pContext->mChannelCount ; inIdx++) {
331 if (inBuffer->s16[inIdx] > maxSample) {
332 maxSample = inBuffer->s16[inIdx];
333 } else if (-inBuffer->s16[inIdx] > maxSample) {
334 maxSample = -inBuffer->s16[inIdx];
335 }
336 rmsSqAcc += (inBuffer->s16[inIdx] * inBuffer->s16[inIdx]);
337 }
338 // store the measurement
339 pContext->mPastMeasurements[pContext->mMeasurementBufferIdx].mPeakU16 = (uint16_t)maxSample;
340 pContext->mPastMeasurements[pContext->mMeasurementBufferIdx].mRmsSquared =
341 rmsSqAcc / (inBuffer->frameCount * pContext->mChannelCount);
342 pContext->mPastMeasurements[pContext->mMeasurementBufferIdx].mIsValid = true;
343 if (++pContext->mMeasurementBufferIdx >= pContext->mMeasurementWindowSizeInBuffers) {
344 pContext->mMeasurementBufferIdx = 0;
345 }
346 }
347
348 // all code below assumes stereo 16 bit PCM output and input
349 int32_t shift;
350
351 if (pContext->mScalingMode == VISUALIZER_SCALING_MODE_NORMALIZED) {
352 // derive capture scaling factor from peak value in current buffer
353 // this gives more interesting captures for display.
354 shift = 32;
355 int len = inBuffer->frameCount * 2;
356 for (int i = 0; i < len; i++) {
357 int32_t smp = inBuffer->s16[i];
358 if (smp < 0) smp = -smp - 1; // take care to keep the max negative in range
359 int32_t clz = __builtin_clz(smp);
360 if (shift > clz) shift = clz;
361 }
362 // A maximum amplitude signal will have 17 leading zeros, which we want to
363 // translate to a shift of 8 (for converting 16 bit to 8 bit)
364 shift = 25 - shift;
365 // Never scale by less than 8 to avoid returning unaltered PCM signal.
366 if (shift < 3) {
367 shift = 3;
368 }
369 // add one to combine the division by 2 needed after summing left and right channels below
370 shift++;
371 } else {
372 assert(pContext->mScalingMode == VISUALIZER_SCALING_MODE_AS_PLAYED);
373 shift = 9;
374 }
375
376 uint32_t captIdx;
377 uint32_t inIdx;
378 uint8_t *buf = pContext->mCaptureBuf;
379 for (inIdx = 0, captIdx = pContext->mCaptureIdx;
380 inIdx < inBuffer->frameCount;
381 inIdx++, captIdx++) {
382 if (captIdx >= CAPTURE_BUF_SIZE) {
383 // wrap around
384 captIdx = 0;
385 }
386 int32_t smp = inBuffer->s16[2 * inIdx] + inBuffer->s16[2 * inIdx + 1];
387 smp = smp >> shift;
388 buf[captIdx] = ((uint8_t)smp)^0x80;
389 }
390
391 // XXX the following two should really be atomic, though it probably doesn't
392 // matter much for visualization purposes
393 pContext->mCaptureIdx = captIdx;
394 // update last buffer update time stamp
395 if (clock_gettime(CLOCK_MONOTONIC, &pContext->mBufferUpdateTime) < 0) {
396 pContext->mBufferUpdateTime.tv_sec = 0;
397 }
398
399 if (inBuffer->raw != outBuffer->raw) {
400 if (pContext->mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
401 for (size_t i = 0; i < outBuffer->frameCount*2; i++) {
402 outBuffer->s16[i] = clamp16(outBuffer->s16[i] + inBuffer->s16[i]);
403 }
404 } else {
405 memcpy(outBuffer->raw, inBuffer->raw, outBuffer->frameCount * 2 * sizeof(int16_t));
406 }
407 }
408 if (pContext->mState != VISUALIZER_STATE_ACTIVE) {
409 return -ENODATA;
410 }
411 return 0;
412 } // end Visualizer_process
413
Visualizer_command(effect_handle_t self,uint32_t cmdCode,uint32_t cmdSize,void * pCmdData,uint32_t * replySize,void * pReplyData)414 int Visualizer_command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize,
415 void *pCmdData, uint32_t *replySize, void *pReplyData) {
416
417 VisualizerContext * pContext = (VisualizerContext *)self;
418 int retsize;
419
420 if (pContext == NULL || pContext->mState == VISUALIZER_STATE_UNINITIALIZED) {
421 return -EINVAL;
422 }
423
424 // ALOGV("Visualizer_command command %" PRIu32 " cmdSize %" PRIu32, cmdCode, cmdSize);
425
426 switch (cmdCode) {
427 case EFFECT_CMD_INIT:
428 if (pReplyData == NULL || replySize == NULL || *replySize != sizeof(int)) {
429 return -EINVAL;
430 }
431 *(int *) pReplyData = Visualizer_init(pContext);
432 break;
433 case EFFECT_CMD_SET_CONFIG:
434 if (pCmdData == NULL || cmdSize != sizeof(effect_config_t)
435 || pReplyData == NULL || replySize == NULL || *replySize != sizeof(int)) {
436 return -EINVAL;
437 }
438 *(int *) pReplyData = Visualizer_setConfig(pContext,
439 (effect_config_t *) pCmdData);
440 break;
441 case EFFECT_CMD_GET_CONFIG:
442 if (pReplyData == NULL || replySize == NULL ||
443 *replySize != sizeof(effect_config_t)) {
444 return -EINVAL;
445 }
446 Visualizer_getConfig(pContext, (effect_config_t *)pReplyData);
447 break;
448 case EFFECT_CMD_RESET:
449 Visualizer_reset(pContext);
450 break;
451 case EFFECT_CMD_ENABLE:
452 if (pReplyData == NULL || replySize == NULL || *replySize != sizeof(int)) {
453 return -EINVAL;
454 }
455 if (pContext->mState != VISUALIZER_STATE_INITIALIZED) {
456 return -ENOSYS;
457 }
458 pContext->mState = VISUALIZER_STATE_ACTIVE;
459 ALOGV("EFFECT_CMD_ENABLE() OK");
460 *(int *)pReplyData = 0;
461 break;
462 case EFFECT_CMD_DISABLE:
463 if (pReplyData == NULL || replySize == NULL || *replySize != sizeof(int)) {
464 return -EINVAL;
465 }
466 if (pContext->mState != VISUALIZER_STATE_ACTIVE) {
467 return -ENOSYS;
468 }
469 pContext->mState = VISUALIZER_STATE_INITIALIZED;
470 ALOGV("EFFECT_CMD_DISABLE() OK");
471 *(int *)pReplyData = 0;
472 break;
473 case EFFECT_CMD_GET_PARAM: {
474 if (pCmdData == NULL ||
475 cmdSize != (int)(sizeof(effect_param_t) + sizeof(uint32_t)) ||
476 pReplyData == NULL || replySize == NULL ||
477 *replySize < (int)(sizeof(effect_param_t) + sizeof(uint32_t) + sizeof(uint32_t))) {
478 return -EINVAL;
479 }
480 memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + sizeof(uint32_t));
481 effect_param_t *p = (effect_param_t *)pReplyData;
482 p->status = 0;
483 *replySize = sizeof(effect_param_t) + sizeof(uint32_t);
484 if (p->psize != sizeof(uint32_t)) {
485 p->status = -EINVAL;
486 break;
487 }
488 switch (*(uint32_t *)p->data) {
489 case VISUALIZER_PARAM_CAPTURE_SIZE:
490 ALOGV("get mCaptureSize = %" PRIu32, pContext->mCaptureSize);
491 *((uint32_t *)p->data + 1) = pContext->mCaptureSize;
492 p->vsize = sizeof(uint32_t);
493 *replySize += sizeof(uint32_t);
494 break;
495 case VISUALIZER_PARAM_SCALING_MODE:
496 ALOGV("get mScalingMode = %" PRIu32, pContext->mScalingMode);
497 *((uint32_t *)p->data + 1) = pContext->mScalingMode;
498 p->vsize = sizeof(uint32_t);
499 *replySize += sizeof(uint32_t);
500 break;
501 case VISUALIZER_PARAM_MEASUREMENT_MODE:
502 ALOGV("get mMeasurementMode = %" PRIu32, pContext->mMeasurementMode);
503 *((uint32_t *)p->data + 1) = pContext->mMeasurementMode;
504 p->vsize = sizeof(uint32_t);
505 *replySize += sizeof(uint32_t);
506 break;
507 default:
508 p->status = -EINVAL;
509 }
510 } break;
511 case EFFECT_CMD_SET_PARAM: {
512 if (pCmdData == NULL ||
513 cmdSize != (int)(sizeof(effect_param_t) + sizeof(uint32_t) + sizeof(uint32_t)) ||
514 pReplyData == NULL || replySize == NULL || *replySize != sizeof(int32_t)) {
515 return -EINVAL;
516 }
517 *(int32_t *)pReplyData = 0;
518 effect_param_t *p = (effect_param_t *)pCmdData;
519 if (p->psize != sizeof(uint32_t) || p->vsize != sizeof(uint32_t)) {
520 *(int32_t *)pReplyData = -EINVAL;
521 break;
522 }
523 switch (*(uint32_t *)p->data) {
524 case VISUALIZER_PARAM_CAPTURE_SIZE:
525 pContext->mCaptureSize = *((uint32_t *)p->data + 1);
526 ALOGV("set mCaptureSize = %" PRIu32, pContext->mCaptureSize);
527 break;
528 case VISUALIZER_PARAM_SCALING_MODE:
529 pContext->mScalingMode = *((uint32_t *)p->data + 1);
530 ALOGV("set mScalingMode = %" PRIu32, pContext->mScalingMode);
531 break;
532 case VISUALIZER_PARAM_LATENCY:
533 pContext->mLatency = *((uint32_t *)p->data + 1);
534 ALOGV("set mLatency = %" PRIu32, pContext->mLatency);
535 break;
536 case VISUALIZER_PARAM_MEASUREMENT_MODE:
537 pContext->mMeasurementMode = *((uint32_t *)p->data + 1);
538 ALOGV("set mMeasurementMode = %" PRIu32, pContext->mMeasurementMode);
539 break;
540 default:
541 *(int32_t *)pReplyData = -EINVAL;
542 }
543 } break;
544 case EFFECT_CMD_SET_DEVICE:
545 case EFFECT_CMD_SET_VOLUME:
546 case EFFECT_CMD_SET_AUDIO_MODE:
547 break;
548
549
550 case VISUALIZER_CMD_CAPTURE: {
551 uint32_t captureSize = pContext->mCaptureSize;
552 if (pReplyData == NULL || replySize == NULL || *replySize != captureSize) {
553 ALOGV("VISUALIZER_CMD_CAPTURE() error *replySize %" PRIu32 " captureSize %" PRIu32,
554 *replySize, captureSize);
555 return -EINVAL;
556 }
557 if (pContext->mState == VISUALIZER_STATE_ACTIVE) {
558 const uint32_t deltaMs = Visualizer_getDeltaTimeMsFromUpdatedTime(pContext);
559
560 // if audio framework has stopped playing audio although the effect is still
561 // active we must clear the capture buffer to return silence
562 if ((pContext->mLastCaptureIdx == pContext->mCaptureIdx) &&
563 (pContext->mBufferUpdateTime.tv_sec != 0) &&
564 (deltaMs > MAX_STALL_TIME_MS)) {
565 ALOGV("capture going to idle");
566 pContext->mBufferUpdateTime.tv_sec = 0;
567 memset(pReplyData, 0x80, captureSize);
568 } else {
569 int32_t latencyMs = pContext->mLatency;
570 latencyMs -= deltaMs;
571 if (latencyMs < 0) {
572 latencyMs = 0;
573 }
574 const uint32_t deltaSmpl =
575 pContext->mConfig.inputCfg.samplingRate * latencyMs / 1000;
576 int32_t capturePoint = pContext->mCaptureIdx - captureSize - deltaSmpl;
577
578 if (capturePoint < 0) {
579 uint32_t size = -capturePoint;
580 if (size > captureSize) {
581 size = captureSize;
582 }
583 memcpy(pReplyData,
584 pContext->mCaptureBuf + CAPTURE_BUF_SIZE + capturePoint,
585 size);
586 pReplyData = (char *)pReplyData + size;
587 captureSize -= size;
588 capturePoint = 0;
589 }
590 memcpy(pReplyData,
591 pContext->mCaptureBuf + capturePoint,
592 captureSize);
593 }
594
595 pContext->mLastCaptureIdx = pContext->mCaptureIdx;
596 } else {
597 memset(pReplyData, 0x80, captureSize);
598 }
599
600 } break;
601
602 case VISUALIZER_CMD_MEASURE: {
603 if (pReplyData == NULL || replySize == NULL ||
604 *replySize < (sizeof(int32_t) * MEASUREMENT_COUNT)) {
605 ALOGV("VISUALIZER_CMD_MEASURE() error *replySize %" PRIu32
606 " < (sizeof(int32_t) * MEASUREMENT_COUNT) %" PRIu32, *replySize,
607 sizeof(int32_t) * MEASUREMENT_COUNT);
608 android_errorWriteLog(0x534e4554, "30229821");
609 return -EINVAL;
610 }
611 uint16_t peakU16 = 0;
612 float sumRmsSquared = 0.0f;
613 uint8_t nbValidMeasurements = 0;
614 // reset measurements if last measurement was too long ago (which implies stored
615 // measurements aren't relevant anymore and shouldn't bias the new one)
616 const int32_t delayMs = Visualizer_getDeltaTimeMsFromUpdatedTime(pContext);
617 if (delayMs > DISCARD_MEASUREMENTS_TIME_MS) {
618 ALOGV("Discarding measurements, last measurement is %" PRId32 "ms old", delayMs);
619 for (uint32_t i=0 ; i<pContext->mMeasurementWindowSizeInBuffers ; i++) {
620 pContext->mPastMeasurements[i].mIsValid = false;
621 pContext->mPastMeasurements[i].mPeakU16 = 0;
622 pContext->mPastMeasurements[i].mRmsSquared = 0;
623 }
624 pContext->mMeasurementBufferIdx = 0;
625 } else {
626 // only use actual measurements, otherwise the first RMS measure happening before
627 // MEASUREMENT_WINDOW_MAX_SIZE_IN_BUFFERS have been played will always be artificially
628 // low
629 for (uint32_t i=0 ; i < pContext->mMeasurementWindowSizeInBuffers ; i++) {
630 if (pContext->mPastMeasurements[i].mIsValid) {
631 if (pContext->mPastMeasurements[i].mPeakU16 > peakU16) {
632 peakU16 = pContext->mPastMeasurements[i].mPeakU16;
633 }
634 sumRmsSquared += pContext->mPastMeasurements[i].mRmsSquared;
635 nbValidMeasurements++;
636 }
637 }
638 }
639 float rms = nbValidMeasurements == 0 ? 0.0f : sqrtf(sumRmsSquared / nbValidMeasurements);
640 int32_t* pIntReplyData = (int32_t*)pReplyData;
641 // convert from I16 sample values to mB and write results
642 if (rms < 0.000016f) {
643 pIntReplyData[MEASUREMENT_IDX_RMS] = -9600; //-96dB
644 } else {
645 pIntReplyData[MEASUREMENT_IDX_RMS] = (int32_t) (2000 * log10(rms / 32767.0f));
646 }
647 if (peakU16 == 0) {
648 pIntReplyData[MEASUREMENT_IDX_PEAK] = -9600; //-96dB
649 } else {
650 pIntReplyData[MEASUREMENT_IDX_PEAK] = (int32_t) (2000 * log10(peakU16 / 32767.0f));
651 }
652 ALOGV("VISUALIZER_CMD_MEASURE peak=%" PRIu16 " (%" PRId32 "mB), rms=%.1f (%" PRId32 "mB)",
653 peakU16, pIntReplyData[MEASUREMENT_IDX_PEAK],
654 rms, pIntReplyData[MEASUREMENT_IDX_RMS]);
655 }
656 break;
657
658 default:
659 ALOGW("Visualizer_command invalid command %" PRIu32, cmdCode);
660 return -EINVAL;
661 }
662
663 return 0;
664 }
665
666 /* Effect Control Interface Implementation: get_descriptor */
Visualizer_getDescriptor(effect_handle_t self,effect_descriptor_t * pDescriptor)667 int Visualizer_getDescriptor(effect_handle_t self,
668 effect_descriptor_t *pDescriptor)
669 {
670 VisualizerContext * pContext = (VisualizerContext *) self;
671
672 if (pContext == NULL || pDescriptor == NULL) {
673 ALOGV("Visualizer_getDescriptor() invalid param");
674 return -EINVAL;
675 }
676
677 *pDescriptor = gVisualizerDescriptor;
678
679 return 0;
680 } /* end Visualizer_getDescriptor */
681
682 // effect_handle_t interface implementation for visualizer effect
683 const struct effect_interface_s gVisualizerInterface = {
684 Visualizer_process,
685 Visualizer_command,
686 Visualizer_getDescriptor,
687 NULL,
688 };
689
690 // This is the only symbol that needs to be exported
691 __attribute__ ((visibility ("default")))
692 audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = {
693 .tag = AUDIO_EFFECT_LIBRARY_TAG,
694 .version = EFFECT_LIBRARY_API_VERSION,
695 .name = "Visualizer Library",
696 .implementor = "The Android Open Source Project",
697 .create_effect = VisualizerLib_Create,
698 .release_effect = VisualizerLib_Release,
699 .get_descriptor = VisualizerLib_GetDescriptor,
700 };
701
702 }; // extern "C"
703