opencore/codecs_v2/audio/gsm_amr/amr_nb/enc/src/s10_8pf.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 Portions of this file are derived from the following 3GPP standard:
  20
  21     3GPP TS 26.073
  22     ANSI-C code for the Adaptive Multi-Rate (AMR) speech codec
  23     Available from http://www.3gpp.org
  24
  25 (C) 2004, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC)
  26 Permission to distribute, modify and use this file under the standard license
  27 terms listed above has been obtained from the copyright holder.
  28 ****************************************************************************************/
  29 /*
  30 ------------------------------------------------------------------------------
  31
  32
  33
  34  Filename: s10_8pf.cpp
  35  Funtions: search_10and8i40
  36
  37 ------------------------------------------------------------------------------
  38 */
  39
  40 /*----------------------------------------------------------------------------
  41 ; INCLUDES
  42 ----------------------------------------------------------------------------*/
  43 #include "s10_8pf.h"
  44 #include "cnst.h"
  45 #include "oscl_mem.h"
  46
  47 /*----------------------------------------------------------------------------
  48 ; MACROS
  49 ; Define module specific macros here
  50 ----------------------------------------------------------------------------*/
  51
  52 /*----------------------------------------------------------------------------
  53 ; DEFINES
  54 ; Include all pre-processor statements here. Include conditional
  55 ; compile variables also.
  56 ----------------------------------------------------------------------------*/
  57
  58 /*----------------------------------------------------------------------------
  59 ; LOCAL FUNCTION DEFINITIONS
  60 ; Function Prototype declaration
  61 ----------------------------------------------------------------------------*/
  62
  63 /*----------------------------------------------------------------------------
  64 ; LOCAL VARIABLE DEFINITIONS
  65 ; Variable declaration - defined here and used outside this module
  66 ----------------------------------------------------------------------------*/
  67
  68 /*
  69 ------------------------------------------------------------------------------
  70  FUNCTION NAME: search_10and8i40
  71 ------------------------------------------------------------------------------
  72  INPUT AND OUTPUT DEFINITIONS
  73
  74  Inputs:
  75     nbPulse = nbPulses to find (Word16)
  76     step = step size (Word16)
  77     nbTracks = nbTracks (Word16)
  78     dn[] = correlation between target and h[] (Word16)
  79     rr[][] = matrix of autocorrelation (Word16)
  80     ipos[] = starting position of each pulse (Word16)
  81     pos_max[] = Position of maximum dn[] (Word16)
  82     codvec[] = Algebraic codebook vector (Word16)
  83     pOverflow = pointer to Overflow flag (Flag)
  84
  85  Outputs:
  86     codvec[] = Algebraic codebook vector (Word16)
  87     pOverflow -> 1 if processing this funvction results in satuaration
  88
  89  Returns:
  90     None
  91
  92  Global Variables Used:
  93     None
  94
  95  Local Variables Needed:
  96     None
  97
  98 ------------------------------------------------------------------------------
  99  FUNCTION DESCRIPTION
 100
 101  This function searches for the best codevector; It determines the positions
 102  of the 10/8 pulses in the 40-sample frame.
 103
 104     search_10and8i40 (10,5,5,dn, rr, ipos, pos_max, codvec);   for GSMEFR
 105     search_10and8i40 (8, 4,4,dn, rr, ipos, pos_max, codvec);   for 10.2
 106
 107
 108 ------------------------------------------------------------------------------
 109  REQUIREMENTS
 110
 111  None
 112
 113 ------------------------------------------------------------------------------
 114  REFERENCES
 115
 116  s10_8pf.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
 117
 118 ------------------------------------------------------------------------------
 119  PSEUDO-CODE
 120
 121 void search_10and8i40 (
 122     Word16 nbPulse,      // i : nbpulses to find
 123     Word16 step,         // i :  stepsize
 124     Word16 nbTracks,     // i :  nbTracks
 125     Word16 dn[],         // i : correlation between target and h[]
 126     Word16 rr[][L_CODE], // i : matrix of autocorrelation
 127     Word16 ipos[],       // i : starting position for each pulse
 128     Word16 pos_max[],    // i : position of maximum of dn[]
 129     Word16 codvec[]      // o : algebraic codebook vector
 130 )
 131 {
 132    Word16 i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
 133    Word16 i, j, k, pos, ia, ib;
 134    Word16 psk, ps, ps0, ps1, ps2, sq, sq2;
 135    Word16 alpk, alp, alp_16;
 136    Word16 rrv[L_CODE];
 137    Word32 s, alp0, alp1, alp2;
 138    Word16 gsmefrFlag;
 139
 140
 141    if (sub(nbPulse, 10) == 0)
 142    {
 143       gsmefrFlag=1;
 144    }
 145    else
 146    {
 147       gsmefrFlag=0;
 148    }
 149
 150    // fix i0 on maximum of correlation position
 151    i0 = pos_max[ipos[0]];
 152
 153    //
 154    // i1 loop:                                                         *
 155    //
 156
 157    // Default value
 158
 159    psk = -1;
 160    alpk = 1;
 161    for (i = 0; i < nbPulse; i++)
 162    {
 163       codvec[i] = i;
 164    }
 165
 166    for (i = 1; i < nbTracks; i++)
 167    {
 168       i1 = pos_max[ipos[1]];
 169       ps0 = add (dn[i0], dn[i1]);
 170       alp0 = L_mult (rr[i0][i0], _1_16);
 171       alp0 = L_mac (alp0, rr[i1][i1], _1_16);
 172       alp0 = L_mac (alp0, rr[i0][i1], _1_8);
 173
 174       //
 175       // i2 and i3 loop
 176       //
 177
 178       for (i3 = ipos[3]; i3 < L_CODE; i3 += step)
 179       {
 180          s = L_mult (rr[i3][i3], _1_8);       // index incr= step+L_CODE
 181          s = L_mac (s, rr[i0][i3], _1_4);     // index increment = step
 182          s = L_mac (s, rr[i1][i3], _1_4);     // index increment = step
 183          rrv[i3] = pv_round (s);
 184       }
 185
 186       // Default value
 187       sq = -1;
 188       alp = 1;
 189       ps = 0;
 190       ia = ipos[2];
 191       ib = ipos[3];
 192
 193       for (i2 = ipos[2]; i2 < L_CODE; i2 += step)
 194       {
 195          // index increment = step
 196          ps1 = add (ps0, dn[i2]);
 197
 198          // index incr= step+L_CODE
 199          alp1 = L_mac (alp0, rr[i2][i2], _1_16);
 200
 201          // index increment = step
 202          alp1 = L_mac (alp1, rr[i0][i2], _1_8);
 203
 204          // index increment = step
 205          alp1 = L_mac (alp1, rr[i1][i2], _1_8);
 206
 207          for (i3 = ipos[3]; i3 < L_CODE; i3 += step)
 208          {
 209             // index increment = step
 210             ps2 = add (ps1, dn[i3]);
 211
 212             // index increment = step
 213             alp2 = L_mac (alp1, rrv[i3], _1_2);
 214
 215             // index increment = step
 216             alp2 = L_mac (alp2, rr[i2][i3], _1_8);
 217
 218             sq2 = mult (ps2, ps2);
 219
 220             alp_16 = pv_round (alp2);
 221
 222             s = L_msu (L_mult (alp, sq2), sq, alp_16);
 223
 224             if (s > 0)
 225             {
 226                sq = sq2;
 227                ps = ps2;
 228                alp = alp_16;
 229                ia = i2;
 230                ib = i3;
 231             }
 232          }
 233       }
 234       i2 = ia;
 235       i3 = ib;
 236
 237         //
 238         // i4 and i5 loop:
 239         //
 240
 241         ps0 = ps;
 242         alp0 = L_mult (alp, _1_2);
 243
 244         for (i5 = ipos[5]; i5 < L_CODE; i5 += step)
 245         {
 246             s = L_mult (rr[i5][i5], _1_8);
 247             s = L_mac (s, rr[i0][i5], _1_4);
 248             s = L_mac (s, rr[i1][i5], _1_4);
 249             s = L_mac (s, rr[i2][i5], _1_4);
 250             s = L_mac (s, rr[i3][i5], _1_4);
 251             rrv[i5] = pv_round (s);
 252         }
 253
 254         // Default value
 255         sq = -1;
 256         alp = 1;
 257         ps = 0;
 258         ia = ipos[4];
 259         ib = ipos[5];
 260
 261         for (i4 = ipos[4]; i4 < L_CODE; i4 += step)
 262         {
 263             ps1 = add (ps0, dn[i4]);
 264
 265             alp1 = L_mac (alp0, rr[i4][i4], _1_32);
 266             alp1 = L_mac (alp1, rr[i0][i4], _1_16);
 267             alp1 = L_mac (alp1, rr[i1][i4], _1_16);
 268             alp1 = L_mac (alp1, rr[i2][i4], _1_16);
 269             alp1 = L_mac (alp1, rr[i3][i4], _1_16);
 270
 271             for (i5 = ipos[5]; i5 < L_CODE; i5 += step)
 272             {
 273                 ps2 = add (ps1, dn[i5]);
 274
 275                 alp2 = L_mac (alp1, rrv[i5], _1_4);
 276                 alp2 = L_mac (alp2, rr[i4][i5], _1_16);
 277
 278                 sq2 = mult (ps2, ps2);
 279
 280                 alp_16 = pv_round (alp2);
 281
 282                 s = L_msu (L_mult (alp, sq2), sq, alp_16);
 283
 284                 if (s > 0)
 285                 {
 286                     sq = sq2;
 287                     ps = ps2;
 288                     alp = alp_16;
 289                     ia = i4;
 290                     ib = i5;
 291                 }
 292             }
 293         }
 294         i4 = ia;
 295         i5 = ib;
 296
 297         //
 298         // i6 and i7 loop:
 299         //
 300
 301         ps0 = ps;
 302         alp0 = L_mult (alp, _1_2);
 303
 304         for (i7 = ipos[7]; i7 < L_CODE; i7 += step)
 305         {
 306             s = L_mult (rr[i7][i7], _1_16);
 307             s = L_mac (s, rr[i0][i7], _1_8);
 308             s = L_mac (s, rr[i1][i7], _1_8);
 309             s = L_mac (s, rr[i2][i7], _1_8);
 310             s = L_mac (s, rr[i3][i7], _1_8);
 311             s = L_mac (s, rr[i4][i7], _1_8);
 312             s = L_mac (s, rr[i5][i7], _1_8);
 313             rrv[i7] = pv_round (s);
 314         }
 315
 316         // Default value
 317         sq = -1;
 318         alp = 1;
 319         ps = 0;
 320         ia = ipos[6];
 321         ib = ipos[7];
 322
 323         for (i6 = ipos[6]; i6 < L_CODE; i6 += step)
 324         {
 325             ps1 = add (ps0, dn[i6]);
 326
 327             alp1 = L_mac (alp0, rr[i6][i6], _1_64);
 328             alp1 = L_mac (alp1, rr[i0][i6], _1_32);
 329             alp1 = L_mac (alp1, rr[i1][i6], _1_32);
 330             alp1 = L_mac (alp1, rr[i2][i6], _1_32);
 331             alp1 = L_mac (alp1, rr[i3][i6], _1_32);
 332             alp1 = L_mac (alp1, rr[i4][i6], _1_32);
 333             alp1 = L_mac (alp1, rr[i5][i6], _1_32);
 334
 335             for (i7 = ipos[7]; i7 < L_CODE; i7 += step)
 336             {
 337                 ps2 = add (ps1, dn[i7]);
 338
 339                 alp2 = L_mac (alp1, rrv[i7], _1_4);
 340                 alp2 = L_mac (alp2, rr[i6][i7], _1_32);
 341
 342                 sq2 = mult (ps2, ps2);
 343
 344                 alp_16 = pv_round (alp2);
 345
 346                 s = L_msu (L_mult (alp, sq2), sq, alp_16);
 347
 348                 if (s > 0)
 349                 {
 350                     sq = sq2;
 351                     ps = ps2;
 352                     alp = alp_16;
 353                     ia = i6;
 354                     ib = i7;
 355                 }
 356             }
 357         }
 358         i6 = ia;
 359         i7 = ib;
 360
 361         // now finished searching a set of 8 pulses
 362
 363         if(gsmefrFlag != 0){
 364            // go on with the two last pulses for GSMEFR
 365            //
 366            // i8 and i9 loop:
 367            //
 368
 369            ps0 = ps;
 370            alp0 = L_mult (alp, _1_2);
 371
 372            for (i9 = ipos[9]; i9 < L_CODE; i9 += step)
 373            {
 374               s = L_mult (rr[i9][i9], _1_16);
 375               s = L_mac (s, rr[i0][i9], _1_8);
 376               s = L_mac (s, rr[i1][i9], _1_8);
 377               s = L_mac (s, rr[i2][i9], _1_8);
 378               s = L_mac (s, rr[i3][i9], _1_8);
 379               s = L_mac (s, rr[i4][i9], _1_8);
 380               s = L_mac (s, rr[i5][i9], _1_8);
 381               s = L_mac (s, rr[i6][i9], _1_8);
 382               s = L_mac (s, rr[i7][i9], _1_8);
 383               rrv[i9] = pv_round (s);
 384            }
 385
 386            // Default value
 387            sq = -1;
 388            alp = 1;
 389            ps = 0;
 390            ia = ipos[8];
 391            ib = ipos[9];
 392
 393            for (i8 = ipos[8]; i8 < L_CODE; i8 += step)
 394            {
 395               ps1 = add (ps0, dn[i8]);
 396
 397               alp1 = L_mac (alp0, rr[i8][i8], _1_128);
 398               alp1 = L_mac (alp1, rr[i0][i8], _1_64);
 399               alp1 = L_mac (alp1, rr[i1][i8], _1_64);
 400               alp1 = L_mac (alp1, rr[i2][i8], _1_64);
 401               alp1 = L_mac (alp1, rr[i3][i8], _1_64);
 402               alp1 = L_mac (alp1, rr[i4][i8], _1_64);
 403               alp1 = L_mac (alp1, rr[i5][i8], _1_64);
 404               alp1 = L_mac (alp1, rr[i6][i8], _1_64);
 405               alp1 = L_mac (alp1, rr[i7][i8], _1_64);
 406
 407               for (i9 = ipos[9]; i9 < L_CODE; i9 += step)
 408               {
 409                  ps2 = add (ps1, dn[i9]);
 410
 411                  alp2 = L_mac (alp1, rrv[i9], _1_8);
 412                  alp2 = L_mac (alp2, rr[i8][i9], _1_64);
 413
 414                  sq2 = mult (ps2, ps2);
 415
 416                  alp_16 = pv_round (alp2);
 417
 418                  s = L_msu (L_mult (alp, sq2), sq, alp_16);
 419
 420                  if (s > 0)
 421                  {
 422                     sq = sq2;
 423                     ps = ps2;
 424                     alp = alp_16;
 425                     ia = i8;
 426                     ib = i9;
 427                  }
 428               }
 429            }
 430         } // end  gsmefrFlag
 431
 432         //
 433         // test and memorise if this combination is better than the last one/
 434         //
 435
 436         s = L_msu (L_mult (alpk, sq), psk, alp);
 437
 438         if (s > 0)
 439         {
 440             psk = sq;
 441             alpk = alp;
 442             codvec[0] = i0;
 443             codvec[1] = i1;
 444             codvec[2] = i2;
 445             codvec[3] = i3;
 446             codvec[4] = i4;
 447             codvec[5] = i5;
 448             codvec[6] = i6;
 449             codvec[7] = i7;
 450
 451             if (gsmefrFlag != 0)
 452             {
 453                codvec[8] = ia;
 454                codvec[9] = ib;
 455             }
 456         }
 457
 458         //
 459         // Cyclic permutation of i1,i2,i3,i4,i5,i6,i7,(i8 and i9)/
 460         //
 461
 462         pos = ipos[1];
 463         for (j = 1, k = 2; k < nbPulse; j++, k++)
 464         {
 465             ipos[j] = ipos[k];
 466         }
 467         ipos[sub(nbPulse,1)] = pos;
 468    } // end 1..nbTracks  loop
 469 }
 470
 471 ------------------------------------------------------------------------------
 472  CAUTION [optional]
 473  [State any special notes, constraints or cautions for users of this function]
 474
 475 ------------------------------------------------------------------------------
 476 */
 477
 478
 479 /*----------------------------------------------------------------------------
 480 ; FUNCTION CODE
 481 ----------------------------------------------------------------------------*/
 482 void search_10and8i40(
 483     Word16 nbPulse,      /* i : nbpulses to find                       */
 484     Word16 step,         /* i : stepsize                               */
 485     Word16 nbTracks,     /* i : nbTracks                               */
 486     Word16 dn[],         /* i : correlation between target and h[]     */
 487     Word16 rr[][L_CODE], /* i : matrix of autocorrelation              */
 488     Word16 ipos[],       /* i : starting position for each pulse       */
 489     Word16 pos_max[],    /* i : position of maximum of dn[]            */
 490     Word16 codvec[],     /* o : algebraic codebook vector              */
 491     Flag   *pOverflow    /* i/o : overflow flag                        */
 492 )
 493 {
 494     Word16 i0, i1, i2, i3, i4, i5, i6, i7, i9;
 495     Word16 i, j, k/*, m*/;
 496     Word16 pos, ia, ib;
 497     Word16 psk;
 498     Word16 sq, sq2;
 499     Word16 alpk, alp, alp_16;
 500     Word32 s;
 501     Word32 alp0, alp1, alp2;
 502     Word16 gsmefrFlag;
 503     Word16 *p_codvec = codvec;
 504     Word16  *p_temp2;
 505
 506     Word16  temp1[2*L_CODE];
 507     Word16  *p_temp1;
 508     Word16  ps2;
 509     Word16  ps1;
 510     Word16  ps;
 511     Word16 ps0;
 512
 513     Word16  index[10];
 514
 515     OSCL_UNUSED_ARG(pOverflow);
 516
 517     if (nbPulse == 10)
 518     {
 519         gsmefrFlag = 1;
 520     }
 521     else
 522     {
 523         gsmefrFlag = 0;
 524     }
 525
 526     /* fix i0 on maximum of correlation position */
 527     i0 = pos_max[ipos[0]];
 528     index[0] = i0;
 529     /*------------------------------------------------------------------*
 530     * i1 loop:                                                         *
 531     *------------------------------------------------------------------*/
 532
 533     /* Default value */
 534     psk = -1;
 535     alpk = 1;
 536     for (i = 0; i < nbPulse; i++)
 537     {
 538         *(p_codvec++) = i;
 539     }
 540
 541     for (i = 1; i < nbTracks; i++)
 542     {
 543         i1 = pos_max[ipos[1]];
 544         index[1] = i1;
 545
 546         /* ps0 = add (dn[i0], dn[i1], pOverflow);*/
 547         ps0 = (Word16)((Word32) dn[i0] + dn[i1]);
 548
 549         /* alp0 = L_mult (rr[i0][i0], _1_16, pOverflow); */
 550         alp0 = (Word32) rr[i0][i0] << 12;
 551
 552         /* alp0 = L_mac (alp0, rr[i1][i1], _1_16, pOverflow); */
 553         alp0 += (Word32) rr[i1][i1] << 12;
 554
 555         /* alp0 = L_mac (alp0, rr[i0][i1], _1_8, pOverflow); */
 556         alp0 += (Word32) rr[i0][i1] << 13;
 557         alp0 += 0x00008000L;
 558
 559         /*----------------------------------------------------------------*
 560         * i2 and i3 loop:                                                *
 561         *----------------------------------------------------------------*/
 562
 563         p_temp1 = temp1;
 564         for (i3 = ipos[3]; i3 < L_CODE; i3 += step)
 565         {
 566             p_temp2 = &rr[i3][0];
 567             s  = (Word32) * (p_temp2 + i3) >> 1;
 568             s += (Word32) * (p_temp2 + i0);
 569             s += (Word32) * (p_temp2 + i1);
 570             *(p_temp1++) = ps0 + dn[i3];
 571             *(p_temp1++) = (Word16)((s + 2) >> 2);
 572         }
 573
 574         /* Default value */
 575         sq = -1;
 576         alp = 1;
 577         ps = 0;
 578         ia = ipos[2];
 579         ib = ipos[3];
 580
 581         s = (alp0 >> 12);
 582
 583         for (j = ipos[2]; j < L_CODE; j += step)
 584         {
 585             /* index increment = step  */
 586             p_temp2 = &rr[j][0];
 587
 588             alp1 = (s + (Word32) * (p_temp2 + j)) >> 1;
 589
 590             alp1 += (Word32) * (p_temp2 + i0);
 591
 592             alp1 += (Word32) * (p_temp2 + i1);
 593
 594             p_temp1 = temp1;
 595             ps1 = dn[j];
 596
 597
 598             for (i3 = ipos[3]; i3 < L_CODE; i3 += step)
 599             {
 600                 /* index increment = step */
 601                 ps2 = ps1 + *(p_temp1++);
 602
 603                 sq2 = (Word16)(((Word32) ps2 * ps2) >> 15);
 604
 605                 alp2 = (alp1 + p_temp2[i3]) >> 2;
 606                 alp2 = (alp2 + *(p_temp1++)) >> 1;  /*  alp2 is always > 0  */
 607                 if (((Word32) sq2 * alp) > ((Word32) sq * alp2))
 608                 {
 609                     sq = sq2;
 610                     ps = ps2;
 611                     alp = (Word16)alp2;
 612                     ia = j;
 613                     ib = i3;
 614                 }
 615             }
 616
 617         }
 618         i2 = ia;
 619         i3 = ib;
 620         index[2] = ia;
 621         index[3] = ib;
 622
 623         /*----------------------------------------------------------------*
 624         * i4 and i5 loop:                                                *
 625         *----------------------------------------------------------------*/
 626
 627         alp0 = ((Word32) alp << 15) + 0x00008000L;
 628         p_temp1 = temp1;
 629
 630         for (i5 = ipos[5]; i5 < L_CODE; i5 += step)
 631         {
 632             p_temp2 = &rr[i5][0];
 633             s = (Word32) * (p_temp2 + i5) >> 1;
 634             s += (Word32) * (p_temp2 + i0);
 635             s += (Word32) * (p_temp2 + i1);
 636             s += (Word32) * (p_temp2 + i2);
 637             s += (Word32) * (p_temp2 + i3);
 638
 639             *(p_temp1++) = ps + dn[i5];
 640             *(p_temp1++) = (Word16)((s + 2) >> 2);
 641         }
 642
 643         /* Default value */
 644         sq = -1;
 645         alp = 1;
 646         ps = 0;
 647         ia = ipos[4];
 648         ib = ipos[5];
 649
 650         for (j = ipos[4]; j < L_CODE; j += step)
 651         {
 652             /* ps1 = add (ps0, dn[i4], pOverflow); */
 653             p_temp2 = &rr[j][0];
 654
 655             /* alp1 = L_mac (alp0, rr[i4][i4], _1_32, pOverflow); */
 656             alp1 = alp0 + ((Word32) * (p_temp2 + j) << 11);
 657
 658             /* alp1 = L_mac (alp1, rr[i0][i4], _1_16, pOverflow); */
 659             alp1 += (Word32) * (p_temp2 + i0) << 12;
 660
 661             /* alp1 = L_mac (alp1, rr[i1][i4], _1_16, pOverflow); */
 662             alp1 += (Word32) * (p_temp2 + i1) << 12;
 663
 664             /* alp1 = L_mac (alp1, rr[i2][i4], _1_16, pOverflow); */
 665             alp1 += (Word32) * (p_temp2 + i2) << 12;
 666
 667             /* alp1 = L_mac (alp1, rr[i3][i4], _1_16, pOverflow); */
 668             alp1 += (Word32) * (p_temp2 + i3) << 12;
 669
 670             p_temp1 = temp1;
 671             ps1 =  dn[j];
 672
 673             for (i5 = ipos[5]; i5 < L_CODE; i5 += step)
 674             {
 675                 ps2 = ps1 + *(p_temp1++);
 676
 677                 alp2 = alp1 + ((Word32) * (p_temp2 + i5) << 12);
 678
 679                 alp_16 = (Word16)((alp2 + ((Word32) * (p_temp1++) << 14)) >> 16);
 680                 sq2 = (Word16)(((Word32) ps2 * ps2) >> 15);
 681
 682                 if (((Word32) sq2 * alp) > ((Word32) sq * alp_16))
 683                 {
 684                     sq = sq2;
 685                     ps = ps2;
 686                     alp = alp_16;
 687                     ia = j;
 688                     ib = i5;
 689                 }
 690
 691             }
 692         }
 693         i4 = ia;
 694         i5 = ib;
 695         index[4] = ia;
 696         index[5] = ib;
 697
 698         /*----------------------------------------------------------------*
 699         * i6 and i7 loop:                                                *
 700         *----------------------------------------------------------------*/
 701
 702         alp0 = ((Word32) alp << 15) + 0x00008000L;
 703
 704         p_temp1 = temp1;
 705
 706         for (i7 = ipos[7]; i7 < L_CODE; i7 += step)
 707         {
 708             s = (Word32) rr[i7][i7] >> 1;
 709             s += (Word32) rr[i0][i7];
 710             s += (Word32) rr[i1][i7];
 711             s += (Word32) rr[i2][i7];
 712             s += (Word32) rr[i3][i7];
 713             s += (Word32) rr[i4][i7];
 714             s += (Word32) rr[i5][i7];
 715             *(p_temp1++) = ps + dn[i7];
 716             *(p_temp1++) = (Word16)((s + 4) >> 3);
 717         }
 718
 719
 720         /* Default value */
 721         sq = -1;
 722         alp = 1;
 723         ps = 0;
 724         ia = ipos[6];
 725         ib = ipos[7];
 726
 727         for (j = ipos[6]; j < L_CODE; j += step)
 728         {
 729             /* ps1 = add (ps0, dn[i6], pOverflow); */
 730
 731             p_temp2 = (Word16 *) & rr[j];
 732
 733             /* alp1 = L_mac (alp0, rr[i6][i6], _1_64, pOverflow); */
 734             alp1 = alp0 + ((Word32) * (p_temp2 + j) << 10);
 735
 736             /* alp1 = L_mac (alp1, rr[i0][i6], _1_32, pOverflow); */
 737             alp1 += (Word32) * (p_temp2 + i0) << 11;
 738
 739
 740             /* alp1 = L_mac (alp1, rr[i1][i6], _1_32, pOverflow); */
 741             alp1 += (Word32) * (p_temp2 + i1) << 11;
 742
 743             /* alp1 = L_mac (alp1, rr[i2][i6], _1_32, pOverflow); */
 744             alp1 += (Word32) * (p_temp2 + i2) << 11;
 745
 746             /* alp1 = L_mac (alp1, rr[i3][i6], _1_32, pOverflow); */
 747             alp1 += (Word32) * (p_temp2 + i3) << 11;
 748
 749             /* alp1 = L_mac (alp1, rr[i4][i6], _1_32, pOverflow); */
 750             alp1 += (Word32) * (p_temp2 + i4) << 11;
 751
 752             /* alp1 = L_mac (alp1, rr[i5][i6], _1_32, pOverflow); */
 753             alp1 += (Word32) * (p_temp2 + i5) << 11;
 754
 755             p_temp1 = temp1;
 756             ps1 = dn[j];
 757
 758             for (i7 = ipos[7]; i7 < L_CODE; i7 += step)
 759             {
 760                 ps2 = ps1 + *(p_temp1++);
 761
 762                 alp2 = alp1 + ((Word32) * (p_temp2 + i7) << 11);
 763
 764                 alp_16 = (Word16)((alp2 + ((Word32) * (p_temp1++) << 14)) >> 16);
 765
 766                 sq2 = (Word16)(((Word32) ps2 * ps2) >> 15);
 767
 768                 if (((Word32) sq2 * alp) > ((Word32) sq * alp_16))
 769                 {
 770                     sq = sq2;
 771                     ps = ps2;
 772                     alp = alp_16;
 773                     ia = j;
 774                     ib = i7;
 775                 }
 776             }
 777         }
 778
 779         i6 = ia;
 780         i7 = ib;
 781         index[6] = ia;
 782         index[7] = ib;
 783
 784         /* now finished searching a set of 8 pulses */
 785
 786         if (gsmefrFlag != 0)
 787         {
 788             /* go on with the two last pulses for GSMEFR                      */
 789             /*----------------------------------------------------------------*
 790             * i8 and i9 loop:                                                *
 791             *----------------------------------------------------------------*/
 792
 793             alp0 = ((Word32) alp << 15) + 0x00008000L;
 794
 795             p_temp1 = temp1;
 796
 797             for (i9 = ipos[9]; i9 < L_CODE; i9 += step)
 798             {
 799                 s = (Word32) rr[i9][i9] >> 1;
 800                 s += (Word32) rr[i0][i9];
 801                 s += (Word32) rr[i1][i9];
 802                 s += (Word32) rr[i2][i9];
 803                 s += (Word32) rr[i3][i9];
 804                 s += (Word32) rr[i4][i9];
 805                 s += (Word32) rr[i5][i9];
 806                 s += (Word32) rr[i6][i9];
 807                 s += (Word32) rr[i7][i9];
 808
 809                 *(p_temp1++) = ps + dn[i9];
 810                 *(p_temp1++) = (Word16)((s + 4) >> 3);
 811             }
 812
 813             /* Default value */
 814             sq = -1;
 815             alp = 1;
 816             ps = 0;
 817             ia = ipos[8];
 818             ib = ipos[9];
 819
 820             for (j = ipos[8]; j < L_CODE; j += step)
 821             {
 822                 /* ps1 = add (ps0, dn[i8], pOverflow); */
 823                 p_temp2 = &rr[j][0];
 824
 825                 /* alp1 = L_mac (alp0, rr[i8][i8], _1_128, pOverflow); */
 826                 alp1 = alp0 + ((Word32) * (p_temp2 + j) << 9);
 827
 828                 /* alp1 = L_mac (alp1, rr[i0][i8], _1_64, pOverflow); */
 829                 alp1 += (Word32) rr[i0][j] << 10;
 830
 831                 /* alp1 = L_mac (alp1, rr[i1][i8], _1_64, pOverflow); */
 832                 alp1 += (Word32) rr[i1][j] << 10;
 833
 834                 /* alp1 = L_mac (alp1, rr[i2][i8], _1_64, pOverflow); */
 835                 alp1 += (Word32) rr[i2][j] << 10;
 836
 837                 /* alp1 = L_mac (alp1, rr[i3][i8], _1_64, pOverflow); */
 838                 alp1 += (Word32) rr[i3][j] << 10;
 839
 840                 /* alp1 = L_mac (alp1, rr[i4][i8], _1_64, pOverflow); */
 841                 alp1 += (Word32) rr[i4][j] << 10;
 842
 843                 /* alp1 = L_mac (alp1, rr[i5][i8], _1_64, pOverflow); */
 844                 alp1 += (Word32) rr[i5][j] << 10;
 845
 846                 /* alp1 = L_mac (alp1, rr[i6][i8], _1_64, pOverflow); */
 847                 alp1 += (Word32) rr[i6][j] << 10;
 848
 849                 /* alp1 = L_mac (alp1, rr[i7][i8], _1_64, pOverflow); */
 850                 alp1 += (Word32) rr[i7][j] << 10;
 851
 852                 p_temp1 = temp1;
 853                 ps1 = dn[j];
 854
 855                 for (i9 = ipos[9]; i9 < L_CODE; i9 += step)
 856                 {
 857                     /* ps2 = add (ps1, dn[i9], pOverflow); */
 858                     ps2 = ps1 + *(p_temp1++);
 859
 860                     /* sq2 = mult (ps2, ps2, pOverflow); */
 861                     sq2 = (Word16)(((Word32) ps2 * ps2) >> 15);
 862
 863                     /* alp2 = L_mac (alp1, rrv[i9], _1_8, pOverflow); */
 864                     alp2 = alp1 + ((Word32) * (p_temp2 + i9) << 10) ;
 865
 866                     /* alp2 = L_mac (alp2, rr[i8][i9], _1_64, pOverflow); */
 867                     alp_16 = (Word16)((alp2 + ((Word32) * (p_temp1++) << 13)) >> 16);
 868
 869                     if (((Word32) sq2 * alp) > ((Word32) sq * alp_16))
 870                     {
 871                         sq = sq2;
 872                         ps = ps2;
 873                         alp = alp_16;
 874                         ia = j;
 875                         ib = i9;
 876                     }
 877                 }
 878             }
 879
 880             index[8] = ia;
 881             index[9] = ib;
 882
 883         }/* end  gsmefrFlag */
 884
 885         /*----------------------------------------------------------------  *
 886          * test and memorise if this combination is better than the last one.*
 887          *----------------------------------------------------------------*/
 888
 889         if (((Word32) alpk * sq) > ((Word32) psk * alp))
 890         {
 891             psk = sq;
 892             alpk = alp;
 893
 894             if (gsmefrFlag != 0)
 895             {
 896                 oscl_memcpy(codvec, index, (2*NB_TRACK)*sizeof(*index));
 897             }
 898             else
 899             {
 900                 oscl_memcpy(codvec, index, (2*NB_TRACK_MR102)*sizeof(*index));
 901             }
 902
 903         }
 904         /*----------------------------------------------------------------*
 905         * Cyclic permutation of i1,i2,i3,i4,i5,i6,i7,(i8 and i9).          *
 906         *----------------------------------------------------------------*/
 907
 908         pos = ipos[1];
 909         for (j = 1, k = 2; k < nbPulse; j++, k++)
 910         {
 911             ipos[j] = ipos[k];
 912         }
 913         ipos[nbPulse-1] = pos;
 914     } /* end 1..nbTracks  loop*/
 915 }
 916