← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty-proposed

« back to all changes in this revision

Viewing changes to intern/audaspace/jack/AUD_JackDevice.cpp

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2013-08-14 10:43:49 UTC
  • mfrom: (14.2.19 sid)
  • Revision ID: package-import@ubuntu.com-20130814104349-t1d5mtwkphp12dyj
Tags: 2.68a-3
* Upload to unstable
* debian/: python3.3 Depends simplified
  - debian/control: python3.3 Depends dropped
    for blender-data package
  - 0001-blender_thumbnailer.patch refreshed
* debian/control: libavcodec b-dep versioning dropped

Show diffs side-by-side

added added

removed removed

Lines of Context:
intern/audaspace/jack/AUD_JackDevice.cpp
56
56
                {
57
57
                        if(m_syncFunc)
58
58
                        {
59
 
                                state = jack_transport_query(m_client, &position);
 
59
                                state = AUD_jack_transport_query(m_client, &position);
60
60
                                m_syncFunc(m_syncFuncData, state != JackTransportStopped, position.frame / (float) m_specs.rate);
61
61
                        }
62
62
 
63
63
                        for(i = 0; i < channels; i++)
64
 
                                jack_ringbuffer_reset(m_ringbuffers[i]);
 
64
                                AUD_jack_ringbuffer_reset(m_ringbuffers[i]);
65
65
                }
66
66
 
67
 
                size = jack_ringbuffer_write_space(m_ringbuffers[0]);
 
67
                size = AUD_jack_ringbuffer_write_space(m_ringbuffers[0]);
68
68
                for(i = 1; i < channels; i++)
69
 
                        if((temp = jack_ringbuffer_write_space(m_ringbuffers[i])) < size)
 
69
                        if((temp = AUD_jack_ringbuffer_write_space(m_ringbuffers[i])) < size)
70
70
                                size = temp;
71
71
 
72
72
                while(size > samplesize)
77
77
                        {
78
78
                                for(j = 0; j < size; j++)
79
79
                                        deinterleave[i * size + j] = buffer[i + j * channels];
80
 
                                jack_ringbuffer_write(m_ringbuffers[i], (char*)(deinterleave + i * size), size * sizeof(float));
 
80
                                AUD_jack_ringbuffer_write(m_ringbuffers[i], (char*)(deinterleave + i * size), size * sizeof(float));
81
81
                        }
82
82
 
83
 
                        size = jack_ringbuffer_write_space(m_ringbuffers[0]);
 
83
                        size = AUD_jack_ringbuffer_write_space(m_ringbuffers[0]);
84
84
                        for(i = 1; i < channels; i++)
85
 
                                if((temp = jack_ringbuffer_write_space(m_ringbuffers[i])) < size)
 
85
                                if((temp = AUD_jack_ringbuffer_write_space(m_ringbuffers[i])) < size)
86
86
                                        size = temp;
87
87
                }
88
88
 
107
107
        {
108
108
                // play silence while syncing
109
109
                for(unsigned int i = 0; i < count; i++)
110
 
                        memset(jack_port_get_buffer(device->m_ports[i], length), 0, length * sizeof(float));
 
110
                        memset(AUD_jack_port_get_buffer(device->m_ports[i], length), 0, length * sizeof(float));
111
111
        }
112
112
        else
