← Back to branch summary

~ubuntu-branches/debian/sid/python-pyo/sid

« back to all changes in this revision

Viewing changes to src/engine/servermodule.c

  • Committer: Package Import Robot
  • Author(s): Tiago Bortoletto Vaz
  • Date: 2012-06-08 20:35:45 UTC
  • Revision ID: package-import@ubuntu.com-20120608203545-4z7kcf2lgvpsk18y
Tags: upstream-0.6.1
Import upstream version 0.6.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/engine/servermodule.c
 
1
/*************************************************************************
 
2
 * Copyright 2010 Olivier Belanger                                        *
 
3
 *                                                                        * 
 
4
 * This file is part of pyo, a python module to help digital signal       *
 
5
 * processing script creation.                                            *  
 
6
 *                                                                        * 
 
7
 * pyo is free software: you can redistribute it and/or modify            *
 
8
 * it under the terms of the GNU General Public License as published by   *
 
9
 * the Free Software Foundation, either version 3 of the License, or      *
 
10
 * (at your option) any later version.                                    * 
 
11
 *                                                                        *
 
12
 * pyo is distributed in the hope that it will be useful,                 *
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of         *    
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
 
15
 * GNU General Public License for more details.                           *
 
16
 *                                                                        *
 
17
 * You should have received a copy of the GNU General Public License      *
 
18
 * along with pyo.  If not, see <http://www.gnu.org/licenses/>.           *
 
19
 *************************************************************************/
 
20
 
 
21
#include <Python.h>
 
22
#include <math.h>
 
23
#include <assert.h>
 
24
#include <stdarg.h>
 
25
#include <time.h>
 
26
#include <stdlib.h>
 
27
 
 
28
#include "structmember.h"
 
29
#include "portaudio.h"
 
30
#include "portmidi.h"
 
31
#include "sndfile.h"
 
32
#include "streammodule.h"
 
33
#include "pyomodule.h"
 
34
#include "servermodule.h"
 
35
 
 
36
static Server *my_server = NULL;
 
37
static PyObject *Server_shut_down(Server *self);
 
38
static PyObject *Server_stop(Server *self);
 
39
static void Server_process_gui(Server *server);
 
40
static void Server_process_time(Server *server);
 
41
static inline void Server_process_buffers(Server *server);
 
42
static int Server_start_rec_internal(Server *self, char *filename);
 
43
 
 
44
/* random objects count and multiplier to assign different seed to each instance. */
 
45
#define num_rnd_objs 27
 
46
 
 
47
int rnd_objs_count[num_rnd_objs] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 
48
int rnd_objs_mult[num_rnd_objs] = {1993,1997,1999,2003,2011,2017,2027,2029,2039,2053,2063,2069,
 
49
                         2081,2083,2087,2089,2099,2111,2113,2129,2131,2137,2141,2143,2153, 2161,2179};
 
50
 
 
51
#ifdef USE_COREAUDIO
 
52
static int coreaudio_stop_callback(Server *self);
 
53
#endif
 
54
 
 
55
void
 
56
Server_error(Server *self, char * format, ...)
 
57
{
 
58
    // Errors should indicate failure to execute a request
 
59
    if (self->verbosity & 1) {
 
60
        char buffer[256];
 
61
        va_list args;
 
62
        va_start (args, format);
 
63
        vsprintf (buffer,format, args);
 
64
        va_end (args);
 
65
 
 
66
        printf("%s",buffer);
 
67
    }
 
68
}
 
69
 
 
70
void
 
71
Server_message(Server *self, char * format, ...)
 
72
{
 
73
    // Messages should print useful or relevant information, or information requested by the user
 
74
    if (self->verbosity & 2) {
 
75
        char buffer[256];
 
76
        va_list args;
 
77
        va_start (args, format);
 
78
        vsprintf (buffer,format, args);
 
79
        va_end (args);
 
80
 
 
81
        printf("%s",buffer);
 
82
    }
 
83
}
 
84
 
 
85
void
 
86
Server_warning(Server *self, char * format, ...)
 
87
{
 
88
    // Warnings should be used when an unexpected or unusual choice was made by pyo
 
89
    if (self->verbosity & 4) {
 
90
        char buffer[256];
 
91
        va_list args;
 
92
        va_start (args, format);
 
93
        vsprintf (buffer,format, args);
 
94
        va_end (args);
 
95
        printf("%s",buffer);
 
96
    }
 
97
}
 
98
 
 
99
void
 
100
Server_debug(Server *self, char * format, ...)
 
101
{    
 
102
    // Debug messages should print internal information which might be necessary for debugging internal conditions.
 
103
    if (self->verbosity & 8) {
 
104
        char buffer[256];
 
105
        va_list args;
 
106
        va_start (args, format);
 
107
        vsprintf (buffer,format, args);
 
108
        va_end (args);
 
109
 
 
110
        printf("%s",buffer);
 
111
    }
 
112
}
 
113
 
 
114
/* Portmidi get input events */
 
115
static void portmidiGetEvents(Server *self) 
 
116
{
 
117
    PmError result;
 
118
    PmEvent buffer;
 
119
 
 
120
    do {
 
121
        result = Pm_Poll(self->in);
 
122
        if (result) {
 
123
            if (Pm_Read(self->in, &buffer, 1) == pmBufferOverflow) 
 
124
                continue;
 
125
            self->midiEvents[self->midi_count++] = buffer;
 
126
        }    
 
127
    } while (result);
 
128
}
 
129
 
 
130
/* Portaudio stuff */
 
131
static void portaudio_assert(PaError ecode, const char* cmdName) {
 
132
    if (ecode != paNoError) {
 
133
        const char* eText = Pa_GetErrorText(ecode);
 
134
        if (!eText) {
 
135
            eText = "???";
 
136
        }
 
137
        printf("portaudio error in %s: %s\n", cmdName, eText);
 
138
        Pa_Terminate();
 
139
    }
 
140
}
 
141
 
 
142
/* Portaudio callback function */
 
143
static int 
 
144
pa_callback_interleaved( const void *inputBuffer, void *outputBuffer,
 
145
                            unsigned long framesPerBuffer,
 
146
                            const PaStreamCallbackTimeInfo* timeInfo,
 
147
                            PaStreamCallbackFlags statusFlags,
 
148
                            void *arg )
 
149
{
 
150
    float *out = (float *)outputBuffer;
 
151
    Server *server = (Server *) arg;
 
152
 
 
153
    assert(framesPerBuffer == server->bufferSize);
 
154
    int i;
 
155
    
 
156
    /* avoid unused variable warnings */
 
157
    (void) timeInfo;
 
158
    (void) statusFlags;
 
159
 
 
160
    if (server->withPortMidi == 1) {
 
161
        portmidiGetEvents(server);
 
162
    }
 
163
    
 
164
    if (server->duplex == 1) {
 
165
        float *in = (float *)inputBuffer;
 
166
        for (i=0; i<server->bufferSize*server->nchnls; i++) {
 
167
            server->input_buffer[i] = (MYFLT)in[i];
 
168
        }
 
169
    }
 
170
 
 
171
    Server_process_buffers(server);
 
172
    for (i=0; i<server->bufferSize*server->nchnls; i++) {
 
173
        out[i] = (float) server->output_buffer[i];
 
174
    }
 
175
    server->midi_count = 0;
 
176
    
 
177
    if (server->server_started == 1) {
 
178
        if (server->server_stopped == 1 && server->currentAmp < 0.0001)
 
179
            server->server_started = 0;
 
180
        return paContinue;
 
181
    }    
 
182
    else {
 
183
        return paComplete;
 
184
    }
 
185
}
 
186
 
 
187
static int 
 
188
pa_callback_nonInterleaved( const void *inputBuffer, void *outputBuffer,
 
189
                        unsigned long framesPerBuffer,
 
190
                        const PaStreamCallbackTimeInfo* timeInfo,
 
191
                        PaStreamCallbackFlags statusFlags,
 
192
                        void *arg )
 
193
{
 
194
    float **out = (float **)outputBuffer;
 
195
    Server *server = (Server *) arg;
 
196
    
 
197
    assert(framesPerBuffer == server->bufferSize);
 
198
    int i, j;
 
199
    
 
200
    /* avoid unused variable warnings */
 
201
    (void) timeInfo;
 
202
    (void) statusFlags;
 
203
    
 
204
    if (server->withPortMidi == 1) {
 
205
        portmidiGetEvents(server);
 
206
    }
 
207
 
 
208
    if (server->duplex == 1) {
 
209
        float **in = (float **)inputBuffer;
 
210
        for (i=0; i<server->bufferSize; i++) {
 
211
            for (j=0; j<server->nchnls; j++) {
 
212
                server->input_buffer[(i*server->nchnls)+j] = (MYFLT)in[j][i];
 
213
            }
 
214
        }
 
215
    }
 
216
 
 
217
    Server_process_buffers(server);
 
218
    for (i=0; i<server->bufferSize; i++) {
 
219
        for (j=0; j<server->nchnls; j++) {
 
220
            out[j][i] = (float) server->output_buffer[(i*server->nchnls)+j];
 
221
        }
 
222
    }
 
223
    server->midi_count = 0;
 
224
    
 
225
    if (server->server_started == 1) {
 
226
        if (server->server_stopped == 1 && server->currentAmp < 0.0001)
 
227
            server->server_started = 0;
 
228
        return paContinue;
 
229
    }    
 
230
    else {
 
231
        return paComplete;
 
232
    }
 
233
}
 
234
 
 
235
#ifdef USE_JACK
 
236
/* Jack callbacks */
 
237
 
 
238
static int
 
239
jack_callback (jack_nframes_t nframes, void *arg)
 
240
{
 
241
    int i, j;
 
242
    Server *server = (Server *) arg;
 
243
    assert(nframes == server->bufferSize);
 
244
    jack_default_audio_sample_t *in_buffers[server->nchnls], *out_buffers[server->nchnls];
 
245
 
 
246
    if (server->withPortMidi == 1) {
 
247
        portmidiGetEvents(server);
 
248
    }
 
249
    PyoJackBackendData *be_data = (PyoJackBackendData *) server->audio_be_data;
 
250
    for (i = 0; i < server->nchnls; i++) {
 
251
        in_buffers[i] = jack_port_get_buffer (be_data->jack_in_ports[i], server->bufferSize);
 
252
    }
 
253
    for (i = 0; i < server->nchnls; i++) {
 
254
        out_buffers[i] = jack_port_get_buffer (be_data->jack_out_ports[i], server->bufferSize);
 
255
        
 
256
    }
 
257
    /* jack audio data is not interleaved */
 
258
    if (server->duplex == 1) {
 
259
        for (i=0; i<server->bufferSize; i++) {
 
260
            for (j=0; j<server->nchnls; j++) {
 
261
                server->input_buffer[(i*server->nchnls)+j] = (MYFLT) in_buffers[j][i];
 
262
            }
 
263
        }
 
264
    }
 
265
    Server_process_buffers(server);
 
266
    for (i=0; i<server->bufferSize; i++) {
 
267
        for (j=0; j<server->nchnls; j++) {
 
268
            out_buffers[j][i] = (jack_default_audio_sample_t) server->output_buffer[(i*server->nchnls)+j];
 
269
        }
 
270
    }
 
271
    server->midi_count = 0;
 
272
    return 0;    
 
273
}
 
274
 
 
275
static int
 
276
jack_srate_cb (jack_nframes_t nframes, void *arg)
 
277
{
 
278
    Server *s = (Server *) arg;
 
279
    s->samplingRate = (double) nframes;
 
280
    Server_debug(s, "the sample rate is now %lu/sec\n", (unsigned long) nframes);
 
281
    return 0;
 
282
}
 
283
 
 
284
static int
 
285
jack_bufsize_cb (jack_nframes_t nframes, void *arg)
 
286
{
 
287
    Server *s = (Server *) arg;
 
288
    s->bufferSize = (int) nframes;
 
289
    Server_debug(s, "the buffer size is now %lu/sec\n", (unsigned long) nframes);
 
290
    return 0;
 
291
}
 
292
 
 
293
static void
 
294
jack_error_cb (const char *desc)
 
295
{
 
296
    printf("JACK error: %s\n", desc);
 
297
}
 
298
 
 
299
static void
 
300
jack_shutdown_cb (void *arg)
 
301
{
 
302
    Server *s = (Server *) arg;
 
303
    Server_shut_down(s);
 
304
    Server_warning(s, "JACK server shutdown. Pyo Server shut down.\n");
 
305
}
 
306
 
 
307
#endif
 
308
 
 
309
#ifdef USE_COREAUDIO
 
310
/* Coreaudio callbacks */
 
311
 
 
312
OSStatus coreaudio_input_callback(AudioDeviceID device, const AudioTimeStamp* inNow,
 
313
                                   const AudioBufferList* inInputData,
 
314
                                   const AudioTimeStamp* inInputTime,
 
315
                                   AudioBufferList* outOutputData,
 
316
                                   const AudioTimeStamp* inOutputTime,
 
317
                                   void* defptr)
 
