~ubuntu-branches/ubuntu/trusty/python-pyo/trusty

Keys of outer dictionaries are the device index as returned by Portaudio. Keys of inner dictionaries are: 'name', 'host api index', 'default sr' and 'latency'.\n\nExamples:\n\n \

200

>>> inputs, outputs = pa_get_devices_infos()\n \

201

>>> print '- Inputs:'\n \

202

>>> for index in sorted(inputs.keys()):\n \

203

... print ' Device index:', index\n \

204

... for key in ['name', 'host api index', 'default sr', 'latency']:\n \

205

... print ' %s:' % key, inputs[index][key]\n \

206

>>> print '- Outputs:'\n \

207

>>> for index in sorted(outputs.keys()):\n \

208

... print ' Device index:', index\n \

209

... for key in ['name', 'host api index', 'default sr', 'latency']:\n \

210

... print ' %s:' % key, outputs[index][key]\n\n"

211

212

static PyObject*

213

portaudio_get_devices_infos(){

214

PaError err;

215

PaDeviceIndex n, i;

216

PyObject *inDict, *outDict, *tmpDict;

217

inDict = PyDict_New();

218

outDict = PyDict_New();

219

220

err = Pa_Initialize();

221

if (err != paNoError) {

222

portaudio_assert(err, "Pa_Initialize");

223

Py_RETURN_NONE;

224

}

225

else {

226

n = Pa_GetDeviceCount();

227

if (n < 0){

228

portaudio_assert(n, "Pa_GetDeviceCount");

229

Py_RETURN_NONE;

230

}

231

else {

232

for (i=0; i < n; ++i){

233

const PaDeviceInfo *info = Pa_GetDeviceInfo(i);

234

assert(info);

235

tmpDict = PyDict_New();

236

if (info->maxInputChannels > 0) {

237

PyDict_SetItemString(tmpDict, "name", PyString_FromString(info->name));

238

PyDict_SetItemString(tmpDict, "host api index", PyInt_FromLong((int)info->hostApi));

239

PyDict_SetItemString(tmpDict, "default sr", PyInt_FromLong((int)info->defaultSampleRate));

240

PyDict_SetItemString(tmpDict, "latency", PyFloat_FromDouble((float)info->defaultLowInputLatency));

241

PyDict_SetItem(inDict, PyInt_FromLong(i), PyDict_Copy(tmpDict));

242

}

243

if (info->maxOutputChannels > 0) {

244

PyDict_SetItemString(tmpDict, "name", PyString_FromString(info->name));

245

PyDict_SetItemString(tmpDict, "host api index", PyInt_FromLong((int)info->hostApi));

246

PyDict_SetItemString(tmpDict, "default sr", PyInt_FromLong((int)info->defaultSampleRate));

247

PyDict_SetItemString(tmpDict, "latency", PyFloat_FromDouble((float)info->defaultLowOutputLatency));

248

PyDict_SetItem(outDict, PyInt_FromLong(i), PyDict_Copy(tmpDict));

249

}

250

}

251

return Py_BuildValue("(OO)", inDict, outDict);

252

}

253

}

254

}

255

196

256

#define portaudio_get_output_devices_info \

197

257

"\nReturns output devices (device names, device indexes) found by Portaudio.\n\npa_get_output_devices()\n\n`device names` is a list of strings and `device indexes` is a list of the actual\nPortaudio index of each device.\n\nExamples:\n\n \

198

258

>>> outs = pa_get_output_devices()\n \

233

293

}

234

294

}

235

295

296

#define portaudio_get_output_max_channels_info \

297

"\nRetrieve the maximum number of output channels for the specified device.\n\npa_get_output_max_channels(x)\n\nParameters:\n\n \

298

x: int\n Device index as listed by Portaudio (see pa_get_output_devices).\n\nExamples:\n\n \

299

>>> device = 'HDA Intel PCH: STAC92xx Analog (hw:0,0)'\n \

300

>>> dev_list, dev_index = pa_get_output_devices()\n \

301

>>> dev = dev_index[dev_list.index(device)]\n \

302

>>> print 'Device index:', dev\n \

303

>>> maxouts = pa_get_output_max_channels(dev)\n \

304

>>> maxins = pa_get_input_max_channels(dev)\n \

305

>>> print 'Max outputs:', maxouts\n \

306

>>> print 'Max inputs:', maxins\n \

307

>>> if maxouts >= 2 and maxins >= 2:\n \

308

... nchnls = 2\n \

309

>>> else:\n \

310

... nchnls = 1\n\n"

311

312

static PyObject*

313

portaudio_get_output_max_channels(PyObject *self, PyObject *arg){

314

PaError err;

315

PaDeviceIndex n, i = PyInt_AsLong(arg);

316

317

err = Pa_Initialize();

318

if (err != paNoError) {

319

portaudio_assert(err, "Pa_Initialize");

320

Py_RETURN_NONE;

321

}

322

else {

323

n = Pa_GetDeviceCount();

324

if (n < 0){

325

portaudio_assert(n, "Pa_GetDeviceCount");

326

Py_RETURN_NONE;

327

}

328

else {

329

const PaDeviceInfo *info=Pa_GetDeviceInfo(i);

330

assert(info);

331

return PyInt_FromLong(info->maxOutputChannels);

332

}

333

}

334

}

335

336

#define portaudio_get_input_max_channels_info \

337

"\nRetrieve the maximum number of input channels for the specified device.\n\npa_get_input_max_channels(x)\n\nParameters:\n\n \

338

x: int\n Device index as listed by Portaudio (see pa_get_input_devices).\n\nExamples:\n\n \

339

>>> device = 'HDA Intel PCH: STAC92xx Analog (hw:0,0)'\n \

340

>>> dev_list, dev_index = pa_get_output_devices()\n \

341

>>> dev = dev_index[dev_list.index(device)]\n \

342

>>> print 'Device index:', dev\n \

343

>>> maxouts = pa_get_output_max_channels(dev)\n \

344

>>> maxins = pa_get_input_max_channels(dev)\n \

345

>>> print 'Max outputs', maxouts\n \

346

>>> print 'Max inputs:', maxins\n \

347

>>> if maxouts >= 2 and maxins >= 2:\n \

348

... nchnls = 2\n \

349

>>> else:\n \

350

... nchnls = 1\n\n"

351

352

353

static PyObject*

354

portaudio_get_input_max_channels(PyObject *self, PyObject *arg){

355

PaError err;

356

PaDeviceIndex n, i = PyInt_AsLong(arg);

357

358

err = Pa_Initialize();

359

if (err != paNoError) {

360

portaudio_assert(err, "Pa_Initialize");

361

Py_RETURN_NONE;

362

}

363

else {

364

n = Pa_GetDeviceCount();

365

if (n < 0){

366

portaudio_assert(n, "Pa_GetDeviceCount");

367

Py_RETURN_NONE;

368

}

369

else {

370

const PaDeviceInfo *info=Pa_GetDeviceInfo(i);

371

assert(info);

372

return PyInt_FromLong(info->maxInputChannels);

373

}

374

}

375

}

376

236

377

#define portaudio_get_input_devices_info \

237

378

"\nReturns input devices (device names, device indexes) found by Portaudio.\n\npa_get_input_devices()\n\n`device names` is a list of strings and `device indexes` is a list of the actual\nPortaudio index of each device.\n\nExamples:\n\n \

238

379

>>> ins = pa_get_input_devices()\n \

932

1073

char *outpath;

933

1074

SNDFILE *sf;

934

1075

SF_INFO info;

935

unsigned int num, snd_size, snd_sr, snd_chnls, num_items;

1076

unsigned int snd_size, snd_sr, snd_chnls, num_items;

936

1077

MYFLT *sincfunc;

937

1078

MYFLT *tmp;

938

1079

MYFLT **samples;

957

1098

num_items = snd_size * snd_chnls;

958

1099

tmp = (MYFLT *)malloc(num_items * sizeof(MYFLT));

959

1100

sf_seek(sf, 0, SEEK_SET);

960

num = SF_READ(sf, tmp, num_items);

1101

SF_READ(sf, tmp, num_items);

961

1102

sf_close(sf);

962

1103

samples = (MYFLT **)malloc(snd_chnls * sizeof(MYFLT));

963

1104

for(i=0; i<snd_chnls; i++)

1035

1176

char *outpath;

1036

1177

SNDFILE *sf;

1037

1178

SF_INFO info;

1038

unsigned int num, snd_size, snd_sr, snd_chnls, num_items;

1179

unsigned int snd_size, snd_sr, snd_chnls, num_items;

1039

1180

MYFLT *sincfunc;

1040

1181

MYFLT *tmp;

1041

1182

MYFLT **samples;

1060

1201

num_items = snd_size * snd_chnls;

1061

1202

tmp = (MYFLT *)malloc(num_items * sizeof(MYFLT));

1062

1203

sf_seek(sf, 0, SEEK_SET);

1063

num = SF_READ(sf, tmp, num_items);

1204

SF_READ(sf, tmp, num_items);

1064

1205

sf_close(sf);

1065

1206

samples = (MYFLT **)malloc(snd_chnls * sizeof(MYFLT));

1066

1207

for(i=0; i<snd_chnls; i++)

1183

1324

MYFLT *pPointsX, *pPointsY;

1184

1325

int *pnUseFlag;

1185

1326

MYFLT dTolerance = .02;

1186

MYFLT xMax, yMin, yMax, yRange;;

1187

1188

static char *kwlist[] = {"pointlist", "tolerance", NULL};

1189

1190

if (! PyArg_ParseTupleAndKeywords(args, kwds, TYPE_O_F, kwlist, &pointlist, &dTolerance))

1191

return PyInt_FromLong(-1);

1192

1193

nPointsCount = PyList_Size(pointlist);

1194

1195

pPointsX = (MYFLT *)malloc(nPointsCount * sizeof(MYFLT));

1196

pPointsY = (MYFLT *)malloc(nPointsCount * sizeof(MYFLT));

1197

pnUseFlag = (int *)malloc(nPointsCount * sizeof(int));

1198

1199

tup = PyList_GET_ITEM(pointlist, 0);

1200

if (PyTuple_Check(tup) == 1) {

1201

for (i=0; i<nPointsCount; i++) {

1202

tup = PyList_GET_ITEM(pointlist, i);

1203

pPointsX[i] = PyFloat_AsDouble(PyNumber_Float(PyTuple_GET_ITEM(tup, 0)));

1204

pPointsY[i] = PyFloat_AsDouble(PyNumber_Float(PyTuple_GET_ITEM(tup, 1)));

1205

pnUseFlag[i] = 0;

1206

}

1207

}

