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 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 51 Visualizer::~Visualizer() 52 { 53 } 54 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 91 status_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 124 status_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 158 status_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 187 status_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 211 status_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 233 status_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 261 void 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 297 uint32_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 322 void 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 337 Visualizer::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 344 bool 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