318
{
 
319
    int i, j, bufchnls, servchnls, off1chnls, off2chnls;
 
320
    Server *server = (Server *) defptr;
 
321
    (void) outOutputData;
 
322
    const AudioBuffer* inputBuf = inInputData->mBuffers;
 
323
    float *bufdata = (float*)inputBuf->mData;
 
324
    bufchnls = inputBuf->mNumberChannels;
 
325
    servchnls = server->nchnls < bufchnls ? server->nchnls : bufchnls;
 
326
    for (i=0; i<server->bufferSize; i++) {
 
327
        off1chnls = i*bufchnls;
 
328
        off2chnls = i*servchnls;
 
329
        for (j=0; j<servchnls; j++) {
 
330
            server->input_buffer[off2chnls+j] = (MYFLT)bufdata[off1chnls+j];
 
331
        }
 
332
    }    
 
333
    return kAudioHardwareNoError;     
 
334
} 
 
335
 
 
336
OSStatus coreaudio_output_callback(AudioDeviceID device, const AudioTimeStamp* inNow,
 
337
                                   const AudioBufferList* inInputData,
 
338
                                   const AudioTimeStamp* inInputTime,
 
339
                                   AudioBufferList* outOutputData,
 
340
                                   const AudioTimeStamp* inOutputTime,
 
341
                                   void* defptr)
 
342
{
 
343
    int i, j, bufchnls, servchnls, off1chnls, off2chnls;
 
344
    Server *server = (Server *) defptr;
 
345
 
 
346
    (void) inInputData;
 
347
 
 
348
    if (server->withPortMidi == 1) {
 
349
        portmidiGetEvents(server);
 
350
    }
 
351
    
 
352
    Server_process_buffers(server);
 
353
    AudioBuffer* outputBuf = outOutputData->mBuffers;
 
354
    bufchnls = outputBuf->mNumberChannels;
 
355
    servchnls = server->nchnls < bufchnls ? server->nchnls : bufchnls;
 
356
    float *bufdata = (float*)outputBuf->mData;
 
357
    for (i=0; i<server->bufferSize; i++) {
 
358
        off1chnls = i*bufchnls;
 
359
        off2chnls = i*servchnls;
 
360
        for(j=0; j<servchnls; j++) {
 
361
            bufdata[off1chnls+j] = server->output_buffer[off2chnls+j];
 
362
        }    
 
363
    }
 
364
    server->midi_count = 0;
 
365
 
 
366
    if (server->server_started == 1) {
 
367
        if (server->server_stopped == 1 && server->currentAmp < 0.0001)
 
368
            coreaudio_stop_callback(server);
 
369
    }        
 
370
 
 
371
    return kAudioHardwareNoError;
 
372
}    
 
373
 
 
374
int
 
375
coreaudio_stop_callback(Server *self) 
 
376
{
 
377
    OSStatus err = kAudioHardwareNoError;
 
378
    
 
379
    if (self->duplex == 1) {
 
380
        err = AudioDeviceStop(self->input, coreaudio_input_callback);
 
381
        if (err != kAudioHardwareNoError) {
 
382
            Server_error(self, "Input AudioDeviceStop failed %d\n", (int)err);
 
383
            return -1;
 
384
        }        
 
385
    }
 
386
    
 
387
    err = AudioDeviceStop(self->output, coreaudio_output_callback);
 
388
    if (err != kAudioHardwareNoError) {
 
389
        Server_error(self, "Output AudioDeviceStop failed %d\n", (int)err);
 
390
        return -1;
 
391
    }
 
392
    self->server_started = 0;
 
393
    return 0;
 
394
}
 
395
 
 
396
#endif
 
397
 
 
398
static int
 
399
offline_process_block(Server *arg)
 
400
{    
 
401
    Server *server = (Server *) arg;
 
402
    Server_process_buffers(server);
 
403
    return 0;
 
404
}
 
405
 
 
406
/* Server audio backend init functions */
 
407
 
 
408
int
 
409
Server_pa_init(Server *self)
 
410
{
 
411
    PaError err;
 
412
    PaStreamParameters outputParameters;
 
413
    PaStreamParameters inputParameters;
 
414
    PaDeviceIndex n, inDevice, outDevice;
 
415
    const PaDeviceInfo *deviceInfo;
 
416
    PaHostApiIndex hostIndex;
 
417
    const PaHostApiInfo *hostInfo;
 
418
    PaHostApiTypeId hostId;
 
419
    PaSampleFormat sampleFormat;
 
420
    PaStreamCallback *streamCallback;
 
421
    double deviceDefaultSamplingRate;
 
422
 
 
423
    err = Pa_Initialize();
 
424
    portaudio_assert(err, "Pa_Initialize");
 
425
 
 
426
    n = Pa_GetDeviceCount();
 
427
    if (n < 0) {
 
428
        portaudio_assert(n, "Pa_GetDeviceCount");
 
429
    }
 
430
 
 
431
    PyoPaBackendData *be_data = (PyoPaBackendData *) malloc(sizeof(PyoPaBackendData *));
 
432
    self->audio_be_data = (void *) be_data;
 
433
 
 
434
    if (self->output == -1)
 
435
        outDevice = Pa_GetDefaultOutputDevice(); /* default output device */
 
436
    else
 
437
        outDevice = (PaDeviceIndex) self->output; /* selected output device */ 
 
438
    if (self->input == -1)
 
439
        inDevice = Pa_GetDefaultInputDevice(); /* default input device */
 
440
    else
 
441
        inDevice = (PaDeviceIndex) self->input; /* selected input device */
 
442
 
 
443
    /* Retrieve host api id and define sample and callback format*/
 
444
    deviceInfo = Pa_GetDeviceInfo(outDevice);
 
445
    deviceDefaultSamplingRate = deviceInfo->defaultSampleRate;
 
446
    hostIndex = deviceInfo->hostApi;
 
447
    hostInfo = Pa_GetHostApiInfo(hostIndex);
 
448
    hostId = hostInfo->type;
 
449
    if (hostId == paASIO) {
 
450
        Server_debug(self, "Portaudio uses non-interleaved callback.\n");
 
451
        sampleFormat = paFloat32 | paNonInterleaved;
 
452
        streamCallback = pa_callback_nonInterleaved;
 
453
    }
 
454
    else if (hostId == paALSA) {
 
455
        Server_debug(self, "Portaudio uses interleaved callback.\n");
 
456
        Server_debug(self, "Using ALSA, if no input/output devices are specified, force to devices 0.\n");
 
457
        if (self->input == -1 && self->output == -1) {
 
458
            self->input = self->output = 0;
 
459
            inDevice = outDevice = (PaDeviceIndex) 0;
 
460
        }
 
461
        sampleFormat = paFloat32;
 
462
        streamCallback = pa_callback_interleaved;
 
463
    }
 
464
     else {
 
465
        Server_debug(self, "Portaudio uses interleaved callback.\n");
 
466
        sampleFormat = paFloat32;
 
467
        streamCallback = pa_callback_interleaved;
 
468
    }
 
469
    
 
470
 
 
471
    /* setup output and input streams */
 
472
    memset(&outputParameters, 0, sizeof(outputParameters));
 
473
    outputParameters.device = outDevice;
 
474
    outputParameters.channelCount = self->nchnls;
 
475
    outputParameters.sampleFormat = sampleFormat;
 
476
    outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultHighOutputLatency;
 
477
    outputParameters.hostApiSpecificStreamInfo = NULL;
 
478
 
 
479
    if (self->duplex == 1) {
 
480
        memset(&inputParameters, 0, sizeof(inputParameters));
 
481
        inputParameters.device = inDevice;
 
482
        inputParameters.channelCount = self->nchnls;
 
483
        inputParameters.sampleFormat = sampleFormat;
 
484
        inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputParameters.device )->defaultHighInputLatency ;
 
485
        inputParameters.hostApiSpecificStreamInfo = NULL;
 
486
    }
 
487
 
 
488
    if (self->input == -1 && self->output == -1) {
 
489
        if (self->duplex == 1)
 
490
            err = Pa_OpenDefaultStream(&be_data->stream, self->nchnls, self->nchnls, sampleFormat, self->samplingRate, self->bufferSize, streamCallback, (void *) self);
 
491
        else
 
492
            err = Pa_OpenDefaultStream(&be_data->stream, 0, self->nchnls, sampleFormat, self->samplingRate, self->bufferSize, streamCallback, (void *) self);
 
493
    }
 
494
    else {
 
495
        if (self->duplex == 1)
 
496
            err = Pa_OpenStream(&be_data->stream, &inputParameters, &outputParameters, self->samplingRate, self->bufferSize, paNoFlag, streamCallback,  (void *) self);
 
497
        else
 
498
            err = Pa_OpenStream(&be_data->stream, (PaStreamParameters *) NULL, &outputParameters, self->samplingRate, self->bufferSize, paNoFlag, streamCallback,  (void *) self);
 
499
    }        
 
500
    portaudio_assert(err, "Pa_OpenStream");
 
501
    if (err < 0) {
 
502
        Server_error(self, "Portaudio error: %s", Pa_GetErrorText(err));
 
503
        return -1;
 
504
    }
 
505
    return 0;
 
506
}
 
507
 
 
508
int
 
509
Server_pa_deinit(Server *self)
 
510
{
 
511
    PaError err;
 
512
    PyoPaBackendData *be_data = (PyoPaBackendData *) self->audio_be_data;
 
513
 
 
514
    if (Pa_IsStreamActive(be_data->stream) || ! Pa_IsStreamStopped(be_data->stream)) {
 
515
        err = Pa_StopStream(be_data->stream);
 
516
        portaudio_assert(err, "Pa_StopStream");
 
517
    }
 
518
    
 
519
    err = Pa_CloseStream(be_data->stream);
 
520
    portaudio_assert(err, "Pa_CloseStream");
 
521
    
 
522
    err = Pa_Terminate();
 
523
    portaudio_assert(err, "Pa_Terminate");
 
524
    
 
525
    free(self->audio_be_data);
 
526
    return err;
 
527
}
 
528
 
 
529
int 
 
530
Server_pa_start(Server *self)
 
531
{
 
532
    PaError err;
 
533
    PyoPaBackendData *be_data = (PyoPaBackendData *) self->audio_be_data;
 
534
 
 
535
    if (Pa_IsStreamActive(be_data->stream) || ! Pa_IsStreamStopped(be_data->stream)) {
 
536
        err = Pa_StopStream(be_data->stream);
 
537
        portaudio_assert(err, "Pa_StopStream");
 
538
    }
 
539
    err = Pa_StartStream(be_data->stream);
 
540
    portaudio_assert(err, "Pa_StartStream");
 
541
    return err;
 
542
}
 
543
 
 
544
int 
 
545
Server_pa_stop(Server *self)
 
546
{
 
547
    self->timeStep = (int)(0.1 * self->samplingRate);
 
548
    self->amp = 0.;
 
549
    self->server_stopped = 1;
 
550
    return 0;
 
551
}
 
552
 
 
553
#ifdef USE_JACK
 
554
 
 
555
int
 
556
Server_jack_autoconnect (Server *self)
 
557
{
 
558
    const char **ports;
 
559
    int ret = 0;
 
560
    PyoJackBackendData *be_data = (PyoJackBackendData *) self->audio_be_data;
 
561
    if ((ports = jack_get_ports (be_data->jack_client, NULL, NULL, 
 
562
        JackPortIsPhysical|JackPortIsOutput)) == NULL) {
 
563
        Server_error(self, "Jack: Cannot find any physical capture ports\n");
 
564
        ret = -1;
 
565
    }
 
566
    int i=0;
 
567
    while(ports[i]!=NULL && be_data->jack_in_ports[i] != NULL){
 
568
        if (jack_connect (be_data->jack_client, ports[i], jack_port_name(be_data->jack_in_ports[i]))) {
 
569
            Server_warning(self, "Jack: cannot connect input ports\n");
 
570
            ret = -1;
 
571
        }
 
572
        i++;
 
573
    }
 
574
    free (ports);
 
575
    
 
576
    if ((ports = jack_get_ports (be_data->jack_client, NULL, NULL, 
 
577
        JackPortIsPhysical|JackPortIsInput)) == NULL) {
 
578
        Server_error(self, "Jack: Cannot find any physical playback ports\n");
 
579
        ret = -1;
 
580
    }
 
581
    
 
582
    i=0;
 
583
    while(ports[i]!=NULL && be_data->jack_out_ports[i] != NULL){
 
584
        if (jack_connect (be_data->jack_client, jack_port_name (be_data->jack_out_ports[i]), ports[i])) {
 
585
            Server_warning(self, "Jack: cannot connect output ports\n");
 
586
            ret = -1;
 
587
        }
 
588
        i++;
 
589
    }
 
590
    free (ports);
 
591
    return ret;
 
592
}
 
593
 
 
594
int
 
595
Server_jack_init (Server *self)
 