1208

else {

1209

for (i=0; i<nPointsCount; i++) {

1210

tup = PyList_GET_ITEM(pointlist, i);

1211

pPointsX[i] = PyFloat_AsDouble(PyNumber_Float(PyList_GET_ITEM(tup, 0)));

1212

pPointsY[i] = PyFloat_AsDouble(PyNumber_Float(PyList_GET_ITEM(tup, 1)));

1213

pnUseFlag[i] = 0;

1214

}

1215

}

1327

MYFLT xMax, yMin, yMax;

1328

1329

static char *kwlist[] = {"pointlist", "tolerance", NULL};

1330

1331

if (! PyArg_ParseTupleAndKeywords(args, kwds, TYPE_O_F, kwlist, &pointlist, &dTolerance))

1332

return PyInt_FromLong(-1);

1333

1334

nPointsCount = PyList_Size(pointlist);

1335

1336

pPointsX = (MYFLT *)malloc(nPointsCount * sizeof(MYFLT));

1337

pPointsY = (MYFLT *)malloc(nPointsCount * sizeof(MYFLT));

1338

pnUseFlag = (int *)malloc(nPointsCount * sizeof(int));

1339

1340

tup = PyList_GET_ITEM(pointlist, 0);

1341

if (PyTuple_Check(tup) == 1) {

1342

for (i=0; i<nPointsCount; i++) {

1343

tup = PyList_GET_ITEM(pointlist, i);

1344

pPointsX[i] = PyFloat_AsDouble(PyNumber_Float(PyTuple_GET_ITEM(tup, 0)));

1345

pPointsY[i] = PyFloat_AsDouble(PyNumber_Float(PyTuple_GET_ITEM(tup, 1)));

1346

pnUseFlag[i] = 0;

1347

}

1348

}

1349

else {

1350

for (i=0; i<nPointsCount; i++) {

1351

tup = PyList_GET_ITEM(pointlist, i);

1352

pPointsX[i] = PyFloat_AsDouble(PyNumber_Float(PyList_GET_ITEM(tup, 0)));

1353

pPointsY[i] = PyFloat_AsDouble(PyNumber_Float(PyList_GET_ITEM(tup, 1)));

1354

pnUseFlag[i] = 0;

1355

}

1356

}

1216

1357

1217

// rescale points between 0. and 1.

1218

xMax = pPointsX[nPointsCount-1];

1219

yMin = 9999999999.9; yMax = -999999.9;

1220

for (i=0; i<nPointsCount; i++) {

1221

if (pPointsY[i] < yMin)

1222

yMin = pPointsY[i];

1223

else if (pPointsY[i] > yMax)

1224

yMax = pPointsY[i];

1225

}

1226

yRange = yMax - yMin;

1358

// rescale points between 0. and 1.

1359

xMax = pPointsX[nPointsCount-1];

1360

yMin = 9999999999.9; yMax = -999999.9;

1361

for (i=0; i<nPointsCount; i++) {

1362

if (pPointsY[i] < yMin)

1363

yMin = pPointsY[i];

1364

else if (pPointsY[i] > yMax)

1365

yMax = pPointsY[i];

1366

}

1227

1367

for (i=0; i<nPointsCount; i++) {

1228

1368

pPointsX[i] = pPointsX[i] / xMax;

1229

1369

pPointsY[i] = (pPointsY[i] - yMin) / yMax;

1872

2012

{"pa_count_devices", (PyCFunction)portaudio_count_devices, METH_NOARGS, portaudio_count_devices_info},

1873

2013

{"pa_count_host_apis", (PyCFunction)portaudio_count_host_apis, METH_NOARGS, portaudio_count_host_apis_info},

1874

2014

{"pa_list_devices", (PyCFunction)portaudio_list_devices, METH_NOARGS, portaudio_list_devices_info},

2015

{"pa_get_devices_infos", (PyCFunction)portaudio_get_devices_infos, METH_NOARGS, portaudio_get_devices_infos_info},

2016

{"pa_get_input_max_channels", (PyCFunction)portaudio_get_input_max_channels, METH_O, portaudio_get_input_max_channels_info},

2017

{"pa_get_output_max_channels", (PyCFunction)portaudio_get_output_max_channels, METH_O, portaudio_get_output_max_channels_info},

1875

2018

{"pa_get_output_devices", (PyCFunction)portaudio_get_output_devices, METH_NOARGS, portaudio_get_output_devices_info},

1876

2019

{"pa_get_input_devices", (PyCFunction)portaudio_get_input_devices, METH_NOARGS, portaudio_get_input_devices_info},

1877

2020

{"pa_list_host_apis", (PyCFunction)portaudio_list_host_apis, METH_NOARGS, portaudio_list_host_apis_info},

1902

2045

{NULL, NULL, 0, NULL},

1903

2046

};

1904

2047

2048

static PyObject *

2049

module_add_object(PyObject *module, const char *name, PyTypeObject *type) {

2050

if (PyType_Ready(type) < 0)

2051

Py_RETURN_NONE;

2052

Py_INCREF(type);

2053

PyModule_AddObject(module, name, (PyObject *)type);

2054

Py_RETURN_NONE;

2055

}

2056

1905

2057

PyMODINIT_FUNC

1906

2058

#ifndef USE_DOUBLE

1907

2059

init_pyo(void)

1921

2073

#endif

1922

2074

#endif

1923

2075

1924

if (PyType_Ready(&ServerType) < 0)

1925

return;

1926

Py_INCREF(&ServerType);

1927

PyModule_AddObject(m, "Server_base", (PyObject *)&ServerType);

1928

1929

if (PyType_Ready(&StreamType) < 0)

1930

return;

1931

Py_INCREF(&StreamType);

1932

PyModule_AddObject(m, "Stream", (PyObject *)&StreamType);

1933

1934

if (PyType_Ready(&TriggerStreamType) < 0)

1935

return;

1936

Py_INCREF(&TriggerStreamType);

1937

PyModule_AddObject(m, "TriggerStream", (PyObject *)&TriggerStreamType);

1938

1939

if (PyType_Ready(&DummyType) < 0)

1940

return;

1941

Py_INCREF(&DummyType);

1942

PyModule_AddObject(m, "Dummy_base", (PyObject *)&DummyType);

1943

1944

if (PyType_Ready(&TriggerDummyType) < 0)

1945

return;

1946

Py_INCREF(&TriggerDummyType);

1947

PyModule_AddObject(m, "TriggerDummy_base", (PyObject *)&TriggerDummyType);

1948

1949

if (PyType_Ready(&RecordType) < 0)

1950

return;

1951

Py_INCREF(&RecordType);

1952

PyModule_AddObject(m, "Record_base", (PyObject *)&RecordType);

1953

1954

if (PyType_Ready(&ControlRecType) < 0)

1955

return;

1956

Py_INCREF(&ControlRecType);

1957

PyModule_AddObject(m, "ControlRec_base", (PyObject *)&ControlRecType);

1958

1959

if (PyType_Ready(&ControlReadType) < 0)

1960

return;

1961

Py_INCREF(&ControlReadType);

1962

PyModule_AddObject(m, "ControlRead_base", (PyObject *)&ControlReadType);

1963

1964

if (PyType_Ready(&NoteinRecType) < 0)

1965

return;

1966

Py_INCREF(&NoteinRecType);

1967

PyModule_AddObject(m, "NoteinRec_base", (PyObject *)&NoteinRecType);

1968

1969

if (PyType_Ready(&NoteinReadType) < 0)

1970

return;

1971

Py_INCREF(&NoteinReadType);

1972

PyModule_AddObject(m, "NoteinRead_base", (PyObject *)&NoteinReadType);

1973

1974

if (PyType_Ready(&CompareType) < 0)

1975

return;

1976

Py_INCREF(&CompareType);

1977

PyModule_AddObject(m, "Compare_base", (PyObject *)&CompareType);

1978

1979

if (PyType_Ready(&MixType) < 0)

1980

return;

1981

Py_INCREF(&MixType);

1982

PyModule_AddObject(m, "Mix_base", (PyObject *)&MixType);

1983

1984

if (PyType_Ready(&SigType) < 0)

1985

return;

1986

Py_INCREF(&SigType);

1987

PyModule_AddObject(m, "Sig_base", (PyObject *)&SigType);

1988

1989

if (PyType_Ready(&SigToType) < 0)

1990

return;

1991

Py_INCREF(&SigToType);

1992

PyModule_AddObject(m, "SigTo_base", (PyObject *)&SigToType);

1993

1994

if (PyType_Ready(&VarPortType) < 0)

1995

return;

1996

Py_INCREF(&VarPortType);

1997

PyModule_AddObject(m, "VarPort_base", (PyObject *)&VarPortType);

1998

1999

if (PyType_Ready(&InputFaderType) < 0)

2000

return;

2001

Py_INCREF(&InputFaderType);

2002

PyModule_AddObject(m, "InputFader_base", (PyObject *)&InputFaderType);

2003

2004

if (PyType_Ready(&AdsrType) < 0)

2005

return;

2006

Py_INCREF(&AdsrType);

2007

PyModule_AddObject(m, "Adsr_base", (PyObject *)&AdsrType);

2008

2009

if (PyType_Ready(&LinsegType) < 0)

2010

return;

2011

Py_INCREF(&LinsegType);

2012

PyModule_AddObject(m, "Linseg_base", (PyObject *)&LinsegType);

2013

2014

if (PyType_Ready(&ExpsegType) < 0)

2015

return;

2016

Py_INCREF(&ExpsegType);

2017

PyModule_AddObject(m, "Expseg_base", (PyObject *)&ExpsegType);

2018

2019

if (PyType_Ready(&TableStreamType) < 0)

2020

return;

2021

Py_INCREF(&TableStreamType);

2022

PyModule_AddObject(m, "TableStream", (PyObject *)&TableStreamType);

2023

2024

if (PyType_Ready(&HarmTableType) < 0)

2025

return;

2026

Py_INCREF(&HarmTableType);

2027

PyModule_AddObject(m, "HarmTable_base", (PyObject *)&HarmTableType);

2028

2029

if (PyType_Ready(&ChebyTableType) < 0)

2030

return;

2031

Py_INCREF(&ChebyTableType);

2032

PyModule_AddObject(m, "ChebyTable_base", (PyObject *)&ChebyTableType);

2033

2034

if (PyType_Ready(&HannTableType) < 0)

2035

