LVM_Init.c revision e44615ff6022239850a3ea459ad6e07b44c37544
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// FIXME: Workaround to avoid reset of headroom parameters on first call to LVM_Process. 561// pInstance->Params.SourceFormat = LVM_MONO; 562 pInstance->Params.SourceFormat = LVM_STEREO; 563 pInstance->Params.SpeakerType = LVM_HEADPHONES; 564 pInstance->Params.VC_EffectLevel = 0; 565 pInstance->Params.VC_Balance = 0; 566 567 /* 568 * Set callback 569 */ 570 pInstance->CallBack = LVM_AlgoCallBack; 571 572 573 /* 574 * DC removal filter 575 */ 576 DC_2I_D16_TRC_WRA_01_Init(&pInstance->DC_RemovalInstance); 577 578 579 /* 580 * Treble Enhancement 581 */ 582 pInstance->pTE_Taps = (LVM_TE_Data_t *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 583 sizeof(LVM_TE_Data_t)); 584 585 pInstance->pTE_State = (LVM_TE_Coefs_t *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 586 sizeof(LVM_TE_Coefs_t)); 587 pInstance->Params.TE_OperatingMode = LVM_TE_OFF; 588 pInstance->Params.TE_EffectLevel = 0; 589 pInstance->TE_Active = LVM_FALSE; 590 591 592 /* 593 * Set the volume control and initialise Current to Target 594 */ 595 pInstance->VC_Volume.MixerStream[0].CallbackParam = 0; 596 pInstance->VC_Volume.MixerStream[0].CallbackSet = 0; 597 pInstance->VC_Volume.MixerStream[0].pCallbackHandle = pInstance; 598 pInstance->VC_Volume.MixerStream[0].pCallBack = LVM_VCCallBack; 599 600 /* In managed buffering, start with low signal level as delay in buffer management causes a click*/ 601 if (pInstParams->BufferMode == LVM_MANAGED_BUFFERS) 602 { 603 LVC_Mixer_Init(&pInstance->VC_Volume.MixerStream[0],0,0); 604 } 605 else 606 { 607 LVC_Mixer_Init(&pInstance->VC_Volume.MixerStream[0],LVM_MAXINT_16,LVM_MAXINT_16); 608 } 609 610 LVC_Mixer_SetTimeConstant(&pInstance->VC_Volume.MixerStream[0],0,LVM_FS_8000,2); 611 612 pInstance->VC_VolumedB = 0; 613 pInstance->VC_AVLFixedVolume = 0; 614 pInstance->VC_Active = LVM_FALSE; 615 616 pInstance->VC_BalanceMix.MixerStream[0].CallbackParam = 0; 617 pInstance->VC_BalanceMix.MixerStream[0].CallbackSet = 0; 618 pInstance->VC_BalanceMix.MixerStream[0].pCallbackHandle = pInstance; 619 pInstance->VC_BalanceMix.MixerStream[0].pCallBack = LVM_VCCallBack; 620 LVC_Mixer_Init(&pInstance->VC_BalanceMix.MixerStream[0],LVM_MAXINT_16,LVM_MAXINT_16); 621 LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[0],LVM_VC_MIXER_TIME,LVM_FS_8000,2); 622 623 pInstance->VC_BalanceMix.MixerStream[1].CallbackParam = 0; 624 pInstance->VC_BalanceMix.MixerStream[1].CallbackSet = 0; 625 pInstance->VC_BalanceMix.MixerStream[1].pCallbackHandle = pInstance; 626 pInstance->VC_BalanceMix.MixerStream[1].pCallBack = LVM_VCCallBack; 627 LVC_Mixer_Init(&pInstance->VC_BalanceMix.MixerStream[1],LVM_MAXINT_16,LVM_MAXINT_16); 628 LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[1],LVM_VC_MIXER_TIME,LVM_FS_8000,2); 629 /* 630 * Set the default EQNB pre-gain and pointer to the band definitions 631 */ 632 pInstance->pEQNB_BandDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 633 (pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t))); 634 pInstance->pEQNB_UserDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 635 (pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t))); 636 637 638 /* 639 * Initialise the Concert Sound module 640 */ 641 { 642 LVCS_Handle_t hCSInstance; /* Instance handle */ 643 LVCS_MemTab_t CS_MemTab; /* Memory table */ 644 LVCS_Capabilities_t CS_Capabilities; /* Initial capabilities */ 645 LVCS_ReturnStatus_en LVCS_Status; /* Function call status */ 646 647 /* 648 * Set default parameters 649 */ 650 pInstance->Params.VirtualizerReverbLevel = 100; 651 pInstance->Params.VirtualizerType = LVM_CONCERTSOUND; 652 pInstance->Params.VirtualizerOperatingMode = LVM_MODE_OFF; 653 pInstance->CS_Active = LVM_FALSE; 654 655 /* 656 * Set the initialisation capabilities 657 */ 658 CS_Capabilities.MaxBlockSize = (LVM_UINT16)InternalBlockSize; 659 CS_Capabilities.CallBack = pInstance->CallBack; 660 CS_Capabilities.pBundleInstance = (void*)pInstance; 661 662 663 /* 664 * Get the memory requirements and then set the address pointers, forcing alignment 665 */ 666 LVCS_Status = LVCS_Memory(LVM_NULL, /* Get the memory requirements */ 667 &CS_MemTab, 668 &CS_Capabilities); 669 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_SLOW_DATA].pBaseAddress = &pInstance->CS_Instance; 670 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 671 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].Size); 672 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 673 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].Size); 674 CS_MemTab.Region[LVCS_MEMREGION_TEMPORARY_FAST].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], 675 0); 676 677 /* 678 * Initialise the Concert Sound instance and save the instance handle 679 */ 680 hCSInstance = LVM_NULL; /* Set to NULL to return handle */ 681 LVCS_Status = LVCS_Init(&hCSInstance, /* Initiailse */ 682 &CS_MemTab, 683 &CS_Capabilities); 684 if (LVCS_Status != LVCS_SUCCESS) return((LVM_ReturnStatus_en)LVCS_Status); 685 pInstance->hCSInstance = hCSInstance; /* Save the instance handle */ 686 687 } 688 689 /* 690 * Initialise the Bass Enhancement module 691 */ 692 { 693 LVDBE_Handle_t hDBEInstance; /* Instance handle */ 694 LVDBE_MemTab_t DBE_MemTab; /* Memory table */ 695 LVDBE_Capabilities_t DBE_Capabilities; /* Initial capabilities */ 696 LVDBE_ReturnStatus_en LVDBE_Status; /* Function call status */ 697 698 699 /* 700 * Set the initialisation parameters 701 */ 702 pInstance->Params.BE_OperatingMode = LVM_BE_OFF; 703 pInstance->Params.BE_CentreFreq = LVM_BE_CENTRE_55Hz; 704 pInstance->Params.BE_EffectLevel = 0; 705 pInstance->Params.BE_HPF = LVM_BE_HPF_OFF; 706 707 pInstance->DBE_Active = LVM_FALSE; 708 709 710 711 /* 712 * Set the initialisation capabilities 713 */ 714 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; 715 DBE_Capabilities.CentreFrequency = LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_66Hz | LVDBE_CAP_CENTRE_78Hz | LVDBE_CAP_CENTRE_90Hz; 716 DBE_Capabilities.MaxBlockSize = (LVM_UINT16)InternalBlockSize; 717 718 719 /* 720 * Get the memory requirements and then set the address pointers 721 */ 722 LVDBE_Status = LVDBE_Memory(LVM_NULL, /* Get the memory requirements */ 723 &DBE_MemTab, 724 &DBE_Capabilities); 725 DBE_MemTab.Region[LVDBE_MEMREGION_INSTANCE].pBaseAddress = &pInstance->DBE_Instance; 726 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 727 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_DATA].Size); 728 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 729 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_COEF].Size); 730 DBE_MemTab.Region[LVDBE_MEMREGION_SCRATCH].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], 731 0); 732 733 734 /* 735 * Initialise the Dynamic Bass Enhancement instance and save the instance handle 736 */ 737 hDBEInstance = LVM_NULL; /* Set to NULL to return handle */ 738 LVDBE_Status = LVDBE_Init(&hDBEInstance, /* Initiailse */ 739 &DBE_MemTab, 740 &DBE_Capabilities); 741 if (LVDBE_Status != LVDBE_SUCCESS) return((LVM_ReturnStatus_en)LVDBE_Status); 742 pInstance->hDBEInstance = hDBEInstance; /* Save the instance handle */ 743 } 744 745 746 /* 747 * Initialise the N-Band Equaliser module 748 */ 749 { 750 LVEQNB_Handle_t hEQNBInstance; /* Instance handle */ 751 LVEQNB_MemTab_t EQNB_MemTab; /* Memory table */ 752 LVEQNB_Capabilities_t EQNB_Capabilities; /* Initial capabilities */ 753 LVEQNB_ReturnStatus_en LVEQNB_Status; /* Function call status */ 754 755 756 /* 757 * Set the initialisation parameters 758 */ 759 pInstance->Params.EQNB_OperatingMode = LVM_EQNB_OFF; 760 pInstance->Params.EQNB_NBands = 0; 761 pInstance->Params.pEQNB_BandDefinition = LVM_NULL; 762 pInstance->EQNB_Active = LVM_FALSE; 763 764 765 /* 766 * Set the initialisation capabilities 767 */ 768 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; 769 EQNB_Capabilities.MaxBlockSize = (LVM_UINT16)InternalBlockSize; 770 EQNB_Capabilities.MaxBands = pInstParams->EQNB_NumBands; 771 EQNB_Capabilities.SourceFormat = LVEQNB_CAP_STEREO | LVEQNB_CAP_MONOINSTEREO; 772 EQNB_Capabilities.CallBack = pInstance->CallBack; 773 EQNB_Capabilities.pBundleInstance = (void*)pInstance; 774 775 776 /* 777 * Get the memory requirements and then set the address pointers, forcing alignment 778 */ 779 LVEQNB_Status = LVEQNB_Memory(LVM_NULL, /* Get the memory requirements */ 780 &EQNB_MemTab, 781 &EQNB_Capabilities); 782 EQNB_MemTab.Region[LVEQNB_MEMREGION_INSTANCE].pBaseAddress = &pInstance->EQNB_Instance; 783 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 784 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_DATA].Size); 785 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 786 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_COEF].Size); 787 EQNB_MemTab.Region[LVEQNB_MEMREGION_SCRATCH].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], 788 0); 789 790 791 /* 792 * Initialise the Dynamic Bass Enhancement instance and save the instance handle 793 */ 794 hEQNBInstance = LVM_NULL; /* Set to NULL to return handle */ 795 LVEQNB_Status = LVEQNB_Init(&hEQNBInstance, /* Initiailse */ 796 &EQNB_MemTab, 797 &EQNB_Capabilities); 798 if (LVEQNB_Status != LVEQNB_SUCCESS) return((LVM_ReturnStatus_en)LVEQNB_Status); 799 pInstance->hEQNBInstance = hEQNBInstance; /* Save the instance handle */ 800 } 801 802 /* 803 * Headroom management memory allocation 804 */ 805 { 806 pInstance->pHeadroom_BandDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 807 (LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t))); 808 pInstance->pHeadroom_UserDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 809 (LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t))); 810 811 /* Headroom management parameters initialisation */ 812 pInstance->NewHeadroomParams.NHeadroomBands = 2; 813 pInstance->NewHeadroomParams.pHeadroomDefinition = pInstance->pHeadroom_BandDefs; 814 pInstance->NewHeadroomParams.pHeadroomDefinition[0].Limit_Low = 20; 815 pInstance->NewHeadroomParams.pHeadroomDefinition[0].Limit_High = 4999; 816 pInstance->NewHeadroomParams.pHeadroomDefinition[0].Headroom_Offset = 3; 817 pInstance->NewHeadroomParams.pHeadroomDefinition[1].Limit_Low = 5000; 818 pInstance->NewHeadroomParams.pHeadroomDefinition[1].Limit_High = 24000; 819 pInstance->NewHeadroomParams.pHeadroomDefinition[1].Headroom_Offset = 4; 820 pInstance->NewHeadroomParams.Headroom_OperatingMode = LVM_HEADROOM_ON; 821 822 pInstance->Headroom =0; 823 } 824 825 826 /* 827 * Initialise the PSA module 828 */ 829 { 830 pLVPSA_Handle_t hPSAInstance = LVM_NULL; /* Instance handle */ 831 LVPSA_MemTab_t PSA_MemTab; 832 LVPSA_RETURN PSA_Status; /* Function call status */ 833 LVPSA_FilterParam_t FiltersParams[9]; 834 835 if(pInstParams->PSA_Included==LVM_PSA_ON) 836 { 837 pInstance->PSA_InitParams.SpectralDataBufferDuration = (LVM_UINT16) 500; 838 pInstance->PSA_InitParams.MaxInputBlockSize = (LVM_UINT16) 2048; 839 pInstance->PSA_InitParams.nBands = (LVM_UINT16) 9; 840 pInstance->PSA_InitParams.pFiltersParams = &FiltersParams[0]; 841 for(i = 0; i < pInstance->PSA_InitParams.nBands; i++) 842 { 843 FiltersParams[i].CenterFrequency = (LVM_UINT16) 1000; 844 FiltersParams[i].QFactor = (LVM_UINT16) 100; 845 FiltersParams[i].PostGain = (LVM_INT16) 0; 846 } 847 848 /*Get the memory requirements and then set the address pointers*/ 849 PSA_Status = LVPSA_Memory (hPSAInstance, 850 &PSA_MemTab, 851 &pInstance->PSA_InitParams); 852 853 if (PSA_Status != LVPSA_OK) 854 { 855 return((LVM_ReturnStatus_en) LVM_ALGORITHMPSA); 856 } 857 858 /* Slow Data */ 859 PSA_MemTab.Region[LVM_PERSISTENT_SLOW_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA], 860 PSA_MemTab.Region[LVM_PERSISTENT_SLOW_DATA].Size); 861 862 863 /* Fast Data */ 864 PSA_MemTab.Region[LVM_PERSISTENT_FAST_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 865 PSA_MemTab.Region[LVM_PERSISTENT_FAST_DATA].Size); 866 867 868 /* Fast Coef */ 869 PSA_MemTab.Region[LVM_PERSISTENT_FAST_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 870 PSA_MemTab.Region[LVM_PERSISTENT_FAST_COEF].Size); 871 872 /* Fast Temporary */ 873 pInstance->pPSAInput = InstAlloc_AddMember(&AllocMem[LVM_TEMPORARY_FAST], 874 (LVM_UINT32) MAX_INTERNAL_BLOCKSIZE * sizeof(LVM_INT16)); 875 876 PSA_MemTab.Region[LVM_TEMPORARY_FAST].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST],0); 877 878 879 /*Initialise PSA instance and save the instance handle*/ 880 pInstance->PSA_ControlParams.Fs = LVM_FS_48000; 881 pInstance->PSA_ControlParams.LevelDetectionSpeed = LVPSA_SPEED_MEDIUM; 882 PSA_Status = LVPSA_Init (&hPSAInstance, 883 &pInstance->PSA_InitParams, 884 &pInstance->PSA_ControlParams, 885 &PSA_MemTab); 886 887 if (PSA_Status != LVPSA_OK) 888 { 889 return((LVM_ReturnStatus_en) LVM_ALGORITHMPSA); 890 } 891 892 pInstance->hPSAInstance = hPSAInstance; /* Save the instance handle */ 893 pInstance->PSA_GainOffset = 0; 894 } 895 else 896 { 897 pInstance->hPSAInstance = LVM_NULL; 898 } 899 900 /* 901 * Set the initialisation parameters. 902 */ 903 pInstance->Params.PSA_PeakDecayRate = LVM_PSA_SPEED_MEDIUM; 904 pInstance->Params.PSA_Enable = LVM_PSA_OFF; 905 } 906 907 /* 908 * Copy the initial parameters to the new parameters for correct readback of 909 * the settings. 910 */ 911 pInstance->NewParams = pInstance->Params; 912 913 914 /* 915 * Create configuration number 916 */ 917 pInstance->ConfigurationNumber = 0x00000000; 918 pInstance->ConfigurationNumber += LVM_CS_MASK; 919 pInstance->ConfigurationNumber += LVM_EQNB_MASK; 920 pInstance->ConfigurationNumber += LVM_DBE_MASK; 921 pInstance->ConfigurationNumber += LVM_VC_MASK; 922 pInstance->ConfigurationNumber += LVM_PSA_MASK; 923 924 if(((pInstance->ConfigurationNumber & LVM_CS_MASK)!=0) || 925 ((pInstance->ConfigurationNumber & LVM_DBE_MASK)!=0) || 926 ((pInstance->ConfigurationNumber & LVM_EQNB_MASK)!=0)|| 927 ((pInstance->ConfigurationNumber & LVM_TE_MASK)!=0) || 928 ((pInstance->ConfigurationNumber & LVM_VC_MASK)!=0)) 929 { 930 pInstance->BlickSizeMultiple = 4; 931 } 932 else 933 { 934 pInstance->BlickSizeMultiple = 1; 935 } 936 937 return(Status); 938} 939 940 941/****************************************************************************************/ 942/* */ 943/* FUNCTION: LVM_ClearAudioBuffers */ 944/* */ 945/* DESCRIPTION: */ 946/* This function is used to clear the internal audio buffers of the bundle. */ 947/* */ 948/* PARAMETERS: */ 949/* hInstance Instance handle */ 950/* */ 951/* RETURNS: */ 952/* LVM_SUCCESS Initialisation succeeded */ 953/* LVM_NULLADDRESS Instance or scratch memory has a NULL pointer */ 954/* */ 955/* NOTES: */ 956/* 1. This function must not be interrupted by the LVM_Process function */ 957/* */ 958/****************************************************************************************/ 959 960LVM_ReturnStatus_en LVM_ClearAudioBuffers(LVM_Handle_t hInstance) 961{ 962 LVM_MemTab_t MemTab; /* Memory table */ 963 LVM_InstParams_t InstParams; /* Instance parameters */ 964 LVM_ControlParams_t Params; /* Control Parameters */ 965 LVM_Instance_t *pInstance = (LVM_Instance_t *)hInstance; /* Pointer to Instance */ 966 967 968 if(hInstance == LVM_NULL){ 969 return LVM_NULLADDRESS; 970 } 971 972 /* Save the control parameters */ /* coverity[unchecked_value] */ /* Do not check return value internal function calls */ 973 LVM_GetControlParameters(hInstance, &Params); 974 975 /* Retrieve allocated buffers in memtab */ 976 LVM_GetMemoryTable(hInstance, &MemTab, LVM_NULL); 977 978 /* Save the instance parameters */ 979 InstParams = pInstance->InstParams; 980 981 /* Call LVM_GetInstanceHandle to re-initialise the bundle */ 982 LVM_GetInstanceHandle( &hInstance, 983 &MemTab, 984 &InstParams); 985 986 /* Restore control parameters */ /* coverity[unchecked_value] */ /* Do not check return value internal function calls */ 987 LVM_SetControlParameters(hInstance, &Params); 988 989 /* DC removal filter */ 990 DC_2I_D16_TRC_WRA_01_Init(&pInstance->DC_RemovalInstance); 991 992 993 return LVM_SUCCESS; 994} 995 996 997 998