596
{   
 
597
    char client_name[32];
 
598
    const char *server_name = "server";
 
599
    jack_options_t options = JackNullOption;
 
600
    jack_status_t status;
 
601
    int sampleRate = 0;
 
602
    int bufferSize = 0;
 
603
    assert(self->audio_be_data == NULL);
 
604
    PyoJackBackendData *be_data = (PyoJackBackendData *) malloc(sizeof(PyoJackBackendData *));
 
605
    self->audio_be_data = (void *) be_data;
 
606
    be_data->jack_in_ports = (jack_port_t **) calloc(self->nchnls, sizeof(jack_port_t *));
 
607
    be_data->jack_out_ports = (jack_port_t **) calloc(self->nchnls, sizeof(jack_port_t *));
 
608
    strncpy(client_name,self->serverName, 32);
 
609
    be_data->jack_client = jack_client_open (client_name, options, &status, server_name);
 
610
    if (be_data->jack_client == NULL) {
 
611
        Server_error(self, "Jack error: Unable to create JACK client\n");
 
612
        if (status & JackServerFailed) {
 
613
            Server_debug(self, "Jack error: jack_client_open() failed, "
 
614
            "status = 0x%2.0x\n", status);
 
615
        }
 
616
        return -1;
 
617
    }
 
618
    if (status & JackServerStarted) {
 
619
        Server_message(self, "JACK server started.\n");
 
620
    }
 
621
    if (strcmp(self->serverName, jack_get_client_name(be_data->jack_client)) ) {
 
622
        strcpy(self->serverName, jack_get_client_name(be_data->jack_client));
 
623
        Server_warning(self, "Jack name `%s' assigned\n", self->serverName);
 
624
    }
 
625
    
 
626
    sampleRate = jack_get_sample_rate (be_data->jack_client);
 
627
    if (sampleRate != self->samplingRate) {
 
628
        self->samplingRate = (double)sampleRate;
 
629
        Server_warning(self, "Sample rate set to Jack engine sample rate: %" PRIu32 "\n", sampleRate);
 
630
    }
 
631
    else {
 
632
        Server_debug(self, "Jack engine sample rate: %" PRIu32 "\n", sampleRate);
 
633
    }
 
634
    if (sampleRate <= 0) {
 
635
        Server_error(self, "Invalid Jack engine sample rate.");
 
636
        jack_client_close (be_data->jack_client);
 
637
        return -1;
 
638
    }
 
639
    bufferSize = jack_get_buffer_size(be_data->jack_client);
 
640
    if (bufferSize != self->bufferSize) {
 
641
        self->bufferSize = bufferSize;
 
642
        Server_warning(self, "Buffer size set to Jack engine buffer size: %" PRIu32 "\n", bufferSize);
 
643
    }
 
644
    else {
 
645
        Server_debug(self, "Jack engine buffer size: %" PRIu32 "\n", bufferSize);
 
646
    }
 
647
    int nchnls = self->nchnls;
 
648
    
 
649
    while (nchnls-- > 0) {
 
650
        char name[16];
 
651
        int ret;
 
652
        int index = self->nchnls - nchnls - 1;
 
653
        ret = sprintf(name, "input_%i", index + 1);
 
654
        if (ret > 0) {
 
655
            be_data->jack_in_ports[index]
 
656
            = jack_port_register (be_data->jack_client, name, 
 
657
                                  JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
 
658
        }
 
659
        ret = sprintf(name, "output_%i", self->nchnls - nchnls);
 
660
        if (ret > 0) {
 
661
            be_data->jack_out_ports[index] 
 
662
            = jack_port_register (be_data->jack_client, name, 
 
663
                                  JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
 
664
        }
 
665
        if ((be_data->jack_in_ports[index] == NULL) || (be_data->jack_out_ports[index] == NULL)) {
 
666
            Server_error(self, "Jack: no more JACK ports available\n");
 
667
            return -1;
 
668
        }
 
669
    }
 
670
    jack_set_error_function (jack_error_cb);
 
671
    jack_set_sample_rate_callback(be_data->jack_client, jack_srate_cb, (void *) self);
 
672
    jack_on_shutdown (be_data->jack_client, jack_shutdown_cb, (void *) self);
 
673
    jack_set_buffer_size_callback (be_data->jack_client, jack_bufsize_cb, (void *) self);
 
674
    return 0;
 
675
}
 
676
 
 
677
int 
 
678
Server_jack_deinit (Server *self)
 
679
{
 
680
    int ret = 0;
 
681
    PyoJackBackendData *be_data = (PyoJackBackendData *) self->audio_be_data;
 
682
    ret = jack_client_close(be_data->jack_client);
 
683
    free(be_data->jack_in_ports);
 
684
    free(be_data->jack_out_ports);
 
685
    free(self->audio_be_data);
 
686
    return ret;
 
687
}
 
688
 
 
689
int 
 
690
Server_jack_start (Server *self)
 
691
{
 
692
    PyoJackBackendData *be_data = (PyoJackBackendData *) self->audio_be_data;
 
693
    jack_set_process_callback(be_data->jack_client, jack_callback, (void *) self);
 
694
    if (jack_activate (be_data->jack_client)) {
 
695
        Server_error(self, "Jack error: cannot activate jack client.\n");
 
696
        jack_client_close (be_data->jack_client);
 
697
        Server_shut_down(self);
 
698
        return -1;
 
699
    }
 
700
    Server_jack_autoconnect(self);
 
701
    return 0;
 
702
}
 
703
 
 
704
int 
 
705
Server_jack_stop (Server *self)
 
706
{
 
707
    PyoJackBackendData *be_data = (PyoJackBackendData *) self->audio_be_data;
 
708
    int ret = jack_deactivate(be_data->jack_client);
 
709
    self->server_started = 0;
 
710
    return ret;
 
711
}
 
712
 
 
713
#endif
 
714
 
 
715
#ifdef USE_COREAUDIO
 
716
int
 
717
Server_coreaudio_init(Server *self)
 
718
{
 
719
    OSStatus err = kAudioHardwareNoError;
 
720
    UInt32 count, namelen, propertySize;
 
721
    int i, numdevices;
 
722
    char *name;
 
723
    AudioDeviceID mOutputDevice = kAudioDeviceUnknown;
 
724
    AudioDeviceID mInputDevice = kAudioDeviceUnknown;
 
725
    Boolean writable;
 
726
    AudioTimeStamp now;
 
727
    
 
728
    now.mFlags = kAudioTimeStampHostTimeValid;
 
729
    now.mHostTime = AudioGetCurrentHostTime();
 
730
 
 
731
    /************************************/
 
732
    /* List Coreaudio available devices */
 
733
    /************************************/    
 
734
    err = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &count, 0);
 
735
    AudioDeviceID *devices = (AudioDeviceID*) malloc(count);    
 
736
    err = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &count, devices);
 
737
    if (err != kAudioHardwareNoError) {
 
738
        Server_error(self, "Get kAudioHardwarePropertyDevices error %s\n", (char*)&err);
 
739
        free(devices);
 
740
    }
 
741
 
 
742
    numdevices = count / sizeof(AudioDeviceID);
 
743
    Server_debug(self, "Coreaudio : Number of devices: %i\n", numdevices);
 
744
 
 
745
    for (i=0; i<numdevices; ++i) {
 
746
        err = AudioDeviceGetPropertyInfo(devices[i], 0, false, kAudioDevicePropertyDeviceName, &count, 0);
 
747
        if (err != kAudioHardwareNoError) {
 
748
            Server_error(self, "Info kAudioDevicePropertyDeviceName error %s A %d %08X\n", (char*)&err, i, devices[i]);
 
749
            break;
 
750
        }
 
751
        
 
752
        char *name = (char*)malloc(count);
 
753
        err = AudioDeviceGetProperty(devices[i], 0, false, kAudioDevicePropertyDeviceName, &count, name);
 
754
        if (err != kAudioHardwareNoError) {
 
755
            Server_error(self, "Get kAudioDevicePropertyDeviceName error %s A %d %08X\n", (char*)&err, i, devices[i]);
 
756
            free(name);
 
757
            break;
 
758
        }
 
759
        Server_message(self, "   %d : \"%s\"\n", i, name);
 
760
        free(name);
 
761
    }    
 
762
    
 
763
    /************************************/
 
764
    /* Acquire input and output devices */
 
765
    /************************************/    
 
766
    /* Acquire input audio device */    
 
767
    if (self->duplex == 1) {
 
768
        if (self->input != -1)
 
769
            mInputDevice = devices[self->input];
 
770
        
 
771
        if (mInputDevice==kAudioDeviceUnknown) {
 
772
            count = sizeof(mInputDevice);
 
773
            err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &count, (void *) &mInputDevice);
 
774
            if (err != kAudioHardwareNoError) {
 
775
                Server_error(self, "Get kAudioHardwarePropertyDefaultInputDevice error %s\n", (char*)&err);
 
776
                return -1;
 
777
            }
 
778
        }     
 
779
        
 
780
        err = AudioDeviceGetPropertyInfo(mInputDevice, 0, false, kAudioDevicePropertyDeviceName, &namelen, 0);
 
781
        if (err != kAudioHardwareNoError) {
 
782
            Server_error(self, "Info kAudioDevicePropertyDeviceName error %s A %08X\n", (char*)&err, mInputDevice);
 
783
        }    
 
784
        name = (char*)malloc(namelen);
 
785
        err = AudioDeviceGetProperty(mInputDevice, 0, false, kAudioDevicePropertyDeviceName, &namelen, name);
 
786
        if (err != kAudioHardwareNoError) {
 
787
            Server_error(self, "Get kAudioDevicePropertyDeviceName error %s A %08X\n", (char*)&err, mInputDevice);
 
788
        }
 
789
        Server_message(self, "Coreaudio : Uses input device : \"%s\"\n", name);
 
790
        self->input = mInputDevice;
 
791
        free(name);
 
792
    }    
 
793
    
 
794
    /* Acquire output audio device */    
 
795
    if (self->output != -1)
 
796
        mOutputDevice = devices[self->output];
 
797
        
 
798
    if (mOutputDevice==kAudioDeviceUnknown) {
 
799
        count = sizeof(mOutputDevice);
 
800
        err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &count, (void *) &mOutputDevice);
 
801
        if (err != kAudioHardwareNoError) {
 
802
            Server_error(self, "Get kAudioHardwarePropertyDefaultOutputDevice error %s\n", (char*)&err);
 
803
            return -1;
 
804
        }
 
805
    }
 
806
 
 
807
    err = AudioDeviceGetPropertyInfo(mOutputDevice, 0, false, kAudioDevicePropertyDeviceName, &namelen, 0);
 
808
    if (err != kAudioHardwareNoError) {
 
809
        Server_error(self, "Info kAudioDevicePropertyDeviceName error %s A %08X\n", (char*)&err, mOutputDevice);
 
810
    }    
 
811
    name = (char*)malloc(namelen);
 
812
    err = AudioDeviceGetProperty(mOutputDevice, 0, false, kAudioDevicePropertyDeviceName, &namelen, name);
 
813
    if (err != kAudioHardwareNoError) {
 
814
        Server_error(self, "Get kAudioDevicePropertyDeviceName error %s A %08X\n", (char*)&err, mOutputDevice);
 
815
    }
 
816
    Server_message(self, "Coreaudio : Uses output device : \"%s\"\n", name);
 
817
    self->output = mOutputDevice;
 
818
    free(name);
 
819
    
 
820
    /*************************************************/
 
821
    /* Get in/out buffer frame and buffer frame size */
 
822
    /*************************************************/
 
823
    UInt32 bufferSize;
 
824
    AudioValueRange range;
 
825
    Float64 sampleRate;
 
826
 
 
827
    /* Get input device buffer frame size and buffer frame size range */
 
828
    if (self->duplex == 1) {
 
829
        count = sizeof(UInt32);
 
830
        err = AudioDeviceGetProperty(mInputDevice, 0, false, kAudioDevicePropertyBufferFrameSize, &count, &bufferSize);
 
831
        if (err != kAudioHardwareNoError)
 
832
            Server_error(self, "Get kAudioDevicePropertyBufferFrameSize error %s\n", (char*)&err);
 
833
        Server_debug(self, "Coreaudio : Coreaudio input device buffer size = %ld\n", bufferSize);
 
834
    
 
835
        count = sizeof(AudioValueRange);
 
836
        err = AudioDeviceGetProperty(mInputDevice, 0, false, kAudioDevicePropertyBufferSizeRange, &count, &range);
 
837
        if (err != kAudioHardwareNoError)
 
838
            Server_error(self, "Get kAudioDevicePropertyBufferSizeRange error %s\n", (char*)&err);
 
839
        Server_debug(self, "Coreaudio : Coreaudio input device buffer size range = %f -> %f\n", range.mMinimum, range.mMaximum);
 
840
    
 
841
        /* Get input device sampling rate */
 
842
        count = sizeof(Float64);
 
843
        err = AudioDeviceGetProperty(mInputDevice, 0, false, kAudioDevicePropertyNominalSampleRate, &count, &sampleRate);
 
844
        if (err != kAudioHardwareNoError)
 
845
            Server_debug(self, "Get kAudioDevicePropertyNominalSampleRate error %s\n", (char*)&err);
 
846
        Server_debug(self, "Coreaudio : Coreaudio input device sampling rate = %.2f\n", sampleRate);
 
847
    }
 
848
    
 
849
    /* Get output device buffer frame size and buffer frame size range */
 
850
    count = sizeof(UInt32);
 
851
    err = AudioDeviceGetProperty(mOutputDevice, 0, false, kAudioDevicePropertyBufferFrameSize, &count, &bufferSize);
 