return;

2036

Py_INCREF(&HannTableType);

2037

PyModule_AddObject(m, "HannTable_base", (PyObject *)&HannTableType);

2038

2039

if (PyType_Ready(&SincTableType) < 0)

2040

return;

2041

Py_INCREF(&SincTableType);

2042

PyModule_AddObject(m, "SincTable_base", (PyObject *)&SincTableType);

2043

2044

if (PyType_Ready(&WinTableType) < 0)

2045

return;

2046

Py_INCREF(&WinTableType);

2047

PyModule_AddObject(m, "WinTable_base", (PyObject *)&WinTableType);

2048

2049

if (PyType_Ready(&ParaTableType) < 0)

2050

return;

2051

Py_INCREF(&ParaTableType);

2052

PyModule_AddObject(m, "ParaTable_base", (PyObject *)&ParaTableType);

2053

2054

if (PyType_Ready(&LinTableType) < 0)

2055

return;

2056

Py_INCREF(&LinTableType);

2057

PyModule_AddObject(m, "LinTable_base", (PyObject *)&LinTableType);

2058

2059

if (PyType_Ready(&CosTableType) < 0)

2060

return;

2061

Py_INCREF(&CosTableType);

2062

PyModule_AddObject(m, "CosTable_base", (PyObject *)&CosTableType);

2063

2064

if (PyType_Ready(&CurveTableType) < 0)

2065

return;

2066

Py_INCREF(&CurveTableType);

2067

PyModule_AddObject(m, "CurveTable_base", (PyObject *)&CurveTableType);

2068

2069

if (PyType_Ready(&ExpTableType) < 0)

2070

return;

2071

Py_INCREF(&ExpTableType);

2072

PyModule_AddObject(m, "ExpTable_base", (PyObject *)&ExpTableType);

2073

2074

if (PyType_Ready(&SndTableType) < 0)

2075

return;

2076

Py_INCREF(&SndTableType);

2077

PyModule_AddObject(m, "SndTable_base", (PyObject *)&SndTableType);

2078

2079

if (PyType_Ready(&DataTableType) < 0)

2080

return;

2081

Py_INCREF(&DataTableType);

2082

PyModule_AddObject(m, "DataTable_base", (PyObject *)&DataTableType);

2083

2084

if (PyType_Ready(&NewTableType) < 0)

2085

return;

2086

Py_INCREF(&NewTableType);

2087

PyModule_AddObject(m, "NewTable_base", (PyObject *)&NewTableType);

2088

2089

if (PyType_Ready(&TableRecType) < 0)

2090

return;

2091

Py_INCREF(&TableRecType);

2092

PyModule_AddObject(m, "TableRec_base", (PyObject *)&TableRecType);

2093

2094

if (PyType_Ready(&TableMorphType) < 0)

2095

return;

2096

Py_INCREF(&TableMorphType);

2097

PyModule_AddObject(m, "TableMorph_base", (PyObject *)&TableMorphType);

2098

2099

if (PyType_Ready(&TrigTableRecType) < 0)

2100

return;

2101

Py_INCREF(&TrigTableRecType);

2102

PyModule_AddObject(m, "TrigTableRec_base", (PyObject *)&TrigTableRecType);

2103

2104

/* Matrix objects */

2105

if (PyType_Ready(&MatrixStreamType) < 0)

2106

return;

2107

Py_INCREF(&MatrixStreamType);

2108

PyModule_AddObject(m, "MatrixStream", (PyObject *)&MatrixStreamType);

2109

2110

if (PyType_Ready(&NewMatrixType) < 0)

2111

return;

2112

Py_INCREF(&NewMatrixType);

2113

PyModule_AddObject(m, "NewMatrix_base", (PyObject *)&NewMatrixType);

2114

2115

if (PyType_Ready(&MatrixPointerType) < 0)

2116

return;

2117

Py_INCREF(&MatrixPointerType);

2118

PyModule_AddObject(m, "MatrixPointer_base", (PyObject *)&MatrixPointerType);

2119

2120

if (PyType_Ready(&MatrixRecType) < 0)

2121

return;

2122

Py_INCREF(&MatrixRecType);

2123

PyModule_AddObject(m, "MatrixRec_base", (PyObject *)&MatrixRecType);

2124

2125

if (PyType_Ready(&MatrixRecLoopType) < 0)

2126

return;

2127

Py_INCREF(&MatrixRecLoopType);

2128

PyModule_AddObject(m, "MatrixRecLoop_base", (PyObject *)&MatrixRecLoopType);

2129

2130

if (PyType_Ready(&MatrixMorphType) < 0)

2131

return;

2132

Py_INCREF(&MatrixMorphType);

2133

PyModule_AddObject(m, "MatrixMorph_base", (PyObject *)&MatrixMorphType);

2134

2135

if (PyType_Ready(&InputType) < 0)

2136

return;

2137

Py_INCREF(&InputType);

2138

PyModule_AddObject(m, "Input_base", (PyObject *)&InputType);

2139

2140

if (PyType_Ready(&TrigType) < 0)

2141

return;

2142

Py_INCREF(&TrigType);

2143

PyModule_AddObject(m, "Trig_base", (PyObject *)&TrigType);

2144

2145

if (PyType_Ready(&NextTrigType) < 0)

2146

return;

2147

Py_INCREF(&NextTrigType);

2148

PyModule_AddObject(m, "NextTrig_base", (PyObject *)&NextTrigType);

2149

2150

if (PyType_Ready(&MetroType) < 0)

2151

return;

2152

Py_INCREF(&MetroType);

2153

PyModule_AddObject(m, "Metro_base", (PyObject *)&MetroType);

2154

2155

if (PyType_Ready(&SeqerType) < 0)

2156

return;

2157

Py_INCREF(&SeqerType);

2158

PyModule_AddObject(m, "Seqer_base", (PyObject *)&SeqerType);

2159

2160

if (PyType_Ready(&SeqType) < 0)

2161

return;

2162

Py_INCREF(&SeqType);

2163

PyModule_AddObject(m, "Seq_base", (PyObject *)&SeqType);

2164

2165

if (PyType_Ready(&ClouderType) < 0)

2166

return;

2167

Py_INCREF(&ClouderType);

2168

PyModule_AddObject(m, "Clouder_base", (PyObject *)&ClouderType);

2169

2170

if (PyType_Ready(&CloudType) < 0)

2171

return;

2172

Py_INCREF(&CloudType);

2173

PyModule_AddObject(m, "Cloud_base", (PyObject *)&CloudType);

2174

2175

if (PyType_Ready(&BeaterType) < 0)

2176

return;

2177

Py_INCREF(&BeaterType);

2178

PyModule_AddObject(m, "Beater_base", (PyObject *)&BeaterType);

2179

2180

if (PyType_Ready(&BeatType) < 0)

2181

return;

2182

Py_INCREF(&BeatType);

2183

PyModule_AddObject(m, "Beat_base", (PyObject *)&BeatType);

2184

2185

if (PyType_Ready(&BeatTapStreamType) < 0)

2186

return;

2187

Py_INCREF(&BeatTapStreamType);

2188

PyModule_AddObject(m, "BeatTapStream_base", (PyObject *)&BeatTapStreamType);

2189

2190

if (PyType_Ready(&BeatAmpStreamType) < 0)

2191

return;

2192

Py_INCREF(&BeatAmpStreamType);

2193

PyModule_AddObject(m, "BeatAmpStream_base", (PyObject *)&BeatAmpStreamType);

2194

2195

if (PyType_Ready(&BeatDurStreamType) < 0)

2196

return;

2197

Py_INCREF(&BeatDurStreamType);

2198

PyModule_AddObject(m, "BeatDurStream_base", (PyObject *)&BeatDurStreamType);

2199

2200

if (PyType_Ready(&BeatEndStreamType) < 0)

2201

return;

2202

Py_INCREF(&BeatEndStreamType);

2203

PyModule_AddObject(m, "BeatEndStream_base", (PyObject *)&BeatEndStreamType);

2204

2205

if (PyType_Ready(&FaderType) < 0)

2206

return;

2207

Py_INCREF(&FaderType);

2208

PyModule_AddObject(m, "Fader_base", (PyObject *)&FaderType);

2209

2210

if (PyType_Ready(&RandiType) < 0)

2211

return;

2212

Py_INCREF(&RandiType);

2213

PyModule_AddObject(m, "Randi_base", (PyObject *)&RandiType);

2214

2215

if (PyType_Ready(&RandhType) < 0)

2216

return;

2217

Py_INCREF(&RandhType);

2218

PyModule_AddObject(m, "Randh_base", (PyObject *)&RandhType);

2219

2220

if (PyType_Ready(&ChoiceType) < 0)

2221

return;

2222

Py_INCREF(&ChoiceType);

2223

PyModule_AddObject(m, "Choice_base", (PyObject *)&ChoiceType);

2224

2225

if (PyType_Ready(&RandDurType) < 0)

2226

return;

2227

Py_INCREF(&RandDurType);

2228

PyModule_AddObject(m, "RandDur_base", (PyObject *)&RandDurType);

2229

2230

if (PyType_Ready(&XnoiseType) < 0)

2231

return;

2232

Py_INCREF(&XnoiseType);

2233

PyModule_AddObject(m, "Xnoise_base", (PyObject *)&XnoiseType);

2234

2235

if (PyType_Ready(&XnoiseMidiType) < 0)

2236

return;

2237

Py_INCREF(&XnoiseMidiType);

2238

PyModule_AddObject(m, "XnoiseMidi_base", (PyObject *)&XnoiseMidiType);

2239

2240

if (PyType_Ready(&XnoiseDurType) < 0)

2241

return;

2242

Py_INCREF(&XnoiseDurType);

2243

PyModule_AddObject(m, "XnoiseDur_base", (PyObject *)&XnoiseDurType);

2244

2245

if (PyType_Ready(&RandIntType) < 0)

2246

return;

2247

Py_INCREF(&RandIntType);

2248

PyModule_AddObject(m, "RandInt_base", (PyObject *)&RandIntType);

2249

2250

if (PyType_Ready(&UrnType) < 0)

2251

return;

2252

Py_INCREF(&UrnType);

2253

PyModule_AddObject(m, "Urn_base", (PyObject *)&UrnType);

2254

2255

if (PyType_Ready(&SfPlayerType) < 0)

2256

return;

2257

Py_INCREF(&SfPlayerType);

2258

PyModule_AddObject(m, "SfPlayer_base", (PyObject *)&SfPlayerType);

2259

2260

