1 /* 2 * Copyright (C) 2004-2010 NXP Software 3 * Copyright (C) 2010 The Android Open Source Project 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 /************************************************************************************/ 19 /* */ 20 /* Includes */ 21 /* */ 22 /************************************************************************************/ 23 24 #include "LVM_Private.h" 25 #include "LVM_Tables.h" 26 #include "VectorArithmetic.h" 27 #include "InstAlloc.h" 28 29 /****************************************************************************************/ 30 /* */ 31 /* FUNCTION: LVM_GetMemoryTable */ 32 /* */ 33 /* DESCRIPTION: */ 34 /* This function is used for memory allocation and free. It can be called in */ 35 /* two ways: */ 36 /* */ 37 /* hInstance = NULL Returns the memory requirements */ 38 /* hInstance = Instance handle Returns the memory requirements and */ 39 /* allocated base addresses for the instance */ 40 /* */ 41 /* When this function is called for memory allocation (hInstance=NULL) the memory */ 42 /* base address pointers are NULL on return. */ 43 /* */ 44 /* When the function is called for free (hInstance = Instance Handle) the memory */ 45 /* table returns the allocated memory and base addresses used during initialisation. */ 46 /* */ 47 /* PARAMETERS: */ 48 /* hInstance Instance Handle */ 49 /* pMemoryTable Pointer to an empty memory definition table */ 50 /* pCapabilities Pointer to the default capabilities */ 51 /* */ 52 /* RETURNS: */ 53 /* LVM_SUCCESS Succeeded */ 54 /* LVM_NULLADDRESS When one of pMemoryTable or pInstParams is NULL */ 55 /* LVM_OUTOFRANGE When any of the Instance parameters are out of range */ 56 /* */ 57 /* NOTES: */ 58 /* 1. This function may be interrupted by the LVM_Process function */ 59 /* 2. The scratch memory is the largest required by any of the sub-modules plus any */ 60 /* additional scratch requirements of the bundle */ 61 /* */ 62 /****************************************************************************************/ 63 64 LVM_ReturnStatus_en LVM_GetMemoryTable(LVM_Handle_t hInstance, 65 LVM_MemTab_t *pMemoryTable, 66 LVM_InstParams_t *pInstParams) 67 { 68 69 LVM_Instance_t *pInstance = (LVM_Instance_t *)hInstance; 70 LVM_UINT32 AlgScratchSize; 71 LVM_UINT32 BundleScratchSize; 72 LVM_UINT16 InternalBlockSize; 73 INST_ALLOC AllocMem[LVM_NR_MEMORY_REGIONS]; 74 LVM_INT16 i; 75 76 77 /* 78 * Check parameters 79 */ 80 if(pMemoryTable == LVM_NULL) 81 { 82 return LVM_NULLADDRESS; 83 } 84 85 86 /* 87 * Return memory table if the instance has already been created 88 */ 89 if (hInstance != LVM_NULL) 90 { 91 /* Read back memory allocation table */ 92 *pMemoryTable = pInstance->MemoryTable; 93 return(LVM_SUCCESS); 94 } 95 96 if(pInstParams == LVM_NULL) 97 { 98 return LVM_NULLADDRESS; 99 } 100 101 /* 102 * Power Spectrum Analyser 103 */ 104 if(pInstParams->PSA_Included > LVM_PSA_ON) 105 { 106 return (LVM_OUTOFRANGE); 107 } 108 109 /* 110 * Check the instance parameters 111 */ 112 if( (pInstParams->BufferMode != LVM_MANAGED_BUFFERS) && (pInstParams->BufferMode != LVM_UNMANAGED_BUFFERS) ) 113 { 114 return (LVM_OUTOFRANGE); 115 } 116 117 /* N-Band Equalizer */ 118 if( pInstParams->EQNB_NumBands > 32 ) 119 { 120 return (LVM_OUTOFRANGE); 121 } 122 123 if(pInstParams->BufferMode == LVM_MANAGED_BUFFERS) 124 { 125 if( (pInstParams->MaxBlockSize < LVM_MIN_MAXBLOCKSIZE ) || (pInstParams->MaxBlockSize > LVM_MANAGED_MAX_MAXBLOCKSIZE ) ) 126 { 127 return (LVM_OUTOFRANGE); 128 } 129 } 130 else 131 { 132 if( (pInstParams->MaxBlockSize < LVM_MIN_MAXBLOCKSIZE ) || (pInstParams->MaxBlockSize > LVM_UNMANAGED_MAX_MAXBLOCKSIZE) ) 133 { 134 return (LVM_OUTOFRANGE); 135 } 136 } 137 138 /* 139 * Initialise the AllocMem structures 140 */ 141 for (i=0; i<LVM_NR_MEMORY_REGIONS; i++) 142 { 143 InstAlloc_Init(&AllocMem[i], LVM_NULL); 144 } 145 InternalBlockSize = (LVM_UINT16)((pInstParams->MaxBlockSize) & MIN_INTERNAL_BLOCKMASK); /* Force to a multiple of MIN_INTERNAL_BLOCKSIZE */ 146 147 if (InternalBlockSize < MIN_INTERNAL_BLOCKSIZE) 148 { 149 InternalBlockSize = MIN_INTERNAL_BLOCKSIZE; 150 } 151 152 /* Maximum Internal Black Size should not be more than MAX_INTERNAL_BLOCKSIZE*/ 153 if(InternalBlockSize > MAX_INTERNAL_BLOCKSIZE) 154 { 155 InternalBlockSize = MAX_INTERNAL_BLOCKSIZE; 156 } 157 158 /* 159 * Bundle requirements 160 */ 161 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA], 162 sizeof(LVM_Instance_t)); 163 164 165 /* 166 * Set the algorithm and bundle scratch requirements 167 */ 168 AlgScratchSize = 0; 169 if (pInstParams->BufferMode == LVM_MANAGED_BUFFERS) 170 { 171 BundleScratchSize = 6 * (MIN_INTERNAL_BLOCKSIZE + InternalBlockSize) * sizeof(LVM_INT16); 172 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], /* Scratch buffer */ 173 BundleScratchSize); 174 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA], 175 sizeof(LVM_Buffer_t)); 176 } 177 178 /* 179 * Treble Enhancement requirements 180 */ 181 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 182 sizeof(LVM_TE_Data_t)); 183 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 184 sizeof(LVM_TE_Coefs_t)); 185 186 /* 187 * N-Band Equalizer requirements 188 */ 189 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], /* Local storage */ 190 (pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t))); 191 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], /* User storage */ 192 (pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t))); 193 194 /* 195 * Concert Sound requirements 196 */ 197 { 198 LVCS_MemTab_t CS_MemTab; 199 LVCS_Capabilities_t CS_Capabilities; 200 201 /* 202 * Set the capabilities 203 */ 204 CS_Capabilities.MaxBlockSize = InternalBlockSize; 205 206 /* 207 * Get the memory requirements 208 */ 209 LVCS_Memory(LVM_NULL, 210 &CS_MemTab, 211 &CS_Capabilities); 212 213 /* 214 * Update the memory allocation structures 215 */ 216 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 217 CS_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size); 218 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 219 CS_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size); 220 if (CS_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size > AlgScratchSize) AlgScratchSize = CS_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size; 221 222 } 223 224 225 /* 226 * Dynamic Bass Enhancement requirements 227 */ 228 { 229 LVDBE_MemTab_t DBE_MemTab; 230 LVDBE_Capabilities_t DBE_Capabilities; 231 232 /* 233 * Set the capabilities 234 */ 235 #if defined(BUILD_FLOAT) && defined(HIGHER_FS) 236 DBE_Capabilities.SampleRate = LVDBE_CAP_FS_8000 | LVDBE_CAP_FS_11025 | LVDBE_CAP_FS_12000 | LVDBE_CAP_FS_16000 | LVDBE_CAP_FS_22050 | LVDBE_CAP_FS_24000 | LVDBE_CAP_FS_32000 | LVDBE_CAP_FS_44100 | LVDBE_CAP_FS_48000 | LVDBE_CAP_FS_96000 | LVDBE_CAP_FS_192000; 237 #else 238 DBE_Capabilities.SampleRate = LVDBE_CAP_FS_8000 | LVDBE_CAP_FS_11025 | LVDBE_CAP_FS_12000 | LVDBE_CAP_FS_16000 | LVDBE_CAP_FS_22050 | LVDBE_CAP_FS_24000 | LVDBE_CAP_FS_32000 | LVDBE_CAP_FS_44100 | LVDBE_CAP_FS_48000; 239 #endif 240 DBE_Capabilities.CentreFrequency = LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_66Hz | LVDBE_CAP_CENTRE_78Hz | LVDBE_CAP_CENTRE_90Hz; 241 DBE_Capabilities.MaxBlockSize = InternalBlockSize; 242 243 /* 244 * Get the memory requirements 245 */ 246 LVDBE_Memory(LVM_NULL, 247 &DBE_MemTab, 248 249 &DBE_Capabilities); 250 /* 251 * Update the bundle table 252 */ 253 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 254 DBE_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size); 255 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 256 DBE_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size); 257 if (DBE_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size > AlgScratchSize) AlgScratchSize = DBE_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size; 258 259 } 260 261 262 /* 263 * N-Band equaliser requirements 264 */ 265 { 266 LVEQNB_MemTab_t EQNB_MemTab; /* For N-Band Equaliser */ 267 LVEQNB_Capabilities_t EQNB_Capabilities; 268 269 /* 270 * Set the capabilities 271 */ 272 #if defined(BUILD_FLOAT) && defined(HIGHER_FS) 273 EQNB_Capabilities.SampleRate = LVEQNB_CAP_FS_8000 | LVEQNB_CAP_FS_11025 | LVEQNB_CAP_FS_12000 | LVEQNB_CAP_FS_16000 | LVEQNB_CAP_FS_22050 | LVEQNB_CAP_FS_24000 | LVEQNB_CAP_FS_32000 | LVEQNB_CAP_FS_44100 | LVEQNB_CAP_FS_48000 | LVEQNB_CAP_FS_96000 | LVEQNB_CAP_FS_192000; 274 #else 275 EQNB_Capabilities.SampleRate = LVEQNB_CAP_FS_8000 | LVEQNB_CAP_FS_11025 | LVEQNB_CAP_FS_12000 | LVEQNB_CAP_FS_16000 | LVEQNB_CAP_FS_22050 | LVEQNB_CAP_FS_24000 | LVEQNB_CAP_FS_32000 | LVEQNB_CAP_FS_44100 | LVEQNB_CAP_FS_48000; 276 #endif 277 EQNB_Capabilities.SourceFormat = LVEQNB_CAP_STEREO | LVEQNB_CAP_MONOINSTEREO; 278 EQNB_Capabilities.MaxBlockSize = InternalBlockSize; 279 EQNB_Capabilities.MaxBands = pInstParams->EQNB_NumBands; 280 281 /* 282 * Get the memory requirements 283 */ 284 LVEQNB_Memory(LVM_NULL, 285 &EQNB_MemTab, 286 &EQNB_Capabilities); 287 288 /* 289 * Update the bundle table 290 */ 291 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 292 EQNB_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size); 293 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 294 EQNB_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size); 295 if (EQNB_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size > AlgScratchSize) AlgScratchSize = EQNB_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size; 296 297 } 298 299 /* 300 * Headroom management memory allocation 301 */ 302 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 303 (LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t))); 304 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 305 (LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t))); 306 307 308 /* 309 * Spectrum Analyzer memory requirements 310 */ 311 { 312 pLVPSA_Handle_t hPSAInst = LVM_NULL; 313 LVPSA_MemTab_t PSA_MemTab; 314 LVPSA_InitParams_t PSA_InitParams; 315 LVPSA_FilterParam_t FiltersParams[9]; 316 LVPSA_RETURN PSA_Status; 317 318 if(pInstParams->PSA_Included == LVM_PSA_ON) 319 { 320 PSA_InitParams.SpectralDataBufferDuration = (LVM_UINT16) 500; 321 PSA_InitParams.MaxInputBlockSize = (LVM_UINT16) 1000; 322 PSA_InitParams.nBands = (LVM_UINT16) 9; 323 324 PSA_InitParams.pFiltersParams = &FiltersParams[0]; 325 for(i = 0; i < PSA_InitParams.nBands; i++) 326 { 327 FiltersParams[i].CenterFrequency = (LVM_UINT16) 1000; 328 FiltersParams[i].QFactor = (LVM_UINT16) 25; 329 FiltersParams[i].PostGain = (LVM_INT16) 0; 330 } 331 332 /* 333 * Get the memory requirements 334 */ 335 PSA_Status = LVPSA_Memory (hPSAInst, 336 &PSA_MemTab, 337 &PSA_InitParams); 338 339 if (PSA_Status != LVPSA_OK) 340 { 341 return((LVM_ReturnStatus_en) LVM_ALGORITHMPSA); 342 } 343 344 /* 345 * Update the bundle table 346 */ 347 /* Slow Data */ 348 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA], 349 PSA_MemTab.Region[LVM_PERSISTENT_SLOW_DATA].Size); 350 351 /* Fast Data */ 352 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 353 PSA_MemTab.Region[LVM_PERSISTENT_FAST_DATA].Size); 354 355 /* Fast Coef */ 356 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 357 PSA_MemTab.Region[LVM_PERSISTENT_FAST_COEF].Size); 358 359 /* Fast Temporary */ 360 InstAlloc_AddMember(&AllocMem[LVM_TEMPORARY_FAST], 361 MAX_INTERNAL_BLOCKSIZE * sizeof(LVM_INT16)); 362 363 if (PSA_MemTab.Region[LVM_TEMPORARY_FAST].Size > AlgScratchSize) 364 { 365 AlgScratchSize = PSA_MemTab.Region[LVM_TEMPORARY_FAST].Size; 366 } 367 } 368 } 369 370 /* 371 * Return the memory table 372 */ 373 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_SLOW_DATA].Size = InstAlloc_GetTotal(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA]); 374 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_SLOW_DATA].Type = LVM_PERSISTENT_SLOW_DATA; 375 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_SLOW_DATA].pBaseAddress = LVM_NULL; 376 377 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size = InstAlloc_GetTotal(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA]); 378 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Type = LVM_PERSISTENT_FAST_DATA; 379 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].pBaseAddress = LVM_NULL; 380 if (pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size < 4) 381 { 382 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size = 0; 383 } 384 385 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size = InstAlloc_GetTotal(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF]); 386 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Type = LVM_PERSISTENT_FAST_COEF; 387 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].pBaseAddress = LVM_NULL; 388 if (pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size < 4) 389 { 390 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size = 0; 391 } 392 393 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], 394 AlgScratchSize); 395 pMemoryTable->Region[LVM_MEMREGION_TEMPORARY_FAST].Size = InstAlloc_GetTotal(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST]); 396 pMemoryTable->Region[LVM_MEMREGION_TEMPORARY_FAST].Type = LVM_TEMPORARY_FAST; 397 pMemoryTable->Region[LVM_MEMREGION_TEMPORARY_FAST].pBaseAddress = LVM_NULL; 398 if (pMemoryTable->Region[LVM_MEMREGION_TEMPORARY_FAST].Size < 4) 399 { 400 pMemoryTable->Region[LVM_MEMREGION_TEMPORARY_FAST].Size = 0; 401 } 402 403 return(LVM_SUCCESS); 404 405 } 406 407 408 /****************************************************************************************/ 409 /* */ 410 /* FUNCTION: LVM_GetInstanceHandle */ 411 /* */ 412 /* DESCRIPTION: */ 413 /* This function is used to create a bundle instance. It returns the created instance */ 414 /* handle through phInstance. All parameters are set to their default, inactive state. */ 415 /* */ 416 /* PARAMETERS: */ 417 /* phInstance pointer to the instance handle */ 418 /* pMemoryTable Pointer to the memory definition table */ 419 /* pInstParams Pointer to the initialisation capabilities */ 420 /* */ 421 /* RETURNS: */ 422 /* LVM_SUCCESS Initialisation succeeded */ 423 /* LVM_OUTOFRANGE When any of the Instance parameters are out of range */ 424 /* LVM_NULLADDRESS When one of phInstance, pMemoryTable or pInstParams are NULL*/ 425 /* */ 426 /* NOTES: */ 427 /* 1. This function must not be interrupted by the LVM_Process function */ 428 /* */ 429 /****************************************************************************************/ 430 431 LVM_ReturnStatus_en LVM_GetInstanceHandle(LVM_Handle_t *phInstance, 432 LVM_MemTab_t *pMemoryTable, 433 LVM_InstParams_t *pInstParams) 434 { 435 436 LVM_ReturnStatus_en Status = LVM_SUCCESS; 437 LVM_Instance_t *pInstance; 438 INST_ALLOC AllocMem[LVM_NR_MEMORY_REGIONS]; 439 LVM_INT16 i; 440 LVM_UINT16 InternalBlockSize; 441 LVM_INT32 BundleScratchSize; 442 443 444 /* 445 * Check valid points have been given 446 */ 447 if ((phInstance == LVM_NULL) || (pMemoryTable == LVM_NULL) || (pInstParams == LVM_NULL)) 448 { 449 return (LVM_NULLADDRESS); 450 } 451 452 /* 453 * Check the memory table for NULL pointers 454 */ 455 for (i=0; i<LVM_NR_MEMORY_REGIONS; i++) 456 { 457 if ((pMemoryTable->Region[i].Size != 0) && 458 (pMemoryTable->Region[i].pBaseAddress==LVM_NULL)) 459 { 460 return(LVM_NULLADDRESS); 461 } 462 } 463 464 /* 465 * Check the instance parameters 466 */ 467 if( (pInstParams->BufferMode != LVM_MANAGED_BUFFERS) && (pInstParams->BufferMode != LVM_UNMANAGED_BUFFERS) ) 468 { 469 return (LVM_OUTOFRANGE); 470 } 471 472 if( pInstParams->EQNB_NumBands > 32 ) 473 { 474 return (LVM_OUTOFRANGE); 475 } 476 477 if(pInstParams->BufferMode == LVM_MANAGED_BUFFERS) 478 { 479 if( (pInstParams->MaxBlockSize < LVM_MIN_MAXBLOCKSIZE ) || (pInstParams->MaxBlockSize > LVM_MANAGED_MAX_MAXBLOCKSIZE ) ) 480 { 481 return (LVM_OUTOFRANGE); 482 } 483 } 484 else 485 { 486 if( (pInstParams->MaxBlockSize < LVM_MIN_MAXBLOCKSIZE ) || (pInstParams->MaxBlockSize > LVM_UNMANAGED_MAX_MAXBLOCKSIZE) ) 487 { 488 return (LVM_OUTOFRANGE); 489 } 490 } 491 492 if(pInstParams->PSA_Included > LVM_PSA_ON) 493 { 494 return (LVM_OUTOFRANGE); 495 } 496 497 /* 498 * Initialise the AllocMem structures 499 */ 500 for (i=0; i<LVM_NR_MEMORY_REGIONS; i++) 501 { 502 InstAlloc_Init(&AllocMem[i], 503 pMemoryTable->Region[i].pBaseAddress); 504 } 505 506 507 /* 508 * Set the instance handle 509 */ 510 *phInstance = (LVM_Handle_t)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA], 511 sizeof(LVM_Instance_t)); 512 pInstance =(LVM_Instance_t *)*phInstance; 513 514 515 /* 516 * Save the memory table, parameters and capabilities 517 */ 518 pInstance->MemoryTable = *pMemoryTable; 519 pInstance->InstParams = *pInstParams; 520 521 522 /* 523 * Set the bundle scratch memory and initialse the buffer management 524 */ 525 InternalBlockSize = (LVM_UINT16)((pInstParams->MaxBlockSize) & MIN_INTERNAL_BLOCKMASK); /* Force to a multiple of MIN_INTERNAL_BLOCKSIZE */ 526 if (InternalBlockSize < MIN_INTERNAL_BLOCKSIZE) 527 { 528 InternalBlockSize = MIN_INTERNAL_BLOCKSIZE; 529 } 530 531 /* Maximum Internal Black Size should not be more than MAX_INTERNAL_BLOCKSIZE*/ 532 if(InternalBlockSize > MAX_INTERNAL_BLOCKSIZE) 533 { 534 InternalBlockSize = MAX_INTERNAL_BLOCKSIZE; 535 } 536 pInstance->InternalBlockSize = (LVM_INT16)InternalBlockSize; 537 538 539 /* 540 * Common settings for managed and unmanaged buffers 541 */ 542 pInstance->SamplesToProcess = 0; /* No samples left to process */ 543 if (pInstParams->BufferMode == LVM_MANAGED_BUFFERS) 544 { 545 /* 546 * Managed buffers required 547 */ 548 pInstance->pBufferManagement = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA], 549 sizeof(LVM_Buffer_t)); 550 BundleScratchSize = (LVM_INT32)(6 * (MIN_INTERNAL_BLOCKSIZE + InternalBlockSize) * sizeof(LVM_INT16)); 551 pInstance->pBufferManagement->pScratch = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], /* Scratch 1 buffer */ 552 (LVM_UINT32)BundleScratchSize); 553 #ifdef BUILD_FLOAT 554 LoadConst_Float(0, /* Clear the input delay buffer */ 555 (LVM_FLOAT *)&pInstance->pBufferManagement->InDelayBuffer, 556 (LVM_INT16)(2 * MIN_INTERNAL_BLOCKSIZE)); 557 #else 558 LoadConst_16(0, /* Clear the input delay buffer */ 559 (LVM_INT16 *)&pInstance->pBufferManagement->InDelayBuffer, 560 (LVM_INT16)(2 * MIN_INTERNAL_BLOCKSIZE)); 561 #endif 562 pInstance->pBufferManagement->InDelaySamples = MIN_INTERNAL_BLOCKSIZE; /* Set the number of delay samples */ 563 pInstance->pBufferManagement->OutDelaySamples = 0; /* No samples in the output buffer */ 564 pInstance->pBufferManagement->BufferState = LVM_FIRSTCALL; /* Set the state ready for the first call */ 565 } 566 567 568 /* 569 * Set default parameters 570 */ 571 pInstance->Params.OperatingMode = LVM_MODE_OFF; 572 pInstance->Params.SampleRate = LVM_FS_8000; 573 pInstance->Params.SourceFormat = LVM_MONO; 574 pInstance->Params.SpeakerType = LVM_HEADPHONES; 575 pInstance->Params.VC_EffectLevel = 0; 576 pInstance->Params.VC_Balance = 0; 577 578 /* 579 * Set callback 580 */ 581 pInstance->CallBack = LVM_AlgoCallBack; 582 583 584 /* 585 * DC removal filter 586 */ 587 DC_2I_D16_TRC_WRA_01_Init(&pInstance->DC_RemovalInstance); 588 589 590 /* 591 * Treble Enhancement 592 */ 593 pInstance->pTE_Taps = (LVM_TE_Data_t *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 594 sizeof(LVM_TE_Data_t)); 595 596 pInstance->pTE_State = (LVM_TE_Coefs_t *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 597 sizeof(LVM_TE_Coefs_t)); 598 pInstance->Params.TE_OperatingMode = LVM_TE_OFF; 599 pInstance->Params.TE_EffectLevel = 0; 600 pInstance->TE_Active = LVM_FALSE; 601 602 603 /* 604 * Set the volume control and initialise Current to Target 605 */ 606 pInstance->VC_Volume.MixerStream[0].CallbackParam = 0; 607 pInstance->VC_Volume.MixerStream[0].CallbackSet = 0; 608 pInstance->VC_Volume.MixerStream[0].pCallbackHandle = pInstance; 609 pInstance->VC_Volume.MixerStream[0].pCallBack = LVM_VCCallBack; 610 611 /* In managed buffering, start with low signal level as delay in buffer management causes a click*/ 612 if (pInstParams->BufferMode == LVM_MANAGED_BUFFERS) 613 { 614 #ifdef BUILD_FLOAT 615 LVC_Mixer_Init(&pInstance->VC_Volume.MixerStream[0], 0, 0); 616 #else 617 LVC_Mixer_Init(&pInstance->VC_Volume.MixerStream[0],0,0); 618 #endif 619 } 620 else 621 { 622 #ifdef BUILD_FLOAT 623 LVC_Mixer_Init(&pInstance->VC_Volume.MixerStream[0], LVM_MAXFLOAT, LVM_MAXFLOAT); 624 #else 625 LVC_Mixer_Init(&pInstance->VC_Volume.MixerStream[0],LVM_MAXINT_16,LVM_MAXINT_16); 626 #endif 627 } 628 629 #ifdef BUILD_FLOAT 630 LVC_Mixer_SetTimeConstant(&pInstance->VC_Volume.MixerStream[0],0,LVM_FS_8000,2); 631 #else 632 LVC_Mixer_SetTimeConstant(&pInstance->VC_Volume.MixerStream[0], 0, LVM_FS_8000, 2); 633 #endif 634 635 pInstance->VC_VolumedB = 0; 636 pInstance->VC_AVLFixedVolume = 0; 637 pInstance->VC_Active = LVM_FALSE; 638 639 pInstance->VC_BalanceMix.MixerStream[0].CallbackParam = 0; 640 pInstance->VC_BalanceMix.MixerStream[0].CallbackSet = 0; 641 pInstance->VC_BalanceMix.MixerStream[0].pCallbackHandle = pInstance; 642 pInstance->VC_BalanceMix.MixerStream[0].pCallBack = LVM_VCCallBack; 643 #ifdef BUILD_FLOAT 644 LVC_Mixer_Init(&pInstance->VC_BalanceMix.MixerStream[0], LVM_MAXFLOAT, LVM_MAXFLOAT); 645 #else 646 LVC_Mixer_Init(&pInstance->VC_BalanceMix.MixerStream[0],LVM_MAXINT_16,LVM_MAXINT_16); 647 #endif 648 LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[0],LVM_VC_MIXER_TIME,LVM_FS_8000,2); 649 650 pInstance->VC_BalanceMix.MixerStream[1].CallbackParam = 0; 651 pInstance->VC_BalanceMix.MixerStream[1].CallbackSet = 0; 652 pInstance->VC_BalanceMix.MixerStream[1].pCallbackHandle = pInstance; 653 pInstance->VC_BalanceMix.MixerStream[1].pCallBack = LVM_VCCallBack; 654 #ifdef BUILD_FLOAT 655 LVC_Mixer_Init(&pInstance->VC_BalanceMix.MixerStream[1], LVM_MAXFLOAT, LVM_MAXFLOAT); 656 #else 657 LVC_Mixer_Init(&pInstance->VC_BalanceMix.MixerStream[1],LVM_MAXINT_16,LVM_MAXINT_16); 658 #endif 659 LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[1],LVM_VC_MIXER_TIME,LVM_FS_8000,2); 660 661 /* 662 * Set the default EQNB pre-gain and pointer to the band definitions 663 */ 664 pInstance->pEQNB_BandDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 665 (pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t))); 666 pInstance->pEQNB_UserDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 667 (pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t))); 668 669 670 /* 671 * Initialise the Concert Sound module 672 */ 673 { 674 LVCS_Handle_t hCSInstance; /* Instance handle */ 675 LVCS_MemTab_t CS_MemTab; /* Memory table */ 676 LVCS_Capabilities_t CS_Capabilities; /* Initial capabilities */ 677 LVCS_ReturnStatus_en LVCS_Status; /* Function call status */ 678 679 /* 680 * Set default parameters 681 */ 682 pInstance->Params.VirtualizerReverbLevel = 100; 683 pInstance->Params.VirtualizerType = LVM_CONCERTSOUND; 684 pInstance->Params.VirtualizerOperatingMode = LVM_MODE_OFF; 685 pInstance->CS_Active = LVM_FALSE; 686 687 /* 688 * Set the initialisation capabilities 689 */ 690 CS_Capabilities.MaxBlockSize = (LVM_UINT16)InternalBlockSize; 691 CS_Capabilities.CallBack = pInstance->CallBack; 692 CS_Capabilities.pBundleInstance = (void*)pInstance; 693 694 695 /* 696 * Get the memory requirements and then set the address pointers, forcing alignment 697 */ 698 LVCS_Status = LVCS_Memory(LVM_NULL, /* Get the memory requirements */ 699 &CS_MemTab, 700 &CS_Capabilities); 701 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_SLOW_DATA].pBaseAddress = &pInstance->CS_Instance; 702 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 703 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].Size); 704 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 705 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].Size); 706 CS_MemTab.Region[LVCS_MEMREGION_TEMPORARY_FAST].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], 707 0); 708 709 /* 710 * Initialise the Concert Sound instance and save the instance handle 711 */ 712 hCSInstance = LVM_NULL; /* Set to NULL to return handle */ 713 LVCS_Status = LVCS_Init(&hCSInstance, /* Initiailse */ 714 &CS_MemTab, 715 &CS_Capabilities); 716 if (LVCS_Status != LVCS_SUCCESS) return((LVM_ReturnStatus_en)LVCS_Status); 717 pInstance->hCSInstance = hCSInstance; /* Save the instance handle */ 718 719 } 720 721 /* 722 * Initialise the Bass Enhancement module 723 */ 724 { 725 LVDBE_Handle_t hDBEInstance; /* Instance handle */ 726 LVDBE_MemTab_t DBE_MemTab; /* Memory table */ 727 LVDBE_Capabilities_t DBE_Capabilities; /* Initial capabilities */ 728 LVDBE_ReturnStatus_en LVDBE_Status; /* Function call status */ 729 730 731 /* 732 * Set the initialisation parameters 733 */ 734 pInstance->Params.BE_OperatingMode = LVM_BE_OFF; 735 pInstance->Params.BE_CentreFreq = LVM_BE_CENTRE_55Hz; 736 pInstance->Params.BE_EffectLevel = 0; 737 pInstance->Params.BE_HPF = LVM_BE_HPF_OFF; 738 739 pInstance->DBE_Active = LVM_FALSE; 740 741 742 743 /* 744 * Set the initialisation capabilities 745 */ 746 #if defined(BUILD_FLOAT) && defined(HIGHER_FS) 747 DBE_Capabilities.SampleRate = LVDBE_CAP_FS_8000 | LVDBE_CAP_FS_11025 | LVDBE_CAP_FS_12000 | LVDBE_CAP_FS_16000 | LVDBE_CAP_FS_22050 | LVDBE_CAP_FS_24000 | LVDBE_CAP_FS_32000 | LVDBE_CAP_FS_44100 | LVDBE_CAP_FS_48000 | LVDBE_CAP_FS_96000 | LVDBE_CAP_FS_192000; 748 #else 749 DBE_Capabilities.SampleRate = LVDBE_CAP_FS_8000 | LVDBE_CAP_FS_11025 | LVDBE_CAP_FS_12000 | LVDBE_CAP_FS_16000 | LVDBE_CAP_FS_22050 | LVDBE_CAP_FS_24000 | LVDBE_CAP_FS_32000 | LVDBE_CAP_FS_44100 | LVDBE_CAP_FS_48000; 750 #endif 751 DBE_Capabilities.CentreFrequency = LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_66Hz | LVDBE_CAP_CENTRE_78Hz | LVDBE_CAP_CENTRE_90Hz; 752 DBE_Capabilities.MaxBlockSize = (LVM_UINT16)InternalBlockSize; 753 754 755 /* 756 * Get the memory requirements and then set the address pointers 757 */ 758 LVDBE_Status = LVDBE_Memory(LVM_NULL, /* Get the memory requirements */ 759 &DBE_MemTab, 760 &DBE_Capabilities); 761 DBE_MemTab.Region[LVDBE_MEMREGION_INSTANCE].pBaseAddress = &pInstance->DBE_Instance; 762 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 763 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_DATA].Size); 764 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 765 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_COEF].Size); 766 DBE_MemTab.Region[LVDBE_MEMREGION_SCRATCH].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], 767 0); 768 769 770 /* 771 * Initialise the Dynamic Bass Enhancement instance and save the instance handle 772 */ 773 hDBEInstance = LVM_NULL; /* Set to NULL to return handle */ 774 LVDBE_Status = LVDBE_Init(&hDBEInstance, /* Initiailse */ 775 &DBE_MemTab, 776 &DBE_Capabilities); 777 if (LVDBE_Status != LVDBE_SUCCESS) return((LVM_ReturnStatus_en)LVDBE_Status); 778 pInstance->hDBEInstance = hDBEInstance; /* Save the instance handle */ 779 } 780 781 782 /* 783 * Initialise the N-Band Equaliser module 784 */ 785 { 786 LVEQNB_Handle_t hEQNBInstance; /* Instance handle */ 787 LVEQNB_MemTab_t EQNB_MemTab; /* Memory table */ 788 LVEQNB_Capabilities_t EQNB_Capabilities; /* Initial capabilities */ 789 LVEQNB_ReturnStatus_en LVEQNB_Status; /* Function call status */ 790 791 792 /* 793 * Set the initialisation parameters 794 */ 795 pInstance->Params.EQNB_OperatingMode = LVM_EQNB_OFF; 796 pInstance->Params.EQNB_NBands = 0; 797 pInstance->Params.pEQNB_BandDefinition = LVM_NULL; 798 pInstance->EQNB_Active = LVM_FALSE; 799 800 801 /* 802 * Set the initialisation capabilities 803 */ 804 #if defined(BUILD_FLOAT) && defined(HIGHER_FS) 805 EQNB_Capabilities.SampleRate = LVEQNB_CAP_FS_8000 | LVEQNB_CAP_FS_11025 | LVEQNB_CAP_FS_12000 | LVEQNB_CAP_FS_16000 | LVEQNB_CAP_FS_22050 | LVEQNB_CAP_FS_24000 | LVEQNB_CAP_FS_32000 | LVEQNB_CAP_FS_44100 | LVEQNB_CAP_FS_48000 | LVEQNB_CAP_FS_96000 | LVEQNB_CAP_FS_192000; 806 #else 807 EQNB_Capabilities.SampleRate = LVEQNB_CAP_FS_8000 | LVEQNB_CAP_FS_11025 | LVEQNB_CAP_FS_12000 | LVEQNB_CAP_FS_16000 | LVEQNB_CAP_FS_22050 | LVEQNB_CAP_FS_24000 | LVEQNB_CAP_FS_32000 | LVEQNB_CAP_FS_44100 | LVEQNB_CAP_FS_48000; 808 #endif 809 EQNB_Capabilities.MaxBlockSize = (LVM_UINT16)InternalBlockSize; 810 EQNB_Capabilities.MaxBands = pInstParams->EQNB_NumBands; 811 EQNB_Capabilities.SourceFormat = LVEQNB_CAP_STEREO | LVEQNB_CAP_MONOINSTEREO; 812 EQNB_Capabilities.CallBack = pInstance->CallBack; 813 EQNB_Capabilities.pBundleInstance = (void*)pInstance; 814 815 816 /* 817 * Get the memory requirements and then set the address pointers, forcing alignment 818 */ 819 LVEQNB_Status = LVEQNB_Memory(LVM_NULL, /* Get the memory requirements */ 820 &EQNB_MemTab, 821 &EQNB_Capabilities); 822 EQNB_MemTab.Region[LVEQNB_MEMREGION_INSTANCE].pBaseAddress = &pInstance->EQNB_Instance; 823 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 824 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_DATA].Size); 825 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 826 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_COEF].Size); 827 EQNB_MemTab.Region[LVEQNB_MEMREGION_SCRATCH].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], 828 0); 829 830 831 /* 832 * Initialise the Dynamic Bass Enhancement instance and save the instance handle 833 */ 834 hEQNBInstance = LVM_NULL; /* Set to NULL to return handle */ 835 LVEQNB_Status = LVEQNB_Init(&hEQNBInstance, /* Initiailse */ 836 &EQNB_MemTab, 837 &EQNB_Capabilities); 838 if (LVEQNB_Status != LVEQNB_SUCCESS) return((LVM_ReturnStatus_en)LVEQNB_Status); 839 pInstance->hEQNBInstance = hEQNBInstance; /* Save the instance handle */ 840 } 841 842 /* 843 * Headroom management memory allocation 844 */ 845 { 846 pInstance->pHeadroom_BandDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 847 (LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t))); 848 pInstance->pHeadroom_UserDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 849 (LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t))); 850 851 /* Headroom management parameters initialisation */ 852 pInstance->NewHeadroomParams.NHeadroomBands = 2; 853 pInstance->NewHeadroomParams.pHeadroomDefinition = pInstance->pHeadroom_BandDefs; 854 pInstance->NewHeadroomParams.pHeadroomDefinition[0].Limit_Low = 20; 855 pInstance->NewHeadroomParams.pHeadroomDefinition[0].Limit_High = 4999; 856 pInstance->NewHeadroomParams.pHeadroomDefinition[0].Headroom_Offset = 3; 857 pInstance->NewHeadroomParams.pHeadroomDefinition[1].Limit_Low = 5000; 858 pInstance->NewHeadroomParams.pHeadroomDefinition[1].Limit_High = 24000; 859 pInstance->NewHeadroomParams.pHeadroomDefinition[1].Headroom_Offset = 4; 860 pInstance->NewHeadroomParams.Headroom_OperatingMode = LVM_HEADROOM_ON; 861 862 pInstance->Headroom =0; 863 } 864 865 866 /* 867 * Initialise the PSA module 868 */ 869 { 870 pLVPSA_Handle_t hPSAInstance = LVM_NULL; /* Instance handle */ 871 LVPSA_MemTab_t PSA_MemTab; 872 LVPSA_RETURN PSA_Status; /* Function call status */ 873 LVPSA_FilterParam_t FiltersParams[9]; 874 875 if(pInstParams->PSA_Included==LVM_PSA_ON) 876 { 877 pInstance->PSA_InitParams.SpectralDataBufferDuration = (LVM_UINT16) 500; 878 pInstance->PSA_InitParams.MaxInputBlockSize = (LVM_UINT16) 2048; 879 pInstance->PSA_InitParams.nBands = (LVM_UINT16) 9; 880 pInstance->PSA_InitParams.pFiltersParams = &FiltersParams[0]; 881 for(i = 0; i < pInstance->PSA_InitParams.nBands; i++) 882 { 883 FiltersParams[i].CenterFrequency = (LVM_UINT16) 1000; 884 FiltersParams[i].QFactor = (LVM_UINT16) 100; 885 FiltersParams[i].PostGain = (LVM_INT16) 0; 886 } 887 888 /*Get the memory requirements and then set the address pointers*/ 889 PSA_Status = LVPSA_Memory (hPSAInstance, 890 &PSA_MemTab, 891 &pInstance->PSA_InitParams); 892 893 if (PSA_Status != LVPSA_OK) 894 { 895 return((LVM_ReturnStatus_en) LVM_ALGORITHMPSA); 896 } 897 898 /* Slow Data */ 899 PSA_MemTab.Region[LVM_PERSISTENT_SLOW_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA], 900 PSA_MemTab.Region[LVM_PERSISTENT_SLOW_DATA].Size); 901 902 903 /* Fast Data */ 904 PSA_MemTab.Region[LVM_PERSISTENT_FAST_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 905 PSA_MemTab.Region[LVM_PERSISTENT_FAST_DATA].Size); 906 907 908 /* Fast Coef */ 909 PSA_MemTab.Region[LVM_PERSISTENT_FAST_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 910 PSA_MemTab.Region[LVM_PERSISTENT_FAST_COEF].Size); 911 912 /* Fast Temporary */ 913 #ifdef BUILD_FLOAT 914 pInstance->pPSAInput = InstAlloc_AddMember(&AllocMem[LVM_TEMPORARY_FAST], 915 (LVM_UINT32) MAX_INTERNAL_BLOCKSIZE * \ 916 sizeof(LVM_FLOAT)); 917 #else 918 pInstance->pPSAInput = InstAlloc_AddMember(&AllocMem[LVM_TEMPORARY_FAST], 919 (LVM_UINT32) MAX_INTERNAL_BLOCKSIZE * sizeof(LVM_INT16)); 920 #endif 921 PSA_MemTab.Region[LVM_TEMPORARY_FAST].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST],0); 922 923 924 /*Initialise PSA instance and save the instance handle*/ 925 pInstance->PSA_ControlParams.Fs = LVM_FS_48000; 926 pInstance->PSA_ControlParams.LevelDetectionSpeed = LVPSA_SPEED_MEDIUM; 927 PSA_Status = LVPSA_Init (&hPSAInstance, 928 &pInstance->PSA_InitParams, 929 &pInstance->PSA_ControlParams, 930 &PSA_MemTab); 931 932 if (PSA_Status != LVPSA_OK) 933 { 934 return((LVM_ReturnStatus_en) LVM_ALGORITHMPSA); 935 } 936 937 pInstance->hPSAInstance = hPSAInstance; /* Save the instance handle */ 938 pInstance->PSA_GainOffset = 0; 939 } 940 else 941 { 942 pInstance->hPSAInstance = LVM_NULL; 943 } 944 945 /* 946 * Set the initialisation parameters. 947 */ 948 pInstance->Params.PSA_PeakDecayRate = LVM_PSA_SPEED_MEDIUM; 949 pInstance->Params.PSA_Enable = LVM_PSA_OFF; 950 } 951 952 /* 953 * Copy the initial parameters to the new parameters for correct readback of 954 * the settings. 955 */ 956 pInstance->NewParams = pInstance->Params; 957 958 959 /* 960 * Create configuration number 961 */ 962 pInstance->ConfigurationNumber = 0x00000000; 963 pInstance->ConfigurationNumber += LVM_CS_MASK; 964 pInstance->ConfigurationNumber += LVM_EQNB_MASK; 965 pInstance->ConfigurationNumber += LVM_DBE_MASK; 966 pInstance->ConfigurationNumber += LVM_VC_MASK; 967 pInstance->ConfigurationNumber += LVM_PSA_MASK; 968 969 if(((pInstance->ConfigurationNumber & LVM_CS_MASK)!=0) || 970 ((pInstance->ConfigurationNumber & LVM_DBE_MASK)!=0) || 971 ((pInstance->ConfigurationNumber & LVM_EQNB_MASK)!=0)|| 972 ((pInstance->ConfigurationNumber & LVM_TE_MASK)!=0) || 973 ((pInstance->ConfigurationNumber & LVM_VC_MASK)!=0)) 974 { 975 pInstance->BlickSizeMultiple = 4; 976 } 977 else 978 { 979 pInstance->BlickSizeMultiple = 1; 980 } 981 982 return(Status); 983 } 984 985 986 /****************************************************************************************/ 987 /* */ 988 /* FUNCTION: LVM_ClearAudioBuffers */ 989 /* */ 990 /* DESCRIPTION: */ 991 /* This function is used to clear the internal audio buffers of the bundle. */ 992 /* */ 993 /* PARAMETERS: */ 994 /* hInstance Instance handle */ 995 /* */ 996 /* RETURNS: */ 997 /* LVM_SUCCESS Initialisation succeeded */ 998 /* LVM_NULLADDRESS Instance or scratch memory has a NULL pointer */ 999 /* */ 1000 /* NOTES: */ 1001 /* 1. This function must not be interrupted by the LVM_Process function */ 1002 /* */ 1003 /****************************************************************************************/ 1004 1005 LVM_ReturnStatus_en LVM_ClearAudioBuffers(LVM_Handle_t hInstance) 1006 { 1007 LVM_MemTab_t MemTab; /* Memory table */ 1008 LVM_InstParams_t InstParams; /* Instance parameters */ 1009 LVM_ControlParams_t Params; /* Control Parameters */ 1010 LVM_Instance_t *pInstance = (LVM_Instance_t *)hInstance; /* Pointer to Instance */ 1011 LVM_HeadroomParams_t HeadroomParams; 1012 1013 1014 if(hInstance == LVM_NULL){ 1015 return LVM_NULLADDRESS; 1016 } 1017 1018 /* Save the control parameters */ /* coverity[unchecked_value] */ /* Do not check return value internal function calls */ 1019 LVM_GetControlParameters(hInstance, &Params); 1020 1021 /*Save the headroom parameters*/ 1022 LVM_GetHeadroomParams(hInstance, &HeadroomParams); 1023 1024 /* Retrieve allocated buffers in memtab */ 1025 LVM_GetMemoryTable(hInstance, &MemTab, LVM_NULL); 1026 1027 /* Save the instance parameters */ 1028 InstParams = pInstance->InstParams; 1029 1030 /* Call LVM_GetInstanceHandle to re-initialise the bundle */ 1031 LVM_GetInstanceHandle( &hInstance, 1032 &MemTab, 1033 &InstParams); 1034 1035 /* Restore control parameters */ /* coverity[unchecked_value] */ /* Do not check return value internal function calls */ 1036 LVM_SetControlParameters(hInstance, &Params); 1037 1038 /*Restore the headroom parameters*/ 1039 LVM_SetHeadroomParams(hInstance, &HeadroomParams); 1040 1041 /* DC removal filter */ 1042 DC_2I_D16_TRC_WRA_01_Init(&pInstance->DC_RemovalInstance); 1043 1044 return LVM_SUCCESS; 1045 } 1046 1047 1048 1049
