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 /* */
21 /* Includes */
22 /* */
23 /****************************************************************************************/
24
25 #include "LVEQNB.h"
26 #include "LVEQNB_Private.h"
27 #include "InstAlloc.h"
28 #include <string.h> /* For memset */
29
30 /****************************************************************************************/
31 /* */
32 /* FUNCTION: LVEQNB_Memory */
33 /* */
34 /* DESCRIPTION: */
35 /* This function is used for memory allocation and free. It can be called in */
36 /* two ways: */
37 /* */
38 /* hInstance = NULL Returns the memory requirements */
39 /* hInstance = Instance handle Returns the memory requirements and */
40 /* allocated base addresses for the instance */
41 /* */
42 /* When this function is called for memory allocation (hInstance=NULL) the memory */
43 /* base address pointers are NULL on return. */
44 /* */
45 /* When the function is called for free (hInstance = Instance Handle) the memory */
46 /* table returns the allocated memory and base addresses used during initialisation. */
47 /* */
48 /* PARAMETERS: */
49 /* hInstance Instance Handle */
50 /* pMemoryTable Pointer to an empty memory definition table */
51 /* pCapabilities Pointer to the instance capabilities */
52 /* */
53 /* RETURNS: */
54 /* LVEQNB_SUCCESS Succeeded */
55 /* LVEQNB_NULLADDRESS When any of pMemoryTable and pCapabilities is NULL address */
56 /* */
57 /* NOTES: */
58 /* 1. This function may be interrupted by the LVEQNB_Process function */
59 /* */
60 /****************************************************************************************/
61
LVEQNB_Memory(LVEQNB_Handle_t hInstance,LVEQNB_MemTab_t * pMemoryTable,LVEQNB_Capabilities_t * pCapabilities)62 LVEQNB_ReturnStatus_en LVEQNB_Memory(LVEQNB_Handle_t hInstance,
63 LVEQNB_MemTab_t *pMemoryTable,
64 LVEQNB_Capabilities_t *pCapabilities)
65 {
66
67 INST_ALLOC AllocMem;
68 LVEQNB_Instance_t *pInstance = (LVEQNB_Instance_t *)hInstance;
69
70
71 if((pMemoryTable == LVM_NULL)|| (pCapabilities == LVM_NULL))
72 {
73 return LVEQNB_NULLADDRESS;
74 }
75
76
77 /*
78 * Fill in the memory table
79 */
80 if (hInstance == LVM_NULL)
81 {
82 /*
83 * Instance memory
84 */
85 InstAlloc_Init(&AllocMem,
86 LVM_NULL);
87 InstAlloc_AddMember(&AllocMem, /* Low pass filter */
88 sizeof(LVEQNB_Instance_t));
89 pMemoryTable->Region[LVEQNB_MEMREGION_INSTANCE].Size = InstAlloc_GetTotal(&AllocMem);
90 pMemoryTable->Region[LVEQNB_MEMREGION_INSTANCE].Alignment = LVEQNB_INSTANCE_ALIGN;
91 pMemoryTable->Region[LVEQNB_MEMREGION_INSTANCE].Type = LVEQNB_PERSISTENT;
92 pMemoryTable->Region[LVEQNB_MEMREGION_INSTANCE].pBaseAddress = LVM_NULL;
93
94
95 /*
96 * Persistant data memory
97 */
98 InstAlloc_Init(&AllocMem,
99 LVM_NULL);
100 InstAlloc_AddMember(&AllocMem, /* Low pass filter */
101 sizeof(Biquad_2I_Order2_Taps_t));
102 InstAlloc_AddMember(&AllocMem, /* High pass filter */
103 sizeof(Biquad_2I_Order2_Taps_t));
104 InstAlloc_AddMember(&AllocMem,
105 (pCapabilities->MaxBands * sizeof(Biquad_2I_Order2_Taps_t))); /* Equaliser Biquad Taps */
106 InstAlloc_AddMember(&AllocMem,
107 (pCapabilities->MaxBands * sizeof(LVEQNB_BandDef_t))); /* Filter definitions */
108 InstAlloc_AddMember(&AllocMem,
109 (pCapabilities->MaxBands * sizeof(LVEQNB_BiquadType_en))); /* Biquad types */
110 pMemoryTable->Region[LVEQNB_MEMREGION_PERSISTENT_DATA].Size = InstAlloc_GetTotal(&AllocMem);
111 pMemoryTable->Region[LVEQNB_MEMREGION_PERSISTENT_DATA].Alignment = LVEQNB_DATA_ALIGN;
112 pMemoryTable->Region[LVEQNB_MEMREGION_PERSISTENT_DATA].Type = LVEQNB_PERSISTENT_DATA;
113 pMemoryTable->Region[LVEQNB_MEMREGION_PERSISTENT_DATA].pBaseAddress = LVM_NULL;
114
115 /*
116 * Persistant coefficient memory
117 */
118 InstAlloc_Init(&AllocMem,
119 LVM_NULL);
120 InstAlloc_AddMember(&AllocMem, /* Low pass filter */
121 sizeof(Biquad_Instance_t));
122 InstAlloc_AddMember(&AllocMem, /* High pass filter */
123 sizeof(Biquad_Instance_t));
124 InstAlloc_AddMember(&AllocMem,
125 pCapabilities->MaxBands * sizeof(Biquad_Instance_t)); /* Equaliser Biquad Instance */
126 pMemoryTable->Region[LVEQNB_MEMREGION_PERSISTENT_COEF].Size = InstAlloc_GetTotal(&AllocMem);
127 pMemoryTable->Region[LVEQNB_MEMREGION_PERSISTENT_COEF].Alignment = LVEQNB_COEF_ALIGN;
128 pMemoryTable->Region[LVEQNB_MEMREGION_PERSISTENT_COEF].Type = LVEQNB_PERSISTENT_COEF;
129 pMemoryTable->Region[LVEQNB_MEMREGION_PERSISTENT_COEF].pBaseAddress = LVM_NULL;
130
131 /*
132 * Scratch memory
133 */
134 InstAlloc_Init(&AllocMem,
135 LVM_NULL);
136 InstAlloc_AddMember(&AllocMem, /* Low pass filter */
137 LVEQNB_SCRATCHBUFFERS*sizeof(LVM_INT16)*pCapabilities->MaxBlockSize);
138 pMemoryTable->Region[LVEQNB_MEMREGION_SCRATCH].Size = InstAlloc_GetTotal(&AllocMem);
139 pMemoryTable->Region[LVEQNB_MEMREGION_SCRATCH].Alignment = LVEQNB_SCRATCH_ALIGN;
140 pMemoryTable->Region[LVEQNB_MEMREGION_SCRATCH].Type = LVEQNB_SCRATCH;
141 pMemoryTable->Region[LVEQNB_MEMREGION_SCRATCH].pBaseAddress = LVM_NULL;
142 }
143 else
144 {
145 /* Read back memory allocation table */
146 *pMemoryTable = pInstance->MemoryTable;
147 }
148
149 return(LVEQNB_SUCCESS);
150 }
151
152
153 /****************************************************************************************/
154 /* */
155 /* FUNCTION: LVEQNB_Init */
156 /* */
157 /* DESCRIPTION: */
158 /* Create and initialisation function for the N-Band equaliser module */
159 /* */
160 /* This function can be used to create an algorithm instance by calling with */
161 /* hInstance set to NULL. In this case the algorithm returns the new instance */
162 /* handle. */
163 /* */
164 /* This function can be used to force a full re-initialisation of the algorithm */
165 /* by calling with hInstance = Instance Handle. In this case the memory table */
166 /* should be correct for the instance, this can be ensured by calling the function */
167 /* DBE_Memory before calling this function. */
168 /* */
169 /* PARAMETERS: */
170 /* hInstance Instance handle */
171 /* pMemoryTable Pointer to the memory definition table */
172 /* pCapabilities Pointer to the instance capabilities */
173 /* */
174 /* RETURNS: */
175 /* LVEQNB_SUCCESS Initialisation succeeded */
176 /* LVEQNB_NULLADDRESS When pCapabilities or pMemoryTableis or phInstance are NULL */
177 /* LVEQNB_NULLADDRESS One or more of the memory regions has a NULL base address */
178 /* pointer for a memory region with a non-zero size. */
179 /* */
180 /* NOTES: */
181 /* 1. The instance handle is the pointer to the base address of the first memory */
182 /* region. */
183 /* 2. This function must not be interrupted by the LVEQNB_Process function */
184 /* */
185 /****************************************************************************************/
186
LVEQNB_Init(LVEQNB_Handle_t * phInstance,LVEQNB_MemTab_t * pMemoryTable,LVEQNB_Capabilities_t * pCapabilities)187 LVEQNB_ReturnStatus_en LVEQNB_Init(LVEQNB_Handle_t *phInstance,
188 LVEQNB_MemTab_t *pMemoryTable,
189 LVEQNB_Capabilities_t *pCapabilities)
190 {
191
192 LVEQNB_Instance_t *pInstance;
193 LVM_UINT32 MemSize;
194 INST_ALLOC AllocMem;
195 LVM_INT32 i;
196
197 /*
198 * Check for NULL pointers
199 */
200 if((phInstance == LVM_NULL) || (pMemoryTable == LVM_NULL) || (pCapabilities == LVM_NULL))
201 {
202 return LVEQNB_NULLADDRESS;
203 }
204
205 /*
206 * Check the memory table for NULL pointers
207 */
208 for (i = 0; i < LVEQNB_NR_MEMORY_REGIONS; i++)
209 {
210 if (pMemoryTable->Region[i].Size!=0)
211 {
212 if (pMemoryTable->Region[i].pBaseAddress==LVM_NULL)
213 {
214 return(LVEQNB_NULLADDRESS);
215 }
216 }
217 }
218
219 /*
220 * Set the instance handle if not already initialised
221 */
222
223 InstAlloc_Init(&AllocMem, pMemoryTable->Region[LVEQNB_MEMREGION_INSTANCE].pBaseAddress);
224
225 if (*phInstance == LVM_NULL)
226 {
227 *phInstance = InstAlloc_AddMember(&AllocMem, sizeof(LVEQNB_Instance_t));
228 }
229 pInstance =(LVEQNB_Instance_t *)*phInstance;
230
231
232
233 /*
234 * Save the memory table in the instance structure
235 */
236 pInstance->Capabilities = *pCapabilities;
237
238
239 /*
240 * Save the memory table in the instance structure and
241 * set the structure pointers
242 */
243 pInstance->MemoryTable = *pMemoryTable;
244
245 /*
246 * Allocate coefficient memory
247 */
248 InstAlloc_Init(&AllocMem,
249 pMemoryTable->Region[LVEQNB_MEMREGION_PERSISTENT_COEF].pBaseAddress);
250
251 pInstance->pEQNB_FilterState = InstAlloc_AddMember(&AllocMem,
252 pCapabilities->MaxBands * sizeof(Biquad_Instance_t)); /* Equaliser Biquad Instance */
253
254
255
256 /*
257 * Allocate data memory
258 */
259 InstAlloc_Init(&AllocMem,
260 pMemoryTable->Region[LVEQNB_MEMREGION_PERSISTENT_DATA].pBaseAddress);
261
262 MemSize = (pCapabilities->MaxBands * sizeof(Biquad_2I_Order2_Taps_t));
263 pInstance->pEQNB_Taps = (Biquad_2I_Order2_Taps_t *)InstAlloc_AddMember(&AllocMem,
264 MemSize);
265 MemSize = (pCapabilities->MaxBands * sizeof(LVEQNB_BandDef_t));
266 pInstance->pBandDefinitions = (LVEQNB_BandDef_t *)InstAlloc_AddMember(&AllocMem,
267 MemSize);
268 // clear all the bands, setting their gain to 0, otherwise when applying new params,
269 // it will compare against uninitialized values
270 memset(pInstance->pBandDefinitions, 0, MemSize);
271 MemSize = (pCapabilities->MaxBands * sizeof(LVEQNB_BiquadType_en));
272 pInstance->pBiquadType = (LVEQNB_BiquadType_en *)InstAlloc_AddMember(&AllocMem,
273 MemSize);
274
275
276 /*
277 * Internally map, structure and allign scratch memory
278 */
279 InstAlloc_Init(&AllocMem,
280 pMemoryTable->Region[LVEQNB_MEMREGION_SCRATCH].pBaseAddress);
281
282 pInstance->pFastTemporary = (LVM_INT16 *)InstAlloc_AddMember(&AllocMem,
283 sizeof(LVM_INT16));
284
285 /*
286 * Update the instance parameters
287 */
288 pInstance->Params.NBands = 0;
289 pInstance->Params.OperatingMode = LVEQNB_BYPASS;
290 pInstance->Params.pBandDefinition = LVM_NULL;
291 pInstance->Params.SampleRate = LVEQNB_FS_8000;
292 pInstance->Params.SourceFormat = LVEQNB_STEREO;
293
294 /*
295 * Initialise the filters
296 */
297 LVEQNB_SetFilters(pInstance, /* Set the filter types */
298 &pInstance->Params);
299
300 LVEQNB_SetCoefficients(pInstance); /* Set the filter coefficients */
301
302 LVEQNB_ClearFilterHistory(pInstance); /* Clear the filter history */
303
304 /*
305 * Initialise the bypass variables
306 */
307 pInstance->BypassMixer.MixerStream[0].CallbackSet = 0;
308 pInstance->BypassMixer.MixerStream[0].CallbackParam = 0;
309 pInstance->BypassMixer.MixerStream[0].pCallbackHandle = (void*)pInstance;
310 pInstance->BypassMixer.MixerStream[0].pCallBack = LVEQNB_BypassMixerCallBack;
311 LVC_Mixer_Init(&pInstance->BypassMixer.MixerStream[0],0,0);
312 LVC_Mixer_SetTimeConstant(&pInstance->BypassMixer.MixerStream[0],0,LVM_FS_8000,2);
313
314 pInstance->BypassMixer.MixerStream[1].CallbackSet = 1;
315 pInstance->BypassMixer.MixerStream[1].CallbackParam = 0;
316 pInstance->BypassMixer.MixerStream[1].pCallbackHandle = LVM_NULL;
317 pInstance->BypassMixer.MixerStream[1].pCallBack = LVM_NULL;
318 LVC_Mixer_Init(&pInstance->BypassMixer.MixerStream[1],0,LVM_MAXINT_16);
319 LVC_Mixer_SetTimeConstant(&pInstance->BypassMixer.MixerStream[1],0,LVM_FS_8000,2);
320
321 pInstance->bInOperatingModeTransition = LVM_FALSE;
322
323 return(LVEQNB_SUCCESS);
324 }
325
326