if (PyType_Ready(&SfPlayType) < 0)

2261

return;

2262

Py_INCREF(&SfPlayType);

2263

PyModule_AddObject(m, "SfPlay_base", (PyObject *)&SfPlayType);

2264

2265

if (PyType_Ready(&SfMarkerShufflerType) < 0)

2266

return;

2267

Py_INCREF(&SfMarkerShufflerType);

2268

PyModule_AddObject(m, "SfMarkerShuffler_base", (PyObject *)&SfMarkerShufflerType);

2269

2270

if (PyType_Ready(&SfMarkerShuffleType) < 0)

2271

return;

2272

Py_INCREF(&SfMarkerShuffleType);

2273

PyModule_AddObject(m, "SfMarkerShuffle_base", (PyObject *)&SfMarkerShuffleType);

2274

2275

if (PyType_Ready(&SfMarkerLooperType) < 0)

2276

return;

2277

Py_INCREF(&SfMarkerLooperType);

2278

PyModule_AddObject(m, "SfMarkerLooper_base", (PyObject *)&SfMarkerLooperType);

2279

2280

if (PyType_Ready(&SfMarkerLoopType) < 0)

2281

return;

2282

Py_INCREF(&SfMarkerLoopType);

2283

PyModule_AddObject(m, "SfMarkerLoop_base", (PyObject *)&SfMarkerLoopType);

2284

2285

if (PyType_Ready(&OscType) < 0)

2286

return;

2287

Py_INCREF(&OscType);

2288

PyModule_AddObject(m, "Osc_base", (PyObject *)&OscType);

2289

2290

if (PyType_Ready(&OscLoopType) < 0)

2291

return;

2292

Py_INCREF(&OscLoopType);

2293

PyModule_AddObject(m, "OscLoop_base", (PyObject *)&OscLoopType);

2294

2295

if (PyType_Ready(&OscBankType) < 0)

2296

return;

2297

Py_INCREF(&OscBankType);

2298

PyModule_AddObject(m, "OscBank_base", (PyObject *)&OscBankType);

2299

2300

if (PyType_Ready(&TableReadType) < 0)

2301

return;

2302

Py_INCREF(&TableReadType);

2303

PyModule_AddObject(m, "TableRead_base", (PyObject *)&TableReadType);

2304

2305

if (PyType_Ready(&PulsarType) < 0)

2306

return;

2307

Py_INCREF(&PulsarType);

2308

PyModule_AddObject(m, "Pulsar_base", (PyObject *)&PulsarType);

2309

2310

if (PyType_Ready(&SineType) < 0)

2311

return;

2312

Py_INCREF(&SineType);

2313

PyModule_AddObject(m, "Sine_base", (PyObject *)&SineType);

2314

2315

if (PyType_Ready(&SineLoopType) < 0)

2316

return;

2317

Py_INCREF(&SineLoopType);

2318

PyModule_AddObject(m, "SineLoop_base", (PyObject *)&SineLoopType);

2319

2320

if (PyType_Ready(&FmType) < 0)

2321

return;

2322

Py_INCREF(&FmType);

2323

PyModule_AddObject(m, "Fm_base", (PyObject *)&FmType);

2324

2325

if (PyType_Ready(&CrossFmType) < 0)

2326

return;

2327

Py_INCREF(&CrossFmType);

2328

PyModule_AddObject(m, "CrossFm_base", (PyObject *)&CrossFmType);

2329

2330

if (PyType_Ready(&LFOType) < 0)

2331

return;

2332

Py_INCREF(&LFOType);

2333

PyModule_AddObject(m, "LFO_base", (PyObject *)&LFOType);

2334

2335

if (PyType_Ready(&BlitType) < 0)

2336

return;

2337

Py_INCREF(&BlitType);

2338

PyModule_AddObject(m, "Blit_base", (PyObject *)&BlitType);

2339

2340

if (PyType_Ready(&RosslerType) < 0)

2341

return;

2342

Py_INCREF(&RosslerType);

2343

PyModule_AddObject(m, "Rossler_base", (PyObject *)&RosslerType);

2344

2345

if (PyType_Ready(&RosslerAltType) < 0)

2346

return;

2347

Py_INCREF(&RosslerAltType);

2348

PyModule_AddObject(m, "RosslerAlt_base", (PyObject *)&RosslerAltType);

2349

2350

if (PyType_Ready(&LorenzType) < 0)

2351

return;

2352

Py_INCREF(&LorenzType);

2353

PyModule_AddObject(m, "Lorenz_base", (PyObject *)&LorenzType);

2354

2355

if (PyType_Ready(&LorenzAltType) < 0)

2356

return;

2357

Py_INCREF(&LorenzAltType);

2358

PyModule_AddObject(m, "LorenzAlt_base", (PyObject *)&LorenzAltType);

2359

2360

if (PyType_Ready(&PhasorType) < 0)

2361

return;

2362

Py_INCREF(&PhasorType);

2363

PyModule_AddObject(m, "Phasor_base", (PyObject *)&PhasorType);

2364

2365

if (PyType_Ready(&PointerType) < 0)

2366

return;

2367

Py_INCREF(&PointerType);

2368

PyModule_AddObject(m, "Pointer_base", (PyObject *)&PointerType);

2369

2370

if (PyType_Ready(&TableIndexType) < 0)

2371

return;

2372

Py_INCREF(&TableIndexType);

2373

PyModule_AddObject(m, "TableIndex_base", (PyObject *)&TableIndexType);

2374

2375

if (PyType_Ready(&LookupType) < 0)

2376

return;

2377

Py_INCREF(&LookupType);

2378

PyModule_AddObject(m, "Lookup_base", (PyObject *)&LookupType);

2379

2380

if (PyType_Ready(&NoiseType) < 0)

2381

return;

2382

Py_INCREF(&NoiseType);

2383

PyModule_AddObject(m, "Noise_base", (PyObject *)&NoiseType);

2384

2385

if (PyType_Ready(&PinkNoiseType) < 0)

2386

return;

2387

Py_INCREF(&PinkNoiseType);

2388

PyModule_AddObject(m, "PinkNoise_base", (PyObject *)&PinkNoiseType);

2389

2390

if (PyType_Ready(&BrownNoiseType) < 0)

2391

return;

2392

Py_INCREF(&BrownNoiseType);

2393

PyModule_AddObject(m, "BrownNoise_base", (PyObject *)&BrownNoiseType);

2394

2395

if (PyType_Ready(&BiquadType) < 0)

2396

return;

2397

Py_INCREF(&BiquadType);

2398

PyModule_AddObject(m, "Biquad_base", (PyObject *)&BiquadType);

2399

2400

if (PyType_Ready(&BiquadxType) < 0)

2401

return;

2402

Py_INCREF(&BiquadxType);

2403

PyModule_AddObject(m, "Biquadx_base", (PyObject *)&BiquadxType);

2404

2405

if (PyType_Ready(&BiquadaType) < 0)

2406

return;

2407

Py_INCREF(&BiquadaType);

2408

PyModule_AddObject(m, "Biquada_base", (PyObject *)&BiquadaType);

2409

2410

if (PyType_Ready(&EQType) < 0)

2411

return;

2412

Py_INCREF(&EQType);

2413

PyModule_AddObject(m, "EQ_base", (PyObject *)&EQType);

2414

2415

if (PyType_Ready(&ToneType) < 0)

2416

return;

2417

Py_INCREF(&ToneType);

2418

PyModule_AddObject(m, "Tone_base", (PyObject *)&ToneType);

2419

2420

if (PyType_Ready(&DCBlockType) < 0)

2421

return;

2422

Py_INCREF(&DCBlockType);

2423

PyModule_AddObject(m, "DCBlock_base", (PyObject *)&DCBlockType);

2424

2425

if (PyType_Ready(&AllpassType) < 0)

2426

return;

2427

Py_INCREF(&AllpassType);

2428

PyModule_AddObject(m, "Allpass_base", (PyObject *)&AllpassType);

2429

2430

if (PyType_Ready(&Allpass2Type) < 0)

2431

return;

2432

Py_INCREF(&Allpass2Type);

2433

PyModule_AddObject(m, "Allpass2_base", (PyObject *)&Allpass2Type);

2434

2435

if (PyType_Ready(&PhaserType) < 0)

2436

return;

2437

Py_INCREF(&PhaserType);

2438

PyModule_AddObject(m, "Phaser_base", (PyObject *)&PhaserType);

2439

2440

if (PyType_Ready(&VocoderType) < 0)

2441

return;

2442

Py_INCREF(&VocoderType);

2443

PyModule_AddObject(m, "Vocoder_base", (PyObject *)&VocoderType);

2444

2445

if (PyType_Ready(&PortType) < 0)

2446

return;

2447

Py_INCREF(&PortType);

2448

PyModule_AddObject(m, "Port_base", (PyObject *)&PortType);

2449

2450

if (PyType_Ready(&DenormType) < 0)

2451

return;

2452

Py_INCREF(&DenormType);

2453

PyModule_AddObject(m, "Denorm_base", (PyObject *)&DenormType);

2454

2455

if (PyType_Ready(&DistoType) < 0)

2456

return;

2457

Py_INCREF(&DistoType);

2458

PyModule_AddObject(m, "Disto_base", (PyObject *)&DistoType);

2459

2460

if (PyType_Ready(&ClipType) < 0)

2461

return;

2462

Py_INCREF(&ClipType);

2463

PyModule_AddObject(m, "Clip_base", (PyObject *)&ClipType);

2464

2465

if (PyType_Ready(&MirrorType) < 0)

2466

return;

2467

Py_INCREF(&MirrorType);

2468

PyModule_AddObject(m, "Mirror_base", (PyObject *)&MirrorType);

2469

2470

if (PyType_Ready(&WrapType) < 0)

2471

return;

2472

Py_INCREF(&WrapType);

2473

PyModule_AddObject(m, "Wrap_base", (PyObject *)&WrapType);

2474

2475

if (PyType_Ready(&BetweenType) < 0)

2476

return;

2477

Py_INCREF(&BetweenType);

2478

PyModule_AddObject(m, "Between_base", (PyObject *)&BetweenType);

2479

2480

if (PyType_Ready(&DegradeType) < 0)

2481

return;

2482

Py_INCREF(&DegradeType);

2483

PyModule_AddObject(m, "Degrade_base", (PyObject *)&DegradeType);

2484

2485

if (PyType_Ready(&CompressType) < 0)

2486

return;

2487

Py_INCREF(&CompressType);

2488

