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_support"
30 #define MODINITNAME cmsisdsp_support
31
32 #include "cmsisdsp_module.h"
33
34 NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
35
36
37 typedef struct {
38 PyObject_HEAD
39 arm_sort_instance_f32 *instance;
40 } dsp_arm_sort_instance_f32Object;
41
42 static void
arm_sort_instance_f32_dealloc(dsp_arm_sort_instance_f32Object * self)43 arm_sort_instance_f32_dealloc(dsp_arm_sort_instance_f32Object* self)
44 {
45 //printf("Dealloc called\n");
46 if (self->instance)
47 {
48
49 PyMem_Free(self->instance);
50 }
51
52 Py_TYPE(self)->tp_free((PyObject*)self);
53 }
54
55 static PyObject *
arm_sort_instance_f32_new(PyTypeObject * type,PyObject * args,PyObject * kwds)56 arm_sort_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
57 {
58 dsp_arm_sort_instance_f32Object *self;
59 //printf("New called\n");
60
61 self = (dsp_arm_sort_instance_f32Object *)type->tp_alloc(type, 0);
62 //printf("alloc called\n");
63
64 if (self != NULL) {
65
66 self->instance = PyMem_Malloc(sizeof(arm_sort_instance_f32));
67
68 }
69
70
71 return (PyObject *)self;
72 }
73
74 static int
arm_sort_instance_f32_init(dsp_arm_sort_instance_f32Object * self,PyObject * args,PyObject * kwds)75 arm_sort_instance_f32_init(dsp_arm_sort_instance_f32Object *self, PyObject *args, PyObject *kwds)
76 {
77
78 PyObject *pState=NULL;
79 PyObject *pCoeffs=NULL;
80 char *kwlist[] = {
81 "arm_sort_alg","arm_sort_dir",NULL
82 };
83
84 uint16_t alg,dir;
85
86 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hh", kwlist,&alg,&dir
87 ))
88 {
89
90 self->instance->alg=alg;
91 self->instance->dir=dir;
92 }
93 return 0;
94 }
95
96 static PyObject *
Method_arm_sort_instance_f32_alg(dsp_arm_sort_instance_f32Object * self,PyObject * ignored)97 Method_arm_sort_instance_f32_alg(dsp_arm_sort_instance_f32Object *self, PyObject *ignored)
98 {
99 return(Py_BuildValue("i",(int)self->instance->alg));
100 }
101
102 static PyObject *
Method_arm_sort_instance_f32_dir(dsp_arm_sort_instance_f32Object * self,PyObject * ignored)103 Method_arm_sort_instance_f32_dir(dsp_arm_sort_instance_f32Object *self, PyObject *ignored)
104 {
105 return(Py_BuildValue("i",(int)self->instance->dir));
106 }
107
108 static PyMethodDef arm_sort_instance_f32_methods[] = {
109
110 {"alg", (PyCFunction) Method_arm_sort_instance_f32_alg,METH_NOARGS,"alg"},
111 {"dir", (PyCFunction) Method_arm_sort_instance_f32_dir,METH_NOARGS,"dir"},
112
113 {NULL} /* Sentinel */
114 };
115
116 DSPType(arm_sort_instance_f32,arm_sort_instance_f32_new,arm_sort_instance_f32_dealloc,arm_sort_instance_f32_init,arm_sort_instance_f32_methods);
117
typeRegistration(PyObject * module)118 void typeRegistration(PyObject *module) {
119
120 ADDTYPE(arm_sort_instance_f32);
121 }
122
123 static PyObject *
cmsis_arm_sort_init_f32(PyObject * obj,PyObject * args)124 cmsis_arm_sort_init_f32(PyObject *obj, PyObject *args)
125 {
126
127 PyObject *S=NULL; // input
128 uint16_t alg,dir; // input
129
130 if (PyArg_ParseTuple(args,"Ohh",&S,&alg,&dir))
131 {
132
133 dsp_arm_sort_instance_f32Object *selfS = (dsp_arm_sort_instance_f32Object *)S;
134
135 arm_sort_init_f32(selfS->instance,alg,dir);
136 Py_RETURN_NONE;
137
138 }
139 return(NULL);
140 }
141
142 static PyObject *
cmsis_arm_sort_f32(PyObject * obj,PyObject * args)143 cmsis_arm_sort_f32(PyObject *obj, PyObject *args)
144 {
145
146 PyObject *S=NULL; // input
147 PyObject *pSrc=NULL; // input
148 float32_t *pSrc_converted=NULL; // input
149 float32_t *pDst=NULL; // output
150 uint32_t blockSize; // input
151
152 if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
153 {
154
155 dsp_arm_sort_instance_f32Object *selfS = (dsp_arm_sort_instance_f32Object *)S;
156 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
157 blockSize = arraySizepSrc ;
158
159 pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
160
161
162 arm_sort_f32(selfS->instance,pSrc_converted,pDst,blockSize);
163 FLOATARRAY1(pDstOBJ,blockSize,pDst);
164
165 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
166
167 FREEARGUMENT(pSrc_converted);
168 Py_DECREF(pDstOBJ);
169 return(pythonResult);
170
171 }
172 return(NULL);
173 }
174
175
176 static PyObject *
cmsis_arm_fill_f32(PyObject * obj,PyObject * args)177 cmsis_arm_fill_f32(PyObject *obj, PyObject *args)
178 {
179
180 float32_t value; // input
181 float32_t *pDst=NULL; // output
182 uint32_t blockSize; // input
183
184 if (PyArg_ParseTuple(args,"fi",&value,&blockSize))
185 {
186
187 pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
188
189
190 arm_fill_f32(value,pDst,blockSize);
191 FLOATARRAY1(pDstOBJ,blockSize,pDst);
192
193 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
194
195 Py_DECREF(pDstOBJ);
196 return(pythonResult);
197
198 }
199 return(NULL);
200 }
201
202 static PyObject *
cmsis_arm_fill_f64(PyObject * obj,PyObject * args)203 cmsis_arm_fill_f64(PyObject *obj, PyObject *args)
204 {
205
206 float64_t value; // input
207 float64_t *pDst=NULL; // output
208 uint32_t blockSize; // input
209
210 if (PyArg_ParseTuple(args,"di",&value,&blockSize))
211 {
212
213 pDst=PyMem_Malloc(sizeof(float64_t)*blockSize);
214
215
216 arm_fill_f64(value,pDst,blockSize);
217 FLOAT64ARRAY1(pDstOBJ,blockSize,pDst);
218
219 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
220
221 Py_DECREF(pDstOBJ);
222 return(pythonResult);
223
224 }
225 return(NULL);
226 }
227
228 static PyObject *
cmsis_arm_fill_q31(PyObject * obj,PyObject * args)229 cmsis_arm_fill_q31(PyObject *obj, PyObject *args)
230 {
231
232 q31_t value; // input
233 q31_t *pDst=NULL; // output
234 uint32_t blockSize; // input
235
236 if (PyArg_ParseTuple(args,"ii",&value,&blockSize))
237 {
238
239 pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
240
241
242 arm_fill_q31(value,pDst,blockSize);
243 INT32ARRAY1(pDstOBJ,blockSize,pDst);
244
245 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
246
247 Py_DECREF(pDstOBJ);
248 return(pythonResult);
249
250 }
251 return(NULL);
252 }
253
254 static PyObject *
cmsis_arm_fill_q15(PyObject * obj,PyObject * args)255 cmsis_arm_fill_q15(PyObject *obj, PyObject *args)
256 {
257
258 q15_t value; // input
259 q15_t *pDst=NULL; // output
260 uint32_t blockSize; // input
261
262 if (PyArg_ParseTuple(args,"hi",&value,&blockSize))
263 {
264
265 pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
266
267
268 arm_fill_q15(value,pDst,blockSize);
269 INT16ARRAY1(pDstOBJ,blockSize,pDst);
270
271 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
272
273 Py_DECREF(pDstOBJ);
274 return(pythonResult);
275
276 }
277 return(NULL);
278 }
279
280 static PyObject *
cmsis_arm_fill_q7(PyObject * obj,PyObject * args)281 cmsis_arm_fill_q7(PyObject *obj, PyObject *args)
282 {
283
284 q31_t value; // input
285 q7_t *pDst=NULL; // output
286 uint32_t blockSize; // input
287
288 if (PyArg_ParseTuple(args,"ii",&value,&blockSize))
289 {
290
291 pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
292
293
294 arm_fill_q7((q7_t)value,pDst,blockSize);
295 INT8ARRAY1(pDstOBJ,blockSize,pDst);
296
297 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
298
299 Py_DECREF(pDstOBJ);
300 return(pythonResult);
301
302 }
303 return(NULL);
304 }
305
306
307
308 static PyObject *
cmsis_arm_copy_f32(PyObject * obj,PyObject * args)309 cmsis_arm_copy_f32(PyObject *obj, PyObject *args)
310 {
311
312 PyObject *pSrc=NULL; // input
313 float32_t *pSrc_converted=NULL; // input
314 float32_t *pDst=NULL; // output
315 uint32_t blockSize; // input
316
317 if (PyArg_ParseTuple(args,"O",&pSrc))
318 {
319
320 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
321 blockSize = arraySizepSrc ;
322
323 pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
324
325
326 arm_copy_f32(pSrc_converted,pDst,blockSize);
327 FLOATARRAY1(pDstOBJ,blockSize,pDst);
328
329 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
330
331 FREEARGUMENT(pSrc_converted);
332 Py_DECREF(pDstOBJ);
333 return(pythonResult);
334
335 }
336 return(NULL);
337 }
338
339 static PyObject *
cmsis_arm_copy_f64(PyObject * obj,PyObject * args)340 cmsis_arm_copy_f64(PyObject *obj, PyObject *args)
341 {
342
343 PyObject *pSrc=NULL; // input
344 float64_t *pSrc_converted=NULL; // input
345 float64_t *pDst=NULL; // output
346 uint32_t blockSize; // input
347
348 if (PyArg_ParseTuple(args,"O",&pSrc))
349 {
350
351 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
352 blockSize = arraySizepSrc ;
353
354 pDst=PyMem_Malloc(sizeof(float64_t)*blockSize);
355
356
357 arm_copy_f64(pSrc_converted,pDst,blockSize);
358 FLOAT64ARRAY1(pDstOBJ,blockSize,pDst);
359
360 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
361
362 FREEARGUMENT(pSrc_converted);
363 Py_DECREF(pDstOBJ);
364 return(pythonResult);
365
366 }
367 return(NULL);
368 }
369
370
371 static PyObject *
cmsis_arm_copy_q7(PyObject * obj,PyObject * args)372 cmsis_arm_copy_q7(PyObject *obj, PyObject *args)
373 {
374
375 PyObject *pSrc=NULL; // input
376 q7_t *pSrc_converted=NULL; // input
377 q7_t *pDst=NULL; // output
378 uint32_t blockSize; // input
379
380 if (PyArg_ParseTuple(args,"O",&pSrc))
381 {
382
383 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
384 blockSize = arraySizepSrc ;
385
386 pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
387
388
389 arm_copy_q7(pSrc_converted,pDst,blockSize);
390 INT8ARRAY1(pDstOBJ,blockSize,pDst);
391
392 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
393
394 FREEARGUMENT(pSrc_converted);
395 Py_DECREF(pDstOBJ);
396 return(pythonResult);
397
398 }
399 return(NULL);
400 }
401
402
403 static PyObject *
cmsis_arm_copy_q15(PyObject * obj,PyObject * args)404 cmsis_arm_copy_q15(PyObject *obj, PyObject *args)
405 {
406
407 PyObject *pSrc=NULL; // input
408 q15_t *pSrc_converted=NULL; // input
409 q15_t *pDst=NULL; // output
410 uint32_t blockSize; // input
411
412 if (PyArg_ParseTuple(args,"O",&pSrc))
413 {
414
415 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
416 blockSize = arraySizepSrc ;
417
418 pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
419
420
421 arm_copy_q15(pSrc_converted,pDst,blockSize);
422 INT16ARRAY1(pDstOBJ,blockSize,pDst);
423
424 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
425
426 FREEARGUMENT(pSrc_converted);
427 Py_DECREF(pDstOBJ);
428 return(pythonResult);
429
430 }
431 return(NULL);
432 }
433
434
435 static PyObject *
cmsis_arm_copy_q31(PyObject * obj,PyObject * args)436 cmsis_arm_copy_q31(PyObject *obj, PyObject *args)
437 {
438
439 PyObject *pSrc=NULL; // input
440 q31_t *pSrc_converted=NULL; // input
441 q31_t *pDst=NULL; // output
442 uint32_t blockSize; // input
443
444 if (PyArg_ParseTuple(args,"O",&pSrc))
445 {
446
447 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
448 blockSize = arraySizepSrc ;
449
450 pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
451
452
453 arm_copy_q31(pSrc_converted,pDst,blockSize);
454 INT32ARRAY1(pDstOBJ,blockSize,pDst);
455
456 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
457
458 FREEARGUMENT(pSrc_converted);
459 Py_DECREF(pDstOBJ);
460 return(pythonResult);
461
462 }
463 return(NULL);
464 }
465
466
467
468
469
470
471
472
473
474 static PyObject *
cmsis_arm_q7_to_q31(PyObject * obj,PyObject * args)475 cmsis_arm_q7_to_q31(PyObject *obj, PyObject *args)
476 {
477
478 PyObject *pSrc=NULL; // input
479 q7_t *pSrc_converted=NULL; // input
480 q31_t *pDst=NULL; // output
481 uint32_t blockSize; // input
482
483 if (PyArg_ParseTuple(args,"O",&pSrc))
484 {
485
486 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
487 blockSize = arraySizepSrc ;
488
489 pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
490
491
492 arm_q7_to_q31(pSrc_converted,pDst,blockSize);
493 INT32ARRAY1(pDstOBJ,blockSize,pDst);
494
495 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
496
497 FREEARGUMENT(pSrc_converted);
498 Py_DECREF(pDstOBJ);
499 return(pythonResult);
500
501 }
502 return(NULL);
503 }
504
505
506
507
508 static PyObject *
cmsis_arm_q7_to_q15(PyObject * obj,PyObject * args)509 cmsis_arm_q7_to_q15(PyObject *obj, PyObject *args)
510 {
511
512 PyObject *pSrc=NULL; // input
513 q7_t *pSrc_converted=NULL; // input
514 q15_t *pDst=NULL; // output
515 uint32_t blockSize; // input
516
517 if (PyArg_ParseTuple(args,"O",&pSrc))
518 {
519
520 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
521 blockSize = arraySizepSrc ;
522
523 pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
524
525
526 arm_q7_to_q15(pSrc_converted,pDst,blockSize);
527 INT16ARRAY1(pDstOBJ,blockSize,pDst);
528
529 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
530
531 FREEARGUMENT(pSrc_converted);
532 Py_DECREF(pDstOBJ);
533 return(pythonResult);
534
535 }
536 return(NULL);
537 }
538
539
540
541
542 static PyObject *
cmsis_arm_q7_to_float(PyObject * obj,PyObject * args)543 cmsis_arm_q7_to_float(PyObject *obj, PyObject *args)
544 {
545
546 PyObject *pSrc=NULL; // input
547 q7_t *pSrc_converted=NULL; // input
548 float32_t *pDst=NULL; // output
549 uint32_t blockSize; // input
550
551 if (PyArg_ParseTuple(args,"O",&pSrc))
552 {
553
554 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
555 blockSize = arraySizepSrc ;
556
557 pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
558
559
560 arm_q7_to_float(pSrc_converted,pDst,blockSize);
561 FLOATARRAY1(pDstOBJ,blockSize,pDst);
562
563 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
564
565 FREEARGUMENT(pSrc_converted);
566 Py_DECREF(pDstOBJ);
567 return(pythonResult);
568
569 }
570 return(NULL);
571 }
572
573
574
575
576
577
578 static PyObject *
cmsis_arm_q31_to_float(PyObject * obj,PyObject * args)579 cmsis_arm_q31_to_float(PyObject *obj, PyObject *args)
580 {
581
582 PyObject *pSrc=NULL; // input
583 q31_t *pSrc_converted=NULL; // input
584 float32_t *pDst=NULL; // output
585 uint32_t blockSize; // input
586
587 if (PyArg_ParseTuple(args,"O",&pSrc))
588 {
589
590 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
591 blockSize = arraySizepSrc ;
592
593 pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
594
595
596 arm_q31_to_float(pSrc_converted,pDst,blockSize);
597 FLOATARRAY1(pDstOBJ,blockSize,pDst);
598
599 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
600
601 FREEARGUMENT(pSrc_converted);
602 Py_DECREF(pDstOBJ);
603 return(pythonResult);
604
605 }
606 return(NULL);
607 }
608
609
610
611
612
613
614 static PyObject *
cmsis_arm_float_to_q31(PyObject * obj,PyObject * args)615 cmsis_arm_float_to_q31(PyObject *obj, PyObject *args)
616 {
617
618 PyObject *pSrc=NULL; // input
619 float32_t *pSrc_converted=NULL; // input
620 q31_t *pDst=NULL; // output
621 uint32_t blockSize; // input
622
623 if (PyArg_ParseTuple(args,"O",&pSrc))
624 {
625
626 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
627 blockSize = arraySizepSrc ;
628
629 pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
630
631
632 arm_float_to_q31(pSrc_converted,pDst,blockSize);
633 INT32ARRAY1(pDstOBJ,blockSize,pDst);
634
635 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
636
637 FREEARGUMENT(pSrc_converted);
638 Py_DECREF(pDstOBJ);
639 return(pythonResult);
640
641 }
642 return(NULL);
643 }
644
645
646 static PyObject *
cmsis_arm_float_to_q15(PyObject * obj,PyObject * args)647 cmsis_arm_float_to_q15(PyObject *obj, PyObject *args)
648 {
649
650 PyObject *pSrc=NULL; // input
651 float32_t *pSrc_converted=NULL; // input
652 q15_t *pDst=NULL; // output
653 uint32_t blockSize; // input
654
655 if (PyArg_ParseTuple(args,"O",&pSrc))
656 {
657
658 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
659 blockSize = arraySizepSrc ;
660
661 pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
662
663
664 arm_float_to_q15(pSrc_converted,pDst,blockSize);
665 INT16ARRAY1(pDstOBJ,blockSize,pDst);
666
667 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
668
669 FREEARGUMENT(pSrc_converted);
670 Py_DECREF(pDstOBJ);
671 return(pythonResult);
672
673 }
674 return(NULL);
675 }
676
677
678 static PyObject *
cmsis_arm_float_to_q7(PyObject * obj,PyObject * args)679 cmsis_arm_float_to_q7(PyObject *obj, PyObject *args)
680 {
681
682 PyObject *pSrc=NULL; // input
683 float32_t *pSrc_converted=NULL; // input
684 q7_t *pDst=NULL; // output
685 uint32_t blockSize; // input
686
687 if (PyArg_ParseTuple(args,"O",&pSrc))
688 {
689
690 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
691 blockSize = arraySizepSrc ;
692
693 pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
694
695
696 arm_float_to_q7(pSrc_converted,pDst,blockSize);
697 INT8ARRAY1(pDstOBJ,blockSize,pDst);
698
699 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
700
701 FREEARGUMENT(pSrc_converted);
702 Py_DECREF(pDstOBJ);
703 return(pythonResult);
704
705 }
706 return(NULL);
707 }
708
709
710 static PyObject *
cmsis_arm_q31_to_q15(PyObject * obj,PyObject * args)711 cmsis_arm_q31_to_q15(PyObject *obj, PyObject *args)
712 {
713
714 PyObject *pSrc=NULL; // input
715 q31_t *pSrc_converted=NULL; // input
716 q15_t *pDst=NULL; // output
717 uint32_t blockSize; // input
718
719 if (PyArg_ParseTuple(args,"O",&pSrc))
720 {
721
722 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
723 blockSize = arraySizepSrc ;
724
725 pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
726
727
728 arm_q31_to_q15(pSrc_converted,pDst,blockSize);
729 INT16ARRAY1(pDstOBJ,blockSize,pDst);
730
731 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
732
733 FREEARGUMENT(pSrc_converted);
734 Py_DECREF(pDstOBJ);
735 return(pythonResult);
736
737 }
738 return(NULL);
739 }
740
741
742 static PyObject *
cmsis_arm_q31_to_q7(PyObject * obj,PyObject * args)743 cmsis_arm_q31_to_q7(PyObject *obj, PyObject *args)
744 {
745
746 PyObject *pSrc=NULL; // input
747 q31_t *pSrc_converted=NULL; // input
748 q7_t *pDst=NULL; // output
749 uint32_t blockSize; // input
750
751 if (PyArg_ParseTuple(args,"O",&pSrc))
752 {
753
754 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
755 blockSize = arraySizepSrc ;
756
757 pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
758
759
760 arm_q31_to_q7(pSrc_converted,pDst,blockSize);
761 INT8ARRAY1(pDstOBJ,blockSize,pDst);
762
763 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
764
765 FREEARGUMENT(pSrc_converted);
766 Py_DECREF(pDstOBJ);
767 return(pythonResult);
768
769 }
770 return(NULL);
771 }
772
773
774 static PyObject *
cmsis_arm_q15_to_float(PyObject * obj,PyObject * args)775 cmsis_arm_q15_to_float(PyObject *obj, PyObject *args)
776 {
777
778 PyObject *pSrc=NULL; // input
779 q15_t *pSrc_converted=NULL; // input
780 float32_t *pDst=NULL; // output
781 uint32_t blockSize; // input
782
783 if (PyArg_ParseTuple(args,"O",&pSrc))
784 {
785
786 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
787 blockSize = arraySizepSrc ;
788
789 pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
790
791
792 arm_q15_to_float(pSrc_converted,pDst,blockSize);
793 FLOATARRAY1(pDstOBJ,blockSize,pDst);
794
795 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
796
797 FREEARGUMENT(pSrc_converted);
798 Py_DECREF(pDstOBJ);
799 return(pythonResult);
800
801 }
802 return(NULL);
803 }
804
805
806 static PyObject *
cmsis_arm_q15_to_q31(PyObject * obj,PyObject * args)807 cmsis_arm_q15_to_q31(PyObject *obj, PyObject *args)
808 {
809
810 PyObject *pSrc=NULL; // input
811 q15_t *pSrc_converted=NULL; // input
812 q31_t *pDst=NULL; // output
813 uint32_t blockSize; // input
814
815 if (PyArg_ParseTuple(args,"O",&pSrc))
816 {
817
818 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
819 blockSize = arraySizepSrc ;
820
821 pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
822
823
824 arm_q15_to_q31(pSrc_converted,pDst,blockSize);
825 INT32ARRAY1(pDstOBJ,blockSize,pDst);
826
827 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
828
829 FREEARGUMENT(pSrc_converted);
830 Py_DECREF(pDstOBJ);
831 return(pythonResult);
832
833 }
834 return(NULL);
835 }
836
837
838 static PyObject *
cmsis_arm_q15_to_q7(PyObject * obj,PyObject * args)839 cmsis_arm_q15_to_q7(PyObject *obj, PyObject *args)
840 {
841
842 PyObject *pSrc=NULL; // input
843 q15_t *pSrc_converted=NULL; // input
844 q7_t *pDst=NULL; // output
845 uint32_t blockSize; // input
846
847 if (PyArg_ParseTuple(args,"O",&pSrc))
848 {
849
850 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
851 blockSize = arraySizepSrc ;
852
853 pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
854
855
856 arm_q15_to_q7(pSrc_converted,pDst,blockSize);
857 INT8ARRAY1(pDstOBJ,blockSize,pDst);
858
859 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
860
861 FREEARGUMENT(pSrc_converted);
862 Py_DECREF(pDstOBJ);
863 return(pythonResult);
864
865 }
866 return(NULL);
867 }
868
869
870 static PyObject *
cmsis_arm_barycenter_f32(PyObject * obj,PyObject * args)871 cmsis_arm_barycenter_f32(PyObject *obj, PyObject *args)
872 {
873
874 PyObject *pSrcA=NULL; // input
875 float32_t *pSrcA_converted=NULL; // input
876 PyObject *pSrcB=NULL; // input
877 float32_t *pSrcB_converted=NULL; // input
878 float32_t *pDst=NULL; // output
879 uint32_t nbVectors,vecDim;
880
881 if (PyArg_ParseTuple(args,"OOII",&pSrcA,&pSrcB,&nbVectors,&vecDim))
882 {
883 GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
884 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
885
886 pDst=PyMem_Malloc(sizeof(float32_t)*vecDim);
887
888
889 arm_barycenter_f32(pSrcA_converted,pSrcB_converted,pDst,nbVectors,vecDim);
890 FLOATARRAY1(pDstOBJ,vecDim,pDst);
891
892 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
893
894 FREEARGUMENT(pSrcA_converted);
895 FREEARGUMENT(pSrcB_converted);
896 Py_DECREF(pDstOBJ);
897 return(pythonResult);
898
899 }
900 return(NULL);
901 }
902
903 static PyObject *
cmsis_arm_weighted_average_f32(PyObject * obj,PyObject * args)904 cmsis_arm_weighted_average_f32(PyObject *obj, PyObject *args)
905 {
906
907 PyObject *pSrcA=NULL; // input
908 float32_t *pSrcA_converted=NULL; // input
909 PyObject *pSrcB=NULL; // input
910 float32_t *pSrcB_converted=NULL; // input
911 float32_t dst; // output
912 uint32_t blockSize;
913
914 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
915 {
916
917 GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
918 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
919 blockSize = arraySizepSrcA ;
920
921
922 dst=arm_weighted_average_f32(pSrcA_converted,pSrcB_converted,blockSize);
923 PyObject* pDstOBJ=Py_BuildValue("f",dst);
924 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
925
926 FREEARGUMENT(pSrcA_converted);
927 FREEARGUMENT(pSrcB_converted);
928 Py_DECREF(pDstOBJ);
929 return(pythonResult);
930
931 }
932 return(NULL);
933 }
934
935 static PyObject *
cmsis_arm_div_int64_to_int32(PyObject * obj,PyObject * args)936 cmsis_arm_div_int64_to_int32(PyObject *obj, PyObject *args)
937 {
938
939 PyObject *pSrc=NULL; // input
940 q63_t num;
941 q31_t den;
942 q31_t result;
943
944 if (PyArg_ParseTuple(args,"Ll",&num,&den))
945 {
946
947
948 result=arm_div_int64_to_int32(num,den);
949
950 PyObject* resultOBJ=Py_BuildValue("l",result);
951
952 PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
953
954 Py_DECREF(resultOBJ);
955
956 return(pythonResult);
957
958 }
959 return(NULL);
960 }
961
962 static PyMethodDef CMSISDSPMethods[] = {
963
964 {"arm_div_int64_to_int32", cmsis_arm_div_int64_to_int32, METH_VARARGS,""},
965 {"arm_copy_f64", cmsis_arm_copy_f64, METH_VARARGS,""},
966 {"arm_copy_f32", cmsis_arm_copy_f32, METH_VARARGS,""},
967 {"arm_copy_q7", cmsis_arm_copy_q7, METH_VARARGS,""},
968 {"arm_copy_q15", cmsis_arm_copy_q15, METH_VARARGS,""},
969 {"arm_copy_q31", cmsis_arm_copy_q31, METH_VARARGS,""},
970
971
972 {"arm_q7_to_q31", cmsis_arm_q7_to_q31, METH_VARARGS,""},
973 {"arm_q7_to_q15", cmsis_arm_q7_to_q15, METH_VARARGS,""},
974 {"arm_q7_to_float", cmsis_arm_q7_to_float, METH_VARARGS,""},
975 {"arm_q31_to_float", cmsis_arm_q31_to_float, METH_VARARGS,""},
976
977
978
979 {"arm_float_to_q31", cmsis_arm_float_to_q31, METH_VARARGS,""},
980 {"arm_float_to_q15", cmsis_arm_float_to_q15, METH_VARARGS,""},
981 {"arm_float_to_q7", cmsis_arm_float_to_q7, METH_VARARGS,""},
982 {"arm_q31_to_q15", cmsis_arm_q31_to_q15, METH_VARARGS,""},
983 {"arm_q31_to_q7", cmsis_arm_q31_to_q7, METH_VARARGS,""},
984 {"arm_q15_to_float", cmsis_arm_q15_to_float, METH_VARARGS,""},
985 {"arm_q15_to_q31", cmsis_arm_q15_to_q31, METH_VARARGS,""},
986 {"arm_q15_to_q7", cmsis_arm_q15_to_q7, METH_VARARGS,""},
987
988 {"arm_fill_f64", cmsis_arm_fill_f64, METH_VARARGS,""},
989 {"arm_fill_f32", cmsis_arm_fill_f32, METH_VARARGS,""},
990 {"arm_fill_q31", cmsis_arm_fill_q31, METH_VARARGS,""},
991 {"arm_fill_q15", cmsis_arm_fill_q15, METH_VARARGS,""},
992 {"arm_fill_q7", cmsis_arm_fill_q7, METH_VARARGS,""},
993 {"arm_sort_f32", cmsis_arm_sort_f32, METH_VARARGS,""},
994 {"arm_sort_init_f32", cmsis_arm_sort_init_f32, METH_VARARGS,""},
995 {"arm_barycenter_f32", cmsis_arm_barycenter_f32, METH_VARARGS,""},
996 {"arm_weighted_average_f32", cmsis_arm_weighted_average_f32, METH_VARARGS,""},
997
998 {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
999 {NULL, NULL, 0, NULL} /* Sentinel */
1000 };
1001
1002 #ifdef IS_PY3K
cmsisdsp_traverse(PyObject * m,visitproc visit,void * arg)1003 static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
1004 Py_VISIT(GETSTATE(m)->error);
1005 return 0;
1006 }
1007
cmsisdsp_clear(PyObject * m)1008 static int cmsisdsp_clear(PyObject *m) {
1009 Py_CLEAR(GETSTATE(m)->error);
1010 return 0;
1011 }
1012
1013
1014 static struct PyModuleDef moduledef = {
1015 PyModuleDef_HEAD_INIT,
1016 MODNAME,
1017 NULL,
1018 sizeof(struct module_state),
1019 CMSISDSPMethods,
1020 NULL,
1021 cmsisdsp_traverse,
1022 cmsisdsp_clear,
1023 NULL
1024 };
1025
1026 #define INITERROR return NULL
1027
1028 PyMODINIT_FUNC
CAT(PyInit_,MODINITNAME)1029 CAT(PyInit_,MODINITNAME)(void)
1030
1031
1032 #else
1033 #define INITERROR return
1034
1035 void CAT(init,MODINITNAME)(void)
1036 #endif
1037 {
1038 import_array();
1039
1040 #ifdef IS_PY3K
1041 PyObject *module = PyModule_Create(&moduledef);
1042 #else
1043 PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
1044 #endif
1045
1046 if (module == NULL)
1047 INITERROR;
1048 struct module_state *st = GETSTATE(module);
1049
1050 st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
1051 if (st->error == NULL) {
1052 Py_DECREF(module);
1053 INITERROR;
1054 }
1055
1056
1057 typeRegistration(module);
1058
1059 #ifdef IS_PY3K
1060 return module;
1061 #endif
1062 }
