← Back to branch summary

~ubuntu-branches/ubuntu/quantal/python-pyo/quantal

« back to all changes in this revision

Viewing changes to include/pyomodule.h

  • Committer: Package Import Robot
  • Author(s): Tiago Bortoletto Vaz
  • Date: 2012-07-03 23:45:41 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120703234541-jh5jg00lvljnwq8m
Tags: 0.6.2-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/pyomodule.h
21
21
#include "Python.h"
22
22
#include <math.h>
23
23
 
 
24
#define PYO_VERSION "0.6.2"
 
25
 
24
26
#ifndef __MYFLT_DEF
25
27
#define __MYFLT_DEF
26
28
 
256
258
extern PyTypeObject AllpassType;
257
259
extern PyTypeObject Allpass2Type;
258
260
extern PyTypeObject PhaserType;
 
261
extern PyTypeObject VocoderType;
259
262
extern PyTypeObject DenormType;
260
263
extern PyTypeObject DistoType;
261
264
extern PyTypeObject ClipType;
284
287
 
285
288
extern PyTypeObject MidictlType;
286
289
extern PyTypeObject CtlScanType;
 
290
extern PyTypeObject CtlScan2Type;
287
291
extern PyTypeObject MidiNoteType;
288
292
extern PyTypeObject NoteinType;
289
293
extern PyTypeObject BendinType;
326
330
extern PyTypeObject NewMatrixType;
327
331
extern PyTypeObject MatrixPointerType;
328
332
extern PyTypeObject MatrixRecType;
 
333
extern PyTypeObject MatrixRecLoopType;
329
334
extern PyTypeObject MatrixMorphType;
330
335
 
331
336
extern PyTypeObject OscSendType;
482
487
 
483
488
/* VISIT & CLEAR */
484
489
#define pyo_VISIT \
 
490
    if (PyServer_get_server() != NULL) \
 
491
        Py_VISIT(self->server); \
485
492
    Py_VISIT(self->stream); \
486
 
    Py_VISIT(self->server); \
487
493
    Py_VISIT(self->mul); \
488
494
    Py_VISIT(self->mul_stream); \
489
495
    Py_VISIT(self->add); \
490
496
    Py_VISIT(self->add_stream);    
491
497
 
 
498
#define pyo_table_VISIT \
 
499
    if (PyServer_get_server() != NULL) \
 
500
        Py_VISIT(self->server); \
 
501
    Py_VISIT(self->tablestream); \
 
502
 
 
503
#define pyo_matrix_VISIT \
 
504
    if (PyServer_get_server() != NULL) \
 
505
        Py_VISIT(self->server); \
 
506
    Py_VISIT(self->matrixstream); \
 
507
 
492
508
#define pyo_CLEAR \
 
509
    if (PyServer_get_server() != NULL) { \
 
510
        Py_INCREF(self->server); \
 
511
        Py_CLEAR(self->server); \
 
512
    } \
493
513
    Py_CLEAR(self->stream); \
494
 
    Py_CLEAR(self->server); \
495
514
    Py_CLEAR(self->mul); \
496
515
    Py_CLEAR(self->mul_stream); \
497
516
    Py_CLEAR(self->add); \
498
 
    Py_CLEAR(self->add_stream);    
499
 
 
500
 
#define DELETE_STREAM \
501
 
    Server_removeStream((Server *)self->server, Stream_getStreamId(self->stream)); \
502
 
    Py_INCREF(Py_None); \
503
 
    return Py_None;
 
517
    Py_CLEAR(self->add_stream); \
 
518
 
 
519
#define pyo_table_CLEAR \
 
520
    if (PyServer_get_server() != NULL) { \
 
521
        Py_INCREF(self->server); \
 
522
        Py_CLEAR(self->server); \
 
523
    } \
 
524
    Py_CLEAR(self->tablestream); \
 
525
 
 
526
#define pyo_matrix_CLEAR \
 
527
    if (PyServer_get_server() != NULL) { \
 
528
        Py_INCREF(self->server); \
 
529
        Py_CLEAR(self->server); \
 
530
    } \
 
531
    Py_CLEAR(self->matrixstream); \
 
532
 
 
533
#define pyo_DEALLOC \
 
534
    if (PyServer_get_server() != NULL) \
 
535
        Server_removeStream((Server *)self->server, Stream_getStreamId(self->stream)); \
 
536
    free(self->data); \
504
537
 
