drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
android_frameworks_base/media/libmedia/ToneGenerator.cpp
The Android Open Source Project 54b6cfa9a9 Initial Contribution
2008-10-21 07:00:00 -07:00

663 lines
22 KiB
C++
Raw Blame History

/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "ToneGenerator"
#include <utils/threads.h>
#include <stdio.h>
#include <math.h>
#include <utils/Log.h>
#include <sys/resource.h>
#include <utils/RefBase.h>
#include <utils/Timers.h>
#include "media/ToneGenerator.h"
namespace android {
// Descriptors for all available tones (See ToneGenerator::ToneDescriptor class declaration for details)
const ToneGenerator::ToneDescriptor
ToneGenerator::toneDescriptors[NUM_TONES] = {
// waveFreq[] segments[] repeatCnt
{ { 1336, 941, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_0
{ { 1209, 697, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_1
{ { 1336, 697, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_2
{ { 1477, 697, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_3
{ { 1209, 770, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_4
{ { 1336, 770, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_5
{ { 1477, 770, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_6
{ { 1209, 852, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_7
{ { 1336, 852, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_8
{ { 1477, 852, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_9
{ { 1209, 941, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_S
{ { 1477, 941, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_P
{ { 1633, 697, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_A
{ { 1633, 770, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_B
{ { 1633, 852, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_C
{ { 1633, 941, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_DTMF_D
{ { 425, 0 }, { ToneGenerator::TONEGEN_INF, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_SUP_DIAL
{ { 425, 0 }, { 500, 500, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_SUP_BUSY
{ { 425, 0 }, { 200, 200, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_SUP_CONGESTION
{ { 425, 0 }, { 200, 0 }, 0 }, // TONE_SUP_RADIO_ACK
{ { 425, 0 }, { 200, 200, 0 }, 2 }, // TONE_SUP_RADIO_NOTAVAIL
{ { 950, 1400, 1800, 0 }, { 330, 1000, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_SUP_ERROR
{ { 425, 0 }, { 200, 600, 200, 3000, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_SUP_CALL_WAITING
{ { 425, 0 }, { 1000, 4000, 0 }, ToneGenerator::TONEGEN_INF }, // TONE_SUP_RINGTONE
{ { 400, 1200, 0 }, { 35, 0 }, 0 }, // TONE_PROP_BEEP
{ { 1200, 0 }, { 100, 100, 0 }, 1 }, // TONE_PROP_ACK
{ { 300, 400, 500, 0 }, { 400, 0 }, 0 }, // TONE_PROP_NACK
{ { 400, 1200, 0 }, { 200, 0 }, 0 }, // TONE_PROP_PROMPT
{ { 400, 1200, 0 }, { 35, 200, 35, 0 }, 0 } // TONE_PROP_BEEP2
};
////////////////////////////////////////////////////////////////////////////////
// ToneGenerator class Implementation
////////////////////////////////////////////////////////////////////////////////
//---------------------------------- public methods ----------------------------
////////////////////////////////////////////////////////////////////////////////
//
// Method: ToneGenerator::ToneGenerator()
//
// Description: Constructor. Initializes the tone sequencer, intantiates required sine wave
// generators, instantiates output audio track.
//
// Input:
// toneType: Type of tone generated (values in enum tone_type)
// streamType: Type of stream used for tone playback (enum AudioTrack::stream_type)
// volume: volume applied to tone (0.0 to 1.0)
//
// Output:
// none
//
////////////////////////////////////////////////////////////////////////////////
ToneGenerator::ToneGenerator(int streamType, float volume) {
const sp<IAudioFlinger>& lpAudioFlinger = AudioSystem::get_audio_flinger();
LOGV("ToneGenerator constructor: streamType=%d, volume=%f\n", streamType, volume);
mState = TONE_IDLE;
mpAudioTrack = 0;
mpToneDesc = 0;
mpNewToneDesc = 0;
if (lpAudioFlinger == 0) {
LOGE("Unable to marshal AudioFlinger");
goto ToneGenerator_exit;
}
mSamplingRate = lpAudioFlinger->sampleRate();
mVolume = volume;
// Open audio track in mono, PCM 16bit, default sampling rate, 2 buffers
mpAudioTrack
= new AudioTrack(streamType, 0, AudioSystem::PCM_16_BIT, 1, NUM_PCM_BUFFERS, 0, audioCallback, this);
if (mpAudioTrack == 0) {
LOGE("AudioTrack allocation failed");
goto ToneGenerator_exit;
}
LOGV("Create Track: %p\n", mpAudioTrack);
if (mpAudioTrack->initCheck() != NO_ERROR) {
LOGE("AudioTrack->initCheck failed");
goto ToneGenerator_exit;
}
mpAudioTrack->setVolume(volume, volume);
LOGV("ToneGenerator INIT OK, time: %d\n", (unsigned int)(systemTime()/1000000));
mState = TONE_INIT;
return;
ToneGenerator_exit:
// Cleanup
if (mpAudioTrack) {
LOGV("Delete Track I: %p\n", mpAudioTrack);
delete mpAudioTrack;
}
LOGV("!!!ToneGenerator INIT FAILED!!!\n");
}
////////////////////////////////////////////////////////////////////////////////
//
// Method: ToneGenerator::~ToneGenerator()
//
// Description: Destructor. Stop sound playback and delete audio track if
// needed and delete sine wave generators.
//
// Input:
// none
//
// Output:
// none
//
////////////////////////////////////////////////////////////////////////////////
ToneGenerator::~ToneGenerator() {
LOGV("ToneGenerator destructor\n");
if (mpAudioTrack) {
stopTone();
LOGV("Delete Track: %p\n", mpAudioTrack);
delete mpAudioTrack;
}
}
////////////////////////////////////////////////////////////////////////////////
//
// Method: ToneGenerator::startTone()
//
// Description: Starts tone playback.
//
// Input:
// none
//
// Output:
// none
//
////////////////////////////////////////////////////////////////////////////////
bool ToneGenerator::startTone(int toneType) {
bool lResult = false;
if (mState == TONE_IDLE || toneType >= NUM_TONES)
return lResult;
LOGV("startTone\n");
mLock.lock();
// Get descriptor for requested tone
mpNewToneDesc = &toneDescriptors[toneType];
if (mState == TONE_INIT) {
if (prepareWave()) {
LOGV("Immediate start, time %d\n", (unsigned int)(systemTime()/1000000));
mState = TONE_STARTING;
mLock.unlock();
mpAudioTrack->start();
mLock.lock();
if (mState == TONE_STARTING) {
if (mWaitCbkCond.waitRelative(mLock, seconds(1)) != NO_ERROR)
LOGE("--- timed out");
}
if (mState == TONE_PLAYING)
lResult = true;
}
} else {
LOGV("Delayed start\n");
mState = TONE_RESTARTING;
if (mWaitCbkCond.waitRelative(mLock, seconds(1)) == NO_ERROR) {
if (mState != TONE_INIT) {
lResult = true;
}
LOGV("cond received");
} else {
LOGE("--- timed out");
}
}
mLock.unlock();
LOGV("Tone started, time %d\n", (unsigned int)(systemTime()/1000000));
return lResult;
}
////////////////////////////////////////////////////////////////////////////////
//
// Method: ToneGenerator::stopTone()
//
// Description: Stops tone playback.
//
// Input:
// none
//
// Output:
// none
//
////////////////////////////////////////////////////////////////////////////////
void ToneGenerator::stopTone() {
LOGV("stopTone");
mLock.lock();
if (mState == TONE_PLAYING || mState == TONE_STARTING || mState == TONE_RESTARTING) {
mState = TONE_STOPPING;
LOGV("waiting cond");
status_t lStatus = mWaitCbkCond.waitRelative(mLock, seconds(1));
if (lStatus == NO_ERROR) {
LOGV("track stop complete, time %d", (unsigned int)(systemTime()/1000000));
} else {
LOGE("--- timed out");
mState = TONE_INIT;
}
}
clearWaveGens();
mLock.unlock();
}
//---------------------------------- private methods ---------------------------
////////////////////////////////////////////////////////////////////////////////
//
// Method: ToneGenerator::audioCallback()
//
// Description: AudioTrack callback implementation. Generates a block of
// PCM samples
// and manages tone generator sequencer: tones pulses, tone duration...
//
// Input:
// user reference (pointer to our ToneGenerator)
// info audio buffer descriptor
//
// Output:
// returned value: always true.
//
////////////////////////////////////////////////////////////////////////////////
void ToneGenerator::audioCallback(void* user, const AudioTrack::Buffer& info) {
ToneGenerator *lpToneGen = static_cast<ToneGenerator *>(user);
short *lpOut = info.i16;
unsigned int lReqSmp = info.size/sizeof(short);
unsigned int lGenSmp;
unsigned int lWaveCmd = WaveGenerator::WAVEGEN_CONT;
bool lSignal = false;
lpToneGen->mLock.lock();
// Clear output buffer: WaveGenerator accumulates into lpOut buffer
memset(lpOut, 0, info.size);
// Update pcm frame count and end time (current time at the end of this process)
lpToneGen->mTotalSmp += lReqSmp;
// Update tone gen state machine and select wave gen command
switch (lpToneGen->mState) {
case TONE_PLAYING:
lWaveCmd = WaveGenerator::WAVEGEN_CONT;
break;
case TONE_STARTING:
LOGV("Starting Cbk");
lWaveCmd = WaveGenerator::WAVEGEN_START;
break;
case TONE_STOPPING:
case TONE_RESTARTING:
LOGV("Stop/restart Cbk");
lWaveCmd = WaveGenerator::WAVEGEN_STOP;
lpToneGen->mNextSegSmp = TONEGEN_INF; // forced to skip state machine management below
break;
default:
LOGV("Extra Cbk");
goto audioCallback_Exit;
}
// Exit if to sequence is over
if (lpToneGen->mpToneDesc->segments[lpToneGen->mCurSegment] == 0) {
goto audioCallback_Exit;
}
if (lpToneGen->mTotalSmp > lpToneGen->mNextSegSmp) {
// Time to go to next sequence segment
LOGV("End Segment, time: %d\n", (unsigned int)(systemTime()/1000000));
lGenSmp = lReqSmp;
if (lpToneGen->mCurSegment & 0x0001) {
// If odd segment, OFF -> ON transition : reset wave generator
lWaveCmd = WaveGenerator::WAVEGEN_START;
LOGV("OFF->ON, lGenSmp: %d, lReqSmp: %d\n", lGenSmp, lReqSmp);
} else {
// If even segment, ON -> OFF transition : ramp volume down
lWaveCmd = WaveGenerator::WAVEGEN_STOP;
LOGV("ON->OFF, lGenSmp: %d, lReqSmp: %d\n", lGenSmp, lReqSmp);
}
// Pre increment segment index and handle loop if last segment reached
if (lpToneGen->mpToneDesc->segments[++lpToneGen->mCurSegment] == 0) {
LOGV("Last Seg: %d\n", lpToneGen->mCurSegment);
// Pre increment loop count and restart if total count not reached. Stop sequence otherwise
if (++lpToneGen->mCurCount <= lpToneGen->mpToneDesc->repeatCnt) {
LOGV("Repeating Count: %d\n", lpToneGen->mCurCount);
lpToneGen->mCurSegment = 0;
LOGV("New segment %d, Next Time: %d\n", lpToneGen->mCurSegment,
(lpToneGen->mNextSegSmp*1000)/lpToneGen->mSamplingRate);
} else {
LOGV("End repeat, time: %d\n", (unsigned int)(systemTime()/1000000));
// Cancel OFF->ON transition in case previous segment tone state was OFF
if (!(lpToneGen->mCurSegment & 0x0001)) {
lGenSmp = 0;
}
}
} else {
LOGV("New segment %d, Next Time: %d\n", lpToneGen->mCurSegment,
(lpToneGen->mNextSegSmp*1000)/lpToneGen->mSamplingRate);
}
// Update next segment transition position. No harm to do it also for last segment as lpToneGen->mNextSegSmp won't be used any more
lpToneGen->mNextSegSmp
+= (lpToneGen->mpToneDesc->segments[lpToneGen->mCurSegment] * lpToneGen->mSamplingRate) / 1000;
} else {
// Inside a segment keep tone ON or OFF
if (lpToneGen->mCurSegment & 0x0001) {
lGenSmp = 0; // If odd segment, tone is currently OFF
} else {
lGenSmp = lReqSmp; // If event segment, tone is currently ON
}
}
if (lGenSmp) {
// If samples must be generated, call all active wave generators and acumulate waves in lpOut
unsigned int lWaveIdx;
for (lWaveIdx = 0; lWaveIdx < (unsigned int)lpToneGen->mWaveGens.size(); lWaveIdx++) {
WaveGenerator *lpWaveGen = lpToneGen->mWaveGens[lWaveIdx];
lpWaveGen->getSamples(lpOut, lGenSmp, lWaveCmd);
}
}
audioCallback_Exit:
switch (lpToneGen->mState) {
case TONE_RESTARTING:
LOGV("Cbk restarting track\n");
if (lpToneGen->prepareWave()) {
lpToneGen->mState = TONE_STARTING;
} else {
lpToneGen->mState = TONE_INIT;
lpToneGen->mpAudioTrack->stop();
}
lSignal = true;
break;
case TONE_STOPPING:
lpToneGen->mState = TONE_INIT;
LOGV("Cbk Stopping track\n");
lSignal = true;
lpToneGen->mpAudioTrack->stop();
break;
case TONE_STARTING:
LOGV("Cbk starting track\n");
lpToneGen->mState = TONE_PLAYING;
lSignal = true;
break;
default:
break;
}
if (lSignal)
lpToneGen->mWaitCbkCond.signal();
lpToneGen->mLock.unlock();
}
////////////////////////////////////////////////////////////////////////////////
//
// Method: ToneGenerator::prepareWave()
//
// Description: Prepare wave generators and reset tone sequencer state machine.
// mpNewToneDesc must have been initialized befoire calling this function.
// Input:
// none
//
// Output:
// returned value: true if wave generators have been created, false otherwise
//
////////////////////////////////////////////////////////////////////////////////
bool ToneGenerator::prepareWave() {
unsigned int lCnt = 0;
unsigned int lNumWaves;
if (!mpNewToneDesc) {
return false;
}
// Remove existing wave generators if any
clearWaveGens();
mpToneDesc = mpNewToneDesc;
// Get total number of sine waves: needed to adapt sine wave gain.
lNumWaves = numWaves();
// Instantiate as many wave generators as listed in descriptor
while (lCnt < lNumWaves) {
ToneGenerator::WaveGenerator *lpWaveGen =
new ToneGenerator::WaveGenerator((unsigned short)mSamplingRate,
mpToneDesc->waveFreq[lCnt],
TONEGEN_GAIN/lNumWaves);
if (lpWaveGen == 0) {
goto prepareWave_exit;
}
mWaveGens.push(lpWaveGen);
LOGV("Create sine: %d\n", mpToneDesc->waveFreq[lCnt]);
lCnt++;
}
// Initialize tone sequencer
mTotalSmp = 0;
mCurSegment = 0;
mCurCount = 0;
mNextSegSmp = (mpToneDesc->segments[0] * mSamplingRate) / 1000;
return true;
prepareWave_exit:
clearWaveGens();
return false;
}
////////////////////////////////////////////////////////////////////////////////
//
// Method: ToneGenerator::numWaves()
//
// Description: Count number of sine waves needed to generate tone (e.g 2 for DTMF).
//
// Input:
// none
//
// Output:
// returned value: nummber of sine waves
//
////////////////////////////////////////////////////////////////////////////////
unsigned int ToneGenerator::numWaves() {
unsigned int lCnt = 0;
while (mpToneDesc->waveFreq[lCnt]) {
lCnt++;
}
return lCnt;
}
////////////////////////////////////////////////////////////////////////////////
//
// Method: ToneGenerator::clearWaveGens()
//
// Description: Removes all wave generators.
//
// Input:
// none
//
// Output:
// none
//
////////////////////////////////////////////////////////////////////////////////
void ToneGenerator::clearWaveGens() {
LOGV("Clearing mWaveGens:");
while (!mWaveGens.isEmpty()) {
delete mWaveGens.top();
mWaveGens.pop();
}
}
////////////////////////////////////////////////////////////////////////////////
// WaveGenerator::WaveGenerator class Implementation
////////////////////////////////////////////////////////////////////////////////
//---------------------------------- public methods ----------------------------
////////////////////////////////////////////////////////////////////////////////
//
// Method: WaveGenerator::WaveGenerator()
//
// Description: Constructor.
//
// Input:
// samplingRate: Output sampling rate in Hz
// frequency: Frequency of the sine wave to generate in Hz
// volume: volume (0.0 to 1.0)
//
// Output:
// none
//
////////////////////////////////////////////////////////////////////////////////
ToneGenerator::WaveGenerator::WaveGenerator(unsigned short samplingRate,
unsigned short frequency, float volume) {
double d0;
double F_div_Fs; // frequency / samplingRate
F_div_Fs = frequency / (double)samplingRate;
d0 = - (float)GEN_AMP * sin(2 * M_PI * F_div_Fs);
mS2_0 = (short)d0;
mS1 = 0;
mS2 = mS2_0;
mAmplitude_Q15 = (short)(32767. * 32767. * volume / GEN_AMP);
// take some margin for amplitude fluctuation
if (mAmplitude_Q15 > 32500)
mAmplitude_Q15 = 32500;
d0 = 32768.0 * cos(2 * M_PI * F_div_Fs); // Q14*2*cos()
if (d0 > 32767)
d0 = 32767;
mA1_Q14 = (short) d0;
LOGV("WaveGenerator init, mA1_Q14: %d, mS2_0: %d, mAmplitude_Q15: %d\n",
mA1_Q14, mS2_0, mAmplitude_Q15);
}
////////////////////////////////////////////////////////////////////////////////
//
// Method: WaveGenerator::~WaveGenerator()
//
// Description: Destructor.
//
// Input:
// none
//
// Output:
// none
//
////////////////////////////////////////////////////////////////////////////////
ToneGenerator::WaveGenerator::~WaveGenerator() {
}
////////////////////////////////////////////////////////////////////////////////
//
// Method: WaveGenerator::getSamples()
//
// Description: Generates count samples of a sine wave and accumulates
// result in outBuffer.
//
// Input:
// outBuffer: Output buffer where to accumulate samples.
// count: number of samples to produce.
// command: special action requested (see enum gen_command).
//
// Output:
// none
//
////////////////////////////////////////////////////////////////////////////////
void ToneGenerator::WaveGenerator::getSamples(short *outBuffer,
unsigned int count, unsigned int command) {
long lS1, lS2;
long lA1, lAmplitude;
long Sample; // current sample
// init local
if (command == WAVEGEN_START) {
lS1 = (long)0;
lS2 = (long)mS2_0;
} else {
lS1 = (long)mS1;
lS2 = (long)mS2;
}
lA1 = (long)mA1_Q14;
lAmplitude = (long)mAmplitude_Q15;
if (command == WAVEGEN_STOP) {
lAmplitude <<= 16;
if (count == 0) {
return;
}
long dec = lAmplitude/count;
// loop generation
while (count--) {
Sample = ((lA1 * lS1) >> S_Q14) - lS2;
// shift delay
lS2 = lS1;
lS1 = Sample;
Sample = ((lAmplitude>>16) * Sample) >> S_Q15;
*(outBuffer++) += (short)Sample; // put result in buffer
lAmplitude -= dec;
}
} else {
// loop generation
while (count--) {
Sample = ((lA1 * lS1) >> S_Q14) - lS2;
// shift delay
lS2 = lS1;
lS1 = Sample;
Sample = (lAmplitude * Sample) >> S_Q15;
*(outBuffer++) += (short)Sample; // put result in buffer
}
}
// save status
mS1 = (short)lS1;
mS2 = (short)lS2;
}
} // end namespace android
Reference in New Issue View Git Blame Copy Permalink