LVM_Init.c revision 2c8e5cab3faa6d360e222b7a6c40a80083d021ac
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 $Author: nxp007753 $ 21 $Revision: 1255 $ 22 $Date: 2010-07-16 17:07:29 +0200 (Fri, 16 Jul 2010) $ 23 24*************************************************************************************/ 25 26/************************************************************************************/ 27/* */ 28/* Includes */ 29/* */ 30/************************************************************************************/ 31 32#include "LVM_Private.h" 33#include "LVM_Tables.h" 34#include "VectorArithmetic.h" 35#include "InstAlloc.h" 36 37/****************************************************************************************/ 38/* */ 39/* FUNCTION: LVM_GetMemoryTable */ 40/* */ 41/* DESCRIPTION: */ 42/* This function is used for memory allocation and free. It can be called in */ 43/* two ways: */ 44/* */ 45/* hInstance = NULL Returns the memory requirements */ 46/* hInstance = Instance handle Returns the memory requirements and */ 47/* allocated base addresses for the instance */ 48/* */ 49/* When this function is called for memory allocation (hInstance=NULL) the memory */ 50/* base address pointers are NULL on return. */ 51/* */ 52/* When the function is called for free (hInstance = Instance Handle) the memory */ 53/* table returns the allocated memory and base addresses used during initialisation. */ 54/* */ 55/* PARAMETERS: */ 56/* hInstance Instance Handle */ 57/* pMemoryTable Pointer to an empty memory definition table */ 58/* pCapabilities Pointer to the default capabilities */ 59/* */ 60/* RETURNS: */ 61/* LVM_SUCCESS Succeeded */ 62/* LVM_NULLADDRESS When one of pMemoryTable or pInstParams is NULL */ 63/* LVM_OUTOFRANGE When any of the Instance parameters are out of range */ 64/* */ 65/* NOTES: */ 66/* 1. This function may be interrupted by the LVM_Process function */ 67/* 2. The scratch memory is the largest required by any of the sub-modules plus any */ 68/* additional scratch requirements of the bundle */ 69/* */ 70/****************************************************************************************/ 71 72LVM_ReturnStatus_en LVM_GetMemoryTable(LVM_Handle_t hInstance, 73 LVM_MemTab_t *pMemoryTable, 74 LVM_InstParams_t *pInstParams) 75{ 76 77 LVM_Instance_t *pInstance = (LVM_Instance_t *)hInstance; 78 LVM_UINT32 AlgScratchSize; 79 LVM_UINT32 BundleScratchSize; 80 LVM_UINT16 InternalBlockSize; 81 INST_ALLOC AllocMem[LVM_NR_MEMORY_REGIONS]; 82 LVM_INT16 i; 83 84 85 /* 86 * Check parameters 87 */ 88 if(pMemoryTable == LVM_NULL) 89 { 90 return LVM_NULLADDRESS; 91 } 92 93 94 /* 95 * Return memory table if the instance has already been created 96 */ 97 if (hInstance != LVM_NULL) 98 { 99 /* Read back memory allocation table */ 100 *pMemoryTable = pInstance->MemoryTable; 101 return(LVM_SUCCESS); 102 } 103 104 if(pInstParams == LVM_NULL) 105 { 106 return LVM_NULLADDRESS; 107 } 108 109 /* 110 * Power Spectrum Analyser 111 */ 112 if(pInstParams->PSA_Included > LVM_PSA_ON) 113 { 114 return (LVM_OUTOFRANGE); 115 } 116 117 /* 118 * Check the instance parameters 119 */ 120 if( (pInstParams->BufferMode != LVM_MANAGED_BUFFERS) && (pInstParams->BufferMode != LVM_UNMANAGED_BUFFERS) ) 121 { 122 return (LVM_OUTOFRANGE); 123 } 124 125 /* N-Band Equalizer */ 126 if( pInstParams->EQNB_NumBands > 32 ) 127 { 128 return (LVM_OUTOFRANGE); 129 } 130 131 if(pInstParams->BufferMode == LVM_MANAGED_BUFFERS) 132 { 133 if( (pInstParams->MaxBlockSize < LVM_MIN_MAXBLOCKSIZE ) || (pInstParams->MaxBlockSize > LVM_MANAGED_MAX_MAXBLOCKSIZE ) ) 134 { 135 return (LVM_OUTOFRANGE); 136 } 137 } 138 else 139 { 140 if( (pInstParams->MaxBlockSize < LVM_MIN_MAXBLOCKSIZE ) || (pInstParams->MaxBlockSize > LVM_UNMANAGED_MAX_MAXBLOCKSIZE) ) 141 { 142 return (LVM_OUTOFRANGE); 143 } 144 } 145 146 /* 147 * Initialise the AllocMem structures 148 */ 149 for (i=0; i<LVM_NR_MEMORY_REGIONS; i++) 150 { 151 InstAlloc_Init(&AllocMem[i], LVM_NULL); 152 } 153 InternalBlockSize = (LVM_UINT16)((pInstParams->MaxBlockSize) & MIN_INTERNAL_BLOCKMASK); /* Force to a multiple of MIN_INTERNAL_BLOCKSIZE */ 154 155 if (InternalBlockSize < MIN_INTERNAL_BLOCKSIZE) 156 { 157 InternalBlockSize = MIN_INTERNAL_BLOCKSIZE; 158 } 159 160 /* Maximum Internal Black Size should not be more than MAX_INTERNAL_BLOCKSIZE*/ 161 if(InternalBlockSize > MAX_INTERNAL_BLOCKSIZE) 162 { 163 InternalBlockSize = MAX_INTERNAL_BLOCKSIZE; 164 } 165 166 /* 167 * Bundle requirements 168 */ 169 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA], 170 sizeof(LVM_Instance_t)); 171 172 173 /* 174 * Set the algorithm and bundle scratch requirements 175 */ 176 AlgScratchSize = 0; 177 if (pInstParams->BufferMode == LVM_MANAGED_BUFFERS) 178 { 179 BundleScratchSize = 6 * (MIN_INTERNAL_BLOCKSIZE + InternalBlockSize) * sizeof(LVM_INT16); 180 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], /* Scratch buffer */ 181 BundleScratchSize); 182 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA], 183 sizeof(LVM_Buffer_t)); 184 } 185 186 /* 187 * Treble Enhancement requirements 188 */ 189 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 190 sizeof(LVM_TE_Data_t)); 191 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 192 sizeof(LVM_TE_Coefs_t)); 193 194 /* 195 * N-Band Equalizer requirements 196 */ 197 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], /* Local storage */ 198 (pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t))); 199 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], /* User storage */ 200 (pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t))); 201 202 /* 203 * Concert Sound requirements 204 */ 205 { 206 LVCS_MemTab_t CS_MemTab; 207 LVCS_Capabilities_t CS_Capabilities; 208 209 /* 210 * Set the capabilities 211 */ 212 CS_Capabilities.MaxBlockSize = InternalBlockSize; 213 214 /* 215 * Get the memory requirements 216 */ 217 LVCS_Memory(LVM_NULL, 218 &CS_MemTab, 219 &CS_Capabilities); 220 221 /* 222 * Update the memory allocation structures 223 */ 224 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 225 CS_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size); 226 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 227 CS_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size); 228 if (CS_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size > AlgScratchSize) AlgScratchSize = CS_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size; 229 230 } 231 232 233 /* 234 * Dynamic Bass Enhancement requirements 235 */ 236 { 237 LVDBE_MemTab_t DBE_MemTab; 238 LVDBE_Capabilities_t DBE_Capabilities; 239 240 /* 241 * Set the capabilities 242 */ 243 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; 244 DBE_Capabilities.CentreFrequency = LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_66Hz | LVDBE_CAP_CENTRE_78Hz | LVDBE_CAP_CENTRE_90Hz; 245 DBE_Capabilities.MaxBlockSize = InternalBlockSize; 246 247 /* 248 * Get the memory requirements 249 */ 250 LVDBE_Memory(LVM_NULL, 251 &DBE_MemTab, 252 253 &DBE_Capabilities); 254 /* 255 * Update the bundle table 256 */ 257 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 258 DBE_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size); 259 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 260 DBE_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size); 261 if (DBE_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size > AlgScratchSize) AlgScratchSize = DBE_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size; 262 263 } 264 265 266 /* 267 * N-Band equaliser requirements 268 */ 269 { 270 LVEQNB_MemTab_t EQNB_MemTab; /* For N-Band Equaliser */ 271 LVEQNB_Capabilities_t EQNB_Capabilities; 272 273 /* 274 * Set the capabilities 275 */ 276 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; 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 431LVM_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 554 LoadConst_16(0, /* Clear the input delay buffer */ 555 (LVM_INT16 *)&pInstance->pBufferManagement->InDelayBuffer, 556 (LVM_INT16)(2 * MIN_INTERNAL_BLOCKSIZE)); 557 pInstance->pBufferManagement->InDelaySamples = MIN_INTERNAL_BLOCKSIZE; /* Set the number of delay samples */ 558 pInstance->pBufferManagement->OutDelaySamples = 0; /* No samples in the output buffer */ 559 pInstance->pBufferManagement->BufferState = LVM_FIRSTCALL; /* Set the state ready for the first call */ 560 } 561 562 563 /* 564 * Set default parameters 565 */ 566 pInstance->Params.OperatingMode = LVM_MODE_OFF; 567 pInstance->Params.SampleRate = LVM_FS_8000; 568 pInstance->Params.SourceFormat = LVM_MONO; 569 pInstance->Params.SpeakerType = LVM_HEADPHONES; 570 pInstance->Params.VC_EffectLevel = 0; 571 pInstance->Params.VC_Balance = 0; 572 573 /* 574 * Set callback 575 */ 576 pInstance->CallBack = LVM_AlgoCallBack; 577 578 579 /* 580 * DC removal filter 581 */ 582 DC_2I_D16_TRC_WRA_01_Init(&pInstance->DC_RemovalInstance); 583 584 585 /* 586 * Treble Enhancement 587 */ 588 pInstance->pTE_Taps = (LVM_TE_Data_t *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 589 sizeof(LVM_TE_Data_t)); 590 591 pInstance->pTE_State = (LVM_TE_Coefs_t *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 592 sizeof(LVM_TE_Coefs_t)); 593 pInstance->Params.TE_OperatingMode = LVM_TE_OFF; 594 pInstance->Params.TE_EffectLevel = 0; 595 pInstance->TE_Active = LVM_FALSE; 596 597 598 /* 599 * Set the volume control and initialise Current to Target 600 */ 601 pInstance->VC_Volume.MixerStream[0].CallbackParam = 0; 602 pInstance->VC_Volume.MixerStream[0].CallbackSet = 0; 603 pInstance->VC_Volume.MixerStream[0].pCallbackHandle = pInstance; 604 pInstance->VC_Volume.MixerStream[0].pCallBack = LVM_VCCallBack; 605 606 /* In managed buffering, start with low signal level as delay in buffer management causes a click*/ 607 if (pInstParams->BufferMode == LVM_MANAGED_BUFFERS) 608 { 609 LVC_Mixer_Init(&pInstance->VC_Volume.MixerStream[0],0,0); 610 } 611 else 612 { 613 LVC_Mixer_Init(&pInstance->VC_Volume.MixerStream[0],LVM_MAXINT_16,LVM_MAXINT_16); 614 } 615 616 LVC_Mixer_SetTimeConstant(&pInstance->VC_Volume.MixerStream[0],0,LVM_FS_8000,2); 617 618 pInstance->VC_VolumedB = 0; 619 pInstance->VC_AVLFixedVolume = 0; 620 pInstance->VC_Active = LVM_FALSE; 621 622 pInstance->VC_BalanceMix.MixerStream[0].CallbackParam = 0; 623 pInstance->VC_BalanceMix.MixerStream[0].CallbackSet = 0; 624 pInstance->VC_BalanceMix.MixerStream[0].pCallbackHandle = pInstance; 625 pInstance->VC_BalanceMix.MixerStream[0].pCallBack = LVM_VCCallBack; 626 LVC_Mixer_Init(&pInstance->VC_BalanceMix.MixerStream[0],LVM_MAXINT_16,LVM_MAXINT_16); 627 LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[0],LVM_VC_MIXER_TIME,LVM_FS_8000,2); 628 629 pInstance->VC_BalanceMix.MixerStream[1].CallbackParam = 0; 630 pInstance->VC_BalanceMix.MixerStream[1].CallbackSet = 0; 631 pInstance->VC_BalanceMix.MixerStream[1].pCallbackHandle = pInstance; 632 pInstance->VC_BalanceMix.MixerStream[1].pCallBack = LVM_VCCallBack; 633 LVC_Mixer_Init(&pInstance->VC_BalanceMix.MixerStream[1],LVM_MAXINT_16,LVM_MAXINT_16); 634 LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[1],LVM_VC_MIXER_TIME,LVM_FS_8000,2); 635 /* 636 * Set the default EQNB pre-gain and pointer to the band definitions 637 */ 638 pInstance->pEQNB_BandDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 639 (pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t))); 640 pInstance->pEQNB_UserDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 641 (pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t))); 642 643 644 /* 645 * Initialise the Concert Sound module 646 */ 647 { 648 LVCS_Handle_t hCSInstance; /* Instance handle */ 649 LVCS_MemTab_t CS_MemTab; /* Memory table */ 650 LVCS_Capabilities_t CS_Capabilities; /* Initial capabilities */ 651 LVCS_ReturnStatus_en LVCS_Status; /* Function call status */ 652 653 /* 654 * Set default parameters 655 */ 656 pInstance->Params.VirtualizerReverbLevel = 100; 657 pInstance->Params.VirtualizerType = LVM_CONCERTSOUND; 658 pInstance->Params.VirtualizerOperatingMode = LVM_MODE_OFF; 659 pInstance->CS_Active = LVM_FALSE; 660 661 /* 662 * Set the initialisation capabilities 663 */ 664 CS_Capabilities.MaxBlockSize = (LVM_UINT16)InternalBlockSize; 665 CS_Capabilities.CallBack = pInstance->CallBack; 666 CS_Capabilities.pBundleInstance = (void*)pInstance; 667 668 669 /* 670 * Get the memory requirements and then set the address pointers, forcing alignment 671 */ 672 LVCS_Status = LVCS_Memory(LVM_NULL, /* Get the memory requirements */ 673 &CS_MemTab, 674 &CS_Capabilities); 675 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_SLOW_DATA].pBaseAddress = &pInstance->CS_Instance; 676 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 677 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].Size); 678 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 679 CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].Size); 680 CS_MemTab.Region[LVCS_MEMREGION_TEMPORARY_FAST].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], 681 0); 682 683 /* 684 * Initialise the Concert Sound instance and save the instance handle 685 */ 686 hCSInstance = LVM_NULL; /* Set to NULL to return handle */ 687 LVCS_Status = LVCS_Init(&hCSInstance, /* Initiailse */ 688 &CS_MemTab, 689 &CS_Capabilities); 690 if (LVCS_Status != LVCS_SUCCESS) return((LVM_ReturnStatus_en)LVCS_Status); 691 pInstance->hCSInstance = hCSInstance; /* Save the instance handle */ 692 693 } 694 695 /* 696 * Initialise the Bass Enhancement module 697 */ 698 { 699 LVDBE_Handle_t hDBEInstance; /* Instance handle */ 700 LVDBE_MemTab_t DBE_MemTab; /* Memory table */ 701 LVDBE_Capabilities_t DBE_Capabilities; /* Initial capabilities */ 702 LVDBE_ReturnStatus_en LVDBE_Status; /* Function call status */ 703 704 705 /* 706 * Set the initialisation parameters 707 */ 708 pInstance->Params.BE_OperatingMode = LVM_BE_OFF; 709 pInstance->Params.BE_CentreFreq = LVM_BE_CENTRE_55Hz; 710 pInstance->Params.BE_EffectLevel = 0; 711 pInstance->Params.BE_HPF = LVM_BE_HPF_OFF; 712 713 pInstance->DBE_Active = LVM_FALSE; 714 715 716 717 /* 718 * Set the initialisation capabilities 719 */ 720 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; 721 DBE_Capabilities.CentreFrequency = LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_66Hz | LVDBE_CAP_CENTRE_78Hz | LVDBE_CAP_CENTRE_90Hz; 722 DBE_Capabilities.MaxBlockSize = (LVM_UINT16)InternalBlockSize; 723 724 725 /* 726 * Get the memory requirements and then set the address pointers 727 */ 728 LVDBE_Status = LVDBE_Memory(LVM_NULL, /* Get the memory requirements */ 729 &DBE_MemTab, 730 &DBE_Capabilities); 731 DBE_MemTab.Region[LVDBE_MEMREGION_INSTANCE].pBaseAddress = &pInstance->DBE_Instance; 732 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 733 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_DATA].Size); 734 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 735 DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_COEF].Size); 736 DBE_MemTab.Region[LVDBE_MEMREGION_SCRATCH].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], 737 0); 738 739 740 /* 741 * Initialise the Dynamic Bass Enhancement instance and save the instance handle 742 */ 743 hDBEInstance = LVM_NULL; /* Set to NULL to return handle */ 744 LVDBE_Status = LVDBE_Init(&hDBEInstance, /* Initiailse */ 745 &DBE_MemTab, 746 &DBE_Capabilities); 747 if (LVDBE_Status != LVDBE_SUCCESS) return((LVM_ReturnStatus_en)LVDBE_Status); 748 pInstance->hDBEInstance = hDBEInstance; /* Save the instance handle */ 749 } 750 751 752 /* 753 * Initialise the N-Band Equaliser module 754 */ 755 { 756 LVEQNB_Handle_t hEQNBInstance; /* Instance handle */ 757 LVEQNB_MemTab_t EQNB_MemTab; /* Memory table */ 758 LVEQNB_Capabilities_t EQNB_Capabilities; /* Initial capabilities */ 759 LVEQNB_ReturnStatus_en LVEQNB_Status; /* Function call status */ 760 761 762 /* 763 * Set the initialisation parameters 764 */ 765 pInstance->Params.EQNB_OperatingMode = LVM_EQNB_OFF; 766 pInstance->Params.EQNB_NBands = 0; 767 pInstance->Params.pEQNB_BandDefinition = LVM_NULL; 768 pInstance->EQNB_Active = LVM_FALSE; 769 770 771 /* 772 * Set the initialisation capabilities 773 */ 774 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; 775 EQNB_Capabilities.MaxBlockSize = (LVM_UINT16)InternalBlockSize; 776 EQNB_Capabilities.MaxBands = pInstParams->EQNB_NumBands; 777 EQNB_Capabilities.SourceFormat = LVEQNB_CAP_STEREO | LVEQNB_CAP_MONOINSTEREO; 778 EQNB_Capabilities.CallBack = pInstance->CallBack; 779 EQNB_Capabilities.pBundleInstance = (void*)pInstance; 780 781 782 /* 783 * Get the memory requirements and then set the address pointers, forcing alignment 784 */ 785 LVEQNB_Status = LVEQNB_Memory(LVM_NULL, /* Get the memory requirements */ 786 &EQNB_MemTab, 787 &EQNB_Capabilities); 788 EQNB_MemTab.Region[LVEQNB_MEMREGION_INSTANCE].pBaseAddress = &pInstance->EQNB_Instance; 789 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 790 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_DATA].Size); 791 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 792 EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_COEF].Size); 793 EQNB_MemTab.Region[LVEQNB_MEMREGION_SCRATCH].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], 794 0); 795 796 797 /* 798 * Initialise the Dynamic Bass Enhancement instance and save the instance handle 799 */ 800 hEQNBInstance = LVM_NULL; /* Set to NULL to return handle */ 801 LVEQNB_Status = LVEQNB_Init(&hEQNBInstance, /* Initiailse */ 802 &EQNB_MemTab, 803 &EQNB_Capabilities); 804 if (LVEQNB_Status != LVEQNB_SUCCESS) return((LVM_ReturnStatus_en)LVEQNB_Status); 805 pInstance->hEQNBInstance = hEQNBInstance; /* Save the instance handle */ 806 } 807 808 /* 809 * Headroom management memory allocation 810 */ 811 { 812 pInstance->pHeadroom_BandDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 813 (LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t))); 814 pInstance->pHeadroom_UserDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 815 (LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t))); 816 817 /* Headroom management parameters initialisation */ 818 pInstance->NewHeadroomParams.NHeadroomBands = 2; 819 pInstance->NewHeadroomParams.pHeadroomDefinition = pInstance->pHeadroom_BandDefs; 820 pInstance->NewHeadroomParams.pHeadroomDefinition[0].Limit_Low = 20; 821 pInstance->NewHeadroomParams.pHeadroomDefinition[0].Limit_High = 4999; 822 pInstance->NewHeadroomParams.pHeadroomDefinition[0].Headroom_Offset = 3; 823 pInstance->NewHeadroomParams.pHeadroomDefinition[1].Limit_Low = 5000; 824 pInstance->NewHeadroomParams.pHeadroomDefinition[1].Limit_High = 24000; 825 pInstance->NewHeadroomParams.pHeadroomDefinition[1].Headroom_Offset = 4; 826 pInstance->NewHeadroomParams.Headroom_OperatingMode = LVM_HEADROOM_ON; 827 828 pInstance->Headroom =0; 829 } 830 831 832 /* 833 * Initialise the PSA module 834 */ 835 { 836 pLVPSA_Handle_t hPSAInstance = LVM_NULL; /* Instance handle */ 837 LVPSA_MemTab_t PSA_MemTab; 838 LVPSA_RETURN PSA_Status; /* Function call status */ 839 LVPSA_FilterParam_t FiltersParams[9]; 840 841 if(pInstParams->PSA_Included==LVM_PSA_ON) 842 { 843 pInstance->PSA_InitParams.SpectralDataBufferDuration = (LVM_UINT16) 500; 844 pInstance->PSA_InitParams.MaxInputBlockSize = (LVM_UINT16) 2048; 845 pInstance->PSA_InitParams.nBands = (LVM_UINT16) 9; 846 pInstance->PSA_InitParams.pFiltersParams = &FiltersParams[0]; 847 for(i = 0; i < pInstance->PSA_InitParams.nBands; i++) 848 { 849 FiltersParams[i].CenterFrequency = (LVM_UINT16) 1000; 850 FiltersParams[i].QFactor = (LVM_UINT16) 100; 851 FiltersParams[i].PostGain = (LVM_INT16) 0; 852 } 853 854 /*Get the memory requirements and then set the address pointers*/ 855 PSA_Status = LVPSA_Memory (hPSAInstance, 856 &PSA_MemTab, 857 &pInstance->PSA_InitParams); 858 859 if (PSA_Status != LVPSA_OK) 860 { 861 return((LVM_ReturnStatus_en) LVM_ALGORITHMPSA); 862 } 863 864 /* Slow Data */ 865 PSA_MemTab.Region[LVM_PERSISTENT_SLOW_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA], 866 PSA_MemTab.Region[LVM_PERSISTENT_SLOW_DATA].Size); 867 868 869 /* Fast Data */ 870 PSA_MemTab.Region[LVM_PERSISTENT_FAST_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], 871 PSA_MemTab.Region[LVM_PERSISTENT_FAST_DATA].Size); 872 873 874 /* Fast Coef */ 875 PSA_MemTab.Region[LVM_PERSISTENT_FAST_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF], 876 PSA_MemTab.Region[LVM_PERSISTENT_FAST_COEF].Size); 877 878 /* Fast Temporary */ 879 pInstance->pPSAInput = InstAlloc_AddMember(&AllocMem[LVM_TEMPORARY_FAST], 880 (LVM_UINT32) MAX_INTERNAL_BLOCKSIZE * sizeof(LVM_INT16)); 881 882 PSA_MemTab.Region[LVM_TEMPORARY_FAST].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST],0); 883 884 885 /*Initialise PSA instance and save the instance handle*/ 886 pInstance->PSA_ControlParams.Fs = LVM_FS_48000; 887 pInstance->PSA_ControlParams.LevelDetectionSpeed = LVPSA_SPEED_MEDIUM; 888 PSA_Status = LVPSA_Init (&hPSAInstance, 889 &pInstance->PSA_InitParams, 890 &pInstance->PSA_ControlParams, 891 &PSA_MemTab); 892 893 if (PSA_Status != LVPSA_OK) 894 { 895 return((LVM_ReturnStatus_en) LVM_ALGORITHMPSA); 896 } 897 898 pInstance->hPSAInstance = hPSAInstance; /* Save the instance handle */ 899 pInstance->PSA_GainOffset = 0; 900 } 901 else 902 { 903 pInstance->hPSAInstance = LVM_NULL; 904 } 905 906 /* 907 * Set the initialisation parameters. 908 */ 909 pInstance->Params.PSA_PeakDecayRate = LVM_PSA_SPEED_MEDIUM; 910 pInstance->Params.PSA_Enable = LVM_PSA_OFF; 911 } 912 913 /* 914 * Copy the initial parameters to the new parameters for correct readback of 915 * the settings. 916 */ 917 pInstance->NewParams = pInstance->Params; 918 919 920 /* 921 * Create configuration number 922 */ 923 pInstance->ConfigurationNumber = 0x00000000; 924 pInstance->ConfigurationNumber += LVM_CS_MASK; 925 pInstance->ConfigurationNumber += LVM_EQNB_MASK; 926 pInstance->ConfigurationNumber += LVM_DBE_MASK; 927 pInstance->ConfigurationNumber += LVM_VC_MASK; 928 pInstance->ConfigurationNumber += LVM_PSA_MASK; 929 930 if(((pInstance->ConfigurationNumber & LVM_CS_MASK)!=0) || 931 ((pInstance->ConfigurationNumber & LVM_DBE_MASK)!=0) || 932 ((pInstance->ConfigurationNumber & LVM_EQNB_MASK)!=0)|| 933 ((pInstance->ConfigurationNumber & LVM_TE_MASK)!=0) || 934 ((pInstance->ConfigurationNumber & LVM_VC_MASK)!=0)) 935 { 936 pInstance->BlickSizeMultiple = 4; 937 } 938 else 939 { 940 pInstance->BlickSizeMultiple = 1; 941 } 942 943 return(Status); 944} 945 946 947/****************************************************************************************/ 948/* */ 949/* FUNCTION: LVM_ClearAudioBuffers */ 950/* */ 951/* DESCRIPTION: */ 952/* This function is used to clear the internal audio buffers of the bundle. */ 953/* */ 954/* PARAMETERS: */ 955/* hInstance Instance handle */ 956/* */ 957/* RETURNS: */ 958/* LVM_SUCCESS Initialisation succeeded */ 959/* LVM_NULLADDRESS Instance or scratch memory has a NULL pointer */ 960/* */ 961/* NOTES: */ 962/* 1. This function must not be interrupted by the LVM_Process function */ 963/* */ 964/****************************************************************************************/ 965 966LVM_ReturnStatus_en LVM_ClearAudioBuffers(LVM_Handle_t hInstance) 967{ 968 LVM_MemTab_t MemTab; /* Memory table */ 969 LVM_InstParams_t InstParams; /* Instance parameters */ 970 LVM_ControlParams_t Params; /* Control Parameters */ 971 LVM_Instance_t *pInstance = (LVM_Instance_t *)hInstance; /* Pointer to Instance */ 972 973 974 if(hInstance == LVM_NULL){ 975 return LVM_NULLADDRESS; 976 } 977 978 /* Save the control parameters */ /* coverity[unchecked_value] */ /* Do not check return value internal function calls */ 979 LVM_GetControlParameters(hInstance, &Params); 980 981 /* Retrieve allocated buffers in memtab */ 982 LVM_GetMemoryTable(hInstance, &MemTab, LVM_NULL); 983 984 /* Save the instance parameters */ 985 InstParams = pInstance->InstParams; 986 987 /* Call LVM_GetInstanceHandle to re-initialise the bundle */ 988 LVM_GetInstanceHandle( &hInstance, 989 &MemTab, 990 &InstParams); 991 992 /* Restore control parameters */ /* coverity[unchecked_value] */ /* Do not check return value internal function calls */ 993 LVM_SetControlParameters(hInstance, &Params); 994 995 /* DC removal filter */ 996 DC_2I_D16_TRC_WRA_01_Init(&pInstance->DC_RemovalInstance); 997 998 999 return LVM_SUCCESS; 1000} 1001 1002 1003 1004