Visualizer.cpp revision 8af901cdea0af7e536579dee6d56e69987035a01 
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,
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
125status_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
159status_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
188status_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
212status_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
234status_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
262void 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
298uint32_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
323void 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
338Visualizer::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
346bool 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