1 /* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
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
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18 /*
19
20 Pathname: long_term_prediction.c
21
22 ------------------------------------------------------------------------------
23 REVISION HISTORY
24
25 Description: Made changes based on comments and experiment results.
26
27 Description: Passed in buffer sizes based on review comments and prototype
28 agreements.
29
30 Description: 1. Passed in "weight_index" instead of "weight".
31 2. Added weight table.
32
33 Description: 1. Removed some passed in buffer size variables since they are
34 not used for long window.
35 2. Modified comments format.
36
37 Description:
38 Modified casting to ensure proper operations for different platforms
39
40 Description:
41 Implemented circular buffer techniques, which save 4096 memmoves per
42 frame.
43
44 Description:
45 Implemented some optimizations found during the code review of this
46 module. The optimizations related to the rules on the range of
47 ltp_buffer_index and num_samples, which allows for a simpler
48 code construct to be used in the processing of the predicted samples.
49
50 Description:
51 Add max calculation on the filter implementation, this to eliminate
52 function buffer_adaptation() on the time to frequency transformation.
53 Function interface changed. It now return the amount of shifting needed
54 to garb only the top 16 MSB.
55
56 Description:
57 Replace clearing memory with for-loop with pvmemset function
58
59 Description:
60
61 ------------------------------------------------------------------------------
62 INPUT AND OUTPUT DEFINITIONS
63
64 Inputs:
65 win_seq = type of window sequence (WINDOW_SEQUENCE).
66
67 weight_index = index (Int) of LTP coefficient table for all windows in
68 current frame.
69
70 delay = buffer (Int) containing delays for each window.
71
72 buffer = history buffer (Int16) containing the reconstructed time domain
73 signals of previous frames.
74
75 buffer_offset = value (Int) that indicates the location of the first
76 element in the LTP circular buffer. (Either 0 or 1024)
77
78 time_quant = filterbank buffer (Int32) This buffer is used by the
79 filterbank, but it's first 1024 elements are equivalent
80 to the last 1024 elements in the conventionally
81 implemented LTP buffer. Using this buffer directly avoids
82 costly duplication of memory.
83
84 predicted_samples = buffer (Int32) with length of 2048 to hold
85 predicted time domain signals.
86
87 buffer_index = index into buffer where the first sample of data from
88 the frame (t-2) (two frames ago) resides. (Int)
89
90 frame_length = length of one frame, type of Int.
91
92 Local Stores/Buffers/Pointers Needed:
93 None
94
95 Global Stores/Buffers/Pointers Needed:
96 None
97
98 Outputs:
99 Amount of shifting needed to grab the top 16 MSB from teh predicted buffer
100
101 Pointers and Buffers Modified:
102 predicted_samples contents are the newly calculated predicted time
103 domain signals
104
105 Local Stores Modified:
106 None
107
108 Global Stores Modified:
109 None
110
111 ------------------------------------------------------------------------------
112 FUNCTION DESCRIPTION
113
114 Long term prediction (LTP) is used to reduce the redundancy of a signal
115 between successive coding frames. This function performs prediction by
116 applying 1-tap IIR filtering to calculate the predicted time domain
117 signals of current frame from previous reconstructed frames stored in
118 time domain history buffer.
119
120 The equation used for IIR filter is as following.
121
122 y(n) = weight * x(n - delay)
123
124 where y(n) ----- predicted time domain signals
125 x(n) ----- reconstructed time domain signals
126 weight ----- LTP coefficient
127 delay ----- optimal delay from 0 to 2047
128
129 ------------------------------------------------------------------------------
130 REQUIREMENTS
131
132 None
133
134 ------------------------------------------------------------------------------
135 REFERENCES
136
137 (1) ISO/IEC 14496-3:1999(E)
138 Part 3: Audio
139 Subpart 4.6.6 Long Term Prediction (LTP)
140
141 (2) MPEG-2 NBC Audio Decoder
142 "This software module was originally developed by Nokia in the course
143 of development of the MPEG-2 AAC/MPEG-4 Audio standard ISO/IEC13818-7,
144 14496-1, 2 and 3. This software module is an implementation of a part
145 of one or more MPEG-2 AAC/MPEG-4 Audio tools as specified by the MPEG-2
146 aac/MPEG-4 Audio standard. ISO/IEC gives users of the MPEG-2aac/MPEG-4
147 Audio standards free license to this software module or modifications
148 thereof for use in hardware or software products claiming conformance
149 to the MPEG-2 aac/MPEG-4 Audio standards. Those intending to use this
150 software module in hardware or software products are advised that this
151 use may infringe existing patents. The original developer of this
152 software module, the subsequent editors and their companies, and ISO/IEC
153 have no liability for use of this software module or modifications
154 thereof in an implementation. Copyright is not released for non MPEG-2
155 aac/MPEG-4 Audio conforming products. The original developer retains
156 full right to use the code for the developer's own purpose, assign or
157 donate the code to a third party and to inhibit third party from using
158 the code for non MPEG-2 aac/MPEG-4 Audio conforming products. This
159 copyright notice must be included in all copies or derivative works.
160 Copyright (c)1997.
161
162 ------------------------------------------------------------------------------
163 PSEUDO-CODE
164
165 pPredicted_samples = &predicted_samples[0];
166
167 weight = codebook[weight_index];
168
169 IF (win_seq != EIGHT_SHORT_SEQUENCE)
170 THEN
171
172 block_length = frame_length << 1;
173
174 lag = delay[0];
175
176 j = block_length - lag;
177
178 IF (lag < frame_length)
179 THEN
180
181 num_samples = frame_length + lag;
182
183 ELSE
184
185 num_samples = block_length;
186
187 ENDIF
188
189 pBuffer = &buffer[j];
190
191 FOR (i = num_samples; i>0; i--)
192
193 *pPredicted_samples = weight * (*pBuffer);
194 pPredicted_samples = pPredicted_samples + 1;
195 pBuffer = pBuffer + 1;
196
197 ENDFOR
198
199 FOR (i = block_length - num_samples; i>0; i--)
200
201 *pPredicted_samples = 0;
202 pPredicted_samples = pPredicted_samples + 1;
203
204 ENDFOR
205
206 ELSE
207
208 FOR (wnd = 0; wnd < short_window_num; wnd++)
209
210 IF (win_prediction_used[wnd] != FALSE)
211 THEN
212
213 delay[wnd] = delay[0] + ltp_short_lag[wnd];
214
215 lag = delay[wnd];
216
217 j = wnd*short_block_length - lag;
218
219 IF (lag < short_frame_length)
220 THEN
221
222 num_samples = short_frame_length + lag;
223
224 ELSE
225
226 num_samples = short_block_length;
227
228 ENDIF
229
230 pBuffer = &buffer[j];
231
232 FOR (i = num_samples; i>0; i--)
233
234 *pPredicted_samples = weight * (*pBuffer);
235 pPredicted_samples = pPredicted_samples + 1;
236 pBuffer = pBuffer + 1;
237
238 ENDFOR
239
240 FOR (i = short_block_length - num_samples; i>0; i--)
241
242 *pPredicted_samples = 0;
243 pPredicted_samples = pPredicted_samples + 1;
244
245 ENDFOR
246
247 ELSE
248
249 CALL pv_memset(
250 pPredicted_samples,
251 0,
252 sizeof(*pPredicted_samples)*short_block_length);
253 MODIFYING (predicted_samples[]);
254
255 pPredicted_samples = pPredicted_samples + short_block_length;
256
257 ENDIF [ IF (win_prediction_used[wnd] != FALSE) ]
258
259 ENDFOR [ FOR (wnd=0; wnd<short_window_num; wnd++) ]
260
261 ENDIF [ IF (win_seq != EIGHT_SHORT_SEQUENCE) ]
262
263 RETURN
264
265 ------------------------------------------------------------------------------
266 RESOURCES USED
267 When the code is written for a specific target processor the
268 the resources used should be documented below.
269
270 STACK USAGE: [stack count for this module] + [variable to represent
271 stack usage for each subroutine called]
272
273 where: [stack usage variable] = stack usage for [subroutine
274 name] (see [filename].ext)
275
276 DATA MEMORY USED: x words
277
278 PROGRAM MEMORY USED: x words
279
280 CLOCK CYCLES: [cycle count equation for this module] + [variable
281 used to represent cycle count for each subroutine
282 called]
283
284 where: [cycle count variable] = cycle count for [subroutine
285 name] (see [filename].ext)
286
287 ------------------------------------------------------------------------------
288 */
289
290
291 /*----------------------------------------------------------------------------
292 ; INCLUDES
293 ----------------------------------------------------------------------------*/
294 #include "pv_audio_type_defs.h"
295 #include "e_window_sequence.h"
296 #include "ltp_common_internal.h"
297 #include "long_term_prediction.h"
298 #include "aac_mem_funcs.h"
299 #include "pv_normalize.h"
300 #include "window_block_fxp.h"
301
302
303 /*----------------------------------------------------------------------------
304 ; MACROS
305 ; Define module specific macros here
306 ----------------------------------------------------------------------------*/
307
308 /*----------------------------------------------------------------------------
309 ; DEFINES
310 ; Include all pre-processor statements here. Include conditional
311 ; compile variables also.
312 ----------------------------------------------------------------------------*/
313
314 /*----------------------------------------------------------------------------
315 ; LOCAL FUNCTION DEFINITIONS
316 ; Function Prototype declaration
317 ----------------------------------------------------------------------------*/
318
319 /*----------------------------------------------------------------------------
320 ; LOCAL STORE/BUFFER/POINTER DEFINITIONS
321 ; Variable declaration - defined here and used outside this module
322 ----------------------------------------------------------------------------*/
323 /* Purpose: Codebook for LTP weight coefficients. Stored in Q15 format */
324 const UInt codebook[CODESIZE] =
325 {
326 18705, /* 0 */
327 22827, /* 1 */
328 26641, /* 2 */
329 29862, /* 3 */
330 32273, /* 4 */
331 34993, /* 5 */
332 39145, /* 6 */
333 44877 /* 7 */
334 };
335
336 /*----------------------------------------------------------------------------
337 ; EXTERNAL FUNCTION REFERENCES
338 ; Declare functions defined elsewhere and referenced in this module
339 ----------------------------------------------------------------------------*/
340
341 /*----------------------------------------------------------------------------
342 ; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
343 ; Declare variables used in this module but defined elsewhere
344 ----------------------------------------------------------------------------*/
345
346 /*----------------------------------------------------------------------------
347 ; FUNCTION CODE
348 ----------------------------------------------------------------------------*/
long_term_prediction(WINDOW_SEQUENCE win_seq,const Int weight_index,const Int delay[],const Int16 buffer[],const Int buffer_offset,const Int32 time_quant[],Int32 predicted_samples[],const Int frame_length)349 Int long_term_prediction(
350 WINDOW_SEQUENCE win_seq,
351 const Int weight_index,
352 const Int delay[],
353 const Int16 buffer[],
354 const Int buffer_offset,
355 const Int32 time_quant[],
356 Int32 predicted_samples[], /* Q15 */
357 const Int frame_length)
358 {
359 /*----------------------------------------------------------------------------
360 ; Define all local variables
361 ----------------------------------------------------------------------------*/
362 /*
363 * Window index
364 *
365 * Int wnd;
366 *
367 * will be enabled when short window information is available.
368 */
369
370 /* Pointer to time domain history buffer */
371
372 const Int16 *pBuffer;
373
374 const Int32 *pTimeQuant = time_quant;
375
376 /* Pointer to array containing predicted samples */
377 Int32 *pPredicted_samples;
378
379 Int32 test;
380 Int32 datum;
381
382 /* IIR coefficient with Q15 format */
383 UInt weight;
384
385 /* Length of one block (two frames) */
386 Int block_length;
387
388 Int shift;
389 Int k;
390 Int ltp_buffer_index;
391 Int jump_point;
392 Int lag;
393 Int num_samples;
394
395 Int32 max = 0;
396
397 /*----------------------------------------------------------------------------
398 ; Function body here
399 ----------------------------------------------------------------------------*/
400 /* Initialize pointers */
401 pPredicted_samples = &predicted_samples[0];
402
403 weight = codebook[weight_index];
404
405 /****************************************/
406 /* LTP decoding process for long window */
407 /****************************************/
408
409 if (win_seq != EIGHT_SHORT_SEQUENCE)
410 {
411 /****************************************************/
412 /* Prediction based on previous time domain signals */
413 /****************************************************/
414 block_length = frame_length << 1;
415
416 /* Calculate time lag for 1-tap IIR filter */
417 lag = delay[0];
418
419 ltp_buffer_index = block_length - lag;
420
421 /* Calculate number of samples used in IIR filter */
422 if (lag < frame_length)
423 {
424 num_samples = frame_length + lag;
425 }
426 else
427 {
428 num_samples = block_length;
429 }
430
431
432 /*
433 * Calculate the predicted time domain signals from the
434 * reconstructed time domain signals of previous frames.
435 */
436
437 /* The data is stored in TWO buffers, either as...
438 *
439 * [ t == 0 ]
440 *
441 * [ t == -1 ][ t == -2 ]
442 *
443 * OR...
444 * [ t == 0 ]
445 *
446 * [ t == -2 ][ t == -1 ]
447 *
448 *
449 *
450 * In the first case, all of the buffers are non-contiguous,
451 * and each must be handled separately. Code for this first case
452 * will function correctly for both cases.
453 *
454 * In the second case, the buffers storing t == -2, and t == -1
455 * data are contiguous, and an optimization could take advantage
456 * of this, at the cost of an increase in code size for this function.
457 */
458
459 /* Decrement block_length by num_samples. This is important
460 * for the loop at the end of the "ACCESS DATA IN THE LTP BUFFERS"
461 * section that sets all remaining samples in the block to zero.
462 */
463
464 block_length -= num_samples;
465
466
467
468
469
470
471 /*
472 ************************************ ACCESS DATA IN THE LTP BUFFERS
473 */
474
475 /*
476 * This section of the code handles the t == -2
477 * buffer, which corresponds to 0 <= ltp_buffer_index < 1024
478 *
479 * BUFFER t == -2
480 *
481 * [0][][][][][][][][][][][...][][][][][][][][][][][][1023]
482 *
483 */
484
485 jump_point = (frame_length - ltp_buffer_index);
486
487 if (jump_point > 0)
488 {
489 pBuffer = &(buffer[ltp_buffer_index + buffer_offset]);
490
491 for (k = jump_point; k > 0; k--)
492 {
493 /* Q15 = Q15 * Q0 */
494 test = (Int32) weight * (*(pBuffer++));
495 *(pPredicted_samples++) = test;
496 max |= (test >> 31) ^ test;
497 }
498
499 num_samples -= jump_point;
500
501 ltp_buffer_index += jump_point;
502 }
503
504 /*
505 * This section of the code handles the t == -1
506 * buffer, which corresponds to 1024 <= ltp_buffer_index < 2048
507 *
508 * BUFFER t == -1
509 *
510 * [1024][][][][][][][][][][][...][][][][][][][][][][][][2047]
511 *
512 */
513
514 jump_point = 2 * frame_length - ltp_buffer_index;
515
516 pBuffer = &(buffer[ltp_buffer_index - buffer_offset]);
517
518 if (num_samples < jump_point)
519 {
520 jump_point = num_samples;
521 }
522
523 for (k = jump_point; k > 0; k--)
524 {
525 /* Q15 = Q15 * Q0 */
526 test = (Int32) weight * (*(pBuffer++));
527 *(pPredicted_samples++) = test;
528 max |= (test >> 31) ^ test;
529 }
530
531 num_samples -= jump_point;
532
533 ltp_buffer_index += jump_point;
534
535 /*
536 * This section of the code handles the t == 0
537 * buffer, which corresponds to 2048 <= ltp_buffer_index < 3072
538 *
539 * BUFFER t == 0
540 *
541 * [2048][][][][][][][][][][][...][][][][][][][][][][][][3071]
542 *
543 */
544 for (k = num_samples; k > 0; k--)
545 {
546
547 datum = *(pTimeQuant++) >> SCALING;
548
549 /*
550 * Limit the values in the 32-bit filterbank's buffer to
551 * 16-bit resolution.
552 *
553 * Value's greater than 32767 or less than -32768 are saturated
554 * to 32767 and -32768, respectively.
555 */
556
557 test = (Int32)datum * weight;
558 *(pPredicted_samples++) = test;
559 max |= (test >> 31) ^ test;
560
561 }
562
563 /* Set any remaining samples in the block to 0. */
564
565 pv_memset(
566 pPredicted_samples,
567 0,
568 block_length*sizeof(*pPredicted_samples));
569
570 } /* if (win_seq != EIGHT_SHORT_SEQUENCE) */
571
572
573 /*****************************************/
574 /* LTP decoding process for short window */
575 /*****************************************/
576
577 /*
578 * For short window LTP, since there is no "ltp_short_lag"
579 * information being passed, the following code for short
580 * window LTP will be applied in the future when those
581 * information are available.
582 */
583
584 /*
585 *----------------------------------------------------------------------------
586 * else
587 * {
588 * for (wnd = 0; wnd < short_window_num; wnd++)
589 * {
590 * if (win_prediction_used[wnd] != FALSE)
591 * {
592 * delay[wnd] = delay[0] + ltp_short_lag[wnd];
593 *
594 * lag = delay[wnd];
595 *
596 * j = wnd*short_block_length - lag;
597 *
598 * if (lag < short_frame_length)
599 * {
600 * num_samples = short_frame_length + lag;
601 * }
602 * else
603 * {
604 * num_samples = short_block_length;
605 * }
606 *
607 * pBuffer = &buffer[j];
608 *
609 * for(i = num_samples; i>0; i--)
610 * {
611 * *(pPredicted_samples++) = weight * (*(pBuffer++));
612 * }
613 *
614 * for(i = short_block_length - num_samples; i>0; i--)
615 * {
616 * *(pPredicted_samples++) = 0;
617 * }
618 * }
619 * else
620 * {
621 * pv_memset(
622 * pPredicted_samples,
623 * 0,
624 * sizeof(*pPredicted_samples)*short_block_length);
625 *
626 * pPredicted_samples += short_block_length;
627 * }
628 * }
629 * }
630 *----------------------------------------------------------------------------
631 */
632
633 shift = 16 - pv_normalize(max);
634
635 if (shift < 0)
636 {
637 shift = 0;
638 }
639
640 /*----------------------------------------------------------------------------
641 ; Return nothing or data or data pointer
642 ----------------------------------------------------------------------------*/
643 return (shift);
644 } /* long_term_prediction */
645
646
647
648
649