Home | History | Annotate | Download | only in libmedia 
      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