852
    if (err != kAudioHardwareNoError)
 
853
        Server_error(self, "Get kAudioDevicePropertyBufferFrameSize error %s\n", (char*)&err);
 
854
    Server_debug(self, "Coreaudio : Coreaudio output device buffer size = %ld\n", bufferSize);
 
855
 
 
856
    count = sizeof(AudioValueRange);
 
857
    err = AudioDeviceGetProperty(mOutputDevice, 0, false, kAudioDevicePropertyBufferSizeRange, &count, &range);
 
858
    if (err != kAudioHardwareNoError)
 
859
        Server_error(self, "Get kAudioDevicePropertyBufferSizeRange error %s\n", (char*)&err);
 
860
    Server_debug(self, "Coreaudio : Coreaudio output device buffer size range = %.2f -> %.2f\n", range.mMinimum, range.mMaximum);
 
861
    
 
862
    /* Get output device sampling rate */
 
863
    count = sizeof(Float64);
 
864
    err = AudioDeviceGetProperty(mOutputDevice, 0, false, kAudioDevicePropertyNominalSampleRate, &count, &sampleRate);
 
865
    if (err != kAudioHardwareNoError)
 
866
        Server_debug(self, "Get kAudioDevicePropertyNominalSampleRate error %s\n", (char*)&err);
 
867
    Server_debug(self, "Coreaudio : Coreaudio output device sampling rate = %.2f\n", sampleRate);
 
868
 
 
869
    
 
870
    /****************************************/
 
871
    /********* Set audio properties *********/
 
872
    /****************************************/
 
873
    /* set/get the buffersize for the devices */
 
874
    count = sizeof(UInt32);
 
875
    err = AudioDeviceSetProperty(mOutputDevice, &now, 0, false, kAudioDevicePropertyBufferFrameSize, count, &self->bufferSize);
 
876
    if (err != kAudioHardwareNoError) {
 
877
        Server_error(self, "set kAudioDevicePropertyBufferFrameSize error %4.4s\n", (char*)&err);
 
878
        self->bufferSize = bufferSize;
 
879
        err = AudioDeviceSetProperty(mOutputDevice, &now, 0, false, kAudioDevicePropertyBufferFrameSize, count, &self->bufferSize);
 
880
        if (err != kAudioHardwareNoError)
 
881
            Server_error(self, "set kAudioDevicePropertyBufferFrameSize error %4.4s\n", (char*)&err);
 
882
        else
 
883
            Server_message(self, "pyo buffer size set to output device buffer size : %i\n", self->bufferSize);
 
884
    } 
 
885
    else
 
886
        Server_message(self, "Coreaudio : Changed output device buffer size successfully: %i\n", self->bufferSize);
 
887
 
 
888
    if (self->duplex == 1) {
 
889
        err = AudioDeviceSetProperty(mInputDevice, &now, 0, false, kAudioDevicePropertyBufferFrameSize, count, &self->bufferSize);
 
890
        if (err != kAudioHardwareNoError) {
 
891
            Server_error(self, "set kAudioDevicePropertyBufferFrameSize error %4.4s\n", (char*)&err);
 
892
        }    
 
893
    }    
 
894
 
 
895
    /* set/get the sampling rate for the devices */
 
896
    count = sizeof(double);
 
897
    double pyoSamplingRate = self->samplingRate;
 
898
    err = AudioDeviceSetProperty(mOutputDevice, &now, 0, false, kAudioDevicePropertyNominalSampleRate, count, &pyoSamplingRate);
 
899
    if (err != kAudioHardwareNoError) {
 
900
        Server_error(self, "set kAudioDevicePropertyNominalSampleRate error %s\n", (char*)&err);
 
901
        self->samplingRate = (double)sampleRate;        
 
902
        err = AudioDeviceSetProperty(mOutputDevice, &now, 0, false, kAudioDevicePropertyNominalSampleRate, count, &sampleRate);
 
903
        if (err != kAudioHardwareNoError)
 
904
            Server_error(self, "set kAudioDevicePropertyNominalSampleRate error %s\n", (char*)&err);
 
905
        else    
 
906
            Server_message(self, "pyo sampling rate set to output device sampling rate : %i\n", self->samplingRate);
 
907
    }
 
908
    else
 
909
        Server_message(self, "Coreaudio : Changed output device sampling rate successfully: %.2f\n", self->samplingRate);
 
910
    
 
911
    if (self->duplex ==1) {
 
912
        pyoSamplingRate = self->samplingRate;
 
913
        err = AudioDeviceSetProperty(mInputDevice, &now, 0, false, kAudioDevicePropertyNominalSampleRate, count, &pyoSamplingRate);
 
914
        if (err != kAudioHardwareNoError) {
 
915
            Server_error(self, "set kAudioDevicePropertyNominalSampleRate error %s\n", (char*)&err);
 
916
        }
 
917
    }    
 
918
 
 
919
 
 
920
    /****************************************/
 
921
    /* Input and output stream descriptions */
 
922
    /****************************************/
 
923
    AudioStreamBasicDescription outputStreamDescription;
 
924
    AudioStreamBasicDescription inputStreamDescription;
 
925
 
 
926
    // Get input device stream configuration
 
927
    if (self->duplex == 1) {
 
928
        count = sizeof(AudioStreamBasicDescription);
 
929
        err = AudioDeviceGetProperty(mInputDevice, 0, true, kAudioDevicePropertyStreamFormat, &count, &inputStreamDescription);
 
930
        if (err != kAudioHardwareNoError)
 
931
            Server_debug(self, "Get kAudioDevicePropertyStreamFormat error %s\n", (char*)&err);
 
932
    
 
933
        /*
 
934
        inputStreamDescription.mSampleRate = (Float64)self->samplingRate;
 
935
    
 
936
        err = AudioDeviceSetProperty(mInputDevice, &now, 0, false, kAudioDevicePropertyStreamFormat, count, &inputStreamDescription);
 
937
        if (err != kAudioHardwareNoError)
 
938
            Server_debug(self, "-- Set kAudioDevicePropertyStreamFormat error %s\n", (char*)&err);
 
939
    
 
940
        // Print new input stream description
 
941
        err = AudioDeviceGetProperty(mInputDevice, 0, true, kAudioDevicePropertyStreamFormat, &count, &inputStreamDescription);
 
942
        if (err != kAudioHardwareNoError)
 
943
            Server_debug(self, "Get kAudioDevicePropertyNominalSampleRate error %s\n", (char*)&err);
 
944
        */
 
945
        Server_debug(self, "Coreaudio : Coreaudio driver input stream sampling rate = %.2f\n", inputStreamDescription.mSampleRate);
 
946
        Server_debug(self, "Coreaudio : Coreaudio driver input stream bytes per frame = %i\n", inputStreamDescription.mBytesPerFrame);
 
947
        Server_debug(self, "Coreaudio : Coreaudio driver input stream number of channels = %i\n", inputStreamDescription.mChannelsPerFrame);
 
948
    }
 
949
    
 
950
    /* Get output device stream configuration */
 
951
    count = sizeof(AudioStreamBasicDescription);
 
952
        err = AudioDeviceGetProperty(mOutputDevice, 0, false, kAudioDevicePropertyStreamFormat, &count, &outputStreamDescription);
 
953
    if (err != kAudioHardwareNoError)
 
954
        Server_debug(self, "Get kAudioDevicePropertyStreamFormat error %s\n", (char*)&err);
 
955
 
 
956
    /*
 
957
    outputStreamDescription.mSampleRate = (Float64)self->samplingRate;
 
958
    
 
959
        err = AudioDeviceSetProperty(mOutputDevice, &now, 0, false, kAudioDevicePropertyStreamFormat, count, &outputStreamDescription);
 
960
    if (err != kAudioHardwareNoError)
 
961
        Server_debug(self, "Set kAudioDevicePropertyStreamFormat error %s\n", (char*)&err);
 
962
    
 
963
    // Print new output stream description
 
964
        err = AudioDeviceGetProperty(mOutputDevice, 0, false, kAudioDevicePropertyStreamFormat, &count, &outputStreamDescription);
 
965
    if (err != kAudioHardwareNoError)
 
966
        Server_debug(self, "Get kAudioDevicePropertyStreamFormat error %s\n", (char*)&err);
 
967
    */
 
968
    Server_debug(self, "Coreaudio : Coreaudio driver output stream sampling rate = %.2f\n", outputStreamDescription.mSampleRate);
 
969
    Server_debug(self, "Coreaudio : Coreaudio driver output stream bytes per frame = %i\n", outputStreamDescription.mBytesPerFrame);
 
970
    Server_debug(self, "Coreaudio : Coreaudio driver output stream number of channels = %i\n", outputStreamDescription.mChannelsPerFrame);
 
971
 
 
972
 
 
973
    /**************************************************/
 
974
    /********* Set input and output callbacks *********/
 
975
    /**************************************************/
 
976
    if (self->duplex == 1) {
 
977
        err = AudioDeviceAddIOProc(self->input, coreaudio_input_callback, (void *) self);       // setup our device with an IO proc
 
978
        if (err != kAudioHardwareNoError) {
 
979
            Server_error(self, "Input AudioDeviceAddIOProc failed %d\n", (int)err);
 
980
            return -1;
 
981
        }        
 
982
        err = AudioDeviceGetPropertyInfo(self->input, 0, true, kAudioDevicePropertyIOProcStreamUsage, &propertySize, &writable);
 
983
        AudioHardwareIOProcStreamUsage *input_su = (AudioHardwareIOProcStreamUsage*)malloc(propertySize);
 
984
        input_su->mIOProc = (void*)coreaudio_input_callback;
 
985
        err = AudioDeviceGetProperty(self->input, 0, true, kAudioDevicePropertyIOProcStreamUsage, &propertySize, input_su);
 
986
        for (i=0; i<inputStreamDescription.mChannelsPerFrame; ++i) {
 
987
            input_su->mStreamIsOn[i] = 1;
 
988
        }
 
989
        err = AudioDeviceSetProperty(self->input, &now, 0, true, kAudioDevicePropertyIOProcStreamUsage, propertySize, input_su);
 
990
    }
 
991
    
 
992
    err = AudioDeviceAddIOProc(self->output, coreaudio_output_callback, (void *) self); // setup our device with an IO proc
 
993
    if (err != kAudioHardwareNoError) {
 
994
        Server_error(self, "Output AudioDeviceAddIOProc failed %d\n", (int)err);
 
995
        return -1;
 
996
    }
 
997
    err = AudioDeviceGetPropertyInfo(self->output, 0, false, kAudioDevicePropertyIOProcStreamUsage, &propertySize, &writable);
 
998
    AudioHardwareIOProcStreamUsage *output_su = (AudioHardwareIOProcStreamUsage*)malloc(propertySize);
 
999
    output_su->mIOProc = (void*)coreaudio_output_callback;
 
1000
    err = AudioDeviceGetProperty(self->output, 0, false, kAudioDevicePropertyIOProcStreamUsage, &propertySize, output_su);
 
1001
    for (i=0; i<outputStreamDescription.mChannelsPerFrame; ++i) {
 
1002
        output_su->mStreamIsOn[i] = 1;
 
1003
    }
 
1004
    err = AudioDeviceSetProperty(self->output, &now, 0, false, kAudioDevicePropertyIOProcStreamUsage, propertySize, output_su);
 
1005
    
 
1006
    return 0;
 
1007
}
 
1008
 
 
1009
int 
 
1010
Server_coreaudio_deinit(Server *self)
 
1011
{
 
1012
    OSStatus err = kAudioHardwareNoError;
 
1013
 
 
1014
    if (self->duplex == 1) {
 
1015
        err = AudioDeviceRemoveIOProc(self->input, coreaudio_input_callback);
 
1016
        if (err != kAudioHardwareNoError) {
 
1017
            Server_error(self, "Input AudioDeviceRemoveIOProc failed %d\n", (int)err);
 
1018
            return -1;
 
1019
        }    
 
1020
    }
 
1021
    
 
1022
    err = AudioDeviceRemoveIOProc(self->output, coreaudio_output_callback);
 
1023
    if (err != kAudioHardwareNoError) {
 
1024
        Server_error(self, "Output AudioDeviceRemoveIOProc failed %d\n", (int)err);
 
1025
        return -1;
 
1026
    }
 
1027
    
 
1028
    return 0;
 
1029
}
 
1030
 
 
1031
int 
 
1032
Server_coreaudio_start(Server *self)
 
1033
{
 
1034
    OSStatus err = kAudioHardwareNoError;
 
1035
 
 
1036
    if (self->duplex == 1) {
 
1037
        err = AudioDeviceStart(self->input, coreaudio_input_callback);
 
1038
        if (err != kAudioHardwareNoError) {
 
1039
            Server_error(self, "Input AudioDeviceStart failed %d\n", (int)err);
 
1040
            return -1;
 
1041
        }        
 
1042
    }
 
1043
    
 
1044
    err = AudioDeviceStart(self->output, coreaudio_output_callback);
 
1045
    if (err != kAudioHardwareNoError) {
 
1046
        Server_error(self, "Output AudioDeviceStart failed %d\n", (int)err);
 
1047
        return -1;
 
1048
    }
 
1049
    return 0;
 
1050
} 
 
