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 "Visualizer"
21 #include <utils/Log.h>
22
23 #include <stdint.h>
24 #include <sys/types.h>
25 #include <limits.h>
26
27 #include <cutils/bitops.h>
28
29 #include <media/Visualizer.h>
30 #include <audio_utils/fixedfft.h>
31
32 namespace android {
33
34 // ---------------------------------------------------------------------------
35
Visualizer(int32_t priority,effect_callback_t cbf,void * user,int sessionId)36 Visualizer::Visualizer (int32_t priority,
37 effect_callback_t cbf,
38 void* user,
39 int sessionId)
40 : AudioEffect(SL_IID_VISUALIZATION, NULL, priority, cbf, user, sessionId),
41 mCaptureRate(CAPTURE_RATE_DEF),
42 mCaptureSize(CAPTURE_SIZE_DEF),
43 mSampleRate(44100000),
44 mScalingMode(VISUALIZER_SCALING_MODE_NORMALIZED),
45 mCaptureCallBack(NULL),
46 mCaptureCbkUser(NULL)
47 {
48 initCaptureSize();
49 }
50
~Visualizer()51 Visualizer::~Visualizer()
52 {
53 }
54
setEnabled(bool enabled)55 status_t Visualizer::setEnabled(bool enabled)
56 {
57 Mutex::Autolock _l(mCaptureLock);
58
59 sp<CaptureThread> t = mCaptureThread;
60 if (t != 0) {
61 if (enabled) {
62 if (t->exitPending()) {
63 if (t->requestExitAndWait() == WOULD_BLOCK) {
64 ALOGE("Visualizer::enable() called from thread");
65 return INVALID_OPERATION;
66 }
67 }
68 }
69 t->mLock.lock();
70 }
71
72 status_t status = AudioEffect::setEnabled(enabled);
73
74 if (status == NO_ERROR) {
75 if (t != 0) {
76 if (enabled) {
77 t->run("Visualizer");
78 } else {
79 t->requestExit();
80 }
81 }
82 }
83
84 if (t != 0) {
85 t->mLock.unlock();
86 }
87
88 return status;
89 }
90
setCaptureCallBack(capture_cbk_t cbk,void * user,uint32_t flags,uint32_t rate)91 status_t Visualizer::setCaptureCallBack(capture_cbk_t cbk, void* user, uint32_t flags,
92 uint32_t rate)
93 {
94 if (rate > CAPTURE_RATE_MAX) {
95 return BAD_VALUE;
96 }
97 Mutex::Autolock _l(mCaptureLock);
98
99 if (mEnabled) {
100 return INVALID_OPERATION;
101 }
102
103 sp<CaptureThread> t = mCaptureThread;
104 if (t != 0) {
105 t->mLock.lock();
106 }
107 mCaptureThread.clear();
108 mCaptureCallBack = cbk;
109 mCaptureCbkUser = user;
110 mCaptureFlags = flags;
111 mCaptureRate = rate;
112
113 if (t != 0) {
114 t->mLock.unlock();
115 }
116
117 if (cbk != NULL) {
118 mCaptureThread = new CaptureThread(*this, rate, ((flags & CAPTURE_CALL_JAVA) != 0));
119 }
120 ALOGV("setCaptureCallBack() rate: %d thread %p flags 0x%08x",
121 rate, mCaptureThread.get(), mCaptureFlags);
122 return NO_ERROR;
123 }
124
setCaptureSize(uint32_t size)125 status_t Visualizer::setCaptureSize(uint32_t size)
126 {
127 if (size > VISUALIZER_CAPTURE_SIZE_MAX ||
128 size < VISUALIZER_CAPTURE_SIZE_MIN ||
129 popcount(size) != 1) {
130 return BAD_VALUE;
131 }
132
133 Mutex::Autolock _l(mCaptureLock);
134 if (mEnabled) {
135 return INVALID_OPERATION;
136 }
137
138 uint32_t buf32[sizeof(effect_param_t) / sizeof(uint32_t) + 2];
139 effect_param_t *p = (effect_param_t *)buf32;
140
141 p->psize = sizeof(uint32_t);
142 p->vsize = sizeof(uint32_t);
143 *(int32_t *)p->data = VISUALIZER_PARAM_CAPTURE_SIZE;
144 *((int32_t *)p->data + 1)= size;
145 status_t status = setParameter(p);
146
147 ALOGV("setCaptureSize size %d status %d p->status %d", size, status, p->status);
148
149 if (status == NO_ERROR) {
150 status = p->status;
151 if (status == NO_ERROR) {
152 mCaptureSize = size;
153 }
154 }
155
156 return status;
157 }
158
setScalingMode(uint32_t mode)159 status_t Visualizer::setScalingMode(uint32_t mode) {
160 if ((mode != VISUALIZER_SCALING_MODE_NORMALIZED)
161 && (mode != VISUALIZER_SCALING_MODE_AS_PLAYED)) {
162 return BAD_VALUE;
163 }
164
165 Mutex::Autolock _l(mCaptureLock);
166
167 uint32_t buf32[sizeof(effect_param_t) / sizeof(uint32_t) + 2];
168 effect_param_t *p = (effect_param_t *)buf32;
169
170 p->psize = sizeof(uint32_t);
171 p->vsize = sizeof(uint32_t);
172 *(int32_t *)p->data = VISUALIZER_PARAM_SCALING_MODE;
173 *((int32_t *)p->data + 1)= mode;
174 status_t status = setParameter(p);
175
176 ALOGV("setScalingMode mode %d status %d p->status %d", mode, status, p->status);
177
178 if (status == NO_ERROR) {
179 status = p->status;
180 if (status == NO_ERROR) {
181 mScalingMode = mode;
182 }
183 }
184
185 return status;
186 }
187
getWaveForm(uint8_t * waveform)188 status_t Visualizer::getWaveForm(uint8_t *waveform)
189 {
190 if (waveform == NULL) {
191 return BAD_VALUE;
192 }
193 if (mCaptureSize == 0) {
194 return NO_INIT;
195 }
196
197 status_t status = NO_ERROR;
198 if (mEnabled) {
199 uint32_t replySize = mCaptureSize;
200 status = command(VISUALIZER_CMD_CAPTURE, 0, NULL, &replySize, waveform);
201 ALOGV("getWaveForm() command returned %d", status);
202 if ((status == NO_ERROR) && (replySize == 0)) {
203 status = NOT_ENOUGH_DATA;
204 }
205 } else {
206 ALOGV("getWaveForm() disabled");
207 memset(waveform, 0x80, mCaptureSize);
208 }
209 return status;
210 }
211
getFft(uint8_t * fft)212 status_t Visualizer::getFft(uint8_t *fft)
213 {
214 if (fft == NULL) {
215 return BAD_VALUE;
216 }
217 if (mCaptureSize == 0) {
218 return NO_INIT;
219 }
220
221 status_t status = NO_ERROR;
222 if (mEnabled) {
223 uint8_t buf[mCaptureSize];
224 status = getWaveForm(buf);
225 if (status == NO_ERROR) {
226 status = doFft(fft, buf);
227 }
228 } else {
229 memset(fft, 0, mCaptureSize);
230 }
231 return status;
232 }
233
doFft(uint8_t * fft,uint8_t * waveform)234 status_t Visualizer::doFft(uint8_t *fft, uint8_t *waveform)
235 {
236 int32_t workspace[mCaptureSize >> 1];
237 int32_t nonzero = 0;
238
239 for (uint32_t i = 0; i < mCaptureSize; i += 2) {
240 workspace[i >> 1] =
241 ((waveform[i] ^ 0x80) << 24) | ((waveform[i + 1] ^ 0x80) << 8);
242 nonzero |= workspace[i >> 1];
243 }
244
245 if (nonzero) {
246 fixed_fft_real(mCaptureSize >> 1, workspace);
247 }
248
249 for (uint32_t i = 0; i < mCaptureSize; i += 2) {
250 short tmp = workspace[i >> 1] >> 21;
251 while (tmp > 127 || tmp < -128) tmp >>= 1;
252 fft[i] = tmp;
253 tmp = workspace[i >> 1];
254 tmp >>= 5;
255 while (tmp > 127 || tmp < -128) tmp >>= 1;
256 fft[i + 1] = tmp;
257 }
258
259 return NO_ERROR;
260 }
261
periodicCapture()262 void Visualizer::periodicCapture()
263 {
264 Mutex::Autolock _l(mCaptureLock);
265 ALOGV("periodicCapture() %p mCaptureCallBack %p mCaptureFlags 0x%08x",
266 this, mCaptureCallBack, mCaptureFlags);
267 if (mCaptureCallBack != NULL &&
268 (mCaptureFlags & (CAPTURE_WAVEFORM|CAPTURE_FFT)) &&
269 mCaptureSize != 0) {
270 uint8_t waveform[mCaptureSize];
271 status_t status = getWaveForm(waveform);
272 if (status != NO_ERROR) {
273 return;
274 }
275 uint8_t fft[mCaptureSize];
276 if (mCaptureFlags & CAPTURE_FFT) {
277 status = doFft(fft, waveform);
278 }
279 if (status != NO_ERROR) {
280 return;
281 }
282 uint8_t *wavePtr = NULL;
283 uint8_t *fftPtr = NULL;
284 uint32_t waveSize = 0;
285 uint32_t fftSize = 0;
286 if (mCaptureFlags & CAPTURE_WAVEFORM) {
287 wavePtr = waveform;
288 waveSize = mCaptureSize;
289 }
290 if (mCaptureFlags & CAPTURE_FFT) {
291 fftPtr = fft;
292 fftSize = mCaptureSize;
293 }
294 mCaptureCallBack(mCaptureCbkUser, waveSize, wavePtr, fftSize, fftPtr, mSampleRate);
295 }
296 }
297
initCaptureSize()298 uint32_t Visualizer::initCaptureSize()
299 {
300 uint32_t buf32[sizeof(effect_param_t) / sizeof(uint32_t) + 2];
301 effect_param_t *p = (effect_param_t *)buf32;
302
303 p->psize = sizeof(uint32_t);
304 p->vsize = sizeof(uint32_t);
305 *(int32_t *)p->data = VISUALIZER_PARAM_CAPTURE_SIZE;
306 status_t status = getParameter(p);
307
308 if (status == NO_ERROR) {
309 status = p->status;
310 }
311
312 uint32_t size = 0;
313 if (status == NO_ERROR) {
314 size = *((int32_t *)p->data + 1);
315 }
316 mCaptureSize = size;
317
318 ALOGV("initCaptureSize size %d status %d", mCaptureSize, status);
319
320 return size;
321 }
322
controlStatusChanged(bool controlGranted)323 void Visualizer::controlStatusChanged(bool controlGranted) {
324 if (controlGranted) {
325 // this Visualizer instance regained control of the effect, reset the scaling mode
326 // and capture size as has been cached through it.
327 ALOGV("controlStatusChanged(true) causes effect parameter reset:");
328 ALOGV(" scaling mode reset to %d", mScalingMode);
329 setScalingMode(mScalingMode);
330 ALOGV(" capture size reset to %d", mCaptureSize);
331 setCaptureSize(mCaptureSize);
332 }
333 AudioEffect::controlStatusChanged(controlGranted);
334 }
335
336 //-------------------------------------------------------------------------
337
CaptureThread(Visualizer & receiver,uint32_t captureRate,bool bCanCallJava)338 Visualizer::CaptureThread::CaptureThread(Visualizer& receiver, uint32_t captureRate,
339 bool bCanCallJava)
340 : Thread(bCanCallJava), mReceiver(receiver)
341 {
342 mSleepTimeUs = 1000000000 / captureRate;
343 ALOGV("CaptureThread cstor %p captureRate %d mSleepTimeUs %d", this, captureRate, mSleepTimeUs);
344 }
345
threadLoop()346 bool Visualizer::CaptureThread::threadLoop()
347 {
348 ALOGV("CaptureThread %p enter", this);
349 while (!exitPending())
350 {
351 usleep(mSleepTimeUs);
352 mReceiver.periodicCapture();
353 }
354 ALOGV("CaptureThread %p exiting", this);
355 return false;
356 }
357
358 }; // namespace android
359