996 lines
44 KiB
C
996 lines
44 KiB
C
/*
|
|
* Copyright (C) 2004-2010 NXP Software
|
|
* Copyright (C) 2010 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/************************************************************************************/
|
|
/* */
|
|
/* Includes */
|
|
/* */
|
|
/************************************************************************************/
|
|
|
|
#include "LVM_Private.h"
|
|
#include "LVM_Tables.h"
|
|
#include "VectorArithmetic.h"
|
|
#include "InstAlloc.h"
|
|
|
|
/****************************************************************************************/
|
|
/* */
|
|
/* FUNCTION: LVM_GetMemoryTable */
|
|
/* */
|
|
/* DESCRIPTION: */
|
|
/* This function is used for memory allocation and free. It can be called in */
|
|
/* two ways: */
|
|
/* */
|
|
/* hInstance = NULL Returns the memory requirements */
|
|
/* hInstance = Instance handle Returns the memory requirements and */
|
|
/* allocated base addresses for the instance */
|
|
/* */
|
|
/* When this function is called for memory allocation (hInstance=NULL) the memory */
|
|
/* base address pointers are NULL on return. */
|
|
/* */
|
|
/* When the function is called for free (hInstance = Instance Handle) the memory */
|
|
/* table returns the allocated memory and base addresses used during initialisation. */
|
|
/* */
|
|
/* PARAMETERS: */
|
|
/* hInstance Instance Handle */
|
|
/* pMemoryTable Pointer to an empty memory definition table */
|
|
/* pCapabilities Pointer to the default capabilities */
|
|
/* */
|
|
/* RETURNS: */
|
|
/* LVM_SUCCESS Succeeded */
|
|
/* LVM_NULLADDRESS When one of pMemoryTable or pInstParams is NULL */
|
|
/* LVM_OUTOFRANGE When any of the Instance parameters are out of range */
|
|
/* */
|
|
/* NOTES: */
|
|
/* 1. This function may be interrupted by the LVM_Process function */
|
|
/* 2. The scratch memory is the largest required by any of the sub-modules plus any */
|
|
/* additional scratch requirements of the bundle */
|
|
/* */
|
|
/****************************************************************************************/
|
|
|
|
LVM_ReturnStatus_en LVM_GetMemoryTable(LVM_Handle_t hInstance,
|
|
LVM_MemTab_t *pMemoryTable,
|
|
LVM_InstParams_t *pInstParams)
|
|
{
|
|
|
|
LVM_Instance_t *pInstance = (LVM_Instance_t *)hInstance;
|
|
LVM_UINT32 AlgScratchSize;
|
|
LVM_UINT32 BundleScratchSize;
|
|
LVM_UINT16 InternalBlockSize;
|
|
INST_ALLOC AllocMem[LVM_NR_MEMORY_REGIONS];
|
|
LVM_INT16 i;
|
|
|
|
|
|
/*
|
|
* Check parameters
|
|
*/
|
|
if(pMemoryTable == LVM_NULL)
|
|
{
|
|
return LVM_NULLADDRESS;
|
|
}
|
|
|
|
|
|
/*
|
|
* Return memory table if the instance has already been created
|
|
*/
|
|
if (hInstance != LVM_NULL)
|
|
{
|
|
/* Read back memory allocation table */
|
|
*pMemoryTable = pInstance->MemoryTable;
|
|
return(LVM_SUCCESS);
|
|
}
|
|
|
|
if(pInstParams == LVM_NULL)
|
|
{
|
|
return LVM_NULLADDRESS;
|
|
}
|
|
|
|
/*
|
|
* Power Spectrum Analyser
|
|
*/
|
|
if(pInstParams->PSA_Included > LVM_PSA_ON)
|
|
{
|
|
return (LVM_OUTOFRANGE);
|
|
}
|
|
|
|
/*
|
|
* Check the instance parameters
|
|
*/
|
|
if( (pInstParams->BufferMode != LVM_MANAGED_BUFFERS) && (pInstParams->BufferMode != LVM_UNMANAGED_BUFFERS) )
|
|
{
|
|
return (LVM_OUTOFRANGE);
|
|
}
|
|
|
|
/* N-Band Equalizer */
|
|
if( pInstParams->EQNB_NumBands > 32 )
|
|
{
|
|
return (LVM_OUTOFRANGE);
|
|
}
|
|
|
|
if(pInstParams->BufferMode == LVM_MANAGED_BUFFERS)
|
|
{
|
|
if( (pInstParams->MaxBlockSize < LVM_MIN_MAXBLOCKSIZE ) || (pInstParams->MaxBlockSize > LVM_MANAGED_MAX_MAXBLOCKSIZE ) )
|
|
{
|
|
return (LVM_OUTOFRANGE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( (pInstParams->MaxBlockSize < LVM_MIN_MAXBLOCKSIZE ) || (pInstParams->MaxBlockSize > LVM_UNMANAGED_MAX_MAXBLOCKSIZE) )
|
|
{
|
|
return (LVM_OUTOFRANGE);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Initialise the AllocMem structures
|
|
*/
|
|
for (i=0; i<LVM_NR_MEMORY_REGIONS; i++)
|
|
{
|
|
InstAlloc_Init(&AllocMem[i], LVM_NULL);
|
|
}
|
|
InternalBlockSize = (LVM_UINT16)((pInstParams->MaxBlockSize) & MIN_INTERNAL_BLOCKMASK); /* Force to a multiple of MIN_INTERNAL_BLOCKSIZE */
|
|
|
|
if (InternalBlockSize < MIN_INTERNAL_BLOCKSIZE)
|
|
{
|
|
InternalBlockSize = MIN_INTERNAL_BLOCKSIZE;
|
|
}
|
|
|
|
/* Maximum Internal Black Size should not be more than MAX_INTERNAL_BLOCKSIZE*/
|
|
if(InternalBlockSize > MAX_INTERNAL_BLOCKSIZE)
|
|
{
|
|
InternalBlockSize = MAX_INTERNAL_BLOCKSIZE;
|
|
}
|
|
|
|
/*
|
|
* Bundle requirements
|
|
*/
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA],
|
|
sizeof(LVM_Instance_t));
|
|
|
|
|
|
/*
|
|
* Set the algorithm and bundle scratch requirements
|
|
*/
|
|
AlgScratchSize = 0;
|
|
if (pInstParams->BufferMode == LVM_MANAGED_BUFFERS)
|
|
{
|
|
BundleScratchSize = 6 * (MIN_INTERNAL_BLOCKSIZE + InternalBlockSize) * sizeof(LVM_INT16);
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], /* Scratch buffer */
|
|
BundleScratchSize);
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA],
|
|
sizeof(LVM_Buffer_t));
|
|
}
|
|
|
|
/*
|
|
* Treble Enhancement requirements
|
|
*/
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
sizeof(LVM_TE_Data_t));
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF],
|
|
sizeof(LVM_TE_Coefs_t));
|
|
|
|
/*
|
|
* N-Band Equalizer requirements
|
|
*/
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], /* Local storage */
|
|
(pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t)));
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA], /* User storage */
|
|
(pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t)));
|
|
|
|
/*
|
|
* Concert Sound requirements
|
|
*/
|
|
{
|
|
LVCS_MemTab_t CS_MemTab;
|
|
LVCS_Capabilities_t CS_Capabilities;
|
|
|
|
/*
|
|
* Set the capabilities
|
|
*/
|
|
CS_Capabilities.MaxBlockSize = InternalBlockSize;
|
|
|
|
/*
|
|
* Get the memory requirements
|
|
*/
|
|
LVCS_Memory(LVM_NULL,
|
|
&CS_MemTab,
|
|
&CS_Capabilities);
|
|
|
|
/*
|
|
* Update the memory allocation structures
|
|
*/
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
CS_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size);
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF],
|
|
CS_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size);
|
|
if (CS_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size > AlgScratchSize) AlgScratchSize = CS_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size;
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
* Dynamic Bass Enhancement requirements
|
|
*/
|
|
{
|
|
LVDBE_MemTab_t DBE_MemTab;
|
|
LVDBE_Capabilities_t DBE_Capabilities;
|
|
|
|
/*
|
|
* Set the capabilities
|
|
*/
|
|
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;
|
|
DBE_Capabilities.CentreFrequency = LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_66Hz | LVDBE_CAP_CENTRE_78Hz | LVDBE_CAP_CENTRE_90Hz;
|
|
DBE_Capabilities.MaxBlockSize = InternalBlockSize;
|
|
|
|
/*
|
|
* Get the memory requirements
|
|
*/
|
|
LVDBE_Memory(LVM_NULL,
|
|
&DBE_MemTab,
|
|
|
|
&DBE_Capabilities);
|
|
/*
|
|
* Update the bundle table
|
|
*/
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
DBE_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size);
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF],
|
|
DBE_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size);
|
|
if (DBE_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size > AlgScratchSize) AlgScratchSize = DBE_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size;
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
* N-Band equaliser requirements
|
|
*/
|
|
{
|
|
LVEQNB_MemTab_t EQNB_MemTab; /* For N-Band Equaliser */
|
|
LVEQNB_Capabilities_t EQNB_Capabilities;
|
|
|
|
/*
|
|
* Set the capabilities
|
|
*/
|
|
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;
|
|
EQNB_Capabilities.SourceFormat = LVEQNB_CAP_STEREO | LVEQNB_CAP_MONOINSTEREO;
|
|
EQNB_Capabilities.MaxBlockSize = InternalBlockSize;
|
|
EQNB_Capabilities.MaxBands = pInstParams->EQNB_NumBands;
|
|
|
|
/*
|
|
* Get the memory requirements
|
|
*/
|
|
LVEQNB_Memory(LVM_NULL,
|
|
&EQNB_MemTab,
|
|
&EQNB_Capabilities);
|
|
|
|
/*
|
|
* Update the bundle table
|
|
*/
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
EQNB_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size);
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF],
|
|
EQNB_MemTab.Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size);
|
|
if (EQNB_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size > AlgScratchSize) AlgScratchSize = EQNB_MemTab.Region[LVM_MEMREGION_TEMPORARY_FAST].Size;
|
|
|
|
}
|
|
|
|
/*
|
|
* Headroom management memory allocation
|
|
*/
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
(LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t)));
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
(LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t)));
|
|
|
|
|
|
/*
|
|
* Spectrum Analyzer memory requirements
|
|
*/
|
|
{
|
|
pLVPSA_Handle_t hPSAInst = LVM_NULL;
|
|
LVPSA_MemTab_t PSA_MemTab;
|
|
LVPSA_InitParams_t PSA_InitParams;
|
|
LVPSA_FilterParam_t FiltersParams[9];
|
|
LVPSA_RETURN PSA_Status;
|
|
|
|
if(pInstParams->PSA_Included == LVM_PSA_ON)
|
|
{
|
|
PSA_InitParams.SpectralDataBufferDuration = (LVM_UINT16) 500;
|
|
PSA_InitParams.MaxInputBlockSize = (LVM_UINT16) 1000;
|
|
PSA_InitParams.nBands = (LVM_UINT16) 9;
|
|
|
|
PSA_InitParams.pFiltersParams = &FiltersParams[0];
|
|
for(i = 0; i < PSA_InitParams.nBands; i++)
|
|
{
|
|
FiltersParams[i].CenterFrequency = (LVM_UINT16) 1000;
|
|
FiltersParams[i].QFactor = (LVM_UINT16) 25;
|
|
FiltersParams[i].PostGain = (LVM_INT16) 0;
|
|
}
|
|
|
|
/*
|
|
* Get the memory requirements
|
|
*/
|
|
PSA_Status = LVPSA_Memory (hPSAInst,
|
|
&PSA_MemTab,
|
|
&PSA_InitParams);
|
|
|
|
if (PSA_Status != LVPSA_OK)
|
|
{
|
|
return((LVM_ReturnStatus_en) LVM_ALGORITHMPSA);
|
|
}
|
|
|
|
/*
|
|
* Update the bundle table
|
|
*/
|
|
/* Slow Data */
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA],
|
|
PSA_MemTab.Region[LVM_PERSISTENT_SLOW_DATA].Size);
|
|
|
|
/* Fast Data */
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
PSA_MemTab.Region[LVM_PERSISTENT_FAST_DATA].Size);
|
|
|
|
/* Fast Coef */
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF],
|
|
PSA_MemTab.Region[LVM_PERSISTENT_FAST_COEF].Size);
|
|
|
|
/* Fast Temporary */
|
|
InstAlloc_AddMember(&AllocMem[LVM_TEMPORARY_FAST],
|
|
MAX_INTERNAL_BLOCKSIZE * sizeof(LVM_INT16));
|
|
|
|
if (PSA_MemTab.Region[LVM_TEMPORARY_FAST].Size > AlgScratchSize)
|
|
{
|
|
AlgScratchSize = PSA_MemTab.Region[LVM_TEMPORARY_FAST].Size;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Return the memory table
|
|
*/
|
|
pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_SLOW_DATA].Size = InstAlloc_GetTotal(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA]);
|
|
pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_SLOW_DATA].Type = LVM_PERSISTENT_SLOW_DATA;
|
|
pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_SLOW_DATA].pBaseAddress = LVM_NULL;
|
|
|
|
pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size = InstAlloc_GetTotal(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA]);
|
|
pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Type = LVM_PERSISTENT_FAST_DATA;
|
|
pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].pBaseAddress = LVM_NULL;
|
|
if (pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size < 4)
|
|
{
|
|
pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_DATA].Size = 0;
|
|
}
|
|
|
|
pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size = InstAlloc_GetTotal(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF]);
|
|
pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Type = LVM_PERSISTENT_FAST_COEF;
|
|
pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].pBaseAddress = LVM_NULL;
|
|
if (pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size < 4)
|
|
{
|
|
pMemoryTable->Region[LVM_MEMREGION_PERSISTENT_FAST_COEF].Size = 0;
|
|
}
|
|
|
|
InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST],
|
|
AlgScratchSize);
|
|
pMemoryTable->Region[LVM_MEMREGION_TEMPORARY_FAST].Size = InstAlloc_GetTotal(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST]);
|
|
pMemoryTable->Region[LVM_MEMREGION_TEMPORARY_FAST].Type = LVM_TEMPORARY_FAST;
|
|
pMemoryTable->Region[LVM_MEMREGION_TEMPORARY_FAST].pBaseAddress = LVM_NULL;
|
|
if (pMemoryTable->Region[LVM_MEMREGION_TEMPORARY_FAST].Size < 4)
|
|
{
|
|
pMemoryTable->Region[LVM_MEMREGION_TEMPORARY_FAST].Size = 0;
|
|
}
|
|
|
|
return(LVM_SUCCESS);
|
|
|
|
}
|
|
|
|
|
|
/****************************************************************************************/
|
|
/* */
|
|
/* FUNCTION: LVM_GetInstanceHandle */
|
|
/* */
|
|
/* DESCRIPTION: */
|
|
/* This function is used to create a bundle instance. It returns the created instance */
|
|
/* handle through phInstance. All parameters are set to their default, inactive state. */
|
|
/* */
|
|
/* PARAMETERS: */
|
|
/* phInstance pointer to the instance handle */
|
|
/* pMemoryTable Pointer to the memory definition table */
|
|
/* pInstParams Pointer to the initialisation capabilities */
|
|
/* */
|
|
/* RETURNS: */
|
|
/* LVM_SUCCESS Initialisation succeeded */
|
|
/* LVM_OUTOFRANGE When any of the Instance parameters are out of range */
|
|
/* LVM_NULLADDRESS When one of phInstance, pMemoryTable or pInstParams are NULL*/
|
|
/* */
|
|
/* NOTES: */
|
|
/* 1. This function must not be interrupted by the LVM_Process function */
|
|
/* */
|
|
/****************************************************************************************/
|
|
|
|
LVM_ReturnStatus_en LVM_GetInstanceHandle(LVM_Handle_t *phInstance,
|
|
LVM_MemTab_t *pMemoryTable,
|
|
LVM_InstParams_t *pInstParams)
|
|
{
|
|
|
|
LVM_ReturnStatus_en Status = LVM_SUCCESS;
|
|
LVM_Instance_t *pInstance;
|
|
INST_ALLOC AllocMem[LVM_NR_MEMORY_REGIONS];
|
|
LVM_INT16 i;
|
|
LVM_UINT16 InternalBlockSize;
|
|
LVM_INT32 BundleScratchSize;
|
|
|
|
|
|
/*
|
|
* Check valid points have been given
|
|
*/
|
|
if ((phInstance == LVM_NULL) || (pMemoryTable == LVM_NULL) || (pInstParams == LVM_NULL))
|
|
{
|
|
return (LVM_NULLADDRESS);
|
|
}
|
|
|
|
/*
|
|
* Check the memory table for NULL pointers
|
|
*/
|
|
for (i=0; i<LVM_NR_MEMORY_REGIONS; i++)
|
|
{
|
|
if ((pMemoryTable->Region[i].Size != 0) &&
|
|
(pMemoryTable->Region[i].pBaseAddress==LVM_NULL))
|
|
{
|
|
return(LVM_NULLADDRESS);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Check the instance parameters
|
|
*/
|
|
if( (pInstParams->BufferMode != LVM_MANAGED_BUFFERS) && (pInstParams->BufferMode != LVM_UNMANAGED_BUFFERS) )
|
|
{
|
|
return (LVM_OUTOFRANGE);
|
|
}
|
|
|
|
if( pInstParams->EQNB_NumBands > 32 )
|
|
{
|
|
return (LVM_OUTOFRANGE);
|
|
}
|
|
|
|
if(pInstParams->BufferMode == LVM_MANAGED_BUFFERS)
|
|
{
|
|
if( (pInstParams->MaxBlockSize < LVM_MIN_MAXBLOCKSIZE ) || (pInstParams->MaxBlockSize > LVM_MANAGED_MAX_MAXBLOCKSIZE ) )
|
|
{
|
|
return (LVM_OUTOFRANGE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( (pInstParams->MaxBlockSize < LVM_MIN_MAXBLOCKSIZE ) || (pInstParams->MaxBlockSize > LVM_UNMANAGED_MAX_MAXBLOCKSIZE) )
|
|
{
|
|
return (LVM_OUTOFRANGE);
|
|
}
|
|
}
|
|
|
|
if(pInstParams->PSA_Included > LVM_PSA_ON)
|
|
{
|
|
return (LVM_OUTOFRANGE);
|
|
}
|
|
|
|
/*
|
|
* Initialise the AllocMem structures
|
|
*/
|
|
for (i=0; i<LVM_NR_MEMORY_REGIONS; i++)
|
|
{
|
|
InstAlloc_Init(&AllocMem[i],
|
|
pMemoryTable->Region[i].pBaseAddress);
|
|
}
|
|
|
|
|
|
/*
|
|
* Set the instance handle
|
|
*/
|
|
*phInstance = (LVM_Handle_t)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA],
|
|
sizeof(LVM_Instance_t));
|
|
pInstance =(LVM_Instance_t *)*phInstance;
|
|
|
|
|
|
/*
|
|
* Save the memory table, parameters and capabilities
|
|
*/
|
|
pInstance->MemoryTable = *pMemoryTable;
|
|
pInstance->InstParams = *pInstParams;
|
|
|
|
|
|
/*
|
|
* Set the bundle scratch memory and initialse the buffer management
|
|
*/
|
|
InternalBlockSize = (LVM_UINT16)((pInstParams->MaxBlockSize) & MIN_INTERNAL_BLOCKMASK); /* Force to a multiple of MIN_INTERNAL_BLOCKSIZE */
|
|
if (InternalBlockSize < MIN_INTERNAL_BLOCKSIZE)
|
|
{
|
|
InternalBlockSize = MIN_INTERNAL_BLOCKSIZE;
|
|
}
|
|
|
|
/* Maximum Internal Black Size should not be more than MAX_INTERNAL_BLOCKSIZE*/
|
|
if(InternalBlockSize > MAX_INTERNAL_BLOCKSIZE)
|
|
{
|
|
InternalBlockSize = MAX_INTERNAL_BLOCKSIZE;
|
|
}
|
|
pInstance->InternalBlockSize = (LVM_INT16)InternalBlockSize;
|
|
|
|
|
|
/*
|
|
* Common settings for managed and unmanaged buffers
|
|
*/
|
|
pInstance->SamplesToProcess = 0; /* No samples left to process */
|
|
if (pInstParams->BufferMode == LVM_MANAGED_BUFFERS)
|
|
{
|
|
/*
|
|
* Managed buffers required
|
|
*/
|
|
pInstance->pBufferManagement = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA],
|
|
sizeof(LVM_Buffer_t));
|
|
BundleScratchSize = (LVM_INT32)(6 * (MIN_INTERNAL_BLOCKSIZE + InternalBlockSize) * sizeof(LVM_INT16));
|
|
pInstance->pBufferManagement->pScratch = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST], /* Scratch 1 buffer */
|
|
(LVM_UINT32)BundleScratchSize);
|
|
|
|
LoadConst_16(0, /* Clear the input delay buffer */
|
|
(LVM_INT16 *)&pInstance->pBufferManagement->InDelayBuffer,
|
|
(LVM_INT16)(2 * MIN_INTERNAL_BLOCKSIZE));
|
|
pInstance->pBufferManagement->InDelaySamples = MIN_INTERNAL_BLOCKSIZE; /* Set the number of delay samples */
|
|
pInstance->pBufferManagement->OutDelaySamples = 0; /* No samples in the output buffer */
|
|
pInstance->pBufferManagement->BufferState = LVM_FIRSTCALL; /* Set the state ready for the first call */
|
|
}
|
|
|
|
|
|
/*
|
|
* Set default parameters
|
|
*/
|
|
pInstance->Params.OperatingMode = LVM_MODE_OFF;
|
|
pInstance->Params.SampleRate = LVM_FS_8000;
|
|
pInstance->Params.SourceFormat = LVM_MONO;
|
|
pInstance->Params.SpeakerType = LVM_HEADPHONES;
|
|
pInstance->Params.VC_EffectLevel = 0;
|
|
pInstance->Params.VC_Balance = 0;
|
|
|
|
/*
|
|
* Set callback
|
|
*/
|
|
pInstance->CallBack = LVM_AlgoCallBack;
|
|
|
|
|
|
/*
|
|
* DC removal filter
|
|
*/
|
|
DC_2I_D16_TRC_WRA_01_Init(&pInstance->DC_RemovalInstance);
|
|
|
|
|
|
/*
|
|
* Treble Enhancement
|
|
*/
|
|
pInstance->pTE_Taps = (LVM_TE_Data_t *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
sizeof(LVM_TE_Data_t));
|
|
|
|
pInstance->pTE_State = (LVM_TE_Coefs_t *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF],
|
|
sizeof(LVM_TE_Coefs_t));
|
|
pInstance->Params.TE_OperatingMode = LVM_TE_OFF;
|
|
pInstance->Params.TE_EffectLevel = 0;
|
|
pInstance->TE_Active = LVM_FALSE;
|
|
|
|
|
|
/*
|
|
* Set the volume control and initialise Current to Target
|
|
*/
|
|
pInstance->VC_Volume.MixerStream[0].CallbackParam = 0;
|
|
pInstance->VC_Volume.MixerStream[0].CallbackSet = 0;
|
|
pInstance->VC_Volume.MixerStream[0].pCallbackHandle = pInstance;
|
|
pInstance->VC_Volume.MixerStream[0].pCallBack = LVM_VCCallBack;
|
|
|
|
/* In managed buffering, start with low signal level as delay in buffer management causes a click*/
|
|
if (pInstParams->BufferMode == LVM_MANAGED_BUFFERS)
|
|
{
|
|
LVC_Mixer_Init(&pInstance->VC_Volume.MixerStream[0],0,0);
|
|
}
|
|
else
|
|
{
|
|
LVC_Mixer_Init(&pInstance->VC_Volume.MixerStream[0],LVM_MAXINT_16,LVM_MAXINT_16);
|
|
}
|
|
|
|
LVC_Mixer_SetTimeConstant(&pInstance->VC_Volume.MixerStream[0],0,LVM_FS_8000,2);
|
|
|
|
pInstance->VC_VolumedB = 0;
|
|
pInstance->VC_AVLFixedVolume = 0;
|
|
pInstance->VC_Active = LVM_FALSE;
|
|
|
|
pInstance->VC_BalanceMix.MixerStream[0].CallbackParam = 0;
|
|
pInstance->VC_BalanceMix.MixerStream[0].CallbackSet = 0;
|
|
pInstance->VC_BalanceMix.MixerStream[0].pCallbackHandle = pInstance;
|
|
pInstance->VC_BalanceMix.MixerStream[0].pCallBack = LVM_VCCallBack;
|
|
LVC_Mixer_Init(&pInstance->VC_BalanceMix.MixerStream[0],LVM_MAXINT_16,LVM_MAXINT_16);
|
|
LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[0],LVM_VC_MIXER_TIME,LVM_FS_8000,2);
|
|
|
|
pInstance->VC_BalanceMix.MixerStream[1].CallbackParam = 0;
|
|
pInstance->VC_BalanceMix.MixerStream[1].CallbackSet = 0;
|
|
pInstance->VC_BalanceMix.MixerStream[1].pCallbackHandle = pInstance;
|
|
pInstance->VC_BalanceMix.MixerStream[1].pCallBack = LVM_VCCallBack;
|
|
LVC_Mixer_Init(&pInstance->VC_BalanceMix.MixerStream[1],LVM_MAXINT_16,LVM_MAXINT_16);
|
|
LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[1],LVM_VC_MIXER_TIME,LVM_FS_8000,2);
|
|
/*
|
|
* Set the default EQNB pre-gain and pointer to the band definitions
|
|
*/
|
|
pInstance->pEQNB_BandDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
(pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t)));
|
|
pInstance->pEQNB_UserDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
(pInstParams->EQNB_NumBands * sizeof(LVM_EQNB_BandDef_t)));
|
|
|
|
|
|
/*
|
|
* Initialise the Concert Sound module
|
|
*/
|
|
{
|
|
LVCS_Handle_t hCSInstance; /* Instance handle */
|
|
LVCS_MemTab_t CS_MemTab; /* Memory table */
|
|
LVCS_Capabilities_t CS_Capabilities; /* Initial capabilities */
|
|
LVCS_ReturnStatus_en LVCS_Status; /* Function call status */
|
|
|
|
/*
|
|
* Set default parameters
|
|
*/
|
|
pInstance->Params.VirtualizerReverbLevel = 100;
|
|
pInstance->Params.VirtualizerType = LVM_CONCERTSOUND;
|
|
pInstance->Params.VirtualizerOperatingMode = LVM_MODE_OFF;
|
|
pInstance->CS_Active = LVM_FALSE;
|
|
|
|
/*
|
|
* Set the initialisation capabilities
|
|
*/
|
|
CS_Capabilities.MaxBlockSize = (LVM_UINT16)InternalBlockSize;
|
|
CS_Capabilities.CallBack = pInstance->CallBack;
|
|
CS_Capabilities.pBundleInstance = (void*)pInstance;
|
|
|
|
|
|
/*
|
|
* Get the memory requirements and then set the address pointers, forcing alignment
|
|
*/
|
|
LVCS_Status = LVCS_Memory(LVM_NULL, /* Get the memory requirements */
|
|
&CS_MemTab,
|
|
&CS_Capabilities);
|
|
CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_SLOW_DATA].pBaseAddress = &pInstance->CS_Instance;
|
|
CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].Size);
|
|
CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF],
|
|
CS_MemTab.Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].Size);
|
|
CS_MemTab.Region[LVCS_MEMREGION_TEMPORARY_FAST].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST],
|
|
0);
|
|
|
|
/*
|
|
* Initialise the Concert Sound instance and save the instance handle
|
|
*/
|
|
hCSInstance = LVM_NULL; /* Set to NULL to return handle */
|
|
LVCS_Status = LVCS_Init(&hCSInstance, /* Initiailse */
|
|
&CS_MemTab,
|
|
&CS_Capabilities);
|
|
if (LVCS_Status != LVCS_SUCCESS) return((LVM_ReturnStatus_en)LVCS_Status);
|
|
pInstance->hCSInstance = hCSInstance; /* Save the instance handle */
|
|
|
|
}
|
|
|
|
/*
|
|
* Initialise the Bass Enhancement module
|
|
*/
|
|
{
|
|
LVDBE_Handle_t hDBEInstance; /* Instance handle */
|
|
LVDBE_MemTab_t DBE_MemTab; /* Memory table */
|
|
LVDBE_Capabilities_t DBE_Capabilities; /* Initial capabilities */
|
|
LVDBE_ReturnStatus_en LVDBE_Status; /* Function call status */
|
|
|
|
|
|
/*
|
|
* Set the initialisation parameters
|
|
*/
|
|
pInstance->Params.BE_OperatingMode = LVM_BE_OFF;
|
|
pInstance->Params.BE_CentreFreq = LVM_BE_CENTRE_55Hz;
|
|
pInstance->Params.BE_EffectLevel = 0;
|
|
pInstance->Params.BE_HPF = LVM_BE_HPF_OFF;
|
|
|
|
pInstance->DBE_Active = LVM_FALSE;
|
|
|
|
|
|
|
|
/*
|
|
* Set the initialisation capabilities
|
|
*/
|
|
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;
|
|
DBE_Capabilities.CentreFrequency = LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_55Hz | LVDBE_CAP_CENTRE_66Hz | LVDBE_CAP_CENTRE_78Hz | LVDBE_CAP_CENTRE_90Hz;
|
|
DBE_Capabilities.MaxBlockSize = (LVM_UINT16)InternalBlockSize;
|
|
|
|
|
|
/*
|
|
* Get the memory requirements and then set the address pointers
|
|
*/
|
|
LVDBE_Status = LVDBE_Memory(LVM_NULL, /* Get the memory requirements */
|
|
&DBE_MemTab,
|
|
&DBE_Capabilities);
|
|
DBE_MemTab.Region[LVDBE_MEMREGION_INSTANCE].pBaseAddress = &pInstance->DBE_Instance;
|
|
DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_DATA].Size);
|
|
DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF],
|
|
DBE_MemTab.Region[LVDBE_MEMREGION_PERSISTENT_COEF].Size);
|
|
DBE_MemTab.Region[LVDBE_MEMREGION_SCRATCH].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST],
|
|
0);
|
|
|
|
|
|
/*
|
|
* Initialise the Dynamic Bass Enhancement instance and save the instance handle
|
|
*/
|
|
hDBEInstance = LVM_NULL; /* Set to NULL to return handle */
|
|
LVDBE_Status = LVDBE_Init(&hDBEInstance, /* Initiailse */
|
|
&DBE_MemTab,
|
|
&DBE_Capabilities);
|
|
if (LVDBE_Status != LVDBE_SUCCESS) return((LVM_ReturnStatus_en)LVDBE_Status);
|
|
pInstance->hDBEInstance = hDBEInstance; /* Save the instance handle */
|
|
}
|
|
|
|
|
|
/*
|
|
* Initialise the N-Band Equaliser module
|
|
*/
|
|
{
|
|
LVEQNB_Handle_t hEQNBInstance; /* Instance handle */
|
|
LVEQNB_MemTab_t EQNB_MemTab; /* Memory table */
|
|
LVEQNB_Capabilities_t EQNB_Capabilities; /* Initial capabilities */
|
|
LVEQNB_ReturnStatus_en LVEQNB_Status; /* Function call status */
|
|
|
|
|
|
/*
|
|
* Set the initialisation parameters
|
|
*/
|
|
pInstance->Params.EQNB_OperatingMode = LVM_EQNB_OFF;
|
|
pInstance->Params.EQNB_NBands = 0;
|
|
pInstance->Params.pEQNB_BandDefinition = LVM_NULL;
|
|
pInstance->EQNB_Active = LVM_FALSE;
|
|
|
|
|
|
/*
|
|
* Set the initialisation capabilities
|
|
*/
|
|
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;
|
|
EQNB_Capabilities.MaxBlockSize = (LVM_UINT16)InternalBlockSize;
|
|
EQNB_Capabilities.MaxBands = pInstParams->EQNB_NumBands;
|
|
EQNB_Capabilities.SourceFormat = LVEQNB_CAP_STEREO | LVEQNB_CAP_MONOINSTEREO;
|
|
EQNB_Capabilities.CallBack = pInstance->CallBack;
|
|
EQNB_Capabilities.pBundleInstance = (void*)pInstance;
|
|
|
|
|
|
/*
|
|
* Get the memory requirements and then set the address pointers, forcing alignment
|
|
*/
|
|
LVEQNB_Status = LVEQNB_Memory(LVM_NULL, /* Get the memory requirements */
|
|
&EQNB_MemTab,
|
|
&EQNB_Capabilities);
|
|
EQNB_MemTab.Region[LVEQNB_MEMREGION_INSTANCE].pBaseAddress = &pInstance->EQNB_Instance;
|
|
EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_DATA].Size);
|
|
EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF],
|
|
EQNB_MemTab.Region[LVEQNB_MEMREGION_PERSISTENT_COEF].Size);
|
|
EQNB_MemTab.Region[LVEQNB_MEMREGION_SCRATCH].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST],
|
|
0);
|
|
|
|
|
|
/*
|
|
* Initialise the Dynamic Bass Enhancement instance and save the instance handle
|
|
*/
|
|
hEQNBInstance = LVM_NULL; /* Set to NULL to return handle */
|
|
LVEQNB_Status = LVEQNB_Init(&hEQNBInstance, /* Initiailse */
|
|
&EQNB_MemTab,
|
|
&EQNB_Capabilities);
|
|
if (LVEQNB_Status != LVEQNB_SUCCESS) return((LVM_ReturnStatus_en)LVEQNB_Status);
|
|
pInstance->hEQNBInstance = hEQNBInstance; /* Save the instance handle */
|
|
}
|
|
|
|
/*
|
|
* Headroom management memory allocation
|
|
*/
|
|
{
|
|
pInstance->pHeadroom_BandDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
(LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t)));
|
|
pInstance->pHeadroom_UserDefs = InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
(LVM_HEADROOM_MAX_NBANDS * sizeof(LVM_HeadroomBandDef_t)));
|
|
|
|
/* Headroom management parameters initialisation */
|
|
pInstance->NewHeadroomParams.NHeadroomBands = 2;
|
|
pInstance->NewHeadroomParams.pHeadroomDefinition = pInstance->pHeadroom_BandDefs;
|
|
pInstance->NewHeadroomParams.pHeadroomDefinition[0].Limit_Low = 20;
|
|
pInstance->NewHeadroomParams.pHeadroomDefinition[0].Limit_High = 4999;
|
|
pInstance->NewHeadroomParams.pHeadroomDefinition[0].Headroom_Offset = 3;
|
|
pInstance->NewHeadroomParams.pHeadroomDefinition[1].Limit_Low = 5000;
|
|
pInstance->NewHeadroomParams.pHeadroomDefinition[1].Limit_High = 24000;
|
|
pInstance->NewHeadroomParams.pHeadroomDefinition[1].Headroom_Offset = 4;
|
|
pInstance->NewHeadroomParams.Headroom_OperatingMode = LVM_HEADROOM_ON;
|
|
|
|
pInstance->Headroom =0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Initialise the PSA module
|
|
*/
|
|
{
|
|
pLVPSA_Handle_t hPSAInstance = LVM_NULL; /* Instance handle */
|
|
LVPSA_MemTab_t PSA_MemTab;
|
|
LVPSA_RETURN PSA_Status; /* Function call status */
|
|
LVPSA_FilterParam_t FiltersParams[9];
|
|
|
|
if(pInstParams->PSA_Included==LVM_PSA_ON)
|
|
{
|
|
pInstance->PSA_InitParams.SpectralDataBufferDuration = (LVM_UINT16) 500;
|
|
pInstance->PSA_InitParams.MaxInputBlockSize = (LVM_UINT16) 2048;
|
|
pInstance->PSA_InitParams.nBands = (LVM_UINT16) 9;
|
|
pInstance->PSA_InitParams.pFiltersParams = &FiltersParams[0];
|
|
for(i = 0; i < pInstance->PSA_InitParams.nBands; i++)
|
|
{
|
|
FiltersParams[i].CenterFrequency = (LVM_UINT16) 1000;
|
|
FiltersParams[i].QFactor = (LVM_UINT16) 100;
|
|
FiltersParams[i].PostGain = (LVM_INT16) 0;
|
|
}
|
|
|
|
/*Get the memory requirements and then set the address pointers*/
|
|
PSA_Status = LVPSA_Memory (hPSAInstance,
|
|
&PSA_MemTab,
|
|
&pInstance->PSA_InitParams);
|
|
|
|
if (PSA_Status != LVPSA_OK)
|
|
{
|
|
return((LVM_ReturnStatus_en) LVM_ALGORITHMPSA);
|
|
}
|
|
|
|
/* Slow Data */
|
|
PSA_MemTab.Region[LVM_PERSISTENT_SLOW_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_SLOW_DATA],
|
|
PSA_MemTab.Region[LVM_PERSISTENT_SLOW_DATA].Size);
|
|
|
|
|
|
/* Fast Data */
|
|
PSA_MemTab.Region[LVM_PERSISTENT_FAST_DATA].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_DATA],
|
|
PSA_MemTab.Region[LVM_PERSISTENT_FAST_DATA].Size);
|
|
|
|
|
|
/* Fast Coef */
|
|
PSA_MemTab.Region[LVM_PERSISTENT_FAST_COEF].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_PERSISTENT_FAST_COEF],
|
|
PSA_MemTab.Region[LVM_PERSISTENT_FAST_COEF].Size);
|
|
|
|
/* Fast Temporary */
|
|
pInstance->pPSAInput = InstAlloc_AddMember(&AllocMem[LVM_TEMPORARY_FAST],
|
|
(LVM_UINT32) MAX_INTERNAL_BLOCKSIZE * sizeof(LVM_INT16));
|
|
|
|
PSA_MemTab.Region[LVM_TEMPORARY_FAST].pBaseAddress = (void *)InstAlloc_AddMember(&AllocMem[LVM_MEMREGION_TEMPORARY_FAST],0);
|
|
|
|
|
|
/*Initialise PSA instance and save the instance handle*/
|
|
pInstance->PSA_ControlParams.Fs = LVM_FS_48000;
|
|
pInstance->PSA_ControlParams.LevelDetectionSpeed = LVPSA_SPEED_MEDIUM;
|
|
PSA_Status = LVPSA_Init (&hPSAInstance,
|
|
&pInstance->PSA_InitParams,
|
|
&pInstance->PSA_ControlParams,
|
|
&PSA_MemTab);
|
|
|
|
if (PSA_Status != LVPSA_OK)
|
|
{
|
|
return((LVM_ReturnStatus_en) LVM_ALGORITHMPSA);
|
|
}
|
|
|
|
pInstance->hPSAInstance = hPSAInstance; /* Save the instance handle */
|
|
pInstance->PSA_GainOffset = 0;
|
|
}
|
|
else
|
|
{
|
|
pInstance->hPSAInstance = LVM_NULL;
|
|
}
|
|
|
|
/*
|
|
* Set the initialisation parameters.
|
|
*/
|
|
pInstance->Params.PSA_PeakDecayRate = LVM_PSA_SPEED_MEDIUM;
|
|
pInstance->Params.PSA_Enable = LVM_PSA_OFF;
|
|
}
|
|
|
|
/*
|
|
* Copy the initial parameters to the new parameters for correct readback of
|
|
* the settings.
|
|
*/
|
|
pInstance->NewParams = pInstance->Params;
|
|
|
|
|
|
/*
|
|
* Create configuration number
|
|
*/
|
|
pInstance->ConfigurationNumber = 0x00000000;
|
|
pInstance->ConfigurationNumber += LVM_CS_MASK;
|
|
pInstance->ConfigurationNumber += LVM_EQNB_MASK;
|
|
pInstance->ConfigurationNumber += LVM_DBE_MASK;
|
|
pInstance->ConfigurationNumber += LVM_VC_MASK;
|
|
pInstance->ConfigurationNumber += LVM_PSA_MASK;
|
|
|
|
if(((pInstance->ConfigurationNumber & LVM_CS_MASK)!=0) ||
|
|
((pInstance->ConfigurationNumber & LVM_DBE_MASK)!=0) ||
|
|
((pInstance->ConfigurationNumber & LVM_EQNB_MASK)!=0)||
|
|
((pInstance->ConfigurationNumber & LVM_TE_MASK)!=0) ||
|
|
((pInstance->ConfigurationNumber & LVM_VC_MASK)!=0))
|
|
{
|
|
pInstance->BlickSizeMultiple = 4;
|
|
}
|
|
else
|
|
{
|
|
pInstance->BlickSizeMultiple = 1;
|
|
}
|
|
|
|
return(Status);
|
|
}
|
|
|
|
|
|
/****************************************************************************************/
|
|
/* */
|
|
/* FUNCTION: LVM_ClearAudioBuffers */
|
|
/* */
|
|
/* DESCRIPTION: */
|
|
/* This function is used to clear the internal audio buffers of the bundle. */
|
|
/* */
|
|
/* PARAMETERS: */
|
|
/* hInstance Instance handle */
|
|
/* */
|
|
/* RETURNS: */
|
|
/* LVM_SUCCESS Initialisation succeeded */
|
|
/* LVM_NULLADDRESS Instance or scratch memory has a NULL pointer */
|
|
/* */
|
|
/* NOTES: */
|
|
/* 1. This function must not be interrupted by the LVM_Process function */
|
|
/* */
|
|
/****************************************************************************************/
|
|
|
|
LVM_ReturnStatus_en LVM_ClearAudioBuffers(LVM_Handle_t hInstance)
|
|
{
|
|
LVM_MemTab_t MemTab; /* Memory table */
|
|
LVM_InstParams_t InstParams; /* Instance parameters */
|
|
LVM_ControlParams_t Params; /* Control Parameters */
|
|
LVM_Instance_t *pInstance = (LVM_Instance_t *)hInstance; /* Pointer to Instance */
|
|
|
|
|
|
if(hInstance == LVM_NULL){
|
|
return LVM_NULLADDRESS;
|
|
}
|
|
|
|
/* Save the control parameters */ /* coverity[unchecked_value] */ /* Do not check return value internal function calls */
|
|
LVM_GetControlParameters(hInstance, &Params);
|
|
|
|
/* Retrieve allocated buffers in memtab */
|
|
LVM_GetMemoryTable(hInstance, &MemTab, LVM_NULL);
|
|
|
|
/* Save the instance parameters */
|
|
InstParams = pInstance->InstParams;
|
|
|
|
/* Call LVM_GetInstanceHandle to re-initialise the bundle */
|
|
LVM_GetInstanceHandle( &hInstance,
|
|
&MemTab,
|
|
&InstParams);
|
|
|
|
/* Restore control parameters */ /* coverity[unchecked_value] */ /* Do not check return value internal function calls */
|
|
LVM_SetControlParameters(hInstance, &Params);
|
|
|
|
/* DC removal filter */
|
|
DC_2I_D16_TRC_WRA_01_Init(&pInstance->DC_RemovalInstance);
|
|
|
|
|
|
return LVM_SUCCESS;
|
|
}
|
|
|
|
|
|
|