1051
 
 
1052
int
 
1053
Server_coreaudio_stop(Server *self)
 
1054
{
 
1055
    self->timeStep = (int)(0.1 * self->samplingRate);
 
1056
    self->amp = 0.;
 
1057
    self->server_stopped = 1;
 
1058
    return 0;
 
1059
}
 
1060
 
 
1061
#endif
 
1062
 
 
1063
int
 
1064
Server_offline_init (Server *self)
 
1065
{
 
1066
    return 0;
 
1067
}
 
1068
 
 
1069
int
 
1070
Server_offline_deinit (Server *self)
 
1071
{
 
1072
    return 0;
 
1073
}
 
1074
 
 
1075
int
 
1076
Server_offline_start (Server *self)
 
1077
{
 
1078
    if (self->recdur < 0) {
 
1079
        Server_error(self,"Duration must be specified for Offline Server (see Server.recordOptions).");
 
1080
        return -1;
 
1081
    }
 
1082
    Server_message(self,"Offline Server rendering file %s dur=%f\n", self->recpath, self->recdur);
 
1083
    int numBlocks = ceil(self->recdur * self->samplingRate/self->bufferSize);
 
1084
    Server_debug(self,"Number of blocks: %i\n", numBlocks);
 
1085
    Server_start_rec_internal(self, self->recpath);
 
1086
    while (numBlocks-- > 0 && self->server_stopped == 0) {
 
1087
        offline_process_block((Server *) self);   
 
1088
    }
 
1089
    self->server_started = 0;
 
1090
    self->record = 0;
 
1091
    sf_close(self->recfile);
 
1092
    Server_message(self,"Offline Server rendering finished.\n"); 
 
1093
    return 0;
 
1094
}
 
1095
 
 
1096
int
 
1097
Server_offline_stop (Server *self)
 
1098
{
 
1099
    self->server_stopped = 1;
 
1100
    return 0;
 
1101
}
 
1102
 
 
1103
/***************************************************/
 
1104
/*  Main Processing functions                      */
 
1105
 
 
1106
static inline void
 
1107
Server_process_buffers(Server *server)
 
1108
{
 
1109
    float *out = server->output_buffer;    
 
1110
    MYFLT buffer[server->nchnls][server->bufferSize];
 
1111
    int i, j, chnl;
 
1112
    int count = server->stream_count;
 
1113
    int nchnls = server->nchnls;
 
1114
    MYFLT amp = server->amp;
 
1115
    Stream *stream_tmp;
 
1116
    MYFLT *data;
 
1117
 
 
1118
    memset(&buffer, 0, sizeof(buffer));
 
1119
    PyGILState_STATE s = PyGILState_Ensure();
 
1120
    for (i=0; i<count; i++) {
 
1121
        stream_tmp = (Stream *)PyList_GET_ITEM(server->streams, i);
 
1122
        if (Stream_getStreamActive(stream_tmp) == 1) {
 
1123
            Stream_callFunction(stream_tmp);
 
1124
            if (Stream_getStreamToDac(stream_tmp) != 0) {
 
1125
                data = Stream_getData(stream_tmp);
 
1126
                chnl = Stream_getStreamChnl(stream_tmp);
 
1127
                for (j=0; j < server->bufferSize; j++) {
 
1128
                    buffer[chnl][j] += *data++;
 
1129
                }
 
1130
            }
 
1131
            if (Stream_getDuration(stream_tmp) != 0) {
 
1132
                Stream_IncrementDurationCount(stream_tmp);
 
1133
            }    
 
1134
        }
 
1135
        else if (Stream_getBufferCountWait(stream_tmp) != 0)
 
1136
            Stream_IncrementBufferCount(stream_tmp);
 
1137
    }
 
1138
    if (server->withGUI == 1 && nchnls <= 8) {
 
1139
        Server_process_gui(server);
 
1140
    }
 
1141
    if (server->withTIME == 1) {
 
1142
        Server_process_time(server);
 
1143
    }
 
1144
    server->elapsedSamples += server->bufferSize;
 
1145
    PyGILState_Release(s);
 
1146
    if (amp != server->lastAmp) {
 
1147
        server->timeCount = 0;
 
1148
        server->stepVal = (amp - server->currentAmp) / server->timeStep;
 
1149
        server->lastAmp = amp;
 
1150
    }
 
1151
    
 
1152
    for (i=0; i < server->bufferSize; i++){
 
1153
        if (server->timeCount < server->timeStep) {
 
1154
            server->currentAmp += server->stepVal;
 
1155
            server->timeCount++;
 
1156
        }
 
1157
        for (j=0; j<server->nchnls; j++) {
 
1158
            out[(i*server->nchnls)+j] = (float)buffer[j][i] * server->currentAmp;
 
1159
        }
 
1160
    }
 
1161
    if (server->record == 1)
 
1162
        sf_write_float(server->recfile, out, server->bufferSize * server->nchnls);
 
1163
 
 
1164
}
 
1165
 
 
1166
static void
 
1167
Server_process_gui(Server *server)
 
1168
{
 
1169
    float rms[server->nchnls];
 
1170
    float *out = server->output_buffer;
 
1171
    float outAmp;
 
1172
    int i,j;
 
1173
    for (j=0; j<server->nchnls; j++) {
 
1174
        rms[j] = 0.0;
 
1175
        for (i=0; i<server->bufferSize; i++) {
 
1176
            outAmp = out[(i*server->nchnls)+j];
 
1177
            outAmp *= outAmp;
 
1178
            if (outAmp > rms[j])
 
1179
                rms[j] = outAmp;
 
1180
        }
 
1181
    }    
 
1182
    if (server->gcount <= server->numPass) {
 
1183
        for (j=0; j<server->nchnls; j++) {            
 
1184
            server->lastRms[j] = (rms[j] + server->lastRms[j]) * 0.5;
 
1185
        }    
 
1186
        server->gcount++;
 
1187
    }
 
1188
    else {
 
1189
        for (j=0; j<server->nchnls; j++) {            
 
1190
            server->lastRms[j] = (rms[j] + server->lastRms[j]) * 0.5;
 
1191
        }  
 
1192
        switch (server->nchnls) {
 
1193
            case 1:
 
1194
                PyObject_CallMethod((PyObject *)server->GUI, "setRms", "f", server->lastRms[0]);
 
1195
                break;
 
1196
            case 2:
 
1197
                PyObject_CallMethod((PyObject *)server->GUI, "setRms", "ff", server->lastRms[0], server->lastRms[1]);
 
1198
                break;
 
1199
            case 3:
 
1200
                PyObject_CallMethod((PyObject *)server->GUI, "setRms", "fff", server->lastRms[0], server->lastRms[1], server->lastRms[2]);
 
1201
                break;
 
1202
            case 4:
 
1203
                PyObject_CallMethod((PyObject *)server->GUI, "setRms", "ffff", server->lastRms[0], server->lastRms[1], server->lastRms[2], server->lastRms[3]);
 
1204
                break;
 
1205
            case 5:
 
1206
                PyObject_CallMethod((PyObject *)server->GUI, "setRms", "fffff", server->lastRms[0], server->lastRms[1], server->lastRms[2], server->lastRms[3], server->lastRms[4]);
 
1207
                break;
 
1208
            case 6:
 
1209
                PyObject_CallMethod((PyObject *)server->GUI, "setRms", "ffffff", server->lastRms[0], server->lastRms[1], server->lastRms[2], server->lastRms[3], server->lastRms[4], server->lastRms[5]);
 
1210
                break;
 
1211
            case 7:
 
1212
                PyObject_CallMethod((PyObject *)server->GUI, "setRms", "fffffff", server->lastRms[0], server->lastRms[1], server->lastRms[2], server->lastRms[3], server->lastRms[4], server->lastRms[5], server->lastRms[6]);
 
1213
                break;
 
1214
            case 8:
 
1215
                PyObject_CallMethod((PyObject *)server->GUI, "setRms", "ffffffff", server->lastRms[0], server->lastRms[1], server->lastRms[2], server->lastRms[3], server->lastRms[4], server->lastRms[5], server->lastRms[6], server->lastRms[7]);
 
1216
                break;
 
1217
        }        
 
1218
        server->gcount = 0;
 
1219
    }
 
1220
}
 
1221
 
 
1222
static void
 
1223
Server_process_time(Server *server)
 
1224
{
 
1225
    int hours, minutes, seconds, milliseconds;
 
1226
    float sr = server->samplingRate;
 
1227
    double sampsToSecs;
 
1228
    
 
1229
    if (server->tcount <= server->timePass) {
 
1230
        server->tcount++;
 
1231
    }
 
1232
    else {
 
1233
        sampsToSecs = (double)(server->elapsedSamples / sr);
 
1234
        seconds = (int)sampsToSecs;
 
1235
        milliseconds = (int)((sampsToSecs - seconds) * 1000);
 
1236
        minutes = seconds / 60;
 
1237
        hours = minutes / 60;
 
1238
        minutes = minutes % 60;
 
1239
        seconds = seconds % 60;
 
1240
        PyObject_CallMethod((PyObject *)server->TIME, "setTime", "iiii", hours, minutes, seconds, milliseconds);   
 
1241
        server->tcount = 0;
 
1242
    }
 
1243
}
 
1244
 
 
1245
/***************************************************/
 
1246
 
 
1247
/* Global function called by any new audio object to 
 
1248
 get a pointer to the server */
 
1249
PyObject *
 
1250
PyServer_get_server()
 
1251
{
 
1252
    return (PyObject *)my_server;
 
1253
}
 
1254
 
 
1255
static PyObject *
 
1256
Server_shut_down(Server *self)
 
1257
{
 
1258
    int i;
 
1259
    int ret = -1;
 
1260
    if (self->server_booted == 0) {
 
1261
        Server_error(self, "The Server must be booted!");
 
1262
        Py_INCREF(Py_None);
 
1263
        return Py_None;
 
1264
    }
 
1265
    if (self->server_started == 1) {
 
1266
        Server_stop((Server *)self);
 
1267
    }
 
1268
    
 
1269
    for (i=0; i<num_rnd_objs; i++) {
 
1270
        rnd_objs_count[i] = 0;
 
1271
    }
 
1272
 
 
1273
    switch (self->audio_be_type) {
 
1274
        case PyoPortaudio:
 
1275
            ret = Server_pa_deinit(self);
 
1276
            break;     
 
1277
        case PyoCoreaudio:
 
1278
#ifdef USE_COREAUDIO       
 
1279
            ret = Server_coreaudio_deinit(self);
 
1280
#endif      
 
1281
            break;          
 
1282
        case PyoJack:    
 
1283
#ifdef USE_JACK    
 
1284
            ret = Server_jack_deinit(self);
 
1285
#endif 
 
1286
            break;       
 
1287
        case PyoOffline:
 
1288
            ret = Server_offline_deinit(self);  
 
1289
            break;         
 
1290
    }
 
1291
    self->server_booted = 0;
 
1292
    if (ret < 0) {
 
1293
        Server_error(self, "Error closing audio backend.\n");
 
1294
    }
 
1295
    
 
1296
    if (self->withPortMidi == 1) {
 
1297
        Pm_Close(self->in);
 
1298
        Pm_Terminate();
 
1299
    }
 
1300
    
 
1301
    Py_INCREF(Py_None);
 
1302
    return Py_None;
 
1303
}
 
1304
 
 
1305
static int
 
1306
Server_traverse(Server *self, visitproc visit, void *arg)
 
1307
{
 
1308
    Py_VISIT(self->streams);
 
1309
    return 0;
 
1310
}
 
1311
 
 
1312
static int 
 
1313
Server_clear(Server *self)
 
1314
{    
 
1315
    Py_CLEAR(self->streams);
 
1316
    return 0;
 
1317
}
 
1318
 
 
1319
static void
 
1320
Server_dealloc(Server* self)
 
1321
{  
 
1322
    Server_shut_down(self);
 
1323
    Server_clear(self);
 
1324
    free(self->input_buffer);
 
1325
    free(self->serverName);
 
1326
    self->ob_type->tp_free((PyObject*)self);
 
1327
}
 
1328
 
 
1329
static PyObject *
 
1330
Server_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 
1331
{
 
1332
    if (PyServer_get_server() != NULL) {
 
1333
        Server_warning((Server *) PyServer_get_server(), "Warning: A Server is already created!\n"
 
1334
            "If you put this Server in a new variable, please delete it!\n");
 
1335
        return PyServer_get_server();
 
1336
    }    
 
1337
    Server *self;
 
1338
    self = (Server *)type->tp_alloc(type, 0);
 
1339
    self->server_booted = 0;
 
1340
    self->audio_be_data = NULL;
 
1341
    self->serverName = (char *) calloc(32, sizeof(char));
 
1342
    self->samplingRate = 44100.0;
 
1343
    self->nchnls = 2;
 
1344
    self->record = 0;
 
1345
    self->bufferSize = 256;
 
1346
    self->duplex = 0;
 
1347
    self->input = -1;
 
1348
    self->output = -1;
 
1349
    self->midi_input = -1;
 
1350
    self->amp = self->resetAmp = 1.;
 
1351
    self->currentAmp = self->lastAmp = 0.;
 
1352
    self->withGUI = 0;
 
1353
    self->withTIME = 0;
 
1354
    self->verbosity = 7;
 
1355
    self->recdur = -1;
 
1356
    self->recformat = 0;
 
1357
    self->rectype = 0;
 
1358
    self->startoffset = 0.0;
 
1359
    self->globalSeed = 0;
 
1360
    Py_XDECREF(my_server);
 
1361
    Py_XINCREF(self);
 
1362
    my_server = (Server *)self;
 
1363
    return (PyObject *)self;
 
1364
}
 
