/* * 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. */ /************************************************************************************ $Author: nxp007753 $ $Revision: 1331 $ $Date: 2010-07-27 12:26:23 +0200 (Tue, 27 Jul 2010) $ *************************************************************************************/ /************************************************************************************/ /* */ /* Includes */ /* */ /************************************************************************************/ #include "LVCS.h" #include "LVCS_Private.h" #include "LVCS_Tables.h" /****************************************************************************************/ /* */ /* FUNCTION: LVCS_Memory */ /* */ /* 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) it is */ /* passed the default capabilities. */ /* */ /* When called for memory allocation the memory base address pointers are NULL on */ /* return. */ /* */ /* When the function is called for free (hInstance = Instance Handle) the */ /* capabilities are ignored and 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 capabilites */ /* */ /* RETURNS: */ /* LVCS_Success Succeeded */ /* */ /* NOTES: */ /* 1. This function may be interrupted by the LVCS_Process function */ /* */ /****************************************************************************************/ LVCS_ReturnStatus_en LVCS_Memory(LVCS_Handle_t hInstance, LVCS_MemTab_t *pMemoryTable, LVCS_Capabilities_t *pCapabilities) { LVM_UINT32 ScratchSize; LVCS_Instance_t *pInstance = (LVCS_Instance_t *)hInstance; /* * Fill in the memory table */ if (hInstance == LVM_NULL) { /* * Instance memory */ pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_SLOW_DATA].Size = (LVM_UINT32)sizeof(LVCS_Instance_t); pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_SLOW_DATA].Type = LVCS_PERSISTENT; pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_SLOW_DATA].pBaseAddress = LVM_NULL; /* * Data memory */ pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].Size = (LVM_UINT32)sizeof(LVCS_Data_t); pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].Type = LVCS_DATA; pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].pBaseAddress = LVM_NULL; /* * Coefficient memory */ pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].Size = (LVM_UINT32)sizeof(LVCS_Coefficient_t); pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].Type = LVCS_COEFFICIENT; pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].pBaseAddress = LVM_NULL; /* * Scratch memory */ ScratchSize = (LVM_UINT32)(LVCS_SCRATCHBUFFERS*sizeof(LVM_INT16)*pCapabilities->MaxBlockSize); /* Inplace processing */ pMemoryTable->Region[LVCS_MEMREGION_TEMPORARY_FAST].Size = ScratchSize; pMemoryTable->Region[LVCS_MEMREGION_TEMPORARY_FAST].Type = LVCS_SCRATCH; pMemoryTable->Region[LVCS_MEMREGION_TEMPORARY_FAST].pBaseAddress = LVM_NULL; } else { /* Read back memory allocation table */ *pMemoryTable = pInstance->MemoryTable; } return(LVCS_SUCCESS); } /************************************************************************************/ /* */ /* FUNCTION: LVCS_Init */ /* */ /* DESCRIPTION: */ /* Create and initialisation function for the Concert Sound module */ /* */ /* This function can be used to create an algorithm instance by calling with */ /* hInstance set to LVM_NULL. In this case the algorithm returns the new instance */ /* handle. */ /* */ /* This function can be used to force a full re-initialisation of the algorithm */ /* by calling with hInstance = Instance Handle. In this case the memory table */ /* should be correct for the instance, this can be ensured by calling the function */ /* LVCS_Memory before calling this function. */ /* */ /* PARAMETERS: */ /* hInstance Instance handle */ /* pMemoryTable Pointer to the memory definition table */ /* pCapabilities Pointer to the capabilities structure */ /* */ /* RETURNS: */ /* LVCS_Success Initialisation succeeded */ /* */ /* NOTES: */ /* 1. The instance handle is the pointer to the base address of the first memory */ /* region. */ /* 2. This function must not be interrupted by the LVCS_Process function */ /* 3. This function must be called with the same capabilities as used for the */ /* call to the memory function */ /* */ /************************************************************************************/ LVCS_ReturnStatus_en LVCS_Init(LVCS_Handle_t *phInstance, LVCS_MemTab_t *pMemoryTable, LVCS_Capabilities_t *pCapabilities) { LVCS_Instance_t *pInstance; LVCS_VolCorrect_t *pLVCS_VolCorrectTable; /* * Set the instance handle if not already initialised */ if (*phInstance == LVM_NULL) { *phInstance = (LVCS_Handle_t)pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_SLOW_DATA].pBaseAddress; } pInstance =(LVCS_Instance_t *)*phInstance; /* * Save the capabilities in the instance structure */ pInstance->Capabilities = *pCapabilities; /* * Save the memory table in the instance structure */ pInstance->MemoryTable = *pMemoryTable; /* * Set all initial parameters to invalid to force a full initialisation */ pInstance->Params.OperatingMode = LVCS_OFF; pInstance->Params.SpeakerType = LVCS_SPEAKERTYPE_MAX; pInstance->OutputDevice = LVCS_HEADPHONE; pInstance->Params.SourceFormat = LVCS_SOURCEMAX; pInstance->Params.CompressorMode = LVM_MODE_OFF; pInstance->Params.SampleRate = LVM_FS_INVALID; pInstance->Params.EffectLevel = 0; pInstance->Params.ReverbLevel = (LVM_UINT16)0x8000; pLVCS_VolCorrectTable = (LVCS_VolCorrect_t*)&LVCS_VolCorrectTable[0]; pInstance->VolCorrect = pLVCS_VolCorrectTable[0]; pInstance->TransitionGain = 0; /* These current and target values are intialized again in LVCS_Control.c */ LVC_Mixer_Init(&pInstance->BypassMix.Mixer_Instance.MixerStream[0],0,0); /* These current and target values are intialized again in LVCS_Control.c */ LVC_Mixer_Init(&pInstance->BypassMix.Mixer_Instance.MixerStream[1],0,0); /* * Initialise the bypass variables */ pInstance->MSTarget0=0; pInstance->MSTarget1=0; pInstance->bInOperatingModeTransition = LVM_FALSE; pInstance->bTimerDone = LVM_FALSE; pInstance->TimerParams.CallBackParam = 0; pInstance->TimerParams.pCallBack = LVCS_TimerCallBack; pInstance->TimerParams.pCallbackInstance = pInstance; pInstance->TimerParams.pCallBackParams = LVM_NULL; return(LVCS_SUCCESS); }