PyModule_AddObject(m, "Compress_base", (PyObject *)&CompressType);

2489

2490

if (PyType_Ready(&GateType) < 0)

2491

return;

2492

Py_INCREF(&GateType);

2493

PyModule_AddObject(m, "Gate_base", (PyObject *)&GateType);

2494

2495

if (PyType_Ready(&DelayType) < 0)

2496

return;

2497

Py_INCREF(&DelayType);

2498

PyModule_AddObject(m, "Delay_base", (PyObject *)&DelayType);

2499

2500

if (PyType_Ready(&SDelayType) < 0)

2501

return;

2502

Py_INCREF(&SDelayType);

2503

PyModule_AddObject(m, "SDelay_base", (PyObject *)&SDelayType);

2504

2505

if (PyType_Ready(&WaveguideType) < 0)

2506

return;

2507

Py_INCREF(&WaveguideType);

2508

PyModule_AddObject(m, "Waveguide_base", (PyObject *)&WaveguideType);

2509

2510

if (PyType_Ready(&AllpassWGType) < 0)

2511

return;

2512

Py_INCREF(&AllpassWGType);

2513

PyModule_AddObject(m, "AllpassWG_base", (PyObject *)&AllpassWGType);

2514

2515

if (PyType_Ready(&MidictlType) < 0)

2516

return;

2517

Py_INCREF(&MidictlType);

2518

PyModule_AddObject(m, "Midictl_base", (PyObject *)&MidictlType);

2519

2520

if (PyType_Ready(&CtlScanType) < 0)

2521

return;

2522

Py_INCREF(&CtlScanType);

2523

PyModule_AddObject(m, "CtlScan_base", (PyObject *)&CtlScanType);

2524

2525

if (PyType_Ready(&CtlScan2Type) < 0)

2526

return;

2527

Py_INCREF(&CtlScan2Type);

2528

PyModule_AddObject(m, "CtlScan2_base", (PyObject *)&CtlScan2Type);

2529

2530

if (PyType_Ready(&MidiNoteType) < 0)

2531

return;

2532

Py_INCREF(&MidiNoteType);

2533

PyModule_AddObject(m, "MidiNote_base", (PyObject *)&MidiNoteType);

2534

2535

if (PyType_Ready(&NoteinType) < 0)

2536

return;

2537

Py_INCREF(&NoteinType);

2538

PyModule_AddObject(m, "Notein_base", (PyObject *)&NoteinType);

2539

2540

if (PyType_Ready(&BendinType) < 0)

2541

return;

2542

Py_INCREF(&BendinType);

2543

PyModule_AddObject(m, "Bendin_base", (PyObject *)&BendinType);

2544

2545

if (PyType_Ready(&TouchinType) < 0)

2546

return;

2547

Py_INCREF(&TouchinType);

2548

PyModule_AddObject(m, "Touchin_base", (PyObject *)&TouchinType);

2549

2550

if (PyType_Ready(&PrograminType) < 0)

2551

return;

2552

Py_INCREF(&PrograminType);

2553

PyModule_AddObject(m, "Programin_base", (PyObject *)&PrograminType);

2554

2555

if (PyType_Ready(&MidiAdsrType) < 0)

2556

return;

2557

Py_INCREF(&MidiAdsrType);

2558

PyModule_AddObject(m, "MidiAdsr_base", (PyObject *)&MidiAdsrType);

2559

2560

if (PyType_Ready(&MidiDelAdsrType) < 0)

2561

return;

2562

Py_INCREF(&MidiDelAdsrType);

2563

PyModule_AddObject(m, "MidiDelAdsr_base", (PyObject *)&MidiDelAdsrType);

2564

2565

if (PyType_Ready(&OscSendType) < 0)

2566

return;

2567

Py_INCREF(&OscSendType);

2568

PyModule_AddObject(m, "OscSend_base", (PyObject *)&OscSendType);

2569

2570

if (PyType_Ready(&OscDataSendType) < 0)

2571

return;

2572

Py_INCREF(&OscDataSendType);

2573

PyModule_AddObject(m, "OscDataSend_base", (PyObject *)&OscDataSendType);

2574

2575

if (PyType_Ready(&OscReceiveType) < 0)

2576

return;

2577

Py_INCREF(&OscReceiveType);

2578

PyModule_AddObject(m, "OscReceive_base", (PyObject *)&OscReceiveType);

2579

2580

if (PyType_Ready(&OscReceiverType) < 0)

2581

return;

2582

Py_INCREF(&OscReceiverType);

2583

PyModule_AddObject(m, "OscReceiver_base", (PyObject *)&OscReceiverType);

2584

2585

if (PyType_Ready(&OscListReceiveType) < 0)

2586

return;

2587

Py_INCREF(&OscListReceiveType);

2588

PyModule_AddObject(m, "OscListReceive_base", (PyObject *)&OscListReceiveType);

2589

2590

if (PyType_Ready(&OscListReceiverType) < 0)

2591

return;

2592

Py_INCREF(&OscListReceiverType);

2593

PyModule_AddObject(m, "OscListReceiver_base", (PyObject *)&OscListReceiverType);

2594

2595

if (PyType_Ready(&OscDataReceiveType) < 0)

2596

return;

2597

Py_INCREF(&OscDataReceiveType);

2598

PyModule_AddObject(m, "OscDataReceive_base", (PyObject *)&OscDataReceiveType);

2599

2600

if (PyType_Ready(&TrigRandType) < 0)

2601

return;

2602

Py_INCREF(&TrigRandType);

2603

PyModule_AddObject(m, "TrigRand_base", (PyObject *)&TrigRandType);

2604

2605

if (PyType_Ready(&TrigRandIntType) < 0)

2606

return;

2607

Py_INCREF(&TrigRandIntType);

2608

PyModule_AddObject(m, "TrigRandInt_base", (PyObject *)&TrigRandIntType);

2609

2610

if (PyType_Ready(&TrigChoiceType) < 0)

2611

return;

2612

Py_INCREF(&TrigChoiceType);

2613

PyModule_AddObject(m, "TrigChoice_base", (PyObject *)&TrigChoiceType);

2614

2615

if (PyType_Ready(&IterType) < 0)

2616

return;

2617

Py_INCREF(&IterType);

2618

PyModule_AddObject(m, "Iter_base", (PyObject *)&IterType);

2619

2620

if (PyType_Ready(&TrigEnvType) < 0)

2621

return;

2622

Py_INCREF(&TrigEnvType);

2623

PyModule_AddObject(m, "TrigEnv_base", (PyObject *)&TrigEnvType);

2624

2625

if (PyType_Ready(&TrigLinsegType) < 0)

2626

return;

2627

Py_INCREF(&TrigLinsegType);

2628

PyModule_AddObject(m, "TrigLinseg_base", (PyObject *)&TrigLinsegType);

2629

2630

if (PyType_Ready(&TrigExpsegType) < 0)

2631

return;

2632

Py_INCREF(&TrigExpsegType);

2633

PyModule_AddObject(m, "TrigExpseg_base", (PyObject *)&TrigExpsegType);

2634

2635

if (PyType_Ready(&TrigFuncType) < 0)

2636

return;

2637

Py_INCREF(&TrigFuncType);

2638

PyModule_AddObject(m, "TrigFunc_base", (PyObject *)&TrigFuncType);

2639

2640

if (PyType_Ready(&TrigXnoiseType) < 0)

2641

return;

2642

Py_INCREF(&TrigXnoiseType);

2643

PyModule_AddObject(m, "TrigXnoise_base", (PyObject *)&TrigXnoiseType);

2644

2645

if (PyType_Ready(&TrigXnoiseMidiType) < 0)

2646

return;

2647

Py_INCREF(&TrigXnoiseMidiType);

2648

PyModule_AddObject(m, "TrigXnoiseMidi_base", (PyObject *)&TrigXnoiseMidiType);

2649

2650

if (PyType_Ready(&PatternType) < 0)

2651

return;

2652

Py_INCREF(&PatternType);

2653

PyModule_AddObject(m, "Pattern_base", (PyObject *)&PatternType);

2654

2655

if (PyType_Ready(&CallAfterType) < 0)

2656

return;

2657

Py_INCREF(&CallAfterType);

2658

PyModule_AddObject(m, "CallAfter_base", (PyObject *)&CallAfterType);

2659

2660

if (PyType_Ready(&BandSplitterType) < 0)

2661

return;

2662

Py_INCREF(&BandSplitterType);

2663

PyModule_AddObject(m, "BandSplitter_base", (PyObject *)&BandSplitterType);

2664

2665

if (PyType_Ready(&BandSplitType) < 0)

2666

return;

2667

Py_INCREF(&BandSplitType);

2668

PyModule_AddObject(m, "BandSplit_base", (PyObject *)&BandSplitType);

2669

2670

if (PyType_Ready(&FourBandMainType) < 0)

2671

return;

2672

Py_INCREF(&FourBandMainType);

2673

PyModule_AddObject(m, "FourBandMain_base", (PyObject *)&FourBandMainType);

2674

2675

if (PyType_Ready(&FourBandType) < 0)

2676

return;

2677

Py_INCREF(&FourBandType);

2678

PyModule_AddObject(m, "FourBand_base", (PyObject *)&FourBandType);

2679

2680

if (PyType_Ready(&HilbertMainType) < 0)

2681

return;

2682

Py_INCREF(&HilbertMainType);

2683

PyModule_AddObject(m, "HilbertMain_base", (PyObject *)&HilbertMainType);

2684

2685

if (PyType_Ready(&HilbertType) < 0)

2686

return;

2687

Py_INCREF(&HilbertType);

2688

PyModule_AddObject(m, "Hilbert_base", (PyObject *)&HilbertType);

2689

2690

if (PyType_Ready(&FollowerType) < 0)

2691

return;

2692

Py_INCREF(&FollowerType);

2693

PyModule_AddObject(m, "Follower_base", (PyObject *)&FollowerType);

2694

2695

if (PyType_Ready(&Follower2Type) < 0)

2696

return;

2697

Py_INCREF(&Follower2Type);

2698

PyModule_AddObject(m, "Follower2_base", (PyObject *)&Follower2Type);

2699

2700

if (PyType_Ready(&ZCrossType) < 0)

2701

return;

2702

Py_INCREF(&ZCrossType);

2703

PyModule_AddObject(m, "ZCross_base", (PyObject *)&ZCrossType);

2704

2705

if (PyType_Ready(&SPannerType) < 0)

2706

return;

2707

Py_INCREF(&SPannerType);

2708

