freebob_driver.c

Revision 302, 31.6 kB (checked in by jwoithe, 17 years ago)

jack driver: call detach() from finish() if detach() hasn't yet been called. This works around the fact that jack doesn't call detach() on close at this stage. Once this is fixed in jack the workaround can be removed.
C streaming API: set sample rate before device initialisation. This permits jackd to set the sample rate to that requested on the command line when starting jackd.
Motu device: start adding details to setSamplingFrequency() beyond that required for basic functionality.

Line
1	/*
2	* FreeBob Backend for Jack
3	* FreeBob = Firewire (pro-)audio for linux
4	*
5	* http://freebob.sf.net
6	* http://jackit.sf.net
7	*
8	* Copyright (C) 2005 Pieter Palmers <pieterpalmers@users.sourceforge.net>
9	*
10	* This program is free software; you can redistribute it and/or modify
11	* it under the terms of the GNU General Public License as published by
12	* the Free Software Foundation; either version 2 of the License, or
13	* (at your option) any later version.
14	*
15	* This program is distributed in the hope that it will be useful,
16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18	* GNU General Public License for more details.
19	*
20	* You should have received a copy of the GNU General Public License
21	* along with this program; if not, write to the Free Software
22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23	*/
24
25	/*
26	* Main Jack driver entry routines
27	*
28	*/
29
30	#include <math.h>
31	#include <stdio.h>
32	#include <memory.h>
33	#include <unistd.h>
34	#include <stdlib.h>
35	#include <errno.h>
36	#include <stdarg.h>
37	#include <sys/mman.h>
38
39	#include <jack/types.h>
40	#include <jack/internal.h>
41	#include <jack/engine.h>
42	#include <sysdeps/time.h>
43
44	#include "freebob_driver.h"
45
46	#define SAMPLE_MAX_24BIT 8388608.0f
47	#define SAMPLE_MAX_16BIT 32768.0f
48
49	static int freebob_driver_stop (freebob_driver_t *driver);
50
51	#ifdef FREEBOB_DRIVER_WITH_MIDI
52	static freebob_driver_midi_handle_t freebob_driver_midi_init(freebob_driver_t driver);
53	static void freebob_driver_midi_finish (freebob_driver_midi_handle_t *m);
54	static int freebob_driver_midi_start (freebob_driver_midi_handle_t *m);
55	static int freebob_driver_midi_stop (freebob_driver_midi_handle_t *m);
56	#endif
57
58	// enable verbose messages
59	static int g_verbose=0;
60
61	static int
62	freebob_driver_attach (freebob_driver_t *driver)
63	{
64	char buf[64];
65	channel_t chn;
66	jack_port_t *port;
67	int port_flags;
68
69	g_verbose=driver->engine->verbose;
70	driver->device_options.verbose=g_verbose;
71
72	driver->engine->set_buffer_size (driver->engine, driver->period_size);
73	driver->engine->set_sample_rate (driver->engine, driver->sample_rate);
74
75	/* packetizer thread options */
76	driver->device_options.realtime=(driver->engine->control->real_time? 1 : 0);
77
78	driver->device_options.packetizer_priority=driver->engine->control->client_priority +
79	FREEBOB_RT_PRIORITY_PACKETIZER_RELATIVE;
80	if (driver->device_options.packetizer_priority>98) {
81	driver->device_options.packetizer_priority=98;
82	}
83
84	driver->dev=freebob_streaming_init(&driver->device_info,driver->device_options);
85
86	if(!driver->dev) {
87	printError("Error creating freebob streaming device");
88	return -1;
89	}
90
91	#ifdef FREEBOB_DRIVER_WITH_MIDI
92	driver->midi_handle=freebob_driver_midi_init(driver);
93	if(!driver->midi_handle) {
94	printError("-----------------------------------------------------------");
95	printError("Error creating midi device!");
96	printError("FreeBob will run without MIDI support.");
97	printError("Consult the above error messages to solve the problem. ");
98	printError("-----------------------------------------------------------\n\n");
99	}
100	#endif
101
102	if (driver->device_options.realtime) {
103	printMessage("Streaming thread running with Realtime scheduling, priority %d",
104	driver->device_options.packetizer_priority);
105	} else {
106	printMessage("Streaming thread running without Realtime scheduling");
107	}
108
109	/* ports */
110	port_flags = JackPortIsOutput\|JackPortIsPhysical\|JackPortIsTerminal;
111
112	driver->capture_nchannels=freebob_streaming_get_nb_capture_streams(driver->dev);
113
114	for (chn = 0; chn < driver->capture_nchannels; chn++) {
115
116	freebob_streaming_get_capture_stream_name(driver->dev, chn, buf, sizeof(buf) - 1);
117
118	if(freebob_streaming_get_capture_stream_type(driver->dev, chn) != freebob_stream_type_audio) {
119	printMessage ("Don't register capture port %s", buf);
120
121	// we have to add a NULL entry in the list to be able to loop over the channels in the read/write routines
122	driver->capture_ports =
123	jack_slist_append (driver->capture_ports, NULL);
124	} else {
125	printMessage ("Registering capture port %s", buf);
126	if ((port = jack_port_register (driver->client, buf,
127	JACK_DEFAULT_AUDIO_TYPE,
128	port_flags, 0)) == NULL) {
129	printError (" cannot register port for %s", buf);
130	break;
131	}
132	driver->capture_ports =
133	jack_slist_append (driver->capture_ports, port);
134	// setup port parameters
135	if(freebob_streaming_set_capture_buffer_type(driver->dev, chn, freebob_buffer_type_float)) {
136	printError(" cannot set port buffer type for %s", buf);
137	}
138	if (freebob_streaming_set_capture_stream_buffer(driver->dev, chn, NULL)) {
139	printError(" cannot configure initial port buffer for %s", buf);
140	}
141	if(freebob_streaming_capture_stream_onoff(driver->dev, chn, 1)) {
142	printError(" cannot enable port %s", buf);
143	}
144	}
145	// jack_port_set_latency (port, driver->period_size);
146
147	}
148
149	port_flags = JackPortIsInput\|JackPortIsPhysical\|JackPortIsTerminal;
150
151	driver->playback_nchannels=freebob_streaming_get_nb_playback_streams(driver->dev);
152
153	for (chn = 0; chn < driver->playback_nchannels; chn++) {
154
155	freebob_streaming_get_playback_stream_name(driver->dev, chn, buf, sizeof(buf) - 1);
156
157	if(freebob_streaming_get_playback_stream_type(driver->dev, chn) != freebob_stream_type_audio) {
158	printMessage ("Don't register playback port %s", buf);
159
160	// we have to add a NULL entry in the list to be able to loop over the channels in the read/write routines
161	driver->playback_ports =
162	jack_slist_append (driver->playback_ports, NULL);
163	} else {
164	printMessage ("Registering playback port %s", buf);
165	if ((port = jack_port_register (driver->client, buf,
166	JACK_DEFAULT_AUDIO_TYPE,
167	port_flags, 0)) == NULL) {
168	printError(" cannot register port for %s", buf);
169	break;
170	}
171	driver->playback_ports =
172	jack_slist_append (driver->playback_ports, port);
173
174	// setup port parameters
175	if(freebob_streaming_set_playback_buffer_type(driver->dev, chn, freebob_buffer_type_float)) {
176	printError(" cannot set port buffer type for %s", buf);
177	}
178	if (freebob_streaming_set_playback_stream_buffer(driver->dev, chn, NULL)) {
179	printError(" cannot configure initial port buffer for %s", buf);
180	}
181	if(freebob_streaming_playback_stream_onoff(driver->dev, chn, 1)) {
182	printError(" cannot enable port %s", buf);
183	}
184	}
185	// jack_port_set_latency (port, (driver->period_size * (driver->user_nperiods - 1)) + driver->playback_frame_latency);
186
187	}
188
189	if(!freebob_streaming_prepare(driver->dev)) {
190	printError("Could not prepare streaming device!");
191	return -1;
192	}
193
194
195	return jack_activate (driver->client);
196	}
197
198	static int
199	freebob_driver_detach (freebob_driver_t *driver)
200	{
201	JSList *node;
202
203	if (driver->engine == NULL) {
204	return 0;
205	}
206
207	for (node = driver->capture_ports; node;
208	node = jack_slist_next (node)) {
209	jack_port_unregister (driver->client,
210	((jack_port_t *) node->data));
211	}
212
213	jack_slist_free (driver->capture_ports);
214	driver->capture_ports = 0;
215
216	for (node = driver->playback_ports; node;
217	node = jack_slist_next (node)) {
218	jack_port_unregister (driver->client,
219	((jack_port_t *) node->data));
220	}
221
222	jack_slist_free (driver->playback_ports);
223	driver->playback_ports = 0;
224
225	freebob_streaming_finish(driver->dev);
226	driver->dev=NULL;
227
228	#ifdef FREEBOB_DRIVER_WITH_MIDI
229	if(driver->midi_handle) {
230	freebob_driver_midi_finish(driver->midi_handle);
231	}
232	#endif
233	driver->midi_handle=NULL;
234
235	return 0;
236
237	}
238
239	static inline void
240	freebob_driver_read_from_channel (freebob_driver_t *driver,
241	channel_t channel,
242	jack_default_audio_sample_t *dst,
243	jack_nframes_t nsamples)
244	{
245
246	freebob_sample_t buffer[nsamples];
247	char src=(char )buffer;
248
249	freebob_streaming_read(driver->dev, channel, buffer, nsamples);
250
251	/* ALERT: signed sign-extension portability !!! */
252
253	while (nsamples--) {
254	int x;
255	#if __BYTE_ORDER == __LITTLE_ENDIAN
256	memcpy((char*)&x + 1, src, 3);
257	#elif __BYTE_ORDER == __BIG_ENDIAN
258	memcpy(&x, src, 3);
259	#endif
260	x >>= 8;
261	*dst = x / SAMPLE_MAX_24BIT;
262	dst++;
263	src += sizeof(freebob_sample_t);
264	}
265
266	}
267
268	static int
269	freebob_driver_read (freebob_driver_t * driver, jack_nframes_t nframes)
270	{
271	jack_default_audio_sample_t* buf;
272	channel_t chn;
273	JSList *node;
274	jack_port_t* port;
275
276	freebob_sample_t nullbuffer[nframes];
277
278	freebob_streaming_stream_type stream_type;
279
280	printEnter();
281
282	for (chn = 0, node = driver->capture_ports; node; node = jack_slist_next (node), chn++) {
283	stream_type = freebob_streaming_get_capture_stream_type(driver->dev, chn);
284	if(stream_type == freebob_stream_type_audio) {
285	port = (jack_port_t *) node->data;
286
287	buf = jack_port_get_buffer (port, nframes);
288	if(!buf) buf=(jack_default_audio_sample_t*)nullbuffer;
289
290	freebob_streaming_set_capture_stream_buffer(driver->dev, chn, (char *)(buf));
291	}
292	}
293
294	// now transfer the buffers
295	freebob_streaming_transfer_capture_buffers(driver->dev);
296
297	printExit();
298
299	return 0;
300
301	}
302
303	static inline void
304	freebob_driver_write_to_channel (freebob_driver_t *driver,
305	channel_t channel,
306	jack_default_audio_sample_t *buf,
307	jack_nframes_t nsamples)
308	{
309	long long y;
310	freebob_sample_t buffer[nsamples];
311	unsigned int i=0;
312	char dst=(char )buffer;
313
314	// convert from float to integer
315	for(;i<nsamples;i++) {
316	y = (long long)(buf SAMPLE_MAX_24BIT);
317
318	if (y > (INT_MAX >> 8 )) {
319	y = (INT_MAX >> 8);
320	} else if (y < (INT_MIN >> 8 )) {
321	y = (INT_MIN >> 8 );
322	}
323	#if __BYTE_ORDER == __LITTLE_ENDIAN
324	memcpy (dst, &y, 3);
325	#elif __BYTE_ORDER == __BIG_ENDIAN
326	memcpy (dst, (char *)&y + 5, 3);
327	#endif
328	dst += sizeof(freebob_sample_t);
329	buf++;
330	}
331
332	// write to the freebob streaming device
333	freebob_streaming_write(driver->dev, channel, buffer, nsamples);
334
335	}
336
337	static int
338	freebob_driver_write (freebob_driver_t * driver, jack_nframes_t nframes)
339	{
340	channel_t chn;
341	JSList *node;
342	jack_default_audio_sample_t* buf;
343
344	jack_port_t *port;
345
346	freebob_streaming_stream_type stream_type;
347
348	freebob_sample_t nullbuffer[nframes];
349
350	memset(&nullbuffer,0,nframes*sizeof(freebob_sample_t));
351
352	printEnter();
353
354	driver->process_count++;
355
356	assert(driver->dev);
357
358	if (driver->engine->freewheeling) {
359	return 0;
360	}
361
362	for (chn = 0, node = driver->playback_ports; node; node = jack_slist_next (node), chn++) {
363	stream_type=freebob_streaming_get_playback_stream_type(driver->dev, chn);
364	if(stream_type == freebob_stream_type_audio) {
365	port = (jack_port_t *) node->data;
366
367	buf = jack_port_get_buffer (port, nframes);
368	if(!buf) buf=(jack_default_audio_sample_t*)nullbuffer;
369
370	freebob_streaming_set_playback_stream_buffer(driver->dev, chn, (char *)(buf));
371	}
372	}
373
374	freebob_streaming_transfer_playback_buffers(driver->dev);
375
376	printExit();
377
378	return 0;
379	}
380
381	//static inline jack_nframes_t
382	static jack_nframes_t
383	freebob_driver_wait (freebob_driver_t driver, int extra_fd, int status,
384	float *delayed_usecs)
385	{
386	int nframes;
387	jack_time_t wait_enter;
388	jack_time_t wait_ret;
389
390	printEnter();
391
392	wait_enter = jack_get_microseconds ();
393	if (wait_enter > driver->wait_next) {
394	/*
395	* This processing cycle was delayed past the
396	* next due interrupt! Do not account this as
397	* a wakeup delay:
398	*/
399	driver->wait_next = 0;
400	driver->wait_late++;
401	}
402	// *status = -2; interrupt
403	// *status = -3; timeout
404	// *status = -4; extra FD
405
406	nframes=freebob_streaming_wait(driver->dev);
407
408	wait_ret = jack_get_microseconds ();
409
410	if (driver->wait_next && wait_ret > driver->wait_next) {
411	*delayed_usecs = wait_ret - driver->wait_next;
412	}
413	driver->wait_last = wait_ret;
414	driver->wait_next = wait_ret + driver->period_usecs;
415	driver->engine->transport_cycle_start (driver->engine, wait_ret);
416
417	// transfer the streaming buffers
418	// we now do this in the read/write functions
419	// freebob_streaming_transfer_buffers(driver->dev);
420
421	if (nframes < 0) {
422	*status=0;
423
424	return 0;
425	//nframes=driver->period_size; //debug
426	}
427
428	*status = 0;
429	driver->last_wait_ust = wait_ret;
430
431	// FIXME: this should do something more usefull
432	*delayed_usecs = 0;
433
434	printExit();
435
436	return nframes - nframes % driver->period_size;
437
438	}
439
440	static int
441	freebob_driver_run_cycle (freebob_driver_t *driver)
442	{
443	jack_engine_t *engine = driver->engine;
444	int wait_status=0;
445	float delayed_usecs=0.0;
446
447	jack_nframes_t nframes = freebob_driver_wait (driver, -1, &wait_status,
448	&delayed_usecs);
449
450	if ((wait_status < 0)) {
451	printError( "wait status < 0! (= %d)",wait_status);
452	return -1;
453	}
454
455	if ((nframes == 0)) {
456	/* we detected an xrun and restarted: notify
457	* clients about the delay. */
458	printMessage("xrun detected");
459	engine->delay (engine, delayed_usecs);
460	return 0;
461	}
462
463	return engine->run_cycle (engine, nframes, delayed_usecs);
464
465	}
466	/*
467	* in a null cycle we should discard the input and write silence to the outputs
468	*/
469	static int
470	freebob_driver_null_cycle (freebob_driver_t* driver, jack_nframes_t nframes)
471	{
472	channel_t chn;
473	JSList *node;
474	snd_pcm_sframes_t nwritten;
475
476	freebob_streaming_stream_type stream_type;
477
478	jack_default_audio_sample_t buff[nframes];
479	jack_default_audio_sample_t* buffer=(jack_default_audio_sample_t*)buff;
480
481	printEnter();
482
483	memset(buffer,0,nframes*sizeof(jack_default_audio_sample_t));
484
485	assert(driver->dev);
486
487	if (driver->engine->freewheeling) {
488	return 0;
489	}
490
491	// write silence to buffer
492	nwritten = 0;
493
494	for (chn = 0, node = driver->playback_ports; node; node = jack_slist_next (node), chn++) {
495	stream_type=freebob_streaming_get_playback_stream_type(driver->dev, chn);
496
497	if(stream_type == freebob_stream_type_audio) {
498	freebob_streaming_set_playback_stream_buffer(driver->dev, chn, (char *)(buffer));
499	}
500	}
501
502	freebob_streaming_transfer_playback_buffers(driver->dev);
503
504	// read & discard from input ports
505	for (chn = 0, node = driver->capture_ports; node; node = jack_slist_next (node), chn++) {
506	stream_type=freebob_streaming_get_capture_stream_type(driver->dev, chn);
507	if(stream_type == freebob_stream_type_audio) {
508	freebob_streaming_set_capture_stream_buffer(driver->dev, chn, (char *)(buffer));
509	}
510	}
511
512	// now transfer the buffers
513	freebob_streaming_transfer_capture_buffers(driver->dev);
514
515	printExit();
516	return 0;
517	}
518
519	static int
520	freebob_driver_start (freebob_driver_t *driver)
521	{
522	int retval=0;
523
524	#ifdef FREEBOB_DRIVER_WITH_MIDI
525	if(driver->midi_handle) {
526	if((retval=freebob_driver_midi_start(driver->midi_handle))) {
527	printError("Could not start MIDI threads");
528	return retval;
529	}
530	}
531	#endif
532
533	if((retval=freebob_streaming_start(driver->dev))) {
534	printError("Could not start streaming threads");
535	#ifdef FREEBOB_DRIVER_WITH_MIDI
536	if(driver->midi_handle) {
537	freebob_driver_midi_stop(driver->midi_handle);
538	}
539	#endif
540	return retval;
541	}
542
543	return 0;
544
545	}
546
547	static int
548	freebob_driver_stop (freebob_driver_t *driver)
549	{
550	int retval=0;
551
552	#ifdef FREEBOB_DRIVER_WITH_MIDI
553	if(driver->midi_handle) {
554	if((retval=freebob_driver_midi_stop(driver->midi_handle))) {
555	printError("Could not stop MIDI threads");
556	return retval;
557	}
558	}
559	#endif
560	if((retval=freebob_streaming_stop(driver->dev))) {
561	printError("Could not stop streaming threads");
562	return retval;
563	}
564
565	return 0;
566	}
567
568
569	static int
570	freebob_driver_bufsize (freebob_driver_t* driver, jack_nframes_t nframes)
571	{
572	printError("Buffer size change requested but not supported!!!");
573
574	/*
575	driver->period_size = nframes;
576	driver->period_usecs =
577	(jack_time_t) floor ((((float) nframes) / driver->sample_rate)
578	* 1000000.0f);
579	*/
580
581	/* tell the engine to change its buffer size */
582	//driver->engine->set_buffer_size (driver->engine, nframes);
583
584	return -1; // unsupported
585	}
586
587	typedef void (JackDriverFinishFunction) (jack_driver_t );
588
589	freebob_driver_t *
590	freebob_driver_new (jack_client_t * client,
591	char *name,
592	freebob_jack_settings_t *params)
593	{
594	freebob_driver_t *driver;
595
596	assert(params);
597
598	if(freebob_get_api_version() != 2) {
599	printError("Incompatible libfreebob version! (%s)", freebob_get_version());
600	return NULL;
601	}
602
603	printMessage("Starting Freebob backend (%s)", freebob_get_version());
604
605	driver = calloc (1, sizeof (freebob_driver_t));
606
607	/* Setup the jack interfaces */
608	jack_driver_nt_init ((jack_driver_nt_t *) driver);
609
610	driver->nt_attach = (JackDriverNTAttachFunction) freebob_driver_attach;
611	driver->nt_detach = (JackDriverNTDetachFunction) freebob_driver_detach;
612	driver->nt_start = (JackDriverNTStartFunction) freebob_driver_start;
613	driver->nt_stop = (JackDriverNTStopFunction) freebob_driver_stop;
614	driver->nt_run_cycle = (JackDriverNTRunCycleFunction) freebob_driver_run_cycle;
615	driver->null_cycle = (JackDriverNullCycleFunction) freebob_driver_null_cycle;
616	driver->write = (JackDriverReadFunction) freebob_driver_write;
617	driver->read = (JackDriverReadFunction) freebob_driver_read;
618	driver->nt_bufsize = (JackDriverNTBufSizeFunction) freebob_driver_bufsize;
619
620	/* copy command line parameter contents to the driver structure */
621	memcpy(&driver->settings,params,sizeof(freebob_jack_settings_t));
622
623	/* prepare all parameters */
624	driver->sample_rate = params->sample_rate;
625	driver->period_size = params->period_size;
626	driver->last_wait_ust = 0;
627
628	driver->period_usecs =
629	(jack_time_t) floor ((((float) driver->period_size) * 1000000.0f) / driver->sample_rate);
630
631	driver->client = client;
632	driver->engine = NULL;
633
634	memset(&driver->device_options,0,sizeof(driver->device_options));
635	driver->device_options.sample_rate=params->sample_rate;
636	driver->device_options.period_size=params->period_size;
637	driver->device_options.nb_buffers=params->buffer_size;
638	driver->device_options.node_id=params->node_id;
639	driver->device_options.port=params->port;
640
641	if(!params->capture_ports) {
642	driver->device_options.directions \|= FREEBOB_IGNORE_CAPTURE;
643	}
644
645	if(!params->playback_ports) {
646	driver->device_options.directions \|= FREEBOB_IGNORE_PLAYBACK;
647	}
648
649	debugPrint(DEBUG_LEVEL_STARTUP, " Driver compiled on %s %s", __DATE__, __TIME__);
650	debugPrint(DEBUG_LEVEL_STARTUP, " Created driver %s", name);
651	debugPrint(DEBUG_LEVEL_STARTUP, " period_size: %d", driver->period_size);
652	debugPrint(DEBUG_LEVEL_STARTUP, " period_usecs: %d", driver->period_usecs);
653	debugPrint(DEBUG_LEVEL_STARTUP, " sample rate: %d", driver->sample_rate);
654
655	return (freebob_driver_t *) driver;
656
657	}
658
659	static void
660	freebob_driver_delete (freebob_driver_t *driver)
661	{
662	jack_driver_nt_finish ((jack_driver_nt_t *) driver);
663	free (driver);
664	}
665
666	#ifdef FREEBOB_DRIVER_WITH_MIDI
667	/*
668	* MIDI support
669	*/
670
671	// the thread that will queue the midi events from the seq to the stream buffers
672
673	void * freebob_driver_midi_queue_thread(void *arg)
674	{
675	freebob_driver_midi_handle_t m=(freebob_driver_midi_handle_t )arg;
676	assert(m);
677	snd_seq_event_t *ev;
678	unsigned char work_buffer[MIDI_TRANSMIT_BUFFER_SIZE];
679	int bytes_to_send;
680	int b;
681	int i;
682
683	printMessage("MIDI queue thread started");
684
685	while(1) {
686	// get next event, if one is present
687	while ((snd_seq_event_input(m->seq_handle, &ev) > 0)) {
688	// get the port this event is originated from
689	freebob_midi_port_t *port=NULL;
690	for (i=0;i<m->nb_output_ports;i++) {
691	if(m->output_ports[i]->seq_port_nr == ev->dest.port) {
692	port=m->output_ports[i];
693	break;
694	}
695	}
696
697	if(!port) {
698	printError(" Could not find target port for event: dst=%d src=%d", ev->dest.port, ev->source.port);
699
700	break;
701	}
702
703	// decode it to the work buffer
704	if((bytes_to_send = snd_midi_event_decode ( port->parser,
705	work_buffer,
706	MIDI_TRANSMIT_BUFFER_SIZE,
707	ev))<0)
708	{ // failed
709	printError(" Error decoding event for port %d (errcode=%d)", port->seq_port_nr,bytes_to_send);
710	bytes_to_send=0;
711	//return -1;
712	}
713
714	for(b=0;b<bytes_to_send;b++) {
715	freebob_sample_t tmp_event=work_buffer[b];
716	if(freebob_streaming_write(m->dev, port->stream_nr, &tmp_event, 1)<1) {
717	printError(" Midi send buffer overrun");
718	}
719	}
720
721	}
722
723	// sleep for some time
724	usleep(MIDI_THREAD_SLEEP_TIME_USECS);
725	}
726	return NULL;
727	}
728
729	// the dequeue thread (maybe we need one thread per stream)
730	void freebob_driver_midi_dequeue_thread (void arg) {
731	freebob_driver_midi_handle_t m=(freebob_driver_midi_handle_t )arg;
732
733	int i;
734	int s;
735
736	int samples_read;
737
738	assert(m);
739
740	while(1) {
741	// read incoming events
742
743	for (i=0;i<m->nb_input_ports;i++) {
744	unsigned int buff[64];
745
746	freebob_midi_port_t *port=m->input_ports[i];
747
748	if(!port) {
749	printError(" something went wrong when setting up the midi input port map (%d)",i);
750	}
751
752	do {
753	samples_read=freebob_streaming_read(m->dev, port->stream_nr, buff, 64);
754
755	for (s=0;s<samples_read;s++) {
756	unsigned int *byte=(buff+s) ;
757	snd_seq_event_t ev;
758	if ((snd_midi_event_encode_byte(port->parser,(*byte) & 0xFF, &ev)) > 0) {
759	// a midi message is complete, send it out to ALSA
760	snd_seq_ev_set_subs(&ev);
761	snd_seq_ev_set_direct(&ev);
762	snd_seq_ev_set_source(&ev, port->seq_port_nr);
763	snd_seq_event_output_direct(port->seq_handle, &ev);
764	}
765	}
766	} while (samples_read>0);
767	}
768
769	// sleep for some time
770	usleep(MIDI_THREAD_SLEEP_TIME_USECS);
771	}
772	return NULL;
773	}
774
775	static freebob_driver_midi_handle_t freebob_driver_midi_init(freebob_driver_t driver) {
776	// int err;
777
778	char buf[256];
779	channel_t chn;
780	int nchannels;
781	int i=0;
782
783	freebob_device_t *dev=driver->dev;
784
785	assert(dev);
786
787	freebob_driver_midi_handle_t *m=calloc(1,sizeof(freebob_driver_midi_handle_t));
788	if (!m) {
789	printError("not enough memory to create midi structure");
790	return NULL;
791	}
792
793	if (snd_seq_open(&m->seq_handle, "default", SND_SEQ_OPEN_DUPLEX, SND_SEQ_NONBLOCK) < 0) {
794	printError("Error opening ALSA sequencer.");
795	free(m);
796	return NULL;
797	}
798
799	snd_seq_set_client_name(m->seq_handle, "FreeBoB Jack MIDI");
800
801	// find out the number of midi in/out ports we need to setup
802	nchannels=freebob_streaming_get_nb_capture_streams(dev);
803
804	m->nb_input_ports=0;
805
806	for (chn = 0; chn < nchannels; chn++) {
807	if(freebob_streaming_get_capture_stream_type(dev, chn) == freebob_stream_type_midi) {
808	m->nb_input_ports++;
809	}
810	}
811
812	m->input_ports=calloc(m->nb_input_ports,sizeof(freebob_midi_port_t *));
813	if(!m->input_ports) {
814	printError("not enough memory to create midi structure");
815	free(m);
816	return NULL;
817	}
818
819	i=0;
820	for (chn = 0; chn < nchannels; chn++) {
821	if(freebob_streaming_get_capture_stream_type(dev, chn) == freebob_stream_type_midi) {
822	m->input_ports[i]=calloc(1,sizeof(freebob_midi_port_t));
823	if(!m->input_ports[i]) {
824	// fixme
825	printError("Could not allocate memory for seq port");
826	continue;
827	}
828
829	freebob_streaming_get_capture_stream_name(dev, chn, buf, sizeof(buf) - 1);
830	printMessage("Register MIDI IN port %s", buf);
831
832	m->input_ports[i]->seq_port_nr=snd_seq_create_simple_port(m->seq_handle, buf,
833	SND_SEQ_PORT_CAP_READ\|SND_SEQ_PORT_CAP_SUBS_READ,
834	SND_SEQ_PORT_TYPE_MIDI_GENERIC);
835
836	if(m->input_ports[i]->seq_port_nr<0) {
837	printError("Could not create seq port");
838	m->input_ports[i]->stream_nr=-1;
839	m->input_ports[i]->seq_port_nr=-1;
840	} else {
841	m->input_ports[i]->stream_nr=chn;
842	m->input_ports[i]->seq_handle=m->seq_handle;
843	if (snd_midi_event_new ( ALSA_SEQ_BUFF_SIZE, &(m->input_ports[i]->parser)) < 0) {
844	printError("could not init parser for MIDI IN port %d",i);
845	m->input_ports[i]->stream_nr=-1;
846	m->input_ports[i]->seq_port_nr=-1;
847	} else {
848	if(freebob_streaming_set_capture_buffer_type(dev, chn, freebob_buffer_type_midi)) {
849	printError(" cannot set port buffer type for %s", buf);
850	m->input_ports[i]->stream_nr=-1;
851	m->input_ports[i]->seq_port_nr=-1;
852	}
853	if(freebob_streaming_capture_stream_onoff(dev, chn, 1)) {
854	printError(" cannot enable port %s", buf);
855	m->input_ports[i]->stream_nr=-1;
856	m->input_ports[i]->seq_port_nr=-1;
857	}
858
859	}
860	}
861
862	i++;
863	}
864	}
865
866	// playback
867	nchannels=freebob_streaming_get_nb_playback_streams(dev);
868
869	m->nb_output_ports=0;
870
871	for (chn = 0; chn < nchannels; chn++) {
872	if(freebob_streaming_get_playback_stream_type(dev, chn) == freebob_stream_type_midi) {
873	m->nb_output_ports++;
874	}
875	}
876
877	m->output_ports=calloc(m->nb_output_ports,sizeof(freebob_midi_port_t *));
878	if(!m->output_ports) {
879	printError("not enough memory to create midi structure");
880	for (i = 0; i < m->nb_input_ports; i++) {
881	free(m->input_ports[i]);
882	}
883	free(m->input_ports);
884	free(m);
885	return NULL;
886	}
887
888	i=0;
889	for (chn = 0; chn < nchannels; chn++) {
890	if(freebob_streaming_get_playback_stream_type(dev, chn) == freebob_stream_type_midi) {
891	m->output_ports[i]=calloc(1,sizeof(freebob_midi_port_t));
892	if(!m->output_ports[i]) {
893	// fixme
894	printError("Could not allocate memory for seq port");
895	continue;
896	}
897
898	freebob_streaming_get_playback_stream_name(dev, chn, buf, sizeof(buf) - 1);
899	printMessage("Register MIDI OUT port %s", buf);
900
901	m->output_ports[i]->seq_port_nr=snd_seq_create_simple_port(m->seq_handle, buf,
902	SND_SEQ_PORT_CAP_WRITE\|SND_SEQ_PORT_CAP_SUBS_WRITE,
903	SND_SEQ_PORT_TYPE_MIDI_GENERIC);
904
905
906	if(m->output_ports[i]->seq_port_nr<0) {
907	printError("Could not create seq port");
908	m->output_ports[i]->stream_nr=-1;
909	m->output_ports[i]->seq_port_nr=-1;
910	} else {
911	m->output_ports[i]->stream_nr=chn;
912	m->output_ports[i]->seq_handle=m->seq_handle;
913	if (snd_midi_event_new ( ALSA_SEQ_BUFF_SIZE, &(m->output_ports[i]->parser)) < 0) {
914	printError("could not init parser for MIDI OUT port %d",i);
915	m->output_ports[i]->stream_nr=-1;
916	m->output_ports[i]->seq_port_nr=-1;
917	} else {
918	if(freebob_streaming_set_playback_buffer_type(dev, chn, freebob_buffer_type_midi)) {
919	printError(" cannot set port buffer type for %s", buf);
920	m->input_ports[i]->stream_nr=-1;
921	m->input_ports[i]->seq_port_nr=-1;
922	}
923	if(freebob_streaming_playback_stream_onoff(dev, chn, 1)) {
924	printError(" cannot enable port %s", buf);
925	m->input_ports[i]->stream_nr=-1;
926	m->input_ports[i]->seq_port_nr=-1;
927	}
928	}
929	}
930
931	i++;
932	}
933	}
934
935	m->dev=dev;
936	m->driver=driver;
937
938	return m;
939	}
940
941	static int
942	freebob_driver_midi_start (freebob_driver_midi_handle_t *m)
943	{
944	assert(m);
945	// start threads
946
947	m->queue_thread_realtime=(m->driver->engine->control->real_time? 1 : 0);
948	m->queue_thread_priority=
949	m->driver->engine->control->client_priority +
950	FREEBOB_RT_PRIORITY_MIDI_RELATIVE;
951
952	if (m->queue_thread_priority>98) {
953	m->queue_thread_priority=98;
954	}
955	if (m->queue_thread_realtime) {
956	printMessage("MIDI threads running with Realtime scheduling, priority %d",
957	m->queue_thread_priority);
958	} else {
959	printMessage("MIDI threads running without Realtime scheduling");
960	}
961
962	if (jack_client_create_thread(NULL, &m->queue_thread, m->queue_thread_priority, m->queue_thread_realtime, freebob_driver_midi_queue_thread, (void *)m)) {
963	printError(" cannot create midi queueing thread");
964	return -1;
965	}
966
967	if (jack_client_create_thread(NULL, &m->dequeue_thread, m->queue_thread_priority, m->queue_thread_realtime, freebob_driver_midi_dequeue_thread, (void *)m)) {
968	printError(" cannot create midi dequeueing thread");
969	return -1;
970	}
971	return 0;
972	}
973
974	static int
975	freebob_driver_midi_stop (freebob_driver_midi_handle_t *m)
976	{
977	assert(m);
978
979	pthread_cancel (m->queue_thread);
980	pthread_join (m->queue_thread, NULL);
981
982	pthread_cancel (m->dequeue_thread);
983	pthread_join (m->dequeue_thread, NULL);
984	return 0;
985
986	}
987
988	static void
989	freebob_driver_midi_finish (freebob_driver_midi_handle_t *m)
990	{
991	assert(m);
992
993	int i;
994	// TODO: add state info here, if not stopped then stop
995
996	for (i=0;i<m->nb_input_ports;i++) {
997	free(m->input_ports[i]);
998
999	}
1000	free(m->input_ports);
1001
1002	for (i=0;i<m->nb_output_ports;i++) {
1003	free(m->output_ports[i]);
1004	}
1005	free(m->output_ports);
1006
1007	free(m);
1008	}
1009	#endif
1010	/*
1011	* dlopen plugin stuff
1012	*/
1013
1014	const char driver_client_name[] = "freebob_pcm";
1015
1016	const jack_driver_desc_t *
1017	driver_get_descriptor ()
1018	{
1019	jack_driver_desc_t * desc;
1020	jack_driver_param_desc_t * params;
1021	unsigned int i;
1022
1023	desc = calloc (1, sizeof (jack_driver_desc_t));
1024
1025	strcpy (desc->name, "freebob");
1026	desc->nparams = 6;
1027
1028	params = calloc (desc->nparams, sizeof (jack_driver_param_desc_t));
1029	desc->params = params;
1030
1031	i = 0;
1032	strcpy (params[i].name, "device");
1033	params[i].character = 'd';
1034	params[i].type = JackDriverParamString;
1035	strcpy (params[i].value.str, "hw:0");
1036	strcpy (params[i].short_desc, "The FireWire device to use. Format is: 'hw:port[,node]'.");
1037	strcpy (params[i].long_desc, params[i].short_desc);
1038
1039	i++;
1040	strcpy (params[i].name, "period");
1041	params[i].character = 'p';
1042	params[i].type = JackDriverParamUInt;
1043	params[i].value.ui = 1024;
1044	strcpy (params[i].short_desc, "Frames per period");
1045	strcpy (params[i].long_desc, params[i].short_desc);
1046
1047	i++;
1048	strcpy (params[i].name, "nperiods");
1049	params[i].character = 'n';
1050	params[i].type = JackDriverParamUInt;
1051	params[i].value.ui = 3;
1052	strcpy (params[i].short_desc, "Number of periods of playback latency");
1053	strcpy (params[i].long_desc, params[i].short_desc);
1054
1055	i++;
1056	strcpy (params[i].name, "rate");
1057	params[i].character = 'r';
1058	params[i].type = JackDriverParamUInt;
1059	params[i].value.ui = 48000U;
1060	strcpy (params[i].short_desc, "Sample rate");
1061	strcpy (params[i].long_desc, params[i].short_desc);
1062
1063	i++;
1064	strcpy (params[i].name, "capture");
1065	params[i].character = 'i';
1066	params[i].type = JackDriverParamUInt;
1067	params[i].value.ui = 1U;
1068	strcpy (params[i].short_desc, "Provide capture ports.");
1069	strcpy (params[i].long_desc, params[i].short_desc);
1070
1071	i++;
1072	strcpy (params[i].name, "playback");
1073	params[i].character = 'o';
1074	params[i].type = JackDriverParamUInt;
1075	params[i].value.ui = 1U;
1076	strcpy (params[i].short_desc, "Provide playback ports.");
1077	strcpy (params[i].long_desc, params[i].short_desc);
1078
1079	return desc;
1080	}
1081
1082
1083	jack_driver_t *
1084	driver_initialize (jack_client_t client, JSList params)
1085	{
1086	jack_driver_t *driver;
1087
1088	unsigned int port=0;
1089	unsigned int node_id=-1;
1090	int nbitems;
1091
1092	const JSList * node;
1093	const jack_driver_param_t * param;
1094
1095	freebob_jack_settings_t cmlparams;
1096
1097	char *device_name="hw:0";
1098
1099	cmlparams.period_size_set=0;
1100	cmlparams.sample_rate_set=0;
1101	cmlparams.buffer_size_set=0;
1102	cmlparams.port_set=0;
1103	cmlparams.node_id_set=0;
1104
1105	/* default values */
1106	cmlparams.period_size=1024;
1107	cmlparams.sample_rate=48000;
1108	cmlparams.buffer_size=3;
1109	cmlparams.port=0;
1110	cmlparams.node_id=-1;
1111	cmlparams.playback_ports=1;
1112	cmlparams.capture_ports=1;
1113
1114	for (node = params; node; node = jack_slist_next (node))
1115	{
1116	param = (jack_driver_param_t *) node->data;
1117
1118	switch (param->character)
1119	{
1120	case 'd':
1121	device_name = strdup (param->value.str);
1122	break;
1123	case 'p':
1124	cmlparams.period_size = param->value.ui;
1125	cmlparams.period_size_set = 1;
1126	break;
1127	case 'n':
1128	cmlparams.buffer_size = param->value.ui;
1129	cmlparams.buffer_size_set = 1;
1130	break;
1131	case 'r':
1132	cmlparams.sample_rate = param->value.ui;
1133	cmlparams.sample_rate_set = 1;
1134	break;
1135	case 'i':
1136	cmlparams.capture_ports = param->value.ui;
1137	break;
1138	case 'o':
1139	cmlparams.playback_ports = param->value.ui;
1140	break;
1141	}
1142	}
1143
1144	nbitems=sscanf(device_name,"hw:%u,%u",&port,&node_id);
1145	if (nbitems<2) {
1146	nbitems=sscanf(device_name,"hw:%u",&port);
1147
1148	if(nbitems < 1) {
1149	free(device_name);
1150	printError("device (-d) argument not valid\n");
1151	return NULL;
1152	} else {
1153	cmlparams.port = port;
1154	cmlparams.port_set=1;
1155
1156	cmlparams.node_id = -1;
1157	cmlparams.node_id_set=0;
1158	}
1159	} else {
1160	cmlparams.port = port;
1161	cmlparams.port_set=1;
1162
1163	cmlparams.node_id = node_id;
1164	cmlparams.node_id_set=1;
1165	}
1166
1167	jack_error("Freebob using Firewire port %d, node %d",cmlparams.port,cmlparams.node_id);
1168
1169	driver=(jack_driver_t *)freebob_driver_new (client, "freebob_pcm", &cmlparams);
1170
1171	return driver;
1172	}
1173
1174	void
1175	driver_finish (jack_driver_t *driver)
1176	{
1177	freebob_driver_t drv=(freebob_driver_t ) driver;
1178	// If jack hasn't called the detach method, do it now. As of jack 0.101.1
1179	// the detach method was not being called explicitly on closedown, and
1180	// we need it to at least deallocate the iso resources.
1181	if (drv->dev != NULL)
1182	freebob_driver_detach(drv);
1183	freebob_driver_delete (drv);
1184	}

Note: See TracBrowser for help on using the browser.

root/branches/libfreebob-2.0/support/jack/freebob_driver.c

Download in other formats: