frameworks/base/media/libstagefright/codecs/aacdec/long_term_prediction.cpp

   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 ----------------------------------------------------------------------------*/
 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