ToneGenerator.cpp revision 0b62e242d112d46e9357242b0a4e11c720c98ca0 
1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17//#define LOG_NDEBUG 0
18#define LOG_TAG "ToneGenerator"
19#include <utils/threads.h>
20
21#include <stdio.h>
22#include <math.h>
23#include <utils/Log.h>
24#include <sys/resource.h>
25#include <utils/RefBase.h>
26#include <utils/Timers.h>
27#include <cutils/properties.h>
28#include "media/ToneGenerator.h"
29
30
31namespace android {
32
33
34// Descriptors for all available tones (See ToneGenerator::ToneDescriptor class declaration for details)
35const ToneGenerator::ToneDescriptor ToneGenerator::sToneDescriptors[] = {
36        { segments: {{ duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1336, 941, 0 }},
37                     { duration: 0 , waveFreq: { 0 }}},
38          repeatCnt: ToneGenerator::TONEGEN_INF,
39          repeatSegment: 0 },                              // TONE_DTMF_0
40        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1209, 697, 0 } },
41                      { duration: 0 , waveFreq: { 0 }}},
42          repeatCnt: ToneGenerator::TONEGEN_INF,
43          repeatSegment: 0 },                              // TONE_DTMF_1
44        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1336, 697, 0 } },
45                      { duration: 0 , waveFreq: { 0 }}},
46          repeatCnt: ToneGenerator::TONEGEN_INF,
47          repeatSegment: 0 },                              // TONE_DTMF_2
48        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1477, 697, 0 } },
49                      { duration: 0 , waveFreq: { 0 }}},
50          repeatCnt: ToneGenerator::TONEGEN_INF,
51          repeatSegment: 0 },                              // TONE_DTMF_3
52        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1209, 770, 0 } },
53                      { duration: 0 , waveFreq: { 0 }}},
54          repeatCnt: ToneGenerator::TONEGEN_INF,
55          repeatSegment: 0 },                              // TONE_DTMF_4
56        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1336, 770, 0 } },
57                      { duration: 0 , waveFreq: { 0 }}},
58          repeatCnt: ToneGenerator::TONEGEN_INF,
59          repeatSegment: 0 },                              // TONE_DTMF_5
60        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1477, 770, 0 } },
61                      { duration: 0 , waveFreq: { 0 }}},
62          repeatCnt: ToneGenerator::TONEGEN_INF,
63          repeatSegment: 0 },                              // TONE_DTMF_6
64        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1209, 852, 0 } },
65                      { duration: 0 , waveFreq: { 0 }}},
66          repeatCnt: ToneGenerator::TONEGEN_INF,
67          repeatSegment: 0 },                              // TONE_DTMF_7
68        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1336, 852, 0 } },
69                      { duration: 0 , waveFreq: { 0 }}},
70          repeatCnt: ToneGenerator::TONEGEN_INF,
71          repeatSegment: 0 },                              // TONE_DTMF_8
72        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1477, 852, 0 } },
73                      { duration: 0 , waveFreq: { 0 }}},
74          repeatCnt: ToneGenerator::TONEGEN_INF,
75          repeatSegment: 0 },                              // TONE_DTMF_9
76        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1209, 941, 0 } },
77                      { duration: 0 , waveFreq: { 0 }}},
78          repeatCnt: ToneGenerator::TONEGEN_INF,
79          repeatSegment: 0 },                              // TONE_DTMF_S
80        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1477, 941, 0 } },
81                      { duration: 0 , waveFreq: { 0 }}},
82          repeatCnt: ToneGenerator::TONEGEN_INF,
83          repeatSegment: 0 },                              // TONE_DTMF_P
84        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1633, 697, 0 } },
85                      { duration: 0 , waveFreq: { 0 }}},
86          repeatCnt: ToneGenerator::TONEGEN_INF,
87          repeatSegment: 0 },                              // TONE_DTMF_A
88        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1633, 770, 0 } },
89                      { duration: 0 , waveFreq: { 0 }}},
90          repeatCnt: ToneGenerator::TONEGEN_INF,
91          repeatSegment: 0 },                             // TONE_DTMF_B
92        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1633, 852, 0 } },
93                      { duration: 0 , waveFreq: { 0 }}},
94          repeatCnt: ToneGenerator::TONEGEN_INF,
95          repeatSegment: 0 },                              // TONE_DTMF_C
96        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 1633, 941, 0 } },
97                      { duration: 0 , waveFreq: { 0 }}},
98          repeatCnt: ToneGenerator::TONEGEN_INF,
99          repeatSegment: 0 },                              // TONE_DTMF_D
100        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 425, 0 } },
101                      { duration: 0 , waveFreq: { 0 }}},
102          repeatCnt: ToneGenerator::TONEGEN_INF,
103          repeatSegment: 0 },                              // TONE_SUP_DIAL
104        { segments: { { duration: 500 , waveFreq: { 425, 0 }},
105                      { duration: 500, waveFreq: { 0 }},
106                         { duration: 0 , waveFreq: { 0 }}},
107          repeatCnt: ToneGenerator::TONEGEN_INF,
108          repeatSegment: 0 },                              // TONE_SUP_BUSY
109        { segments: { { duration: 200, waveFreq: { 425, 0 } },
110                      { duration: 200, waveFreq: { 0 } },
111                      { duration: 0 , waveFreq: { 0 }}},
112          repeatCnt: ToneGenerator::TONEGEN_INF,
113          repeatSegment: 0 },                              // TONE_SUP_CONGESTION
114        { segments: { { duration: 200, waveFreq: { 425, 0 } },
115                      { duration: 0 , waveFreq: { 0 }}},
116          repeatCnt: 0,
117          repeatSegment: 0 },                              // TONE_SUP_RADIO_ACK
118        { segments: { { duration: 200, waveFreq: { 425, 0 }},
119                      { duration: 200, waveFreq: { 0 }},
120                      { duration: 0 , waveFreq: { 0 }}},
121          repeatCnt: 2,
122          repeatSegment: 0 },                              // TONE_SUP_RADIO_NOTAVAIL
123        { segments: { { duration: 330, waveFreq: { 950, 1400, 1800, 0 }},
124                      { duration: 1000, waveFreq: { 0 } },
125                      { duration: 0 , waveFreq: { 0 }}},
126          repeatCnt: ToneGenerator::TONEGEN_INF,
127          repeatSegment: 0 },                              // TONE_SUP_ERROR
128        { segments: { { duration: 200, waveFreq: { 425, 0 } },
129                      { duration: 600, waveFreq: { 0 } },
130                      { duration: 200, waveFreq: { 425, 0 } },
131                      { duration: 3000, waveFreq: { 0 } },
132                      { duration: 0 , waveFreq: { 0 }}},
133          repeatCnt: ToneGenerator::TONEGEN_INF,
134          repeatSegment: 0 },                              // TONE_SUP_CALL_WAITING
135        { segments: { { duration: 1000, waveFreq: { 425, 0 } },
136                      { duration: 4000, waveFreq: { 0 } },
137                      { duration: 0 , waveFreq: { 0 }}},
138          repeatCnt: ToneGenerator::TONEGEN_INF,
139          repeatSegment: 0 },                              // TONE_SUP_RINGTONE
140        { segments: { { duration: 40, waveFreq: { 400, 1200, 0 } },
141                      { duration: 0 , waveFreq: { 0 }}},
142          repeatCnt: 0,
143          repeatSegment: 0 },                              // TONE_PROP_BEEP
144        { segments: { { duration: 100, waveFreq: { 1200, 0 } },
145                      { duration: 100, waveFreq: { 0 }  },
146                      { duration: 0 , waveFreq: { 0 }}},
147          repeatCnt: 1,
148          repeatSegment: 0 },                              // TONE_PROP_ACK
149        { segments: { { duration: 400, waveFreq: { 300, 400, 500, 0 } },
150                      { duration: 0 , waveFreq: { 0 }}},
151          repeatCnt: 0,
152          repeatSegment: 0 },                              // TONE_PROP_NACK
153        { segments: { { duration: 200, waveFreq: { 400, 1200, 0 } },
154                      { duration: 0 , waveFreq: { 0 }}},
155          repeatCnt: 0,
156          repeatSegment: 0 },                              // TONE_PROP_PROMPT
157        { segments: { { duration: 40, waveFreq: { 400, 1200, 0 } },
158                      { duration: 200, waveFreq: { 0 } },
159                      { duration: 40, waveFreq: { 400, 1200, 0 } },
160                      { duration: 0 , waveFreq: { 0 }}},
161          repeatCnt: 0,
162          repeatSegment: 0 },                             // TONE_PROP_BEEP2
163        { segments: { { duration: 250, waveFreq: { 440, 0 } },
164                      { duration: 250, waveFreq: { 620, 0 } },
165                      { duration: 0 , waveFreq: { 0 }}},
166          repeatCnt: ToneGenerator::TONEGEN_INF,
167          repeatSegment: 0 },                              // TONE_SUP_INTERCEPT
168        { segments: { { duration: 250, waveFreq: { 440, 0 } },
169                      { duration: 250, waveFreq: { 620, 0 } },
170                      { duration: 0 , waveFreq: { 0 }}},
171          repeatCnt: 7,
172          repeatSegment: 0 },                             // TONE_SUP_INTERCEPT_ABBREV
173        { segments: { { duration: 250, waveFreq: { 480, 620, 0 } },
174                      { duration: 250, waveFreq: { 0 } },
175                      { duration: 0 , waveFreq: { 0 }}},
176          repeatCnt: 7,
177          repeatSegment: 0 },                             // TONE_SUP_CONGESTION_ABBREV
178        { segments: { { duration: 100, waveFreq: { 350, 440, 0 } },
179                      { duration: 100, waveFreq: { 0 } },
180                      { duration: 0 , waveFreq: { 0 }}},
181          repeatCnt: 2,
182          repeatSegment: 0 },                             // TONE_SUP_CONFIRM
183        { segments: { { duration: 100, waveFreq: { 480, 0 } },
184                      { duration: 100, waveFreq: { 0 } },
185                      { duration: 0 , waveFreq: { 0 }}},
186          repeatCnt: 3,
187          repeatSegment: 0 },                              // TONE_SUP_PIP
188        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 350, 440, 0 } },
189                      { duration: 0 , waveFreq: { 0 }}},
190          repeatCnt: ToneGenerator::TONEGEN_INF,
191          repeatSegment: 0 },                              // TONE_ANSI_DIAL
192        { segments: { { duration: 500, waveFreq: { 480, 620, 0 } },
193                      { duration: 500, waveFreq: { 0 } },
194                      { duration: 0 , waveFreq: { 0 }}},
195          repeatCnt: ToneGenerator::TONEGEN_INF,
196          repeatSegment: 0 },                              // TONE_ANSI_BUSY
197        { segments: { { duration: 250, waveFreq: { 480, 620, 0 } },
198                      { duration: 250, waveFreq: { 0 } },
199                      { duration: 0 , waveFreq: { 0 }}},
200          repeatCnt: ToneGenerator::TONEGEN_INF,
201          repeatSegment: 0 },                              // TONE_ANSI_CONGESTION
202        { segments: { { duration: 300, waveFreq: { 440, 0 } },
203                      { duration: 9700, waveFreq: { 0 } },
204                      { duration: 100, waveFreq: { 440, 0 } },
205                      { duration: 100, waveFreq: { 0 } },
206                      { duration: 100, waveFreq: { 440, 0 } },
207                      { duration: 0 , waveFreq: { 0 }}},
208          repeatCnt: ToneGenerator::TONEGEN_INF,
209          repeatSegment: 1 },                              // TONE_ANSI_CALL_WAITING
210        { segments: { { duration: 2000, waveFreq: { 440, 480, 0 } },
211                      { duration: 4000, waveFreq: { 0 } },
212                      { duration: 0 , waveFreq: { 0 }}},
213          repeatCnt: ToneGenerator::TONEGEN_INF,
214          repeatSegment: 0 },                              // TONE_ANSI_RINGTONE
215        { segments: { { duration: ToneGenerator::TONEGEN_INF, waveFreq: { 400, 0 } },
216                      { duration: 0 , waveFreq: { 0 }}},
217          repeatCnt: ToneGenerator::TONEGEN_INF,
218          repeatSegment: 0 },                              // TONE_JAPAN_DIAL
219        { segments: { { duration: 500, waveFreq: { 400, 0 } },
220                      { duration: 500, waveFreq: { 0 } },
221                      { duration: 0 , waveFreq: { 0 }}},
222          repeatCnt: ToneGenerator::TONEGEN_INF,
223          repeatSegment: 0 },                              // TONE_JAPAN_BUSY
224        { segments: { { duration: 1000, waveFreq: { 400, 0 } },
225                      { duration: 2000, waveFreq: { 0 } },
226                      { duration: 0 , waveFreq: { 0 }}},
227          repeatCnt: ToneGenerator::TONEGEN_INF,
228          repeatSegment: 0 },                              // TONE_JAPAN_RADIO_ACK
229};
230
231// Used by ToneGenerator::getToneForRegion() to convert user specified supervisory tone type
232// to actual tone for current region.
233const unsigned char ToneGenerator::sToneMappingTable[NUM_REGIONS-1][NUM_SUP_TONES] = {
234        {   // ANSI
235            TONE_ANSI_DIAL,             // TONE_SUP_DIAL
236            TONE_ANSI_BUSY,             // TONE_SUP_BUSY
237            TONE_ANSI_CONGESTION,       // TONE_SUP_CONGESTION
238            TONE_SUP_RADIO_ACK,         // TONE_SUP_RADIO_ACK
239            TONE_SUP_RADIO_NOTAVAIL,    // TONE_SUP_RADIO_NOTAVAIL
240            TONE_SUP_ERROR,             // TONE_SUP_ERROR
241            TONE_ANSI_CALL_WAITING,     // TONE_SUP_CALL_WAITING
242            TONE_ANSI_RINGTONE          // TONE_SUP_RINGTONE
243        },
244        {   // JAPAN
245            TONE_JAPAN_DIAL,             // TONE_SUP_DIAL
246            TONE_JAPAN_BUSY,             // TONE_SUP_BUSY
247            TONE_SUP_CONGESTION,         // TONE_SUP_CONGESTION
248            TONE_JAPAN_RADIO_ACK,        // TONE_SUP_RADIO_ACK
249            TONE_SUP_RADIO_NOTAVAIL,     // TONE_SUP_RADIO_NOTAVAIL
250            TONE_SUP_ERROR,              // TONE_SUP_ERROR
251            TONE_SUP_CALL_WAITING,       // TONE_SUP_CALL_WAITING
252            TONE_SUP_RINGTONE            // TONE_SUP_RINGTONE
253        }
254};
255
256
257////////////////////////////////////////////////////////////////////////////////
258//                           ToneGenerator class Implementation
259////////////////////////////////////////////////////////////////////////////////
260
261
262//---------------------------------- public methods ----------------------------
263
264
265////////////////////////////////////////////////////////////////////////////////
266//
267//    Method:        ToneGenerator::ToneGenerator()
268//
269//    Description:    Constructor. Initializes the tone sequencer, intantiates required sine wave
270//        generators, instantiates output audio track.
271//
272//    Input:
273//        toneType:        Type of tone generated (values in enum tone_type)
274//        streamType:        Type of stream used for tone playback (enum AudioTrack::stream_type)
275//        volume:            volume applied to tone (0.0 to 1.0)
276//
277//    Output:
278//        none
279//
280////////////////////////////////////////////////////////////////////////////////
281ToneGenerator::ToneGenerator(int streamType, float volume) {
282
283    LOGV("ToneGenerator constructor: streamType=%d, volume=%f\n", streamType, volume);
284
285    mState = TONE_IDLE;
286
287    if (AudioSystem::getOutputSamplingRate(&mSamplingRate, streamType) != NO_ERROR) {
288        LOGE("Unable to marshal AudioFlinger");
289        return;
290    }
291    mStreamType = streamType;
292    mVolume = volume;
293    mpAudioTrack = 0;
294    mpToneDesc = 0;
295    mpNewToneDesc = 0;
296    // Generate tone by chunks of 20 ms to keep cadencing precision
297    mProcessSize = (mSamplingRate * 20) / 1000;
298
299    char value[PROPERTY_VALUE_MAX];
300    property_get("gsm.operator.iso-country", value, "");
301    if (strcmp(value,"us") == 0 ||
302        strcmp(value,"ca") == 0) {
303        mRegion = ANSI;
304    } else if (strcmp(value,"jp") == 0) {
305        mRegion = JAPAN;
306    } else {
307        mRegion = CEPT;
308    }
309
310    if (initAudioTrack()) {
311        LOGV("ToneGenerator INIT OK, time: %d\n", (unsigned int)(systemTime()/1000000));
312    } else {
313        LOGV("!!!ToneGenerator INIT FAILED!!!\n");
314    }
315}
316
317
318
319
320////////////////////////////////////////////////////////////////////////////////
321//
322//    Method:        ToneGenerator::~ToneGenerator()
323//
324//    Description:    Destructor. Stop sound playback and delete audio track if
325//      needed and delete sine wave generators.
326//
327//    Input:
328//        none
329//
330//    Output:
331//        none
332//
333////////////////////////////////////////////////////////////////////////////////
334ToneGenerator::~ToneGenerator() {
335    LOGV("ToneGenerator destructor\n");
336
337    if (mpAudioTrack) {
338        stopTone();
339        LOGV("Delete Track: %p\n", mpAudioTrack);
340        delete mpAudioTrack;
341    }
342}
343
344////////////////////////////////////////////////////////////////////////////////
345//
346//    Method:        ToneGenerator::startTone()
347//
348//    Description:    Starts tone playback.
349//
350//    Input:
351//        none
352//
353//    Output:
354//        none
355//
356////////////////////////////////////////////////////////////////////////////////
357bool ToneGenerator::startTone(int toneType) {
358    bool lResult = false;
359
360    if (toneType >= NUM_TONES)
361        return lResult;
362
363    if (mState == TONE_IDLE) {
364        LOGV("startTone: try to re-init AudioTrack");
365        if (!initAudioTrack()) {
366            return lResult;
367        }
368    }
369
370    LOGV("startTone\n");
371
372    mLock.lock();
373
374    // Get descriptor for requested tone
375    toneType = getToneForRegion(toneType);
376    mpNewToneDesc = &sToneDescriptors[toneType];
377
378    if (mState == TONE_INIT) {
379        if (prepareWave()) {
380            LOGV("Immediate start, time %d\n", (unsigned int)(systemTime()/1000000));
381            lResult = true;
382            mState = TONE_STARTING;
383            mLock.unlock();
384            mpAudioTrack->start();
385            mLock.lock();
386            if (mState == TONE_STARTING) {
387                LOGV("Wait for start callback");
388                status_t lStatus = mWaitCbkCond.waitRelative(mLock, seconds(1));
389                if (lStatus != NO_ERROR) {
390                    LOGE("--- Immediate start timed out, status %d", lStatus);
391                    mState = TONE_IDLE;
392                    lResult = false;
393                }
394            }
395        } else {
396            mState == TONE_IDLE;
397        }
398    } else {
399        LOGV("Delayed start\n");
400
401        mState = TONE_RESTARTING;
402        status_t lStatus = mWaitCbkCond.waitRelative(mLock, seconds(1));
403        if (lStatus == NO_ERROR) {
404            if (mState != TONE_IDLE) {
405                lResult = true;
406            }
407            LOGV("cond received");
408        } else {
409            LOGE("--- Delayed start timed out, status %d", lStatus);
410            mState = TONE_IDLE;
411        }
412    }
413    mLock.unlock();
414
415    LOGV_IF(lResult, "Tone started, time %d\n", (unsigned int)(systemTime()/1000000));
416    LOGW_IF(!lResult, "Tone start failed!!!, time %d\n", (unsigned int)(systemTime()/1000000));
417
418    return lResult;
419}
420
421////////////////////////////////////////////////////////////////////////////////
422//
423//    Method:        ToneGenerator::stopTone()
424//
425//    Description:    Stops tone playback.
426//
427//    Input:
428//        none
429//
430//    Output:
431//        none
432//
433////////////////////////////////////////////////////////////////////////////////
434void ToneGenerator::stopTone() {
435    LOGV("stopTone");
436
437    mLock.lock();
438    if (mState == TONE_PLAYING || mState == TONE_STARTING || mState == TONE_RESTARTING) {
439        mState = TONE_STOPPING;
440        LOGV("waiting cond");
441        status_t lStatus = mWaitCbkCond.waitRelative(mLock, seconds(1));
442        if (lStatus == NO_ERROR) {
443            LOGV("track stop complete, time %d", (unsigned int)(systemTime()/1000000));
444        } else {
445            LOGE("--- Stop timed out");
446            mState = TONE_IDLE;
447            mpAudioTrack->stop();
448        }
449    }
450
451    clearWaveGens();
452
453    mLock.unlock();
454}
455
456//---------------------------------- private methods ---------------------------
457
458
459
460
461////////////////////////////////////////////////////////////////////////////////
462//
463//    Method:        ToneGenerator::initAudioTrack()
464//
465//    Description:    Allocates and configures AudioTrack used for PCM output.
466//
467//    Input:
468//        none
469//
470//    Output:
471//        none
472//
473////////////////////////////////////////////////////////////////////////////////
474bool ToneGenerator::initAudioTrack() {
475
476    if (mpAudioTrack) {
477        delete mpAudioTrack;
478        mpAudioTrack = 0;
479    }
480
481   // Open audio track in mono, PCM 16bit, default sampling rate, default buffer size
482    mpAudioTrack
483            = new AudioTrack(mStreamType, 0, AudioSystem::PCM_16_BIT, 1, 0, 0, audioCallback, this, 0);
484
485    if (mpAudioTrack == 0) {
486        LOGE("AudioTrack allocation failed");
487        goto initAudioTrack_exit;
488    }
489    LOGV("Create Track: %p\n", mpAudioTrack);
490
491    if (mpAudioTrack->initCheck() != NO_ERROR) {
492        LOGE("AudioTrack->initCheck failed");
493        goto initAudioTrack_exit;
494    }
495
496    mpAudioTrack->setVolume(mVolume, mVolume);
497
498    mState = TONE_INIT;
499
500    return true;
501
502initAudioTrack_exit:
503
504    // Cleanup
505    if (mpAudioTrack) {
506        LOGV("Delete Track I: %p\n", mpAudioTrack);
507        delete mpAudioTrack;
508        mpAudioTrack = 0;
509    }
510
511    return false;
512}
513
514
515////////////////////////////////////////////////////////////////////////////////
516//
517//    Method:        ToneGenerator::audioCallback()
518//
519//    Description:    AudioTrack callback implementation. Generates a block of
520//        PCM samples
521//        and manages tone generator sequencer: tones pulses, tone duration...
522//
523//    Input:
524//        user    reference (pointer to our ToneGenerator)
525//        info    audio buffer descriptor
526//
527//    Output:
528//        returned value: always true.
529//
530////////////////////////////////////////////////////////////////////////////////
531void ToneGenerator::audioCallback(int event, void* user, void *info) {
532
533    if (event != AudioTrack::EVENT_MORE_DATA) return;
534
535    const AudioTrack::Buffer *buffer = static_cast<const AudioTrack::Buffer *>(info);
536    ToneGenerator *lpToneGen = static_cast<ToneGenerator *>(user);
537    short *lpOut = buffer->i16;
538    unsigned int lNumSmp = buffer->size/sizeof(short);
539    const ToneDescriptor *lpToneDesc = lpToneGen->mpToneDesc;
540
541    if (buffer->size == 0) return;
542
543
544    // Clear output buffer: WaveGenerator accumulates into lpOut buffer
545    memset(lpOut, 0, buffer->size);
546
547    while (lNumSmp) {
548        unsigned int lReqSmp = lNumSmp < lpToneGen->mProcessSize*2 ? lNumSmp : lpToneGen->mProcessSize;
549        unsigned int lGenSmp;
550        unsigned int lWaveCmd = WaveGenerator::WAVEGEN_CONT;
551        bool lSignal = false;
552
553        lpToneGen->mLock.lock();
554
555        // Update pcm frame count and end time (current time at the end of this process)
556        lpToneGen->mTotalSmp += lReqSmp;
557
558        // Update tone gen state machine and select wave gen command
559        switch (lpToneGen->mState) {
560        case TONE_PLAYING:
561            lWaveCmd = WaveGenerator::WAVEGEN_CONT;
562            break;
563        case TONE_STARTING:
564            LOGV("Starting Cbk");
565
566            lWaveCmd = WaveGenerator::WAVEGEN_START;
567            break;
568        case TONE_STOPPING:
569        case TONE_RESTARTING:
570            LOGV("Stop/restart Cbk");
571
572            lWaveCmd = WaveGenerator::WAVEGEN_STOP;
573            lpToneGen->mNextSegSmp = TONEGEN_INF; // forced to skip state machine management below
574            break;
575        default:
576            LOGV("Extra Cbk");
577            // Force loop exit
578            lNumSmp = 0;
579            goto audioCallback_EndLoop;
580        }
581
582
583        // Exit if tone sequence is over
584        if (lpToneDesc->segments[lpToneGen->mCurSegment].duration == 0) {
585            if (lpToneGen->mState == TONE_PLAYING) {
586                lpToneGen->mState = TONE_STOPPING;
587            }
588            goto audioCallback_EndLoop;
589        }
590
591        if (lpToneGen->mTotalSmp > lpToneGen->mNextSegSmp) {
592            // Time to go to next sequence segment
593
594            LOGV("End Segment, time: %d\n", (unsigned int)(systemTime()/1000000));
595
596            lGenSmp = lReqSmp;
597
598            // If segment,  ON -> OFF transition : ramp volume down
599            if (lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[0] != 0) {
600                lWaveCmd = WaveGenerator::WAVEGEN_STOP;
601                unsigned int lFreqIdx = 0;
602                unsigned short lFrequency = lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[lFreqIdx];
603
604                while (lFrequency != 0) {
605                    WaveGenerator *lpWaveGen = lpToneGen->mWaveGens.valueFor(lFrequency);
606                    lpWaveGen->getSamples(lpOut, lGenSmp, lWaveCmd);
607                    lFrequency = lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[++lFreqIdx];
608                }
609                LOGV("ON->OFF, lGenSmp: %d, lReqSmp: %d\n", lGenSmp, lReqSmp);
610            }
611
612            // Go to next segment
613            lpToneGen->mCurSegment++;
614
615            // Handle loop if last segment reached
616            if (lpToneDesc->segments[lpToneGen->mCurSegment].duration == 0) {
617                LOGV("Last Seg: %d\n", lpToneGen->mCurSegment);
618
619                // Pre increment loop count and restart if total count not reached. Stop sequence otherwise
620                if (++lpToneGen->mCurCount <= lpToneDesc->repeatCnt) {
621                    LOGV("Repeating Count: %d\n", lpToneGen->mCurCount);
622
623                    lpToneGen->mCurSegment = lpToneDesc->repeatSegment;
624                    if (lpToneDesc->segments[lpToneDesc->repeatSegment].waveFreq[0] != 0) {
625                        lWaveCmd = WaveGenerator::WAVEGEN_START;
626                    }
627
628                    LOGV("New segment %d, Next Time: %d\n", lpToneGen->mCurSegment,
629                            (lpToneGen->mNextSegSmp*1000)/lpToneGen->mSamplingRate);
630
631                } else {
632                    lGenSmp = 0;
633                    LOGV("End repeat, time: %d\n", (unsigned int)(systemTime()/1000000));
634                }
635            } else {
636                LOGV("New segment %d, Next Time: %d\n", lpToneGen->mCurSegment,
637                        (lpToneGen->mNextSegSmp*1000)/lpToneGen->mSamplingRate);
638                if (lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[0] != 0) {
639                    // If next segment is not silent,  OFF -> ON transition : reset wave generator
640                    lWaveCmd = WaveGenerator::WAVEGEN_START;
641
642                    LOGV("OFF->ON, lGenSmp: %d, lReqSmp: %d\n", lGenSmp, lReqSmp);
643                } else {
644                    lGenSmp = 0;
645                }
646            }
647
648            // Update next segment transition position. No harm to do it also for last segment as lpToneGen->mNextSegSmp won't be used any more
649            lpToneGen->mNextSegSmp
650                    += (lpToneDesc->segments[lpToneGen->mCurSegment].duration * lpToneGen->mSamplingRate) / 1000;
651
652        } else {
653            // Inside a segment keep tone ON or OFF
654            if (lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[0] == 0) {
655                lGenSmp = 0;  // If odd segment, tone is currently OFF
656            } else {
657                lGenSmp = lReqSmp;  // If event segment, tone is currently ON
658            }
659        }
660
661        if (lGenSmp) {
662            // If samples must be generated, call all active wave generators and acumulate waves in lpOut
663            unsigned int lFreqIdx = 0;
664            unsigned short lFrequency = lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[lFreqIdx];
665
666            while (lFrequency != 0) {
667                WaveGenerator *lpWaveGen = lpToneGen->mWaveGens.valueFor(lFrequency);
668                lpWaveGen->getSamples(lpOut, lGenSmp, lWaveCmd);
669                lFrequency = lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[++lFreqIdx];
670            }
671        }
672
673        lNumSmp -= lReqSmp;
674        lpOut += lReqSmp;
675
676audioCallback_EndLoop:
677
678        switch (lpToneGen->mState) {
679        case TONE_RESTARTING:
680            LOGV("Cbk restarting track\n");
681            if (lpToneGen->prepareWave()) {
682                lpToneGen->mState = TONE_STARTING;
683            } else {
684                LOGW("Cbk restarting prepareWave() failed\n");
685                lpToneGen->mState = TONE_IDLE;
686                lpToneGen->mpAudioTrack->stop();
687                // Force loop exit
688                lNumSmp = 0;
689            }
690            lSignal = true;
691            break;
692        case TONE_STOPPING:
693            lpToneGen->mState = TONE_INIT;
694            LOGV("Cbk Stopping track\n");
695            lSignal = true;
696            lpToneGen->mpAudioTrack->stop();
697
698            // Force loop exit
699            lNumSmp = 0;
700            break;
701        case TONE_STARTING:
702            LOGV("Cbk starting track\n");
703            lpToneGen->mState = TONE_PLAYING;
704            lSignal = true;
705           break;
706        default:
707            break;
708        }
709
710        if (lSignal)
711            lpToneGen->mWaitCbkCond.signal();
712        lpToneGen->mLock.unlock();
713    }
714}
715
716
717////////////////////////////////////////////////////////////////////////////////
718//
719//    Method:        ToneGenerator::prepareWave()
720//
721//    Description:    Prepare wave generators and reset tone sequencer state machine.
722//      mpNewToneDesc must have been initialized before calling this function.
723//    Input:
724//        none
725//
726//    Output:
727//        returned value:   true if wave generators have been created, false otherwise
728//
729////////////////////////////////////////////////////////////////////////////////
730bool ToneGenerator::prepareWave() {
731    unsigned int segmentIdx = 0;
732
733    if (!mpNewToneDesc) {
734        return false;
735    }
736
737    // Remove existing wave generators if any
738    clearWaveGens();
739
740    mpToneDesc = mpNewToneDesc;
741
742    while (mpToneDesc->segments[segmentIdx].duration) {
743        // Get total number of sine waves: needed to adapt sine wave gain.
744        unsigned int lNumWaves = numWaves(segmentIdx);
745        unsigned int freqIdx = 0;
746        unsigned int frequency = mpToneDesc->segments[segmentIdx].waveFreq[freqIdx];
747        while (frequency) {
748            // Instantiate a wave generator if  ot already done for this frequency
749            if (mWaveGens.indexOfKey(frequency) == NAME_NOT_FOUND) {
750                ToneGenerator::WaveGenerator *lpWaveGen =
751                        new ToneGenerator::WaveGenerator((unsigned short)mSamplingRate,
752                                frequency,
753                                TONEGEN_GAIN/lNumWaves);
754                if (lpWaveGen == 0) {
755                    goto prepareWave_exit;
756                }
757                mWaveGens.add(frequency, lpWaveGen);
758            }
759            frequency = mpNewToneDesc->segments[segmentIdx].waveFreq[++freqIdx];
760        }
761        segmentIdx++;
762    }
763
764    // Initialize tone sequencer
765    mTotalSmp = 0;
766    mCurSegment = 0;
767    mCurCount = 0;
768    if (mpToneDesc->segments[0].duration == TONEGEN_INF) {
769        mNextSegSmp = TONEGEN_INF;
770    } else{
771        mNextSegSmp = (mpToneDesc->segments[0].duration * mSamplingRate) / 1000;
772    }
773
774    return true;
775
776prepareWave_exit:
777
778    clearWaveGens();
779
780    return false;
781}
782
783
784////////////////////////////////////////////////////////////////////////////////
785//
786//    Method:        ToneGenerator::numWaves()
787//
788//    Description:    Count number of sine waves needed to generate a tone segment (e.g 2 for DTMF).
789//
790//    Input:
791//        segmentIdx        tone segment index
792//
793//    Output:
794//        returned value:    nummber of sine waves
795//
796////////////////////////////////////////////////////////////////////////////////
797unsigned int ToneGenerator::numWaves(unsigned int segmentIdx) {
798    unsigned int lCnt = 0;
799
800    if (mpToneDesc->segments[segmentIdx].duration) {
801        while (mpToneDesc->segments[segmentIdx].waveFreq[lCnt]) {
802            lCnt++;
803        }
804        lCnt++;
805    }
806
807    return lCnt;
808}
809
810
811////////////////////////////////////////////////////////////////////////////////
812//
813//    Method:        ToneGenerator::clearWaveGens()
814//
815//    Description:    Removes all wave generators.
816//
817//    Input:
818//        none
819//
820//    Output:
821//        none
822//
823////////////////////////////////////////////////////////////////////////////////
824void ToneGenerator::clearWaveGens() {
825    LOGV("Clearing mWaveGens:");
826
827    for (size_t lIdx = 0; lIdx < mWaveGens.size(); lIdx++) {
828        delete mWaveGens.valueAt(lIdx);
829    }
830    mWaveGens.clear();
831}
832
833////////////////////////////////////////////////////////////////////////////////
834//
835//    Method:       ToneGenerator::getToneForRegion()
836//
837//    Description:  Get correct ringtone type according to current region.
838//      The corrected ring tone type is the tone descriptor index in sToneDescriptors[].
839//
840//    Input:
841//        none
842//
843//    Output:
844//        none
845//
846////////////////////////////////////////////////////////////////////////////////
847int ToneGenerator::getToneForRegion(int toneType) {
848    int regionTone;
849
850    if (mRegion == CEPT || toneType < FIRST_SUP_TONE || toneType > LAST_SUP_TONE) {
851        regionTone = toneType;
852    } else {
853        regionTone = sToneMappingTable[mRegion][toneType - FIRST_SUP_TONE];
854    }
855
856    LOGV("getToneForRegion, tone %d, region %d, regionTone %d", toneType, mRegion, regionTone);
857
858    return regionTone;
859}
860
861
862////////////////////////////////////////////////////////////////////////////////
863//                WaveGenerator::WaveGenerator class    Implementation
864////////////////////////////////////////////////////////////////////////////////
865
866//---------------------------------- public methods ----------------------------
867
868////////////////////////////////////////////////////////////////////////////////
869//
870//    Method:        WaveGenerator::WaveGenerator()
871//
872//    Description:    Constructor.
873//
874//    Input:
875//        samplingRate:    Output sampling rate in Hz
876//        frequency:       Frequency of the sine wave to generate in Hz
877//        volume:          volume (0.0 to 1.0)
878//
879//    Output:
880//        none
881//
882////////////////////////////////////////////////////////////////////////////////
883ToneGenerator::WaveGenerator::WaveGenerator(unsigned short samplingRate,
884        unsigned short frequency, float volume) {
885    double d0;
886    double F_div_Fs;  // frequency / samplingRate
887
888    F_div_Fs = frequency / (double)samplingRate;
889    d0 = - (float)GEN_AMP * sin(2 * M_PI * F_div_Fs);
890    mS2_0 = (short)d0;
891    mS1 = 0;
892    mS2 = mS2_0;
893
894    mAmplitude_Q15 = (short)(32767. * 32767. * volume / GEN_AMP);
895    // take some margin for amplitude fluctuation
896    if (mAmplitude_Q15 > 32500)
897        mAmplitude_Q15 = 32500;
898
899    d0 = 32768.0 * cos(2 * M_PI * F_div_Fs);  // Q14*2*cos()
900    if (d0 > 32767)
901        d0 = 32767;
902    mA1_Q14 = (short) d0;
903
904    LOGV("WaveGenerator init, mA1_Q14: %d, mS2_0: %d, mAmplitude_Q15: %d\n",
905            mA1_Q14, mS2_0, mAmplitude_Q15);
906}
907
908////////////////////////////////////////////////////////////////////////////////
909//
910//    Method:        WaveGenerator::~WaveGenerator()
911//
912//    Description:    Destructor.
913//
914//    Input:
915//        none
916//
917//    Output:
918//        none
919//
920////////////////////////////////////////////////////////////////////////////////
921ToneGenerator::WaveGenerator::~WaveGenerator() {
922}
923
924////////////////////////////////////////////////////////////////////////////////
925//
926//    Method:        WaveGenerator::getSamples()
927//
928//    Description:    Generates count samples of a sine wave and accumulates
929//        result in outBuffer.
930//
931//    Input:
932//        outBuffer:      Output buffer where to accumulate samples.
933//        count:          number of samples to produce.
934//        command:        special action requested (see enum gen_command).
935//
936//    Output:
937//        none
938//
939////////////////////////////////////////////////////////////////////////////////
940void ToneGenerator::WaveGenerator::getSamples(short *outBuffer,
941        unsigned int count, unsigned int command) {
942    long lS1, lS2;
943    long lA1, lAmplitude;
944    long Sample;  // current sample
945
946    // init local
947    if (command == WAVEGEN_START) {
948        lS1 = (long)0;
949        lS2 = (long)mS2_0;
950    } else {
951        lS1 = (long)mS1;
952        lS2 = (long)mS2;
953    }
954    lA1 = (long)mA1_Q14;
955    lAmplitude = (long)mAmplitude_Q15;
956
957    if (command == WAVEGEN_STOP) {
958        lAmplitude <<= 16;
959        if (count == 0) {
960            return;
961        }
962        long dec = lAmplitude/count;
963        // loop generation
964        while (count--) {
965            Sample = ((lA1 * lS1) >> S_Q14) - lS2;
966            // shift delay
967            lS2 = lS1;
968            lS1 = Sample;
969            Sample = ((lAmplitude>>16) * Sample) >> S_Q15;
970            *(outBuffer++) += (short)Sample;  // put result in buffer
971            lAmplitude -= dec;
972        }
973    } else {
974        // loop generation
975        while (count--) {
976            Sample = ((lA1 * lS1) >> S_Q14) - lS2;
977            // shift delay
978            lS2 = lS1;
979            lS1 = Sample;
980            Sample = (lAmplitude * Sample) >> S_Q15;
981            *(outBuffer++) += (short)Sample;  // put result in buffer
982        }
983    }
984
985    // save status
986    mS1 = (short)lS1;
987    mS2 = (short)lS2;
988}
989
990}  // end namespace android
991
992