1365
 
 
1366
static int
 
1367
Server_init(Server *self, PyObject *args, PyObject *kwds)
 
1368
{
 
1369
    static char *kwlist[] = {"sr", "nchnls", "buffersize", "duplex", "audio", "jackname", NULL};
 
1370
    
 
1371
    char *audioType = "portaudio";
 
1372
    char *serverName = "pyo";
 
1373
 
 
1374
    //Server_debug(self, "Server_init. Compiled " TIMESTAMP "\n");  // Only for debugging purposes
 
1375
    if (! PyArg_ParseTupleAndKeywords(args, kwds, "|diiiss", kwlist, 
 
1376
            &self->samplingRate, &self->nchnls, &self->bufferSize, &self->duplex, &audioType, &serverName))
 
1377
        return -1;
 
1378
    if (strcmp(audioType, "jack") == 0) {
 
1379
        self->audio_be_type = PyoJack;
 
1380
    }
 
1381
    else if (strcmp(audioType, "portaudio") == 0 || strcmp(audioType, "pa") == 0 ) {
 
1382
        self->audio_be_type = PyoPortaudio;
 
1383
    }
 
1384
    else if (strcmp(audioType, "coreaudio") == 0) {
 
1385
        self->audio_be_type = PyoCoreaudio;
 
1386
    }    
 
1387
    else if (strcmp(audioType, "offline") == 0) {
 
1388
        self->audio_be_type = PyoOffline;
 
1389
    } 
 
1390
    else {
 
1391
        Server_warning(self, "Unknown audio type. Using Portaudio\n");
 
1392
        self->audio_be_type = PyoPortaudio;
 
1393
    }
 
1394
    strncpy(self->serverName, serverName, 32);
 
1395
    if (strlen(serverName) > 31) {
 
1396
        self->serverName[31] = '\0';
 
1397
    }
 
1398
    self->recpath = getenv("HOME");
 
1399
    if (self->recpath != NULL)
 
1400
        strncat(self->recpath, "/pyo_rec.wav", strlen("/pyo_rec.wav")); 
 
1401
    return 0;
 
1402
}
 
1403
 
 
1404
 
 
1405
static PyObject *
 
1406
Server_setInputDevice(Server *self, PyObject *arg)
 
1407
{
 
1408
        if (arg != NULL) {
 
1409
        if (PyInt_Check(arg))
 
1410
            self->input = PyInt_AsLong(arg);
 
1411
    }
 
1412
    Py_INCREF(Py_None);
 
1413
    return Py_None;
 
1414
}
 
1415
 
 
1416
static PyObject *
 
1417
Server_setInOutDevice(Server *self, PyObject *arg)
 
1418
{
 
1419
        if (arg != NULL) {
 
1420
        if (PyInt_Check(arg))
 
1421
            self->input = PyInt_AsLong(arg);
 
1422
            self->output = PyInt_AsLong(arg);
 
1423
    }
 
1424
    Py_INCREF(Py_None);
 
1425
    return Py_None;
 
1426
}
 
1427
 
 
1428
static PyObject *
 
1429
Server_setOutputDevice(Server *self, PyObject *arg)
 
1430
{
 
1431
        if (arg != NULL) {
 
1432
        if (PyInt_Check(arg))
 
1433
            self->output = PyInt_AsLong(arg);
 
1434
    }
 
1435
    Py_INCREF(Py_None);
 
1436
    return Py_None;
 
1437
}
 
1438
 
 
1439
static PyObject *
 
1440
Server_setMidiInputDevice(Server *self, PyObject *arg)
 
1441
{
 
1442
        if (arg != NULL) {
 
1443
        if (PyInt_Check(arg))
 
1444
            self->midi_input = PyInt_AsLong(arg);
 
1445
    }
 
1446
    Py_INCREF(Py_None);
 
1447
    return Py_None;
 
1448
}
 
1449
 
 
1450
static PyObject *
 
1451
Server_setSamplingRate(Server *self, PyObject *arg)
 
1452
{
 
1453
    if (self->server_booted) {
 
1454
        Server_warning(self, "Can't change sampling rate for booted server.\n");
 
1455
        Py_INCREF(Py_None);
 
1456
        return Py_None;
 
1457
    }
 
1458
    if (arg != NULL && PyNumber_Check(arg)) {
 
1459
        self->samplingRate = PyFloat_AsDouble(PyNumber_Float(arg));
 
1460
    }
 
1461
    else {
 
1462
        Server_error(self, "Sampling rate must be a number.\n");
 
1463
    }
 
1464
    Py_INCREF(Py_None);
 
1465
    return Py_None;
 
1466
}
 
1467
 
 
1468
static PyObject *
 
1469
Server_setNchnls(Server *self, PyObject *arg)
 
1470
{
 
1471
    if (self->server_booted) {
 
1472
        Server_warning(self, "Can't change number of channels for booted server.\n");
 
1473
        Py_INCREF(Py_None);
 
1474
        return Py_None;
 
1475
    }
 
1476
    if (arg != NULL && PyInt_Check(arg)) {
 
1477
        self->nchnls = PyInt_AsLong(arg);
 
1478
    }
 
1479
    else {
 
1480
        Server_error(self, "Number of channels must be an integer.\n");
 
1481
    }
 
1482
    Py_INCREF(Py_None);
 
1483
    return Py_None;
 
1484
}
 
1485
 
 
1486
static PyObject *
 
1487
Server_setBufferSize(Server *self, PyObject *arg)
 
1488
{
 
1489
    if (self->server_booted) {
 
1490
        Server_warning(self, "Can't change buffer size for booted server.\n");
 
1491
        Py_INCREF(Py_None);
 
1492
        return Py_None;
 
1493
    }
 
1494
    if (arg != NULL && PyInt_Check(arg)) {
 
1495
        self->bufferSize = PyInt_AsLong(arg);
 
1496
    }
 
1497
    else {
 
1498
        Server_error(self, "Buffer size must be an integer.\n");
 
1499
    }
 
1500
    Py_INCREF(Py_None);
 
1501
    return Py_None;
 
1502
}
 
1503
 
 
1504
static PyObject *
 
1505
Server_setDuplex(Server *self, PyObject *arg)
 
1506
{
 
1507
    if (self->server_booted) {
 
1508
        Server_warning(self,"Can't change duplex mode for booted server.\n");
 
1509
        Py_INCREF(Py_None);
 
1510
        return Py_None;
 
1511
    }
 
1512
    if (arg != NULL) {
 
1513
        if (PyInt_Check(arg))
 
1514
            self->duplex = PyInt_AsLong(arg);
 
1515
    }
 
1516
    Py_INCREF(Py_None);
 
1517
    return Py_None;
 
1518
}
 
1519
 
 
1520
static PyObject *
 
1521
Server_setGlobalSeed(Server *self, PyObject *arg)
 
1522
{
 
1523
    unsigned int tmp;
 
1524
    
 
1525
    if (arg != NULL) {
 
1526
        if (PyInt_Check(arg)) {
 
1527
            tmp = PyInt_AsLong(arg);
 
1528
            if (tmp < 0)
 
1529
                self->globalSeed = 0;
 
1530
            else
 
1531
                self->globalSeed = tmp;
 
1532
        }
 
1533
        else
 
1534
            self->globalSeed = 0;
 
1535
    }
 
1536
    else
 
1537
        self->globalSeed = 0;
 
1538
    
 
1539
    Py_INCREF(Py_None);
 
1540
    return Py_None;
 
1541
}
 
1542
 
 
1543
int
 
1544
Server_generateSeed(Server *self, int oid)
 
1545
{
 
1546
    int curseed, seed, count, mult;
 
1547
    long ltime;
 
1548
 
 
1549
    count = ++rnd_objs_count[oid];
 
1550
    mult = rnd_objs_mult[oid];
 
1551
 
 
1552
    if (self->globalSeed > 0) {
 
1553
        curseed = self->globalSeed + ((count * mult) % 32768);
 
1554
    }
 
1555
    else {
 
1556
        ltime = time(NULL);
 
1557
        seed = (unsigned) (ltime / 2) % 32768;
 
1558
        curseed = seed + ((count * mult) % 32768);
 
1559
    }
 
1560
    srand(curseed);
 
1561
 
 
1562
    return 0;
 
1563
}
 
1564
 
 
1565
static PyObject *
 
1566
Server_setAmp(Server *self, PyObject *arg)
 
1567
{
 
1568
    if (arg != NULL) {
 
1569
        int check = PyNumber_Check(arg);
 
1570
        
 
1571
        if (check) {
 
1572
            self->amp = PyFloat_AsDouble(PyNumber_Float(arg));
 
1573
            if (self->amp != 0.0)
 
1574
                self->resetAmp = self->amp;
 
1575
        }
 
1576
    }
 
1577
    Py_INCREF(Py_None);
 
1578
    return Py_None;
 
1579
}
 
1580
 
 
1581
static PyObject *
 
1582
Server_setAmpCallable(Server *self, PyObject *arg)
 
1583
{
 
1584
    int i;
 
1585
    PyObject *tmp;
 
1586
    
 
1587
    if (arg == NULL) {
 
1588
        Server_error(self,"The amplitude callable attribute must be a method.\n");
 
1589
        Py_INCREF(Py_None);
 
1590
        return Py_None;
 
1591
    }
 
1592
    
 
1593
    tmp = arg;
 
1594
    Py_XDECREF(self->GUI);
 
1595
    Py_INCREF(tmp);
 
1596
    self->GUI = tmp;
 
1597
 
 
1598
    self->lastRms = (float *)realloc(self->lastRms, self->nchnls * sizeof(float));
 
1599
    for (i=0; i<self->nchnls; i++) {
 
1600
        self->lastRms[i] = 0.0;
 
1601
    }
 
1602
    
 
1603
    for (i=1; i<100; i++) {
 
1604
        if ((self->bufferSize * i / self->samplingRate) > 0.045) {
 
1605
            self->numPass = i;
 
1606
            break;
 
1607
        }
 
1608
    } 
 
1609
    self->gcount = 0;
 
1610
    self->withGUI = 1;
 
1611
    
 
1612
    Py_INCREF(Py_None);
 
1613
    return Py_None;
 
1614
}
 
1615
 
 
1616
static PyObject *
 
1617
Server_setTimeCallable(Server *self, PyObject *arg)
 
1618
{
 
1619
    int i;
 
1620
    PyObject *tmp;
 
1621
    
 
1622
    if (arg == NULL) {
 
1623
        Server_error(self,"The time callable attribute must be a method.\n");
 
1624
        Py_INCREF(Py_None);
 
1625
        return Py_None;
 
1626
    }
 
1627
    
 
1628
    tmp = arg;
 
1629
    Py_XDECREF(self->TIME);
 
1630
    Py_INCREF(tmp);
 
1631
    self->TIME = tmp;
 
1632
 
 
1633
    for (i=1; i<100; i++) {
 
1634
        if ((self->bufferSize * i / self->samplingRate) > 0.06) {
 
1635
            self->timePass = i;
 
1636
            break;
 
1637
        }
 
1638
    } 
 
1639
    self->tcount = 0;
 
1640
    self->withTIME = 1;
 
1641
    
 
1642
    Py_INCREF(Py_None);
 
1643
    return Py_None;
 
1644
}
 
1645
 
 
1646
static PyObject *
 
1647
Server_setVerbosity(Server *self, PyObject *arg)
 
1648
{
 
1649
    if (arg != NULL) {
 
1650
        int check = PyInt_Check(arg);
 
1651
        
 
1652
        if (check) {
 
1653
            self->verbosity = PyInt_AsLong(arg);
 
1654
        }
 
1655
    }
 
1656
    
 
1657
    Py_INCREF(Py_None);
 
1658
    return Py_None;
 
1659
}
 
1660
 
 
1661
static PyObject *
 
1662
Server_setStartOffset(Server *self, PyObject *arg)
 
1663
{
 
1664
    if (arg != NULL) {
 
1665
        int check = PyNumber_Check(arg);
 
1666
        
 
1667
        if (check) {
 
1668
            self->startoffset = PyFloat_AsDouble(PyNumber_Float(arg));
 
1669
        }
 
1670
    }
 
1671
    
 
1672
    Py_INCREF(Py_None);
 
1673
    return Py_None;
 
1674
}
 
1675
 
 
1676
int
 
1677
Server_pm_init(Server *self)
 
