|
1 /* |
|
2 * Copyright (c) 2010 Ixonos Plc. |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of the "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - Initial contribution |
|
11 * |
|
12 * Contributors: |
|
13 * Ixonos Plc |
|
14 * |
|
15 * Description: |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 #include "ProcAMRFrameHandler.h" |
|
23 #include "ProcFrameHandler.h" |
|
24 #include "ProcTools.h" |
|
25 |
|
26 #include <e32math.h> |
|
27 |
|
28 |
|
29 TBool CProcAMRFrameHandler::ManipulateGainL(const HBufC8* aFrameIn, HBufC8*& aFrameOut, TInt8 aGain) |
|
30 { |
|
31 |
|
32 aFrameOut = HBufC8::NewLC(aFrameIn->Size()); |
|
33 |
|
34 if (aFrameIn->Size() == 1) // noData element |
|
35 { |
|
36 aFrameOut->Des().Append(aFrameIn[0]); |
|
37 CleanupStack::Pop(); // aFrameOut |
|
38 |
|
39 return ETrue; |
|
40 } |
|
41 |
|
42 |
|
43 aGain = static_cast<TInt8>(aGain/2); |
|
44 |
|
45 |
|
46 TInt posNow = 0; |
|
47 TInt nextFrameLength = 1; |
|
48 |
|
49 while (nextFrameLength > 0) |
|
50 { |
|
51 |
|
52 nextFrameLength = GetNextFrameLength(aFrameIn, posNow); |
|
53 if (nextFrameLength < 1) break; |
|
54 |
|
55 if (nextFrameLength + posNow > aFrameIn->Size()) |
|
56 { |
|
57 // something wrong with the frame, return the original |
|
58 aFrameOut->Des().Append(aFrameIn[0]); |
|
59 CleanupStack::Pop(); // aFrameOut |
|
60 return ETrue; |
|
61 } |
|
62 |
|
63 HBufC8* tmpFrame = HBufC8::NewLC(nextFrameLength); |
|
64 tmpFrame->Des().Copy(aFrameIn->Mid(posNow, nextFrameLength)); |
|
65 |
|
66 posNow += nextFrameLength; |
|
67 |
|
68 |
|
69 const TUint8 ch = (*tmpFrame)[0]; |
|
70 |
|
71 TUint dec_mode = (enum Mode)((ch & 0x0078) >> 3); |
|
72 |
|
73 TInt maxGain; |
|
74 |
|
75 RArray<TInt> gains; |
|
76 GetAMRGains(tmpFrame, gains, maxGain); |
|
77 |
|
78 |
|
79 TInt gamma10000 = KAmrGain_dB2Gamma[aGain+127]; |
|
80 |
|
81 TInt a = 0; |
|
82 TInt old_gain, old_gain1 = 0; |
|
83 TInt old_pitch, old_pitch1 = 0; |
|
84 TInt new_gain, new_gain1 = 0; |
|
85 TInt8 new_index = 0; |
|
86 |
|
87 |
|
88 |
|
89 switch (dec_mode){ |
|
90 case 0: |
|
91 |
|
92 for (a = 0; a < gains.Count()-1 ; a+=4) |
|
93 { |
|
94 |
|
95 old_gain = gains[a+1]; |
|
96 new_gain = static_cast<TInt>((gamma10000*old_gain)/10000); |
|
97 old_pitch = gains[a]; |
|
98 |
|
99 old_gain1 = gains[a+3]; |
|
100 new_gain1 = static_cast<TInt>((gamma10000*old_gain1)/10000); |
|
101 old_pitch1 = gains[a+2]; |
|
102 |
|
103 |
|
104 new_index = ProcTools::FindNewIndex475VQ(new_gain, |
|
105 old_pitch, |
|
106 new_gain1, |
|
107 old_pitch1); |
|
108 |
|
109 if (a == 0) |
|
110 { |
|
111 ProcTools::SetValueToShuffledFrame(tmpFrame, |
|
112 new_index, |
|
113 KAmrGains475_1_2, |
|
114 8); |
|
115 } |
|
116 else if(a == 4) |
|
117 { |
|
118 ProcTools::SetValueToShuffledFrame(tmpFrame, |
|
119 new_index, |
|
120 KAmrGains475_3_4, |
|
121 8); |
|
122 } |
|
123 } |
|
124 |
|
125 break; |
|
126 case 1: |
|
127 |
|
128 for (a = 0; a < gains.Count()-1 ; a+=2) |
|
129 { |
|
130 |
|
131 old_gain = gains[a+1]; |
|
132 new_gain = static_cast<TInt>((gamma10000*old_gain)/10000); |
|
133 old_pitch = gains[a]; |
|
134 |
|
135 new_index = ProcTools::FindNewIndexVQ(new_gain, old_pitch, KAmrGainTable590, 128); |
|
136 if (a == 0) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains515_1, 6); |
|
137 else if (a == 2) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains515_2, 6); |
|
138 else if (a == 4) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains515_3, 6); |
|
139 else if (a == 6) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains515_4, 6); |
|
140 } |
|
141 |
|
142 break; |
|
143 case 2: |
|
144 |
|
145 for (a = 0; a < gains.Count()-1 ; a+=2) |
|
146 { |
|
147 |
|
148 old_gain = gains[a+1]; |
|
149 new_gain = static_cast<TInt>((gamma10000*old_gain)/10000); |
|
150 old_pitch = gains[a]; |
|
151 |
|
152 new_index = ProcTools::FindNewIndexVQ(new_gain, old_pitch, KAmrGainTable590, 128); |
|
153 if (a == 0) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains590_1, 6); |
|
154 else if (a == 2) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains590_2, 6); |
|
155 else if (a == 4) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains590_3, 6); |
|
156 else if (a == 6) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains590_4, 6); |
|
157 } |
|
158 |
|
159 break; |
|
160 case 3: |
|
161 |
|
162 for (a = 0; a < gains.Count()-1 ; a+=2) |
|
163 { |
|
164 |
|
165 |
|
166 old_gain = gains[a+1]; |
|
167 new_gain = static_cast<TInt>((gamma10000*old_gain)/10000); |
|
168 old_pitch = gains[a]; |
|
169 |
|
170 new_index = ProcTools::FindNewIndexVQ(new_gain, old_pitch, KAmrGainTable102, 256); |
|
171 if (a == 0) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains670_1, 7); |
|
172 else if (a == 2) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains670_2, 7); |
|
173 else if (a == 4) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains670_3, 7); |
|
174 else if (a == 6) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains670_4, 7); |
|
175 } |
|
176 |
|
177 break; |
|
178 case 4: |
|
179 |
|
180 for (a = 0; a < gains.Count()-1 ; a+=2) |
|
181 { |
|
182 |
|
183 old_gain = gains[a+1]; |
|
184 new_gain = static_cast<TInt>((gamma10000*old_gain)/10000); |
|
185 old_pitch = gains[a]; |
|
186 |
|
187 new_index = ProcTools::FindNewIndexVQ(new_gain, old_pitch, KAmrGainTable102, 256); |
|
188 if (a == 0) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains740_1, 7); |
|
189 else if (a == 2) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains740_2, 7); |
|
190 else if (a == 4) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains740_3, 7); |
|
191 else if (a == 6) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains740_4, 7); |
|
192 } |
|
193 |
|
194 break; |
|
195 case 5: |
|
196 |
|
197 for (a = 0; a < gains.Count() ; a++) |
|
198 { |
|
199 |
|
200 old_gain = gains[a]; |
|
201 new_gain = static_cast<TInt>((gamma10000*old_gain)/10000); |
|
202 |
|
203 new_index = ProcTools::FindNewIndexSQ(new_gain, KAmrGainTable122, 32); |
|
204 if (a == 0) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains795_1, 5); |
|
205 else if (a == 1) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains795_2, 5); |
|
206 else if (a == 2) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains795_3, 5); |
|
207 else if (a == 3) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains795_4, 5); |
|
208 } |
|
209 |
|
210 break; |
|
211 case 6: |
|
212 |
|
213 |
|
214 for (a = 0; a < gains.Count()-1 ; a+=2) |
|
215 { |
|
216 |
|
217 old_gain = gains[a+1]; |
|
218 new_gain = static_cast<TInt>((gamma10000*old_gain)/10000); |
|
219 old_pitch = gains[a]; |
|
220 |
|
221 new_index = ProcTools::FindNewIndexVQ(new_gain, old_pitch, KAmrGainTable102, 256); |
|
222 if (a == 0) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains102_1, 7); |
|
223 else if (a == 2) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains102_2, 7); |
|
224 else if (a == 4) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains102_3, 7); |
|
225 else if (a == 6) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains102_4, 7); |
|
226 } |
|
227 |
|
228 break; |
|
229 |
|
230 case 7: |
|
231 |
|
232 |
|
233 for (a = 0; a < gains.Count() ; a++) |
|
234 { |
|
235 |
|
236 old_gain = gains[a]; |
|
237 new_gain = static_cast<TInt>((gamma10000*old_gain)/10000); |
|
238 |
|
239 new_index = ProcTools::FindNewIndexSQ(new_gain, KAmrGainTable122, 32); |
|
240 if (a == 0) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains122_1, 5); |
|
241 else if (a == 1) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains122_2, 5); |
|
242 else if (a == 2) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains122_3, 5); |
|
243 else if (a == 3) ProcTools::SetValueToShuffledFrame(tmpFrame, new_index, KAmrGains122_4, 5); |
|
244 } |
|
245 |
|
246 break; |
|
247 case 8: |
|
248 |
|
249 break; |
|
250 case 15: |
|
251 |
|
252 break; |
|
253 default: |
|
254 |
|
255 break; |
|
256 }; |
|
257 |
|
258 |
|
259 gains.Reset(); |
|
260 aFrameOut->Des().Append(tmpFrame->Des()); |
|
261 CleanupStack::PopAndDestroy(tmpFrame); |
|
262 |
|
263 } |
|
264 CleanupStack::Pop(); // aFrameOut |
|
265 |
|
266 return ETrue; |
|
267 } |
|
268 |
|
269 TBool CProcAMRFrameHandler::GetGainL(const HBufC8* aFrame, RArray<TInt>& aGains, TInt& aMaxGain) const |
|
270 { |
|
271 |
|
272 TBool vectorQuant = EFalse; |
|
273 |
|
274 const TUint8 ch = (*aFrame)[0]; |
|
275 |
|
276 TUint dec_mode = (enum Mode)((ch & 0x0078) >> 3); |
|
277 |
|
278 TBool mode475 = EFalse; |
|
279 |
|
280 switch (dec_mode) |
|
281 { |
|
282 case 0: |
|
283 |
|
284 mode475 = ETrue; |
|
285 vectorQuant = ETrue; |
|
286 break; |
|
287 |
|
288 case 1: |
|
289 case 2: |
|
290 case 3: |
|
291 case 4: |
|
292 case 6: |
|
293 vectorQuant = ETrue; |
|
294 break; |
|
295 |
|
296 default: |
|
297 break; |
|
298 }; |
|
299 |
|
300 |
|
301 RArray<TInt> amrGains; |
|
302 RArray<TInt> gpGains; |
|
303 |
|
304 TInt maxGain = 0; |
|
305 |
|
306 TReal b[4] = {0.68, 0.58, 0.34, 0.19}; |
|
307 |
|
308 |
|
309 if (aFrame->Size() < 10) |
|
310 |
|
311 { |
|
312 // SID or no data |
|
313 for (TInt r = 0; r < 4 ; r++) |
|
314 { |
|
315 iPreviousRn[r] = 0; |
|
316 |
|
317 iPreviousEnergy = 0; |
|
318 |
|
319 |
|
320 } |
|
321 |
|
322 aGains.Append(0); |
|
323 aMaxGain = 1; |
|
324 return ETrue; |
|
325 } |
|
326 |
|
327 GetAMRGains(aFrame, amrGains, maxGain); |
|
328 GetGPGains(aFrame, gpGains); |
|
329 |
|
330 TInt gains = 4; |
|
331 if (mode475) |
|
332 { |
|
333 gains = 2; |
|
334 } |
|
335 |
|
336 for (TInt subFrame = 0 ; subFrame < gains ; subFrame++) |
|
337 { |
|
338 |
|
339 // calculate gc (fixed codebook gain) -------------------------> |
|
340 |
|
341 TReal currentGamma = 0; |
|
342 if (vectorQuant) |
|
343 { |
|
344 currentGamma = (TReal)(amrGains[subFrame*2+1])/4096.0; // Q12, 2^12 = 4096 |
|
345 } |
|
346 else |
|
347 { |
|
348 currentGamma = (TReal)(amrGains[subFrame])/4096.0; |
|
349 } |
|
350 |
|
351 TReal E = iPreviousRn[3]*b[0]+iPreviousRn[2]*b[1]+iPreviousRn[1]*b[2]+iPreviousRn[0]*b[3]; |
|
352 |
|
353 TReal logGamma = 0; |
|
354 Math::Log(logGamma, currentGamma); |
|
355 TReal R = 20 * logGamma; |
|
356 |
|
357 TReal gcPred = 0; //g'c |
|
358 Math::Pow10(gcPred, 0.05*E); |
|
359 TReal gc = gcPred*currentGamma; |
|
360 |
|
361 |
|
362 // update previous R(n) values ---------> |
|
363 for (TInt re = 0; re < 3 ; re++) |
|
364 { |
|
365 iPreviousRn[re] = iPreviousRn[re+1]; |
|
366 } |
|
367 iPreviousRn[3] = R; |
|
368 // <---------- update ends |
|
369 |
|
370 // <---------- gc calculated |
|
371 |
|
372 // calculate energy from adaptive codebook -------------> |
|
373 |
|
374 TReal currentGp = 0; |
|
375 |
|
376 if (vectorQuant) |
|
377 { |
|
378 currentGp = (TReal)(amrGains[subFrame*2])/16384.0; // Q14 = 2^14 = 16384 |
|
379 } |
|
380 else |
|
381 { |
|
382 currentGp = (TReal)(gpGains[subFrame])/16384.0; // Q14, 2^13 = 8192 |
|
383 } |
|
384 |
|
385 |
|
386 TReal energyFromAdaptiveCB = (iPreviousEnergy*currentGp)/2; |
|
387 |
|
388 // <----------------------- energy from adaptive codebook calculated |
|
389 |
|
390 TReal totalEnergy = energyFromAdaptiveCB+(gc*45); |
|
391 |
|
392 iPreviousEnergy = totalEnergy; |
|
393 |
|
394 TReal logTotalEnergy = 0; |
|
395 |
|
396 if (totalEnergy < 1) totalEnergy = 1; |
|
397 |
|
398 Math::Log(logTotalEnergy, totalEnergy); |
|
399 |
|
400 if (logTotalEnergy > 3.5) |
|
401 { |
|
402 logTotalEnergy = 3.5; |
|
403 } |
|
404 |
|
405 aGains.Append(logTotalEnergy*100); |
|
406 |
|
407 const TInt KMaxGain = 350; |
|
408 |
|
409 aMaxGain = KMaxGain; |
|
410 |
|
411 |
|
412 } |
|
413 |
|
414 |
|
415 amrGains.Reset(); |
|
416 gpGains.Reset(); |
|
417 return ETrue; |
|
418 } |
|
419 |
|
420 |
|
421 TBool CProcAMRFrameHandler::GetNormalizingMargin(const HBufC8* aFrame, TInt8& aMargin) const |
|
422 |
|
423 { |
|
424 |
|
425 const TUint8 ch = (*aFrame)[0]; |
|
426 |
|
427 TUint dec_mode = (enum Mode)((ch & 0x0078) >> 3); |
|
428 RArray<TInt> gains; |
|
429 |
|
430 TInt error = KErrNone; |
|
431 TRAP(error, CleanupClosePushL(gains) ); |
|
432 |
|
433 if (error != KErrNone) |
|
434 return EFalse; |
|
435 |
|
436 TInt gamma10000 = 1; |
|
437 TInt largestGain = 1; |
|
438 TInt a = 0; |
|
439 TInt maxGain; |
|
440 |
|
441 switch (dec_mode) |
|
442 { |
|
443 case 0: |
|
444 |
|
445 GetAMRGains(aFrame, gains, maxGain); |
|
446 |
|
447 for (a = 1 ; a < gains.Count() ; a+=2) |
|
448 { |
|
449 if (gains[a] > largestGain) |
|
450 { |
|
451 largestGain = gains[a]; |
|
452 } |
|
453 |
|
454 } |
|
455 |
|
456 gamma10000 = (KAmrLargestGain475*10000)/largestGain; |
|
457 |
|
458 break; |
|
459 case 1: |
|
460 case 2: |
|
461 |
|
462 // bitrates 515, 590 |
|
463 GetAMRGains(aFrame, gains, maxGain); |
|
464 |
|
465 for (a = 1 ; a < gains.Count() ; a+=2) |
|
466 { |
|
467 if (gains[a] > largestGain) |
|
468 { |
|
469 largestGain = gains[a]; |
|
470 } |
|
471 |
|
472 } |
|
473 gamma10000 = (KAmrLargestGain590*10000)/largestGain; |
|
474 |
|
475 |
|
476 break; |
|
477 case 3: |
|
478 case 4: |
|
479 case 6: |
|
480 // bitRate = 670, 740, 1020; |
|
481 GetAMRGains(aFrame, gains, maxGain); |
|
482 |
|
483 for (a = 1 ; a < gains.Count() ; a+=2) |
|
484 { |
|
485 if (gains[a] > largestGain) |
|
486 { |
|
487 largestGain = gains[a]; |
|
488 } |
|
489 |
|
490 } |
|
491 gamma10000 = (KAmrLargestGain102*10000)/largestGain; |
|
492 |
|
493 break; |
|
494 case 5: |
|
495 case 7: |
|
496 //bitRate = 795 & 12.2 |
|
497 GetAMRGains(aFrame, gains, maxGain); |
|
498 |
|
499 |
|
500 for (a = 0 ; a < gains.Count() ; a++) |
|
501 { |
|
502 if (gains[a] > largestGain) |
|
503 { |
|
504 largestGain = gains[a]; |
|
505 } |
|
506 |
|
507 } |
|
508 gamma10000 = (KAmrLargestGain122*10000)/largestGain; |
|
509 |
|
510 |
|
511 break; |
|
512 |
|
513 case 8: |
|
514 |
|
515 case 15: |
|
516 |
|
517 default: |
|
518 aMargin = 100; |
|
519 return ETrue; |
|
520 |
|
521 }; |
|
522 |
|
523 |
|
524 CleanupStack::PopAndDestroy(&gains); |
|
525 |
|
526 TUint8 newIndex = ProcTools::FindNewIndexSQ(gamma10000, KAmrGain_dB2Gamma, 256); |
|
527 |
|
528 TInt8 newGain = static_cast<TInt8>(newIndex-127); |
|
529 |
|
530 |
|
531 if (newGain > 63) |
|
532 { |
|
533 newGain = 63; |
|
534 } |
|
535 else if (newGain < -63) |
|
536 { |
|
537 newGain = -63; |
|
538 } |
|
539 |
|
540 aMargin = static_cast<TInt8>(newGain*2); |
|
541 // aMargin is now in dB/2:s |
|
542 return ETrue; |
|
543 |
|
544 |
|
545 } |
|
546 |
|
547 CProcAMRFrameHandler::~CProcAMRFrameHandler() |
|
548 { |
|
549 |
|
550 } |
|
551 |
|
552 CProcAMRFrameHandler* CProcAMRFrameHandler::NewL() |
|
553 { |
|
554 |
|
555 |
|
556 CProcAMRFrameHandler* self = NewLC(); |
|
557 CleanupStack::Pop(self); |
|
558 return self; |
|
559 |
|
560 } |
|
561 CProcAMRFrameHandler* CProcAMRFrameHandler::NewLC() |
|
562 { |
|
563 |
|
564 CProcAMRFrameHandler* self = new (ELeave) CProcAMRFrameHandler(); |
|
565 CleanupStack::PushL(self); |
|
566 self->ConstructL(); |
|
567 return self; |
|
568 |
|
569 } |
|
570 |
|
571 void CProcAMRFrameHandler::ConstructL() |
|
572 { |
|
573 |
|
574 |
|
575 } |
|
576 |
|
577 CProcAMRFrameHandler::CProcAMRFrameHandler() |
|
578 { |
|
579 |
|
580 } |
|
581 |
|
582 TBool CProcAMRFrameHandler::GetAMRGains(const HBufC8* aFrame, |
|
583 RArray<TInt>& aGains, |
|
584 TInt& aMaxGain) const |
|
585 |
|
586 { |
|
587 |
|
588 |
|
589 const TUint8 ch = (*aFrame)[0]; |
|
590 |
|
591 TUint dec_mode = (enum Mode)((ch & 0x0078) >> 3); |
|
592 TInt gainIndex = 0; |
|
593 |
|
594 |
|
595 switch (dec_mode) |
|
596 { |
|
597 case 0: |
|
598 // bitRate = 475; |
|
599 |
|
600 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains475_1_2, 8); |
|
601 aGains.Append(KAmrGainTable475[gainIndex*4]); |
|
602 aGains.Append(KAmrGainTable475[gainIndex*4+1]); |
|
603 aGains.Append(KAmrGainTable475[gainIndex*4+2]); |
|
604 aGains.Append(KAmrGainTable475[gainIndex*4+3]); |
|
605 |
|
606 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains475_3_4, 8); |
|
607 aGains.Append(KAmrGainTable475[gainIndex*4]); |
|
608 aGains.Append(KAmrGainTable475[gainIndex*4+1]); |
|
609 aGains.Append(KAmrGainTable475[gainIndex*4+2]); |
|
610 aGains.Append(KAmrGainTable475[gainIndex*4+3]); |
|
611 |
|
612 break; |
|
613 case 1: |
|
614 // bitRate = 515; |
|
615 |
|
616 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains515_1, 6); |
|
617 aGains.Append(KAmrGainTable590[gainIndex*2]); |
|
618 aGains.Append(KAmrGainTable590[gainIndex*2+1]); |
|
619 |
|
620 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains515_2, 6); |
|
621 aGains.Append(KAmrGainTable590[gainIndex*2]); |
|
622 aGains.Append(KAmrGainTable590[gainIndex*2+1]); |
|
623 |
|
624 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains515_3, 6); |
|
625 aGains.Append(KAmrGainTable590[gainIndex*2]); |
|
626 aGains.Append(KAmrGainTable590[gainIndex*2+1]); |
|
627 |
|
628 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains515_4, 6); |
|
629 aGains.Append(KAmrGainTable590[gainIndex*2]); |
|
630 aGains.Append(KAmrGainTable590[gainIndex*2+1]); |
|
631 break; |
|
632 case 2: |
|
633 // bitRate = 590; |
|
634 |
|
635 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains590_1, 6); |
|
636 aGains.Append(KAmrGainTable590[gainIndex*2]); |
|
637 aGains.Append(KAmrGainTable590[gainIndex*2+1]); |
|
638 |
|
639 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains590_2, 6); |
|
640 aGains.Append(KAmrGainTable590[gainIndex*2]); |
|
641 aGains.Append(KAmrGainTable590[gainIndex*2+1]); |
|
642 |
|
643 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains590_3, 6); |
|
644 aGains.Append(KAmrGainTable590[gainIndex*2]); |
|
645 aGains.Append(KAmrGainTable590[gainIndex*2+1]); |
|
646 |
|
647 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains590_4, 6); |
|
648 aGains.Append(KAmrGainTable590[gainIndex*2]); |
|
649 aGains.Append(KAmrGainTable590[gainIndex*2+1]); |
|
650 |
|
651 break; |
|
652 case 3: |
|
653 // bitRate = 670; |
|
654 |
|
655 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains670_1, 7); |
|
656 aGains.Append(KAmrGainTable102[gainIndex*2]); |
|
657 aGains.Append(KAmrGainTable102[gainIndex*2+1]); |
|
658 |
|
659 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains670_2, 7); |
|
660 aGains.Append(KAmrGainTable102[gainIndex*2]); |
|
661 aGains.Append(KAmrGainTable102[gainIndex*2+1]); |
|
662 |
|
663 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains670_3, 7); |
|
664 aGains.Append(KAmrGainTable102[gainIndex*2]); |
|
665 aGains.Append(KAmrGainTable102[gainIndex*2+1]); |
|
666 |
|
667 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains670_4, 7); |
|
668 aGains.Append(KAmrGainTable102[gainIndex*2]); |
|
669 aGains.Append(KAmrGainTable102[gainIndex*2+1]); |
|
670 |
|
671 break; |
|
672 case 4: |
|
673 // bitRate = 740; |
|
674 |
|
675 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains740_1, 7); |
|
676 aGains.Append(KAmrGainTable102[gainIndex*2]); |
|
677 aGains.Append(KAmrGainTable102[gainIndex*2+1]); |
|
678 |
|
679 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains740_2, 7); |
|
680 aGains.Append(KAmrGainTable102[gainIndex*2]); |
|
681 aGains.Append(KAmrGainTable102[gainIndex*2+1]); |
|
682 |
|
683 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains740_3, 7); |
|
684 aGains.Append(KAmrGainTable102[gainIndex*2]); |
|
685 aGains.Append(KAmrGainTable102[gainIndex*2+1]); |
|
686 |
|
687 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains740_4, 7); |
|
688 aGains.Append(KAmrGainTable102[gainIndex*2]); |
|
689 aGains.Append(KAmrGainTable102[gainIndex*2+1]); |
|
690 |
|
691 break; |
|
692 case 5: |
|
693 // bitRate = 795; |
|
694 |
|
695 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains795_1, 5); |
|
696 aGains.Append(KAmrGainTable122[gainIndex]); |
|
697 |
|
698 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains795_2, 5); |
|
699 aGains.Append(KAmrGainTable122[gainIndex]); |
|
700 |
|
701 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains795_3, 5); |
|
702 aGains.Append(KAmrGainTable122[gainIndex]); |
|
703 |
|
704 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains795_4, 5); |
|
705 aGains.Append(KAmrGainTable122[gainIndex]); |
|
706 |
|
707 break; |
|
708 case 6: |
|
709 // bitRate = 1020; |
|
710 |
|
711 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains102_1, 7); |
|
712 aGains.Append(KAmrGainTable102[gainIndex*2]); |
|
713 aGains.Append(KAmrGainTable102[gainIndex*2+1]); |
|
714 |
|
715 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains102_2, 7); |
|
716 aGains.Append(KAmrGainTable102[gainIndex*2]); |
|
717 aGains.Append(KAmrGainTable102[gainIndex*2+1]); |
|
718 |
|
719 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains102_3, 7); |
|
720 aGains.Append(KAmrGainTable102[gainIndex*2]); |
|
721 aGains.Append(KAmrGainTable102[gainIndex*2+1]); |
|
722 |
|
723 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains102_4, 7); |
|
724 aGains.Append(KAmrGainTable102[gainIndex*2]); |
|
725 aGains.Append(KAmrGainTable102[gainIndex*2+1]); |
|
726 |
|
727 break; |
|
728 case 7: |
|
729 // bitRate = 1220; |
|
730 |
|
731 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains122_1, 5); |
|
732 aGains.Append(KAmrGainTable122[gainIndex]); |
|
733 |
|
734 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains122_2, 5); |
|
735 aGains.Append(KAmrGainTable122[gainIndex]); |
|
736 |
|
737 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains122_3, 5); |
|
738 aGains.Append(KAmrGainTable122[gainIndex]); |
|
739 |
|
740 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGains122_4, 5); |
|
741 aGains.Append(KAmrGainTable122[gainIndex]); |
|
742 |
|
743 |
|
744 break; |
|
745 case 8: |
|
746 // bitRate = 0; |
|
747 break; |
|
748 case 15: |
|
749 // bitRate = 0; |
|
750 break; |
|
751 default: |
|
752 // bitRate = 0; |
|
753 break; |
|
754 }; |
|
755 |
|
756 |
|
757 aMaxGain = KAmrLargestGain102; |
|
758 |
|
759 return ETrue; |
|
760 |
|
761 |
|
762 } |
|
763 |
|
764 TInt CProcAMRFrameHandler::GetNextFrameLength(const HBufC8* aFrame, TInt aPosNow) |
|
765 { |
|
766 |
|
767 |
|
768 if (aPosNow >= aFrame->Size()) return -1; |
|
769 |
|
770 |
|
771 const TUint8 ch = (*aFrame)[aPosNow]; |
|
772 |
|
773 TUint dec_mode = (enum Mode)((ch & 0x0078) >> 3); |
|
774 |
|
775 switch (dec_mode) |
|
776 { |
|
777 case 0: |
|
778 { |
|
779 return 12+1; |
|
780 } |
|
781 |
|
782 case 1: |
|
783 { |
|
784 return 13+1; |
|
785 } |
|
786 |
|
787 case 2: |
|
788 { |
|
789 return 15+1; |
|
790 } |
|
791 |
|
792 case 3: |
|
793 { |
|
794 return 17+1; |
|
795 } |
|
796 |
|
797 case 4: |
|
798 { |
|
799 return 19+1; |
|
800 } |
|
801 |
|
802 case 5: |
|
803 { |
|
804 return 20+1; |
|
805 } |
|
806 |
|
807 case 6: |
|
808 { |
|
809 return 26+1; |
|
810 } |
|
811 |
|
812 case 7: |
|
813 { |
|
814 return 31+1; |
|
815 } |
|
816 |
|
817 case 8: |
|
818 { |
|
819 return 5+1; |
|
820 } |
|
821 |
|
822 case 15: |
|
823 { |
|
824 return 0; |
|
825 } |
|
826 |
|
827 default: |
|
828 return 0+1; |
|
829 |
|
830 }; |
|
831 |
|
832 |
|
833 } |
|
834 |
|
835 |
|
836 TBool CProcAMRFrameHandler::GetGPGains(const HBufC8* aFrame, |
|
837 RArray<TInt>& aGains) const |
|
838 |
|
839 { |
|
840 |
|
841 |
|
842 const TUint8 ch = (*aFrame)[0]; |
|
843 |
|
844 TUint dec_mode = (enum Mode)((ch & 0x0078) >> 3); |
|
845 TInt gainIndex = 0; |
|
846 |
|
847 |
|
848 switch (dec_mode) |
|
849 { |
|
850 |
|
851 case 7: |
|
852 // bitRate = 1220; |
|
853 |
|
854 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGPGains122_1, 4); |
|
855 aGains.Append(KAmrGPTable[gainIndex]); |
|
856 |
|
857 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGPGains122_2, 4); |
|
858 aGains.Append(KAmrGPTable[gainIndex]); |
|
859 |
|
860 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGPGains122_3, 4); |
|
861 aGains.Append(KAmrGPTable[gainIndex]); |
|
862 |
|
863 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGPGains122_4, 4); |
|
864 aGains.Append(KAmrGPTable[gainIndex]); |
|
865 |
|
866 |
|
867 break; |
|
868 |
|
869 case 5: |
|
870 // 7.95 |
|
871 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGPGains795_1, 4); |
|
872 aGains.Append(KAmrGPTable[gainIndex]); |
|
873 |
|
874 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGPGains795_2, 4); |
|
875 aGains.Append(KAmrGPTable[gainIndex]); |
|
876 |
|
877 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGPGains795_3, 4); |
|
878 aGains.Append(KAmrGPTable[gainIndex]); |
|
879 |
|
880 gainIndex = ProcTools::GetValueFromShuffledFrame(aFrame, KAmrGPGains795_4, 4); |
|
881 aGains.Append(KAmrGPTable[gainIndex]); |
|
882 break; |
|
883 |
|
884 |
|
885 |
|
886 default: |
|
887 // return EFalse; |
|
888 break; |
|
889 }; |
|
890 |
|
891 |
|
892 return ETrue; |
|
893 |
|
894 |
|
895 } |