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