1678
{
 
1679
   /* Initializing MIDI */    
 
1680
    PmError pmerr;
 
1681
 
 
1682
    pmerr = Pm_Initialize();
 
1683
    if (pmerr) {
 
1684
        Server_warning(self, "PortMidi warning: could not initialize PortMidi: %s\n", Pm_GetErrorText(pmerr));
 
1685
        self->withPortMidi = 0;
 
1686
        return -1;
 
1687
    }    
 
1688
    else {
 
1689
        Server_debug(self, "PortMidi initialized.\n");
 
1690
        self->withPortMidi = 1;
 
1691
    }    
 
1692
 
 
1693
    if (self->withPortMidi == 1) {
 
1694
        int num_devices = Pm_CountDevices();
 
1695
        if (num_devices > 0) {
 
1696
            if (self->midi_input == -1 || self->midi_input >= num_devices)
 
1697
                self->midi_input = 0;
 
1698
            const PmDeviceInfo *info = Pm_GetDeviceInfo(self->midi_input);
 
1699
            if (info->input) {
 
1700
                pmerr = Pm_OpenInput(&self->in, self->midi_input, NULL, 100, NULL, NULL);
 
1701
                if (pmerr) {
 
1702
                    Server_warning(self, 
 
1703
                                 "PortMidi warning: could not open midi input %d (%s): %s\nPortmidi closed\n",
 
1704
                                 0, info->name, Pm_GetErrorText(pmerr));
 
1705
                    self->withPortMidi = 0;
 
1706
                    Pm_Terminate();
 
1707
                }    
 
1708
                else
 
1709
                    Server_debug(self, "Midi Input (%s) opened.\n", info->name);
 
1710
            }
 
1711
            else {
 
1712
                Server_warning(self, "PortMidi warning: Something wrong with midi device!\nPortmidi closed\n");
 
1713
                self->withPortMidi = 0;
 
1714
                Pm_Terminate();
 
1715
            }    
 
1716
        }    
 
1717
        else {
 
1718
            Server_warning(self, "PortMidi warning: No midi device found!\nPortmidi closed\n");
 
1719
            self->withPortMidi = 0;
 
1720
            Pm_Terminate();
 
1721
        }    
 
1722
    }
 
1723
    if (self->withPortMidi == 1) {
 
1724
        self->midi_count = 0;
 
1725
        Pm_SetFilter(self->in, PM_FILT_ACTIVE | PM_FILT_CLOCK);
 
1726
    } 
 
1727
    return 0;
 
1728
}
 
1729
 
 
1730
 
 
1731
static PyObject *
 
1732
Server_boot(Server *self)
 
1733
{
 
1734
    int audioerr = 0, midierr = 0;
 
1735
    int i;
 
1736
    if (self->server_booted == 1) {
 
1737
        Server_error(self, "Server already booted!\n");
 
1738
        Py_INCREF(Py_None);
 
1739
        return Py_None;
 
1740
    }
 
1741
    self->server_started = 0;
 
1742
    self->stream_count = 0;
 
1743
    self->elapsedSamples = 0;
 
1744
    
 
1745
    midierr = Server_pm_init(self);
 
1746
    Server_debug(self, "PortMidi initialization return code : %d.\n", midierr);
 
1747
 
 
1748
    self->streams = PyList_New(0);
 
1749
    switch (self->audio_be_type) {
 
1750
        case PyoPortaudio:
 
1751
            audioerr = Server_pa_init(self);
 
1752
            break;
 
1753
        case PyoJack:
 
1754
#ifdef USE_JACK
 
1755
            audioerr = Server_jack_init(self);
 
1756
            if (audioerr < 0) {
 
1757
                Server_jack_deinit(self);
 
1758
            }
 
1759
#else
 
1760
            audioerr = -1;
 
1761
            Server_error(self, "Pyo built without Jack support\n");
 
1762
#endif
 
1763
            break;
 
1764
        case PyoCoreaudio:
 
1765
#ifdef USE_COREAUDIO
 
1766
            audioerr = Server_coreaudio_init(self);
 
1767
            if (audioerr < 0) {
 
1768
                Server_coreaudio_deinit(self);
 
1769
            }
 
1770
#else
 
1771
            audioerr = -1;
 
1772
            Server_error(self, "Pyo built without Coreaudio support\n");
 
1773
#endif
 
1774
            break;
 
1775
        case PyoOffline:
 
1776
            audioerr = Server_offline_init(self);
 
1777
            if (audioerr < 0) {
 
1778
                Server_offline_deinit(self);
 
1779
            }
 
1780
            break;
 
1781
    }
 
1782
    // Must allocate buffer after initializing the audio backend in case parameters change there
 
1783
    if (self->input_buffer) {
 
1784
        free(self->input_buffer);
 
1785
    }
 
1786
    self->input_buffer = (MYFLT *)calloc(self->bufferSize * self->nchnls, sizeof(MYFLT));
 
1787
    if (self->output_buffer) {
 
1788
        free(self->output_buffer);
 
1789
    }
 
1790
    self->output_buffer = (float *)calloc(self->bufferSize * self->nchnls, sizeof(float));
 
1791
    for (i=0; i<self->bufferSize*self->nchnls; i++) {
 
1792
        self->input_buffer[i] = 0.0;
 
1793
        self->output_buffer[i] = 0.0;
 
1794
    }
 
1795
    if (audioerr == 0 && midierr == 0) {
 
1796
        self->server_booted = 1;
 
1797
    }
 
1798
    else {
 
1799
        self->server_booted = 0;
 
1800
        Server_error(self, "\nServer not booted.\n");
 
1801
    }    
 
1802
    
 
1803
    Py_INCREF(Py_None);
 
1804
    return Py_None;
 
1805
}
 
1806
 
 
1807
static PyObject *
 
1808
Server_start(Server *self)
 
1809
{
 
1810
    if (self->server_started == 1) {
 
1811
        Server_warning(self, "Server already started!\n");
 
1812
        Py_INCREF(Py_None);
 
1813
        return Py_None;
 
1814
    }
 
1815
 
 
1816
    if (self->server_booted == 0) {
 
1817
        Server_warning(self, "The Server must be booted!\n");
 
1818
        Py_INCREF(Py_None);
 
1819
        return Py_None;
 
1820
    }
 
1821
    int err = -1;
 
1822
    
 
1823
    /* Ensure Python is set up for threading */
 
1824
    PyEval_InitThreads();
 
1825
 
 
1826
    self->server_stopped = 0;
 
1827
    self->server_started = 1;
 
1828
    self->timeStep = (int)(0.01 * self->samplingRate);
 
1829
    
 
1830
    if (self->startoffset > 0.0) {
 
1831
        Server_message(self,"Rendering %.2f seconds offline...\n", self->startoffset);
 
1832
        int numBlocks = ceil(self->startoffset * self->samplingRate/self->bufferSize);
 
1833
        self->lastAmp = 1.0; self->amp = 0.0;
 
1834
        while (numBlocks-- > 0) {
 
1835
            offline_process_block((Server *) self); 
 
1836
        }
 
1837
        Server_message(self,"Offline rendering completed. Start realtime processing.\n");
 
1838
        self->startoffset = 0.0;
 
1839
    }    
 
1840
 
 
1841
    self->amp = self->resetAmp;
 
1842
 
 
1843
    switch (self->audio_be_type) {
 
1844
        case PyoPortaudio:
 
1845
            err = Server_pa_start(self);
 
1846
            break;          
 
1847
        case PyoCoreaudio:
 
1848
#ifdef USE_COREAUDIO  
 
1849
            err = Server_coreaudio_start(self);
 
1850
#endif     
 
1851
            break;           
 
1852
        case PyoJack:  
 
1853
#ifdef USE_JACK      
 
1854
            err = Server_jack_start(self);
 
1855
#endif    
 
1856
            break;
 
1857
        case PyoOffline:
 
1858
            err = Server_offline_start(self);
 
1859
            break;           
 
1860
    }
 
1861
    if (err) {
 
1862
        Server_error(self, "Error starting server.");
 
1863
    }
 
1864
 
 
1865
    Py_INCREF(Py_None);
 
1866
    return Py_None;
 
1867
}
 
1868
 
 
1869
static PyObject *
 
1870
Server_stop(Server *self)
 
1871
{
 
1872
    int err = -1;
 
1873
    if (self->server_started == 0) {
 
1874
        Server_warning(self, "The Server must be started!\n");
 
1875
        Py_INCREF(Py_None);
 
1876
        return Py_None;
 
1877
    }
 
1878
    switch (self->audio_be_type) {
 
1879
        case PyoPortaudio:
 
1880
            err = Server_pa_stop(self);
 
1881
            break;          
 
1882
        case PyoCoreaudio:
 
1883
#ifdef USE_COREAUDIO  
 
1884
            err = Server_coreaudio_stop(self);
 
1885
#endif            
 
1886
            break;        
 
1887
        case PyoJack:
 
1888
#ifdef USE_JACK    
 
1889
            err = Server_jack_stop(self);
 
1890
#endif            
 
1891
            break;
 
1892
        case PyoOffline:
 
1893
            err = Server_offline_stop(self);
 
1894
            break;    
 
1895
    }
 
1896
 
 
1897
    if (err < 0) {
 
1898
        Server_error(self, "Error stopping server.\n");
 
1899
    }
 
1900
    else {
 
1901
        self->server_stopped = 1;
 
1902
    }
 
1903
    Py_INCREF(Py_None);
 
1904
    return Py_None;
 
1905
}
 
1906
 
 
1907
static PyObject *
 
1908
Server_recordOptions(Server *self, PyObject *args, PyObject *kwds)
 
1909
{    
 
1910
    static char *kwlist[] = {"dur", "filename", "fileformat", "sampletype", NULL};
 
1911
    
 
1912
    if (! PyArg_ParseTupleAndKeywords(args, kwds, "d|sii", kwlist, &self->recdur, &self->recpath, &self->recformat, &self->rectype)) {
 
1913
        return PyInt_FromLong(-1);
 
1914
    }
 
1915
    
 
1916
    Py_INCREF(Py_None);
 
1917
    return Py_None;
 
1918
}
 
1919
 
 
1920
static PyObject *
 
1921
Server_start_rec(Server *self, PyObject *args, PyObject *kwds)
 
1922
{    
 
1923
    char *filename=NULL;
 
1924
    
 
1925
    static char *kwlist[] = {"filename", NULL};
 
1926
 
 
1927
    if (! PyArg_ParseTupleAndKeywords(args, kwds, "|s", kwlist, &filename)) {
 
1928
        return PyInt_FromLong(-1);
 
1929
    }
 
1930
    Server_start_rec_internal(self, filename);
 
1931
    
 
1932
    Py_INCREF(Py_None);
 
1933
    return Py_None;
 
1934
}
 
1935
 
 
1936
static int 
 
1937
Server_start_rec_internal(Server *self, char *filename)
 
1938
{
 
1939
    /* Prepare sfinfo */
 
1940
    self->recinfo.samplerate = (int)self->samplingRate;
 
1941
    self->recinfo.channels = self->nchnls;
 
1942
 
 
1943
    Server_debug(self, "recinfo.samplerate : %i\n", self->recinfo.samplerate);
 
1944
    Server_debug(self, "recinfo.channels : %i\n", self->recinfo.channels);
 
1945
 
 
1946
    switch (self->recformat) {
 
1947
        case 0:
 
1948
            self->recinfo.format = SF_FORMAT_WAV;
 
1949
            break;
 
1950
        case 1:
 
1951
            self->recinfo.format = SF_FORMAT_AIFF;
 
1952
            break;
 
1953
    }
 
1954
    switch (self->rectype) {
 
1955
        case 0:
 
1956
            self->recinfo.format = self->recinfo.format | SF_FORMAT_PCM_16;
 
1957
            break;
 
1958
        case 1:
 
1959
            self->recinfo.format = self->recinfo.format | SF_FORMAT_PCM_24;
 
1960
            break;
 
1961
        case 2:
 
1962
            self->recinfo.format = self->recinfo.format | SF_FORMAT_PCM_32;
 
1963
            break;
 
1964
        case 3:
 
1965
            self->recinfo.format = self->recinfo.format | SF_FORMAT_FLOAT;
 
1966
            break;
 
1967
        case 4:
 
1968
            self->recinfo.format = self->recinfo.format | SF_FORMAT_DOUBLE;
 
1969
            break;
 
1970
    }
 
1971
    Server_debug(self, "recinfo.format : %i\n", self->recinfo.format);
 
1972
 
 
1973
    /* Open the output file. */
 
1974
    if (filename == NULL) {
 
1975
        Server_debug(self, "recpath : %s\n", self->recpath);
 
1976
        if (! (self->recfile = sf_open(self->recpath, SFM_WRITE, &self->recinfo))) {   
 
1977
            Server_error(self, "Not able to open output file %s.\n", self->recpath);
 
1978
            Server_debug(self, "%s\n", sf_strerror(self->recfile));
 
1979
            return -1;
 
1980
        }
 
1981
    }
 
1982
    else {
 
1983
        Server_debug(self, "filename : %s\n", filename);
 
1984
        if (! (self->recfile = sf_open(filename, SFM_WRITE, &self->recinfo))) {   
 
1985
            Server_error(self, "Not able to open output file %s.\n", filename);
 
1986
            Server_debug(self, "%s\n", sf_strerror(self->recfile));
 
1987
            return -1;
 
1988
        }
 
1989
    }
 
1990
    
 
1991
    self->record = 1;
 
1992
    return 0;
 
1993
}
 
