LVM_Init.c revision aa1c402d4ed471dfd0863f73f40a776be258419e
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 64LVM_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 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; 236 DBE_Capabilities.CentreFrequency = LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_66Hz | LVDBE_CAP_CENTRE_78Hz | LVDBE_CAP_CENTRE_90Hz; 237 DBE_Capabilities.MaxBlockSize = InternalBlockSize; 238 239 /* 240 * Get the memory requirements 241 */ 242 LVDBE_Memory(LVM_NULL, 243 &DBE_MemTab, 244 245 &DBE_Capabilities); 246 /* 247 * Update the bundle table 248 */ 249 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 250 DBE_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size); 251 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 252 DBE_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size); 253 if (DBE_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size > AlgScratchSize) AlgScratchSize = DBE_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size; 254 255 } 256 257 258 /* 259 * N-Band equaliser requirements 260 */ 261 { 262 LVEQNB_MemTab_t EQNB_MemTab; /* For N-Band Equaliser */ 263 LVEQNB_Capabilities_t EQNB_Capabilities; 264 265 /* 266 * Set the capabilities 267 */ 268 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; 269 EQNB_Capabilities.SourceFormat = LVEQNB_CAP_STEREO | LVEQNB_CAP_MONOINSTEREO; 270 EQNB_Capabilities.MaxBlockSize = InternalBlockSize; 271 EQNB_Capabilities.MaxBands = pInstParams->EQNB_NumBands; 272 273 /* 274 * Get the memory requirements 275 */ 276 LVEQNB_Memory(LVM_NULL, 277 &EQNB_MemTab, 278 &EQNB_Capabilities); 279 280 /* 281 * Update the bundle table 282 */ 283 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 284 EQNB_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size); 285 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 286 EQNB_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size); 287 if (EQNB_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size > AlgScratchSize) AlgScratchSize = EQNB_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size; 288 289 } 290 291 /* 292 * Headroom management memory allocation 293 */ 294 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 295 (LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t))); 296 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 297 (LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t))); 298 299 300 /* 301 * Spectrum Analyzer memory requirements 302 */ 303 { 304 pLVPSA_Handle_t hPSAInst = LVM_NULL; 305 LVPSA_MemTab_t PSA_MemTab; 306 LVPSA_InitParams_t PSA_InitParams; 307 LVPSA_FilterParam_t FiltersParams[9]; 308 LVPSA_RETURN PSA_Status; 309 310 if(pInstParams->PSA_Included == LVM_PSA_ON) 311 { 312 PSA_InitParams.SpectralDataBufferDuration = (LVM_UINT16) 500; 313 PSA_InitParams.MaxInputBlockSize = (LVM_UINT16) 1000; 314 PSA_InitParams.nBands = (LVM_UINT16) 9; 315 316 PSA_InitParams.pFiltersParams = &FiltersParams[0]; 317 for(i = 0; i < PSA_InitParams.nBands; i++) 318 { 319 FiltersParams[i].CenterFrequency = (LVM_UINT16) 1000; 320 FiltersParams[i].QFactor = (LVM_UINT16) 25; 321 FiltersParams[i].PostGain = (LVM_INT16) 0; 322 } 323 324 /* 325 * Get the memory requirements 326 */ 327 PSA_Status = LVPSA_Memory (hPSAInst, 328 &PSA_MemTab, 329 &PSA_InitParams); 330 331 if (PSA_Status != LVPSA_OK) 332 { 333 return((LVM_ReturnStatus_en) LVM_ALGORITHMPSA); 334 } 335 336 /* 337 * Update the bundle table 338 */ 339 /* Slow Data */ 340 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA], 341 PSA_MemTab.Region[LVM_PERSISTENT_SLOW_DATA].Size); 342 343 /* Fast Data */ 344 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 345 PSA_MemTab.Region[LVM_PERSISTENT_FAST_DATA].Size); 346 347 /* Fast Coef */ 348 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 349 PSA_MemTab.Region[LVM_PERSISTENT_FAST_COEF].Size); 350 351 /* Fast Temporary */ 352 InstAlloc_AddMember(&AllocMem[LVM_TEMPORARY_FAST], 353 MAX_INTERNAL_BLOCKSIZE * sizeof(LVM_INT16)); 354 355 if (PSA_MemTab.Region[LVM_TEMPORARY_FAST].Size > AlgScratchSize) 356 { 357 AlgScratchSize = PSA_MemTab.Region[LVM_TEMPORARY_FAST].Size; 358 } 359 } 360 } 361 362 /* 363 * Return the memory table 364 */ 365 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_SLOW_DATA].Size = InstAlloc_GetTotal(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA]); 366 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_SLOW_DATA].Type = LVM_PERSISTENT_SLOW_DATA; 367 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_SLOW_DATA].pBaseAddress = LVM_NULL; 368 369 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size = InstAlloc_GetTotal(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA]); 370 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Type = LVM_PERSISTENT_FAST_DATA; 371 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].pBaseAddress = LVM_NULL; 372 if (pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size < 4) 373 { 374 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size = 0; 375 } 376 377 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size = InstAlloc_GetTotal(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF]); 378 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Type = LVM_PERSISTENT_FAST_COEF; 379 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].pBaseAddress = LVM_NULL; 380 if (pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size < 4) 381 { 382 pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size = 0; 383 } 384 385 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], 386 AlgScratchSize); 387 pMemoryTable->Region[LVM_MEMREGION_TEMPORARY_FAST].Size = InstAlloc_GetTotal(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST]); 388 pMemoryTable->Region[LVM_MEMREGION_TEMPORARY_FAST].Type = LVM_TEMPORARY_FAST; 389 pMemoryTable->Region[LVM_MEMREGION_TEMPORARY_FAST].pBaseAddress = LVM_NULL; 390 if (pMemoryTable->Region[LVM_MEMREGION_TEMPORARY_FAST].Size < 4) 391 { 392 pMemoryTable->Region[LVM_MEMREGION_TEMPORARY_FAST].Size = 0; 393 } 394 395 return(LVM_SUCCESS); 396 397} 398 399 400/****************************************************************************************/ 401/* */ 402/* FUNCTION: LVM_GetInstanceHandle */ 403/* */ 404/* DESCRIPTION: */ 405/* This function is used to create a bundle instance. It returns the created instance */ 406/* handle through phInstance. All parameters are set to their default, inactive state. */ 407/* */ 408/* PARAMETERS: */ 409/* phInstance pointer to the instance handle */ 410/* pMemoryTable Pointer to the memory definition table */ 411/* pInstParams Pointer to the initialisation capabilities */ 412/* */ 413/* RETURNS: */ 414/* LVM_SUCCESS Initialisation succeeded */ 415/* LVM_OUTOFRANGE When any of the Instance parameters are out of range */ 416/* LVM_NULLADDRESS When one of phInstance, pMemoryTable or pInstParams are NULL*/ 417/* */ 418/* NOTES: */ 419/* 1. This function must not be interrupted by the LVM_Process function */ 420/* */ 421/****************************************************************************************/ 422 423LVM_ReturnStatus_en LVM_GetInstanceHandle(LVM_Handle_t *phInstance, 424 LVM_MemTab_t *pMemoryTable, 425 LVM_InstParams_t *pInstParams) 426{ 427 428 LVM_ReturnStatus_en Status = LVM_SUCCESS; 429 LVM_Instance_t *pInstance; 430 INST_ALLOC AllocMem[LVM_NR_MEMORY_REGIONS]; 431 LVM_INT16 i; 432 LVM_UINT16 InternalBlockSize; 433 LVM_INT32 BundleScratchSize; 434 435 436 /* 437 * Check valid points have been given 438 */ 439 if ((phInstance == LVM_NULL) || (pMemoryTable == LVM_NULL) || (pInstParams == LVM_NULL)) 440 { 441 return (LVM_NULLADDRESS); 442 } 443 444 /* 445 * Check the memory table for NULL pointers 446 */ 447 for (i=0; i<LVM_NR_MEMORY_REGIONS; i++) 448 { 449 if ((pMemoryTable->Region[i].Size != 0) && 450 (pMemoryTable->Region[i].pBaseAddress==LVM_NULL)) 451 { 452 return(LVM_NULLADDRESS); 453 } 454 } 455 456 /* 457 * Check the instance parameters 458 */ 459 if( (pInstParams->BufferMode != LVM_MANAGED_BUFFERS) && (pInstParams->BufferMode != LVM_UNMANAGED_BUFFERS) ) 460 { 461 return (LVM_OUTOFRANGE); 462 } 463 464 if( pInstParams->EQNB_NumBands > 32 ) 465 { 466 return (LVM_OUTOFRANGE); 467 } 468 469 if(pInstParams->BufferMode == LVM_MANAGED_BUFFERS) 470 { 471 if( (pInstParams->MaxBlockSize < LVM_MIN_MAXBLOCKSIZE ) || (pInstParams->MaxBlockSize > LVM_MANAGED_MAX_MAXBLOCKSIZE ) ) 472 { 473 return (LVM_OUTOFRANGE); 474 } 475 } 476 else 477 { 478 if( (pInstParams->MaxBlockSize < LVM_MIN_MAXBLOCKSIZE ) || (pInstParams->MaxBlockSize > LVM_UNMANAGED_MAX_MAXBLOCKSIZE) ) 479 { 480 return (LVM_OUTOFRANGE); 481 } 482 } 483 484 if(pInstParams->PSA_Included > LVM_PSA_ON) 485 { 486 return (LVM_OUTOFRANGE); 487 } 488 489 /* 490 * Initialise the AllocMem structures 491 */ 492 for (i=0; i<LVM_NR_MEMORY_REGIONS; i++) 493 { 494 InstAlloc_Init(&AllocMem[i], 495 pMemoryTable->Region[i].pBaseAddress); 496 } 497 498 499 /* 500 * Set the instance handle 501 */ 502 *phInstance = (LVM_Handle_t)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA], 503 sizeof(LVM_Instance_t)); 504 pInstance =(LVM_Instance_t *)*phInstance; 505 506 507 /* 508 * Save the memory table, parameters and capabilities 509 */ 510 pInstance->MemoryTable = *pMemoryTable; 511 pInstance->InstParams = *pInstParams; 512 513 514 /* 515 * Set the bundle scratch memory and initialse the buffer management 516 */ 517 InternalBlockSize = (LVM_UINT16)((pInstParams->MaxBlockSize) & MIN_INTERNAL_BLOCKMASK); /* Force to a multiple of MIN_INTERNAL_BLOCKSIZE */ 518 if (InternalBlockSize < MIN_INTERNAL_BLOCKSIZE) 519 { 520 InternalBlockSize = MIN_INTERNAL_BLOCKSIZE; 521 } 522 523 /* Maximum Internal Black Size should not be more than MAX_INTERNAL_BLOCKSIZE*/ 524 if(InternalBlockSize > MAX_INTERNAL_BLOCKSIZE) 525 { 526 InternalBlockSize = MAX_INTERNAL_BLOCKSIZE; 527 } 528 pInstance->InternalBlockSize = (LVM_INT16)InternalBlockSize; 529 530 531 /* 532 * Common settings for managed and unmanaged buffers 533 */ 534 pInstance->SamplesToProcess = 0; /* No samples left to process */ 535 if (pInstParams->BufferMode == LVM_MANAGED_BUFFERS) 536 { 537 /* 538 * Managed buffers required 539 */ 540 pInstance->pBufferManagement = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA], 541 sizeof(LVM_Buffer_t)); 542 BundleScratchSize = (LVM_INT32)(6 * (MIN_INTERNAL_BLOCKSIZE + InternalBlockSize) * sizeof(LVM_INT16)); 543 pInstance->pBufferManagement->pScratch = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], /* Scratch 1 buffer */ 544 (LVM_UINT32)BundleScratchSize); 545 546 LoadConst_16(0, /* Clear the input delay buffer */ 547 (LVM_INT16 *)&pInstance->pBufferManagement->InDelayBuffer, 548 (LVM_INT16)(2 * MIN_INTERNAL_BLOCKSIZE)); 549 pInstance->pBufferManagement->InDelaySamples = MIN_INTERNAL_BLOCKSIZE; /* Set the number of delay samples */ 550 pInstance->pBufferManagement->OutDelaySamples = 0; /* No samples in the output buffer */ 551 pInstance->pBufferManagement->BufferState = LVM_FIRSTCALL; /* Set the state ready for the first call */ 552 } 553 554 555 /* 556 * Set default parameters 557 */ 558 pInstance->Params.OperatingMode = LVM_MODE_OFF; 559 pInstance->Params.SampleRate = LVM_FS_8000; 560 pInstance->Params.SourceFormat = LVM_MONO; 561 pInstance->Params.SpeakerType = LVM_HEADPHONES; 562 pInstance->Params.VC_EffectLevel = 0; 563 pInstance->Params.VC_Balance = 0; 564 565 /* 566 * Set callback 567 */ 568 pInstance->CallBack = LVM_AlgoCallBack; 569 570 571 /* 572 * DC removal filter 573 */ 574 DC_2I_D16_TRC_WRA_01_Init(&pInstance->DC_RemovalInstance); 575 576 577 /* 578 * Treble Enhancement 579 */ 580 pInstance->pTE_Taps = (LVM_TE_Data_t *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 581 sizeof(LVM_TE_Data_t)); 582 583 pInstance->pTE_State = (LVM_TE_Coefs_t *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 584 sizeof(LVM_TE_Coefs_t)); 585 pInstance->Params.TE_OperatingMode = LVM_TE_OFF; 586 pInstance->Params.TE_EffectLevel = 0; 587 pInstance->TE_Active = LVM_FALSE; 588 589 590 /* 591 * Set the volume control and initialise Current to Target 592 */ 593 pInstance->VC_Volume.MixerStream[0].CallbackParam = 0; 594 pInstance->VC_Volume.MixerStream[0].CallbackSet = 0; 595 pInstance->VC_Volume.MixerStream[0].pCallbackHandle = pInstance; 596 pInstance->VC_Volume.MixerStream[0].pCallBack = LVM_VCCallBack; 597 598 /* In managed buffering, start with low signal level as delay in buffer management causes a click*/ 599 if (pInstParams->BufferMode == LVM_MANAGED_BUFFERS) 600 { 601 LVC_Mixer_Init(&pInstance->VC_Volume.MixerStream[0],0,0); 602 } 603 else 604 { 605 LVC_Mixer_Init(&pInstance->VC_Volume.MixerStream[0],LVM_MAXINT_16,LVM_MAXINT_16); 606 } 607 608 LVC_Mixer_SetTimeConstant(&pInstance->VC_Volume.MixerStream[0],0,LVM_FS_8000,2); 609 610 pInstance->VC_VolumedB = 0; 611 pInstance->VC_AVLFixedVolume = 0; 612 pInstance->VC_Active = LVM_FALSE; 613 614 pInstance->VC_BalanceMix.MixerStream[0].CallbackParam = 0; 615 pInstance->VC_BalanceMix.MixerStream[0].CallbackSet = 0; 616 pInstance->VC_BalanceMix.MixerStream[0].pCallbackHandle = pInstance; 617 pInstance->VC_BalanceMix.MixerStream[0].pCallBack = LVM_VCCallBack; 618 LVC_Mixer_Init(&pInstance->VC_BalanceMix.MixerStream[0],LVM_MAXINT_16,LVM_MAXINT_16); 619 LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[0],LVM_VC_MIXER_TIME,LVM_FS_8000,2); 620 621 pInstance->VC_BalanceMix.MixerStream[1].CallbackParam = 0; 622 pInstance->VC_BalanceMix.MixerStream[1].CallbackSet = 0; 623 pInstance->VC_BalanceMix.MixerStream[1].pCallbackHandle = pInstance; 624 pInstance->VC_BalanceMix.MixerStream[1].pCallBack = LVM_VCCallBack; 625 LVC_Mixer_Init(&pInstance->VC_BalanceMix.MixerStream[1],LVM_MAXINT_16,LVM_MAXINT_16); 626 LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[1],LVM_VC_MIXER_TIME,LVM_FS_8000,2); 627 /* 628 * Set the default EQNB pre-gain and pointer to the band definitions 629 */ 630 pInstance->pEQNB_BandDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 631 (pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t))); 632 pInstance->pEQNB_UserDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 633 (pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t))); 634 635 636 /* 637 * Initialise the Concert Sound module 638 */ 639 { 640 LVCS_Handle_t hCSInstance; /* Instance handle */ 641 LVCS_MemTab_t CS_MemTab; /* Memory table */ 642 LVCS_Capabilities_t CS_Capabilities; /* Initial capabilities */ 643 LVCS_ReturnStatus_en LVCS_Status; /* Function call status */ 644 645 /* 646 * Set default parameters 647 */ 648 pInstance->Params.VirtualizerReverbLevel = 100; 649 pInstance->Params.VirtualizerType = LVM_CONCERTSOUND; 650 pInstance->Params.VirtualizerOperatingMode = LVM_MODE_OFF; 651 pInstance->CS_Active = LVM_FALSE; 652 653 /* 654 * Set the initialisation capabilities 655 */ 656 CS_Capabilities.MaxBlockSize = (LVM_UINT16)InternalBlockSize; 657 CS_Capabilities.CallBack = pInstance->CallBack; 658 CS_Capabilities.pBundleInstance = (void*)pInstance; 659 660 661 /* 662 * Get the memory requirements and then set the address pointers, forcing alignment 663 */ 664 LVCS_Status = LVCS_Memory(LVM_NULL, /* Get the memory requirements */ 665 &CS_MemTab, 666 &CS_Capabilities); 667 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_SLOW_DATA].pBaseAddress = &pInstance->CS_Instance; 668 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 669 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].Size); 670 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 671 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].Size); 672 CS_MemTab.Region[LVCS_MEMREGION_TEMPORARY_FAST].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], 673 0); 674 675 /* 676 * Initialise the Concert Sound instance and save the instance handle 677 */ 678 hCSInstance = LVM_NULL; /* Set to NULL to return handle */ 679 LVCS_Status = LVCS_Init(&hCSInstance, /* Initiailse */ 680 &CS_MemTab, 681 &CS_Capabilities); 682 if (LVCS_Status != LVCS_SUCCESS) return((LVM_ReturnStatus_en)LVCS_Status); 683 pInstance->hCSInstance = hCSInstance; /* Save the instance handle */ 684 685 } 686 687 /* 688 * Initialise the Bass Enhancement module 689 */ 690 { 691 LVDBE_Handle_t hDBEInstance; /* Instance handle */ 692 LVDBE_MemTab_t DBE_MemTab; /* Memory table */ 693 LVDBE_Capabilities_t DBE_Capabilities; /* Initial capabilities */ 694 LVDBE_ReturnStatus_en LVDBE_Status; /* Function call status */ 695 696 697 /* 698 * Set the initialisation parameters 699 */ 700 pInstance->Params.BE_OperatingMode = LVM_BE_OFF; 701 pInstance->Params.BE_CentreFreq = LVM_BE_CENTRE_55Hz; 702 pInstance->Params.BE_EffectLevel = 0; 703 pInstance->Params.BE_HPF = LVM_BE_HPF_OFF; 704 705 pInstance->DBE_Active = LVM_FALSE; 706 707 708 709 /* 710 * Set the initialisation capabilities 711 */ 712 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; 713 DBE_Capabilities.CentreFrequency = LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_66Hz | LVDBE_CAP_CENTRE_78Hz | LVDBE_CAP_CENTRE_90Hz; 714 DBE_Capabilities.MaxBlockSize = (LVM_UINT16)InternalBlockSize; 715 716 717 /* 718 * Get the memory requirements and then set the address pointers 719 */ 720 LVDBE_Status = LVDBE_Memory(LVM_NULL, /* Get the memory requirements */ 721 &DBE_MemTab, 722 &DBE_Capabilities); 723 DBE_MemTab.Region[LVDBE_MEMREGION_INSTANCE].pBaseAddress = &pInstance->DBE_Instance; 724 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 725 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_DATA].Size); 726 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 727 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_COEF].Size); 728 DBE_MemTab.Region[LVDBE_MEMREGION_SCRATCH].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], 729 0); 730 731 732 /* 733 * Initialise the Dynamic Bass Enhancement instance and save the instance handle 734 */ 735 hDBEInstance = LVM_NULL; /* Set to NULL to return handle */ 736 LVDBE_Status = LVDBE_Init(&hDBEInstance, /* Initiailse */ 737 &DBE_MemTab, 738 &DBE_Capabilities); 739 if (LVDBE_Status != LVDBE_SUCCESS) return((LVM_ReturnStatus_en)LVDBE_Status); 740 pInstance->hDBEInstance = hDBEInstance; /* Save the instance handle */ 741 } 742 743 744 /* 745 * Initialise the N-Band Equaliser module 746 */ 747 { 748 LVEQNB_Handle_t hEQNBInstance; /* Instance handle */ 749 LVEQNB_MemTab_t EQNB_MemTab; /* Memory table */ 750 LVEQNB_Capabilities_t EQNB_Capabilities; /* Initial capabilities */ 751 LVEQNB_ReturnStatus_en LVEQNB_Status; /* Function call status */ 752 753 754 /* 755 * Set the initialisation parameters 756 */ 757 pInstance->Params.EQNB_OperatingMode = LVM_EQNB_OFF; 758 pInstance->Params.EQNB_NBands = 0; 759 pInstance->Params.pEQNB_BandDefinition = LVM_NULL; 760 pInstance->EQNB_Active = LVM_FALSE; 761 762 763 /* 764 * Set the initialisation capabilities 765 */ 766 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; 767 EQNB_Capabilities.MaxBlockSize = (LVM_UINT16)InternalBlockSize; 768 EQNB_Capabilities.MaxBands = pInstParams->EQNB_NumBands; 769 EQNB_Capabilities.SourceFormat = LVEQNB_CAP_STEREO | LVEQNB_CAP_MONOINSTEREO; 770 EQNB_Capabilities.CallBack = pInstance->CallBack; 771 EQNB_Capabilities.pBundleInstance = (void*)pInstance; 772 773 774 /* 775 * Get the memory requirements and then set the address pointers, forcing alignment 776 */ 777 LVEQNB_Status = LVEQNB_Memory(LVM_NULL, /* Get the memory requirements */ 778 &EQNB_MemTab, 779 &EQNB_Capabilities); 780 EQNB_MemTab.Region[LVEQNB_MEMREGION_INSTANCE].pBaseAddress = &pInstance->EQNB_Instance; 781 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 782 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_DATA].Size); 783 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 784 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_COEF].Size); 785 EQNB_MemTab.Region[LVEQNB_MEMREGION_SCRATCH].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], 786 0); 787 788 789 /* 790 * Initialise the Dynamic Bass Enhancement instance and save the instance handle 791 */ 792 hEQNBInstance = LVM_NULL; /* Set to NULL to return handle */ 793 LVEQNB_Status = LVEQNB_Init(&hEQNBInstance, /* Initiailse */ 794 &EQNB_MemTab, 795 &EQNB_Capabilities); 796 if (LVEQNB_Status != LVEQNB_SUCCESS) return((LVM_ReturnStatus_en)LVEQNB_Status); 797 pInstance->hEQNBInstance = hEQNBInstance; /* Save the instance handle */ 798 } 799 800 /* 801 * Headroom management memory allocation 802 */ 803 { 804 pInstance->pHeadroom_BandDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 805 (LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t))); 806 pInstance->pHeadroom_UserDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 807 (LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t))); 808 809 /* Headroom management parameters initialisation */ 810 pInstance->NewHeadroomParams.NHeadroomBands = 2; 811 pInstance->NewHeadroomParams.pHeadroomDefinition = pInstance->pHeadroom_BandDefs; 812 pInstance->NewHeadroomParams.pHeadroomDefinition[0].Limit_Low = 20; 813 pInstance->NewHeadroomParams.pHeadroomDefinition[0].Limit_High = 4999; 814 pInstance->NewHeadroomParams.pHeadroomDefinition[0].Headroom_Offset = 3; 815 pInstance->NewHeadroomParams.pHeadroomDefinition[1].Limit_Low = 5000; 816 pInstance->NewHeadroomParams.pHeadroomDefinition[1].Limit_High = 24000; 817 pInstance->NewHeadroomParams.pHeadroomDefinition[1].Headroom_Offset = 4; 818 pInstance->NewHeadroomParams.Headroom_OperatingMode = LVM_HEADROOM_ON; 819 820 pInstance->Headroom =0; 821 } 822 823 824 /* 825 * Initialise the PSA module 826 */ 827 { 828 pLVPSA_Handle_t hPSAInstance = LVM_NULL; /* Instance handle */ 829 LVPSA_MemTab_t PSA_MemTab; 830 LVPSA_RETURN PSA_Status; /* Function call status */ 831 LVPSA_FilterParam_t FiltersParams[9]; 832 833 if(pInstParams->PSA_Included==LVM_PSA_ON) 834 { 835 pInstance->PSA_InitParams.SpectralDataBufferDuration = (LVM_UINT16) 500; 836 pInstance->PSA_InitParams.MaxInputBlockSize = (LVM_UINT16) 2048; 837 pInstance->PSA_InitParams.nBands = (LVM_UINT16) 9; 838 pInstance->PSA_InitParams.pFiltersParams = &FiltersParams[0]; 839 for(i = 0; i < pInstance->PSA_InitParams.nBands; i++) 840 { 841 FiltersParams[i].CenterFrequency = (LVM_UINT16) 1000; 842 FiltersParams[i].QFactor = (LVM_UINT16) 100; 843 FiltersParams[i].PostGain = (LVM_INT16) 0; 844 } 845 846 /*Get the memory requirements and then set the address pointers*/ 847 PSA_Status = LVPSA_Memory (hPSAInstance, 848 &PSA_MemTab, 849 &pInstance->PSA_InitParams); 850 851 if (PSA_Status != LVPSA_OK) 852 { 853 return((LVM_ReturnStatus_en) LVM_ALGORITHMPSA); 854 } 855 856 /* Slow Data */ 857 PSA_MemTab.Region[LVM_PERSISTENT_SLOW_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA], 858 PSA_MemTab.Region[LVM_PERSISTENT_SLOW_DATA].Size); 859 860 861 /* Fast Data */ 862 PSA_MemTab.Region[LVM_PERSISTENT_FAST_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 863 PSA_MemTab.Region[LVM_PERSISTENT_FAST_DATA].Size); 864 865 866 /* Fast Coef */ 867 PSA_MemTab.Region[LVM_PERSISTENT_FAST_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 868 PSA_MemTab.Region[LVM_PERSISTENT_FAST_COEF].Size); 869 870 /* Fast Temporary */ 871 pInstance->pPSAInput = InstAlloc_AddMember(&AllocMem[LVM_TEMPORARY_FAST], 872 (LVM_UINT32) MAX_INTERNAL_BLOCKSIZE * sizeof(LVM_INT16)); 873 874 PSA_MemTab.Region[LVM_TEMPORARY_FAST].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST],0); 875 876 877 /*Initialise PSA instance and save the instance handle*/ 878 pInstance->PSA_ControlParams.Fs = LVM_FS_48000; 879 pInstance->PSA_ControlParams.LevelDetectionSpeed = LVPSA_SPEED_MEDIUM; 880 PSA_Status = LVPSA_Init (&hPSAInstance, 881 &pInstance->PSA_InitParams, 882 &pInstance->PSA_ControlParams, 883 &PSA_MemTab); 884 885 if (PSA_Status != LVPSA_OK) 886 { 887 return((LVM_ReturnStatus_en) LVM_ALGORITHMPSA); 888 } 889 890 pInstance->hPSAInstance = hPSAInstance; /* Save the instance handle */ 891 pInstance->PSA_GainOffset = 0; 892 } 893 else 894 { 895 pInstance->hPSAInstance = LVM_NULL; 896 } 897 898 /* 899 * Set the initialisation parameters. 900 */ 901 pInstance->Params.PSA_PeakDecayRate = LVM_PSA_SPEED_MEDIUM; 902 pInstance->Params.PSA_Enable = LVM_PSA_OFF; 903 } 904 905 /* 906 * Copy the initial parameters to the new parameters for correct readback of 907 * the settings. 908 */ 909 pInstance->NewParams = pInstance->Params; 910 911 912 /* 913 * Create configuration number 914 */ 915 pInstance->ConfigurationNumber = 0x00000000; 916 pInstance->ConfigurationNumber += LVM_CS_MASK; 917 pInstance->ConfigurationNumber += LVM_EQNB_MASK; 918 pInstance->ConfigurationNumber += LVM_DBE_MASK; 919 pInstance->ConfigurationNumber += LVM_VC_MASK; 920 pInstance->ConfigurationNumber += LVM_PSA_MASK; 921 922 if(((pInstance->ConfigurationNumber & LVM_CS_MASK)!=0) || 923 ((pInstance->ConfigurationNumber & LVM_DBE_MASK)!=0) || 924 ((pInstance->ConfigurationNumber & LVM_EQNB_MASK)!=0)|| 925 ((pInstance->ConfigurationNumber & LVM_TE_MASK)!=0) || 926 ((pInstance->ConfigurationNumber & LVM_VC_MASK)!=0)) 927 { 928 pInstance->BlickSizeMultiple = 4; 929 } 930 else 931 { 932 pInstance->BlickSizeMultiple = 1; 933 } 934 935 return(Status); 936} 937 938 939/****************************************************************************************/ 940/* */ 941/* FUNCTION: LVM_ClearAudioBuffers */ 942/* */ 943/* DESCRIPTION: */ 944/* This function is used to clear the internal audio buffers of the bundle. */ 945/* */ 946/* PARAMETERS: */ 947/* hInstance Instance handle */ 948/* */ 949/* RETURNS: */ 950/* LVM_SUCCESS Initialisation succeeded */ 951/* LVM_NULLADDRESS Instance or scratch memory has a NULL pointer */ 952/* */ 953/* NOTES: */ 954/* 1. This function must not be interrupted by the LVM_Process function */ 955/* */ 956/****************************************************************************************/ 957 958LVM_ReturnStatus_en LVM_ClearAudioBuffers(LVM_Handle_t hInstance) 959{ 960 LVM_MemTab_t MemTab; /* Memory table */ 961 LVM_InstParams_t InstParams; /* Instance parameters */ 962 LVM_ControlParams_t Params; /* Control Parameters */ 963 LVM_Instance_t *pInstance = (LVM_Instance_t *)hInstance; /* Pointer to Instance */ 964 LVM_HeadroomParams_t HeadroomParams; 965 966 967 if(hInstance == LVM_NULL){ 968 return LVM_NULLADDRESS; 969 } 970 971 /* Save the control parameters */ /* coverity[unchecked_value] */ /* Do not check return value internal function calls */ 972 LVM_GetControlParameters(hInstance, &Params); 973 974 /*Save the headroom parameters*/ 975 LVM_GetHeadroomParams(hInstance, &HeadroomParams); 976 977 /* Retrieve allocated buffers in memtab */ 978 LVM_GetMemoryTable(hInstance, &MemTab, LVM_NULL); 979 980 /* Save the instance parameters */ 981 InstParams = pInstance->InstParams; 982 983 /* Call LVM_GetInstanceHandle to re-initialise the bundle */ 984 LVM_GetInstanceHandle( &hInstance, 985 &MemTab, 986 &InstParams); 987 988 /* Restore control parameters */ /* coverity[unchecked_value] */ /* Do not check return value internal function calls */ 989 LVM_SetControlParameters(hInstance, &Params); 990 991 /*Restore the headroom parameters*/ 992 LVM_SetHeadroomParams(hInstance, &HeadroomParams); 993 994 /* DC removal filter */ 995 DC_2I_D16_TRC_WRA_01_Init(&pInstance->DC_RemovalInstance); 996 997 998 return LVM_SUCCESS; 999} 1000 1001 1002 1003