505
538
/* INIT INPUT STREAM */
506
539
#define INIT_INPUT_STREAM \
 
540
    if ( PyObject_HasAttrString((PyObject *)inputtmp, "server") == 0 ) { \
 
541
        PySys_WriteStderr("TypeError: \"input\" argument must be a PyoObject.\n"); \
 
542
        if (PyInt_AsLong(PyObject_CallMethod(self->server, "getIsBooted", NULL))) { \
 
543
            PyObject_CallMethod(self->server, "shutdown", NULL); \
 
544
        } \
 
545
        Py_Exit(1); \
 
546
    } \
 
547
    Py_INCREF(inputtmp); \
507
548
    Py_XDECREF(self->input); \
508
549
    self->input = inputtmp; \
509
550
    input_streamtmp = PyObject_CallMethod((PyObject *)self->input, "_getStream", NULL); \
512
553
    self->input_stream = (Stream *)input_streamtmp;
513
554
 
514
555
#define INIT_INPUT_TRIGGER_STREAM \
 
556
    Py_INCREF(inputtmp); \
515
557
    Py_XDECREF(self->input); \
516
558
    self->input = inputtmp; \
517
559
    input_streamtmp = PyObject_CallMethod((PyObject *)self->input, "_getTriggerStream", NULL); \
519
561
    Py_XDECREF(self->input_stream); \
520
562
    self->input_stream = (TriggerStream *)input_streamtmp;
521
563
 
 
564
/* Init Server & Stream */
 
565
#define INIT_OBJECT_COMMON \
 
566
    self->server = PyServer_get_server(); \
 
567
    self->mul = PyFloat_FromDouble(1); \
 
568
    self->add = PyFloat_FromDouble(0); \
 
569
    self->bufsize = PyInt_AsLong(PyObject_CallMethod(self->server, "getBufferSize", NULL)); \
 
570
    self->sr = PyFloat_AsDouble(PyObject_CallMethod(self->server, "getSamplingRate", NULL)); \
 
571
    self->nchnls = PyInt_AsLong(PyObject_CallMethod(self->server, "getNchnls", NULL)); \
 
572
    self->data = (MYFLT *)realloc(self->data, (self->bufsize) * sizeof(MYFLT)); \
 
573
    for (i=0; i<self->bufsize; i++) \
 
574
        self->data[i] = 0.0; \
 
575
    MAKE_NEW_STREAM(self->stream, &StreamType, NULL); \
 
576
    Stream_setStreamObject(self->stream, (PyObject *)self); \
 
577
    Stream_setStreamId(self->stream, Stream_getNewStreamId()); \
 
578
    Stream_setBufferSize(self->stream, self->bufsize); \
 
579
    Stream_setData(self->stream, self->data);
 
580
 
 
581
#define SET_INTERP_POINTER \
 
582
    if (self->interp == 0) \
 
583
        self->interp = 2; \
 
584
    if (self->interp == 1) \
 
585
        self->interp_func_ptr = nointerp; \
 
586
    else if (self->interp == 2) \
 
587
        self->interp_func_ptr = linear; \
 
588
    else if (self->interp == 3) \
 
589
        self->interp_func_ptr = cosine; \
 
590
    else if (self->interp == 4) \
 
591
        self->interp_func_ptr = cubic; \
 
592
 
522
593
/* Set data */
523
594
#define SET_TABLE_DATA \
524
595
    int i; \
835
906
 \
836
907
    return PyFloat_FromDouble(self->data[y][x]); \
837
908
 
838
 
 
839
 
/* Init Server & Stream */
840
 
#define INIT_OBJECT_COMMON \
841
 
    self->server = PyServer_get_server(); \
842
 
    self->mul = PyFloat_FromDouble(1); \
843
 
    self->add = PyFloat_FromDouble(0); \
844
 
    self->bufsize = PyInt_AsLong(PyObject_CallMethod(self->server, "getBufferSize", NULL)); \
845
 
    self->sr = PyFloat_AsDouble(PyObject_CallMethod(self->server, "getSamplingRate", NULL)); \
846
 
    self->nchnls = PyInt_AsLong(PyObject_CallMethod(self->server, "getNchnls", NULL)); \
847
 
    self->data = (MYFLT *)realloc(self->data, (self->bufsize) * sizeof(MYFLT)); \
848
 
    MAKE_NEW_STREAM(self->stream, &StreamType, NULL); \
