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 "LVCS.h" 25#include "LVCS_Private.h" 26#include "LVCS_Tables.h" 27 28/****************************************************************************************/ 29/* */ 30/* FUNCTION: LVCS_Memory */ 31/* */ 32/* DESCRIPTION: */ 33/* This function is used for memory allocation and free. It can be called in */ 34/* two ways: */ 35/* */ 36/* hInstance = NULL Returns the memory requirements */ 37/* hInstance = Instance handle Returns the memory requirements and */ 38/* allocated base addresses for the instance */ 39/* */ 40/* When this function is called for memory allocation (hInstance=NULL) it is */ 41/* passed the default capabilities. */ 42/* */ 43/* When called for memory allocation the memory base address pointers are NULL on */ 44/* return. */ 45/* */ 46/* When the function is called for free (hInstance = Instance Handle) the */ 47/* capabilities are ignored and the memory table returns the allocated memory and */ 48/* base addresses used during initialisation. */ 49/* */ 50/* PARAMETERS: */ 51/* hInstance Instance Handle */ 52/* pMemoryTable Pointer to an empty memory definition table */ 53/* pCapabilities Pointer to the default capabilites */ 54/* */ 55/* RETURNS: */ 56/* LVCS_Success Succeeded */ 57/* */ 58/* NOTES: */ 59/* 1. This function may be interrupted by the LVCS_Process function */ 60/* */ 61/****************************************************************************************/ 62 63LVCS_ReturnStatus_en LVCS_Memory(LVCS_Handle_t hInstance, 64 LVCS_MemTab_t *pMemoryTable, 65 LVCS_Capabilities_t *pCapabilities) 66{ 67 68 LVM_UINT32 ScratchSize; 69 LVCS_Instance_t *pInstance = (LVCS_Instance_t *)hInstance; 70 71 72 /* 73 * Fill in the memory table 74 */ 75 if (hInstance == LVM_NULL) 76 { 77 /* 78 * Instance memory 79 */ 80 pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_SLOW_DATA].Size = (LVM_UINT32)sizeof(LVCS_Instance_t); 81 pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_SLOW_DATA].Type = LVCS_PERSISTENT; 82 pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_SLOW_DATA].pBaseAddress = LVM_NULL; 83 84 /* 85 * Data memory 86 */ 87 pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].Size = (LVM_UINT32)sizeof(LVCS_Data_t); 88 pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].Type = LVCS_DATA; 89 pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_FAST_DATA].pBaseAddress = LVM_NULL; 90 91 /* 92 * Coefficient memory 93 */ 94 pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].Size = (LVM_UINT32)sizeof(LVCS_Coefficient_t); 95 pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].Type = LVCS_COEFFICIENT; 96 pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_FAST_COEF].pBaseAddress = LVM_NULL; 97 98 /* 99 * Scratch memory 100 */ 101 ScratchSize = (LVM_UINT32)(LVCS_SCRATCHBUFFERS*sizeof(LVM_INT16)*pCapabilities->MaxBlockSize); /* Inplace processing */ 102 pMemoryTable->Region[LVCS_MEMREGION_TEMPORARY_FAST].Size = ScratchSize; 103 pMemoryTable->Region[LVCS_MEMREGION_TEMPORARY_FAST].Type = LVCS_SCRATCH; 104 pMemoryTable->Region[LVCS_MEMREGION_TEMPORARY_FAST].pBaseAddress = LVM_NULL; 105 } 106 else 107 { 108 /* Read back memory allocation table */ 109 *pMemoryTable = pInstance->MemoryTable; 110 } 111 112 return(LVCS_SUCCESS); 113} 114 115 116/************************************************************************************/ 117/* */ 118/* FUNCTION: LVCS_Init */ 119/* */ 120/* DESCRIPTION: */ 121/* Create and initialisation function for the Concert Sound module */ 122/* */ 123/* This function can be used to create an algorithm instance by calling with */ 124/* hInstance set to LVM_NULL. In this case the algorithm returns the new instance */ 125/* handle. */ 126/* */ 127/* This function can be used to force a full re-initialisation of the algorithm */ 128/* by calling with hInstance = Instance Handle. In this case the memory table */ 129/* should be correct for the instance, this can be ensured by calling the function */ 130/* LVCS_Memory before calling this function. */ 131/* */ 132/* PARAMETERS: */ 133/* hInstance Instance handle */ 134/* pMemoryTable Pointer to the memory definition table */ 135/* pCapabilities Pointer to the capabilities structure */ 136/* */ 137/* RETURNS: */ 138/* LVCS_Success Initialisation succeeded */ 139/* */ 140/* NOTES: */ 141/* 1. The instance handle is the pointer to the base address of the first memory */ 142/* region. */ 143/* 2. This function must not be interrupted by the LVCS_Process function */ 144/* 3. This function must be called with the same capabilities as used for the */ 145/* call to the memory function */ 146/* */ 147/************************************************************************************/ 148 149LVCS_ReturnStatus_en LVCS_Init(LVCS_Handle_t *phInstance, 150 LVCS_MemTab_t *pMemoryTable, 151 LVCS_Capabilities_t *pCapabilities) 152{ 153 154 LVCS_Instance_t *pInstance; 155 LVCS_VolCorrect_t *pLVCS_VolCorrectTable; 156 157 158 /* 159 * Set the instance handle if not already initialised 160 */ 161 if (*phInstance == LVM_NULL) 162 { 163 *phInstance = (LVCS_Handle_t)pMemoryTable->Region[LVCS_MEMREGION_PERSISTENT_SLOW_DATA].pBaseAddress; 164 } 165 pInstance =(LVCS_Instance_t *)*phInstance; 166 167 168 /* 169 * Save the capabilities in the instance structure 170 */ 171 pInstance->Capabilities = *pCapabilities; 172 173 /* 174 * Save the memory table in the instance structure 175 */ 176 pInstance->MemoryTable = *pMemoryTable; 177 178 179 /* 180 * Set all initial parameters to invalid to force a full initialisation 181 */ 182 pInstance->Params.OperatingMode = LVCS_OFF; 183 pInstance->Params.SpeakerType = LVCS_SPEAKERTYPE_MAX; 184 pInstance->OutputDevice = LVCS_HEADPHONE; 185 pInstance->Params.SourceFormat = LVCS_SOURCEMAX; 186 pInstance->Params.CompressorMode = LVM_MODE_OFF; 187 pInstance->Params.SampleRate = LVM_FS_INVALID; 188 pInstance->Params.EffectLevel = 0; 189 pInstance->Params.ReverbLevel = (LVM_UINT16)0x8000; 190 pLVCS_VolCorrectTable = (LVCS_VolCorrect_t*)&LVCS_VolCorrectTable[0]; 191 pInstance->VolCorrect = pLVCS_VolCorrectTable[0]; 192 pInstance->TransitionGain = 0; 193 /* These current and target values are intialized again in LVCS_Control.c */ 194 LVC_Mixer_Init(&pInstance->BypassMix.Mixer_Instance.MixerStream[0],0,0); 195 /* These current and target values are intialized again in LVCS_Control.c */ 196 LVC_Mixer_Init(&pInstance->BypassMix.Mixer_Instance.MixerStream[1],0,0); 197 198 /* 199 * Initialise the bypass variables 200 */ 201 pInstance->MSTarget0=0; 202 pInstance->MSTarget1=0; 203 pInstance->bInOperatingModeTransition = LVM_FALSE; 204 pInstance->bTimerDone = LVM_FALSE; 205 pInstance->TimerParams.CallBackParam = 0; 206 pInstance->TimerParams.pCallBack = LVCS_TimerCallBack; 207 pInstance->TimerParams.pCallbackInstance = pInstance; 208 pInstance->TimerParams.pCallBackParams = LVM_NULL; 209 210 return(LVCS_SUCCESS); 211} 212 213