1 2 /* ----------------------------------------------------------------------------------------------------------- 3 Software License for The Fraunhofer FDK AAC Codec Library for Android 4 5 Copyright 1995 - 2013 Fraunhofer-Gesellschaft zur Frderung der angewandten Forschung e.V. 6 All rights reserved. 7 8 1. INTRODUCTION 9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements 10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio. 11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices. 12 13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual 14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by 15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part 16 of the MPEG specifications. 17 18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer) 19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners 20 individually for the purpose of encoding or decoding bit streams in products that are compliant with 21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license 22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec 23 software may already be covered under those patent licenses when it is used for those licensed purposes only. 24 25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality, 26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional 27 applications information and documentation. 28 29 2. COPYRIGHT LICENSE 30 31 Redistribution and use in source and binary forms, with or without modification, are permitted without 32 payment of copyright license fees provided that you satisfy the following conditions: 33 34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or 35 your modifications thereto in source code form. 36 37 You must retain the complete text of this software license in the documentation and/or other materials 38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form. 39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your 40 modifications thereto to recipients of copies in binary form. 41 42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without 43 prior written permission. 44 45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec 46 software or your modifications thereto. 47 48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software 49 and the date of any change. For modified versions of the FDK AAC Codec, the term 50 "Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term 51 "Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android." 52 53 3. NO PATENT LICENSE 54 55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer, 56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with 57 respect to this software. 58 59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized 60 by appropriate patent licenses. 61 62 4. DISCLAIMER 63 64 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors 65 "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties 66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages, 68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits, 69 or business interruption, however caused and on any theory of liability, whether in contract, strict 70 liability, or tort (including negligence), arising in any way out of the use of this software, even if 71 advised of the possibility of such damage. 72 73 5. CONTACT INFORMATION 74 75 Fraunhofer Institute for Integrated Circuits IIS 76 Attention: Audio and Multimedia Departments - FDK AAC LL 77 Am Wolfsmantel 33 78 91058 Erlangen, Germany 79 80 www.iis.fraunhofer.de/amm 81 amm-info (at) iis.fraunhofer.de 82 ----------------------------------------------------------------------------------------------------------- */ 83 84 /***************************** MPEG-4 AAC Encoder ************************** 85 86 Author(s): M. Werner, Tobias Chalupka 87 Description: Block switching 88 89 ******************************************************************************/ 90 91 /****************** Includes *****************************/ 92 93 #include "block_switch.h" 94 #include "genericStds.h" 95 96 97 #define LOWOV_WINDOW _LOWOV_WINDOW 98 99 /**************** internal function prototypes ***********/ 100 101 static FIXP_DBL FDKaacEnc_GetWindowEnergy(const FIXP_DBL in[], const INT blSwWndIdx); 102 103 static void FDKaacEnc_CalcWindowEnergy( 104 BLOCK_SWITCHING_CONTROL *RESTRICT blockSwitchingControl, 105 INT windowLen, 106 const INT_PCM *pTimeSignal 107 ); 108 109 /****************** Constants *****************************/ 110 /* LONG START SHORT STOP LOWOV */ 111 static const INT blockType2windowShape[2][5] = { {SINE_WINDOW, KBD_WINDOW, WRONG_WINDOW, SINE_WINDOW, KBD_WINDOW}, /* LD */ 112 {KBD_WINDOW, SINE_WINDOW, SINE_WINDOW, KBD_WINDOW, WRONG_WINDOW} }; /* LC */ 113 114 /* IIR high pass coeffs */ 115 116 #ifndef SINETABLE_16BIT 117 118 static const FIXP_DBL hiPassCoeff[BLOCK_SWITCHING_IIR_LEN]= 119 { 120 FL2FXCONST_DBL(-0.5095),FL2FXCONST_DBL(0.7548) 121 }; 122 123 static const FIXP_DBL accWindowNrgFac = FL2FXCONST_DBL(0.3f); /* factor for accumulating filtered window energies */ 124 static const FIXP_DBL oneMinusAccWindowNrgFac = FL2FXCONST_DBL(0.7f); 125 /* static const float attackRatio = 10.0; */ /* lower ratio limit for attacks */ 126 static const FIXP_DBL invAttackRatio = FL2FXCONST_DBL(0.1f); /* inverted lower ratio limit for attacks */ 127 128 /* The next constants are scaled, because they are used for comparison with scaled values*/ 129 /* minimum energy for attacks */ 130 static const FIXP_DBL minAttackNrg = (FL2FXCONST_DBL(1e+6f*NORM_PCM_ENERGY)>>BLOCK_SWITCH_ENERGY_SHIFT); /* minimum energy for attacks */ 131 132 #else 133 134 static const FIXP_SGL hiPassCoeff[BLOCK_SWITCHING_IIR_LEN]= 135 { 136 FL2FXCONST_SGL(-0.5095),FL2FXCONST_SGL(0.7548) 137 }; 138 139 static const FIXP_DBL accWindowNrgFac = FL2FXCONST_DBL(0.3f); /* factor for accumulating filtered window energies */ 140 static const FIXP_SGL oneMinusAccWindowNrgFac = FL2FXCONST_SGL(0.7f); 141 /* static const float attackRatio = 10.0; */ /* lower ratio limit for attacks */ 142 static const FIXP_SGL invAttackRatio = FL2FXCONST_SGL(0.1f); /* inverted lower ratio limit for attacks */ 143 /* minimum energy for attacks */ 144 static const FIXP_DBL minAttackNrg = (FL2FXCONST_DBL(1e+6f*NORM_PCM_ENERGY)>>BLOCK_SWITCH_ENERGY_SHIFT); /* minimum energy for attacks */ 145 146 #endif 147 148 /**************** internal function prototypes ***********/ 149 150 /****************** Routines ****************************/ 151 void FDKaacEnc_InitBlockSwitching(BLOCK_SWITCHING_CONTROL *blockSwitchingControl, INT isLowDelay) 152 { 153 FDKmemclear (blockSwitchingControl, sizeof(BLOCK_SWITCHING_CONTROL)); 154 155 if (isLowDelay) 156 { 157 blockSwitchingControl->nBlockSwitchWindows = 4; 158 blockSwitchingControl->allowShortFrames = 0; 159 blockSwitchingControl->allowLookAhead = 0; 160 } 161 else 162 { 163 blockSwitchingControl->nBlockSwitchWindows = 8; 164 blockSwitchingControl->allowShortFrames = 1; 165 blockSwitchingControl->allowLookAhead = 1; 166 } 167 168 blockSwitchingControl->noOfGroups = MAX_NO_OF_GROUPS; 169 170 /* Initialize startvalue for blocktype */ 171 blockSwitchingControl->lastWindowSequence = LONG_WINDOW; 172 blockSwitchingControl->windowShape = blockType2windowShape[blockSwitchingControl->allowShortFrames][blockSwitchingControl->lastWindowSequence]; 173 174 } 175 176 static const INT suggestedGroupingTable[TRANS_FAC][MAX_NO_OF_GROUPS] = 177 { 178 /* Attack in Window 0 */ {1, 3, 3, 1}, 179 /* Attack in Window 1 */ {1, 1, 3, 3}, 180 /* Attack in Window 2 */ {2, 1, 3, 2}, 181 /* Attack in Window 3 */ {3, 1, 3, 1}, 182 /* Attack in Window 4 */ {3, 1, 1, 3}, 183 /* Attack in Window 5 */ {3, 2, 1, 2}, 184 /* Attack in Window 6 */ {3, 3, 1, 1}, 185 /* Attack in Window 7 */ {3, 3, 1, 1} 186 }; 187 188 /* change block type depending on current blocktype and whether there's an attack */ 189 /* assume no look-ahead */ 190 static const INT chgWndSq[2][N_BLOCKTYPES] = 191 { 192 /* LONG WINDOW START_WINDOW SHORT_WINDOW STOP_WINDOW, LOWOV_WINDOW, WRONG_WINDOW */ 193 /*no attack*/ {LONG_WINDOW, STOP_WINDOW, WRONG_WINDOW, LONG_WINDOW, STOP_WINDOW , WRONG_WINDOW }, 194 /*attack */ {START_WINDOW, LOWOV_WINDOW, WRONG_WINDOW, START_WINDOW, LOWOV_WINDOW, WRONG_WINDOW } 195 }; 196 197 /* change block type depending on current blocktype and whether there's an attack */ 198 /* assume look-ahead */ 199 static const INT chgWndSqLkAhd[2][2][N_BLOCKTYPES] = 200 { 201 /*attack LONG WINDOW START_WINDOW SHORT_WINDOW STOP_WINDOW LOWOV_WINDOW, WRONG_WINDOW */ /* last attack */ 202 /*no attack*/ { {LONG_WINDOW, SHORT_WINDOW, STOP_WINDOW, LONG_WINDOW, WRONG_WINDOW, WRONG_WINDOW}, /* no attack */ 203 /*attack */ {START_WINDOW, SHORT_WINDOW, SHORT_WINDOW, START_WINDOW, WRONG_WINDOW, WRONG_WINDOW} }, /* no attack */ 204 /*no attack*/ { {LONG_WINDOW, SHORT_WINDOW, SHORT_WINDOW, LONG_WINDOW, WRONG_WINDOW, WRONG_WINDOW}, /* attack */ 205 /*attack */ {START_WINDOW, SHORT_WINDOW, SHORT_WINDOW, START_WINDOW, WRONG_WINDOW, WRONG_WINDOW} } /* attack */ 206 }; 207 208 int FDKaacEnc_BlockSwitching(BLOCK_SWITCHING_CONTROL *blockSwitchingControl, const INT granuleLength, const int isLFE, const INT_PCM *pTimeSignal) 209 { 210 UINT i; 211 FIXP_DBL enM1, enMax; 212 213 UINT nBlockSwitchWindows = blockSwitchingControl->nBlockSwitchWindows; 214 215 /* for LFE : only LONG window allowed */ 216 if (isLFE) { 217 218 /* case LFE: */ 219 /* only long blocks, always use sine windows (MPEG2 AAC, MPEG4 AAC) */ 220 blockSwitchingControl->lastWindowSequence = LONG_WINDOW; 221 blockSwitchingControl->windowShape = SINE_WINDOW; 222 blockSwitchingControl->noOfGroups = 1; 223 blockSwitchingControl->groupLen[0] = 1; 224 225 return(0); 226 }; 227 228 /* Save current attack index as last attack index */ 229 blockSwitchingControl->lastattack = blockSwitchingControl->attack; 230 blockSwitchingControl->lastAttackIndex = blockSwitchingControl->attackIndex; 231 232 /* Save current window energy as last window energy */ 233 FDKmemcpy(blockSwitchingControl->windowNrg[0], blockSwitchingControl->windowNrg[1], sizeof(blockSwitchingControl->windowNrg[0])); 234 FDKmemcpy(blockSwitchingControl->windowNrgF[0], blockSwitchingControl->windowNrgF[1], sizeof(blockSwitchingControl->windowNrgF[0])); 235 236 if (blockSwitchingControl->allowShortFrames) 237 { 238 /* Calculate suggested grouping info for the last frame */ 239 240 /* Reset grouping info */ 241 FDKmemclear (blockSwitchingControl->groupLen, sizeof(blockSwitchingControl->groupLen)); 242 243 /* Set grouping info */ 244 blockSwitchingControl->noOfGroups = MAX_NO_OF_GROUPS; 245 246 FDKmemcpy(blockSwitchingControl->groupLen, suggestedGroupingTable[blockSwitchingControl->lastAttackIndex], sizeof(blockSwitchingControl->groupLen)); 247 248 if (blockSwitchingControl->attack == TRUE) 249 blockSwitchingControl->maxWindowNrg = FDKaacEnc_GetWindowEnergy(blockSwitchingControl->windowNrg[0], blockSwitchingControl->lastAttackIndex); 250 else 251 blockSwitchingControl->maxWindowNrg = FL2FXCONST_DBL(0.0); 252 253 } 254 255 256 /* Calculate unfiltered and filtered energies in subwindows and combine to segments */ 257 FDKaacEnc_CalcWindowEnergy(blockSwitchingControl, granuleLength>>(nBlockSwitchWindows==4? 2:3 ), pTimeSignal); 258 259 /* now calculate if there is an attack */ 260 261 /* reset attack */ 262 blockSwitchingControl->attack = FALSE; 263 264 /* look for attack */ 265 enMax = FL2FXCONST_DBL(0.0f); 266 enM1 = blockSwitchingControl->windowNrgF[0][nBlockSwitchWindows-1]; 267 268 for (i=0; i<nBlockSwitchWindows; i++) { 269 FIXP_DBL tmp = fMultDiv2(oneMinusAccWindowNrgFac, blockSwitchingControl->accWindowNrg); 270 blockSwitchingControl->accWindowNrg = fMultAdd(tmp, accWindowNrgFac, enM1) ; 271 272 if (fMult(blockSwitchingControl->windowNrgF[1][i],invAttackRatio) > blockSwitchingControl->accWindowNrg ) { 273 blockSwitchingControl->attack = TRUE; 274 blockSwitchingControl->attackIndex = i; 275 } 276 enM1 = blockSwitchingControl->windowNrgF[1][i]; 277 enMax = fixMax(enMax, enM1); 278 } 279 280 281 if (enMax < minAttackNrg) blockSwitchingControl->attack = FALSE; 282 283 /* Check if attack spreads over frame border */ 284 if((blockSwitchingControl->attack == FALSE) && (blockSwitchingControl->lastattack == TRUE)) { 285 /* if attack is in last window repeat SHORT_WINDOW */ 286 if ( ((blockSwitchingControl->windowNrgF[0][nBlockSwitchWindows-1]>>4) > fMult((FIXP_DBL)(10<<(DFRACT_BITS-1-4)), blockSwitchingControl->windowNrgF[1][1])) 287 && (blockSwitchingControl->lastAttackIndex == (INT)nBlockSwitchWindows-1) 288 ) 289 { 290 blockSwitchingControl->attack = TRUE; 291 blockSwitchingControl->attackIndex = 0; 292 } 293 } 294 295 296 if(blockSwitchingControl->allowLookAhead) 297 { 298 299 300 blockSwitchingControl->lastWindowSequence = 301 chgWndSqLkAhd[blockSwitchingControl->lastattack][blockSwitchingControl->attack][blockSwitchingControl->lastWindowSequence]; 302 } 303 else 304 { 305 /* Low Delay */ 306 blockSwitchingControl->lastWindowSequence = 307 chgWndSq[blockSwitchingControl->attack][blockSwitchingControl->lastWindowSequence]; 308 } 309 310 311 /* update window shape */ 312 blockSwitchingControl->windowShape = blockType2windowShape[blockSwitchingControl->allowShortFrames][blockSwitchingControl->lastWindowSequence]; 313 314 return(0); 315 } 316 317 318 319 static FIXP_DBL FDKaacEnc_GetWindowEnergy(const FIXP_DBL in[], const INT blSwWndIdx) 320 { 321 /* For coherency, change FDKaacEnc_GetWindowEnergy() to calcluate the energy for a block switching analysis windows, 322 not for a short block. The same is done FDKaacEnc_CalcWindowEnergy(). The result of FDKaacEnc_GetWindowEnergy() 323 is used for a comparision of the max energy of left/right channel. */ 324 325 return in[blSwWndIdx]; 326 327 } 328 329 static void FDKaacEnc_CalcWindowEnergy(BLOCK_SWITCHING_CONTROL *RESTRICT blockSwitchingControl, INT windowLen, const INT_PCM *pTimeSignal) 330 { 331 INT i; 332 UINT w; 333 334 FIXP_SGL hiPassCoeff0 = hiPassCoeff[0]; 335 FIXP_SGL hiPassCoeff1 = hiPassCoeff[1]; 336 337 /* sum up scalarproduct of timesignal as windowed Energies */ 338 for (w=0; w < blockSwitchingControl->nBlockSwitchWindows; w++) { 339 340 FIXP_DBL temp_windowNrg = FL2FXCONST_DBL(0.0f); 341 FIXP_DBL temp_windowNrgF = FL2FXCONST_DBL(0.0f); 342 FIXP_DBL temp_iirState0 = blockSwitchingControl->iirStates[0]; 343 FIXP_DBL temp_iirState1 = blockSwitchingControl->iirStates[1]; 344 345 /* windowNrg = sum(timesample^2) */ 346 for(i=0;i<windowLen;i++) 347 { 348 349 FIXP_DBL tempUnfiltered, tempFiltred, t1, t2; 350 /* tempUnfiltered is scaled with 1 to prevent overflows during calculation of tempFiltred */ 351 #if SAMPLE_BITS == DFRACT_BITS 352 tempUnfiltered = (FIXP_DBL) *pTimeSignal++ >> 1; 353 #else 354 tempUnfiltered = (FIXP_DBL) *pTimeSignal++ << (DFRACT_BITS-SAMPLE_BITS-1); 355 #endif 356 t1 = fMultDiv2(hiPassCoeff1, tempUnfiltered-temp_iirState0); 357 t2 = fMultDiv2(hiPassCoeff0, temp_iirState1); 358 tempFiltred = (t1 - t2) << 1; 359 360 temp_iirState0 = tempUnfiltered; 361 temp_iirState1 = tempFiltred; 362 363 /* subtract 2 from overallscaling (BLOCK_SWITCH_ENERGY_SHIFT) 364 * because tempUnfiltered was already scaled with 1 (is 2 after squaring) 365 * subtract 1 from overallscaling (BLOCK_SWITCH_ENERGY_SHIFT) 366 * because of fMultDiv2 is doing a scaling by one */ 367 temp_windowNrg += fPow2Div2(tempUnfiltered) >> (BLOCK_SWITCH_ENERGY_SHIFT - 1 - 2); 368 temp_windowNrgF += fPow2Div2(tempFiltred) >> (BLOCK_SWITCH_ENERGY_SHIFT - 1 - 2); 369 } 370 blockSwitchingControl->windowNrg[1][w] = temp_windowNrg; 371 blockSwitchingControl->windowNrgF[1][w] = temp_windowNrgF; 372 blockSwitchingControl->iirStates[0] = temp_iirState0; 373 blockSwitchingControl->iirStates[1] = temp_iirState1; 374 } 375 } 376 377 378 static const UCHAR synchronizedBlockTypeTable[5][5] = 379 { 380 /* LONG_WINDOW START_WINDOW SHORT_WINDOW STOP_WINDOW LOWOV_WINDOW*/ 381 /* LONG_WINDOW */ {LONG_WINDOW, START_WINDOW, SHORT_WINDOW, STOP_WINDOW, LOWOV_WINDOW}, 382 /* START_WINDOW */ {START_WINDOW, START_WINDOW, SHORT_WINDOW, SHORT_WINDOW, LOWOV_WINDOW}, 383 /* SHORT_WINDOW */ {SHORT_WINDOW, SHORT_WINDOW, SHORT_WINDOW, SHORT_WINDOW, WRONG_WINDOW}, 384 /* STOP_WINDOW */ {STOP_WINDOW, SHORT_WINDOW, SHORT_WINDOW, STOP_WINDOW, LOWOV_WINDOW}, 385 /* LOWOV_WINDOW */ {LOWOV_WINDOW, LOWOV_WINDOW, WRONG_WINDOW, LOWOV_WINDOW, LOWOV_WINDOW}, 386 }; 387 388 int FDKaacEnc_SyncBlockSwitching ( 389 BLOCK_SWITCHING_CONTROL *blockSwitchingControlLeft, 390 BLOCK_SWITCHING_CONTROL *blockSwitchingControlRight, 391 const INT nChannels, 392 const INT commonWindow ) 393 { 394 UCHAR patchType = LONG_WINDOW; 395 396 if( nChannels == 2 && commonWindow == TRUE) 397 { 398 /* could be better with a channel loop (need a handle to psy_data) */ 399 /* get suggested Block Types and synchronize */ 400 patchType = synchronizedBlockTypeTable[patchType][blockSwitchingControlLeft->lastWindowSequence]; 401 patchType = synchronizedBlockTypeTable[patchType][blockSwitchingControlRight->lastWindowSequence]; 402 403 /* sanity check (no change from low overlap window to short winow and vice versa) */ 404 if (patchType == WRONG_WINDOW) 405 return -1; /* mixed up AAC-LC and AAC-LD */ 406 407 /* Set synchronized Blocktype */ 408 blockSwitchingControlLeft->lastWindowSequence = patchType; 409 blockSwitchingControlRight->lastWindowSequence = patchType; 410 411 /* update window shape */ 412 blockSwitchingControlLeft->windowShape = blockType2windowShape[blockSwitchingControlLeft->allowShortFrames][blockSwitchingControlLeft->lastWindowSequence]; 413 blockSwitchingControlRight->windowShape = blockType2windowShape[blockSwitchingControlLeft->allowShortFrames][blockSwitchingControlRight->lastWindowSequence]; 414 } 415 416 if (blockSwitchingControlLeft->allowShortFrames) 417 { 418 int i; 419 420 if( nChannels == 2 ) 421 { 422 if (commonWindow == TRUE) 423 { 424 /* Synchronize grouping info */ 425 int windowSequenceLeftOld = blockSwitchingControlLeft->lastWindowSequence; 426 int windowSequenceRightOld = blockSwitchingControlRight->lastWindowSequence; 427 428 /* Long Blocks */ 429 if(patchType != SHORT_WINDOW) { 430 /* Set grouping info */ 431 blockSwitchingControlLeft->noOfGroups = 1; 432 blockSwitchingControlRight->noOfGroups = 1; 433 blockSwitchingControlLeft->groupLen[0] = 1; 434 blockSwitchingControlRight->groupLen[0] = 1; 435 436 for (i = 1; i < MAX_NO_OF_GROUPS; i++) 437 { 438 blockSwitchingControlLeft->groupLen[i] = 0; 439 blockSwitchingControlRight->groupLen[i] = 0; 440 } 441 } 442 443 /* Short Blocks */ 444 else { 445 /* in case all two channels were detected as short-blocks before syncing, use the grouping of channel with higher maxWindowNrg */ 446 if( (windowSequenceLeftOld == SHORT_WINDOW) && 447 (windowSequenceRightOld == SHORT_WINDOW) ) 448 { 449 if(blockSwitchingControlLeft->maxWindowNrg > blockSwitchingControlRight->maxWindowNrg) { 450 /* Left Channel wins */ 451 blockSwitchingControlRight->noOfGroups = blockSwitchingControlLeft->noOfGroups; 452 for (i = 0; i < MAX_NO_OF_GROUPS; i++){ 453 blockSwitchingControlRight->groupLen[i] = blockSwitchingControlLeft->groupLen[i]; 454 } 455 } 456 else { 457 /* Right Channel wins */ 458 blockSwitchingControlLeft->noOfGroups = blockSwitchingControlRight->noOfGroups; 459 for (i = 0; i < MAX_NO_OF_GROUPS; i++){ 460 blockSwitchingControlLeft->groupLen[i] = blockSwitchingControlRight->groupLen[i]; 461 } 462 } 463 } 464 else if ( (windowSequenceLeftOld == SHORT_WINDOW) && 465 (windowSequenceRightOld != SHORT_WINDOW) ) 466 { 467 /* else use grouping of short-block channel */ 468 blockSwitchingControlRight->noOfGroups = blockSwitchingControlLeft->noOfGroups; 469 for (i = 0; i < MAX_NO_OF_GROUPS; i++){ 470 blockSwitchingControlRight->groupLen[i] = blockSwitchingControlLeft->groupLen[i]; 471 } 472 } 473 else if ( (windowSequenceRightOld == SHORT_WINDOW) && 474 (windowSequenceLeftOld != SHORT_WINDOW) ) 475 { 476 blockSwitchingControlLeft->noOfGroups = blockSwitchingControlRight->noOfGroups; 477 for (i = 0; i < MAX_NO_OF_GROUPS; i++){ 478 blockSwitchingControlLeft->groupLen[i] = blockSwitchingControlRight->groupLen[i]; 479 } 480 } else { 481 /* syncing a start and stop window ... */ 482 blockSwitchingControlLeft->noOfGroups = blockSwitchingControlRight->noOfGroups = 2; 483 blockSwitchingControlLeft->groupLen[0] = blockSwitchingControlRight->groupLen[0] = 4; 484 blockSwitchingControlLeft->groupLen[1] = blockSwitchingControlRight->groupLen[1] = 4; 485 } 486 } /* Short Blocks */ 487 } 488 else { 489 /* stereo, no common window */ 490 if (blockSwitchingControlLeft->lastWindowSequence!=SHORT_WINDOW){ 491 blockSwitchingControlLeft->noOfGroups = 1; 492 blockSwitchingControlLeft->groupLen[0] = 1; 493 for (i = 1; i < MAX_NO_OF_GROUPS; i++) 494 { 495 blockSwitchingControlLeft->groupLen[i] = 0; 496 } 497 } 498 if (blockSwitchingControlRight->lastWindowSequence!=SHORT_WINDOW){ 499 blockSwitchingControlRight->noOfGroups = 1; 500 blockSwitchingControlRight->groupLen[0] = 1; 501 for (i = 1; i < MAX_NO_OF_GROUPS; i++) 502 { 503 blockSwitchingControlRight->groupLen[i] = 0; 504 } 505 } 506 } /* common window */ 507 } else { 508 /* Mono */ 509 if (blockSwitchingControlLeft->lastWindowSequence!=SHORT_WINDOW){ 510 blockSwitchingControlLeft->noOfGroups = 1; 511 blockSwitchingControlLeft->groupLen[0] = 1; 512 513 for (i = 1; i < MAX_NO_OF_GROUPS; i++) 514 { 515 blockSwitchingControlLeft->groupLen[i] = 0; 516 } 517 } 518 } 519 } /* allowShortFrames */ 520 521 522 /* Translate LOWOV_WINDOW block type to a meaningful window shape. */ 523 if ( ! blockSwitchingControlLeft->allowShortFrames ) { 524 if ( blockSwitchingControlLeft->lastWindowSequence != LONG_WINDOW 525 && blockSwitchingControlLeft->lastWindowSequence != STOP_WINDOW ) 526 { 527 blockSwitchingControlLeft->lastWindowSequence = LONG_WINDOW; 528 blockSwitchingControlLeft->windowShape = LOL_WINDOW; 529 } 530 } 531 if (nChannels == 2) { 532 if ( ! blockSwitchingControlRight->allowShortFrames ) { 533 if ( blockSwitchingControlRight->lastWindowSequence != LONG_WINDOW 534 && blockSwitchingControlRight->lastWindowSequence != STOP_WINDOW ) 535 { 536 blockSwitchingControlRight->lastWindowSequence = LONG_WINDOW; 537 blockSwitchingControlRight->windowShape = LOL_WINDOW; 538 } 539 } 540 } 541 542 return 0; 543 } 544 545 546
