1 /* ----------------------------------------------------------------------
2 * Project: CMSIS DSP Python Wrapper
3 * Title: cmsismodule.h
4 * Description: C code for the CMSIS-DSP Python wrapper
5 *
6 * $Date: 27 April 2021
7 * $Revision: V1.0
8 *
9 * Target Processor: Cortex-M cores
10 * -------------------------------------------------------------------- */
11 /*
12 * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
13 *
14 * SPDX-License-Identifier: Apache-2.0
15 *
16 * Licensed under the Apache License, Version 2.0 (the License); you may
17 * not use this file except in compliance with the License.
18 * You may obtain a copy of the License at
19 *
20 * www.apache.org/licenses/LICENSE-2.0
21 *
22 * Unless required by applicable law or agreed to in writing, software
23 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
24 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
25 * See the License for the specific language governing permissions and
26 * limitations under the License.
27 */
28
29 #define MODNAME "cmsisdsp_transform"
30 #define MODINITNAME cmsisdsp_transform
31
32 #include "cmsisdsp_module.h"
33
34
35
36 NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
37
38
39
40
41 typedef struct {
42 PyObject_HEAD
43 arm_cfft_radix2_instance_q15 *instance;
44 } dsp_arm_cfft_radix2_instance_q15Object;
45
46
47 static void
arm_cfft_radix2_instance_q15_dealloc(dsp_arm_cfft_radix2_instance_q15Object * self)48 arm_cfft_radix2_instance_q15_dealloc(dsp_arm_cfft_radix2_instance_q15Object* self)
49 {
50 //printf("Dealloc called\n");
51 if (self->instance)
52 {
53
54
55 PyMem_Free(self->instance);
56 }
57
58 Py_TYPE(self)->tp_free((PyObject*)self);
59 }
60
61
62 static PyObject *
arm_cfft_radix2_instance_q15_new(PyTypeObject * type,PyObject * args,PyObject * kwds)63 arm_cfft_radix2_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
64 {
65 dsp_arm_cfft_radix2_instance_q15Object *self;
66 //printf("New called\n");
67
68 self = (dsp_arm_cfft_radix2_instance_q15Object *)type->tp_alloc(type, 0);
69 //printf("alloc called\n");
70
71 if (self != NULL) {
72
73 self->instance = PyMem_Malloc(sizeof(arm_cfft_radix2_instance_q15));
74
75 self->instance->pTwiddle = NULL;
76 self->instance->pBitRevTable = NULL;
77
78 }
79
80
81 return (PyObject *)self;
82 }
83
84 static int
arm_cfft_radix2_instance_q15_init(dsp_arm_cfft_radix2_instance_q15Object * self,PyObject * args,PyObject * kwds)85 arm_cfft_radix2_instance_q15_init(dsp_arm_cfft_radix2_instance_q15Object *self, PyObject *args, PyObject *kwds)
86 {
87
88 PyObject *pTwiddle=NULL;
89 PyObject *pBitRevTable=NULL;
90 char *kwlist[] = {
91 "fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor",NULL
92 };
93
94 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihh", kwlist,&self->instance->fftLen
95 ,&self->instance->ifftFlag
96 ,&self->instance->bitReverseFlag
97 ,&self->instance->twidCoefModifier
98 ,&self->instance->bitRevFactor
99 ))
100 {
101
102
103 }
104 return 0;
105 }
106
107 GETFIELD(arm_cfft_radix2_instance_q15,fftLen,"h");
108 GETFIELD(arm_cfft_radix2_instance_q15,ifftFlag,"i");
109 GETFIELD(arm_cfft_radix2_instance_q15,bitReverseFlag,"i");
110 GETFIELD(arm_cfft_radix2_instance_q15,twidCoefModifier,"h");
111 GETFIELD(arm_cfft_radix2_instance_q15,bitRevFactor,"h");
112
113
114 static PyMethodDef arm_cfft_radix2_instance_q15_methods[] = {
115
116 {"fftLen", (PyCFunction) Method_arm_cfft_radix2_instance_q15_fftLen,METH_NOARGS,"fftLen"},
117 {"ifftFlag", (PyCFunction) Method_arm_cfft_radix2_instance_q15_ifftFlag,METH_NOARGS,"ifftFlag"},
118 {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix2_instance_q15_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
119 {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix2_instance_q15_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
120 {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix2_instance_q15_bitRevFactor,METH_NOARGS,"bitRevFactor"},
121
122 {NULL} /* Sentinel */
123 };
124
125
126 DSPType(arm_cfft_radix2_instance_q15,arm_cfft_radix2_instance_q15_new,arm_cfft_radix2_instance_q15_dealloc,arm_cfft_radix2_instance_q15_init,arm_cfft_radix2_instance_q15_methods);
127
128
129 typedef struct {
130 PyObject_HEAD
131 arm_cfft_radix4_instance_q15 *instance;
132 } dsp_arm_cfft_radix4_instance_q15Object;
133
134
135 static void
arm_cfft_radix4_instance_q15_dealloc(dsp_arm_cfft_radix4_instance_q15Object * self)136 arm_cfft_radix4_instance_q15_dealloc(dsp_arm_cfft_radix4_instance_q15Object* self)
137 {
138 //printf("Dealloc called\n");
139 if (self->instance)
140 {
141
142
143 PyMem_Free(self->instance);
144 }
145
146 Py_TYPE(self)->tp_free((PyObject*)self);
147 }
148
149
150 static PyObject *
arm_cfft_radix4_instance_q15_new(PyTypeObject * type,PyObject * args,PyObject * kwds)151 arm_cfft_radix4_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
152 {
153 dsp_arm_cfft_radix4_instance_q15Object *self;
154 //printf("New called\n");
155
156 self = (dsp_arm_cfft_radix4_instance_q15Object *)type->tp_alloc(type, 0);
157 //printf("alloc called\n");
158
159 if (self != NULL) {
160
161 self->instance = PyMem_Malloc(sizeof(arm_cfft_radix4_instance_q15));
162
163 self->instance->pTwiddle = NULL;
164 self->instance->pBitRevTable = NULL;
165
166 }
167
168
169 return (PyObject *)self;
170 }
171
172 static int
arm_cfft_radix4_instance_q15_init(dsp_arm_cfft_radix4_instance_q15Object * self,PyObject * args,PyObject * kwds)173 arm_cfft_radix4_instance_q15_init(dsp_arm_cfft_radix4_instance_q15Object *self, PyObject *args, PyObject *kwds)
174 {
175
176 PyObject *pTwiddle=NULL;
177 PyObject *pBitRevTable=NULL;
178 char *kwlist[] = {
179 "fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor",NULL
180 };
181
182 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihh", kwlist,&self->instance->fftLen
183 ,&self->instance->ifftFlag
184 ,&self->instance->bitReverseFlag
185 ,&self->instance->twidCoefModifier
186 ,&self->instance->bitRevFactor
187 ))
188 {
189
190
191 }
192 return 0;
193 }
194
195 GETFIELD(arm_cfft_radix4_instance_q15,fftLen,"h");
196 GETFIELD(arm_cfft_radix4_instance_q15,ifftFlag,"i");
197 GETFIELD(arm_cfft_radix4_instance_q15,bitReverseFlag,"i");
198 GETFIELD(arm_cfft_radix4_instance_q15,twidCoefModifier,"h");
199 GETFIELD(arm_cfft_radix4_instance_q15,bitRevFactor,"h");
200
201
202 static PyMethodDef arm_cfft_radix4_instance_q15_methods[] = {
203
204 {"fftLen", (PyCFunction) Method_arm_cfft_radix4_instance_q15_fftLen,METH_NOARGS,"fftLen"},
205 {"ifftFlag", (PyCFunction) Method_arm_cfft_radix4_instance_q15_ifftFlag,METH_NOARGS,"ifftFlag"},
206 {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix4_instance_q15_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
207 {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix4_instance_q15_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
208 {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix4_instance_q15_bitRevFactor,METH_NOARGS,"bitRevFactor"},
209
210 {NULL} /* Sentinel */
211 };
212
213
214 DSPType(arm_cfft_radix4_instance_q15,arm_cfft_radix4_instance_q15_new,arm_cfft_radix4_instance_q15_dealloc,arm_cfft_radix4_instance_q15_init,arm_cfft_radix4_instance_q15_methods);
215
216
217 typedef struct {
218 PyObject_HEAD
219 arm_cfft_radix2_instance_q31 *instance;
220 } dsp_arm_cfft_radix2_instance_q31Object;
221
222
223 static void
arm_cfft_radix2_instance_q31_dealloc(dsp_arm_cfft_radix2_instance_q31Object * self)224 arm_cfft_radix2_instance_q31_dealloc(dsp_arm_cfft_radix2_instance_q31Object* self)
225 {
226 //printf("Dealloc called\n");
227 if (self->instance)
228 {
229
230
231 PyMem_Free(self->instance);
232 }
233
234 Py_TYPE(self)->tp_free((PyObject*)self);
235 }
236
237
238 static PyObject *
arm_cfft_radix2_instance_q31_new(PyTypeObject * type,PyObject * args,PyObject * kwds)239 arm_cfft_radix2_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
240 {
241 dsp_arm_cfft_radix2_instance_q31Object *self;
242 //printf("New called\n");
243
244 self = (dsp_arm_cfft_radix2_instance_q31Object *)type->tp_alloc(type, 0);
245 //printf("alloc called\n");
246
247 if (self != NULL) {
248
249 self->instance = PyMem_Malloc(sizeof(arm_cfft_radix2_instance_q31));
250
251 self->instance->pTwiddle = NULL;
252 self->instance->pBitRevTable = NULL;
253
254 }
255
256
257 return (PyObject *)self;
258 }
259
260 static int
arm_cfft_radix2_instance_q31_init(dsp_arm_cfft_radix2_instance_q31Object * self,PyObject * args,PyObject * kwds)261 arm_cfft_radix2_instance_q31_init(dsp_arm_cfft_radix2_instance_q31Object *self, PyObject *args, PyObject *kwds)
262 {
263
264 PyObject *pTwiddle=NULL;
265 PyObject *pBitRevTable=NULL;
266 char *kwlist[] = {
267 "fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor",NULL
268 };
269
270 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihh", kwlist,&self->instance->fftLen
271 ,&self->instance->ifftFlag
272 ,&self->instance->bitReverseFlag
273 ,&self->instance->twidCoefModifier
274 ,&self->instance->bitRevFactor
275 ))
276 {
277
278
279 }
280 return 0;
281 }
282
283 GETFIELD(arm_cfft_radix2_instance_q31,fftLen,"h");
284 GETFIELD(arm_cfft_radix2_instance_q31,ifftFlag,"i");
285 GETFIELD(arm_cfft_radix2_instance_q31,bitReverseFlag,"i");
286 GETFIELD(arm_cfft_radix2_instance_q31,twidCoefModifier,"h");
287 GETFIELD(arm_cfft_radix2_instance_q31,bitRevFactor,"h");
288
289
290 static PyMethodDef arm_cfft_radix2_instance_q31_methods[] = {
291
292 {"fftLen", (PyCFunction) Method_arm_cfft_radix2_instance_q31_fftLen,METH_NOARGS,"fftLen"},
293 {"ifftFlag", (PyCFunction) Method_arm_cfft_radix2_instance_q31_ifftFlag,METH_NOARGS,"ifftFlag"},
294 {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix2_instance_q31_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
295 {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix2_instance_q31_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
296 {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix2_instance_q31_bitRevFactor,METH_NOARGS,"bitRevFactor"},
297
298 {NULL} /* Sentinel */
299 };
300
301
302 DSPType(arm_cfft_radix2_instance_q31,arm_cfft_radix2_instance_q31_new,arm_cfft_radix2_instance_q31_dealloc,arm_cfft_radix2_instance_q31_init,arm_cfft_radix2_instance_q31_methods);
303
304
305 typedef struct {
306 PyObject_HEAD
307 arm_cfft_radix4_instance_q31 *instance;
308 } dsp_arm_cfft_radix4_instance_q31Object;
309
310
311 static void
arm_cfft_radix4_instance_q31_dealloc(dsp_arm_cfft_radix4_instance_q31Object * self)312 arm_cfft_radix4_instance_q31_dealloc(dsp_arm_cfft_radix4_instance_q31Object* self)
313 {
314 //printf("Dealloc called\n");
315 if (self->instance)
316 {
317
318
319 PyMem_Free(self->instance);
320 }
321
322 Py_TYPE(self)->tp_free((PyObject*)self);
323 }
324
325
326 static PyObject *
arm_cfft_radix4_instance_q31_new(PyTypeObject * type,PyObject * args,PyObject * kwds)327 arm_cfft_radix4_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
328 {
329 dsp_arm_cfft_radix4_instance_q31Object *self;
330 //printf("New called\n");
331
332 self = (dsp_arm_cfft_radix4_instance_q31Object *)type->tp_alloc(type, 0);
333 //printf("alloc called\n");
334
335 if (self != NULL) {
336
337 self->instance = PyMem_Malloc(sizeof(arm_cfft_radix4_instance_q31));
338
339 self->instance->pTwiddle = NULL;
340 self->instance->pBitRevTable = NULL;
341
342 }
343
344
345 return (PyObject *)self;
346 }
347
348 static int
arm_cfft_radix4_instance_q31_init(dsp_arm_cfft_radix4_instance_q31Object * self,PyObject * args,PyObject * kwds)349 arm_cfft_radix4_instance_q31_init(dsp_arm_cfft_radix4_instance_q31Object *self, PyObject *args, PyObject *kwds)
350 {
351
352 PyObject *pTwiddle=NULL;
353 PyObject *pBitRevTable=NULL;
354 char *kwlist[] = {
355 "fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor",NULL
356 };
357
358 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihh", kwlist,&self->instance->fftLen
359 ,&self->instance->ifftFlag
360 ,&self->instance->bitReverseFlag
361 ,&self->instance->twidCoefModifier
362 ,&self->instance->bitRevFactor
363 ))
364 {
365
366
367 }
368 return 0;
369 }
370
371 GETFIELD(arm_cfft_radix4_instance_q31,fftLen,"h");
372 GETFIELD(arm_cfft_radix4_instance_q31,ifftFlag,"i");
373 GETFIELD(arm_cfft_radix4_instance_q31,bitReverseFlag,"i");
374 GETFIELD(arm_cfft_radix4_instance_q31,twidCoefModifier,"h");
375 GETFIELD(arm_cfft_radix4_instance_q31,bitRevFactor,"h");
376
377
378 static PyMethodDef arm_cfft_radix4_instance_q31_methods[] = {
379
380 {"fftLen", (PyCFunction) Method_arm_cfft_radix4_instance_q31_fftLen,METH_NOARGS,"fftLen"},
381 {"ifftFlag", (PyCFunction) Method_arm_cfft_radix4_instance_q31_ifftFlag,METH_NOARGS,"ifftFlag"},
382 {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix4_instance_q31_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
383 {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix4_instance_q31_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
384 {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix4_instance_q31_bitRevFactor,METH_NOARGS,"bitRevFactor"},
385
386 {NULL} /* Sentinel */
387 };
388
389
390 DSPType(arm_cfft_radix4_instance_q31,arm_cfft_radix4_instance_q31_new,arm_cfft_radix4_instance_q31_dealloc,arm_cfft_radix4_instance_q31_init,arm_cfft_radix4_instance_q31_methods);
391
392
393 typedef struct {
394 PyObject_HEAD
395 arm_cfft_radix2_instance_f32 *instance;
396 } dsp_arm_cfft_radix2_instance_f32Object;
397
398
399 static void
arm_cfft_radix2_instance_f32_dealloc(dsp_arm_cfft_radix2_instance_f32Object * self)400 arm_cfft_radix2_instance_f32_dealloc(dsp_arm_cfft_radix2_instance_f32Object* self)
401 {
402 //printf("Dealloc called\n");
403 if (self->instance)
404 {
405
406
407 PyMem_Free(self->instance);
408 }
409
410 Py_TYPE(self)->tp_free((PyObject*)self);
411 }
412
413
414 static PyObject *
arm_cfft_radix2_instance_f32_new(PyTypeObject * type,PyObject * args,PyObject * kwds)415 arm_cfft_radix2_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
416 {
417 dsp_arm_cfft_radix2_instance_f32Object *self;
418 //printf("New called\n");
419
420 self = (dsp_arm_cfft_radix2_instance_f32Object *)type->tp_alloc(type, 0);
421 //printf("alloc called\n");
422
423 if (self != NULL) {
424
425 self->instance = PyMem_Malloc(sizeof(arm_cfft_radix2_instance_f32));
426
427 self->instance->pTwiddle = NULL;
428 self->instance->pBitRevTable = NULL;
429
430 }
431
432
433 return (PyObject *)self;
434 }
435
436 static int
arm_cfft_radix2_instance_f32_init(dsp_arm_cfft_radix2_instance_f32Object * self,PyObject * args,PyObject * kwds)437 arm_cfft_radix2_instance_f32_init(dsp_arm_cfft_radix2_instance_f32Object *self, PyObject *args, PyObject *kwds)
438 {
439
440 PyObject *pTwiddle=NULL;
441 PyObject *pBitRevTable=NULL;
442 char *kwlist[] = {
443 "fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor","onebyfftLen",NULL
444 };
445
446 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihhf", kwlist,&self->instance->fftLen
447 ,&self->instance->ifftFlag
448 ,&self->instance->bitReverseFlag
449 ,&self->instance->twidCoefModifier
450 ,&self->instance->bitRevFactor
451 ,&self->instance->onebyfftLen
452 ))
453 {
454
455
456 }
457 return 0;
458 }
459
460 GETFIELD(arm_cfft_radix2_instance_f32,fftLen,"h");
461 GETFIELD(arm_cfft_radix2_instance_f32,ifftFlag,"i");
462 GETFIELD(arm_cfft_radix2_instance_f32,bitReverseFlag,"i");
463 GETFIELD(arm_cfft_radix2_instance_f32,twidCoefModifier,"h");
464 GETFIELD(arm_cfft_radix2_instance_f32,bitRevFactor,"h");
465 GETFIELD(arm_cfft_radix2_instance_f32,onebyfftLen,"f");
466
467
468 static PyMethodDef arm_cfft_radix2_instance_f32_methods[] = {
469
470 {"fftLen", (PyCFunction) Method_arm_cfft_radix2_instance_f32_fftLen,METH_NOARGS,"fftLen"},
471 {"ifftFlag", (PyCFunction) Method_arm_cfft_radix2_instance_f32_ifftFlag,METH_NOARGS,"ifftFlag"},
472 {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix2_instance_f32_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
473 {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix2_instance_f32_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
474 {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix2_instance_f32_bitRevFactor,METH_NOARGS,"bitRevFactor"},
475 {"onebyfftLen", (PyCFunction) Method_arm_cfft_radix2_instance_f32_onebyfftLen,METH_NOARGS,"onebyfftLen"},
476
477 {NULL} /* Sentinel */
478 };
479
480
481 DSPType(arm_cfft_radix2_instance_f32,arm_cfft_radix2_instance_f32_new,arm_cfft_radix2_instance_f32_dealloc,arm_cfft_radix2_instance_f32_init,arm_cfft_radix2_instance_f32_methods);
482
483
484 typedef struct {
485 PyObject_HEAD
486 arm_cfft_radix4_instance_f32 *instance;
487 } dsp_arm_cfft_radix4_instance_f32Object;
488
489
490 static void
arm_cfft_radix4_instance_f32_dealloc(dsp_arm_cfft_radix4_instance_f32Object * self)491 arm_cfft_radix4_instance_f32_dealloc(dsp_arm_cfft_radix4_instance_f32Object* self)
492 {
493 //printf("Dealloc called\n");
494 if (self->instance)
495 {
496
497
498 PyMem_Free(self->instance);
499 }
500
501 Py_TYPE(self)->tp_free((PyObject*)self);
502 }
503
504
505 static PyObject *
arm_cfft_radix4_instance_f32_new(PyTypeObject * type,PyObject * args,PyObject * kwds)506 arm_cfft_radix4_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
507 {
508 dsp_arm_cfft_radix4_instance_f32Object *self;
509 //printf("New called\n");
510
511 self = (dsp_arm_cfft_radix4_instance_f32Object *)type->tp_alloc(type, 0);
512 //printf("alloc called\n");
513
514 if (self != NULL) {
515
516 self->instance = PyMem_Malloc(sizeof(arm_cfft_radix4_instance_f32));
517
518 self->instance->pTwiddle = NULL;
519 self->instance->pBitRevTable = NULL;
520
521 }
522
523
524 return (PyObject *)self;
525 }
526
527 static int
arm_cfft_radix4_instance_f32_init(dsp_arm_cfft_radix4_instance_f32Object * self,PyObject * args,PyObject * kwds)528 arm_cfft_radix4_instance_f32_init(dsp_arm_cfft_radix4_instance_f32Object *self, PyObject *args, PyObject *kwds)
529 {
530
531 PyObject *pTwiddle=NULL;
532 PyObject *pBitRevTable=NULL;
533 char *kwlist[] = {
534 "fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor","onebyfftLen",NULL
535 };
536
537 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihhf", kwlist,&self->instance->fftLen
538 ,&self->instance->ifftFlag
539 ,&self->instance->bitReverseFlag
540 ,&self->instance->twidCoefModifier
541 ,&self->instance->bitRevFactor
542 ,&self->instance->onebyfftLen
543 ))
544 {
545
546
547 }
548 return 0;
549 }
550
551 GETFIELD(arm_cfft_radix4_instance_f32,fftLen,"h");
552 GETFIELD(arm_cfft_radix4_instance_f32,ifftFlag,"i");
553 GETFIELD(arm_cfft_radix4_instance_f32,bitReverseFlag,"i");
554 GETFIELD(arm_cfft_radix4_instance_f32,twidCoefModifier,"h");
555 GETFIELD(arm_cfft_radix4_instance_f32,bitRevFactor,"h");
556 GETFIELD(arm_cfft_radix4_instance_f32,onebyfftLen,"f");
557
558
559 static PyMethodDef arm_cfft_radix4_instance_f32_methods[] = {
560
561 {"fftLen", (PyCFunction) Method_arm_cfft_radix4_instance_f32_fftLen,METH_NOARGS,"fftLen"},
562 {"ifftFlag", (PyCFunction) Method_arm_cfft_radix4_instance_f32_ifftFlag,METH_NOARGS,"ifftFlag"},
563 {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix4_instance_f32_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
564 {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix4_instance_f32_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
565 {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix4_instance_f32_bitRevFactor,METH_NOARGS,"bitRevFactor"},
566 {"onebyfftLen", (PyCFunction) Method_arm_cfft_radix4_instance_f32_onebyfftLen,METH_NOARGS,"onebyfftLen"},
567
568 {NULL} /* Sentinel */
569 };
570
571
572 DSPType(arm_cfft_radix4_instance_f32,arm_cfft_radix4_instance_f32_new,arm_cfft_radix4_instance_f32_dealloc,arm_cfft_radix4_instance_f32_init,arm_cfft_radix4_instance_f32_methods);
573
574
575 typedef struct {
576 PyObject_HEAD
577 arm_cfft_instance_q15 *instance;
578 } dsp_arm_cfft_instance_q15Object;
579
580
581 static void
arm_cfft_instance_q15_dealloc(dsp_arm_cfft_instance_q15Object * self)582 arm_cfft_instance_q15_dealloc(dsp_arm_cfft_instance_q15Object* self)
583 {
584 //printf("Dealloc called\n");
585 if (self->instance)
586 {
587
588
589 PyMem_Free(self->instance);
590 }
591
592 Py_TYPE(self)->tp_free((PyObject*)self);
593 }
594
595
596 static PyObject *
arm_cfft_instance_q15_new(PyTypeObject * type,PyObject * args,PyObject * kwds)597 arm_cfft_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
598 {
599 dsp_arm_cfft_instance_q15Object *self;
600 //printf("New called\n");
601
602 self = (dsp_arm_cfft_instance_q15Object *)type->tp_alloc(type, 0);
603 //printf("alloc called\n");
604
605 if (self != NULL) {
606
607 self->instance = PyMem_Malloc(sizeof(arm_cfft_instance_q15));
608
609 self->instance->pTwiddle = NULL;
610 self->instance->pBitRevTable = NULL;
611
612 }
613
614
615 return (PyObject *)self;
616 }
617
618 static int
arm_cfft_instance_q15_init(dsp_arm_cfft_instance_q15Object * self,PyObject * args,PyObject * kwds)619 arm_cfft_instance_q15_init(dsp_arm_cfft_instance_q15Object *self, PyObject *args, PyObject *kwds)
620 {
621
622 PyObject *pTwiddle=NULL;
623 PyObject *pBitRevTable=NULL;
624 char *kwlist[] = {
625 "fftLen","bitRevLength",NULL
626 };
627
628 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hh", kwlist,&self->instance->fftLen
629 ,&self->instance->bitRevLength
630 ))
631 {
632
633
634 }
635 return 0;
636 }
637
638 GETFIELD(arm_cfft_instance_q15,fftLen,"h");
639 GETFIELD(arm_cfft_instance_q15,bitRevLength,"h");
640
641
642 static PyMethodDef arm_cfft_instance_q15_methods[] = {
643
644 {"fftLen", (PyCFunction) Method_arm_cfft_instance_q15_fftLen,METH_NOARGS,"fftLen"},
645 {"bitRevLength", (PyCFunction) Method_arm_cfft_instance_q15_bitRevLength,METH_NOARGS,"bitRevLength"},
646
647 {NULL} /* Sentinel */
648 };
649
650
651 DSPType(arm_cfft_instance_q15,arm_cfft_instance_q15_new,arm_cfft_instance_q15_dealloc,arm_cfft_instance_q15_init,arm_cfft_instance_q15_methods);
652
653
654 typedef struct {
655 PyObject_HEAD
656 arm_cfft_instance_q31 *instance;
657 } dsp_arm_cfft_instance_q31Object;
658
659
660 static void
arm_cfft_instance_q31_dealloc(dsp_arm_cfft_instance_q31Object * self)661 arm_cfft_instance_q31_dealloc(dsp_arm_cfft_instance_q31Object* self)
662 {
663 //printf("Dealloc called\n");
664 if (self->instance)
665 {
666
667
668 PyMem_Free(self->instance);
669 }
670
671 Py_TYPE(self)->tp_free((PyObject*)self);
672 }
673
674
675 static PyObject *
arm_cfft_instance_q31_new(PyTypeObject * type,PyObject * args,PyObject * kwds)676 arm_cfft_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
677 {
678 dsp_arm_cfft_instance_q31Object *self;
679 //printf("New called\n");
680
681 self = (dsp_arm_cfft_instance_q31Object *)type->tp_alloc(type, 0);
682 //printf("alloc called\n");
683
684 if (self != NULL) {
685
686 self->instance = PyMem_Malloc(sizeof(arm_cfft_instance_q31));
687
688 self->instance->pTwiddle = NULL;
689 self->instance->pBitRevTable = NULL;
690
691 }
692
693
694 return (PyObject *)self;
695 }
696
697 static int
arm_cfft_instance_q31_init(dsp_arm_cfft_instance_q31Object * self,PyObject * args,PyObject * kwds)698 arm_cfft_instance_q31_init(dsp_arm_cfft_instance_q31Object *self, PyObject *args, PyObject *kwds)
699 {
700
701 PyObject *pTwiddle=NULL;
702 PyObject *pBitRevTable=NULL;
703 char *kwlist[] = {
704 "fftLen","bitRevLength",NULL
705 };
706
707 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hh", kwlist,&self->instance->fftLen
708 ,&self->instance->bitRevLength
709 ))
710 {
711
712
713 }
714 return 0;
715 }
716
717 GETFIELD(arm_cfft_instance_q31,fftLen,"h");
718 GETFIELD(arm_cfft_instance_q31,bitRevLength,"h");
719
720
721 static PyMethodDef arm_cfft_instance_q31_methods[] = {
722
723 {"fftLen", (PyCFunction) Method_arm_cfft_instance_q31_fftLen,METH_NOARGS,"fftLen"},
724 {"bitRevLength", (PyCFunction) Method_arm_cfft_instance_q31_bitRevLength,METH_NOARGS,"bitRevLength"},
725
726 {NULL} /* Sentinel */
727 };
728
729
730 DSPType(arm_cfft_instance_q31,arm_cfft_instance_q31_new,arm_cfft_instance_q31_dealloc,arm_cfft_instance_q31_init,arm_cfft_instance_q31_methods);
731
732 typedef struct {
733 PyObject_HEAD
734 arm_cfft_instance_f64 *instance;
735 } dsp_arm_cfft_instance_f64Object;
736
737
738 static void
arm_cfft_instance_f64_dealloc(dsp_arm_cfft_instance_f64Object * self)739 arm_cfft_instance_f64_dealloc(dsp_arm_cfft_instance_f64Object* self)
740 {
741 //printf("Dealloc called\n");
742 if (self->instance)
743 {
744
745
746 PyMem_Free(self->instance);
747 }
748
749 Py_TYPE(self)->tp_free((PyObject*)self);
750 }
751
752
753 static PyObject *
arm_cfft_instance_f64_new(PyTypeObject * type,PyObject * args,PyObject * kwds)754 arm_cfft_instance_f64_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
755 {
756 dsp_arm_cfft_instance_f64Object *self;
757 //printf("New called\n");
758
759 self = (dsp_arm_cfft_instance_f64Object *)type->tp_alloc(type, 0);
760 //printf("alloc called\n");
761
762 if (self != NULL) {
763
764 self->instance = PyMem_Malloc(sizeof(arm_cfft_instance_f64));
765
766 self->instance->pTwiddle = NULL;
767 self->instance->pBitRevTable = NULL;
768
769 }
770
771 return (PyObject *)self;
772 }
773
774 static int
arm_cfft_instance_f64_init(dsp_arm_cfft_instance_f64Object * self,PyObject * args,PyObject * kwds)775 arm_cfft_instance_f64_init(dsp_arm_cfft_instance_f64Object *self, PyObject *args, PyObject *kwds)
776 {
777
778 PyObject *pTwiddle=NULL;
779 PyObject *pBitRevTable=NULL;
780 char *kwlist[] = {
781 "fftLen","bitRevLength",NULL
782 };
783
784 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hh", kwlist,&self->instance->fftLen
785 ,&self->instance->bitRevLength
786 ))
787 {
788
789
790 }
791 return 0;
792 }
793
794 GETFIELD(arm_cfft_instance_f64,fftLen,"h");
795 GETFIELD(arm_cfft_instance_f64,bitRevLength,"h");
796
797
798 static PyMethodDef arm_cfft_instance_f64_methods[] = {
799
800 {"fftLen", (PyCFunction) Method_arm_cfft_instance_f64_fftLen,METH_NOARGS,"fftLen"},
801 {"bitRevLength", (PyCFunction) Method_arm_cfft_instance_f64_bitRevLength,METH_NOARGS,"bitRevLength"},
802
803 {NULL} /* Sentinel */
804 };
805
806
807 DSPType(arm_cfft_instance_f64,arm_cfft_instance_f64_new,arm_cfft_instance_f64_dealloc,arm_cfft_instance_f64_init,arm_cfft_instance_f64_methods);
808
809
810 typedef struct {
811 PyObject_HEAD
812 arm_cfft_instance_f32 *instance;
813 } dsp_arm_cfft_instance_f32Object;
814
815
816 static void
arm_cfft_instance_f32_dealloc(dsp_arm_cfft_instance_f32Object * self)817 arm_cfft_instance_f32_dealloc(dsp_arm_cfft_instance_f32Object* self)
818 {
819 //printf("Dealloc called\n");
820 if (self->instance)
821 {
822
823
824 PyMem_Free(self->instance);
825 }
826
827 Py_TYPE(self)->tp_free((PyObject*)self);
828 }
829
830
831 static PyObject *
arm_cfft_instance_f32_new(PyTypeObject * type,PyObject * args,PyObject * kwds)832 arm_cfft_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
833 {
834 dsp_arm_cfft_instance_f32Object *self;
835 //printf("New called\n");
836
837 self = (dsp_arm_cfft_instance_f32Object *)type->tp_alloc(type, 0);
838 //printf("alloc called\n");
839
840 if (self != NULL) {
841
842 self->instance = PyMem_Malloc(sizeof(arm_cfft_instance_f32));
843
844 self->instance->pTwiddle = NULL;
845 self->instance->pBitRevTable = NULL;
846
847 }
848
849
850 return (PyObject *)self;
851 }
852
853 static int
arm_cfft_instance_f32_init(dsp_arm_cfft_instance_f32Object * self,PyObject * args,PyObject * kwds)854 arm_cfft_instance_f32_init(dsp_arm_cfft_instance_f32Object *self, PyObject *args, PyObject *kwds)
855 {
856
857 PyObject *pTwiddle=NULL;
858 PyObject *pBitRevTable=NULL;
859 char *kwlist[] = {
860 "fftLen","bitRevLength",NULL
861 };
862
863 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hh", kwlist,&self->instance->fftLen
864 ,&self->instance->bitRevLength
865 ))
866 {
867
868
869 }
870 return 0;
871 }
872
873 GETFIELD(arm_cfft_instance_f32,fftLen,"h");
874 GETFIELD(arm_cfft_instance_f32,bitRevLength,"h");
875
876
877 static PyMethodDef arm_cfft_instance_f32_methods[] = {
878
879 {"fftLen", (PyCFunction) Method_arm_cfft_instance_f32_fftLen,METH_NOARGS,"fftLen"},
880 {"bitRevLength", (PyCFunction) Method_arm_cfft_instance_f32_bitRevLength,METH_NOARGS,"bitRevLength"},
881
882 {NULL} /* Sentinel */
883 };
884
885
886 DSPType(arm_cfft_instance_f32,arm_cfft_instance_f32_new,arm_cfft_instance_f32_dealloc,arm_cfft_instance_f32_init,arm_cfft_instance_f32_methods);
887
888
889 typedef struct {
890 PyObject_HEAD
891 arm_rfft_instance_q15 *instance;
892 } dsp_arm_rfft_instance_q15Object;
893
894
895 static void
arm_rfft_instance_q15_dealloc(dsp_arm_rfft_instance_q15Object * self)896 arm_rfft_instance_q15_dealloc(dsp_arm_rfft_instance_q15Object* self)
897 {
898 //printf("Dealloc called\n");
899 if (self->instance)
900 {
901
902
903 PyMem_Free(self->instance);
904 }
905
906 Py_TYPE(self)->tp_free((PyObject*)self);
907 }
908
909
910 static PyObject *
arm_rfft_instance_q15_new(PyTypeObject * type,PyObject * args,PyObject * kwds)911 arm_rfft_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
912 {
913 dsp_arm_rfft_instance_q15Object *self;
914 //printf("New called\n");
915
916 self = (dsp_arm_rfft_instance_q15Object *)type->tp_alloc(type, 0);
917 //printf("alloc called\n");
918
919 if (self != NULL) {
920
921 self->instance = PyMem_Malloc(sizeof(arm_rfft_instance_q15));
922
923 self->instance->pTwiddleAReal = NULL;
924 self->instance->pTwiddleBReal = NULL;
925 self->instance->pCfft = NULL;
926
927 }
928
929
930 return (PyObject *)self;
931 }
932
933 static int
arm_rfft_instance_q15_init(dsp_arm_rfft_instance_q15Object * self,PyObject * args,PyObject * kwds)934 arm_rfft_instance_q15_init(dsp_arm_rfft_instance_q15Object *self, PyObject *args, PyObject *kwds)
935 {
936
937 PyObject *pTwiddleAReal=NULL;
938 PyObject *pTwiddleBReal=NULL;
939 PyObject *pCfft=NULL;
940 char *kwlist[] = {
941 "fftLenReal","ifftFlagR","bitReverseFlagR","twidCoefRModifier",NULL
942 };
943
944 if (PyArg_ParseTupleAndKeywords(args, kwds, "|iiii", kwlist,&self->instance->fftLenReal
945 ,&self->instance->ifftFlagR
946 ,&self->instance->bitReverseFlagR
947 ,&self->instance->twidCoefRModifier
948 ))
949 {
950
951
952 }
953 return 0;
954 }
955
956 GETFIELD(arm_rfft_instance_q15,fftLenReal,"i");
957 GETFIELD(arm_rfft_instance_q15,ifftFlagR,"i");
958 GETFIELD(arm_rfft_instance_q15,bitReverseFlagR,"i");
959 GETFIELD(arm_rfft_instance_q15,twidCoefRModifier,"i");
960
961
962 static PyMethodDef arm_rfft_instance_q15_methods[] = {
963
964 {"fftLenReal", (PyCFunction) Method_arm_rfft_instance_q15_fftLenReal,METH_NOARGS,"fftLenReal"},
965 {"ifftFlagR", (PyCFunction) Method_arm_rfft_instance_q15_ifftFlagR,METH_NOARGS,"ifftFlagR"},
966 {"bitReverseFlagR", (PyCFunction) Method_arm_rfft_instance_q15_bitReverseFlagR,METH_NOARGS,"bitReverseFlagR"},
967 {"twidCoefRModifier", (PyCFunction) Method_arm_rfft_instance_q15_twidCoefRModifier,METH_NOARGS,"twidCoefRModifier"},
968
969 {NULL} /* Sentinel */
970 };
971
972
973 DSPType(arm_rfft_instance_q15,arm_rfft_instance_q15_new,arm_rfft_instance_q15_dealloc,arm_rfft_instance_q15_init,arm_rfft_instance_q15_methods);
974
975
976 typedef struct {
977 PyObject_HEAD
978 arm_rfft_instance_q31 *instance;
979 } dsp_arm_rfft_instance_q31Object;
980
981
982 static void
arm_rfft_instance_q31_dealloc(dsp_arm_rfft_instance_q31Object * self)983 arm_rfft_instance_q31_dealloc(dsp_arm_rfft_instance_q31Object* self)
984 {
985 //printf("Dealloc called\n");
986 if (self->instance)
987 {
988
989
990 PyMem_Free(self->instance);
991 }
992
993 Py_TYPE(self)->tp_free((PyObject*)self);
994 }
995
996
997 static PyObject *
arm_rfft_instance_q31_new(PyTypeObject * type,PyObject * args,PyObject * kwds)998 arm_rfft_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
999 {
1000 dsp_arm_rfft_instance_q31Object *self;
1001 //printf("New called\n");
1002
1003 self = (dsp_arm_rfft_instance_q31Object *)type->tp_alloc(type, 0);
1004 //printf("alloc called\n");
1005
1006 if (self != NULL) {
1007
1008 self->instance = PyMem_Malloc(sizeof(arm_rfft_instance_q31));
1009
1010 self->instance->pTwiddleAReal = NULL;
1011 self->instance->pTwiddleBReal = NULL;
1012 self->instance->pCfft = NULL;
1013
1014 }
1015
1016
1017 return (PyObject *)self;
1018 }
1019
1020 static int
arm_rfft_instance_q31_init(dsp_arm_rfft_instance_q31Object * self,PyObject * args,PyObject * kwds)1021 arm_rfft_instance_q31_init(dsp_arm_rfft_instance_q31Object *self, PyObject *args, PyObject *kwds)
1022 {
1023
1024 PyObject *pTwiddleAReal=NULL;
1025 PyObject *pTwiddleBReal=NULL;
1026 PyObject *pCfft=NULL;
1027 char *kwlist[] = {
1028 "fftLenReal","ifftFlagR","bitReverseFlagR","twidCoefRModifier",NULL
1029 };
1030
1031 if (PyArg_ParseTupleAndKeywords(args, kwds, "|iiii", kwlist,&self->instance->fftLenReal
1032 ,&self->instance->ifftFlagR
1033 ,&self->instance->bitReverseFlagR
1034 ,&self->instance->twidCoefRModifier
1035 ))
1036 {
1037
1038
1039 }
1040 return 0;
1041 }
1042
1043 GETFIELD(arm_rfft_instance_q31,fftLenReal,"i");
1044 GETFIELD(arm_rfft_instance_q31,ifftFlagR,"i");
1045 GETFIELD(arm_rfft_instance_q31,bitReverseFlagR,"i");
1046 GETFIELD(arm_rfft_instance_q31,twidCoefRModifier,"i");
1047
1048
1049 static PyMethodDef arm_rfft_instance_q31_methods[] = {
1050
1051 {"fftLenReal", (PyCFunction) Method_arm_rfft_instance_q31_fftLenReal,METH_NOARGS,"fftLenReal"},
1052 {"ifftFlagR", (PyCFunction) Method_arm_rfft_instance_q31_ifftFlagR,METH_NOARGS,"ifftFlagR"},
1053 {"bitReverseFlagR", (PyCFunction) Method_arm_rfft_instance_q31_bitReverseFlagR,METH_NOARGS,"bitReverseFlagR"},
1054 {"twidCoefRModifier", (PyCFunction) Method_arm_rfft_instance_q31_twidCoefRModifier,METH_NOARGS,"twidCoefRModifier"},
1055
1056 {NULL} /* Sentinel */
1057 };
1058
1059
1060 DSPType(arm_rfft_instance_q31,arm_rfft_instance_q31_new,arm_rfft_instance_q31_dealloc,arm_rfft_instance_q31_init,arm_rfft_instance_q31_methods);
1061
1062
1063 typedef struct {
1064 PyObject_HEAD
1065 arm_rfft_instance_f32 *instance;
1066 } dsp_arm_rfft_instance_f32Object;
1067
1068
1069 static void
arm_rfft_instance_f32_dealloc(dsp_arm_rfft_instance_f32Object * self)1070 arm_rfft_instance_f32_dealloc(dsp_arm_rfft_instance_f32Object* self)
1071 {
1072 //printf("Dealloc called\n");
1073 if (self->instance)
1074 {
1075
1076
1077 PyMem_Free(self->instance);
1078 }
1079
1080 Py_TYPE(self)->tp_free((PyObject*)self);
1081 }
1082
1083
1084 static PyObject *
arm_rfft_instance_f32_new(PyTypeObject * type,PyObject * args,PyObject * kwds)1085 arm_rfft_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1086 {
1087 dsp_arm_rfft_instance_f32Object *self;
1088 //printf("New called\n");
1089
1090 self = (dsp_arm_rfft_instance_f32Object *)type->tp_alloc(type, 0);
1091 //printf("alloc called\n");
1092
1093 if (self != NULL) {
1094
1095 self->instance = PyMem_Malloc(sizeof(arm_rfft_instance_f32));
1096
1097 self->instance->pTwiddleAReal = NULL;
1098 self->instance->pTwiddleBReal = NULL;
1099 self->instance->pCfft = NULL;
1100
1101 }
1102
1103
1104 return (PyObject *)self;
1105 }
1106
1107 static int
arm_rfft_instance_f32_init(dsp_arm_rfft_instance_f32Object * self,PyObject * args,PyObject * kwds)1108 arm_rfft_instance_f32_init(dsp_arm_rfft_instance_f32Object *self, PyObject *args, PyObject *kwds)
1109 {
1110
1111 PyObject *pTwiddleAReal=NULL;
1112 PyObject *pTwiddleBReal=NULL;
1113 PyObject *pCfft=NULL;
1114 char *kwlist[] = {
1115 "fftLenReal","fftLenBy2","ifftFlagR","bitReverseFlagR","twidCoefRModifier",NULL
1116 };
1117
1118 if (PyArg_ParseTupleAndKeywords(args, kwds, "|ihiii", kwlist,&self->instance->fftLenReal
1119 ,&self->instance->fftLenBy2
1120 ,&self->instance->ifftFlagR
1121 ,&self->instance->bitReverseFlagR
1122 ,&self->instance->twidCoefRModifier
1123 ))
1124 {
1125
1126
1127 }
1128 return 0;
1129 }
1130
1131 GETFIELD(arm_rfft_instance_f32,fftLenReal,"i");
1132 GETFIELD(arm_rfft_instance_f32,fftLenBy2,"h");
1133 GETFIELD(arm_rfft_instance_f32,ifftFlagR,"i");
1134 GETFIELD(arm_rfft_instance_f32,bitReverseFlagR,"i");
1135 GETFIELD(arm_rfft_instance_f32,twidCoefRModifier,"i");
1136
1137
1138 static PyMethodDef arm_rfft_instance_f32_methods[] = {
1139
1140 {"fftLenReal", (PyCFunction) Method_arm_rfft_instance_f32_fftLenReal,METH_NOARGS,"fftLenReal"},
1141 {"fftLenBy2", (PyCFunction) Method_arm_rfft_instance_f32_fftLenBy2,METH_NOARGS,"fftLenBy2"},
1142 {"ifftFlagR", (PyCFunction) Method_arm_rfft_instance_f32_ifftFlagR,METH_NOARGS,"ifftFlagR"},
1143 {"bitReverseFlagR", (PyCFunction) Method_arm_rfft_instance_f32_bitReverseFlagR,METH_NOARGS,"bitReverseFlagR"},
1144 {"twidCoefRModifier", (PyCFunction) Method_arm_rfft_instance_f32_twidCoefRModifier,METH_NOARGS,"twidCoefRModifier"},
1145
1146 {NULL} /* Sentinel */
1147 };
1148
1149
1150 DSPType(arm_rfft_instance_f32,arm_rfft_instance_f32_new,arm_rfft_instance_f32_dealloc,arm_rfft_instance_f32_init,arm_rfft_instance_f32_methods);
1151
1152
1153 typedef struct {
1154 PyObject_HEAD
1155 arm_rfft_fast_instance_f64 *instance;
1156 } dsp_arm_rfft_fast_instance_f64Object;
1157
1158
1159 static void
arm_rfft_fast_instance_f64_dealloc(dsp_arm_rfft_fast_instance_f64Object * self)1160 arm_rfft_fast_instance_f64_dealloc(dsp_arm_rfft_fast_instance_f64Object* self)
1161 {
1162 //printf("Dealloc called\n");
1163 if (self->instance)
1164 {
1165
1166
1167 PyMem_Free(self->instance);
1168 }
1169
1170 Py_TYPE(self)->tp_free((PyObject*)self);
1171 }
1172
1173
1174 static PyObject *
arm_rfft_fast_instance_f64_new(PyTypeObject * type,PyObject * args,PyObject * kwds)1175 arm_rfft_fast_instance_f64_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1176 {
1177 dsp_arm_rfft_fast_instance_f64Object *self;
1178 //printf("New called\n");
1179
1180 self = (dsp_arm_rfft_fast_instance_f64Object *)type->tp_alloc(type, 0);
1181 //printf("alloc called\n");
1182
1183 if (self != NULL) {
1184
1185 self->instance = PyMem_Malloc(sizeof(arm_rfft_fast_instance_f64));
1186
1187 self->instance->pTwiddleRFFT = NULL;
1188
1189 }
1190
1191
1192 return (PyObject *)self;
1193 }
1194
1195 static int
arm_rfft_fast_instance_f64_init(dsp_arm_rfft_fast_instance_f64Object * self,PyObject * args,PyObject * kwds)1196 arm_rfft_fast_instance_f64_init(dsp_arm_rfft_fast_instance_f64Object *self, PyObject *args, PyObject *kwds)
1197 {
1198
1199 PyObject *pTwiddleRFFT=NULL;
1200 char *kwlist[] = {
1201 "Sint","fftLenRFFT",NULL
1202 };
1203
1204 if (PyArg_ParseTupleAndKeywords(args, kwds, "|?h", kwlist,&self->instance->Sint
1205 ,&self->instance->fftLenRFFT
1206 ))
1207 {
1208
1209
1210 }
1211 return 0;
1212 }
1213
1214 GETFIELD(arm_rfft_fast_instance_f64,Sint,"?");
1215 GETFIELD(arm_rfft_fast_instance_f64,fftLenRFFT,"h");
1216
1217
1218 static PyMethodDef arm_rfft_fast_instance_f64_methods[] = {
1219
1220 {"Sint", (PyCFunction) Method_arm_rfft_fast_instance_f64_Sint,METH_NOARGS,"Sint"},
1221 {"fftLenRFFT", (PyCFunction) Method_arm_rfft_fast_instance_f64_fftLenRFFT,METH_NOARGS,"fftLenRFFT"},
1222
1223 {NULL} /* Sentinel */
1224 };
1225
1226
1227 DSPType(arm_rfft_fast_instance_f64,arm_rfft_fast_instance_f64_new,arm_rfft_fast_instance_f64_dealloc,arm_rfft_fast_instance_f64_init,arm_rfft_fast_instance_f64_methods);
1228
1229
1230 typedef struct {
1231 PyObject_HEAD
1232 arm_rfft_fast_instance_f32 *instance;
1233 } dsp_arm_rfft_fast_instance_f32Object;
1234
1235
1236 static void
arm_rfft_fast_instance_f32_dealloc(dsp_arm_rfft_fast_instance_f32Object * self)1237 arm_rfft_fast_instance_f32_dealloc(dsp_arm_rfft_fast_instance_f32Object* self)
1238 {
1239 //printf("Dealloc called\n");
1240 if (self->instance)
1241 {
1242
1243
1244 PyMem_Free(self->instance);
1245 }
1246
1247 Py_TYPE(self)->tp_free((PyObject*)self);
1248 }
1249
1250
1251 static PyObject *
arm_rfft_fast_instance_f32_new(PyTypeObject * type,PyObject * args,PyObject * kwds)1252 arm_rfft_fast_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1253 {
1254 dsp_arm_rfft_fast_instance_f32Object *self;
1255 //printf("New called\n");
1256
1257 self = (dsp_arm_rfft_fast_instance_f32Object *)type->tp_alloc(type, 0);
1258 //printf("alloc called\n");
1259
1260 if (self != NULL) {
1261
1262 self->instance = PyMem_Malloc(sizeof(arm_rfft_fast_instance_f32));
1263
1264 self->instance->pTwiddleRFFT = NULL;
1265
1266 }
1267
1268
1269 return (PyObject *)self;
1270 }
1271
1272 static int
arm_rfft_fast_instance_f32_init(dsp_arm_rfft_fast_instance_f32Object * self,PyObject * args,PyObject * kwds)1273 arm_rfft_fast_instance_f32_init(dsp_arm_rfft_fast_instance_f32Object *self, PyObject *args, PyObject *kwds)
1274 {
1275
1276 PyObject *pTwiddleRFFT=NULL;
1277 char *kwlist[] = {
1278 "Sint","fftLenRFFT",NULL
1279 };
1280
1281 if (PyArg_ParseTupleAndKeywords(args, kwds, "|?h", kwlist,&self->instance->Sint
1282 ,&self->instance->fftLenRFFT
1283 ))
1284 {
1285
1286
1287 }
1288 return 0;
1289 }
1290
1291 GETFIELD(arm_rfft_fast_instance_f32,Sint,"?");
1292 GETFIELD(arm_rfft_fast_instance_f32,fftLenRFFT,"h");
1293
1294
1295 static PyMethodDef arm_rfft_fast_instance_f32_methods[] = {
1296
1297 {"Sint", (PyCFunction) Method_arm_rfft_fast_instance_f32_Sint,METH_NOARGS,"Sint"},
1298 {"fftLenRFFT", (PyCFunction) Method_arm_rfft_fast_instance_f32_fftLenRFFT,METH_NOARGS,"fftLenRFFT"},
1299
1300 {NULL} /* Sentinel */
1301 };
1302
1303
1304 DSPType(arm_rfft_fast_instance_f32,arm_rfft_fast_instance_f32_new,arm_rfft_fast_instance_f32_dealloc,arm_rfft_fast_instance_f32_init,arm_rfft_fast_instance_f32_methods);
1305
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 arm_dct4_instance_f32 *instance;
1310 } dsp_arm_dct4_instance_f32Object;
1311
1312
1313 static void
arm_dct4_instance_f32_dealloc(dsp_arm_dct4_instance_f32Object * self)1314 arm_dct4_instance_f32_dealloc(dsp_arm_dct4_instance_f32Object* self)
1315 {
1316 //printf("Dealloc called\n");
1317 if (self->instance)
1318 {
1319
1320
1321 PyMem_Free(self->instance);
1322 }
1323
1324 Py_TYPE(self)->tp_free((PyObject*)self);
1325 }
1326
1327
1328 static PyObject *
arm_dct4_instance_f32_new(PyTypeObject * type,PyObject * args,PyObject * kwds)1329 arm_dct4_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1330 {
1331 dsp_arm_dct4_instance_f32Object *self;
1332 //printf("New called\n");
1333
1334 self = (dsp_arm_dct4_instance_f32Object *)type->tp_alloc(type, 0);
1335 //printf("alloc called\n");
1336
1337 if (self != NULL) {
1338
1339 self->instance = PyMem_Malloc(sizeof(arm_dct4_instance_f32));
1340
1341 self->instance->pTwiddle = NULL;
1342 self->instance->pCosFactor = NULL;
1343 self->instance->pRfft = NULL;
1344 self->instance->pCfft = NULL;
1345
1346 }
1347
1348
1349 return (PyObject *)self;
1350 }
1351
1352 static int
arm_dct4_instance_f32_init(dsp_arm_dct4_instance_f32Object * self,PyObject * args,PyObject * kwds)1353 arm_dct4_instance_f32_init(dsp_arm_dct4_instance_f32Object *self, PyObject *args, PyObject *kwds)
1354 {
1355
1356 PyObject *pTwiddle=NULL;
1357 PyObject *pCosFactor=NULL;
1358 PyObject *pRfft=NULL;
1359 PyObject *pCfft=NULL;
1360 char *kwlist[] = {
1361 "N","Nby2","normalize",NULL
1362 };
1363
1364 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhf", kwlist,&self->instance->N
1365 ,&self->instance->Nby2
1366 ,&self->instance->normalize
1367 ))
1368 {
1369
1370
1371 }
1372 return 0;
1373 }
1374
1375 GETFIELD(arm_dct4_instance_f32,N,"h");
1376 GETFIELD(arm_dct4_instance_f32,Nby2,"h");
1377 GETFIELD(arm_dct4_instance_f32,normalize,"f");
1378
1379
1380 static PyMethodDef arm_dct4_instance_f32_methods[] = {
1381
1382 {"N", (PyCFunction) Method_arm_dct4_instance_f32_N,METH_NOARGS,"N"},
1383 {"Nby2", (PyCFunction) Method_arm_dct4_instance_f32_Nby2,METH_NOARGS,"Nby2"},
1384 {"normalize", (PyCFunction) Method_arm_dct4_instance_f32_normalize,METH_NOARGS,"normalize"},
1385
1386 {NULL} /* Sentinel */
1387 };
1388
1389
1390 DSPType(arm_dct4_instance_f32,arm_dct4_instance_f32_new,arm_dct4_instance_f32_dealloc,arm_dct4_instance_f32_init,arm_dct4_instance_f32_methods);
1391
1392
1393 typedef struct {
1394 PyObject_HEAD
1395 arm_dct4_instance_q31 *instance;
1396 } dsp_arm_dct4_instance_q31Object;
1397
1398
1399 static void
arm_dct4_instance_q31_dealloc(dsp_arm_dct4_instance_q31Object * self)1400 arm_dct4_instance_q31_dealloc(dsp_arm_dct4_instance_q31Object* self)
1401 {
1402 //printf("Dealloc called\n");
1403 if (self->instance)
1404 {
1405
1406
1407 PyMem_Free(self->instance);
1408 }
1409
1410 Py_TYPE(self)->tp_free((PyObject*)self);
1411 }
1412
1413
1414 static PyObject *
arm_dct4_instance_q31_new(PyTypeObject * type,PyObject * args,PyObject * kwds)1415 arm_dct4_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1416 {
1417 dsp_arm_dct4_instance_q31Object *self;
1418 //printf("New called\n");
1419
1420 self = (dsp_arm_dct4_instance_q31Object *)type->tp_alloc(type, 0);
1421 //printf("alloc called\n");
1422
1423 if (self != NULL) {
1424
1425 self->instance = PyMem_Malloc(sizeof(arm_dct4_instance_q31));
1426
1427 self->instance->pTwiddle = NULL;
1428 self->instance->pCosFactor = NULL;
1429 self->instance->pRfft = NULL;
1430 self->instance->pCfft = NULL;
1431
1432 }
1433
1434
1435 return (PyObject *)self;
1436 }
1437
1438 static int
arm_dct4_instance_q31_init(dsp_arm_dct4_instance_q31Object * self,PyObject * args,PyObject * kwds)1439 arm_dct4_instance_q31_init(dsp_arm_dct4_instance_q31Object *self, PyObject *args, PyObject *kwds)
1440 {
1441
1442 PyObject *pTwiddle=NULL;
1443 PyObject *pCosFactor=NULL;
1444 PyObject *pRfft=NULL;
1445 PyObject *pCfft=NULL;
1446 char *kwlist[] = {
1447 "N","Nby2","normalize",NULL
1448 };
1449
1450 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhi", kwlist,&self->instance->N
1451 ,&self->instance->Nby2
1452 ,&self->instance->normalize
1453 ))
1454 {
1455
1456
1457 }
1458 return 0;
1459 }
1460
1461 GETFIELD(arm_dct4_instance_q31,N,"h");
1462 GETFIELD(arm_dct4_instance_q31,Nby2,"h");
1463 GETFIELD(arm_dct4_instance_q31,normalize,"i");
1464
1465
1466 static PyMethodDef arm_dct4_instance_q31_methods[] = {
1467
1468 {"N", (PyCFunction) Method_arm_dct4_instance_q31_N,METH_NOARGS,"N"},
1469 {"Nby2", (PyCFunction) Method_arm_dct4_instance_q31_Nby2,METH_NOARGS,"Nby2"},
1470 {"normalize", (PyCFunction) Method_arm_dct4_instance_q31_normalize,METH_NOARGS,"normalize"},
1471
1472 {NULL} /* Sentinel */
1473 };
1474
1475
1476 DSPType(arm_dct4_instance_q31,arm_dct4_instance_q31_new,arm_dct4_instance_q31_dealloc,arm_dct4_instance_q31_init,arm_dct4_instance_q31_methods);
1477
1478
1479 typedef struct {
1480 PyObject_HEAD
1481 arm_dct4_instance_q15 *instance;
1482 } dsp_arm_dct4_instance_q15Object;
1483
1484
1485 static void
arm_dct4_instance_q15_dealloc(dsp_arm_dct4_instance_q15Object * self)1486 arm_dct4_instance_q15_dealloc(dsp_arm_dct4_instance_q15Object* self)
1487 {
1488 //printf("Dealloc called\n");
1489 if (self->instance)
1490 {
1491
1492
1493 PyMem_Free(self->instance);
1494 }
1495
1496 Py_TYPE(self)->tp_free((PyObject*)self);
1497 }
1498
1499
1500 static PyObject *
arm_dct4_instance_q15_new(PyTypeObject * type,PyObject * args,PyObject * kwds)1501 arm_dct4_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1502 {
1503 dsp_arm_dct4_instance_q15Object *self;
1504 //printf("New called\n");
1505
1506 self = (dsp_arm_dct4_instance_q15Object *)type->tp_alloc(type, 0);
1507 //printf("alloc called\n");
1508
1509 if (self != NULL) {
1510
1511 self->instance = PyMem_Malloc(sizeof(arm_dct4_instance_q15));
1512
1513 self->instance->pTwiddle = NULL;
1514 self->instance->pCosFactor = NULL;
1515 self->instance->pRfft = NULL;
1516 self->instance->pCfft = NULL;
1517
1518 }
1519
1520
1521 return (PyObject *)self;
1522 }
1523
1524 static int
arm_dct4_instance_q15_init(dsp_arm_dct4_instance_q15Object * self,PyObject * args,PyObject * kwds)1525 arm_dct4_instance_q15_init(dsp_arm_dct4_instance_q15Object *self, PyObject *args, PyObject *kwds)
1526 {
1527
1528 PyObject *pTwiddle=NULL;
1529 PyObject *pCosFactor=NULL;
1530 PyObject *pRfft=NULL;
1531 PyObject *pCfft=NULL;
1532 char *kwlist[] = {
1533 "N","Nby2","normalize",NULL
1534 };
1535
1536 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhh", kwlist,&self->instance->N
1537 ,&self->instance->Nby2
1538 ,&self->instance->normalize
1539 ))
1540 {
1541
1542
1543 }
1544 return 0;
1545 }
1546
1547 GETFIELD(arm_dct4_instance_q15,N,"h");
1548 GETFIELD(arm_dct4_instance_q15,Nby2,"h");
1549 GETFIELD(arm_dct4_instance_q15,normalize,"h");
1550
1551
1552 static PyMethodDef arm_dct4_instance_q15_methods[] = {
1553
1554 {"N", (PyCFunction) Method_arm_dct4_instance_q15_N,METH_NOARGS,"N"},
1555 {"Nby2", (PyCFunction) Method_arm_dct4_instance_q15_Nby2,METH_NOARGS,"Nby2"},
1556 {"normalize", (PyCFunction) Method_arm_dct4_instance_q15_normalize,METH_NOARGS,"normalize"},
1557
1558 {NULL} /* Sentinel */
1559 };
1560
1561
1562 DSPType(arm_dct4_instance_q15,arm_dct4_instance_q15_new,arm_dct4_instance_q15_dealloc,arm_dct4_instance_q15_init,arm_dct4_instance_q15_methods);
1563
1564
1565
1566 typedef struct {
1567 PyObject_HEAD
1568 arm_mfcc_instance_f32 *instance;
1569 } dsp_arm_mfcc_instance_f32Object;
1570
1571 typedef struct {
1572 PyObject_HEAD
1573 arm_mfcc_instance_q31 *instance;
1574 } dsp_arm_mfcc_instance_q31Object;
1575
1576 typedef struct {
1577 PyObject_HEAD
1578 arm_mfcc_instance_q15 *instance;
1579 } dsp_arm_mfcc_instance_q15Object;
1580
1581 static void
arm_mfcc_instance_f32_dealloc(dsp_arm_mfcc_instance_f32Object * self)1582 arm_mfcc_instance_f32_dealloc(dsp_arm_mfcc_instance_f32Object* self)
1583 {
1584 //printf("Dealloc called\n");
1585 if (self->instance)
1586 {
1587
1588
1589 PyMem_Free(self->instance);
1590 }
1591
1592 Py_TYPE(self)->tp_free((PyObject*)self);
1593 }
1594
1595 static void
arm_mfcc_instance_q31_dealloc(dsp_arm_mfcc_instance_q31Object * self)1596 arm_mfcc_instance_q31_dealloc(dsp_arm_mfcc_instance_q31Object* self)
1597 {
1598 //printf("Dealloc called\n");
1599 if (self->instance)
1600 {
1601
1602
1603 PyMem_Free(self->instance);
1604 }
1605
1606 Py_TYPE(self)->tp_free((PyObject*)self);
1607 }
1608
1609 static void
arm_mfcc_instance_q15_dealloc(dsp_arm_mfcc_instance_q15Object * self)1610 arm_mfcc_instance_q15_dealloc(dsp_arm_mfcc_instance_q15Object* self)
1611 {
1612 //printf("Dealloc called\n");
1613 if (self->instance)
1614 {
1615
1616
1617 PyMem_Free(self->instance);
1618 }
1619
1620 Py_TYPE(self)->tp_free((PyObject*)self);
1621 }
1622
1623 static PyObject *
arm_mfcc_instance_f32_new(PyTypeObject * type,PyObject * args,PyObject * kwds)1624 arm_mfcc_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1625 {
1626 dsp_arm_mfcc_instance_f32Object *self;
1627 //printf("New called\n");
1628
1629 self = (dsp_arm_mfcc_instance_f32Object *)type->tp_alloc(type, 0);
1630 //printf("alloc called\n");
1631
1632 if (self != NULL) {
1633
1634 self->instance = PyMem_Malloc(sizeof(arm_mfcc_instance_f32));
1635
1636 self->instance->dctCoefs = NULL;
1637 self->instance->filterCoefs = NULL;
1638 self->instance->windowCoefs = NULL;
1639 self->instance->filterPos = NULL;
1640 self->instance->filterLengths = NULL;
1641
1642 }
1643
1644
1645 return (PyObject *)self;
1646 }
1647
1648 static PyObject *
arm_mfcc_instance_q31_new(PyTypeObject * type,PyObject * args,PyObject * kwds)1649 arm_mfcc_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1650 {
1651 dsp_arm_mfcc_instance_q31Object *self;
1652 //printf("New called\n");
1653
1654 self = (dsp_arm_mfcc_instance_q31Object *)type->tp_alloc(type, 0);
1655 //printf("alloc called\n");
1656
1657 if (self != NULL) {
1658
1659 self->instance = PyMem_Malloc(sizeof(arm_mfcc_instance_q31));
1660
1661 self->instance->dctCoefs = NULL;
1662 self->instance->filterCoefs = NULL;
1663 self->instance->windowCoefs = NULL;
1664 self->instance->filterPos = NULL;
1665 self->instance->filterLengths = NULL;
1666
1667 }
1668
1669
1670 return (PyObject *)self;
1671 }
1672
1673 static PyObject *
arm_mfcc_instance_q15_new(PyTypeObject * type,PyObject * args,PyObject * kwds)1674 arm_mfcc_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1675 {
1676 dsp_arm_mfcc_instance_q15Object *self;
1677 //printf("New called\n");
1678
1679 self = (dsp_arm_mfcc_instance_q15Object *)type->tp_alloc(type, 0);
1680 //printf("alloc called\n");
1681
1682 if (self != NULL) {
1683
1684 self->instance = PyMem_Malloc(sizeof(arm_mfcc_instance_q15));
1685
1686 self->instance->dctCoefs = NULL;
1687 self->instance->filterCoefs = NULL;
1688 self->instance->windowCoefs = NULL;
1689 self->instance->filterPos = NULL;
1690 self->instance->filterLengths = NULL;
1691
1692 }
1693
1694
1695 return (PyObject *)self;
1696 }
1697
1698 static int
arm_mfcc_instance_f32_init(dsp_arm_mfcc_instance_f32Object * self,PyObject * args,PyObject * kwds)1699 arm_mfcc_instance_f32_init(dsp_arm_mfcc_instance_f32Object *self, PyObject *args, PyObject *kwds)
1700 {
1701
1702 PyObject *pTwiddle=NULL;
1703 PyObject *pBitRevTable=NULL;
1704 char *kwlist[] = {
1705 "fftLen","nbMelFilters","nbDctOutputs",NULL
1706 };
1707
1708 if (PyArg_ParseTupleAndKeywords(args, kwds, "|iii", kwlist,&self->instance->fftLen
1709 ,&self->instance->nbMelFilters,&self->instance->nbDctOutputs
1710 ))
1711 {
1712
1713
1714 }
1715 return 0;
1716 }
1717
1718 static int
arm_mfcc_instance_q31_init(dsp_arm_mfcc_instance_q31Object * self,PyObject * args,PyObject * kwds)1719 arm_mfcc_instance_q31_init(dsp_arm_mfcc_instance_q31Object *self, PyObject *args, PyObject *kwds)
1720 {
1721
1722 PyObject *pTwiddle=NULL;
1723 PyObject *pBitRevTable=NULL;
1724 char *kwlist[] = {
1725 "fftLen","nbMelFilters","nbDctOutputs",NULL
1726 };
1727
1728 if (PyArg_ParseTupleAndKeywords(args, kwds, "|iii", kwlist,&self->instance->fftLen
1729 ,&self->instance->nbMelFilters,&self->instance->nbDctOutputs
1730 ))
1731 {
1732
1733
1734 }
1735 return 0;
1736 }
1737
1738 static int
arm_mfcc_instance_q15_init(dsp_arm_mfcc_instance_q15Object * self,PyObject * args,PyObject * kwds)1739 arm_mfcc_instance_q15_init(dsp_arm_mfcc_instance_q15Object *self, PyObject *args, PyObject *kwds)
1740 {
1741
1742 PyObject *pTwiddle=NULL;
1743 PyObject *pBitRevTable=NULL;
1744 char *kwlist[] = {
1745 "fftLen","nbMelFilters","nbDctOutputs",NULL
1746 };
1747
1748 if (PyArg_ParseTupleAndKeywords(args, kwds, "|iii", kwlist,&self->instance->fftLen
1749 ,&self->instance->nbMelFilters,&self->instance->nbDctOutputs
1750 ))
1751 {
1752
1753
1754 }
1755 return 0;
1756 }
1757
1758 GETFIELD(arm_mfcc_instance_f32,fftLen,"i");
1759 GETFIELD(arm_mfcc_instance_f32,nbMelFilters,"i");
1760 GETFIELD(arm_mfcc_instance_f32,nbDctOutputs,"i");
1761
1762 GETFIELD(arm_mfcc_instance_q31,fftLen,"i");
1763 GETFIELD(arm_mfcc_instance_q31,nbMelFilters,"i");
1764 GETFIELD(arm_mfcc_instance_q31,nbDctOutputs,"i");
1765
1766 GETFIELD(arm_mfcc_instance_q15,fftLen,"i");
1767 GETFIELD(arm_mfcc_instance_q15,nbMelFilters,"i");
1768 GETFIELD(arm_mfcc_instance_q15,nbDctOutputs,"i");
1769
1770
1771 static PyMethodDef arm_mfcc_instance_f32_methods[] = {
1772
1773 {"fftLen", (PyCFunction) Method_arm_mfcc_instance_f32_fftLen,METH_NOARGS,"fftLen"},
1774 {"nbMelFilters", (PyCFunction) Method_arm_mfcc_instance_f32_nbMelFilters,METH_NOARGS,"nbMelFilters"},
1775 {"nbDctOutputs", (PyCFunction) Method_arm_mfcc_instance_f32_nbDctOutputs,METH_NOARGS,"nbDctOutputs"},
1776
1777 {NULL} /* Sentinel */
1778 };
1779
1780 static PyMethodDef arm_mfcc_instance_q31_methods[] = {
1781
1782 {"fftLen", (PyCFunction) Method_arm_mfcc_instance_q31_fftLen,METH_NOARGS,"fftLen"},
1783 {"nbMelFilters", (PyCFunction) Method_arm_mfcc_instance_q31_nbMelFilters,METH_NOARGS,"nbMelFilters"},
1784 {"nbDctOutputs", (PyCFunction) Method_arm_mfcc_instance_q31_nbDctOutputs,METH_NOARGS,"nbDctOutputs"},
1785
1786 {NULL} /* Sentinel */
1787 };
1788
1789 static PyMethodDef arm_mfcc_instance_q15_methods[] = {
1790
1791 {"fftLen", (PyCFunction) Method_arm_mfcc_instance_q15_fftLen,METH_NOARGS,"fftLen"},
1792 {"nbMelFilters", (PyCFunction) Method_arm_mfcc_instance_q15_nbMelFilters,METH_NOARGS,"nbMelFilters"},
1793 {"nbDctOutputs", (PyCFunction) Method_arm_mfcc_instance_q15_nbDctOutputs,METH_NOARGS,"nbDctOutputs"},
1794
1795 {NULL} /* Sentinel */
1796 };
1797
1798
1799 DSPType(arm_mfcc_instance_f32,arm_mfcc_instance_f32_new,arm_mfcc_instance_f32_dealloc,arm_mfcc_instance_f32_init,arm_mfcc_instance_f32_methods);
1800 DSPType(arm_mfcc_instance_q31,arm_mfcc_instance_q31_new,arm_mfcc_instance_q31_dealloc,arm_mfcc_instance_q31_init,arm_mfcc_instance_q31_methods);
1801 DSPType(arm_mfcc_instance_q15,arm_mfcc_instance_q15_new,arm_mfcc_instance_q15_dealloc,arm_mfcc_instance_q15_init,arm_mfcc_instance_q15_methods);
1802
1803
1804
typeRegistration(PyObject * module)1805 void typeRegistration(PyObject *module) {
1806
1807
1808
1809 ADDTYPE(arm_cfft_radix2_instance_q15);
1810 ADDTYPE(arm_cfft_radix4_instance_q15);
1811 ADDTYPE(arm_cfft_radix2_instance_q31);
1812 ADDTYPE(arm_cfft_radix4_instance_q31);
1813 ADDTYPE(arm_cfft_radix2_instance_f32);
1814 ADDTYPE(arm_cfft_radix4_instance_f32);
1815 ADDTYPE(arm_cfft_instance_q15);
1816 ADDTYPE(arm_cfft_instance_q31);
1817 ADDTYPE(arm_cfft_instance_f32);
1818 ADDTYPE(arm_rfft_instance_q15);
1819 ADDTYPE(arm_rfft_instance_q31);
1820 ADDTYPE(arm_rfft_fast_instance_f32);
1821 ADDTYPE(arm_rfft_fast_instance_f64);
1822 ADDTYPE(arm_dct4_instance_f32);
1823 ADDTYPE(arm_dct4_instance_q31);
1824 ADDTYPE(arm_dct4_instance_q15);
1825
1826
1827 ADDTYPE(arm_mfcc_instance_f32);
1828 ADDTYPE(arm_mfcc_instance_q31);
1829 ADDTYPE(arm_mfcc_instance_q15);
1830 }
1831
1832
1833
1834
1835 static PyObject *
cmsis_arm_cfft_radix2_init_q15(PyObject * obj,PyObject * args)1836 cmsis_arm_cfft_radix2_init_q15(PyObject *obj, PyObject *args)
1837 {
1838
1839 PyObject *S=NULL; // input
1840 uint16_t fftLen; // input
1841 uint32_t ifftFlag; // input
1842 uint32_t bitReverseFlag; // input
1843
1844 if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
1845 {
1846
1847 dsp_arm_cfft_radix2_instance_q15Object *selfS = (dsp_arm_cfft_radix2_instance_q15Object *)S;
1848
1849 arm_status returnValue = arm_cfft_radix2_init_q15(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
1850 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1851
1852 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
1853
1854 Py_DECREF(theReturnOBJ);
1855 return(pythonResult);
1856
1857 }
1858 return(NULL);
1859 }
1860
1861
1862 static PyObject *
cmsis_arm_cfft_radix2_q15(PyObject * obj,PyObject * args)1863 cmsis_arm_cfft_radix2_q15(PyObject *obj, PyObject *args)
1864 {
1865
1866 PyObject *S=NULL; // input
1867 PyObject *pSrc=NULL; // input
1868 q15_t *pSrc_converted=NULL; // input
1869
1870 if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
1871 {
1872
1873 dsp_arm_cfft_radix2_instance_q15Object *selfS = (dsp_arm_cfft_radix2_instance_q15Object *)S;
1874 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
1875
1876 arm_cfft_radix2_q15(selfS->instance,pSrc_converted);
1877 FREEARGUMENT(pSrc_converted);
1878 Py_RETURN_NONE;
1879
1880 }
1881 return(NULL);
1882 }
1883
1884
1885 static PyObject *
cmsis_arm_cfft_radix4_init_q15(PyObject * obj,PyObject * args)1886 cmsis_arm_cfft_radix4_init_q15(PyObject *obj, PyObject *args)
1887 {
1888
1889 PyObject *S=NULL; // input
1890 uint16_t fftLen; // input
1891 uint32_t ifftFlag; // input
1892 uint32_t bitReverseFlag; // input
1893
1894 if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
1895 {
1896
1897 dsp_arm_cfft_radix4_instance_q15Object *selfS = (dsp_arm_cfft_radix4_instance_q15Object *)S;
1898
1899 arm_status returnValue = arm_cfft_radix4_init_q15(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
1900 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1901
1902 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
1903
1904 Py_DECREF(theReturnOBJ);
1905 return(pythonResult);
1906
1907 }
1908 return(NULL);
1909 }
1910
1911
1912 static PyObject *
cmsis_arm_cfft_radix4_q15(PyObject * obj,PyObject * args)1913 cmsis_arm_cfft_radix4_q15(PyObject *obj, PyObject *args)
1914 {
1915
1916 PyObject *S=NULL; // input
1917 PyObject *pSrc=NULL; // input
1918 q15_t *pSrc_converted=NULL; // input
1919
1920 if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
1921 {
1922
1923 dsp_arm_cfft_radix4_instance_q15Object *selfS = (dsp_arm_cfft_radix4_instance_q15Object *)S;
1924 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
1925
1926 arm_cfft_radix4_q15(selfS->instance,pSrc_converted);
1927 FREEARGUMENT(pSrc_converted);
1928 Py_RETURN_NONE;
1929
1930 }
1931 return(NULL);
1932 }
1933
1934
1935 static PyObject *
cmsis_arm_cfft_radix2_init_q31(PyObject * obj,PyObject * args)1936 cmsis_arm_cfft_radix2_init_q31(PyObject *obj, PyObject *args)
1937 {
1938
1939 PyObject *S=NULL; // input
1940 uint16_t fftLen; // input
1941 uint32_t ifftFlag; // input
1942 uint32_t bitReverseFlag; // input
1943
1944 if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
1945 {
1946
1947 dsp_arm_cfft_radix2_instance_q31Object *selfS = (dsp_arm_cfft_radix2_instance_q31Object *)S;
1948
1949 arm_status returnValue = arm_cfft_radix2_init_q31(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
1950 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1951
1952 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
1953
1954 Py_DECREF(theReturnOBJ);
1955 return(pythonResult);
1956
1957 }
1958 return(NULL);
1959 }
1960
1961
1962 static PyObject *
cmsis_arm_cfft_radix2_q31(PyObject * obj,PyObject * args)1963 cmsis_arm_cfft_radix2_q31(PyObject *obj, PyObject *args)
1964 {
1965
1966 PyObject *S=NULL; // input
1967 PyObject *pSrc=NULL; // input
1968 q31_t *pSrc_converted=NULL; // input
1969
1970 if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
1971 {
1972
1973 dsp_arm_cfft_radix2_instance_q31Object *selfS = (dsp_arm_cfft_radix2_instance_q31Object *)S;
1974 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
1975
1976 arm_cfft_radix2_q31(selfS->instance,pSrc_converted);
1977 FREEARGUMENT(pSrc_converted);
1978 Py_RETURN_NONE;
1979
1980 }
1981 return(NULL);
1982 }
1983
1984
1985 static PyObject *
cmsis_arm_cfft_radix4_q31(PyObject * obj,PyObject * args)1986 cmsis_arm_cfft_radix4_q31(PyObject *obj, PyObject *args)
1987 {
1988
1989 PyObject *S=NULL; // input
1990 PyObject *pSrc=NULL; // input
1991 q31_t *pSrc_converted=NULL; // input
1992
1993 if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
1994 {
1995
1996 dsp_arm_cfft_radix4_instance_q31Object *selfS = (dsp_arm_cfft_radix4_instance_q31Object *)S;
1997 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
1998
1999 arm_cfft_radix4_q31(selfS->instance,pSrc_converted);
2000 FREEARGUMENT(pSrc_converted);
2001 Py_RETURN_NONE;
2002
2003 }
2004 return(NULL);
2005 }
2006
2007
2008 static PyObject *
cmsis_arm_cfft_radix4_init_q31(PyObject * obj,PyObject * args)2009 cmsis_arm_cfft_radix4_init_q31(PyObject *obj, PyObject *args)
2010 {
2011
2012 PyObject *S=NULL; // input
2013 uint16_t fftLen; // input
2014 uint32_t ifftFlag; // input
2015 uint32_t bitReverseFlag; // input
2016
2017 if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
2018 {
2019
2020 dsp_arm_cfft_radix4_instance_q31Object *selfS = (dsp_arm_cfft_radix4_instance_q31Object *)S;
2021
2022 arm_status returnValue = arm_cfft_radix4_init_q31(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
2023 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2024
2025 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2026
2027 Py_DECREF(theReturnOBJ);
2028 return(pythonResult);
2029
2030 }
2031 return(NULL);
2032 }
2033
2034
2035 static PyObject *
cmsis_arm_cfft_radix2_init_f32(PyObject * obj,PyObject * args)2036 cmsis_arm_cfft_radix2_init_f32(PyObject *obj, PyObject *args)
2037 {
2038
2039 PyObject *S=NULL; // input
2040 uint16_t fftLen; // input
2041 uint32_t ifftFlag; // input
2042 uint32_t bitReverseFlag; // input
2043
2044 if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
2045 {
2046
2047 dsp_arm_cfft_radix2_instance_f32Object *selfS = (dsp_arm_cfft_radix2_instance_f32Object *)S;
2048
2049 arm_status returnValue = arm_cfft_radix2_init_f32(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
2050 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2051
2052 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2053
2054 Py_DECREF(theReturnOBJ);
2055 return(pythonResult);
2056
2057 }
2058 return(NULL);
2059 }
2060
2061
2062 static PyObject *
cmsis_arm_cfft_radix2_f32(PyObject * obj,PyObject * args)2063 cmsis_arm_cfft_radix2_f32(PyObject *obj, PyObject *args)
2064 {
2065
2066 PyObject *S=NULL; // input
2067 PyObject *pSrc=NULL; // input
2068 float32_t *pSrc_converted=NULL; // input
2069
2070 if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
2071 {
2072
2073 dsp_arm_cfft_radix2_instance_f32Object *selfS = (dsp_arm_cfft_radix2_instance_f32Object *)S;
2074 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
2075
2076 arm_cfft_radix2_f32(selfS->instance,pSrc_converted);
2077 FREEARGUMENT(pSrc_converted);
2078 Py_RETURN_NONE;
2079
2080 }
2081 return(NULL);
2082 }
2083
2084
2085 static PyObject *
cmsis_arm_cfft_radix4_init_f32(PyObject * obj,PyObject * args)2086 cmsis_arm_cfft_radix4_init_f32(PyObject *obj, PyObject *args)
2087 {
2088
2089 PyObject *S=NULL; // input
2090 uint16_t fftLen; // input
2091 uint32_t ifftFlag; // input
2092 uint32_t bitReverseFlag; // input
2093
2094 if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
2095 {
2096
2097 dsp_arm_cfft_radix4_instance_f32Object *selfS = (dsp_arm_cfft_radix4_instance_f32Object *)S;
2098
2099 arm_status returnValue = arm_cfft_radix4_init_f32(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
2100 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2101
2102 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2103
2104 Py_DECREF(theReturnOBJ);
2105 return(pythonResult);
2106
2107 }
2108 return(NULL);
2109 }
2110
2111
2112 static PyObject *
cmsis_arm_cfft_radix4_f32(PyObject * obj,PyObject * args)2113 cmsis_arm_cfft_radix4_f32(PyObject *obj, PyObject *args)
2114 {
2115
2116 PyObject *S=NULL; // input
2117 PyObject *pSrc=NULL; // input
2118 float32_t *pSrc_converted=NULL; // input
2119
2120 if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
2121 {
2122
2123 dsp_arm_cfft_radix4_instance_f32Object *selfS = (dsp_arm_cfft_radix4_instance_f32Object *)S;
2124 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
2125
2126 arm_cfft_radix4_f32(selfS->instance,pSrc_converted);
2127 FREEARGUMENT(pSrc_converted);
2128 Py_RETURN_NONE;
2129
2130 }
2131 return(NULL);
2132 }
2133
2134
2135 static PyObject *
cmsis_arm_cfft_q15(PyObject * obj,PyObject * args)2136 cmsis_arm_cfft_q15(PyObject *obj, PyObject *args)
2137 {
2138
2139 PyObject *S=NULL; // input
2140 PyObject *p1=NULL; // input
2141 q15_t *p1_converted=NULL; // input
2142 uint32_t ifftFlag; // input
2143 uint32_t bitReverseFlag; // input
2144
2145 if (PyArg_ParseTuple(args,"OOii",&S,&p1,&ifftFlag,&bitReverseFlag))
2146 {
2147
2148 dsp_arm_cfft_instance_q15Object *selfS = (dsp_arm_cfft_instance_q15Object *)S;
2149 GETARGUMENT(p1,NPY_INT16,int16_t,int16_t);
2150
2151 arm_cfft_q15(selfS->instance,p1_converted,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
2152 INT16ARRAY1(p1OBJ,2*selfS->instance->fftLen,p1_converted);
2153
2154 PyObject *pythonResult = Py_BuildValue("O",p1OBJ);
2155
2156 return(pythonResult);
2157
2158 }
2159 return(NULL);
2160 }
2161
2162
2163 static PyObject *
cmsis_arm_cfft_q31(PyObject * obj,PyObject * args)2164 cmsis_arm_cfft_q31(PyObject *obj, PyObject *args)
2165 {
2166
2167 PyObject *S=NULL; // input
2168 PyObject *p1=NULL; // input
2169 q31_t *p1_converted=NULL; // input
2170 uint32_t ifftFlag; // input
2171 uint32_t bitReverseFlag; // input
2172
2173 if (PyArg_ParseTuple(args,"OOii",&S,&p1,&ifftFlag,&bitReverseFlag))
2174 {
2175
2176 dsp_arm_cfft_instance_q31Object *selfS = (dsp_arm_cfft_instance_q31Object *)S;
2177 GETARGUMENT(p1,NPY_INT32,int32_t,int32_t);
2178
2179 arm_cfft_q31(selfS->instance,p1_converted,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
2180 INT32ARRAY1(p1OBJ,2*selfS->instance->fftLen,p1_converted);
2181
2182 PyObject *pythonResult = Py_BuildValue("O",p1OBJ);
2183
2184 return(pythonResult);
2185
2186 }
2187 return(NULL);
2188 }
2189
2190
2191
2192 static PyObject *
cmsis_arm_cfft_f64(PyObject * obj,PyObject * args)2193 cmsis_arm_cfft_f64(PyObject *obj, PyObject *args)
2194 {
2195
2196 PyObject *S=NULL; // input
2197 PyObject *p1=NULL; // input
2198 float64_t *p1_converted=NULL; // input
2199 uint32_t ifftFlag; // input
2200 uint32_t bitReverseFlag; // input
2201
2202 if (PyArg_ParseTuple(args,"OOii",&S,&p1,&ifftFlag,&bitReverseFlag))
2203 {
2204
2205 dsp_arm_cfft_instance_f64Object *selfS = (dsp_arm_cfft_instance_f64Object *)S;
2206 GETARGUMENT(p1,NPY_DOUBLE,double,float64_t);
2207
2208 arm_cfft_f64(selfS->instance,p1_converted,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
2209 FLOAT64ARRAY1(p1OBJ,2*selfS->instance->fftLen,p1_converted);
2210
2211 PyObject *pythonResult = Py_BuildValue("O",p1OBJ);
2212
2213 return(pythonResult);
2214
2215 }
2216 return(NULL);
2217 }
2218
2219
2220 static PyObject *
cmsis_arm_cfft_f32(PyObject * obj,PyObject * args)2221 cmsis_arm_cfft_f32(PyObject *obj, PyObject *args)
2222 {
2223
2224 PyObject *S=NULL; // input
2225 PyObject *p1=NULL; // input
2226 float32_t *p1_converted=NULL; // input
2227 uint32_t ifftFlag; // input
2228 uint32_t bitReverseFlag; // input
2229
2230 if (PyArg_ParseTuple(args,"OOii",&S,&p1,&ifftFlag,&bitReverseFlag))
2231 {
2232
2233 dsp_arm_cfft_instance_f32Object *selfS = (dsp_arm_cfft_instance_f32Object *)S;
2234 GETARGUMENT(p1,NPY_DOUBLE,double,float32_t);
2235
2236 arm_cfft_f32(selfS->instance,p1_converted,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
2237 FLOATARRAY1(p1OBJ,2*selfS->instance->fftLen,p1_converted);
2238
2239 PyObject *pythonResult = Py_BuildValue("O",p1OBJ);
2240
2241 return(pythonResult);
2242
2243 }
2244 return(NULL);
2245 }
2246
2247
2248 static PyObject *
cmsis_arm_rfft_init_q15(PyObject * obj,PyObject * args)2249 cmsis_arm_rfft_init_q15(PyObject *obj, PyObject *args)
2250 {
2251
2252 PyObject *S=NULL; // input
2253 uint32_t fftLenReal; // input
2254 uint32_t ifftFlagR; // input
2255 uint32_t bitReverseFlag; // input
2256
2257 if (PyArg_ParseTuple(args,"Oiii",&S,&fftLenReal,&ifftFlagR,&bitReverseFlag))
2258 {
2259
2260 dsp_arm_rfft_instance_q15Object *selfS = (dsp_arm_rfft_instance_q15Object *)S;
2261
2262 arm_status returnValue = arm_rfft_init_q15(selfS->instance,fftLenReal,ifftFlagR,bitReverseFlag);
2263 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2264
2265 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2266
2267 Py_DECREF(theReturnOBJ);
2268 return(pythonResult);
2269
2270 }
2271 return(NULL);
2272 }
2273
2274
2275 static PyObject *
cmsis_arm_rfft_q15(PyObject * obj,PyObject * args)2276 cmsis_arm_rfft_q15(PyObject *obj, PyObject *args)
2277 {
2278
2279 PyObject *S=NULL; // input
2280 PyObject *pSrc=NULL; // input
2281 q15_t *pSrc_converted=NULL; // input
2282 q15_t *pDst=NULL; // output
2283
2284 if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
2285 {
2286 int inputSize;
2287 int outputSize;
2288
2289 dsp_arm_rfft_instance_q15Object *selfS = (dsp_arm_rfft_instance_q15Object *)S;
2290
2291 inputSize=selfS->instance->fftLenReal;
2292 if (selfS->instance->ifftFlagR)
2293 {
2294 outputSize = inputSize;
2295 }
2296 else
2297 {
2298 outputSize = 2*inputSize;
2299 }
2300
2301 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
2302
2303 pDst=PyMem_Malloc(sizeof(q15_t)*outputSize);
2304
2305
2306 arm_rfft_q15(selfS->instance,pSrc_converted,pDst);
2307 INT16ARRAY1(pDstOBJ,outputSize,pDst);
2308
2309 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
2310
2311 FREEARGUMENT(pSrc_converted);
2312 Py_DECREF(pDstOBJ);
2313 return(pythonResult);
2314
2315 }
2316 return(NULL);
2317 }
2318
2319
2320 static PyObject *
cmsis_arm_rfft_init_q31(PyObject * obj,PyObject * args)2321 cmsis_arm_rfft_init_q31(PyObject *obj, PyObject *args)
2322 {
2323
2324 PyObject *S=NULL; // input
2325 uint32_t fftLenReal; // input
2326 uint32_t ifftFlagR; // input
2327 uint32_t bitReverseFlag; // input
2328
2329 if (PyArg_ParseTuple(args,"Oiii",&S,&fftLenReal,&ifftFlagR,&bitReverseFlag))
2330 {
2331
2332 dsp_arm_rfft_instance_q31Object *selfS = (dsp_arm_rfft_instance_q31Object *)S;
2333
2334 arm_status returnValue = arm_rfft_init_q31(selfS->instance,fftLenReal,ifftFlagR,bitReverseFlag);
2335 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2336
2337 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2338
2339 Py_DECREF(theReturnOBJ);
2340 return(pythonResult);
2341
2342 }
2343 return(NULL);
2344 }
2345
2346
2347 static PyObject *
cmsis_arm_rfft_q31(PyObject * obj,PyObject * args)2348 cmsis_arm_rfft_q31(PyObject *obj, PyObject *args)
2349 {
2350
2351 PyObject *S=NULL; // input
2352 PyObject *pSrc=NULL; // input
2353 q31_t *pSrc_converted=NULL; // input
2354 q31_t *pDst=NULL; // output
2355
2356
2357
2358 if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
2359 {
2360 int inputSize;
2361 int outputSize;
2362
2363 dsp_arm_rfft_instance_q31Object *selfS = (dsp_arm_rfft_instance_q31Object *)S;
2364
2365 inputSize=selfS->instance->fftLenReal;
2366 if (selfS->instance->ifftFlagR)
2367 {
2368 outputSize = inputSize;
2369 }
2370 else
2371 {
2372 outputSize = 2*inputSize;
2373 }
2374
2375 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
2376
2377 pDst=PyMem_Malloc(sizeof(q31_t)*outputSize);
2378
2379
2380 arm_rfft_q31(selfS->instance,pSrc_converted,pDst);
2381 INT32ARRAY1(pDstOBJ,outputSize,pDst);
2382
2383 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
2384
2385 FREEARGUMENT(pSrc_converted);
2386 Py_DECREF(pDstOBJ);
2387 return(pythonResult);
2388
2389 }
2390 return(NULL);
2391 }
2392
2393
2394 static PyObject *
cmsis_arm_rfft_init_f32(PyObject * obj,PyObject * args)2395 cmsis_arm_rfft_init_f32(PyObject *obj, PyObject *args)
2396 {
2397
2398 PyObject *S=NULL; // input
2399 PyObject *S_CFFT=NULL; // input
2400 uint32_t fftLenReal; // input
2401 uint32_t ifftFlagR; // input
2402 uint32_t bitReverseFlag; // input
2403
2404 if (PyArg_ParseTuple(args,"OOiii",&S,&S_CFFT,&fftLenReal,&ifftFlagR,&bitReverseFlag))
2405 {
2406
2407 dsp_arm_rfft_instance_f32Object *selfS = (dsp_arm_rfft_instance_f32Object *)S;
2408 dsp_arm_cfft_radix4_instance_f32Object *selfS_CFFT = (dsp_arm_cfft_radix4_instance_f32Object *)S_CFFT;
2409
2410 arm_status returnValue = arm_rfft_init_f32(selfS->instance,selfS_CFFT->instance,fftLenReal,ifftFlagR,bitReverseFlag);
2411 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2412
2413 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2414
2415 Py_DECREF(theReturnOBJ);
2416 return(pythonResult);
2417
2418 }
2419 return(NULL);
2420 }
2421
2422
2423 static PyObject *
cmsis_arm_rfft_f32(PyObject * obj,PyObject * args)2424 cmsis_arm_rfft_f32(PyObject *obj, PyObject *args)
2425 {
2426
2427 PyObject *S=NULL; // input
2428 PyObject *pSrc=NULL; // input
2429 float32_t *pSrc_converted=NULL; // input
2430 float32_t *pDst=NULL; // output
2431
2432 if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
2433 {
2434
2435 dsp_arm_rfft_instance_f32Object *selfS = (dsp_arm_rfft_instance_f32Object *)S;
2436 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
2437
2438 pDst=PyMem_Malloc(sizeof(float32_t)*2*selfS->instance->fftLenReal);
2439
2440
2441 arm_rfft_f32(selfS->instance,pSrc_converted,pDst);
2442 FLOATARRAY1(pDstOBJ,selfS->instance->fftLenReal+1,pDst);
2443
2444 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
2445
2446 FREEARGUMENT(pSrc_converted);
2447 Py_DECREF(pDstOBJ);
2448 return(pythonResult);
2449
2450 }
2451 return(NULL);
2452 }
2453
2454 static PyObject *
cmsis_arm_rfft_fast_init_f64(PyObject * obj,PyObject * args)2455 cmsis_arm_rfft_fast_init_f64(PyObject *obj, PyObject *args)
2456 {
2457
2458 PyObject *S=NULL; // input
2459 uint16_t fftLen; // input
2460
2461 if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
2462 {
2463
2464 dsp_arm_rfft_fast_instance_f64Object *selfS = (dsp_arm_rfft_fast_instance_f64Object *)S;
2465
2466 arm_status returnValue = arm_rfft_fast_init_f64(selfS->instance,fftLen);
2467 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2468
2469 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2470
2471 Py_DECREF(theReturnOBJ);
2472 return(pythonResult);
2473
2474 }
2475 return(NULL);
2476 }
2477
2478
2479
2480 static PyObject *
cmsis_arm_rfft_fast_f64(PyObject * obj,PyObject * args)2481 cmsis_arm_rfft_fast_f64(PyObject *obj, PyObject *args)
2482 {
2483
2484 PyObject *S=NULL; // input
2485 PyObject *p=NULL; // input
2486 float64_t *p_converted=NULL; // input
2487 float64_t *pOut=NULL; // output
2488 uint32_t ifftFlag; // input
2489
2490 if (PyArg_ParseTuple(args,"OOi",&S,&p,&ifftFlag))
2491 {
2492
2493 dsp_arm_rfft_fast_instance_f64Object *selfS = (dsp_arm_rfft_fast_instance_f64Object *)S;
2494 GETARGUMENT(p,NPY_DOUBLE,double,float64_t);
2495
2496 pOut=PyMem_Malloc(sizeof(float64_t)*selfS->instance->fftLenRFFT);
2497
2498
2499 arm_rfft_fast_f64(selfS->instance,p_converted,pOut,(uint8_t)ifftFlag);
2500 FLOAT64ARRAY1(pOutOBJ,selfS->instance->fftLenRFFT,pOut);
2501
2502 PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
2503
2504 FREEARGUMENT(p_converted);
2505 Py_DECREF(pOutOBJ);
2506 return(pythonResult);
2507
2508 }
2509 return(NULL);
2510 }
2511
2512
2513
2514 static PyObject *
cmsis_arm_rfft_fast_init_f32(PyObject * obj,PyObject * args)2515 cmsis_arm_rfft_fast_init_f32(PyObject *obj, PyObject *args)
2516 {
2517
2518 PyObject *S=NULL; // input
2519 uint16_t fftLen; // input
2520
2521 if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
2522 {
2523
2524 dsp_arm_rfft_fast_instance_f32Object *selfS = (dsp_arm_rfft_fast_instance_f32Object *)S;
2525
2526 arm_status returnValue = arm_rfft_fast_init_f32(selfS->instance,fftLen);
2527 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2528
2529 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2530
2531 Py_DECREF(theReturnOBJ);
2532 return(pythonResult);
2533
2534 }
2535 return(NULL);
2536 }
2537
2538
2539
2540 static PyObject *
cmsis_arm_rfft_fast_f32(PyObject * obj,PyObject * args)2541 cmsis_arm_rfft_fast_f32(PyObject *obj, PyObject *args)
2542 {
2543
2544 PyObject *S=NULL; // input
2545 PyObject *p=NULL; // input
2546 float32_t *p_converted=NULL; // input
2547 float32_t *pOut=NULL; // output
2548 uint32_t ifftFlag; // input
2549
2550 if (PyArg_ParseTuple(args,"OOi",&S,&p,&ifftFlag))
2551 {
2552
2553 dsp_arm_rfft_fast_instance_f32Object *selfS = (dsp_arm_rfft_fast_instance_f32Object *)S;
2554 GETARGUMENT(p,NPY_DOUBLE,double,float32_t);
2555
2556 pOut=PyMem_Malloc(sizeof(float32_t)*(selfS->instance->fftLenRFFT));
2557
2558
2559 arm_rfft_fast_f32(selfS->instance,p_converted,pOut,(uint8_t)ifftFlag);
2560 FLOATARRAY1(pOutOBJ,(selfS->instance->fftLenRFFT),pOut);
2561
2562 PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
2563
2564 FREEARGUMENT(p_converted);
2565 Py_DECREF(pOutOBJ);
2566 return(pythonResult);
2567
2568 }
2569 return(NULL);
2570 }
2571
2572
2573 static PyObject *
cmsis_arm_dct4_init_f32(PyObject * obj,PyObject * args)2574 cmsis_arm_dct4_init_f32(PyObject *obj, PyObject *args)
2575 {
2576
2577 PyObject *S=NULL; // input
2578 PyObject *S_RFFT=NULL; // input
2579 PyObject *S_CFFT=NULL; // input
2580 uint16_t N; // input
2581 uint16_t Nby2; // input
2582 float32_t normalize; // input
2583
2584 if (PyArg_ParseTuple(args,"OOOhhf",&S,&S_RFFT,&S_CFFT,&N,&Nby2,&normalize))
2585 {
2586
2587 dsp_arm_dct4_instance_f32Object *selfS = (dsp_arm_dct4_instance_f32Object *)S;
2588 dsp_arm_rfft_instance_f32Object *selfS_RFFT = (dsp_arm_rfft_instance_f32Object *)S_RFFT;
2589 dsp_arm_cfft_radix4_instance_f32Object *selfS_CFFT = (dsp_arm_cfft_radix4_instance_f32Object *)S_CFFT;
2590 uint32_t outputLength = selfS->instance->N ;
2591
2592 arm_status returnValue = arm_dct4_init_f32(selfS->instance,selfS_RFFT->instance,selfS_CFFT->instance,N,Nby2,normalize);
2593 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2594
2595 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2596
2597 Py_DECREF(theReturnOBJ);
2598 return(pythonResult);
2599
2600 }
2601 return(NULL);
2602 }
2603
2604
2605 static PyObject *
cmsis_arm_dct4_f32(PyObject * obj,PyObject * args)2606 cmsis_arm_dct4_f32(PyObject *obj, PyObject *args)
2607 {
2608
2609 PyObject *S=NULL; // input
2610 PyObject *pState=NULL; // input
2611 float32_t *pState_converted=NULL; // input
2612 PyObject *pInlineBuffer=NULL; // input
2613 float32_t *pInlineBuffer_converted=NULL; // input
2614
2615 if (PyArg_ParseTuple(args,"OOO",&S,&pState,&pInlineBuffer))
2616 {
2617
2618 dsp_arm_dct4_instance_f32Object *selfS = (dsp_arm_dct4_instance_f32Object *)S;
2619 GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
2620 GETARGUMENT(pInlineBuffer,NPY_DOUBLE,double,float32_t);
2621 uint32_t outputLength = selfS->instance->N ;
2622
2623 arm_dct4_f32(selfS->instance,pState_converted,pInlineBuffer_converted);
2624 FLOATARRAY1(pInlineBufferOBJ,outputLength,pInlineBuffer_converted);
2625
2626 PyObject *pythonResult = Py_BuildValue("O",pInlineBufferOBJ);
2627
2628 FREEARGUMENT(pState_converted);
2629 return(pythonResult);
2630
2631 }
2632 return(NULL);
2633 }
2634
2635
2636 static PyObject *
cmsis_arm_dct4_init_q31(PyObject * obj,PyObject * args)2637 cmsis_arm_dct4_init_q31(PyObject *obj, PyObject *args)
2638 {
2639
2640 PyObject *S=NULL; // input
2641 PyObject *S_RFFT=NULL; // input
2642 PyObject *S_CFFT=NULL; // input
2643 uint16_t N; // input
2644 uint16_t Nby2; // input
2645 q31_t normalize; // input
2646
2647 if (PyArg_ParseTuple(args,"OOOhhi",&S,&S_RFFT,&S_CFFT,&N,&Nby2,&normalize))
2648 {
2649
2650 dsp_arm_dct4_instance_q31Object *selfS = (dsp_arm_dct4_instance_q31Object *)S;
2651 dsp_arm_rfft_instance_q31Object *selfS_RFFT = (dsp_arm_rfft_instance_q31Object *)S_RFFT;
2652 dsp_arm_cfft_radix4_instance_q31Object *selfS_CFFT = (dsp_arm_cfft_radix4_instance_q31Object *)S_CFFT;
2653 uint32_t outputLength = selfS->instance->N ;
2654
2655 arm_status returnValue = arm_dct4_init_q31(selfS->instance,selfS_RFFT->instance,selfS_CFFT->instance,N,Nby2,normalize);
2656 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2657
2658 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2659
2660 Py_DECREF(theReturnOBJ);
2661 return(pythonResult);
2662
2663 }
2664 return(NULL);
2665 }
2666
2667
2668 static PyObject *
cmsis_arm_dct4_q31(PyObject * obj,PyObject * args)2669 cmsis_arm_dct4_q31(PyObject *obj, PyObject *args)
2670 {
2671
2672 PyObject *S=NULL; // input
2673 PyObject *pState=NULL; // input
2674 q31_t *pState_converted=NULL; // input
2675 PyObject *pInlineBuffer=NULL; // input
2676 q31_t *pInlineBuffer_converted=NULL; // input
2677
2678 if (PyArg_ParseTuple(args,"OOO",&S,&pState,&pInlineBuffer))
2679 {
2680
2681 dsp_arm_dct4_instance_q31Object *selfS = (dsp_arm_dct4_instance_q31Object *)S;
2682 GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
2683 GETARGUMENT(pInlineBuffer,NPY_INT32,int32_t,int32_t);
2684 uint32_t outputLength = selfS->instance->N ;
2685
2686 arm_dct4_q31(selfS->instance,pState_converted,pInlineBuffer_converted);
2687 INT32ARRAY1(pInlineBufferOBJ,outputLength,pInlineBuffer_converted);
2688
2689 PyObject *pythonResult = Py_BuildValue("O",pInlineBufferOBJ);
2690
2691 FREEARGUMENT(pState_converted);
2692 return(pythonResult);
2693
2694 }
2695 return(NULL);
2696 }
2697
2698
2699 static PyObject *
cmsis_arm_dct4_init_q15(PyObject * obj,PyObject * args)2700 cmsis_arm_dct4_init_q15(PyObject *obj, PyObject *args)
2701 {
2702
2703 PyObject *S=NULL; // input
2704 PyObject *S_RFFT=NULL; // input
2705 PyObject *S_CFFT=NULL; // input
2706 uint16_t N; // input
2707 uint16_t Nby2; // input
2708 q15_t normalize; // input
2709
2710 if (PyArg_ParseTuple(args,"OOOhhh",&S,&S_RFFT,&S_CFFT,&N,&Nby2,&normalize))
2711 {
2712
2713 dsp_arm_dct4_instance_q15Object *selfS = (dsp_arm_dct4_instance_q15Object *)S;
2714 dsp_arm_rfft_instance_q15Object *selfS_RFFT = (dsp_arm_rfft_instance_q15Object *)S_RFFT;
2715 dsp_arm_cfft_radix4_instance_q15Object *selfS_CFFT = (dsp_arm_cfft_radix4_instance_q15Object *)S_CFFT;
2716 uint32_t outputLength = selfS->instance->N ;
2717
2718 arm_status returnValue = arm_dct4_init_q15(selfS->instance,selfS_RFFT->instance,selfS_CFFT->instance,N,Nby2,normalize);
2719 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2720
2721 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2722
2723 Py_DECREF(theReturnOBJ);
2724 return(pythonResult);
2725
2726 }
2727 return(NULL);
2728 }
2729
2730
2731 static PyObject *
cmsis_arm_dct4_q15(PyObject * obj,PyObject * args)2732 cmsis_arm_dct4_q15(PyObject *obj, PyObject *args)
2733 {
2734
2735 PyObject *S=NULL; // input
2736 PyObject *pState=NULL; // input
2737 q15_t *pState_converted=NULL; // input
2738 PyObject *pInlineBuffer=NULL; // input
2739 q15_t *pInlineBuffer_converted=NULL; // input
2740
2741 if (PyArg_ParseTuple(args,"OOO",&S,&pState,&pInlineBuffer))
2742 {
2743
2744 dsp_arm_dct4_instance_q15Object *selfS = (dsp_arm_dct4_instance_q15Object *)S;
2745 GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
2746 GETARGUMENT(pInlineBuffer,NPY_INT16,int16_t,int16_t);
2747 uint32_t outputLength = selfS->instance->N ;
2748
2749 arm_dct4_q15(selfS->instance,pState_converted,pInlineBuffer_converted);
2750 INT16ARRAY1(pInlineBufferOBJ,outputLength,pInlineBuffer_converted);
2751
2752 PyObject *pythonResult = Py_BuildValue("O",pInlineBufferOBJ);
2753
2754 FREEARGUMENT(pState_converted);
2755 return(pythonResult);
2756
2757 }
2758 return(NULL);
2759 }
2760
2761
2762
2763
2764 static PyObject *
cmsis_arm_cfft_init_f32(PyObject * obj,PyObject * args)2765 cmsis_arm_cfft_init_f32(PyObject *obj, PyObject *args)
2766 {
2767
2768 PyObject *S=NULL; // input
2769 uint16_t fftLen; // input
2770
2771 if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
2772 {
2773
2774 dsp_arm_cfft_instance_f32Object *selfS = (dsp_arm_cfft_instance_f32Object *)S;
2775
2776 arm_status returnValue = arm_cfft_init_f32(selfS->instance,fftLen);
2777 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2778
2779 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2780
2781 Py_DECREF(theReturnOBJ);
2782 return(pythonResult);
2783
2784 }
2785 return(NULL);
2786 }
2787
2788 static PyObject *
cmsis_arm_cfft_init_f64(PyObject * obj,PyObject * args)2789 cmsis_arm_cfft_init_f64(PyObject *obj, PyObject *args)
2790 {
2791
2792 PyObject *S=NULL; // input
2793 uint16_t fftLen; // input
2794
2795 if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
2796 {
2797
2798 dsp_arm_cfft_instance_f64Object *selfS = (dsp_arm_cfft_instance_f64Object *)S;
2799
2800 arm_status returnValue = arm_cfft_init_f64(selfS->instance,fftLen);
2801 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2802
2803 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2804
2805 Py_DECREF(theReturnOBJ);
2806 return(pythonResult);
2807
2808 }
2809 return(NULL);
2810 }
2811
2812 static PyObject *
cmsis_arm_cfft_init_q31(PyObject * obj,PyObject * args)2813 cmsis_arm_cfft_init_q31(PyObject *obj, PyObject *args)
2814 {
2815
2816 PyObject *S=NULL; // input
2817 uint16_t fftLen; // input
2818
2819 if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
2820 {
2821
2822 dsp_arm_cfft_instance_q31Object *selfS = (dsp_arm_cfft_instance_q31Object *)S;
2823
2824 arm_status returnValue = arm_cfft_init_q31(selfS->instance,fftLen);
2825 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2826
2827 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2828
2829 Py_DECREF(theReturnOBJ);
2830 return(pythonResult);
2831
2832 }
2833 return(NULL);
2834 }
2835
2836
2837 static PyObject *
cmsis_arm_cfft_init_q15(PyObject * obj,PyObject * args)2838 cmsis_arm_cfft_init_q15(PyObject *obj, PyObject *args)
2839 {
2840
2841 PyObject *S=NULL; // input
2842 uint16_t fftLen; // input
2843
2844 if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
2845 {
2846
2847 dsp_arm_cfft_instance_q15Object *selfS = (dsp_arm_cfft_instance_q15Object *)S;
2848
2849 arm_status returnValue = arm_cfft_init_q15(selfS->instance,fftLen);
2850 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2851
2852 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2853
2854 Py_DECREF(theReturnOBJ);
2855 return(pythonResult);
2856
2857 }
2858 return(NULL);
2859 }
2860
2861
2862
2863 /*
2864
2865 MFCC
2866
2867 */
2868
2869 static PyObject *
cmsis_arm_mfcc_init_f32(PyObject * obj,PyObject * args)2870 cmsis_arm_mfcc_init_f32(PyObject *obj, PyObject *args)
2871 {
2872
2873 PyObject *S=NULL; // input
2874 uint32_t fftLen,nbMelFilters,nbDctOutputs; // input
2875
2876 PyObject *pdctCoefs=NULL; // input
2877 float32_t *pdctCoefs_converted=NULL; // input
2878
2879 PyObject *pfilterCoefs=NULL; // input
2880 float32_t *pfilterCoefs_converted=NULL; // input
2881
2882 PyObject *pwindowCoefs=NULL; // input
2883 float32_t *pwindowCoefs_converted=NULL; // input
2884
2885 PyObject *pfilterPos=NULL; // input
2886 uint32_t *pfilterPos_converted=NULL; // input
2887
2888 PyObject *pfilterLengths=NULL; // input
2889 uint32_t *pfilterLengths_converted=NULL; // input
2890
2891 if (PyArg_ParseTuple(args,"OiiiOOOOO",&S,&fftLen,&nbMelFilters,&nbDctOutputs,
2892 &pdctCoefs,&pfilterPos,&pfilterLengths,&pfilterCoefs,&pwindowCoefs))
2893 {
2894
2895 dsp_arm_mfcc_instance_f32Object *selfS = (dsp_arm_mfcc_instance_f32Object *)S;
2896
2897 GETARGUMENT(pdctCoefs,NPY_DOUBLE,double,float32_t);
2898 GETARGUMENT(pfilterPos,NPY_UINT32,uint32_t,uint32_t);
2899 GETARGUMENT(pfilterLengths,NPY_UINT32,uint32_t,uint32_t);
2900 GETARGUMENT(pfilterCoefs,NPY_DOUBLE,double,float32_t);
2901 GETARGUMENT(pwindowCoefs,NPY_DOUBLE,double,float32_t);
2902
2903
2904 arm_status returnValue = arm_mfcc_init_f32(selfS->instance,
2905 fftLen,nbMelFilters,nbDctOutputs,
2906 pdctCoefs_converted,
2907 pfilterPos_converted,pfilterLengths_converted,pfilterCoefs_converted,
2908 pwindowCoefs_converted);
2909 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2910
2911 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
2912
2913 Py_DECREF(theReturnOBJ);
2914 return(pythonResult);
2915
2916 }
2917 return(NULL);
2918 }
2919
2920 static PyObject *
cmsis_arm_mfcc_f32(PyObject * obj,PyObject * args)2921 cmsis_arm_mfcc_f32(PyObject *obj, PyObject *args)
2922 {
2923
2924 PyObject *S=NULL; // input
2925 PyObject *p1=NULL; // input
2926 float32_t *p1_converted=NULL; // input
2927
2928 PyObject *tmp=NULL; // input
2929 float32_t *tmp_converted=NULL; // input
2930
2931 float32_t *pDst;
2932 if (PyArg_ParseTuple(args,"OOO",&S,&p1,&tmp))
2933 {
2934
2935 dsp_arm_mfcc_instance_f32Object *selfS = (dsp_arm_mfcc_instance_f32Object *)S;
2936 GETARGUMENT(p1,NPY_DOUBLE,double,float32_t);
2937 GETARGUMENT(tmp,NPY_DOUBLE,double,float32_t);
2938
2939 pDst=PyMem_Malloc(sizeof(float32_t)*selfS->instance->nbDctOutputs);
2940
2941 arm_mfcc_f32(selfS->instance,p1_converted,pDst,tmp_converted);
2942
2943 FLOATARRAY1(pDstOBJ,selfS->instance->nbDctOutputs,pDst);
2944
2945 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
2946 Py_DECREF(pDstOBJ);
2947
2948 FREEARGUMENT(p1_converted);
2949 FREEARGUMENT(tmp_converted);
2950
2951
2952
2953
2954 return(pythonResult);
2955
2956 }
2957 return(NULL);
2958 }
2959
2960 static PyObject *
cmsis_arm_mfcc_init_q15(PyObject * obj,PyObject * args)2961 cmsis_arm_mfcc_init_q15(PyObject *obj, PyObject *args)
2962 {
2963
2964 PyObject *S=NULL; // input
2965 uint32_t fftLen,nbMelFilters,nbDctOutputs; // input
2966
2967 PyObject *pdctCoefs=NULL; // input
2968 q15_t *pdctCoefs_converted=NULL; // input
2969
2970 PyObject *pfilterCoefs=NULL; // input
2971 q15_t *pfilterCoefs_converted=NULL; // input
2972
2973 PyObject *pwindowCoefs=NULL; // input
2974 q15_t *pwindowCoefs_converted=NULL; // input
2975
2976 PyObject *pfilterPos=NULL; // input
2977 uint32_t *pfilterPos_converted=NULL; // input
2978
2979 PyObject *pfilterLengths=NULL; // input
2980 uint32_t *pfilterLengths_converted=NULL; // input
2981
2982 if (PyArg_ParseTuple(args,"OiiiOOOOO",&S,&fftLen,&nbMelFilters,&nbDctOutputs,
2983 &pdctCoefs,&pfilterPos,&pfilterLengths,&pfilterCoefs,&pwindowCoefs))
2984 {
2985
2986 dsp_arm_mfcc_instance_q15Object *selfS = (dsp_arm_mfcc_instance_q15Object *)S;
2987
2988 GETARGUMENT(pdctCoefs,NPY_INT16,int16_t,int16_t);
2989 GETARGUMENT(pfilterPos,NPY_UINT32,uint32_t,uint32_t);
2990 GETARGUMENT(pfilterLengths,NPY_UINT32,uint32_t,uint32_t);
2991 GETARGUMENT(pfilterCoefs,NPY_INT16,int16_t,int16_t);
2992 GETARGUMENT(pwindowCoefs,NPY_INT16,int16_t,int16_t);
2993
2994
2995 arm_status returnValue = arm_mfcc_init_q15(selfS->instance,
2996 fftLen,nbMelFilters,nbDctOutputs,
2997 pdctCoefs_converted,
2998 pfilterPos_converted,pfilterLengths_converted,pfilterCoefs_converted,
2999 pwindowCoefs_converted);
3000 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
3001
3002 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
3003
3004 Py_DECREF(theReturnOBJ);
3005 return(pythonResult);
3006
3007 }
3008 return(NULL);
3009 }
3010
3011 static PyObject *
cmsis_arm_mfcc_q15(PyObject * obj,PyObject * args)3012 cmsis_arm_mfcc_q15(PyObject *obj, PyObject *args)
3013 {
3014
3015 PyObject *S=NULL; // input
3016 PyObject *p1=NULL; // input
3017 q15_t *p1_converted=NULL; // input
3018
3019 PyObject *tmp=NULL; // input
3020 q31_t *tmp_converted=NULL; // input
3021
3022 q15_t *pDst;
3023 if (PyArg_ParseTuple(args,"OOO",&S,&p1,&tmp))
3024 {
3025
3026 dsp_arm_mfcc_instance_q15Object *selfS = (dsp_arm_mfcc_instance_q15Object *)S;
3027 GETARGUMENT(p1,NPY_INT16,int16_t,int16_t);
3028 GETARGUMENT(tmp,NPY_INT32,int32_t,int32_t);
3029
3030 pDst=PyMem_Malloc(sizeof(q15_t)*selfS->instance->nbDctOutputs);
3031
3032 arm_status status = arm_mfcc_q15(selfS->instance,p1_converted,pDst,tmp_converted);
3033
3034 INT16ARRAY1(pDstOBJ,selfS->instance->nbDctOutputs,pDst);
3035
3036 PyObject* theReturnOBJ=Py_BuildValue("i",status);
3037 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
3038 Py_DECREF(pDstOBJ);
3039 Py_DECREF(theReturnOBJ);
3040
3041 FREEARGUMENT(p1_converted);
3042 FREEARGUMENT(tmp_converted);
3043
3044
3045
3046 return(pythonResult);
3047
3048 }
3049 return(NULL);
3050 }
3051
3052 static PyObject *
cmsis_arm_mfcc_init_q31(PyObject * obj,PyObject * args)3053 cmsis_arm_mfcc_init_q31(PyObject *obj, PyObject *args)
3054 {
3055
3056 PyObject *S=NULL; // input
3057 uint32_t fftLen,nbMelFilters,nbDctOutputs; // input
3058
3059 PyObject *pdctCoefs=NULL; // input
3060 q31_t *pdctCoefs_converted=NULL; // input
3061
3062 PyObject *pfilterCoefs=NULL; // input
3063 q31_t *pfilterCoefs_converted=NULL; // input
3064
3065 PyObject *pwindowCoefs=NULL; // input
3066 q31_t *pwindowCoefs_converted=NULL; // input
3067
3068 PyObject *pfilterPos=NULL; // input
3069 uint32_t *pfilterPos_converted=NULL; // input
3070
3071 PyObject *pfilterLengths=NULL; // input
3072 uint32_t *pfilterLengths_converted=NULL; // input
3073
3074 if (PyArg_ParseTuple(args,"OiiiOOOOO",&S,&fftLen,&nbMelFilters,&nbDctOutputs,
3075 &pdctCoefs,&pfilterPos,&pfilterLengths,&pfilterCoefs,&pwindowCoefs))
3076 {
3077
3078 dsp_arm_mfcc_instance_q31Object *selfS = (dsp_arm_mfcc_instance_q31Object *)S;
3079
3080 GETARGUMENT(pdctCoefs,NPY_INT32,int32_t,int32_t);
3081 GETARGUMENT(pfilterPos,NPY_UINT32,uint32_t,uint32_t);
3082 GETARGUMENT(pfilterLengths,NPY_UINT32,uint32_t,uint32_t);
3083 GETARGUMENT(pfilterCoefs,NPY_INT32,int32_t,int32_t);
3084 GETARGUMENT(pwindowCoefs,NPY_INT32,int32_t,int32_t);
3085
3086
3087 arm_status returnValue = arm_mfcc_init_q31(selfS->instance,
3088 fftLen,nbMelFilters,nbDctOutputs,
3089 pdctCoefs_converted,
3090 pfilterPos_converted,pfilterLengths_converted,pfilterCoefs_converted,
3091 pwindowCoefs_converted);
3092 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
3093
3094 PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
3095
3096 Py_DECREF(theReturnOBJ);
3097 return(pythonResult);
3098
3099 }
3100 return(NULL);
3101 }
3102
3103 static PyObject *
cmsis_arm_mfcc_q31(PyObject * obj,PyObject * args)3104 cmsis_arm_mfcc_q31(PyObject *obj, PyObject *args)
3105 {
3106
3107 PyObject *S=NULL; // input
3108 PyObject *p1=NULL; // input
3109 q31_t *p1_converted=NULL; // input
3110
3111 PyObject *tmp=NULL; // input
3112 q31_t *tmp_converted=NULL; // input
3113
3114 q31_t *pDst;
3115 if (PyArg_ParseTuple(args,"OOO",&S,&p1,&tmp))
3116 {
3117
3118 dsp_arm_mfcc_instance_q31Object *selfS = (dsp_arm_mfcc_instance_q31Object *)S;
3119 GETARGUMENT(p1,NPY_INT32,int32_t,int32_t);
3120 GETARGUMENT(tmp,NPY_INT32,int32_t,int32_t);
3121
3122 pDst=PyMem_Malloc(sizeof(q31_t)*selfS->instance->nbDctOutputs);
3123
3124 arm_status status = arm_mfcc_q31(selfS->instance,p1_converted,pDst,tmp_converted);
3125
3126 INT32ARRAY1(pDstOBJ,selfS->instance->nbDctOutputs,pDst);
3127
3128 PyObject* theReturnOBJ=Py_BuildValue("i",status);
3129 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
3130 Py_DECREF(pDstOBJ);
3131 Py_DECREF(theReturnOBJ);
3132
3133 FREEARGUMENT(p1_converted);
3134 FREEARGUMENT(tmp_converted);
3135
3136
3137
3138 return(pythonResult);
3139
3140 }
3141 return(NULL);
3142 }
3143
3144
3145 static PyMethodDef CMSISDSPMethods[] = {
3146
3147
3148
3149
3150 {"arm_cfft_radix2_init_q15", cmsis_arm_cfft_radix2_init_q15, METH_VARARGS,""},
3151 {"arm_cfft_radix2_q15", cmsis_arm_cfft_radix2_q15, METH_VARARGS,""},
3152 {"arm_cfft_radix4_init_q15", cmsis_arm_cfft_radix4_init_q15, METH_VARARGS,""},
3153 {"arm_cfft_radix4_q15", cmsis_arm_cfft_radix4_q15, METH_VARARGS,""},
3154 {"arm_cfft_radix2_init_q31", cmsis_arm_cfft_radix2_init_q31, METH_VARARGS,""},
3155 {"arm_cfft_radix2_q31", cmsis_arm_cfft_radix2_q31, METH_VARARGS,""},
3156 {"arm_cfft_radix4_q31", cmsis_arm_cfft_radix4_q31, METH_VARARGS,""},
3157 {"arm_cfft_radix4_init_q31", cmsis_arm_cfft_radix4_init_q31, METH_VARARGS,""},
3158 {"arm_cfft_radix2_init_f32", cmsis_arm_cfft_radix2_init_f32, METH_VARARGS,""},
3159 {"arm_cfft_radix2_f32", cmsis_arm_cfft_radix2_f32, METH_VARARGS,""},
3160 {"arm_cfft_radix4_init_f32", cmsis_arm_cfft_radix4_init_f32, METH_VARARGS,""},
3161 {"arm_cfft_radix4_f32", cmsis_arm_cfft_radix4_f32, METH_VARARGS,""},
3162 {"arm_cfft_q15", cmsis_arm_cfft_q15, METH_VARARGS,""},
3163 {"arm_cfft_q31", cmsis_arm_cfft_q31, METH_VARARGS,""},
3164 {"arm_cfft_f64", cmsis_arm_cfft_f64, METH_VARARGS,""},
3165 {"arm_cfft_f32", cmsis_arm_cfft_f32, METH_VARARGS,""},
3166 {"arm_rfft_init_q15", cmsis_arm_rfft_init_q15, METH_VARARGS,""},
3167 {"arm_rfft_q15", cmsis_arm_rfft_q15, METH_VARARGS,""},
3168 {"arm_rfft_init_q31", cmsis_arm_rfft_init_q31, METH_VARARGS,""},
3169 {"arm_rfft_q31", cmsis_arm_rfft_q31, METH_VARARGS,""},
3170 {"arm_rfft_fast_init_f64", cmsis_arm_rfft_fast_init_f64, METH_VARARGS,""},
3171 {"arm_rfft_fast_f64", cmsis_arm_rfft_fast_f64, METH_VARARGS,""},
3172 {"arm_rfft_fast_f32", cmsis_arm_rfft_fast_f32, METH_VARARGS,""},
3173 {"arm_rfft_fast_init_f32", cmsis_arm_rfft_fast_init_f32, METH_VARARGS,""},
3174 {"arm_rfft_fast_f32", cmsis_arm_rfft_fast_f32, METH_VARARGS,""},
3175 {"arm_dct4_init_f32", cmsis_arm_dct4_init_f32, METH_VARARGS,""},
3176 {"arm_dct4_f32", cmsis_arm_dct4_f32, METH_VARARGS,""},
3177 {"arm_dct4_init_q31", cmsis_arm_dct4_init_q31, METH_VARARGS,""},
3178 {"arm_dct4_q31", cmsis_arm_dct4_q31, METH_VARARGS,""},
3179 {"arm_dct4_init_q15", cmsis_arm_dct4_init_q15, METH_VARARGS,""},
3180 {"arm_dct4_q15", cmsis_arm_dct4_q15, METH_VARARGS,""},
3181
3182
3183 {"arm_cfft_init_f32", cmsis_arm_cfft_init_f32, METH_VARARGS,""},
3184 {"arm_cfft_init_f64", cmsis_arm_cfft_init_f64, METH_VARARGS,""},
3185 {"arm_cfft_init_q31", cmsis_arm_cfft_init_q31, METH_VARARGS,""},
3186 {"arm_cfft_init_q15", cmsis_arm_cfft_init_q15, METH_VARARGS,""},
3187
3188
3189 {"arm_mfcc_init_f32", cmsis_arm_mfcc_init_f32, METH_VARARGS,""},
3190 {"arm_mfcc_f32", cmsis_arm_mfcc_f32, METH_VARARGS,""},
3191 {"arm_mfcc_init_q15", cmsis_arm_mfcc_init_q15, METH_VARARGS,""},
3192 {"arm_mfcc_q15", cmsis_arm_mfcc_q15, METH_VARARGS,""},
3193 {"arm_mfcc_init_q31", cmsis_arm_mfcc_init_q31, METH_VARARGS,""},
3194 {"arm_mfcc_q31", cmsis_arm_mfcc_q31, METH_VARARGS,""},
3195
3196 {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
3197 {NULL, NULL, 0, NULL} /* Sentinel */
3198 };
3199
3200 #ifdef IS_PY3K
cmsisdsp_traverse(PyObject * m,visitproc visit,void * arg)3201 static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
3202 Py_VISIT(GETSTATE(m)->error);
3203 return 0;
3204 }
3205
cmsisdsp_clear(PyObject * m)3206 static int cmsisdsp_clear(PyObject *m) {
3207 Py_CLEAR(GETSTATE(m)->error);
3208 return 0;
3209 }
3210
3211
3212 static struct PyModuleDef moduledef = {
3213 PyModuleDef_HEAD_INIT,
3214 MODNAME,
3215 NULL,
3216 sizeof(struct module_state),
3217 CMSISDSPMethods,
3218 NULL,
3219 cmsisdsp_traverse,
3220 cmsisdsp_clear,
3221 NULL
3222 };
3223
3224 #define INITERROR return NULL
3225
3226 PyMODINIT_FUNC
CAT(PyInit_,MODINITNAME)3227 CAT(PyInit_,MODINITNAME)(void)
3228
3229
3230 #else
3231 #define INITERROR return
3232
3233 void CAT(init,MODINITNAME)(void)
3234 #endif
3235 {
3236 import_array();
3237
3238 #ifdef IS_PY3K
3239 PyObject *module = PyModule_Create(&moduledef);
3240 #else
3241 PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
3242 #endif
3243
3244 if (module == NULL)
3245 INITERROR;
3246 struct module_state *st = GETSTATE(module);
3247
3248 st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
3249 if (st->error == NULL) {
3250 Py_DECREF(module);
3251 INITERROR;
3252 }
3253
3254
3255 typeRegistration(module);
3256
3257 #ifdef IS_PY3K
3258 return module;
3259 #endif
3260 }