PyModule_AddObject(m, "SPanner_base", (PyObject *)&SPannerType);

2709

2710

if (PyType_Ready(&PannerType) < 0)

2711

return;

2712

Py_INCREF(&PannerType);

2713

PyModule_AddObject(m, "Panner_base", (PyObject *)&PannerType);

2714

2715

if (PyType_Ready(&PanType) < 0)

2716

return;

2717

Py_INCREF(&PanType);

2718

PyModule_AddObject(m, "Pan_base", (PyObject *)&PanType);

2719

2720

if (PyType_Ready(&SPanType) < 0)

2721

return;

2722

Py_INCREF(&SPanType);

2723

PyModule_AddObject(m, "SPan_base", (PyObject *)&SPanType);

2724

2725

if (PyType_Ready(&SwitcherType) < 0)

2726

return;

2727

Py_INCREF(&SwitcherType);

2728

PyModule_AddObject(m, "Switcher_base", (PyObject *)&SwitcherType);

2729

2730

if (PyType_Ready(&SwitchType) < 0)

2731

return;

2732

Py_INCREF(&SwitchType);

2733

PyModule_AddObject(m, "Switch_base", (PyObject *)&SwitchType);

2734

2735

if (PyType_Ready(&SelectorType) < 0)

2736

return;

2737

Py_INCREF(&SelectorType);

2738

PyModule_AddObject(m, "Selector_base", (PyObject *)&SelectorType);

2739

2740

if (PyType_Ready(&VoiceManagerType) < 0)

2741

return;

2742

Py_INCREF(&VoiceManagerType);

2743

PyModule_AddObject(m, "VoiceManager_base", (PyObject *)&VoiceManagerType);

2744

2745

if (PyType_Ready(&MixerType) < 0)

2746

return;

2747

Py_INCREF(&MixerType);

2748

PyModule_AddObject(m, "Mixer_base", (PyObject *)&MixerType);

2749

2750

if (PyType_Ready(&MixerVoiceType) < 0)

2751

return;

2752

Py_INCREF(&MixerVoiceType);

2753

PyModule_AddObject(m, "MixerVoice_base", (PyObject *)&MixerVoiceType);

2754

2755

if (PyType_Ready(&CounterType) < 0)

2756

return;

2757

Py_INCREF(&CounterType);

2758

PyModule_AddObject(m, "Counter_base", (PyObject *)&CounterType);

2759

2760

if (PyType_Ready(&CountType) < 0)

2761

return;

2762

Py_INCREF(&CountType);

2763

PyModule_AddObject(m, "Count_base", (PyObject *)&CountType);

2764

2765

if (PyType_Ready(&ThreshType) < 0)

2766

return;

2767

Py_INCREF(&ThreshType);

2768

PyModule_AddObject(m, "Thresh_base", (PyObject *)&ThreshType);

2769

2770

if (PyType_Ready(&PercentType) < 0)

2771

return;

2772

Py_INCREF(&PercentType);

2773

PyModule_AddObject(m, "Percent_base", (PyObject *)&PercentType);

2774

2775

if (PyType_Ready(&TimerType) < 0)

2776

return;

2777

Py_INCREF(&TimerType);

2778

PyModule_AddObject(m, "Timer_base", (PyObject *)&TimerType);

2779

2780

if (PyType_Ready(&SelectType) < 0)

2781

return;

2782

Py_INCREF(&SelectType);

2783

PyModule_AddObject(m, "Select_base", (PyObject *)&SelectType);

2784

2785

if (PyType_Ready(&ChangeType) < 0)

2786

return;

2787

Py_INCREF(&ChangeType);

2788

PyModule_AddObject(m, "Change_base", (PyObject *)&ChangeType);

2789

2790

if (PyType_Ready(&ScoreType) < 0)

2791

return;

2792

Py_INCREF(&ScoreType);

2793

PyModule_AddObject(m, "Score_base", (PyObject *)&ScoreType);

2794

2795

if (PyType_Ready(&FreeverbType) < 0)

2796

return;

2797

Py_INCREF(&FreeverbType);

2798

PyModule_AddObject(m, "Freeverb_base", (PyObject *)&FreeverbType);

2799

2800

if (PyType_Ready(&WGVerbType) < 0)

2801

return;

2802

Py_INCREF(&WGVerbType);

2803

PyModule_AddObject(m, "WGVerb_base", (PyObject *)&WGVerbType);

2804

2805

if (PyType_Ready(&ChorusType) < 0)

2806

return;

2807

Py_INCREF(&ChorusType);

2808

PyModule_AddObject(m, "Chorus_base", (PyObject *)&ChorusType);

2809

2810

if (PyType_Ready(&ConvolveType) < 0)

2811

return;

2812

Py_INCREF(&ConvolveType);

2813

PyModule_AddObject(m, "Convolve_base", (PyObject *)&ConvolveType);

2814

2815

if (PyType_Ready(&IRWinSincType) < 0)

2816

return;

2817

Py_INCREF(&IRWinSincType);

2818

PyModule_AddObject(m, "IRWinSinc_base", (PyObject *)&IRWinSincType);

2819

2820

if (PyType_Ready(&IRPulseType) < 0)

2821

return;

2822

Py_INCREF(&IRPulseType);

2823

PyModule_AddObject(m, "IRPulse_base", (PyObject *)&IRPulseType);

2824

2825

if (PyType_Ready(&IRAverageType) < 0)

2826

return;

2827

Py_INCREF(&IRAverageType);

2828

PyModule_AddObject(m, "IRAverage_base", (PyObject *)&IRAverageType);

2829

2830

if (PyType_Ready(&IRFMType) < 0)

2831

return;

2832

Py_INCREF(&IRFMType);

2833

PyModule_AddObject(m, "IRFM_base", (PyObject *)&IRFMType);

2834

2835

if (PyType_Ready(&GranulatorType) < 0)

2836

return;

2837

Py_INCREF(&GranulatorType);

2838

PyModule_AddObject(m, "Granulator_base", (PyObject *)&GranulatorType);

2839

2840

if (PyType_Ready(&LooperType) < 0)

2841

return;

2842

Py_INCREF(&LooperType);

2843

PyModule_AddObject(m, "Looper_base", (PyObject *)&LooperType);

2844

2845

if (PyType_Ready(&HarmonizerType) < 0)

2846

return;

2847

Py_INCREF(&HarmonizerType);

2848

PyModule_AddObject(m, "Harmonizer_base", (PyObject *)&HarmonizerType);

2849

2850

if (PyType_Ready(&PrintType) < 0)

2851

return;

2852

Py_INCREF(&PrintType);

2853

PyModule_AddObject(m, "Print_base", (PyObject *)&PrintType);

2854

2855

if (PyType_Ready(&M_SinType) < 0)

2856

return;

2857

Py_INCREF(&M_SinType);

2858

PyModule_AddObject(m, "M_Sin_base", (PyObject *)&M_SinType);

2859

2860

if (PyType_Ready(&M_CosType) < 0)

2861

return;

2862

Py_INCREF(&M_CosType);

2863

PyModule_AddObject(m, "M_Cos_base", (PyObject *)&M_CosType);

2864

2865

if (PyType_Ready(&M_TanType) < 0)

2866

return;

2867

Py_INCREF(&M_TanType);

2868

PyModule_AddObject(m, "M_Tan_base", (PyObject *)&M_TanType);

2869

2870

if (PyType_Ready(&M_AbsType) < 0)

2871

return;

2872

Py_INCREF(&M_AbsType);

2873

PyModule_AddObject(m, "M_Abs_base", (PyObject *)&M_AbsType);

2874

2875

if (PyType_Ready(&M_SqrtType) < 0)

2876

return;

2877

Py_INCREF(&M_SqrtType);

2878

PyModule_AddObject(m, "M_Sqrt_base", (PyObject *)&M_SqrtType);

2879

2880

if (PyType_Ready(&M_LogType) < 0)

2881

return;

2882

Py_INCREF(&M_LogType);

2883

PyModule_AddObject(m, "M_Log_base", (PyObject *)&M_LogType);

2884

2885

if (PyType_Ready(&M_Log2Type) < 0)

2886

return;

2887

Py_INCREF(&M_Log2Type);

2888

PyModule_AddObject(m, "M_Log2_base", (PyObject *)&M_Log2Type);

2889

2890

if (PyType_Ready(&M_Log10Type) < 0)

2891

return;

2892

Py_INCREF(&M_Log10Type);

2893

PyModule_AddObject(m, "M_Log10_base", (PyObject *)&M_Log10Type);

2894

2895

if (PyType_Ready(&M_PowType) < 0)

2896

return;

2897

Py_INCREF(&M_PowType);

2898

PyModule_AddObject(m, "M_Pow_base", (PyObject *)&M_PowType);

2899

2900

if (PyType_Ready(&M_Atan2Type) < 0)

2901

return;

2902

Py_INCREF(&M_Atan2Type);

2903

PyModule_AddObject(m, "M_Atan2_base", (PyObject *)&M_Atan2Type);

2904

2905

if (PyType_Ready(&M_FloorType) < 0)

2906

return;

2907

Py_INCREF(&M_FloorType);

2908

PyModule_AddObject(m, "M_Floor_base", (PyObject *)&M_FloorType);

2909

2910

if (PyType_Ready(&M_CeilType) < 0)

2911

return;

2912

Py_INCREF(&M_CeilType);

2913

PyModule_AddObject(m, "M_Ceil_base", (PyObject *)&M_CeilType);

2914

2915

if (PyType_Ready(&M_RoundType) < 0)

2916

return;

2917

Py_INCREF(&M_RoundType);

2918

PyModule_AddObject(m, "M_Round_base", (PyObject *)&M_RoundType);

2919

2920

if (PyType_Ready(&SnapType) < 0)

2921

return;

2922

Py_INCREF(&SnapType);

2923

PyModule_AddObject(m, "Snap_base", (PyObject *)&SnapType);

2924

2925

if (PyType_Ready(&InterpType) < 0)

2926

return;

2927

Py_INCREF(&InterpType);

2928

PyModule_AddObject(m, "Interp_base", (PyObject *)&InterpType);

2929

2930

if (PyType_Ready(&SampHoldType) < 0)

2931

return;

2932

Py_INCREF(&SampHoldType);

2933

PyModule_AddObject(m, "SampHold_base", (PyObject *)&SampHoldType);

2934

2935

if (PyType_Ready(&DBToAType) < 0)

2936

return;

2937

Py_INCREF(&DBToAType);

2938

