auto import from //depot/cupcake/@135843
diff --git a/media/libmedia/ToneGenerator.cpp b/media/libmedia/ToneGenerator.cpp
new file mode 100644
index 0000000..5416629
--- /dev/null
+++ b/media/libmedia/ToneGenerator.cpp
@@ -0,0 +1,730 @@
+/*
+ * 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 }, { 40, 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 }, { 40, 200, 40, 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) {
+
+ LOGV("ToneGenerator constructor: streamType=%d, volume=%f\n", streamType, volume);
+
+ mState = TONE_IDLE;
+
+ if (AudioSystem::getOutputSamplingRate(&mSamplingRate, streamType) != NO_ERROR) {
+ LOGE("Unable to marshal AudioFlinger");
+ return;
+ }
+ mStreamType = streamType;
+ mVolume = volume;
+ mpAudioTrack = 0;
+ mpToneDesc = 0;
+ mpNewToneDesc = 0;
+ // Generate tone by chunks of 20 ms to keep cadencing precision
+ mProcessSize = (mSamplingRate * 20) / 1000;
+
+ if (initAudioTrack()) {
+ LOGV("ToneGenerator INIT OK, time: %d\n", (unsigned int)(systemTime()/1000000));
+ } else {
+ 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 (toneType >= NUM_TONES)
+ return lResult;
+
+ if (mState == TONE_IDLE) {
+ LOGV("startTone: try to re-init AudioTrack");
+ if (!initAudioTrack()) {
+ 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));
+ lResult = true;
+ mState = TONE_STARTING;
+ mLock.unlock();
+ mpAudioTrack->start();
+ mLock.lock();
+ if (mState == TONE_STARTING) {
+ LOGV("Wait for start callback");
+ if (mWaitCbkCond.waitRelative(mLock, seconds(1)) != NO_ERROR) {
+ LOGE("--- Immediate start timed out");
+ mState = TONE_IDLE;
+ lResult = false;
+ }
+ }
+ } else {
+ mState == TONE_IDLE;
+ }
+ } else {
+ LOGV("Delayed start\n");
+
+ mState = TONE_RESTARTING;
+ if (mWaitCbkCond.waitRelative(mLock, seconds(1)) == NO_ERROR) {
+ if (mState != TONE_IDLE) {
+ lResult = true;
+ }
+ LOGV("cond received");
+ } else {
+ LOGE("--- Delayed start timed out");
+ mState = TONE_IDLE;
+ }
+ }
+ mLock.unlock();
+
+ LOGV_IF(lResult, "Tone started, time %d\n", (unsigned int)(systemTime()/1000000));
+ LOGW_IF(!lResult, "Tone start failed!!!, 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("--- Stop timed out");
+ mState = TONE_IDLE;
+ mpAudioTrack->stop();
+ }
+ }
+
+ clearWaveGens();
+
+ mLock.unlock();
+}
+
+//---------------------------------- private methods ---------------------------
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Method: ToneGenerator::initAudioTrack()
+//
+// Description: Allocates and configures AudioTrack used for PCM output.
+//
+// Input:
+// none
+//
+// Output:
+// none
+//
+////////////////////////////////////////////////////////////////////////////////
+bool ToneGenerator::initAudioTrack() {
+
+ if (mpAudioTrack) {
+ delete mpAudioTrack;
+ mpAudioTrack = 0;
+ }
+
+ // Open audio track in mono, PCM 16bit, default sampling rate, default buffer size
+ mpAudioTrack
+ = new AudioTrack(mStreamType, 0, AudioSystem::PCM_16_BIT, 1, 0, 0, audioCallback, this, 0);
+
+ if (mpAudioTrack == 0) {
+ LOGE("AudioTrack allocation failed");
+ goto initAudioTrack_exit;
+ }
+ LOGV("Create Track: %p\n", mpAudioTrack);
+
+ if (mpAudioTrack->initCheck() != NO_ERROR) {
+ LOGE("AudioTrack->initCheck failed");
+ goto initAudioTrack_exit;
+ }
+
+ mpAudioTrack->setVolume(mVolume, mVolume);
+
+ mState = TONE_INIT;
+
+ return true;
+
+initAudioTrack_exit:
+
+ // Cleanup
+ if (mpAudioTrack) {
+ LOGV("Delete Track I: %p\n", mpAudioTrack);
+ delete mpAudioTrack;
+ mpAudioTrack = 0;
+ }
+
+ return false;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// 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(int event, void* user, void *info) {
+
+ if (event != AudioTrack::EVENT_MORE_DATA) return;
+
+ const AudioTrack::Buffer *buffer = static_cast<const AudioTrack::Buffer *>(info);
+ ToneGenerator *lpToneGen = static_cast<ToneGenerator *>(user);
+ short *lpOut = buffer->i16;
+ unsigned int lNumSmp = buffer->size/sizeof(short);
+
+ if (buffer->size == 0) return;
+
+
+ // Clear output buffer: WaveGenerator accumulates into lpOut buffer
+ memset(lpOut, 0, buffer->size);
+
+ while (lNumSmp) {
+ unsigned int lReqSmp = lNumSmp < lpToneGen->mProcessSize*2 ? lNumSmp : lpToneGen->mProcessSize;
+ unsigned int lGenSmp;
+ unsigned int lWaveCmd = WaveGenerator::WAVEGEN_CONT;
+ bool lSignal = false;
+
+ lpToneGen->mLock.lock();
+
+ // 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_EndLoop;
+ }
+
+
+ // Exit if tone sequence is over
+ if (lpToneGen->mpToneDesc->segments[lpToneGen->mCurSegment] == 0) {
+ if (lpToneGen->mState == TONE_PLAYING) {
+ lpToneGen->mState = TONE_STOPPING;
+ }
+ goto audioCallback_EndLoop;
+ }
+
+ 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);
+ }
+ }
+
+ lNumSmp -= lReqSmp;
+ lpOut += lReqSmp;
+
+audioCallback_EndLoop:
+
+ switch (lpToneGen->mState) {
+ case TONE_RESTARTING:
+ LOGV("Cbk restarting track\n");
+ if (lpToneGen->prepareWave()) {
+ lpToneGen->mState = TONE_STARTING;
+ } else {
+ LOGW("Cbk restarting prepareWave() failed\n");
+ lpToneGen->mState = TONE_IDLE;
+ lpToneGen->mpAudioTrack->stop();
+ // Force loop exit
+ lNumSmp = 0;
+ }
+ lSignal = true;
+ break;
+ case TONE_STOPPING:
+ lpToneGen->mState = TONE_INIT;
+ LOGV("Cbk Stopping track\n");
+ lSignal = true;
+ lpToneGen->mpAudioTrack->stop();
+
+ // Force loop exit
+ lNumSmp = 0;
+ 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
+