849
 
    Stream_setStreamObject(self->stream, (PyObject *)self); \
850
 
    Stream_setStreamId(self->stream, Stream_getNewStreamId()); \
851
 
    Stream_setBufferSize(self->stream, self->bufsize); \
852
 
    for (i=0; i<self->bufsize; i++) \
853
 
        self->data[i] = 0.0; \
854
 
    Stream_setData(self->stream, self->data);
855
 
 
856
 
 
857
 
#define SET_INTERP_POINTER \
858
 
    if (self->interp == 0) \
859
 
        self->interp = 2; \
860
 
    if (self->interp == 1) \
861
 
        self->interp_func_ptr = nointerp; \
862
 
    else if (self->interp == 2) \
863
 
        self->interp_func_ptr = linear; \
864
 
    else if (self->interp == 3) \
865
 
        self->interp_func_ptr = cosine; \
866
 
    else if (self->interp == 4) \
867
 
        self->interp_func_ptr = cubic; \
868
 
 
869
909
/* GETS & SETS */
870
910
#define GET_SERVER \
871
911
    if (self->server == NULL) { \
1040
1080
    MAKE_NEW_DUMMY(dummy, &DummyType, NULL); \
1041
1081
    Dummy_initialize(dummy); \
1042
1082
    PyObject_CallMethod((PyObject *)dummy, "setMul", "O", arg); \
1043
 
    Py_INCREF(self); \
1044
1083
    PyObject_CallMethod((PyObject *)dummy, "setInput", "O", self); \
1045
 
    Py_INCREF(dummy); \
1046
1084
    return (PyObject *)dummy;
1047
1085
 
1048
1086
#define INPLACE_MULTIPLY \
1049
1087
    PyObject_CallMethod((PyObject *)self, "setMul", "O", arg); \
1050
 
    Py_INCREF(self); \
1051
1088
    return (PyObject *)self;
1052
1089
 
1053
1090
#define ADD \
1055
1092
    MAKE_NEW_DUMMY(dummy, &DummyType, NULL); \
1056
1093
    Dummy_initialize(dummy); \
1057
1094
    PyObject_CallMethod((PyObject *)dummy, "setAdd", "O", arg); \
1058
 
    Py_INCREF(self); \
1059
1095
    PyObject_CallMethod((PyObject *)dummy, "setInput", "O", self); \
1060
 
    Py_INCREF(dummy); \
1061
1096
    return (PyObject *)dummy;
1062
1097
 
1063
1098
#define INPLACE_ADD \
1064
1099
    PyObject_CallMethod((PyObject *)self, "setAdd", "O", arg); \
1065
 
    Py_INCREF(self); \
1066
1100
    return (PyObject *)self;
1067
1101
 
1068
1102
#define SUB \
1070
1104
    MAKE_NEW_DUMMY(dummy, &DummyType, NULL); \
1071
1105
    Dummy_initialize(dummy); \
1072
1106
    PyObject_CallMethod((PyObject *)dummy, "setSub", "O", arg); \
1073
 
    Py_INCREF(self); \
1074
1107
    PyObject_CallMethod((PyObject *)dummy, "setInput", "O", self); \
1075
 
    Py_INCREF(dummy); \
1076
1108
    return (PyObject *)dummy;
1077
1109
 
1078
1110
#define INPLACE_SUB \
1079
1111
    PyObject_CallMethod((PyObject *)self, "setSub", "O", arg); \
1080
 
    Py_INCREF(self); \
1081
1112
    return (PyObject *)self;
1082
1113
 
1083
1114
#define DIV \
1085
1116
    MAKE_NEW_DUMMY(dummy, &DummyType, NULL); \
1086
1117
    Dummy_initialize(dummy); \
1087
1118
    PyObject_CallMethod((PyObject *)dummy, "setDiv", "O", arg); \
1088
 
    Py_INCREF(self); \
1089
1119
    PyObject_CallMethod((PyObject *)dummy, "setInput", "O", self); \
1090
 
    Py_INCREF(dummy); \
1091
1120
    return (PyObject *)dummy;
1092
1121
 
1093
1122
#define INPLACE_DIV \
1094
1123
    PyObject_CallMethod((PyObject *)self, "setDiv", "O", arg); \
1095
 
    Py_INCREF(self); \
1096
1124
    return (PyObject *)self;
1097
1125
 
1098
1126
/* PLAY, OUT, STOP */