DSPLIB User Guide
DSPLIB_cascadeBiquad_ci.cpp
Go to the documentation of this file.
1 /******************************************************************************/
5 /* Copyright (C) 2017 Texas Instruments Incorporated - https://www.ti.com/
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * Redistributions of source code must retain the above copyright
12  * notice, this list of conditions and the following disclaimer.
13  *
14  * Redistributions in binary form must reproduce the above copyright
15  * notice, this list of conditions and the following disclaimer in the
16  * documentation and/or other materials provided with the
17  * distribution.
18  *
19  * Neither the name of Texas Instruments Incorporated nor the names of
20  * its contributors may be used to endorse or promote products derived
21  * from this software without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34  *
35  ******************************************************************************/
36 
37 /******************************************************************************
38  * Version 1.0 Date 4/13/22 Author: Asheesh Bhardwaj
39  *****************************************************************************/
40 
41 /*******************************************************************************
42  *
43  * INCLUDES
44  *
45  ******************************************************************************/
46 
47 #include "../common/c71/DSPLIB_inlines.h"
48 #include "DSPLIB_cascadeBiquad_priv.h"
49 
50 /*******************************************************************************
51  *
52  * DEFINES
53  *
54  ******************************************************************************/
55 
56 template <typename dataType>
57 DSPLIB_STATUS DSPLIB_cascadeBiquad_init_ci(DSPLIB_kernelHandle handle,
58  const DSPLIB_bufParams2D_t *bufParamsIn,
59  const DSPLIB_bufParams1D_t *bufParamsFilterCoeff,
60  const DSPLIB_bufParams2D_t *bufParamsFilterVar,
61  const DSPLIB_bufParams2D_t *bufParamsOut,
62  const DSPLIB_cascadeBiquad_InitArgs *pKerInitArgs)
63 {
64  DSPLIB_STATUS status = DSPLIB_SUCCESS;
65  __SE_TEMPLATE_v1 se0Params;
66  __SE_TEMPLATE_v1 se1Params;
67  __SA_TEMPLATE_v1 sa0Params;
68  __SA_TEMPLATE_v1 sa1Params;
69 
70  DSPLIB_cascadeBiquad_PrivArgs *pKerPrivArgs = (DSPLIB_cascadeBiquad_PrivArgs *) handle;
71  uint8_t *pBlock = pKerPrivArgs->bufPblock;
72  uint32_t dataSize = pKerPrivArgs->initArgs.dataSize;
73  uint32_t numChannels = pKerPrivArgs->initArgs.numChannels;
74  uint32_t numStages = pKerPrivArgs->initArgs.numStages;
75  uint32_t dataBufferInPitch = pKerPrivArgs->dataBufferInPitch;
76  uint32_t dataBufferOutPitch = pKerPrivArgs->dataBufferOutPitch;
77  uint32_t filterVarPitch = pKerPrivArgs->filterVarPitch;
78 
79  __SE_ELETYPE SE_ELETYPE;
80  __SE_VECLEN SE_VECLEN;
81  __SA_VECLEN SA_VECLEN;
82 
83  typedef typename c7x::make_full_vector<dataType>::type vec;
84  SE_VECLEN = c7x::se_veclen<vec>::value;
85  SA_VECLEN = c7x::sa_veclen<vec>::value;
86  SE_ELETYPE = c7x::se_eletype<vec>::value;
87 
88  uint32_t eleCount = c7x::element_count_of<vec>::value;
89 
90 #if DSPLIB_DEBUGPRINT
91  printf("DSPLIB_DEBUGPRINT SE_VECLEN: %d, SA_VECLEN: %d, SE_ELETYPE: %d "
92  "numChannels %d numStages %d\n",
93  SE_VECLEN, SA_VECLEN, SE_ELETYPE, numChannels, numStages);
94  printf("DSPLIB_DEBUGPRINT SE_VECLEN: %d, SA_VECLEN: %d, SE_ELETYPE: %d "
95  "eleCount %d\n",
96  SE_VECLEN, SA_VECLEN, SE_ELETYPE, eleCount);
97 #endif
98 
99  uint32_t icnt1Param = (numChannels > eleCount) ? eleCount : numChannels;
100  icnt1Param = (icnt1Param == 0) ? 1 : icnt1Param;
101  uint32_t icnt2Param =
102  (numChannels % eleCount == 0) ? (numChannels / eleCount) : (numChannels + eleCount) / eleCount;
103 
104  /**********************************************************************/
105  /* Prepare streaming engine 1 to fetch the input */
106  /**********************************************************************/
107  se1Params = __gen_SE_TEMPLATE_v1();
108 
109  se1Params.ICNT0 = icnt1Param;
110  se1Params.ICNT1 = dataSize;
111  se1Params.DIM1 = (int32_t) dataBufferInPitch;
112  se1Params.ICNT2 = icnt2Param;
113  se1Params.DIM2 = eleCount;
114  se1Params.ELETYPE = SE_ELETYPE;
115  se1Params.VECLEN = SE_VECLEN;
116  se1Params.DECDIM1_WIDTH = numChannels;
117  se1Params.DECDIM1 = __SE_DECDIM_DIM2;
118  se1Params.DIMFMT = __SE_DIMFMT_3D;
119  /**********************************************************************/
120  /* Prepare streaming engine 0 to fetch filter variables */
121  /**********************************************************************/
122  se0Params = __gen_SE_TEMPLATE_v1();
123  se0Params.ICNT0 = icnt1Param;
124  se0Params.ICNT1 = numStages * 2;
125  se0Params.DIM1 = (int32_t) filterVarPitch;
126  se0Params.ICNT2 = icnt2Param;
127  se0Params.DIM2 = eleCount;
128  se0Params.ELETYPE = SE_ELETYPE;
129  se0Params.VECLEN = SE_VECLEN;
130  se0Params.DECDIM1_WIDTH = numChannels;
131  se0Params.DECDIM1 = __SE_DECDIM_DIM2;
132  se0Params.DIMFMT = __SE_DIMFMT_3D;
133 
134  /**********************************************************************/
135  /* Prepare SA template to store output */
136  /**********************************************************************/
137  sa0Params = __gen_SA_TEMPLATE_v1();
138 
139  sa0Params.ICNT0 = icnt1Param;
140  sa0Params.ICNT1 = dataSize;
141  sa0Params.DIM1 = (int32_t) dataBufferOutPitch;
142  sa0Params.ICNT2 = icnt2Param;
143  sa0Params.DIM2 = eleCount;
144  sa0Params.DECDIM1_WIDTH = numChannels;
145  sa0Params.DECDIM1 = __SA_DECDIM_DIM2;
146  sa0Params.DECDIM2_WIDTH = dataBufferOutPitch * dataSize;
147  sa0Params.DECDIM2 = __SA_DECDIM_DIM2;
148  sa0Params.VECLEN = SA_VECLEN;
149  sa0Params.DIMFMT = __SA_DIMFMT_3D;
150 
151  /**********************************************************************/
152  /* Prepare SA template to store filter variables */
153  /**********************************************************************/
154  sa1Params = __gen_SA_TEMPLATE_v1();
155 
156  sa1Params.ICNT0 = icnt1Param;
157  sa1Params.ICNT1 = numStages * 2;
158  sa1Params.DIM1 = (int32_t) filterVarPitch;
159  sa1Params.ICNT2 = icnt2Param;
160  sa1Params.DIM2 = eleCount;
161  sa1Params.DECDIM1_WIDTH = numChannels;
162  sa1Params.DECDIM1 = __SA_DECDIM_DIM2;
163  sa1Params.VECLEN = SA_VECLEN;
164  sa1Params.DIMFMT = __SA_DIMFMT_3D;
165 
166  *(__SE_TEMPLATE_v1 *) ((uint8_t *) pBlock + SE_SE0_PARAM_OFFSET) = se0Params;
167  *(__SE_TEMPLATE_v1 *) ((uint8_t *) pBlock + SE_SE1_PARAM_OFFSET) = se1Params;
168  *(__SA_TEMPLATE_v1 *) ((uint8_t *) pBlock + SE_SA0_PARAM_OFFSET) = sa0Params;
169  *(__SA_TEMPLATE_v1 *) ((uint8_t *) pBlock + SE_SA1_PARAM_OFFSET) = sa1Params;
170 
171  return status;
172 }
173 template <typename dataType> static inline dataType fast_recip(dataType x)
174 {
175  typedef typename c7x::make_full_vector<dataType>::type vec;
176 
177  vec a = (vec) x;
178  vec f = __recip(a);
179  f = f * (2 - a * f);
180  f = f * (2 - a * f);
181  f = f * (2 - a * f);
182  vec out = f * (2 - a * f);
183  return out.s[0];
184 }
185 
186 template DSPLIB_STATUS DSPLIB_cascadeBiquad_init_ci<float>(DSPLIB_kernelHandle handle,
187  const DSPLIB_bufParams2D_t *bufParamsIn,
188  const DSPLIB_bufParams1D_t *bufParamsFilterCoeff,
189  const DSPLIB_bufParams2D_t *bufParamsFilterVar,
190  const DSPLIB_bufParams2D_t *bufParamsOut,
191  const DSPLIB_cascadeBiquad_InitArgs *pKerInitArgs);
192 /*******************************************************************************
193  *
194  * EXECUTION FUNCTIONS
195  *
196  ******************************************************************************/
197 
198 template <typename dataType>
199 DSPLIB_STATUS DSPLIB_cascadeBiquad_exec_ci(DSPLIB_kernelHandle handle,
200  void *restrict pIn,
201  void *restrict pFilterCoeff,
202  void *restrict pFilterVar,
203  void *restrict pOut)
204 {
205  __SE_TEMPLATE_v1 se0Params;
206  __SE_TEMPLATE_v1 se1Params;
207  __SA_TEMPLATE_v1 sa0Params;
208  __SA_TEMPLATE_v1 sa1Params;
209 
210  DSPLIB_cascadeBiquad_PrivArgs *pKerPrivArgs = (DSPLIB_cascadeBiquad_PrivArgs *) handle;
211  uint8_t *pBlock = pKerPrivArgs->bufPblock;
212  uint32_t dataSize = pKerPrivArgs->initArgs.dataSize;
213  uint32_t numStages = pKerPrivArgs->initArgs.numStages;
214  uint32_t numChannels = pKerPrivArgs->initArgs.numChannels;
215 
216  dataType *pInLocal = (dataType *) pIn;
217  dataType *pFilterCoeffLocal = (dataType *) pFilterCoeff;
218  dataType *pFilterVarLocal = (dataType *) pFilterVar;
219  dataType *pOutLocal = (dataType *) pOut;
220 
221 #if DSPLIB_DEBUGPRINT
222  printf("Enter DSPLIB_cascadeBiquad_exec_ci\n");
223 #endif
224 
225  typedef typename c7x::make_full_vector<dataType>::type vec;
226  int eleCount = c7x::element_count_of<vec>::value;
227 
228  vec input;
229  // vec filter;
230 
231 #if DSPLIB_DEBUGPRINT
232  printf("Enter pFilter %p\n", pFilterCoeff);
233 #endif
234 
235  // Filter coefficient
236  se0Params = *(__SE_TEMPLATE_v1 *) ((uint8_t *) pBlock + SE_SE0_PARAM_OFFSET);
237  __SE0_OPEN(pFilterVarLocal, se0Params);
238 
239  // Input samples
240  se1Params = *(__SE_TEMPLATE_v1 *) ((uint8_t *) pBlock + SE_SE1_PARAM_OFFSET);
241  __SE1_OPEN(pInLocal, se1Params);
242 
243  // Output samples
244  sa0Params = *(__SA_TEMPLATE_v1 *) ((uint8_t *) pBlock + SE_SA0_PARAM_OFFSET);
245  __SA0_OPEN(sa0Params);
246 
247  // Filter variables read and write
248  sa1Params = *(__SA_TEMPLATE_v1 *) ((uint8_t *) pBlock + SE_SA1_PARAM_OFFSET);
249  __SA1_OPEN(sa1Params);
250 
251 #if DSPLIB_DEBUGPRINT
252  printf("DSPLIB_DEBUGPRINT dataSize %d numChannels %d numStages %d pOutLocal "
253  "%p\n",
254  dataSize, numChannels, numStages, pOutLocal);
255 #endif
256 
257  vec output1, output2, output3;
258  vec temp1_mul_1, temp0_mul_1, d0_temp_1, d1_mul_1;
259  vec temp1_mul_2, temp0_mul_2, d0_temp_2, d1_mul_2;
260  vec temp1_mul_3, temp0_mul_3, d0_temp_3, d1_mul_3;
261  vec temp1_add_1, temp1_add_2, temp1_add_3;
262 
263  dataType coeff0 = pFilterCoeffLocal[0];
264  // printf("\ncoeff0: %10g\n", coeff0);
265  vec b10 = (vec) (coeff0); // pFilterCoeffLocal[0];
266  vec r = (vec) (fast_recip<dataType>(coeff0));
267  vec b11 = pFilterCoeffLocal[1] * r;
268  vec b12 = pFilterCoeffLocal[2] * r;
269  vec a11 = (vec) (-1 * pFilterCoeffLocal[3]);
270  vec a12 = (vec) (-1 * pFilterCoeffLocal[4]);
271 
272  vec b20, b21, b22, a21, a22;
273  if (numStages >= 2) {
274  coeff0 = pFilterCoeffLocal[5];
275  b20 = (vec) (coeff0); // pFilterCoeffLocal[5];
276  r = (vec) fast_recip<dataType>(coeff0);
277  b21 = pFilterCoeffLocal[6] * r;
278  b22 = pFilterCoeffLocal[7] * r;
279  a21 = -pFilterCoeffLocal[8];
280  a22 = -pFilterCoeffLocal[9];
281  }
282  else {
283  // if second stage is unused, create coefficients of unity transfer function
284  b20 = (vec) 1.0;
285  b21 = (vec) 0;
286  b22 = (vec) 0;
287  a21 = (vec) 0;
288  a22 = (vec) 0;
289  }
290 
291  vec b30, b31, b32, a31, a32;
292  if (numStages >= 3) {
293  coeff0 = pFilterCoeffLocal[10];
294  b30 = (vec) (coeff0); // pFilterCoeffLocal[10];
295  r = (vec) fast_recip<dataType>(coeff0);
296  b31 = pFilterCoeffLocal[11] * r;
297  b32 = pFilterCoeffLocal[12] * r;
298  a31 = -pFilterCoeffLocal[13];
299  a32 = -pFilterCoeffLocal[14];
300  }
301  else {
302  // if third stage is unused, create coefficients of unity transfer function
303  b30 = (vec) 1.0;
304  b31 = (vec) 0;
305  b32 = (vec) 0;
306  a31 = (vec) 0;
307  a32 = (vec) 0;
308  }
309  /* Get the filter states into corresponding regs */
310 
311  vec outGain = b10 * b20 * b30; // Final output gain rescales based on b0 term
312 
313  vec b11_a11 = b11 + a11;
314  vec b12_a12 = b12 + a12;
315  vec b21_a21 = b21 + a21;
316  vec b22_a22 = b22 + a22;
317  vec b31_a31 = b31 + a31;
318  vec b32_a32 = b32 + a32;
319 
320 #if DSPLIB_DEBUGPRINT
321  DSPLIB_debugPrintVector(outGain);
322 // DSPLIB_debugPrintVector(b10);
323 // DSPLIB_debugPrintVector(b11);
324 // DSPLIB_debugPrintVector(b12);
325 // DSPLIB_debugPrintVector(b20);
326 // DSPLIB_debugPrintVector(b21);
327 // DSPLIB_debugPrintVector(b22);
328 // DSPLIB_debugPrintVector(b30);
329 // DSPLIB_debugPrintVector(b31);
330 // DSPLIB_debugPrintVector(b32);
331 #endif
332 
333  for (uint32_t chCount = 0; chCount < numChannels; chCount += eleCount) {
334  // Read filter variables
335  vec filtVars_d0_1 = c7x::strm_eng<0, vec>::get_adv();
336  vec filtVars_d1_1 = c7x::strm_eng<0, vec>::get_adv();
337  vec filtVars_d0_2 = c7x::strm_eng<0, vec>::get_adv();
338  vec filtVars_d1_2 = c7x::strm_eng<0, vec>::get_adv();
339  vec filtVars_d0_3 = c7x::strm_eng<0, vec>::get_adv();
340  vec filtVars_d1_3 = c7x::strm_eng<0, vec>::get_adv();
341 
342 #if DSPLIB_DEBUGPRINT
343 // DSPLIB_debugPrintVector(filtVars_d0_1);
344 // DSPLIB_debugPrintVector(filtVars_d1_1);
345 // DSPLIB_debugPrintVector(filtVars_d0_2);
346 // DSPLIB_debugPrintVector(filtVars_d1_2);
347 // DSPLIB_debugPrintVector(filtVars_d0_3);
348 // DSPLIB_debugPrintVector(filtVars_d1_3);
349 #endif
350  for (uint32_t samp = 0; samp < dataSize; samp++) {
351  // multi channel second stage
352  input = c7x::strm_eng<1, vec>::get();
353 #if DSPLIB_DEBUGPRINT
354 // DSPLIB_debugPrintVector(input);
355 #endif
356  output1 = input + filtVars_d0_1; // output1 = input1 + vd01;
357  temp1_mul_1 = input * b11_a11; // t1 = (((b11 + a11) * input1) + vd11) ;
358  temp1_add_1 = temp1_mul_1 + filtVars_d1_1;
359  temp0_mul_1 = a12 * filtVars_d0_1; // t0 = (a12 * vd01);
360  d0_temp_1 = a11 * filtVars_d0_1; // vd01 = ((a11 * vd01) + t1) ;
361  filtVars_d0_1 = d0_temp_1 + temp1_add_1;
362  input = c7x::strm_eng<1, vec>::get_adv();
363  d1_mul_1 = b12_a12 * input; // vd11 = (((b12 + a12) * input1) + t0) ;
364  filtVars_d1_1 = d1_mul_1 + temp0_mul_1;
365 
366  // multi channel second stage
367  output2 = output1 + filtVars_d0_2; // output2 = (output01 + vd02);
368  temp1_mul_2 = b21_a21 * output1; // t3 = (((b21 + a21) * output01) + vd12);
369  temp1_add_2 = temp1_mul_2 + filtVars_d1_2;
370  temp0_mul_2 = a22 * filtVars_d0_2; // t2 = (a22 * vd02);
371  d0_temp_2 = a21 * filtVars_d0_2; // vd02 = ((a21 * vd02) + t3) ;
372  filtVars_d0_2 = d0_temp_2 + temp1_add_2;
373  d1_mul_2 = b22_a22 * output1; // vd12 = (((b22 + a22) * output01) + t2) ;
374  filtVars_d1_2 = d1_mul_2 + temp0_mul_2;
375 
376  // multi channel third stage
377  output3 = output2 + filtVars_d0_3; // output3 = (output02 + vd03);
378  temp1_mul_3 = b31_a31 * output2;
379  temp1_add_3 = temp1_mul_3 + filtVars_d1_3; // t5 = (((b31 + a31) * output02) + vd13) ;
380  temp0_mul_3 = a32 * filtVars_d0_3; // t4 = (a32 * vd03);
381  d0_temp_3 = a31 * filtVars_d0_3; // vd03 = ((a31 * vd03) + t5) ;
382  filtVars_d0_3 = d0_temp_3 + temp1_add_3;
383  d1_mul_3 = b32_a32 * output2; // vd13 = (((b32 + a32) * output02) + t4) ;
384  filtVars_d1_3 = d1_mul_3 + temp0_mul_3;
385 
386  __vpred tmp = c7x::strm_agen<0, vec>::get_vpred();
387  vec *VB1 = c7x::strm_agen<0, vec>::get_adv(pOutLocal);
388 #if DSPLIB_DEBUGPRINT
389 // if (samp == 0 || samp == 1) {
390 // DSPLIB_debugPrintVector(input);
391 // DSPLIB_debugPrintVector(output1);
392 // DSPLIB_debugPrintVector(output2);
393 // DSPLIB_debugPrintVector(output3);
394 // }
395 #endif
396  vec output = output3 * outGain;
397 #if DSPLIB_DEBUGPRINT
398  // if (samp == 0 || samp == 1) {
399  DSPLIB_debugPrintVector(output);
400 // }
401 #endif
402  __vstore_pred(tmp, VB1, output);
403  }
404 
405  __vpred tmp1 = c7x::strm_agen<1, vec>::get_vpred();
406  vec *VB2 = c7x::strm_agen<1, vec>::get_adv(pFilterVarLocal);
407  __vstore_pred(tmp1, VB2, filtVars_d0_1);
408 
409  tmp1 = c7x::strm_agen<1, vec>::get_vpred();
410  VB2 = c7x::strm_agen<1, vec>::get_adv(pFilterVarLocal);
411  __vstore_pred(tmp1, VB2, filtVars_d1_1);
412 
413  tmp1 = c7x::strm_agen<1, vec>::get_vpred();
414  VB2 = c7x::strm_agen<1, vec>::get_adv(pFilterVarLocal);
415  __vstore_pred(tmp1, VB2, filtVars_d0_2);
416 
417  tmp1 = c7x::strm_agen<1, vec>::get_vpred();
418  VB2 = c7x::strm_agen<1, vec>::get_adv(pFilterVarLocal);
419  __vstore_pred(tmp1, VB2, filtVars_d1_2);
420 
421  tmp1 = c7x::strm_agen<1, vec>::get_vpred();
422  VB2 = c7x::strm_agen<1, vec>::get_adv(pFilterVarLocal);
423  __vstore_pred(tmp1, VB2, filtVars_d0_3);
424 
425  tmp1 = c7x::strm_agen<1, vec>::get_vpred();
426  VB2 = c7x::strm_agen<1, vec>::get_adv(pFilterVarLocal);
427  __vstore_pred(tmp1, VB2, filtVars_d1_3);
428  }
429  __SE0_CLOSE();
430  __SE1_CLOSE();
431  __SA0_CLOSE();
432  __SA1_CLOSE();
433 
434  return DSPLIB_SUCCESS;
435 }
436 
437 template DSPLIB_STATUS DSPLIB_cascadeBiquad_exec_ci<float>(DSPLIB_kernelHandle handle,
438  void *restrict pIn,
439  void *restrict pFilterCoeff,
440  void *restrict pFilterVar,
441  void *restrict pOut);
SE_SE0_PARAM_OFFSET
#define SE_SE0_PARAM_OFFSET
Definition: DSPLIB_add_ci.cpp:58
SE_SA0_PARAM_OFFSET
#define SE_SA0_PARAM_OFFSET
Definition: DSPLIB_add_ci.cpp:59
SE_SE1_PARAM_OFFSET
#define SE_SE1_PARAM_OFFSET
Definition: DSPLIB_bexp_ci.cpp:57
fast_recip
static dataType fast_recip(dataType x)
Definition: DSPLIB_cascadeBiquad_ci.cpp:173
DSPLIB_cascadeBiquad_init_ci
DSPLIB_STATUS DSPLIB_cascadeBiquad_init_ci(DSPLIB_kernelHandle handle, const DSPLIB_bufParams2D_t *bufParamsIn, const DSPLIB_bufParams1D_t *bufParamsFilterCoeff, const DSPLIB_bufParams2D_t *bufParamsFilterVar, const DSPLIB_bufParams2D_t *bufParamsOut, const DSPLIB_cascadeBiquad_InitArgs *pKerInitArgs)
This function is the initialization function for the C7x implementation of the kernel....
Definition: DSPLIB_cascadeBiquad_ci.cpp:57
DSPLIB_cascadeBiquad_init_ci< float >
template DSPLIB_STATUS DSPLIB_cascadeBiquad_init_ci< float >(DSPLIB_kernelHandle handle, const DSPLIB_bufParams2D_t *bufParamsIn, const DSPLIB_bufParams1D_t *bufParamsFilterCoeff, const DSPLIB_bufParams2D_t *bufParamsFilterVar, const DSPLIB_bufParams2D_t *bufParamsOut, const DSPLIB_cascadeBiquad_InitArgs *pKerInitArgs)
DSPLIB_cascadeBiquad_exec_ci
DSPLIB_STATUS DSPLIB_cascadeBiquad_exec_ci(DSPLIB_kernelHandle handle, void *restrict pIn, void *restrict pFilterCoeff, void *restrict pFilterVar, void *restrict pOut)
This function is the main execution function for the C7x implementation of the kernel....
Definition: DSPLIB_cascadeBiquad_ci.cpp:199
DSPLIB_cascadeBiquad_exec_ci< float >
template DSPLIB_STATUS DSPLIB_cascadeBiquad_exec_ci< float >(DSPLIB_kernelHandle handle, void *restrict pIn, void *restrict pFilterCoeff, void *restrict pFilterVar, void *restrict pOut)
DSPLIB_cascadeBiquad_priv.h
Header file for kernel's internal use. For the kernel's interface, please see DSPLIB_cascadeBiquad.
SE_SA1_PARAM_OFFSET
#define SE_SA1_PARAM_OFFSET
Definition: DSPLIB_cascadeBiquad_priv.h:48
DSPLIB_STATUS_NAME
DSPLIB_STATUS_NAME
The enumeration of all status codes.
Definition: DSPLIB_types.h:151
DSPLIB_kernelHandle
void * DSPLIB_kernelHandle
Handle type for DSPLIB operations.
Definition: DSPLIB_types.h:172
DSPLIB_SUCCESS
@ DSPLIB_SUCCESS
Definition: DSPLIB_types.h:152
DSPLIB_bufParams1D_t
A structure for a 1 dimensional buffer descriptor.
Definition: DSPLIB_bufParams.h:70
DSPLIB_bufParams2D_t
A structure for a 2 dimensional buffer descriptor.
Definition: DSPLIB_bufParams.h:78
DSPLIB_cascadeBiquad_InitArgs
Structure containing the parameters to initialize the kernel.
Definition: DSPLIB_cascadeBiquad.h:105
DSPLIB_cascadeBiquad_InitArgs::dataSize
uint32_t dataSize
Size of input data
Definition: DSPLIB_cascadeBiquad.h:109
DSPLIB_cascadeBiquad_InitArgs::numChannels
uint32_t numChannels
number of channels
Definition: DSPLIB_cascadeBiquad.h:117
DSPLIB_cascadeBiquad_InitArgs::numStages
uint32_t numStages
Size of batch in terms of number of channels of input data
Definition: DSPLIB_cascadeBiquad.h:115
DSPLIB_cascadeBiquad_PrivArgs
Structure that is reserved for internal use by the kernel.
Definition: DSPLIB_cascadeBiquad_priv.h:228
DSPLIB_cascadeBiquad_PrivArgs::bufPblock
uint8_t bufPblock[DSPLIB_CASCADEBIQUAD_PBLOCK_SIZE]
Definition: DSPLIB_cascadeBiquad_priv.h:256
DSPLIB_cascadeBiquad_PrivArgs::filterVarPitch
uint32_t filterVarPitch
Pitch of filter Variable buffer for different channels DSPLIB_cascadeBiquad_init that will be retriev...
Definition: DSPLIB_cascadeBiquad_priv.h:246
DSPLIB_cascadeBiquad_PrivArgs::dataBufferOutPitch
uint32_t dataBufferOutPitch
Pitch of output buffer for different batches DSPLIB_cascadeBiquad_init that will be retrieved and use...
Definition: DSPLIB_cascadeBiquad_priv.h:242
DSPLIB_cascadeBiquad_PrivArgs::initArgs
DSPLIB_cascadeBiquad_InitArgs initArgs
Structure holding initialization parameters
Definition: DSPLIB_cascadeBiquad_priv.h:230
DSPLIB_cascadeBiquad_PrivArgs::dataBufferInPitch
uint32_t dataBufferInPitch
Pitch of input buffer for different batches DSPLIB_cascadeBiquad_init that will be retrieved and used...
Definition: DSPLIB_cascadeBiquad_priv.h:238