PyModule_AddObject(m, "DBToA_base", (PyObject *)&DBToAType);

2939

2940

if (PyType_Ready(&AToDBType) < 0)

2941

return;

2942

Py_INCREF(&AToDBType);

2943

PyModule_AddObject(m, "AToDB_base", (PyObject *)&AToDBType);

2944

2945

if (PyType_Ready(&ScaleType) < 0)

2946

return;

2947

Py_INCREF(&ScaleType);

2948

PyModule_AddObject(m, "Scale_base", (PyObject *)&ScaleType);

2949

2950

if (PyType_Ready(&CentsToTranspoType) < 0)

2951

return;

2952

Py_INCREF(&CentsToTranspoType);

2953

PyModule_AddObject(m, "CentsToTranspo_base", (PyObject *)&CentsToTranspoType);

2954

2955

if (PyType_Ready(&TranspoToCentsType) < 0)

2956

return;

2957

Py_INCREF(&TranspoToCentsType);

2958

PyModule_AddObject(m, "TranspoToCents_base", (PyObject *)&TranspoToCentsType);

2959

2960

if (PyType_Ready(&MToFType) < 0)

2961

return;

2962

Py_INCREF(&MToFType);

2963

PyModule_AddObject(m, "MToF_base", (PyObject *)&MToFType);

2964

2965

if (PyType_Ready(&MToTType) < 0)

2966

return;

2967

Py_INCREF(&MToTType);

2968

PyModule_AddObject(m, "MToT_base", (PyObject *)&MToTType);

2969

2970

if (PyType_Ready(&FFTMainType) < 0)

2971

return;

2972

Py_INCREF(&FFTMainType);

2973

PyModule_AddObject(m, "FFTMain_base", (PyObject *)&FFTMainType);

2974

2975

if (PyType_Ready(&FFTType) < 0)

2976

return;

2977

Py_INCREF(&FFTType);

2978

PyModule_AddObject(m, "FFT_base", (PyObject *)&FFTType);

2979

2980

if (PyType_Ready(&IFFTType) < 0)

2981

return;

2982

Py_INCREF(&IFFTType);

2983

PyModule_AddObject(m, "IFFT_base", (PyObject *)&IFFTType);

2984

2985

if (PyType_Ready(&CarToPolType) < 0)

2986

return;

2987

Py_INCREF(&CarToPolType);

2988

PyModule_AddObject(m, "CarToPol_base", (PyObject *)&CarToPolType);

2989

2990

if (PyType_Ready(&PolToCarType) < 0)

2991

return;

2992

Py_INCREF(&PolToCarType);

2993

PyModule_AddObject(m, "PolToCar_base", (PyObject *)&PolToCarType);

2994

2995

if (PyType_Ready(&FrameDeltaMainType) < 0)

2996

return;

2997

Py_INCREF(&FrameDeltaMainType);

2998

PyModule_AddObject(m, "FrameDeltaMain_base", (PyObject *)&FrameDeltaMainType);

2999

3000

if (PyType_Ready(&FrameDeltaType) < 0)

3001

return;

3002

Py_INCREF(&FrameDeltaType);

3003

PyModule_AddObject(m, "FrameDelta_base", (PyObject *)&FrameDeltaType);

3004

3005

if (PyType_Ready(&FrameAccumType) < 0)

3006

return;

3007

Py_INCREF(&FrameAccumType);

3008

PyModule_AddObject(m, "FrameAccum_base", (PyObject *)&FrameAccumType);

3009

3010

if (PyType_Ready(&FrameAccumMainType) < 0)

3011

return;

3012

Py_INCREF(&FrameAccumMainType);

3013

PyModule_AddObject(m, "FrameAccumMain_base", (PyObject *)&FrameAccumMainType);

3014

3015

if (PyType_Ready(&VectralMainType) < 0)

3016

return;

3017

Py_INCREF(&VectralMainType);

3018

PyModule_AddObject(m, "VectralMain_base", (PyObject *)&VectralMainType);

3019

3020

if (PyType_Ready(&VectralType) < 0)

3021

return;

3022

Py_INCREF(&VectralType);

3023

PyModule_AddObject(m, "Vectral_base", (PyObject *)&VectralType);

3024

2076

module_add_object(m, "Server_base", &ServerType);

2077

module_add_object(m, "Stream", &StreamType);

2078

module_add_object(m, "TriggerStream", &TriggerStreamType);

2079

module_add_object(m, "Dummy_base", &DummyType);

2080

module_add_object(m, "TriggerDummy_base", &TriggerDummyType);

2081

module_add_object(m, "TableStream", &TableStreamType);

2082

module_add_object(m, "MatrixStream", &MatrixStreamType);

2083

module_add_object(m, "Record_base", &RecordType);

2084

module_add_object(m, "ControlRec_base", &ControlRecType);

2085

module_add_object(m, "ControlRead_base", &ControlReadType);

2086

module_add_object(m, "NoteinRec_base", &NoteinRecType);

2087

module_add_object(m, "NoteinRead_base", &NoteinReadType);

2088

module_add_object(m, "Compare_base", &CompareType);

2089

module_add_object(m, "Mix_base", &MixType);

2090

module_add_object(m, "Sig_base", &SigType);

2091

module_add_object(m, "SigTo_base", &SigToType);

2092

module_add_object(m, "VarPort_base", &VarPortType);

2093

module_add_object(m, "InputFader_base", &InputFaderType);

2094

module_add_object(m, "Adsr_base", &AdsrType);

2095

module_add_object(m, "Linseg_base", &LinsegType);

2096

module_add_object(m, "Expseg_base", &ExpsegType);

2097

module_add_object(m, "HarmTable_base", &HarmTableType);

2098

module_add_object(m, "ChebyTable_base", &ChebyTableType);

2099

module_add_object(m, "HannTable_base", &HannTableType);

2100

module_add_object(m, "SincTable_base", &SincTableType);

2101

module_add_object(m, "WinTable_base", &WinTableType);

2102

module_add_object(m, "ParaTable_base", &ParaTableType);

2103

module_add_object(m, "LinTable_base", &LinTableType);

2104

module_add_object(m, "LogTable_base", &LogTableType);

2105

module_add_object(m, "CosLogTable_base", &CosLogTableType);

2106

module_add_object(m, "CosTable_base", &CosTableType);

2107

module_add_object(m, "CurveTable_base", &CurveTableType);

2108

module_add_object(m, "ExpTable_base", &ExpTableType);

2109

module_add_object(m, "SndTable_base", &SndTableType);

2110

module_add_object(m, "DataTable_base", &DataTableType);

2111

module_add_object(m, "NewTable_base", &NewTableType);

2112

module_add_object(m, "TableRec_base", &TableRecType);

2113

module_add_object(m, "TableRecTimeStream_base", &TableRecTimeStreamType);

2114

module_add_object(m, "TableMorph_base", &TableMorphType);

2115

module_add_object(m, "TrigTableRec_base", &TrigTableRecType);

2116

module_add_object(m, "TrigTableRecTimeStream_base", &TrigTableRecTimeStreamType);

2117

module_add_object(m, "TablePut_base", &TablePutType);

2118

module_add_object(m, "NewMatrix_base", &NewMatrixType);

2119

module_add_object(m, "MatrixPointer_base", &MatrixPointerType);

2120

module_add_object(m, "MatrixRec_base", &MatrixRecType);

2121

module_add_object(m, "MatrixRecLoop_base", &MatrixRecLoopType);

2122

module_add_object(m, "MatrixMorph_base", &MatrixMorphType);

2123

module_add_object(m, "Input_base", &InputType);

2124

module_add_object(m, "Trig_base", &TrigType);

2125

module_add_object(m, "NextTrig_base", &NextTrigType);

2126

module_add_object(m, "Metro_base", &MetroType);

2127

module_add_object(m, "Seqer_base", &SeqerType);

2128

module_add_object(m, "Seq_base", &SeqType);

2129

module_add_object(m, "Clouder_base", &ClouderType);

2130

module_add_object(m, "Cloud_base", &CloudType);

2131

module_add_object(m, "Beater_base", &BeaterType);

2132

module_add_object(m, "Beat_base", &BeatType);

2133

module_add_object(m, "BeatTapStream_base", &BeatTapStreamType);

2134

module_add_object(m, "BeatAmpStream_base", &BeatAmpStreamType);

2135

module_add_object(m, "BeatDurStream_base", &BeatDurStreamType);

2136

module_add_object(m, "BeatEndStream_base", &BeatEndStreamType);

2137

module_add_object(m, "Fader_base", &FaderType);

2138

module_add_object(m, "Randi_base", &RandiType);

2139

module_add_object(m, "Randh_base", &RandhType);

2140

module_add_object(m, "Choice_base", &ChoiceType);

2141

module_add_object(m, "RandDur_base", &RandDurType);

2142

module_add_object(m, "Xnoise_base", &XnoiseType);

2143

module_add_object(m, "XnoiseMidi_base", &XnoiseMidiType);

2144

module_add_object(m, "XnoiseDur_base", &XnoiseDurType);

2145

module_add_object(m, "RandInt_base", &RandIntType);

2146

module_add_object(m, "Urn_base", &UrnType);

2147

module_add_object(m, "SfPlayer_base", &SfPlayerType);

2148

module_add_object(m, "SfPlay_base", &SfPlayType);

2149

module_add_object(m, "SfMarkerShuffler_base", &SfMarkerShufflerType);

2150

module_add_object(m, "SfMarkerShuffle_base", &SfMarkerShuffleType);

2151

module_add_object(m, "SfMarkerLooper_base", &SfMarkerLooperType);

2152

module_add_object(m, "SfMarkerLoop_base", &SfMarkerLoopType);

2153

module_add_object(m, "Osc_base", &OscType);

2154

module_add_object(m, "OscLoop_base", &OscLoopType);

2155

module_add_object(m, "OscTrig_base", &OscTrigType);

2156

module_add_object(m, "OscBank_base", &OscBankType);

2157

module_add_object(m, "SumOsc_base", &SumOscType);

2158

module_add_object(m, "TableRead_base", &TableReadType);

2159

module_add_object(m, "Pulsar_base", &PulsarType);

2160

module_add_object(m, "Sine_base", &SineType);

2161

module_add_object(m, "SineLoop_base", &SineLoopType);

2162

module_add_object(m, "Fm_base", &FmType);

2163

module_add_object(m, "CrossFm_base", &CrossFmType);

2164

module_add_object(m, "LFO_base", &LFOType);

2165

module_add_object(m, "Blit_base", &BlitType);

