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