1994
 
 
1995
static PyObject *
 
1996
Server_stop_rec(Server *self, PyObject *args)
 
1997
{
 
1998
    self->record = 0;
 
1999
    sf_close(self->recfile);
 
2000
    
 
2001
    Py_INCREF(Py_None);
 
2002
    return Py_None;
 
2003
}
 
2004
 
 
2005
static PyObject *
 
2006
Server_addStream(Server *self, PyObject *args)
 
2007
{
 
2008
    PyObject *tmp;
 
2009
    
 
2010
    if (! PyArg_ParseTuple(args, "O", &tmp))
 
2011
        return PyInt_FromLong(-1); 
 
2012
        
 
2013
    if (tmp == NULL) {
 
2014
        Server_error(self, "Need a pyo object as argument\n");
 
2015
        return PyInt_FromLong(-1);
 
2016
    }
 
2017
 
 
2018
    Py_INCREF(tmp);
 
2019
    PyList_Append(self->streams, tmp);
 
2020
 
 
2021
    self->stream_count++;
 
2022
    
 
2023
    Py_INCREF(Py_None);
 
2024
    return Py_None;
 
2025
}
 
2026
 
 
2027
PyObject *
 
2028
Server_removeStream(Server *self, int id)
 
2029
{
 
2030
    int i, sid;
 
2031
    Stream *stream_tmp;
 
2032
    
 
2033
    for (i=0; i<self->stream_count; i++) {
 
2034
        stream_tmp = (Stream *)PyList_GET_ITEM(self->streams, i);
 
2035
        sid = Stream_getStreamId(stream_tmp);
 
2036
        if (sid == id) {
 
2037
            Server_debug(self, "Removed stream id %d\n", id);
 
2038
            PySequence_DelItem(self->streams, i);
 
2039
            self->stream_count--;
 
2040
        }
 
2041
    }
 
2042
    Py_INCREF(Py_None);
 
2043
    return Py_None;    
 
2044
}
 
2045
 
 
2046
PyObject *
 
2047
Server_changeStreamPosition(Server *self, PyObject *args)
 
2048
{
 
2049
    int err, i, rsid, csid, sid;
 
2050
    Stream *ref_stream_tmp, *cur_stream_tmp, *stream_tmp;
 
2051
 
 
2052
    if (! PyArg_ParseTuple(args, "OO", &ref_stream_tmp, &cur_stream_tmp))
 
2053
        return PyInt_FromLong(-1); 
 
2054
 
 
2055
    rsid = Stream_getStreamId(ref_stream_tmp);
 
2056
    csid = Stream_getStreamId(cur_stream_tmp);
 
2057
    
 
2058
    for (i=0; i<self->stream_count; i++) {
 
2059
        stream_tmp = (Stream *)PyList_GET_ITEM(self->streams, i);
 
2060
        sid = Stream_getStreamId(stream_tmp);
 
2061
        if (sid == csid) {
 
2062
            PySequence_DelItem(self->streams, i);
 
2063
            self->stream_count--;
 
2064
            break;
 
2065
        }
 
2066
    }
 
2067
 
 
2068
    for (i=0; i<self->stream_count; i++) {
 
2069
        stream_tmp = (Stream *)PyList_GET_ITEM(self->streams, i);
 
2070
        sid = Stream_getStreamId(stream_tmp);
 
2071
        if (sid == rsid) {
 
2072
            break;
 
2073
        }
 
2074
    }
 
2075
 
 
2076
    Py_INCREF(cur_stream_tmp);
 
2077
    err = PyList_Insert(self->streams, i, (PyObject *)cur_stream_tmp);
 
2078
    self->stream_count++;
 
2079
 
 
2080
    Py_INCREF(Py_None);
 
2081
    return Py_None;    
 
2082
}
 
2083
 
 
2084
MYFLT *
 
2085
Server_getInputBuffer(Server *self) {
 
2086
    return (MYFLT *)self->input_buffer;
 
2087
}
 
2088
 
 
2089
PmEvent *
 
2090
Server_getMidiEventBuffer(Server *self) {
 
2091
    return (PmEvent *)self->midiEvents;
 
2092
}
 
2093
 
 
2094
int
 
2095
Server_getMidiEventCount(Server *self) {
 
2096
    return self->midi_count;
 
2097
}
 
2098
 
 
2099
static PyObject *
 
2100
Server_getSamplingRate(Server *self)
 
2101
{
 
2102
    return PyFloat_FromDouble(self->samplingRate);
 
2103
}
 
2104
 
 
2105
static PyObject *
 
2106
Server_getNchnls(Server *self)
 
2107
{
 
2108
    return PyInt_FromLong(self->nchnls);
 
2109
}
 
2110
 
 
2111
static PyObject *
 
2112
Server_getGlobalSeed(Server *self)
 
2113
{
 
2114
    return PyInt_FromLong(self->globalSeed);
 
2115
}
 
2116
 
 
2117
static PyObject *
 
2118
Server_getBufferSize(Server *self)
 
2119
{
 
2120
    return PyInt_FromLong(self->bufferSize);
 
2121
}
 
2122
 
 
2123
static PyObject *
 
2124
Server_getIsStarted(Server *self)
 
2125
{
 
2126
    return PyInt_FromLong(self->server_started);
 
2127
}
 
2128
 
 
2129
static PyObject *
 
2130
Server_getIsBooted(Server *self)
 
2131
{
 
2132
    return PyInt_FromLong(self->server_booted);
 
2133
}
 
2134
 
 
2135
static PyObject *
 
2136
Server_getMidiActive(Server *self)
 
2137
{
 
2138
    return PyInt_FromLong(self->withPortMidi);
 
2139
}
 
2140
 
 
2141
static PyObject *
 
2142
Server_getStreams(Server *self)
 
2143
{
 
2144
    Py_INCREF(self->streams);
 
2145
    return self->streams;
 
2146
}
 
2147
 
 
2148
 
 
2149
static PyMethodDef Server_methods[] = {
 
2150
    {"setInputDevice", (PyCFunction)Server_setInputDevice, METH_O, "Sets audio input device."},
 
2151
    {"setOutputDevice", (PyCFunction)Server_setOutputDevice, METH_O, "Sets audio output device."},
 
2152
    {"setInOutDevice", (PyCFunction)Server_setInOutDevice, METH_O, "Sets both audio input and output device."},
 
2153
    {"setMidiInputDevice", (PyCFunction)Server_setMidiInputDevice, METH_O, "Sets MIDI input device."},
 
2154
    {"setSamplingRate", (PyCFunction)Server_setSamplingRate, METH_O, "Sets the server's sampling rate."},
 
2155
    {"setBufferSize", (PyCFunction)Server_setBufferSize, METH_O, "Sets the server's buffer size."},
 
2156
    {"setNchnls", (PyCFunction)Server_setNchnls, METH_O, "Sets the server's number of channels."},
 
2157
    {"setDuplex", (PyCFunction)Server_setDuplex, METH_O, "Sets the server's duplex mode (0 = only out, 1 = in/out)."},
 
2158
    {"setGlobalSeed", (PyCFunction)Server_setGlobalSeed, METH_O, "Sets the server's global seed for random objects."},
 
2159
    {"setAmp", (PyCFunction)Server_setAmp, METH_O, "Sets the overall amplitude."},
 
2160
    {"setAmpCallable", (PyCFunction)Server_setAmpCallable, METH_O, "Sets the Server's GUI object."},
 
2161
    {"setTimeCallable", (PyCFunction)Server_setTimeCallable, METH_O, "Sets the Server's TIME object."},
 
2162
    {"setVerbosity", (PyCFunction)Server_setVerbosity, METH_O, "Sets the verbosity."},
 
2163
    {"setStartOffset", (PyCFunction)Server_setStartOffset, METH_O, "Sets starting time offset."},
 
2164
    {"boot", (PyCFunction)Server_boot, METH_NOARGS, "Setup and boot the server."},
 
2165
    {"shutdown", (PyCFunction)Server_shut_down, METH_NOARGS, "Shut down the server."},
 
2166
    {"start", (PyCFunction)Server_start, METH_NOARGS, "Starts the server's callback loop."},
 
2167
    {"stop", (PyCFunction)Server_stop, METH_NOARGS, "Stops the server's callback loop."},
 
2168
    {"recordOptions", (PyCFunction)Server_recordOptions, METH_VARARGS|METH_KEYWORDS, "Sets format settings for offline rendering and global recording."},
 
2169
    {"recstart", (PyCFunction)Server_start_rec, METH_VARARGS|METH_KEYWORDS, "Start automatic output recording."},
 
2170
    {"recstop", (PyCFunction)Server_stop_rec, METH_NOARGS, "Stop automatic output recording."},
 
2171
    {"addStream", (PyCFunction)Server_addStream, METH_VARARGS, "Adds an audio stream to the server. \
 
2172
                                                                This is for internal use and must never be called by the user."},
 
2173
    {"removeStream", (PyCFunction)Server_removeStream, METH_VARARGS, "Adds an audio stream to the server. \
 
2174
                                                                This is for internal use and must never be called by the user."},
 
2175
    {"changeStreamPosition", (PyCFunction)Server_changeStreamPosition, METH_VARARGS, "Puts an audio stream before another in the stack. \
 
2176
                                                                This is for internal use and must never be called by the user."},
 
2177
    {"getStreams", (PyCFunction)Server_getStreams, METH_NOARGS, "Returns the list of streams added to the server."},
 
2178
    {"getSamplingRate", (PyCFunction)Server_getSamplingRate, METH_NOARGS, "Returns the server's sampling rate."},
 
2179
    {"getNchnls", (PyCFunction)Server_getNchnls, METH_NOARGS, "Returns the server's current number of channels."},
 
2180
    {"getGlobalSeed", (PyCFunction)Server_getGlobalSeed, METH_NOARGS, "Returns the server's global seed."},
 
2181
    {"getBufferSize", (PyCFunction)Server_getBufferSize, METH_NOARGS, "Returns the server's buffer size."},
 
2182
    {"getIsBooted", (PyCFunction)Server_getIsBooted, METH_NOARGS, "Returns 1 if the server is booted, otherwise returns 0."},
 
2183
    {"getIsStarted", (PyCFunction)Server_getIsStarted, METH_NOARGS, "Returns 1 if the server is started, otherwise returns 0."},
 
2184
    {"getMidiActive", (PyCFunction)Server_getMidiActive, METH_NOARGS, "Returns 1 if midi callback is active, otherwise returns 0."},
 
2185
    {NULL}  /* Sentinel */
 
2186
};
 
2187
 
 
2188
static PyMemberDef Server_members[] = {
 
2189
    {"streams", T_OBJECT_EX, offsetof(Server, streams), 0, "Server's streams list."},
 
2190
    {NULL}  /* Sentinel */
 
2191
};
 
2192
 
 
2193
PyTypeObject ServerType = {
 
2194
    PyObject_HEAD_INIT(NULL)
 
2195
    0,                         /*ob_size*/
 
2196
    "_pyo.Server",         /*tp_name*/
 
2197
    sizeof(Server),         /*tp_basicsize*/
 
2198
    0,                         /*tp_itemsize*/
 
2199
    (destructor)Server_dealloc, /*tp_dealloc*/
 
2200
    0,                         /*tp_print*/
 
2201
    0,                         /*tp_getattr*/
 
2202
    0,                         /*tp_setattr*/
 
2203
    0,                         /*tp_compare*/
 
2204
    0,                         /*tp_repr*/
 
2205
    0,                         /*tp_as_number*/
 
2206
    0,                         /*tp_as_sequence*/
 
2207
    0,                         /*tp_as_mapping*/
 
2208
    0,                         /*tp_hash */
 
2209
    0,                         /*tp_call*/
 
2210
    0,                         /*tp_str*/
 
2211
    0,                         /*tp_getattro*/
 
2212
    0,                         /*tp_setattro*/
 
2213
    0,                         /*tp_as_buffer*/
 
2214
    Py_TPFLAGS_DEFAULT, /*tp_flags*/
 
2215
    "Pyo Server object. Handles communication with Portaudio and processing callback loop.",           /* tp_doc */
 
2216
    (traverseproc)Server_traverse,   /* tp_traverse */
 
2217
    (inquiry)Server_clear,           /* tp_clear */
 
2218
    0,                         /* tp_richcompare */
 
2219
    0,                         /* tp_weaklistoffset */
 
2220
    0,                         /* tp_iter */
 
2221
    0,                         /* tp_iternext */
 
2222
    Server_methods,             /* tp_methods */
 
2223
    Server_members,             /* tp_members */
 
2224
    0,                      /* tp_getset */
 
2225
    0,                         /* tp_base */
 
2226
    0,                         /* tp_dict */
 
2227
    0,                         /* tp_descr_get */
 
2228
    0,                         /* tp_descr_set */
 
2229
    0,                         /* tp_dictoffset */
 
2230
    (initproc)Server_init,      /* tp_init */
 
2231
    0,                         /* tp_alloc */
 
2232
    Server_new,                 /* tp_new */
 
2233
};