2166

module_add_object(m, "Rossler_base", &RosslerType);

2167

module_add_object(m, "RosslerAlt_base", &RosslerAltType);

2168

module_add_object(m, "Lorenz_base", &LorenzType);

2169

module_add_object(m, "LorenzAlt_base", &LorenzAltType);

2170

module_add_object(m, "Phasor_base", &PhasorType);

2171

module_add_object(m, "SuperSaw_base", &SuperSawType);

2172

module_add_object(m, "Pointer_base", &PointerType);

2173

module_add_object(m, "TableIndex_base", &TableIndexType);

2174

module_add_object(m, "Lookup_base", &LookupType);

2175

module_add_object(m, "Noise_base", &NoiseType);

2176

module_add_object(m, "PinkNoise_base", &PinkNoiseType);

2177

module_add_object(m, "BrownNoise_base", &BrownNoiseType);

2178

module_add_object(m, "Biquad_base", &BiquadType);

2179

module_add_object(m, "Biquadx_base", &BiquadxType);

2180

module_add_object(m, "Biquada_base", &BiquadaType);

2181

module_add_object(m, "EQ_base", &EQType);

2182

module_add_object(m, "Tone_base", &ToneType);

2183

module_add_object(m, "Atone_base", &AtoneType);

2184

module_add_object(m, "DCBlock_base", &DCBlockType);

2185

module_add_object(m, "Allpass_base", &AllpassType);

2186

module_add_object(m, "Allpass2_base", &Allpass2Type);

2187

module_add_object(m, "Phaser_base", &PhaserType);

2188

module_add_object(m, "Vocoder_base", &VocoderType);

2189

module_add_object(m, "Port_base", &PortType);

2190

module_add_object(m, "Denorm_base", &DenormType);

2191

module_add_object(m, "Disto_base", &DistoType);

2192

module_add_object(m, "Clip_base", &ClipType);

2193

module_add_object(m, "Mirror_base", &MirrorType);

2194

module_add_object(m, "Wrap_base", &WrapType);

2195

module_add_object(m, "Between_base", &BetweenType);

2196

module_add_object(m, "Degrade_base", &DegradeType);

2197

module_add_object(m, "Compress_base", &CompressType);

2198

module_add_object(m, "Gate_base", &GateType);

2199

module_add_object(m, "Balance_base", &BalanceType);

2200

module_add_object(m, "Delay_base", &DelayType);

2201

module_add_object(m, "SDelay_base", &SDelayType);

2202

module_add_object(m, "Waveguide_base", &WaveguideType);

2203

module_add_object(m, "AllpassWG_base", &AllpassWGType);

2204

module_add_object(m, "Midictl_base", &MidictlType);

2205

module_add_object(m, "CtlScan_base", &CtlScanType);

2206

module_add_object(m, "CtlScan2_base", &CtlScan2Type);

2207

module_add_object(m, "MidiNote_base", &MidiNoteType);

2208

module_add_object(m, "Notein_base", &NoteinType);

2209

module_add_object(m, "Bendin_base", &BendinType);

2210

module_add_object(m, "Touchin_base", &TouchinType);

2211

module_add_object(m, "Programin_base", &PrograminType);

2212

module_add_object(m, "MidiAdsr_base", &MidiAdsrType);

2213

module_add_object(m, "MidiDelAdsr_base", &MidiDelAdsrType);

2214

module_add_object(m, "OscSend_base", &OscSendType);

2215

module_add_object(m, "OscDataSend_base", &OscDataSendType);

2216

module_add_object(m, "OscReceive_base", &OscReceiveType);

2217

module_add_object(m, "OscReceiver_base", &OscReceiverType);

2218

module_add_object(m, "OscListReceive_base", &OscListReceiveType);

2219

module_add_object(m, "OscListReceiver_base", &OscListReceiverType);

2220

module_add_object(m, "OscDataReceive_base", &OscDataReceiveType);

2221

module_add_object(m, "TrigRand_base", &TrigRandType);

2222

module_add_object(m, "TrigRandInt_base", &TrigRandIntType);

2223

module_add_object(m, "TrigVal_base", &TrigValType);

2224

module_add_object(m, "TrigChoice_base", &TrigChoiceType);

2225

module_add_object(m, "Iter_base", &IterType);

2226

module_add_object(m, "TrigEnv_base", &TrigEnvType);

2227

module_add_object(m, "TrigLinseg_base", &TrigLinsegType);

2228

module_add_object(m, "TrigExpseg_base", &TrigExpsegType);

2229

module_add_object(m, "TrigFunc_base", &TrigFuncType);

2230

module_add_object(m, "TrigXnoise_base", &TrigXnoiseType);

2231

module_add_object(m, "TrigXnoiseMidi_base", &TrigXnoiseMidiType);

2232

module_add_object(m, "Pattern_base", &PatternType);

2233

module_add_object(m, "CallAfter_base", &CallAfterType);

2234

module_add_object(m, "BandSplitter_base", &BandSplitterType);

2235

module_add_object(m, "BandSplit_base", &BandSplitType);

2236

module_add_object(m, "FourBandMain_base", &FourBandMainType);

2237

module_add_object(m, "FourBand_base", &FourBandType);

2238

module_add_object(m, "HilbertMain_base", &HilbertMainType);

2239

module_add_object(m, "Hilbert_base", &HilbertType);

2240

module_add_object(m, "Follower_base", &FollowerType);

2241

module_add_object(m, "Follower2_base", &Follower2Type);

2242

module_add_object(m, "ZCross_base", &ZCrossType);

2243

module_add_object(m, "SPanner_base", &SPannerType);

2244

module_add_object(m, "Panner_base", &PannerType);

2245

module_add_object(m, "Pan_base", &PanType);

2246

module_add_object(m, "SPan_base", &SPanType);

2247

module_add_object(m, "Switcher_base", &SwitcherType);

2248

module_add_object(m, "Switch_base", &SwitchType);

2249

module_add_object(m, "Selector_base", &SelectorType);

2250

module_add_object(m, "VoiceManager_base", &VoiceManagerType);

2251

module_add_object(m, "Mixer_base", &MixerType);

2252

module_add_object(m, "MixerVoice_base", &MixerVoiceType);

2253

module_add_object(m, "Counter_base", &CounterType);

2254

module_add_object(m, "Count_base", &CountType);

2255

module_add_object(m, "Thresh_base", &ThreshType);

2256

module_add_object(m, "Percent_base", &PercentType);

2257

module_add_object(m, "Timer_base", &TimerType);

2258

module_add_object(m, "Select_base", &SelectType);

2259

module_add_object(m, "Change_base", &ChangeType);

2260

module_add_object(m, "Score_base", &ScoreType);

2261

module_add_object(m, "Freeverb_base", &FreeverbType);

2262

module_add_object(m, "WGVerb_base", &WGVerbType);

2263

module_add_object(m, "Chorus_base", &ChorusType);

2264

module_add_object(m, "Convolve_base", &ConvolveType);

2265

module_add_object(m, "IRWinSinc_base", &IRWinSincType);

2266

module_add_object(m, "IRPulse_base", &IRPulseType);

2267

module_add_object(m, "IRAverage_base", &IRAverageType);

2268

module_add_object(m, "IRFM_base", &IRFMType);

2269

module_add_object(m, "Granulator_base", &GranulatorType);

2270

module_add_object(m, "Looper_base", &LooperType);

2271

module_add_object(m, "Harmonizer_base", &HarmonizerType);

2272

module_add_object(m, "Print_base", &PrintType);

2273

module_add_object(m, "M_Sin_base", &M_SinType);

2274

module_add_object(m, "M_Cos_base", &M_CosType);

2275

module_add_object(m, "M_Tan_base", &M_TanType);

2276

module_add_object(m, "M_Abs_base", &M_AbsType);

2277

module_add_object(m, "M_Sqrt_base", &M_SqrtType);

2278

module_add_object(m, "M_Log_base", &M_LogType);

2279

module_add_object(m, "M_Log2_base", &M_Log2Type);

2280

module_add_object(m, "M_Log10_base", &M_Log10Type);

2281

module_add_object(m, "M_Pow_base", &M_PowType);

2282

module_add_object(m, "M_Atan2_base", &M_Atan2Type);

2283

module_add_object(m, "M_Floor_base", &M_FloorType);

2284

module_add_object(m, "M_Ceil_base", &M_CeilType);

2285

module_add_object(m, "M_Round_base", &M_RoundType);

2286

module_add_object(m, "Snap_base", &SnapType);

2287

module_add_object(m, "Interp_base", &InterpType);

2288

module_add_object(m, "SampHold_base", &SampHoldType);

2289

module_add_object(m, "DBToA_base", &DBToAType);

2290

module_add_object(m, "AToDB_base", &AToDBType);

2291

module_add_object(m, "Scale_base", &ScaleType);

2292

module_add_object(m, "CentsToTranspo_base", &CentsToTranspoType);

2293

module_add_object(m, "TranspoToCents_base", &TranspoToCentsType);

2294

module_add_object(m, "MToF_base", &MToFType);

2295

module_add_object(m, "MToT_base", &MToTType);

2296

module_add_object(m, "FFTMain_base", &FFTMainType);

2297

module_add_object(m, "FFT_base", &FFTType);

2298

module_add_object(m, "IFFT_base", &IFFTType);

2299

module_add_object(m, "CarToPol_base", &CarToPolType);

2300

module_add_object(m, "PolToCar_base", &PolToCarType);

2301

module_add_object(m, "FrameDeltaMain_base", &FrameDeltaMainType);

2302

module_add_object(m, "FrameDelta_base", &FrameDeltaType);

2303

module_add_object(m, "FrameAccum_base", &FrameAccumType);

2304

module_add_object(m, "FrameAccumMain_base", &FrameAccumMainType);

2305

module_add_object(m, "VectralMain_base", &VectralMainType);

2306

module_add_object(m, "Vectral_base", &VectralType);

2307

module_add_object(m, "Min_base", &MinType);

2308

module_add_object(m, "Max_base", &MaxType);

2309

module_add_object(m, "Delay1_base", &Delay1Type);

2310

module_add_object(m, "RCOsc_base", &RCOscType);

2311

2312

#ifdef COMPILE_EXTERNALS

2313

EXTERNAL_OBJECTS

2314

PyModule_AddIntConstant(m, "WITH_EXTERNALS", 1);

2315

#else

2316

PyModule_AddIntConstant(m, "WITH_EXTERNALS", 0);

2317

#endif

3025

2318

}

Older »