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
20#include <math.h>
21#include <utils/Log.h>
22#include <cutils/properties.h>
23#include "media/ToneGenerator.h"
24
25
26namespace android {
27
28
29// Descriptors for all available tones (See ToneGenerator::ToneDescriptor class declaration for details)
30const ToneGenerator::ToneDescriptor ToneGenerator::sToneDescriptors[] = {
31        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1336, 941, 0 }, 0, 0},
32                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
33          .repeatCnt = ToneGenerator::TONEGEN_INF,
34          .repeatSegment = 0 },                              // TONE_DTMF_0
35        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1209, 697, 0 }, 0, 0 },
36                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
37          .repeatCnt = ToneGenerator::TONEGEN_INF,
38          .repeatSegment = 0 },                              // TONE_DTMF_1
39        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1336, 697, 0 }, 0, 0 },
40                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
41          .repeatCnt = ToneGenerator::TONEGEN_INF,
42          .repeatSegment = 0 },                              // TONE_DTMF_2
43        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1477, 697, 0 }, 0, 0 },
44                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
45          .repeatCnt = ToneGenerator::TONEGEN_INF,
46          .repeatSegment = 0 },                              // TONE_DTMF_3
47        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1209, 770, 0 }, 0, 0 },
48                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
49          .repeatCnt = ToneGenerator::TONEGEN_INF,
50          .repeatSegment = 0 },                              // TONE_DTMF_4
51        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1336, 770, 0 }, 0, 0 },
52                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
53          .repeatCnt = ToneGenerator::TONEGEN_INF,
54          .repeatSegment = 0 },                              // TONE_DTMF_5
55        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1477, 770, 0 }, 0, 0 },
56                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
57          .repeatCnt = ToneGenerator::TONEGEN_INF,
58          .repeatSegment = 0 },                              // TONE_DTMF_6
59        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1209, 852, 0 }, 0, 0 },
60                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
61          .repeatCnt = ToneGenerator::TONEGEN_INF,
62          .repeatSegment = 0 },                              // TONE_DTMF_7
63        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1336, 852, 0 }, 0, 0 },
64                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
65          .repeatCnt = ToneGenerator::TONEGEN_INF,
66          .repeatSegment = 0 },                              // TONE_DTMF_8
67        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1477, 852, 0 }, 0, 0 },
68                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
69          .repeatCnt = ToneGenerator::TONEGEN_INF,
70          .repeatSegment = 0 },                              // TONE_DTMF_9
71        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1209, 941, 0 }, 0, 0 },
72                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
73          .repeatCnt = ToneGenerator::TONEGEN_INF,
74          .repeatSegment = 0 },                              // TONE_DTMF_S
75        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1477, 941, 0 }, 0, 0 },
76                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
77          .repeatCnt = ToneGenerator::TONEGEN_INF,
78          .repeatSegment = 0 },                              // TONE_DTMF_P
79        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1633, 697, 0 }, 0, 0 },
80                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
81          .repeatCnt = ToneGenerator::TONEGEN_INF,
82          .repeatSegment = 0 },                              // TONE_DTMF_A
83        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1633, 770, 0 }, 0, 0 },
84                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
85          .repeatCnt = ToneGenerator::TONEGEN_INF,
86          .repeatSegment = 0 },                             // TONE_DTMF_B
87        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1633, 852, 0 }, 0, 0 },
88                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
89          .repeatCnt = ToneGenerator::TONEGEN_INF,
90          .repeatSegment = 0 },                              // TONE_DTMF_C
91        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1633, 941, 0 }, 0, 0 },
92                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
93          .repeatCnt = ToneGenerator::TONEGEN_INF,
94          .repeatSegment = 0 },                              // TONE_DTMF_D
95        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 425, 0 }, 0, 0 },
96                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
97          .repeatCnt = ToneGenerator::TONEGEN_INF,
98          .repeatSegment = 0 },                              // TONE_SUP_DIAL
99        { .segments = { { .duration = 500 , .waveFreq = { 425, 0 }, 0, 0},
100                        { .duration = 500, .waveFreq = { 0 }, 0, 0},
101                           { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
102          .repeatCnt = ToneGenerator::TONEGEN_INF,
103          .repeatSegment = 0 },                              // TONE_SUP_BUSY
104        { .segments = { { .duration = 200, .waveFreq = { 425, 0 }, 0, 0 },
105                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
106                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
107          .repeatCnt = ToneGenerator::TONEGEN_INF,
108          .repeatSegment = 0 },                              // TONE_SUP_CONGESTION
109        { .segments = { { .duration = 200, .waveFreq = { 425, 0 }, 0, 0 },
110                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
111          .repeatCnt = 0,
112          .repeatSegment = 0 },                              // TONE_SUP_RADIO_ACK
113        { .segments = { { .duration = 200, .waveFreq = { 425, 0 }, 0, 0},
114                        { .duration = 200, .waveFreq = { 0 }, 0, 0},
115                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
116          .repeatCnt = 2,
117          .repeatSegment = 0 },                              // TONE_SUP_RADIO_NOTAVAIL
118        { .segments = { { .duration = 330, .waveFreq = { 950, 1400, 1800, 0 }, 0, 0},
119                        { .duration = 1000, .waveFreq = { 0 }, 0, 0},
120                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
121          .repeatCnt = ToneGenerator::TONEGEN_INF,
122          .repeatSegment = 0 },                              // TONE_SUP_ERROR
123        { .segments = { { .duration = 200, .waveFreq = { 425, 0 }, 0, 0 },
124                        { .duration = 600, .waveFreq = { 0 }, 0, 0 },
125                        { .duration = 200, .waveFreq = { 425, 0 }, 0, 0 },
126                        { .duration = 3000, .waveFreq = { 0 }, 0, 0 },
127                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
128          .repeatCnt = ToneGenerator::TONEGEN_INF,
129          .repeatSegment = 0 },                              // TONE_SUP_CALL_WAITING
130        { .segments = { { .duration = 1000, .waveFreq = { 425, 0 }, 0, 0 },
131                        { .duration = 4000, .waveFreq = { 0 }, 0, 0 },
132                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
133          .repeatCnt = ToneGenerator::TONEGEN_INF,
134          .repeatSegment = 0 },                              // TONE_SUP_RINGTONE
135        { .segments = { { .duration = 40, .waveFreq = { 400, 1200, 0 }, 0, 0 },
136                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
137          .repeatCnt = 0,
138          .repeatSegment = 0 },                              // TONE_PROP_BEEP
139        { .segments = { { .duration = 100, .waveFreq = { 1200, 0 }, 0, 0 },
140                        { .duration = 100, .waveFreq = { 0 }, 0, 0  },
141                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
142          .repeatCnt = 1,
143          .repeatSegment = 0 },                              // TONE_PROP_ACK
144        { .segments = { { .duration = 400, .waveFreq = { 300, 400, 500, 0 }, 0, 0 },
145                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
146          .repeatCnt = 0,
147          .repeatSegment = 0 },                              // TONE_PROP_NACK
148        { .segments = { { .duration = 200, .waveFreq = { 400, 1200, 0 }, 0, 0 },
149                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
150          .repeatCnt = 0,
151          .repeatSegment = 0 },                              // TONE_PROP_PROMPT
152        { .segments = { { .duration = 40, .waveFreq = { 400, 1200, 0 }, 0, 0 },
153                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
154                        { .duration = 40, .waveFreq = { 400, 1200, 0 }, 0, 0 },
155                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
156          .repeatCnt = 0,
157          .repeatSegment = 0 },                             // TONE_PROP_BEEP2
158        { .segments = { { .duration = 250, .waveFreq = { 440, 0 }, 0, 0 },
159                        { .duration = 250, .waveFreq = { 620, 0 }, 0, 0 },
160                        { .duration = 0 , .waveFreq = { 0 }, 0, 0 }},
161          .repeatCnt = ToneGenerator::TONEGEN_INF,
162          .repeatSegment = 0 },                              // TONE_SUP_INTERCEPT
163        { .segments = { { .duration = 250, .waveFreq = { 440, 0 }, 0, 0 },
164                        { .duration = 250, .waveFreq = { 620, 0 }, 0, 0 },
165                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
166          .repeatCnt = 7,
167          .repeatSegment = 0 },                             // TONE_SUP_INTERCEPT_ABBREV
168        { .segments = { { .duration = 250, .waveFreq = { 480, 620, 0 }, 0, 0 },
169                        { .duration = 250, .waveFreq = { 0 }, 0, 0 },
170                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
171          .repeatCnt = 7,
172          .repeatSegment = 0 },                             // TONE_SUP_CONGESTION_ABBREV
173        { .segments = { { .duration = 100, .waveFreq = { 350, 440, 0 }, 0, 0 },
174                        { .duration = 100, .waveFreq = { 0 }, 0, 0 },
175                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
176          .repeatCnt = 2,
177          .repeatSegment = 0 },                             // TONE_SUP_CONFIRM
178        { .segments = { { .duration = 100, .waveFreq = { 480, 0 }, 0, 0 },
179                        { .duration = 100, .waveFreq = { 0 }, 0, 0 },
180                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
181          .repeatCnt = 3,
182          .repeatSegment = 0 },                              // TONE_SUP_PIP
183        { .segments = {{ .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 425, 0 }, 0, 0},
184                       { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
185          .repeatCnt = ToneGenerator::TONEGEN_INF,
186          .repeatSegment = 0 },                              // TONE_CDMA_DIAL_TONE_LITE
187        { .segments = { { .duration = 2000, .waveFreq = { 440, 480, 0 }, 0, 0 },
188                        { .duration = 4000, .waveFreq = { 0 }, 0, 0 },
189                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
190          .repeatCnt = ToneGenerator::TONEGEN_INF,
191          .repeatSegment = 0 },                              // TONE_CDMA_NETWORK_USA_RINGBACK
192        { .segments = { { .duration = 250, .waveFreq = { 440, 0 }, 0, 0 },
193                        { .duration = 250, .waveFreq = { 620, 0 }, 0, 0 },
194                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
195          .repeatCnt =  ToneGenerator::TONEGEN_INF,
196          .repeatSegment = 0 },                             // TONE_CDMA_INTERCEPT
197        { .segments = { { .duration = 250, .waveFreq = { 440, 0 }, 0, 0 },
198                        { .duration = 250, .waveFreq = { 620, 0 }, 0, 0 },
199                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
200          .repeatCnt =  0,
201          .repeatSegment = 0 },                             // TONE_CDMA_ABBR_INTERCEPT
202        { .segments = { { .duration = 250, .waveFreq = { 480, 620, 0 }, 0, 0 },
203                        { .duration = 250, .waveFreq = { 0 }, 0, 0 },
204                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
205          .repeatCnt = ToneGenerator::TONEGEN_INF,
206          .repeatSegment = 0 },                              // TONE_CDMA_REORDER
207        { .segments = { { .duration = 250, .waveFreq = { 480, 620, 0 }, 0, 0 },
208                        { .duration = 250, .waveFreq = { 0 }, 0, 0 },
209                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
210          .repeatCnt = 7,
211          .repeatSegment = 0 },                              // TONE_CDMA_ABBR_REORDER
212        { .segments = { { .duration = 500, .waveFreq = { 480, 620, 0 }, 0, 0 },
213                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
214                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
215          .repeatCnt = ToneGenerator::TONEGEN_INF,
216          .repeatSegment = 0 },                              // TONE_CDMA_NETWORK_BUSY
217        { .segments = { { .duration = 100, .waveFreq = { 350, 440, 0 }, 0, 0 },
218                        { .duration = 100, .waveFreq = { 0 }, 0, 0 },
219                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
220          .repeatCnt = 2,
221          .repeatSegment = 0 },                              // TONE_CDMA_CONFIRM
222        { .segments = { { .duration = 500, .waveFreq = { 660, 1000, 0 }, 0, 0 },
223                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
224          .repeatCnt = 0,
225          .repeatSegment = 0 },                              // TONE_CDMA_ANSWER
226        { .segments = { { .duration = 300, .waveFreq = { 440, 0 }, 0, 0 },
227                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
228          .repeatCnt = 0,
229          .repeatSegment = 0 },                              // TONE_CDMA_NETWORK_CALLWAITING
230        { .segments = { { .duration = 100, .waveFreq = { 480, 0 }, 0, 0 },
231                        { .duration = 100, .waveFreq = { 0 }, 0, 0 },
232                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
233          .repeatCnt = 3,
234          .repeatSegment = 0 },                              // TONE_CDMA_PIP
235
236        { .segments = { { .duration = 32, .waveFreq = { 2091, 0}, 0, 0 },
237                        { .duration = 64, .waveFreq = { 2556, 0}, 19, 0},
238                        { .duration = 32, .waveFreq = { 2091, 0}, 0, 0},
239                        { .duration = 48, .waveFreq = { 2556, 0}, 0, 0},
240                        { .duration = 4000, .waveFreq = { 0 }, 0, 0},
241                        { .duration = 0,  .waveFreq = { 0 }, 0, 0}},
242          .repeatCnt = 0,
243          .repeatSegment = 0 },                             // TONE_CDMA_CALL_SIGNAL_ISDN_NORMAL
244        { .segments = { { .duration = 32, .waveFreq = { 2091, 0}, 0, 0 },
245                        { .duration = 64, .waveFreq = { 2556, 0}, 7, 0 },
246                        { .duration = 32, .waveFreq = { 2091, 0}, 0, 0 },
247                        { .duration = 400, .waveFreq = { 0 }, 0, 0 },
248                        { .duration = 32,  .waveFreq = { 2091, 0}, 0, 0 },
249                        { .duration = 64,  .waveFreq = { 2556, 0}, 7, 4 },
250                        { .duration = 32,  .waveFreq = { 2091, 0}, 0, 0 },
251                        { .duration = 4000, .waveFreq = { 0 }, 0, 0 },
252                        { .duration = 0,    .waveFreq = { 0 }, 0, 0 } },
253          .repeatCnt = 0,
254          .repeatSegment = 0 },                              // TONE_CDMA_CALL_SIGNAL_ISDN_INTERGROUP
255        { .segments = { { .duration = 32, .waveFreq = { 2091, 0}, 0, 0 },
256                        { .duration = 64, .waveFreq = { 2556, 0}, 3, 0 },
257                        { .duration = 16, .waveFreq = { 2091, 0}, 0, 0 },
258                        { .duration = 200, .waveFreq = { 0 },     0, 0 },
259                        { .duration = 32, .waveFreq = { 2091, 0}, 0, 0 },
260                        { .duration = 64, .waveFreq = { 2556, 0}, 3, 4 },
261                        { .duration = 16, .waveFreq = { 2091, 0}, 0, 0 },
262                        { .duration = 200, .waveFreq = { 0 },     0, 0 },
263                        { .duration = 0,   .waveFreq = { 0 },     0, 0 } },
264          .repeatCnt = 0,
265          .repeatSegment = 0 },                            // TONE_CDMA_CALL_SIGNAL_ISDN_SP_PRI
266        { .segments = { { .duration = 0,  .waveFreq = { 0 }, 0, 0} },
267          .repeatCnt = 0,
268          .repeatSegment = 0 },                            // TONE_CDMA_CALL_SIGNAL_ISDN_PAT3
269        { .segments = { { .duration = 32, .waveFreq = { 2091, 0 }, 0, 0 },
270                        { .duration = 64, .waveFreq = { 2556, 0 }, 4, 0 },
271                        { .duration = 20, .waveFreq = { 2091, 0 }, 0, 0 },
272                        { .duration = 0,  .waveFreq = { 0 }      , 0, 0 } },
273          .repeatCnt = 0,
274          .repeatSegment = 0 },                             // TONE_CDMA_CALL_SIGNAL_ISDN_PING_RING
275        { .segments = { { .duration = 0,  .waveFreq = { 0 }, 0, 0} },
276          .repeatCnt = 0,
277          .repeatSegment = 0 },                             // TONE_CDMA_CALL_SIGNAL_ISDN_PAT5
278        { .segments = { { .duration = 0,  .waveFreq = { 0 }, 0, 0} },
279          .repeatCnt = 0,
280          .repeatSegment = 0 },                             // TONE_CDMA_CALL_SIGNAL_ISDN_PAT6
281        { .segments = { { .duration = 0,  .waveFreq = { 0 }, 0, 0} },
282          .repeatCnt = 0,
283          .repeatSegment = 0 },                             // TONE_CDMA_CALL_SIGNAL_ISDN_PAT7
284
285        { .segments = { { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
286                        { .duration = 25, .waveFreq = { 4000, 0 }, 39, 0 },
287                        { .duration = 4000, .waveFreq = { 0 },     0, 0 },
288                        { .duration = 0,    .waveFreq = { 0 },     0, 0 } },
289          .repeatCnt = ToneGenerator::TONEGEN_INF,
290          .repeatSegment = 0 },                           // TONE_CDMA_HIGH_L
291        { .segments = { { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
292                        { .duration = 25, .waveFreq = { 2900, 0 }, 39, 0 },
293                        { .duration = 4000, .waveFreq = { 0 },     0, 0 },
294                        { .duration = 0,    .waveFreq = { 0 },     0, 0 } },
295          .repeatCnt = ToneGenerator::TONEGEN_INF,
296          .repeatSegment = 0 },                           // TONE_CDMA_MED_L
297        { .segments = { { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
298                        { .duration = 25, .waveFreq = { 1450, 0 }, 39, 0 },
299                        { .duration = 4000, .waveFreq = { 0 },     0, 0 },
300                        { .duration = 0,    .waveFreq = { 0 },     0, 0 } },
301          .repeatCnt = ToneGenerator::TONEGEN_INF,
302          .repeatSegment = 0 },                           // TONE_CDMA_LOW_L
303        { .segments = { { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
304                        { .duration = 25, .waveFreq = { 4000, 0 }, 15, 0 },
305                        { .duration = 400, .waveFreq = { 0 }, 0, 0 },
306                        { .duration = 0, .waveFreq = { 0 }, 0, 0 } },
307          .repeatCnt = ToneGenerator::TONEGEN_INF,
308          .repeatSegment = 0 },                           // TONE_CDMA_HIGH_SS
309        { .segments = { { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
310                        { .duration = 25, .waveFreq = { 2900, 0 }, 15, 0 },
311                        { .duration = 400, .waveFreq = { 0 }, 0, 0 },
312                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
313          .repeatCnt = ToneGenerator::TONEGEN_INF,
314          .repeatSegment = 0 },                           // TONE_CDMA_MED_SS
315        { .segments = { { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
316                        { .duration = 25, .waveFreq = { 1450, 0 }, 15, 0 },
317                        { .duration = 400, .waveFreq = { 0 }, 0, 0 },
318                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
319          .repeatCnt = ToneGenerator::TONEGEN_INF,
320          .repeatSegment = 0 },                           // TONE_CDMA_LOW_SS
321        { .segments = { { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
322                        { .duration = 25, .waveFreq = { 4000, 0 }, 7, 0 },
323                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
324                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
325                        { .duration = 25, .waveFreq = { 4000, 0 }, 7, 3 },
326                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
327                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
328                        { .duration = 25, .waveFreq = { 4000, 0 }, 15, 6 },
329                        { .duration = 4000, .waveFreq = { 0 }, 0, 0 },
330                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
331          .repeatCnt = ToneGenerator::TONEGEN_INF,
332          .repeatSegment = 0 },                           // TONE_CDMA_HIGH_SSL
333        { .segments = { { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
334                        { .duration = 25, .waveFreq = { 2900, 0 }, 7, 0 },
335                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
336                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
337                        { .duration = 25, .waveFreq = { 2900, 0 }, 7, 3 },
338                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
339                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
340                        { .duration = 25, .waveFreq = { 2900, 0 }, 15, 6 },
341                        { .duration = 4000, .waveFreq = { 0 }, 0, 0 },
342                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
343          .repeatCnt = ToneGenerator::TONEGEN_INF,
344          .repeatSegment = 0 },                           // TONE_CDMA_MED_SSL
345        { .segments = { { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
346                        { .duration = 25, .waveFreq = { 1450, 0 }, 7, 0 },
347                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
348                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
349                        { .duration = 25, .waveFreq = { 1450, 0 }, 7, 3 },
350                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
351                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
352                        { .duration = 25, .waveFreq = { 1450, 0 }, 15, 6 },
353                        { .duration = 4000, .waveFreq = { 0 }, 0, 0 },
354                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
355          .repeatCnt = ToneGenerator::TONEGEN_INF,
356          .repeatSegment = 0 },                           // TONE_CDMA_LOW_SSL
357        { .segments = { { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
358                          { .duration = 25, .waveFreq = { 4000, 0 }, 19, 0 },
359                        { .duration = 1000, .waveFreq = { 0 }, 0, 0 },
360                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
361                        { .duration = 25, .waveFreq = { 4000, 0 }, 19, 3 },
362                        { .duration = 3000, .waveFreq = { 0 }, 0, 0 },
363                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
364          .repeatCnt = ToneGenerator::TONEGEN_INF,
365          .repeatSegment = 0 },                           // TONE_CDMA_HIGH_SS_2
366        { .segments = { { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
367                        { .duration = 25, .waveFreq = { 2900, 0 }, 19, 0 },
368                        { .duration = 1000, .waveFreq = { 0 }, 0, 0 },
369                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
370                        { .duration = 25, .waveFreq = { 2900, 0 }, 19, 3 },
371                        { .duration = 3000, .waveFreq = { 0 }, 0, 0 },
372                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
373          .repeatCnt = ToneGenerator::TONEGEN_INF,
374          .repeatSegment = 0 },                           // TONE_CDMA_MED_SS_2
375        { .segments = { { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
376                        { .duration = 25, .waveFreq = { 1450, 0 }, 19, 0 },
377                        { .duration = 1000, .waveFreq = { 0 }, 0, 0 },
378                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
379                        { .duration = 25, .waveFreq = { 1450, 0 }, 19, 3 },
380                        { .duration = 3000, .waveFreq = { 0 }, 0, 0 },
381                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
382          .repeatCnt = ToneGenerator::TONEGEN_INF,
383          .repeatSegment = 0 },                           // TONE_CDMA_LOW_SS_2
384        { .segments = { { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
385                        { .duration = 25, .waveFreq = { 4000, 0 }, 9, 0 },
386                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
387                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
388                        { .duration = 25, .waveFreq = { 4000, 0 }, 19, 3 },
389                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
390                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
391                        { .duration = 25, .waveFreq = { 4000, 0 }, 9, 6 },
392                        { .duration = 3000, .waveFreq = { 0 }, 0, 0 },
393                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
394          .repeatCnt = ToneGenerator::TONEGEN_INF,
395          .repeatSegment = 0 },                           // TONE_CDMA_HIGH_SLS
396        { .segments = { { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
397                        { .duration = 25, .waveFreq = { 2900, 0 }, 9, 0 },
398                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
399                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
400                        { .duration = 25, .waveFreq = { 2900, 0 }, 19, 3 },
401                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
402                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
403                        { .duration = 25, .waveFreq = { 2900, 0 }, 9, 6 },
404                        { .duration = 3000, .waveFreq = { 0 }, 0, 0 },
405                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
406          .repeatCnt = ToneGenerator::TONEGEN_INF,
407          .repeatSegment = 0 },                           // TONE_CDMA_MED_SLS
408        { .segments = { { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
409                        { .duration = 25, .waveFreq = { 1450, 0 }, 9, 0 },
410                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
411                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
412                        { .duration = 25, .waveFreq = { 1450, 0 }, 19, 3 },
413                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
414                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
415                        { .duration = 25, .waveFreq = { 1450, 0 }, 9, 6 },
416                        { .duration = 3000, .waveFreq = { 0 }, 0, 0 },
417                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
418          .repeatCnt = ToneGenerator::TONEGEN_INF,
419          .repeatSegment = 0 },                           // TONE_CDMA_LOW_SLS
420        { .segments = { { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
421                        { .duration = 25, .waveFreq = { 4000, 0 }, 9, 0 },
422                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
423                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
424                        { .duration = 25, .waveFreq = { 4000, 0 }, 9, 3 },
425                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
426                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
427                        { .duration = 25, .waveFreq = { 4000, 0 }, 9, 6 },
428                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
429                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
430                        { .duration = 25, .waveFreq = { 4000, 0 }, 9, 9 },
431                        { .duration = 2500, .waveFreq = { 0 }, 0, 0 },
432                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
433          .repeatCnt = ToneGenerator::TONEGEN_INF,
434          .repeatSegment = 0 },                           // TONE_CDMA_HIGH_S_X4
435        { .segments = { { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
436                        { .duration = 25, .waveFreq = { 2900, 0 }, 9, 0 },
437                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
438                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
439                        { .duration = 25, .waveFreq = { 2900, 0 }, 9, 3 },
440                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
441                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
442                        { .duration = 25, .waveFreq = { 2900, 0 }, 9, 6 },
443                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
444                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
445                        { .duration = 25, .waveFreq = { 2900, 0 }, 9, 9 },
446                        { .duration = 2500, .waveFreq = { 0 }, 0, 0 },
447                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
448          .repeatCnt = ToneGenerator::TONEGEN_INF,
449          .repeatSegment = 0 },                           // TONE_CDMA_MED_S_X4
450        { .segments = { { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
451                        { .duration = 25, .waveFreq = { 1450, 0 }, 9, 0 },
452                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
453                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
454                        { .duration = 25, .waveFreq = { 1450, 0 }, 9, 3 },
455                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
456                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
457                        { .duration = 25, .waveFreq = { 1450, 0 }, 9, 6 },
458                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
459                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
460                        { .duration = 25, .waveFreq = { 1450, 0 }, 9, 9 },
461                        { .duration = 2500, .waveFreq = { 0 }, 0, 0 },
462                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
463          .repeatCnt = ToneGenerator::TONEGEN_INF,
464          .repeatSegment = 0 },                           // TONE_CDMA_LOW_S_X4
465        { .segments = { { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
466                        { .duration = 25, .waveFreq = { 4000, 0 }, 19, 0 },
467                        { .duration = 2000, .waveFreq = { 0 }, 0, 0 },
468                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
469          .repeatCnt = ToneGenerator::TONEGEN_INF,
470          .repeatSegment = 0 },                           // TONE_CDMA_HIGH_PBX_L
471        { .segments = { { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
472                        { .duration = 25, .waveFreq = { 2900, 0 }, 19, 0 },
473                        { .duration = 2000, .waveFreq = { 0 }, 0, 0 },
474                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
475          .repeatCnt = ToneGenerator::TONEGEN_INF,
476          .repeatSegment = 0 },                           // TONE_CDMA_MED_PBX_L
477        { .segments = { { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
478                        { .duration = 25, .waveFreq = { 1450, 0 }, 19, 0 },
479                        { .duration = 2000, .waveFreq = { 0 }, 0, 0 },
480                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
481          .repeatCnt = ToneGenerator::TONEGEN_INF,
482          .repeatSegment = 0 },                           // TONE_CDMA_LOW_PBX_L
483        { .segments = { { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
484                        { .duration = 25, .waveFreq = { 4000, 0 }, 7, 0 },
485                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
486                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
487                        { .duration = 25, .waveFreq = { 4000, 0 }, 7, 3 },
488                        { .duration = 2000, .waveFreq = { 0 }, 0, 0 },
489                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
490          .repeatCnt = ToneGenerator::TONEGEN_INF,
491          .repeatSegment = 0 },                           // TONE_CDMA_HIGH_PBX_SS
492        { .segments = { { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
493                        { .duration = 25, .waveFreq = { 2900, 0 }, 7, 0 },
494                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
495                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
496                        { .duration = 25, .waveFreq = { 2900, 0 }, 7, 3 },
497                        { .duration = 2000, .waveFreq = { 0 }, 0, 0 },
498                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
499          .repeatCnt = ToneGenerator::TONEGEN_INF,
500          .repeatSegment = 0 },                           // TONE_CDMA_MED_PBX_SS
501        { .segments = { { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
502                        { .duration = 25, .waveFreq = { 1450, 0 }, 7, 0 },
503                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
504                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
505                        { .duration = 25, .waveFreq = { 1450, 0 }, 7, 3 },
506                        { .duration = 2000, .waveFreq = { 0 }, 0, 0 },
507                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
508          .repeatCnt = ToneGenerator::TONEGEN_INF,
509          .repeatSegment = 0 },                           // TONE_CDMA_LOW_PBX_SS
510        { .segments = { { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
511                        { .duration = 25, .waveFreq = { 4000, 0 }, 7, 0 },
512                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
513                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
514                        { .duration = 25, .waveFreq = { 4000, 0 }, 7, 3 },
515                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
516                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
517                        { .duration = 25, .waveFreq = { 4000, 0 }, 15, 6 },
518                        { .duration = 1000, .waveFreq = { 0 }, 0, 0 },
519                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
520          .repeatCnt = ToneGenerator::TONEGEN_INF,
521          .repeatSegment = 0 },                           // TONE_CDMA_HIGH_PBX_SSL
522        { .segments = { { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
523                        { .duration = 25, .waveFreq = { 2900, 0 }, 7, 0 },
524                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
525                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
526                        { .duration = 25, .waveFreq = { 2900, 0 }, 7, 3 },
527                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
528                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
529                        { .duration = 25, .waveFreq = { 2900, 0 }, 15, 6 },
530                        { .duration = 1000, .waveFreq = { 0 }, 0, 0 },
531                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
532          .repeatCnt = ToneGenerator::TONEGEN_INF,
533          .repeatSegment = 0 },                           // TONE_CDMA_MED_PBX_SSL
534        { .segments = { { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
535                        { .duration = 25, .waveFreq = { 1450, 0 }, 7, 0 },
536                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
537                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
538                        { .duration = 25, .waveFreq = { 1450, 0 }, 7, 3 },
539                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
540                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
541                        { .duration = 25, .waveFreq = { 1450, 0 }, 15, 6 },
542                        { .duration = 1000, .waveFreq = { 0 }, 0, 0 },
543                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
544          .repeatCnt = ToneGenerator::TONEGEN_INF,
545          .repeatSegment = 0 },                           // TONE_CDMA_LOW_PBX_SSL
546        { .segments = { { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
547                        { .duration = 25, .waveFreq = { 4000, 0 }, 7, 0 },
548                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
549                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
550                        { .duration = 25, .waveFreq = { 4000, 0 }, 15, 3 },
551                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
552                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
553                        { .duration = 25, .waveFreq = { 4000, 0 }, 7, 6 },
554                        { .duration = 1000, .waveFreq = { 0 }, 0, 0 },
555                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
556          .repeatCnt = ToneGenerator::TONEGEN_INF,
557          .repeatSegment = 0 },                           // TONE_CDMA_HIGH_PBX_SLS
558        { .segments = { { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
559                        { .duration = 25, .waveFreq = { 2900, 0 }, 7, 0 },
560                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
561                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
562                        { .duration = 25, .waveFreq = { 2900, 0 }, 15, 3 },
563                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
564                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
565                        { .duration = 25, .waveFreq = { 2900, 0 }, 7, 6 },
566                        { .duration = 1000, .waveFreq = { 0 }, 0, 0 },
567                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
568          .repeatCnt = ToneGenerator::TONEGEN_INF,
569          .repeatSegment = 0 },                           // TONE_CDMA_MED_PBX_SLS
570        { .segments = { { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
571                        { .duration = 25, .waveFreq = { 1450, 0 }, 7, 0 },
572                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
573                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
574                        { .duration = 25, .waveFreq = { 1450, 0 }, 15, 3 },
575                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
576                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
577                        { .duration = 25, .waveFreq = { 1450, 0 }, 7, 6 },
578                        { .duration = 1000, .waveFreq = { 0 }, 0, 0 },
579                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
580           .repeatCnt = ToneGenerator::TONEGEN_INF,
581          .repeatSegment = 0 },                           // TONE_CDMA_LOW_PBX_SLS
582        { .segments = { { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
583                        { .duration = 25, .waveFreq = { 4000, 0 }, 7, 0 },
584                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
585                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
586                        { .duration = 25, .waveFreq = { 4000, 0 }, 7, 3 },
587                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
588                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
589                        { .duration = 25, .waveFreq = { 4000, 0 }, 7, 6 },
590                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
591                        { .duration = 25, .waveFreq = { 3700, 0 }, 0, 0 },
592                        { .duration = 25, .waveFreq = { 4000, 0 }, 7, 9 },
593                        { .duration = 800, .waveFreq = { 0 }, 0, 0 },
594                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
595          .repeatCnt = ToneGenerator::TONEGEN_INF,
596          .repeatSegment = 0 },                           // TONE_CDMA_HIGH_PBX_S_X4
597        { .segments = { { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
598                        { .duration = 25, .waveFreq = { 2900, 0 }, 7, 0 },
599                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
600                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
601                        { .duration = 25, .waveFreq = { 2900, 0 }, 7, 3 },
602                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
603                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
604                        { .duration = 25, .waveFreq = { 2900, 0 }, 7, 6 },
605                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
606                        { .duration = 25, .waveFreq = { 2600, 0 }, 0, 0 },
607                        { .duration = 25, .waveFreq = { 2900, 0 }, 7, 9 },
608                        { .duration = 800, .waveFreq = { 0 }, 0, 0 },
609                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
610          .repeatCnt = ToneGenerator::TONEGEN_INF,
611          .repeatSegment = 0 },                           // TONE_CDMA_MED_PBX_S_X4
612        { .segments = { { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
613                        { .duration = 25, .waveFreq = { 1450, 0 }, 7, 0 },
614                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
615                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
616                        { .duration = 25, .waveFreq = { 1450, 0 }, 7, 3 },
617                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
618                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
619                        { .duration = 25, .waveFreq = { 1450, 0 }, 7, 6 },
620                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
621                        { .duration = 25, .waveFreq = { 1300, 0 }, 0, 0 },
622                        { .duration = 25, .waveFreq = { 1450, 0 }, 7, 9 },
623                        { .duration = 800, .waveFreq = { 0 }, 0, 0 },
624                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
625          .repeatCnt = ToneGenerator::TONEGEN_INF,
626          .repeatSegment = 0 },                           // TONE_CDMA_LOW_PBX_S_X4
627
628        { .segments = { { .duration = 62, .waveFreq = { 1109, 0 }, 0, 0 },
629                        { .duration = 62, .waveFreq = { 784, 0 },  0, 0 },
630                        { .duration = 62, .waveFreq = { 740, 0 },  0, 0 },
631                        { .duration = 62, .waveFreq = { 622, 0 },  0, 0 },
632                        { .duration = 62, .waveFreq = { 1109, 0 }, 0, 0 },
633                        { .duration = 0,  .waveFreq = { 0 },       0, 0 } },
634          .repeatCnt = 0,
635          .repeatSegment = 0 },                            // TONE_CDMA_ALERT_NETWORK_LITE
636        { .segments = { { .duration = 62, .waveFreq = { 1245, 0 }, 0, 0 },
637                        { .duration = 62, .waveFreq = { 659, 0 },  2, 0 },
638                        { .duration = 62, .waveFreq = { 1245, 0 }, 0, 0 },
639                        { .duration = 0,  .waveFreq = { 0 },       0, 0 } },
640          .repeatCnt = 0,
641          .repeatSegment = 0 },                            // TONE_CDMA_ALERT_AUTOREDIAL_LITE
642        { .segments = { { .duration = 400, .waveFreq = { 1150, 770, 0 }, 0, 0 },
643                        { .duration = 0,   .waveFreq = { 0 },            0, 0 } },
644          .repeatCnt = 0,
645          .repeatSegment = 0 },                            // TONE_CDMA_ONE_MIN_BEEP
646        { .segments = { { .duration = 120, .waveFreq = { 941, 1477, 0 }, 0, 0 },
647                        { .duration = 0,   .waveFreq = { 0 },            0, 0 } },
648          .repeatCnt = 0,
649          .repeatSegment = 0 },                            // TONE_CDMA_KEYPAD_VOLUME_KEY_LITE
650        { .segments = { { .duration = 375, .waveFreq = { 587, 0 }, 0, 0 },
651                        { .duration = 125, .waveFreq = { 1175, 0 }, 0, 0 },
652                        { .duration = 0,   .waveFreq = { 0 },       0, 0 } },
653          .repeatCnt = 0,
654          .repeatSegment = 0 },                            // TONE_CDMA_PRESSHOLDKEY_LITE
655        { .segments = { { .duration = 62, .waveFreq = { 587, 0 }, 0, 0 },
656                        { .duration = 62, .waveFreq = { 784, 0 }, 0, 0 },
657                        { .duration = 62, .waveFreq = { 831, 0 }, 0, 0 },
658                        { .duration = 62, .waveFreq = { 784, 0 }, 0, 0 },
659                        { .duration = 62, .waveFreq = { 1109, 0 }, 0, 0 },
660                        { .duration = 62, .waveFreq = { 784, 0 }, 0, 0 },
661                        { .duration = 62, .waveFreq = { 831, 0 }, 0, 0 },
662                        { .duration = 62, .waveFreq = { 784, 0 }, 0, 0 },
663                        { .duration = 0,  .waveFreq = { 0 },      0, 0 } },
664          .repeatCnt = 0,
665          .repeatSegment = 0 },                             // TONE_CDMA_ALERT_INCALL_LITE
666        { .segments = { { .duration = 125, .waveFreq = { 941, 0 }, 0, 0 },
667                        { .duration = 10,  .waveFreq = { 0 },      2, 0 },
668                        { .duration = 4990, .waveFreq = { 0 },     0, 0 },
669                        { .duration = 0,    .waveFreq = { 0 },     0, 0 } },
670          .repeatCnt = ToneGenerator::TONEGEN_INF,
671          .repeatSegment = 0 },                            // TONE_CDMA_EMERGENCY_RINGBACK
672        { .segments = { { .duration = 125, .waveFreq = { 1319, 0 }, 0, 0 },
673                        { .duration = 125, .waveFreq = { 0 },       0, 0 },
674                        { .duration = 0,   .waveFreq = { 0 },       0, 0 } },
675          .repeatCnt = 2,
676          .repeatSegment = 0 },                            // TONE_CDMA_ALERT_CALL_GUARD
677        { .segments = { { .duration = 125, .waveFreq = { 1047, 0 }, 0, 0 },
678                        { .duration = 125, .waveFreq = { 370,  0 }, 0, 0 },
679                        { .duration = 0,   .waveFreq = { 0 },       0, 0 } },
680          .repeatCnt = 0,
681          .repeatSegment = 0 },                            // TONE_CDMA_SOFT_ERROR_LITE
682        { .segments = { { .duration = 125, .waveFreq = { 1480, 0 }, 0, 0 },
683                        { .duration = 125, .waveFreq = { 1397, 0 }, 0, 0 },
684                        { .duration = 125, .waveFreq = { 784, 0 },  0, 0 },
685                        { .duration = 0,   .waveFreq = { 0 },       0, 0 } },
686          .repeatCnt = 0,
687          .repeatSegment = 0 },                            // TONE_CDMA_CALLDROP_LITE
688
689        { .segments = { { .duration = 500, .waveFreq = { 425, 0 }, 0, 0 },
690                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
691                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
692          .repeatCnt = 0,
693          .repeatSegment = 0 },                           // TONE_CDMA_NETWORK_BUSY_ONE_SHOT
694        { .segments = { { .duration = 400, .waveFreq = { 1150, 770 }, 0, 0 },
695                        { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
696          .repeatCnt = 0,
697          .repeatSegment = 0 },                           // TONE_CDMA_ABBR_ALERT
698          { .segments = { { .duration = 0, .waveFreq = { 0 }, 0, 0 }},
699          .repeatCnt = 0,
700          .repeatSegment = 0 },                            // TONE_CDMA_SIGNAL_OFF
701
702        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 350, 440, 0 }, 0, 0 },
703                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
704          .repeatCnt = ToneGenerator::TONEGEN_INF,
705          .repeatSegment = 0 },                              // TONE_ANSI_DIAL
706        { .segments = { { .duration = 500, .waveFreq = { 480, 620, 0 }, 0, 0 },
707                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
708                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
709          .repeatCnt = ToneGenerator::TONEGEN_INF,
710          .repeatSegment = 0 },                              // TONE_ANSI_BUSY
711        { .segments = { { .duration = 250, .waveFreq = { 480, 620, 0 }, 0, 0 },
712                        { .duration = 250, .waveFreq = { 0 }, 0, 0 },
713                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
714          .repeatCnt = ToneGenerator::TONEGEN_INF,
715          .repeatSegment = 0 },                              // TONE_ANSI_CONGESTION
716        { .segments = { { .duration = 300, .waveFreq = { 440, 0 }, 0, 0 },
717                        { .duration = 9700, .waveFreq = { 0 }, 0, 0 },
718                        { .duration = 100, .waveFreq = { 440, 0 }, 0, 0 },
719                        { .duration = 100, .waveFreq = { 0 }, 0, 0 },
720                        { .duration = 100, .waveFreq = { 440, 0 }, 0, 0 },
721                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
722          .repeatCnt = ToneGenerator::TONEGEN_INF,
723          .repeatSegment = 1 },                              // TONE_ANSI_CALL_WAITING
724        { .segments = { { .duration = 2000, .waveFreq = { 440, 480, 0 }, 0, 0 },
725                        { .duration = 4000, .waveFreq = { 0 }, 0, 0 },
726                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
727          .repeatCnt = ToneGenerator::TONEGEN_INF,
728          .repeatSegment = 0 },                              // TONE_ANSI_RINGTONE
729        { .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 400, 0 }, 0, 0 },
730                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
731          .repeatCnt = ToneGenerator::TONEGEN_INF,
732          .repeatSegment = 0 },                              // TONE_JAPAN_DIAL
733        { .segments = { { .duration = 500, .waveFreq = { 400, 0 }, 0, 0 },
734                        { .duration = 500, .waveFreq = { 0 }, 0, 0 },
735                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
736          .repeatCnt = ToneGenerator::TONEGEN_INF,
737          .repeatSegment = 0 },                              // TONE_JAPAN_BUSY
738        { .segments = { { .duration = 1000, .waveFreq = { 400, 0 }, 0, 0 },
739                        { .duration = 2000, .waveFreq = { 0 }, 0, 0 },
740                        { .duration = 0 , .waveFreq = { 0 }, 0, 0}},
741          .repeatCnt = ToneGenerator::TONEGEN_INF,
742          .repeatSegment = 0 },                              // TONE_JAPAN_RADIO_ACK
743        { .segments = { { .duration = 400, .waveFreq = { 400, 450, 0 }, 0, 0 },
744                        { .duration = 200, .waveFreq = { 0 }, 0, 0 },
745                        { .duration = 400, .waveFreq = { 400, 450, 0 }, 0, 0 },
746                        { .duration = 2000, .waveFreq = { 0 }, 0, 0},
747                        { .duration = 0, .waveFreq = { 0 }, 0, 0}},
748          .repeatCnt = ToneGenerator::TONEGEN_INF,
749          .repeatSegment = 0 },                              // TONE_UK_RINGTONE
750
751
752
753};
754
755// Used by ToneGenerator::getToneForRegion() to convert user specified supervisory tone type
756// to actual tone for current region.
757const unsigned char /*tone_type*/ ToneGenerator::sToneMappingTable[NUM_REGIONS-1][NUM_SUP_TONES] = {
758        {   // ANSI
759            TONE_ANSI_DIAL,             // TONE_SUP_DIAL
760            TONE_ANSI_BUSY,             // TONE_SUP_BUSY
761            TONE_ANSI_CONGESTION,       // TONE_SUP_CONGESTION
762            TONE_SUP_RADIO_ACK,         // TONE_SUP_RADIO_ACK
763            TONE_SUP_RADIO_NOTAVAIL,    // TONE_SUP_RADIO_NOTAVAIL
764            TONE_SUP_ERROR,             // TONE_SUP_ERROR
765            TONE_ANSI_CALL_WAITING,     // TONE_SUP_CALL_WAITING
766            TONE_ANSI_RINGTONE          // TONE_SUP_RINGTONE
767        },
768        {   // JAPAN
769            TONE_JAPAN_DIAL,             // TONE_SUP_DIAL
770            TONE_JAPAN_BUSY,             // TONE_SUP_BUSY
771            TONE_SUP_CONGESTION,         // TONE_SUP_CONGESTION
772            TONE_JAPAN_RADIO_ACK,        // TONE_SUP_RADIO_ACK
773            TONE_SUP_RADIO_NOTAVAIL,     // TONE_SUP_RADIO_NOTAVAIL
774            TONE_SUP_ERROR,              // TONE_SUP_ERROR
775            TONE_SUP_CALL_WAITING,       // TONE_SUP_CALL_WAITING
776            TONE_SUP_RINGTONE            // TONE_SUP_RINGTONE
777        },
778        {   // UK
779            TONE_SUP_DIAL,               // TONE_SUP_DIAL
780            TONE_SUP_BUSY,               // TONE_SUP_BUSY
781            TONE_SUP_CONGESTION,         // TONE_SUP_CONGESTION
782            TONE_SUP_RADIO_ACK,          // TONE_SUP_RADIO_ACK
783            TONE_SUP_RADIO_NOTAVAIL,     // TONE_SUP_RADIO_NOTAVAIL
784            TONE_SUP_ERROR,              // TONE_SUP_ERROR
785            TONE_SUP_CALL_WAITING,       // TONE_SUP_CALL_WAITING
786            TONE_UK_RINGTONE             // TONE_SUP_RINGTONE
787        }
788
789};
790
791
792////////////////////////////////////////////////////////////////////////////////
793//                           ToneGenerator class Implementation
794////////////////////////////////////////////////////////////////////////////////
795
796
797//---------------------------------- public methods ----------------------------
798
799
800////////////////////////////////////////////////////////////////////////////////
801//
802//    Method:        ToneGenerator::ToneGenerator()
803//
804//    Description:    Constructor. Initializes the tone sequencer, intantiates required sine wave
805//        generators, instantiates output audio track.
806//
807//    Input:
808//        streamType:        Type of stream used for tone playback
809//        volume:            volume applied to tone (0.0 to 1.0)
810//
811//    Output:
812//        none
813//
814////////////////////////////////////////////////////////////////////////////////
815ToneGenerator::ToneGenerator(audio_stream_type_t streamType, float volume, bool threadCanCallJava) {
816
817    ALOGV("ToneGenerator constructor: streamType=%d, volume=%f", streamType, volume);
818
819    mState = TONE_IDLE;
820
821    if (AudioSystem::getOutputSamplingRate(&mSamplingRate, streamType) != NO_ERROR) {
822        ALOGE("Unable to marshal AudioFlinger");
823        return;
824    }
825    mThreadCanCallJava = threadCanCallJava;
826    mStreamType = streamType;
827    mVolume = volume;
828    mpToneDesc = NULL;
829    mpNewToneDesc = NULL;
830    // Generate tone by chunks of 20 ms to keep cadencing precision
831    mProcessSize = (mSamplingRate * 20) / 1000;
832
833    char value[PROPERTY_VALUE_MAX];
834    property_get("gsm.operator.iso-country", value, "");
835    if (strcmp(value,"us") == 0 ||
836        strcmp(value,"ca") == 0) {
837        mRegion = ANSI;
838    } else if (strcmp(value,"jp") == 0) {
839        mRegion = JAPAN;
840    } else if (strcmp(value,"uk") == 0 ||
841               strcmp(value,"uk,uk") == 0) {
842        mRegion = UK;
843    } else {
844        mRegion = CEPT;
845    }
846
847    if (initAudioTrack()) {
848        ALOGV("ToneGenerator INIT OK, time: %d", (unsigned int)(systemTime()/1000000));
849    } else {
850        ALOGV("!!!ToneGenerator INIT FAILED!!!");
851    }
852}
853
854
855
856
857////////////////////////////////////////////////////////////////////////////////
858//
859//    Method:        ToneGenerator::~ToneGenerator()
860//
861//    Description:    Destructor. Stop sound playback and delete audio track if
862//      needed and delete sine wave generators.
863//
864//    Input:
865//        none
866//
867//    Output:
868//        none
869//
870////////////////////////////////////////////////////////////////////////////////
871ToneGenerator::~ToneGenerator() {
872    ALOGV("ToneGenerator destructor");
873
874    if (mpAudioTrack != 0) {
875        stopTone();
876        ALOGV("Delete Track: %p", mpAudioTrack.get());
877        mpAudioTrack.clear();
878    }
879}
880
881////////////////////////////////////////////////////////////////////////////////
882//
883//    Method:        ToneGenerator::startTone()
884//
885//    Description:    Starts tone playback.
886//
887//    Input:
888//        toneType:        Type of tone generated (values in enum tone_type)
889//        durationMs:      The tone duration in milliseconds. If the tone is limited in time by definition,
890//              the actual duration will be the minimum of durationMs and the defined tone duration.
891//              Ommiting or setting durationMs to -1 does not limit tone duration.
892//
893//    Output:
894//        none
895//
896////////////////////////////////////////////////////////////////////////////////
897bool ToneGenerator::startTone(tone_type toneType, int durationMs) {
898    bool lResult = false;
899    status_t lStatus;
900
901    if ((toneType < 0) || (toneType >= NUM_TONES))
902        return lResult;
903
904    toneType = getToneForRegion(toneType);
905    if (toneType == TONE_CDMA_SIGNAL_OFF) {
906        return true;
907    }
908
909    if (mState == TONE_IDLE) {
910        ALOGV("startTone: try to re-init AudioTrack");
911        if (!initAudioTrack()) {
912            return lResult;
913        }
914    }
915
916    ALOGV("startTone");
917
918    mLock.lock();
919
920    // Get descriptor for requested tone
921    mpNewToneDesc = &sToneDescriptors[toneType];
922
923    mDurationMs = durationMs;
924
925    if (mState == TONE_STOPPED) {
926        ALOGV("Start waiting for previous tone to stop");
927        lStatus = mWaitCbkCond.waitRelative(mLock, seconds(3));
928        if (lStatus != NO_ERROR) {
929            ALOGE("--- start wait for stop timed out, status %d", lStatus);
930            mState = TONE_IDLE;
931            mLock.unlock();
932            return lResult;
933        }
934    }
935
936    if (mState == TONE_INIT) {
937        if (prepareWave()) {
938            ALOGV("Immediate start, time %d", (unsigned int)(systemTime()/1000000));
939            lResult = true;
940            mState = TONE_STARTING;
941            if (clock_gettime(CLOCK_MONOTONIC, &mStartTime) != 0) {
942                mStartTime.tv_sec = 0;
943            }
944            mLock.unlock();
945            mpAudioTrack->start();
946            mLock.lock();
947            if (mState == TONE_STARTING) {
948                ALOGV("Wait for start callback");
949                lStatus = mWaitCbkCond.waitRelative(mLock, seconds(3));
950                if (lStatus != NO_ERROR) {
951                    ALOGE("--- Immediate start timed out, status %d", lStatus);
952                    mState = TONE_IDLE;
953                    lResult = false;
954                }
955            }
956        } else {
957            mState = TONE_IDLE;
958        }
959    } else {
960        ALOGV("Delayed start");
961        mState = TONE_RESTARTING;
962        mStartTime.tv_sec = 0;
963        lStatus = mWaitCbkCond.waitRelative(mLock, seconds(3));
964        if (lStatus == NO_ERROR) {
965            if (mState != TONE_IDLE) {
966                lResult = true;
967            }
968            ALOGV("cond received");
969        } else {
970            ALOGE("--- Delayed start timed out, status %d", lStatus);
971            mState = TONE_IDLE;
972        }
973    }
974    mLock.unlock();
975
976    ALOGV_IF(lResult, "Tone started, time %d", (unsigned int)(systemTime()/1000000));
977    ALOGW_IF(!lResult, "Tone start failed!!!, time %d", (unsigned int)(systemTime()/1000000));
978
979    return lResult;
980}
981
982////////////////////////////////////////////////////////////////////////////////
983//
984//    Method:        ToneGenerator::stopTone()
985//
986//    Description:    Stops tone playback.
987//
988//    Input:
989//        none
990//
991//    Output:
992//        none
993//
994////////////////////////////////////////////////////////////////////////////////
995void ToneGenerator::stopTone() {
996    ALOGV("stopTone");
997
998    mLock.lock();
999    if (mState != TONE_IDLE && mState != TONE_INIT) {
1000        if (mState == TONE_PLAYING || mState == TONE_STARTING || mState == TONE_RESTARTING) {
1001            struct timespec stopTime;
1002            // If the start time is valid, make sure that the number of audio samples produced
1003            // corresponds at least to the time between the start and stop commands.
1004            // This is needed in case of cold start of the output stream.
1005            if ((mStartTime.tv_sec != 0) && (clock_gettime(CLOCK_MONOTONIC, &stopTime) == 0)) {
1006                time_t sec = stopTime.tv_sec - mStartTime.tv_sec;
1007                long nsec = stopTime.tv_nsec - mStartTime.tv_nsec;
1008                if (nsec < 0) {
1009                    --sec;
1010                    nsec += 1000000000;
1011                }
1012
1013                if ((sec + 1) > ((long)(INT_MAX / mSamplingRate))) {
1014                    mMaxSmp = sec * mSamplingRate;
1015                } else {
1016                    // mSamplingRate is always > 1000
1017                    sec = sec * 1000 + nsec / 1000000; // duration in milliseconds
1018                    mMaxSmp = (unsigned int)(((int64_t)sec * mSamplingRate) / 1000);
1019                }
1020                ALOGV("stopTone() forcing mMaxSmp to %d, total for far %d", mMaxSmp,  mTotalSmp);
1021            } else {
1022                mState = TONE_STOPPING;
1023            }
1024        }
1025        ALOGV("waiting cond");
1026        status_t lStatus = mWaitCbkCond.waitRelative(mLock, seconds(3));
1027        if (lStatus == NO_ERROR) {
1028            // If the tone was restarted exit now before calling clearWaveGens();
1029            if (mState != TONE_INIT) {
1030                mLock.unlock();
1031                return;
1032            }
1033            ALOGV("track stop complete, time %d", (unsigned int)(systemTime()/1000000));
1034        } else {
1035            ALOGE("--- Stop timed out");
1036            mState = TONE_IDLE;
1037            mpAudioTrack->stop();
1038        }
1039        clearWaveGens();
1040    }
1041
1042    mLock.unlock();
1043}
1044
1045//---------------------------------- private methods ---------------------------
1046
1047
1048
1049
1050////////////////////////////////////////////////////////////////////////////////
1051//
1052//    Method:        ToneGenerator::initAudioTrack()
1053//
1054//    Description:    Allocates and configures AudioTrack used for PCM output.
1055//
1056//    Input:
1057//        none
1058//
1059//    Output:
1060//        none
1061//
1062////////////////////////////////////////////////////////////////////////////////
1063bool ToneGenerator::initAudioTrack() {
1064
1065    // Open audio track in mono, PCM 16bit, default sampling rate, default buffer size
1066    mpAudioTrack = new AudioTrack();
1067    ALOGV("Create Track: %p", mpAudioTrack.get());
1068
1069    mpAudioTrack->set(mStreamType,
1070                      0,    // sampleRate
1071                      AUDIO_FORMAT_PCM_16_BIT,
1072                      AUDIO_CHANNEL_OUT_MONO,
1073                      0,    // frameCount
1074                      AUDIO_OUTPUT_FLAG_FAST,
1075                      audioCallback,
1076                      this, // user
1077                      0,    // notificationFrames
1078                      0,    // sharedBuffer
1079                      mThreadCanCallJava,
1080                      AUDIO_SESSION_ALLOCATE,
1081                      AudioTrack::TRANSFER_CALLBACK);
1082
1083    if (mpAudioTrack->initCheck() != NO_ERROR) {
1084        ALOGE("AudioTrack->initCheck failed");
1085        goto initAudioTrack_exit;
1086    }
1087
1088    mpAudioTrack->setVolume(mVolume);
1089
1090    mState = TONE_INIT;
1091
1092    return true;
1093
1094initAudioTrack_exit:
1095
1096    ALOGV("Init failed: %p", mpAudioTrack.get());
1097
1098    // Cleanup
1099    mpAudioTrack.clear();
1100
1101    return false;
1102}
1103
1104
1105////////////////////////////////////////////////////////////////////////////////
1106//
1107//    Method:        ToneGenerator::audioCallback()
1108//
1109//    Description:    AudioTrack callback implementation. Generates a block of
1110//        PCM samples
1111//        and manages tone generator sequencer: tones pulses, tone duration...
1112//
1113//    Input:
1114//        user    reference (pointer to our ToneGenerator)
1115//        info    audio buffer descriptor
1116//
1117//    Output:
1118//        returned value: always true.
1119//
1120////////////////////////////////////////////////////////////////////////////////
1121void ToneGenerator::audioCallback(int event, void* user, void *info) {
1122
1123    if (event != AudioTrack::EVENT_MORE_DATA) return;
1124
1125    AudioTrack::Buffer *buffer = static_cast<AudioTrack::Buffer *>(info);
1126    ToneGenerator *lpToneGen = static_cast<ToneGenerator *>(user);
1127    short *lpOut = buffer->i16;
1128    unsigned int lNumSmp = buffer->size/sizeof(short);
1129    const ToneDescriptor *lpToneDesc = lpToneGen->mpToneDesc;
1130
1131    if (buffer->size == 0) return;
1132
1133
1134    // Clear output buffer: WaveGenerator accumulates into lpOut buffer
1135    memset(lpOut, 0, buffer->size);
1136
1137    while (lNumSmp) {
1138        unsigned int lReqSmp = lNumSmp < lpToneGen->mProcessSize*2 ? lNumSmp : lpToneGen->mProcessSize;
1139        unsigned int lGenSmp;
1140        unsigned int lWaveCmd = WaveGenerator::WAVEGEN_CONT;
1141        bool lSignal = false;
1142
1143        lpToneGen->mLock.lock();
1144
1145
1146        // Update pcm frame count and end time (current time at the end of this process)
1147        lpToneGen->mTotalSmp += lReqSmp;
1148
1149        // Update tone gen state machine and select wave gen command
1150        switch (lpToneGen->mState) {
1151        case TONE_PLAYING:
1152            lWaveCmd = WaveGenerator::WAVEGEN_CONT;
1153            break;
1154        case TONE_STARTING:
1155            ALOGV("Starting Cbk");
1156
1157            lWaveCmd = WaveGenerator::WAVEGEN_START;
1158            break;
1159        case TONE_STOPPING:
1160        case TONE_RESTARTING:
1161            ALOGV("Stop/restart Cbk");
1162
1163            lWaveCmd = WaveGenerator::WAVEGEN_STOP;
1164            lpToneGen->mNextSegSmp = TONEGEN_INF; // forced to skip state machine management below
1165            break;
1166        case TONE_STOPPED:
1167            ALOGV("Stopped Cbk");
1168            goto audioCallback_EndLoop;
1169        default:
1170            ALOGV("Extra Cbk");
1171            goto audioCallback_EndLoop;
1172        }
1173
1174        // Exit if tone sequence is over
1175        if (lpToneDesc->segments[lpToneGen->mCurSegment].duration == 0 ||
1176            lpToneGen->mTotalSmp > lpToneGen->mMaxSmp) {
1177            if (lpToneGen->mState == TONE_PLAYING) {
1178                lpToneGen->mState = TONE_STOPPING;
1179            }
1180            if (lpToneDesc->segments[lpToneGen->mCurSegment].duration == 0) {
1181                goto audioCallback_EndLoop;
1182            }
1183            // fade out before stopping if maximum duration reached
1184            lWaveCmd = WaveGenerator::WAVEGEN_STOP;
1185            lpToneGen->mNextSegSmp = TONEGEN_INF; // forced to skip state machine management below
1186        }
1187
1188        if (lpToneGen->mTotalSmp > lpToneGen->mNextSegSmp) {
1189            // Time to go to next sequence segment
1190
1191            ALOGV("End Segment, time: %d", (unsigned int)(systemTime()/1000000));
1192
1193            lGenSmp = lReqSmp;
1194
1195            // If segment,  ON -> OFF transition : ramp volume down
1196            if (lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[0] != 0) {
1197                lWaveCmd = WaveGenerator::WAVEGEN_STOP;
1198                unsigned int lFreqIdx = 0;
1199                unsigned short lFrequency = lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[lFreqIdx];
1200
1201                while (lFrequency != 0) {
1202                    WaveGenerator *lpWaveGen = lpToneGen->mWaveGens.valueFor(lFrequency);
1203                    lpWaveGen->getSamples(lpOut, lGenSmp, lWaveCmd);
1204                    lFrequency = lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[++lFreqIdx];
1205                }
1206                ALOGV("ON->OFF, lGenSmp: %d, lReqSmp: %d", lGenSmp, lReqSmp);
1207            }
1208
1209            // check if we need to loop and loop for the reqd times
1210            if (lpToneDesc->segments[lpToneGen->mCurSegment].loopCnt) {
1211                if (lpToneGen->mLoopCounter < lpToneDesc->segments[lpToneGen->mCurSegment].loopCnt) {
1212                    ALOGV ("in if loop loopCnt(%d) loopctr(%d), CurSeg(%d)",
1213                          lpToneDesc->segments[lpToneGen->mCurSegment].loopCnt,
1214                          lpToneGen->mLoopCounter,
1215                          lpToneGen->mCurSegment);
1216                    lpToneGen->mCurSegment = lpToneDesc->segments[lpToneGen->mCurSegment].loopIndx;
1217                    ++lpToneGen->mLoopCounter;
1218                } else {
1219                    // completed loop. go to next segment
1220                    lpToneGen->mLoopCounter = 0;
1221                    lpToneGen->mCurSegment++;
1222                    ALOGV ("in else loop loopCnt(%d) loopctr(%d), CurSeg(%d)",
1223                          lpToneDesc->segments[lpToneGen->mCurSegment].loopCnt,
1224                          lpToneGen->mLoopCounter,
1225                          lpToneGen->mCurSegment);
1226                }
1227            } else {
1228                lpToneGen->mCurSegment++;
1229                ALOGV ("Goto next seg loopCnt(%d) loopctr(%d), CurSeg(%d)",
1230                      lpToneDesc->segments[lpToneGen->mCurSegment].loopCnt,
1231                      lpToneGen->mLoopCounter,
1232                      lpToneGen->mCurSegment);
1233
1234            }
1235
1236            // Handle loop if last segment reached
1237            if (lpToneDesc->segments[lpToneGen->mCurSegment].duration == 0) {
1238                ALOGV("Last Seg: %d", lpToneGen->mCurSegment);
1239
1240                // Pre increment loop count and restart if total count not reached. Stop sequence otherwise
1241                if (++lpToneGen->mCurCount <= lpToneDesc->repeatCnt) {
1242                    ALOGV("Repeating Count: %d", lpToneGen->mCurCount);
1243
1244                    lpToneGen->mCurSegment = lpToneDesc->repeatSegment;
1245                    if (lpToneDesc->segments[lpToneDesc->repeatSegment].waveFreq[0] != 0) {
1246                        lWaveCmd = WaveGenerator::WAVEGEN_START;
1247                    }
1248
1249                    ALOGV("New segment %d, Next Time: %d", lpToneGen->mCurSegment,
1250                            (lpToneGen->mNextSegSmp*1000)/lpToneGen->mSamplingRate);
1251
1252                } else {
1253                    lGenSmp = 0;
1254                    ALOGV("End repeat, time: %d", (unsigned int)(systemTime()/1000000));
1255                }
1256            } else {
1257                ALOGV("New segment %d, Next Time: %d", lpToneGen->mCurSegment,
1258                        (lpToneGen->mNextSegSmp*1000)/lpToneGen->mSamplingRate);
1259                if (lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[0] != 0) {
1260                    // If next segment is not silent,  OFF -> ON transition : reset wave generator
1261                    lWaveCmd = WaveGenerator::WAVEGEN_START;
1262
1263                    ALOGV("OFF->ON, lGenSmp: %d, lReqSmp: %d", lGenSmp, lReqSmp);
1264                } else {
1265                    lGenSmp = 0;
1266                }
1267            }
1268
1269            // Update next segment transition position. No harm to do it also for last segment as lpToneGen->mNextSegSmp won't be used any more
1270            lpToneGen->mNextSegSmp
1271                    += (lpToneDesc->segments[lpToneGen->mCurSegment].duration * lpToneGen->mSamplingRate) / 1000;
1272
1273        } else {
1274            // Inside a segment keep tone ON or OFF
1275            if (lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[0] == 0) {
1276                lGenSmp = 0;  // If odd segment, tone is currently OFF
1277            } else {
1278                lGenSmp = lReqSmp;  // If event segment, tone is currently ON
1279            }
1280        }
1281
1282        if (lGenSmp) {
1283            // If samples must be generated, call all active wave generators and acumulate waves in lpOut
1284            unsigned int lFreqIdx = 0;
1285            unsigned short lFrequency = lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[lFreqIdx];
1286
1287            while (lFrequency != 0) {
1288                WaveGenerator *lpWaveGen = lpToneGen->mWaveGens.valueFor(lFrequency);
1289                lpWaveGen->getSamples(lpOut, lGenSmp, lWaveCmd);
1290                lFrequency = lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[++lFreqIdx];
1291            }
1292        }
1293
1294        lNumSmp -= lReqSmp;
1295        lpOut += lReqSmp;
1296
1297audioCallback_EndLoop:
1298
1299        switch (lpToneGen->mState) {
1300        case TONE_RESTARTING:
1301            ALOGV("Cbk restarting track");
1302            if (lpToneGen->prepareWave()) {
1303                lpToneGen->mState = TONE_STARTING;
1304                if (clock_gettime(CLOCK_MONOTONIC, &lpToneGen->mStartTime) != 0) {
1305                    lpToneGen->mStartTime.tv_sec = 0;
1306                }
1307                // must reload lpToneDesc as prepareWave() may change mpToneDesc
1308                lpToneDesc = lpToneGen->mpToneDesc;
1309            } else {
1310                ALOGW("Cbk restarting prepareWave() failed");
1311                lpToneGen->mState = TONE_IDLE;
1312                lpToneGen->mpAudioTrack->stop();
1313                // Force loop exit
1314                lNumSmp = 0;
1315            }
1316            lSignal = true;
1317            break;
1318        case TONE_STOPPING:
1319            ALOGV("Cbk Stopping");
1320            lpToneGen->mState = TONE_STOPPED;
1321            // Force loop exit
1322            lNumSmp = 0;
1323            break;
1324        case TONE_STOPPED:
1325            lpToneGen->mState = TONE_INIT;
1326            ALOGV("Cbk Stopped track");
1327            lpToneGen->mpAudioTrack->stop();
1328            // Force loop exit
1329            lNumSmp = 0;
1330            buffer->size = 0;
1331            lSignal = true;
1332            break;
1333        case TONE_STARTING:
1334            ALOGV("Cbk starting track");
1335            lpToneGen->mState = TONE_PLAYING;
1336            lSignal = true;
1337            break;
1338        case TONE_PLAYING:
1339            break;
1340        default:
1341            // Force loop exit
1342            lNumSmp = 0;
1343            buffer->size = 0;
1344            break;
1345        }
1346
1347        if (lSignal)
1348            lpToneGen->mWaitCbkCond.broadcast();
1349        lpToneGen->mLock.unlock();
1350    }
1351}
1352
1353
1354////////////////////////////////////////////////////////////////////////////////
1355//
1356//    Method:        ToneGenerator::prepareWave()
1357//
1358//    Description:    Prepare wave generators and reset tone sequencer state machine.
1359//      mpNewToneDesc must have been initialized before calling this function.
1360//    Input:
1361//        none
1362//
1363//    Output:
1364//        returned value:   true if wave generators have been created, false otherwise
1365//
1366////////////////////////////////////////////////////////////////////////////////
1367bool ToneGenerator::prepareWave() {
1368    unsigned int segmentIdx = 0;
1369
1370    if (mpNewToneDesc == NULL) {
1371        return false;
1372    }
1373
1374    // Remove existing wave generators if any
1375    clearWaveGens();
1376
1377    mpToneDesc = mpNewToneDesc;
1378
1379    if (mDurationMs == -1) {
1380        mMaxSmp = TONEGEN_INF;
1381    } else {
1382        if (mDurationMs > (int)(TONEGEN_INF / mSamplingRate)) {
1383            mMaxSmp = (mDurationMs / 1000) * mSamplingRate;
1384        } else {
1385            mMaxSmp = (mDurationMs * mSamplingRate) / 1000;
1386        }
1387        ALOGV("prepareWave, duration limited to %d ms", mDurationMs);
1388    }
1389
1390    while (mpToneDesc->segments[segmentIdx].duration) {
1391        // Get total number of sine waves: needed to adapt sine wave gain.
1392        unsigned int lNumWaves = numWaves(segmentIdx);
1393        unsigned int freqIdx = 0;
1394        unsigned int frequency = mpToneDesc->segments[segmentIdx].waveFreq[freqIdx];
1395        while (frequency) {
1396            // Instantiate a wave generator if  ot already done for this frequency
1397            if (mWaveGens.indexOfKey(frequency) == NAME_NOT_FOUND) {
1398                ToneGenerator::WaveGenerator *lpWaveGen =
1399                        new ToneGenerator::WaveGenerator((unsigned short)mSamplingRate,
1400                                frequency,
1401                                TONEGEN_GAIN/lNumWaves);
1402                mWaveGens.add(frequency, lpWaveGen);
1403            }
1404            frequency = mpNewToneDesc->segments[segmentIdx].waveFreq[++freqIdx];
1405        }
1406        segmentIdx++;
1407    }
1408
1409    // Initialize tone sequencer
1410    mTotalSmp = 0;
1411    mCurSegment = 0;
1412    mCurCount = 0;
1413    mLoopCounter = 0;
1414    if (mpToneDesc->segments[0].duration == TONEGEN_INF) {
1415        mNextSegSmp = TONEGEN_INF;
1416    } else{
1417        mNextSegSmp = (mpToneDesc->segments[0].duration * mSamplingRate) / 1000;
1418    }
1419
1420    return true;
1421}
1422
1423
1424////////////////////////////////////////////////////////////////////////////////
1425//
1426//    Method:        ToneGenerator::numWaves()
1427//
1428//    Description:    Count number of sine waves needed to generate a tone segment (e.g 2 for DTMF).
1429//
1430//    Input:
1431//        segmentIdx        tone segment index
1432//
1433//    Output:
1434//        returned value:    nummber of sine waves
1435//
1436////////////////////////////////////////////////////////////////////////////////
1437unsigned int ToneGenerator::numWaves(unsigned int segmentIdx) {
1438    unsigned int lCnt = 0;
1439
1440    if (mpToneDesc->segments[segmentIdx].duration) {
1441        while (mpToneDesc->segments[segmentIdx].waveFreq[lCnt]) {
1442            lCnt++;
1443        }
1444        lCnt++;
1445    }
1446
1447    return lCnt;
1448}
1449
1450
1451////////////////////////////////////////////////////////////////////////////////
1452//
1453//    Method:        ToneGenerator::clearWaveGens()
1454//
1455//    Description:    Removes all wave generators.
1456//
1457//    Input:
1458//        none
1459//
1460//    Output:
1461//        none
1462//
1463////////////////////////////////////////////////////////////////////////////////
1464void ToneGenerator::clearWaveGens() {
1465    ALOGV("Clearing mWaveGens:");
1466
1467    for (size_t lIdx = 0; lIdx < mWaveGens.size(); lIdx++) {
1468        delete mWaveGens.valueAt(lIdx);
1469    }
1470    mWaveGens.clear();
1471}
1472
1473////////////////////////////////////////////////////////////////////////////////
1474//
1475//    Method:       ToneGenerator::getToneForRegion()
1476//
1477//    Description:  Get correct ringtone type according to current region.
1478//      The corrected ring tone type is the tone descriptor index in sToneDescriptors[].
1479//
1480//    Input:
1481//        none
1482//
1483//    Output:
1484//        none
1485//
1486////////////////////////////////////////////////////////////////////////////////
1487ToneGenerator::tone_type ToneGenerator::getToneForRegion(tone_type toneType) {
1488    tone_type regionTone;
1489
1490    if (mRegion == CEPT || toneType < FIRST_SUP_TONE || toneType > LAST_SUP_TONE) {
1491        regionTone = toneType;
1492    } else {
1493        regionTone = (tone_type) sToneMappingTable[mRegion][toneType - FIRST_SUP_TONE];
1494    }
1495
1496    ALOGV("getToneForRegion, tone %d, region %d, regionTone %d", toneType, mRegion, regionTone);
1497
1498    return regionTone;
1499}
1500
1501
1502////////////////////////////////////////////////////////////////////////////////
1503//                WaveGenerator::WaveGenerator class    Implementation
1504////////////////////////////////////////////////////////////////////////////////
1505
1506//---------------------------------- public methods ----------------------------
1507
1508////////////////////////////////////////////////////////////////////////////////
1509//
1510//    Method:        WaveGenerator::WaveGenerator()
1511//
1512//    Description:    Constructor.
1513//
1514//    Input:
1515//        samplingRate:    Output sampling rate in Hz
1516//        frequency:       Frequency of the sine wave to generate in Hz
1517//        volume:          volume (0.0 to 1.0)
1518//
1519//    Output:
1520//        none
1521//
1522////////////////////////////////////////////////////////////////////////////////
1523ToneGenerator::WaveGenerator::WaveGenerator(unsigned short samplingRate,
1524        unsigned short frequency, float volume) {
1525    double d0;
1526    double F_div_Fs;  // frequency / samplingRate
1527
1528    F_div_Fs = frequency / (double)samplingRate;
1529    d0 = - (float)GEN_AMP * sin(2 * M_PI * F_div_Fs);
1530    mS2_0 = (short)d0;
1531    mS1 = 0;
1532    mS2 = mS2_0;
1533
1534    mAmplitude_Q15 = (short)(32767. * 32767. * volume / GEN_AMP);
1535    // take some margin for amplitude fluctuation
1536    if (mAmplitude_Q15 > 32500)
1537        mAmplitude_Q15 = 32500;
1538
1539    d0 = 32768.0 * cos(2 * M_PI * F_div_Fs);  // Q14*2*cos()
1540    if (d0 > 32767)
1541        d0 = 32767;
1542    mA1_Q14 = (short) d0;
1543
1544    ALOGV("WaveGenerator init, mA1_Q14: %d, mS2_0: %d, mAmplitude_Q15: %d",
1545            mA1_Q14, mS2_0, mAmplitude_Q15);
1546}
1547
1548////////////////////////////////////////////////////////////////////////////////
1549//
1550//    Method:        WaveGenerator::~WaveGenerator()
1551//
1552//    Description:    Destructor.
1553//
1554//    Input:
1555//        none
1556//
1557//    Output:
1558//        none
1559//
1560////////////////////////////////////////////////////////////////////////////////
1561ToneGenerator::WaveGenerator::~WaveGenerator() {
1562}
1563
1564////////////////////////////////////////////////////////////////////////////////
1565//
1566//    Method:        WaveGenerator::getSamples()
1567//
1568//    Description:    Generates count samples of a sine wave and accumulates
1569//        result in outBuffer.
1570//
1571//    Input:
1572//        outBuffer:      Output buffer where to accumulate samples.
1573//        count:          number of samples to produce.
1574//        command:        special action requested (see enum gen_command).
1575//
1576//    Output:
1577//        none
1578//
1579////////////////////////////////////////////////////////////////////////////////
1580void ToneGenerator::WaveGenerator::getSamples(short *outBuffer,
1581        unsigned int count, unsigned int command) {
1582    long lS1, lS2;
1583    long lA1, lAmplitude;
1584    long Sample;  // current sample
1585
1586    // init local
1587    if (command == WAVEGEN_START) {
1588        lS1 = (long)0;
1589        lS2 = (long)mS2_0;
1590    } else {
1591        lS1 = (long)mS1;
1592        lS2 = (long)mS2;
1593    }
1594    lA1 = (long)mA1_Q14;
1595    lAmplitude = (long)mAmplitude_Q15;
1596
1597    if (command == WAVEGEN_STOP) {
1598        lAmplitude <<= 16;
1599        if (count == 0) {
1600            return;
1601        }
1602        long dec = lAmplitude/count;
1603        // loop generation
1604        while (count) {
1605            count--;
1606            Sample = ((lA1 * lS1) >> S_Q14) - lS2;
1607            // shift delay
1608            lS2 = lS1;
1609            lS1 = Sample;
1610            Sample = ((lAmplitude>>16) * Sample) >> S_Q15;
1611            *(outBuffer++) += (short)Sample;  // put result in buffer
1612            lAmplitude -= dec;
1613        }
1614    } else {
1615        // loop generation
1616        while (count) {
1617            count--;
1618            Sample = ((lA1 * lS1) >> S_Q14) - lS2;
1619            // shift delay
1620            lS2 = lS1;
1621            lS1 = Sample;
1622            Sample = (lAmplitude * Sample) >> S_Q15;
1623            *(outBuffer++) += (short)Sample;  // put result in buffer
1624        }
1625    }
1626
1627    // save status
1628    mS1 = (short)lS1;
1629    mS2 = (short)lS2;
1630}
1631
1632}  // end namespace android
1633