113
113
        {
114
114
                size_t temp;
115
 
                size_t readsamples = jack_ringbuffer_read_space(device->m_ringbuffers[0]);
 
115
                size_t readsamples = AUD_jack_ringbuffer_read_space(device->m_ringbuffers[0]);
116
116
                for(i = 1; i < count; i++)
117
 
                        if((temp = jack_ringbuffer_read_space(device->m_ringbuffers[i])) < readsamples)
 
117
                        if((temp = AUD_jack_ringbuffer_read_space(device->m_ringbuffers[i])) < readsamples)
118
118
                                readsamples = temp;
119
119
 
120
120
                readsamples = AUD_MIN(readsamples / sizeof(float), length);
121
121
 
122
122
                for(unsigned int i = 0; i < count; i++)
123
123
                {
124
 
                        buffer = (char*)jack_port_get_buffer(device->m_ports[i], length);
125
 
                        jack_ringbuffer_read(device->m_ringbuffers[i], buffer, readsamples * sizeof(float));
 
124
                        buffer = (char*)AUD_jack_port_get_buffer(device->m_ports[i], length);
 
125
                        AUD_jack_ringbuffer_read(device->m_ringbuffers[i], buffer, readsamples * sizeof(float));
126
126
                        if(readsamples < length)
127
127
                                memset(buffer + readsamples * sizeof(float), 0, (length - readsamples) * sizeof(float));
128
128
                }
193
193
        jack_status_t status;
194
194
 
195
195
        // open client
196
 
        m_client = jack_client_open(name.c_str(), options, &status);
 
196
        m_client = AUD_jack_client_open(name.c_str(), options, &status);
197
197
        if(m_client == NULL)
198
198
                AUD_THROW(AUD_ERROR_JACK, clientopen_error);
199
199
 
200
200
        // set callbacks
201
 
        jack_set_process_callback(m_client, AUD_JackDevice::jack_mix, this);
202
 
        jack_on_shutdown(m_client, AUD_JackDevice::jack_shutdown, this);
203
 
        jack_set_sync_callback(m_client, AUD_JackDevice::jack_sync, this);
 
201
        AUD_jack_set_process_callback(m_client, AUD_JackDevice::jack_mix, this);
 
202
        AUD_jack_on_shutdown(m_client, AUD_JackDevice::jack_shutdown, this);
 
203
        AUD_jack_set_sync_callback(m_client, AUD_JackDevice::jack_sync, this);
204
204
 
205
205
        // register our output channels which are called ports in jack
206
206
        m_ports = new jack_port_t*[m_specs.channels];
211
211
                for(int i = 0; i < m_specs.channels; i++)
212
212
                {
213
213
                        sprintf(portname, "out %d", i+1);
214
 
                        m_ports[i] = jack_port_register(m_client, portname,
 
214
                        m_ports[i] = AUD_jack_port_register(m_client, portname,
215
215
                                                                                        JACK_DEFAULT_AUDIO_TYPE,
216
216
                                                                                        JackPortIsOutput, 0);
217
217
                        if(m_ports[i] == NULL)
220
220
        }
221
221
        catch(AUD_Exception&)
222
222
        {
223
 
                jack_client_close(m_client);
 
223
                AUD_jack_client_close(m_client);
224
224
                delete[] m_ports;
225
225
                throw;
226
226
        }
227
227
 
228
 
        m_specs.rate = (AUD_SampleRate)jack_get_sample_rate(m_client);
 
228
        m_specs.rate = (AUD_SampleRate)AUD_jack_get_sample_rate(m_client);
229
229
 
230
230
        buffersize *= sizeof(sample_t);
231
231
        m_ringbuffers = new jack_ringbuffer_t*[specs.channels];
232
232
        for(unsigned int i = 0; i < specs.channels; i++)
233
 
                m_ringbuffers[i] = jack_ringbuffer_create(buffersize);
 
233
                m_ringbuffers[i] = AUD_jack_ringbuffer_create(buffersize);
234
234
        buffersize *= specs.channels;
235
235
        m_deinterleavebuf.resize(buffersize);
236
236
        m_buffer.resize(buffersize);
240
240
        m_valid = true;
241
241
        m_sync = 0;
242
242
        m_syncFunc = NULL;
243
 
        m_nextState = m_state = jack_transport_query(m_client, NULL);
 
243
        m_nextState = m_state = AUD_jack_transport_query(m_client, NULL);
244
244
 
245
245
        pthread_mutex_init(&m_mixingLock, NULL);
246
246
        pthread_cond_init(&m_mixingCondition, NULL);
247
247
 
248
248
        // activate the client
249
 
        if(jack_activate(m_client))
 
249
        if(AUD_jack_activate(m_client))
250
250
        {
251
 
                jack_client_close(m_client);
 
251
                AUD_jack_client_close(m_client);
252
252
                delete[] m_ports;
253
253
                for(unsigned int i = 0; i < specs.channels; i++)
254
 
                        jack_ringbuffer_free(m_ringbuffers[i]);
 
254
                        AUD_jack_ringbuffer_free(m_ringbuffers[i]);
255
255
                delete[] m_ringbuffers;
256
256
                pthread_mutex_destroy(&m_mixingLock);
257
257
                pthread_cond_destroy(&m_mixingCondition);
260
260
                AUD_THROW(AUD_ERROR_JACK, activate_error);
261
261
        }
262
262
 
263
 
        const char** ports = jack_get_ports(m_client, NULL, NULL,
 
263
        const char** ports = AUD_jack_get_ports(m_client, NULL, NULL,
264
264
                                                                                JackPortIsPhysical | JackPortIsInput);
265
265
        if(ports != NULL)
266
266
        {
267
267
                for(int i = 0; i < m_specs.channels && ports[i]; i++)
268
 
                        jack_connect(m_client, jack_port_name(m_ports[i]), ports[i]);
 
268
                        AUD_jack_connect(m_client, AUD_jack_port_name(m_ports[i]), ports[i]);
269
269
 
270
270
                free(ports);
271
271
        }
282
282
AUD_JackDevice::~AUD_JackDevice()
283
283
{
284
284
        if(m_valid)
285
 
                jack_client_close(m_client);
 
285
                AUD_jack_client_close(m_client);
286
286
        m_valid = false;
287
287
 
288
288
        delete[] m_ports;
295
295
        pthread_cond_destroy(&m_mixingCondition);
296
296
        pthread_mutex_destroy(&m_mixingLock);
297
297
        for(unsigned int i = 0; i < m_specs.channels; i++)
298
 
                jack_ringbuffer_free(m_ringbuffers[i]);
 
298
                AUD_jack_ringbuffer_free(m_ringbuffers[i]);
299
299
        delete[] m_ringbuffers;
300
300
 
301
301
        destroy();
308
308
 
309
309
void AUD_JackDevice::startPlayback()
310
310
{
311
 
        jack_transport_start(m_client);
 
311
        AUD_jack_transport_start(m_client);
312
312
        m_nextState = JackTransportRolling;
313
313
}
314
314
 
315
315
void AUD_JackDevice::stopPlayback()
316
316
{
317
 
        jack_transport_stop(m_client);
 
317
        AUD_jack_transport_stop(m_client);
318
318
        m_nextState = JackTransportStopped;
319
319
}
320
320
 
321
321
void AUD_JackDevice::seekPlayback(float time)
322
322
{
323
323
        if(time >= 0.0f)
324
 
                jack_transport_locate(m_client, time * m_specs.rate);
 
324
                AUD_jack_transport_locate(m_client, time * m_specs.rate);
325
325
}
326
326
 
327
327
void AUD_JackDevice::setSyncCallback(AUD_syncFunction sync, void* data)
333
333
float AUD_JackDevice::getPlaybackPosition()
334
334
{
335
335
        jack_position_t position;
336
 
        jack_transport_query(m_client, &position);
 
336
        AUD_jack_transport_query(m_client, &position);
337
337
        return position.frame / (float) m_specs.rate;
338
338
}
339
339
 
340
340
bool AUD_JackDevice::doesPlayback()
341
341
{
342
 
        jack_transport_state_t state = jack_transport_query(m_client, NULL);
 
342
        jack_transport_state_t state = AUD_jack_transport_query(m_client, NULL);
343
343
 
344
344
        if(state != m_state)
345
345
                m_nextState = m_state = state;