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
LVM_GetMemoryTable(LVM_Handle_t hInstance,LVM_MemTab_t * pMemoryTable,LVM_InstParams_t * pInstParams)64 LVM_ReturnStatus_en LVM_GetMemoryTable(LVM_Handle_t hInstance,
65 LVM_MemTab_t *pMemoryTable,
66 LVM_InstParams_t *pInstParams)
67 {
68
69 LVM_Instance_t *pInstance = (LVM_Instance_t *)hInstance;
70 LVM_UINT32 AlgScratchSize;
71 LVM_UINT32 BundleScratchSize;
72 LVM_UINT16 InternalBlockSize;
73 INST_ALLOC AllocMem[LVM_NR_MEMORY_REGIONS];
74 LVM_INT16 i;
75
76
77 /*
78 * Check parameters
79 */
80 if(pMemoryTable == LVM_NULL)
81 {
82 return LVM_NULLADDRESS;
83 }
84
85
86 /*
87 * Return memory table if the instance has already been created
88 */
89 if (hInstance != LVM_NULL)
90 {
91 /* Read back memory allocation table */
92 *pMemoryTable = pInstance->MemoryTable;
93 return(LVM_SUCCESS);
94 }
95
96 if(pInstParams == LVM_NULL)
97 {
98 return LVM_NULLADDRESS;
99 }
100
101 /*
102 * Power Spectrum Analyser
103 */
104 if(pInstParams->PSA_Included > LVM_PSA_ON)
105 {
106 return (LVM_OUTOFRANGE);
107 }
108
109 /*
110 * Check the instance parameters
111 */
112 if( (pInstParams->BufferMode != LVM_MANAGED_BUFFERS) && (pInstParams->BufferMode != LVM_UNMANAGED_BUFFERS) )
113 {
114 return (LVM_OUTOFRANGE);
115 }
116
117 /* N-Band Equalizer */
118 if( pInstParams->EQNB_NumBands > 32 )
119 {
120 return (LVM_OUTOFRANGE);
121 }
122
123 if(pInstParams->BufferMode == LVM_MANAGED_BUFFERS)
124 {
125 if( (pInstParams->MaxBlockSize < LVM_MIN_MAXBLOCKSIZE ) || (pInstParams->MaxBlockSize > LVM_MANAGED_MAX_MAXBLOCKSIZE ) )
126 {
127 return (LVM_OUTOFRANGE);
128 }
129 }
130 else
131 {
132 if( (pInstParams->MaxBlockSize < LVM_MIN_MAXBLOCKSIZE ) || (pInstParams->MaxBlockSize > LVM_UNMANAGED_MAX_MAXBLOCKSIZE) )
133 {
134 return (LVM_OUTOFRANGE);
135 }
136 }
137
138 /*
139 * Initialise the AllocMem structures
140 */
141 for (i=0; i<LVM_NR_MEMORY_REGIONS; i++)
142 {
143 InstAlloc_Init(&AllocMem[i], LVM_NULL);
144 }
145 InternalBlockSize = (LVM_UINT16)((pInstParams->MaxBlockSize) & MIN_INTERNAL_BLOCKMASK); /* Force to a multiple of MIN_INTERNAL_BLOCKSIZE */
146
147 if (InternalBlockSize < MIN_INTERNAL_BLOCKSIZE)
148 {
149 InternalBlockSize = MIN_INTERNAL_BLOCKSIZE;
150 }
151
152 /* Maximum Internal Black Size should not be more than MAX_INTERNAL_BLOCKSIZE*/
153 if(InternalBlockSize > MAX_INTERNAL_BLOCKSIZE)
154 {
155 InternalBlockSize = MAX_INTERNAL_BLOCKSIZE;
156 }
157
158 /*
159 * Bundle requirements
160 */
161 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA],
162 sizeof(LVM_Instance_t));
163
164
165 /*
166 * Set the algorithm and bundle scratch requirements
167 */
168 AlgScratchSize = 0;
169 if (pInstParams->BufferMode == LVM_MANAGED_BUFFERS)
170 {
171 BundleScratchSize = 6 * (MIN_INTERNAL_BLOCKSIZE + InternalBlockSize) * sizeof(LVM_INT16);
172 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], /* Scratch buffer */
173 BundleScratchSize);
174 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA],
175 sizeof(LVM_Buffer_t));
176 }
177
178 /*
179 * Treble Enhancement requirements
180 */
181 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
182 sizeof(LVM_TE_Data_t));
183 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF],
184 sizeof(LVM_TE_Coefs_t));
185
186 /*
187 * N-Band Equalizer requirements
188 */
189 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], /* Local storage */
190 (pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t)));
191 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], /* User storage */
192 (pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t)));
193
194 /*
195 * Concert Sound requirements
196 */
197 {
198 LVCS_MemTab_t CS_MemTab;
199 LVCS_Capabilities_t CS_Capabilities;
200
201 /*
202 * Set the capabilities
203 */
204 CS_Capabilities.MaxBlockSize = InternalBlockSize;
205
206 /*
207 * Get the memory requirements
208 */
209 LVCS_Memory(LVM_NULL,
210 &CS_MemTab,
211 &CS_Capabilities);
212
213 /*
214 * Update the memory allocation structures
215 */
216 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
217 CS_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size);
218 InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF],
219 CS_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size);
220 if (CS_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size > AlgScratchSize) AlgScratchSize = CS_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size;
221
222 }
223
224
225 /*
226 * Dynamic Bass Enhancement requirements
227 */
228 {
229 LVDBE_MemTab_t DBE_MemTab;
230 LVDBE_Capabilities_t DBE_Capabilities;
231
232 /*
233 * Set the capabilities
234 */
235 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
LVM_GetInstanceHandle(LVM_Handle_t * phInstance,LVM_MemTab_t * pMemoryTable,LVM_InstParams_t * pInstParams)423 LVM_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
LVM_ClearAudioBuffers(LVM_Handle_t hInstance)958 LVM_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