jackaudio
/
jack1
mirror of https://github.com/jackaudio/jack1
1
0
Fork 0
Code Releases 19 Activity
jack1 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1348 Commits
4 Branches
7.0MB
Tree: 27ea8647fa
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '27ea8647fa'
${ noResults }
jack1/drivers/oss/oss_driver.c

1318 lines
30KB
Raw Blame History 

  1. /*

  2. 

  3. 	OSS driver for Jack

  4. 	Copyright (C) 2003-2007 Jussi Laako <jussi@sonarnerd.net>

  5. 

  6. 	This program is free software; you can redistribute it and/or modify

  7. 	it under the terms of the GNU General Public License as published by

  8. 	the Free Software Foundation; either version 2 of the License, or

  9. 	(at your option) any later version.

  10. 

  11. 	This program is distributed in the hope that it will be useful,

  12. 	but WITHOUT ANY WARRANTY; without even the implied warranty of

  13. 	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  14. 	GNU General Public License for more details.

  15. 

  16. 	You should have received a copy of the GNU General Public License

  17. 	along with this program; if not, write to the Free Software

  18. 	Foundation, Inc., 59 Temple Place, Suite 330, Boston,

  19. 	MA  02111-1307  USA

  20. 

  21. */

  22. 

  23. 

  24. #include <config.h>

  25. 

  26. #ifdef USE_BARRIER

  27. /*

  28.  * POSIX conformance level should be globally defined somewhere, possibly

  29.  * in config.h? Otherwise it's pre 1993/09 level, which leaves out significant

  30.  * parts of threading and realtime stuff. Note: most of the parts are still

  31.  * defined as optional by the standard, so OS conformance to this level

  32.  * doesn't necessarily mean everything exists.

  33.  */

  34. #define _XOPEN_SOURCE	600

  35. #endif

  36. #ifndef _REENTRANT

  37. #define _REENTRANT

  38. #endif

  39. #ifndef _THREAD_SAFE

  40. #define _THREAD_SAFE

  41. #endif

  42. #include <unistd.h>

  43. #include <pthread.h>

  44. #include <stdlib.h>

  45. #include <string.h>

  46. #include <stdio.h>

  47. #include <fcntl.h>

  48. #include <errno.h>

  49. #include <math.h>

  50. #include <float.h>

  51. #include <stdarg.h>

  52. #include <getopt.h>

  53. #include <semaphore.h>

  54. 

  55. #include <sys/types.h>

  56. #include <sys/stat.h>

  57. #include <sys/ioctl.h>

  58. #include <sys/soundcard.h>

  59. 

  60. #include <jack/types.h>

  61. #include <jack/internal.h>

  62. #include <jack/engine.h>

  63. #include <jack/thread.h>

  64. #include <sysdeps/time.h>

  65. 

  66. #include "oss_driver.h"

  67. 

  68. 

  69. #ifndef SNDCTL_DSP_COOKEDMODE

  70. #ifdef _SIOWR

  71. #define SNDCTL_DSP_COOKEDMODE _SIOWR('P', 30, int)

  72. #else  /* _SIOWR */

  73. #warning "Unable to define cooked mode!"

  74. #define OSS_NO_COOKED_MODE

  75. #endif  /* _SIOWR */

  76. #endif  /* SNDCTL_DSP_COOKEDMODE */

  77. 

  78. #define OSS_DRIVER_N_PARAMS	11

  79. const static jack_driver_param_desc_t oss_params[OSS_DRIVER_N_PARAMS] = {

  80. 	{ "rate",

  81. 	  'r',

  82. 	  JackDriverParamUInt,

  83. 	  { .ui = OSS_DRIVER_DEF_FS },

  84. 	  "sample rate",

  85. 	  "sample rate"

  86. 	},

  87. 	{ "period",

  88. 	  'p',

  89. 	  JackDriverParamUInt,

  90. 	  { .ui = OSS_DRIVER_DEF_BLKSIZE },

  91. 	  "period size",

  92. 	  "period size"

  93. 	},

  94. 	{ "nperiods",

  95. 	  'n',

  96. 	  JackDriverParamUInt,

  97. 	  { .ui = OSS_DRIVER_DEF_NPERIODS },

  98. 	  "number of periods in buffer",

  99. 	  "number of periods in buffer"

  100. 	},

  101. 	{ "wordlength",

  102. 	  'w',

  103. 	  JackDriverParamInt,

  104. 	  { .i = OSS_DRIVER_DEF_BITS },

  105. 	  "word length",

  106. 	  "word length"

  107. 	},

  108. 	{ "inchannels",

  109. 	  'i',

  110. 	  JackDriverParamUInt,

  111. 	  { .ui = OSS_DRIVER_DEF_INS },

  112. 	  "capture channels",

  113. 	  "capture channels"

  114. 	},

  115. 	{ "outchannels",

  116. 	  'o',

  117. 	  JackDriverParamUInt,

  118. 	  { .ui = OSS_DRIVER_DEF_OUTS },

  119. 	  "playback channels",

  120. 	  "playback channels"

  121. 	},

  122. 	{ "capture",

  123. 	  'C',

  124. 	  JackDriverParamString,

  125. 	  { .str = OSS_DRIVER_DEF_DEV },

  126. 	  "input device",

  127. 	  "input device"

  128. 	},

  129. 	{ "playback",

  130. 	  'P',

  131. 	  JackDriverParamString,

  132. 	  { .str = OSS_DRIVER_DEF_DEV },

  133. 	  "output device",

  134. 	  "output device"

  135. 	},

  136. 	{ "ignorehwbuf",

  137. 	  'b',

  138. 	  JackDriverParamBool,

  139. 	  { },

  140. 	  "ignore hardware period size",

  141. 	  "ignore hardware period size"

  142. 	},

  143. 	{ "input latency",

  144. 	  'I',

  145. 	  JackDriverParamUInt,

  146. 	  { .ui = 0 },

  147. 	  "system input latency",

  148. 	  "system input latency"

  149. 	},

  150. 	{ "output latency",

  151. 	  'O',

  152. 	  JackDriverParamUInt,

  153. 	  { .ui = 0 },

  154. 	  "system output latency",

  155. 	  "system output latency"

  156. 	}

  157. };

  158. 

  159. 

  160. 

  161. /* internal functions */

  162. 

  163. 

  164. static void set_period_size (oss_driver_t *driver, 

  165. 	jack_nframes_t new_period_size)

  166. {

  167. 	driver->period_size = new_period_size;

  168. 

  169. 	driver->period_usecs = 

  170. 		((double) driver->period_size /

  171. 		(double) driver->sample_rate) * 1e6;

  172. 	driver->last_wait_ust = 0;

  173. 	driver->last_periodtime = jack_get_microseconds();

  174. 	driver->next_periodtime = 0;

  175. 	driver->iodelay = 0.0F;

  176. }

  177. 

  178. 

  179. static inline void update_times (oss_driver_t *driver)

  180. {

  181. 	driver->last_periodtime = jack_get_microseconds();

  182. 	if (driver->next_periodtime > 0)

  183. 	{

  184. 		driver->iodelay = (float)

  185. 			((long double) driver->last_periodtime - 

  186. 			(long double) driver->next_periodtime);

  187. 	}

  188. 	else driver->iodelay = 0.0F;

  189. 	driver->next_periodtime = 

  190. 		driver->last_periodtime +

  191. 		driver->period_usecs;

  192. }

  193. 

  194. 

  195. static inline void driver_cycle (oss_driver_t *driver)

  196. {

  197. 	update_times(driver);

  198. 	driver->engine->transport_cycle_start(driver->engine,

  199. 		driver->last_periodtime);

  200. 

  201. 	driver->last_wait_ust = driver->last_periodtime;

  202. 	driver->engine->run_cycle(driver->engine, 

  203. 		driver->period_size, driver->iodelay);

  204. }

  205. 

  206. 

  207. static void copy_and_convert_in (jack_sample_t *dst, void *src, 

  208. 	size_t nframes,	int channel, int chcount, int bits)

  209. {

  210. 	int srcidx;

  211. 	int dstidx;

  212. 	signed short *s16src = (signed short *) src;

  213. 	signed int *s32src = (signed int *) src;

  214. 	double *f64src = (double *) src;

  215. 	jack_sample_t scale;

  216. 

  217. 	srcidx = channel;

  218. 	switch (bits)

  219. 	{

  220. 		case 16:

  221. 			scale = 1.0f / 0x7fff;

  222. 			for (dstidx = 0; dstidx < nframes; dstidx++)

  223. 			{

  224. 				dst[dstidx] = (jack_sample_t) 

  225. 					s16src[srcidx] * scale;

  226. 				srcidx += chcount;

  227. 			}

  228. 			break;

  229. 		case 24:

  230. 			scale = 1.0f / 0x7fffff;

  231. 			for (dstidx = 0; dstidx < nframes; dstidx++)

  232. 			{

  233. 				dst[dstidx] = (jack_sample_t)

  234. 					s32src[srcidx] * scale;

  235. 				srcidx += chcount;

  236. 			}

  237. 			break;

  238. 		case 32:

  239. 			scale = 1.0f / 0x7fffffff;

  240. 			for (dstidx = 0; dstidx < nframes; dstidx++)

  241. 			{

  242. 				dst[dstidx] = (jack_sample_t)

  243. 					s32src[srcidx] * scale;

  244. 				srcidx += chcount;

  245. 			}

  246. 			break;

  247. 		case 64:

  248. 			for (dstidx = 0; dstidx < nframes; dstidx++)

  249. 			{

  250. 				dst[dstidx] = (jack_sample_t) f64src[srcidx];

  251. 				srcidx += chcount;

  252. 			}

  253. 			break;

  254. 	}

  255. }

  256. 

  257. 

  258. static void copy_and_convert_out (void *dst, jack_sample_t *src, 

  259. 	size_t nframes,	int channel, int chcount, int bits)

  260. {

  261. 	int srcidx;

  262. 	int dstidx;

  263. 	signed short *s16dst = (signed short *) dst;

  264. 	signed int *s32dst = (signed int *) dst;

  265. 	double *f64dst = (double *) dst;

  266. 	jack_sample_t scale;

  267. 

  268. 	dstidx = channel;

  269. 	switch (bits)

  270. 	{

  271. 		case 16:

  272. 			scale = 0x7fff;

  273. 			for (srcidx = 0; srcidx < nframes; srcidx++)

  274. 			{

  275. 				s16dst[dstidx] = (signed short)

  276. 					(src[srcidx] >= 0.0f) ?

  277. 					(src[srcidx] * scale + 0.5f) :

  278. 					(src[srcidx] * scale - 0.5f);

  279. 				dstidx += chcount;

  280. 			}

  281. 			break;

  282. 		case 24:

  283. 			scale = 0x7fffff;

  284. 			for (srcidx = 0; srcidx < nframes; srcidx++)

  285. 			{

  286. 				s32dst[dstidx] = (signed int)

  287. 					(src[srcidx] >= 0.0f) ?

  288. 					(src[srcidx] * scale + 0.5f) :

  289. 					(src[srcidx] * scale - 0.5f);

  290. 				dstidx += chcount;

  291. 			}

  292. 			break;

  293. 		case 32:

  294. 			scale = 0x7fffffff;

  295. 			for (srcidx = 0; srcidx < nframes; srcidx++)

  296. 			{

  297. 				s32dst[dstidx] = (signed int)

  298. 					(src[srcidx] >= 0.0f) ?

  299. 					(src[srcidx] * scale + 0.5f) :

  300. 					(src[srcidx] * scale - 0.5f);

  301. 				dstidx += chcount;

  302. 			}

  303. 			break;

  304. 		case 64:

  305. 			for (srcidx = 0; srcidx < nframes; srcidx++)

  306. 			{

  307. 				f64dst[dstidx] = (double) src[srcidx];

  308. 				dstidx += chcount;

  309. 			}

  310. 			break;

  311. 	}

  312. }

  313. 

  314. 

  315. static void set_fragment (int fd, size_t fragsize, unsigned int fragcount)

  316. {

  317. 	int fragsize_2p;

  318. 	int fragments;

  319. 

  320. 	fragsize_2p = (int) (log(fragsize) / log(2.0) + 0.5);

  321. 	fragments = ((fragcount << 16) | (fragsize_2p & 0xffff));

  322. 	if (ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &fragments) < 0)

  323. 	{

  324. 		jack_error("OSS: failed to set fragment size: %s@%i, errno=%d",

  325. 			__FILE__, __LINE__, errno);

  326. 	}

  327. }

  328. 

  329. 

  330. static int get_fragment (int fd)

  331. {

  332. 	int fragsize;

  333. 

  334. 	if (ioctl(fd, SNDCTL_DSP_GETBLKSIZE, &fragsize) < 0)

  335. 	{

  336. 		jack_error("OSS: failed to get fragment size: %s@%i, errno=%d",

  337. 			__FILE__, __LINE__, errno);

  338. 		return 0;

  339. 	}

  340. 	return fragsize;

  341. }

  342. 

  343. 

  344. static void *io_thread (void *);

  345. 

  346. 

  347. /* jack driver interface */

  348. 

  349. 

  350. static int oss_driver_attach (oss_driver_t *driver, jack_engine_t *engine)

  351. {

  352. 	int port_flags;

  353. 	unsigned int channel;

  354. 	char channel_name[64];

  355. 	jack_port_t *port;

  356. 

  357. 	driver->engine = engine;

  358. 

  359. 	if (engine->set_buffer_size(engine, driver->period_size)) {

  360. 		jack_error ("OSS: cannot set engine buffer size to %d (check MIDI)", driver->period_size);

  361. 		return -1;

  362. 	}

  363. 	engine->set_sample_rate(engine, driver->sample_rate);

  364. 

  365. 	port_flags = JackPortIsOutput|JackPortIsPhysical|JackPortIsTerminal;

  366. 	for (channel = 0; channel < driver->capture_channels; channel++)

  367. 	{

  368. 		snprintf(channel_name, sizeof(channel_name), 

  369. 			"capture_%u", channel + 1);

  370. 		port = jack_port_register(driver->client, channel_name,

  371. 			JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);

  372. 		if (port == NULL)

  373. 		{

  374. 			jack_error("OSS: cannot register port for %s: %s@%i",

  375. 				channel_name, __FILE__, __LINE__);

  376. 			break;

  377. 		}

  378. 		jack_port_set_latency(port,

  379. 			driver->period_size + driver->sys_in_latency);

  380. 		driver->capture_ports = 

  381. 			jack_slist_append(driver->capture_ports, port);

  382. 	}

  383. 

  384. 	port_flags = JackPortIsInput|JackPortIsPhysical|JackPortIsTerminal;

  385. 	for (channel = 0; channel < driver->playback_channels; channel++)

  386. 	{

  387. 		snprintf(channel_name, sizeof(channel_name),

  388. 			"playback_%u", channel + 1);

  389. 		port = jack_port_register(driver->client, channel_name,

  390. 			JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);

  391. 		if (port == NULL)

  392. 		{

  393. 			jack_error("OSS: cannot register port for %s: %s@%i",

  394. 				channel_name, __FILE__, __LINE__);

  395. 			break;

  396. 		}

  397. 		jack_port_set_latency(port,

  398. 			driver->period_size + driver->sys_out_latency);

  399. 		driver->playback_ports =

  400. 			jack_slist_append(driver->playback_ports, port);

  401. 	}

  402. 

  403. 	jack_activate(driver->client);

  404. 

  405. 	return 0;

  406. }

  407. 

  408. 

  409. static int oss_driver_detach (oss_driver_t *driver, jack_engine_t *engine)

  410. {

  411. 	JSList *node;

  412. 

  413. 	if (driver->engine == NULL)

  414. 		return -1;

  415. 

  416. 	/*jack_deactivate(driver->client);*/	/* ? */

  417. 

  418. 	node = driver->capture_ports;

  419. 	while (node != NULL)

  420. 	{

  421. 		jack_port_unregister(driver->client, 

  422. 			((jack_port_t *) node->data));

  423. 		node = jack_slist_next(node);

  424. 	}

  425. 	jack_slist_free(driver->capture_ports);

  426. 	driver->capture_ports = NULL;

  427. 

  428. 	node = driver->playback_ports;

  429. 	while (node != NULL)

  430. 	{

  431. 		jack_port_unregister(driver->client,

  432. 			((jack_port_t *) node->data));

  433. 		node = jack_slist_next(node);

  434. 	}

  435. 	jack_slist_free(driver->playback_ports);

  436. 	driver->playback_ports = NULL;

  437. 

  438. 	driver->engine = NULL;

  439. 

  440. 	return 0;

  441. }

  442. 

  443. 

  444. static int oss_driver_start (oss_driver_t *driver)

  445. {

  446. 	int flags = 0;

  447. 	int format;

  448. 	int channels;

  449. 	int samplerate;

  450. 	int infd = driver->infd;

  451. 	int outfd = driver->outfd;

  452. 	unsigned int period_size;

  453. 	size_t samplesize;

  454. 	size_t fragsize;

  455. 	const char *indev = driver->indev;

  456. 	const char *outdev = driver->outdev;

  457. 

  458. 	switch (driver->bits)

  459. 	{

  460. 		case 24:

  461. 		case 32:

  462. 			samplesize = sizeof(int);

  463. 			break;

  464. 		case 64:

  465. 			samplesize = sizeof(double);

  466. 			break;

  467. 		case 16:

  468. 		default:

  469. 			samplesize = sizeof(short);

  470. 			break;

  471. 	}

  472. 	driver->trigger = 0;

  473. 	if (strcmp(indev, outdev) != 0)

  474. 	{

  475. 		if (driver->capture_channels > 0)

  476. 		{

  477. 			infd = open(indev, O_RDONLY|O_EXCL);

  478. 			if (infd < 0)

  479. 			{

  480. 				jack_error(

  481. 					"OSS: failed to open input device %s: %s@%i, errno=%d",

  482. 					indev, __FILE__, __LINE__, errno);

  483. 			}

  484. #ifndef OSS_NO_COOKED_MODE

  485. 			ioctl(infd, SNDCTL_DSP_COOKEDMODE, &flags);

  486. #endif

  487. 			fragsize = driver->period_size * 

  488. 				driver->capture_channels * samplesize;

  489. 			set_fragment(infd, fragsize, driver->nperiods);

  490. 		}

  491. 		else infd = -1;

  492. 

  493. 		if (driver->playback_channels > 0)

  494. 		{

  495. 			outfd = open(outdev, O_WRONLY|O_EXCL);

  496. 			if (outfd < 0)

  497. 			{

  498. 				jack_error(

  499. 					"OSS: failed to open output device %s: %s@%i, errno=%d",

  500. 					outdev, __FILE__, __LINE__, errno);

  501. 			}

  502. #ifndef OSS_NO_COOKED_MODE

  503. 			ioctl(outfd, SNDCTL_DSP_COOKEDMODE, &flags);

  504. #endif

  505. 			fragsize = driver->period_size * 

  506. 				driver->playback_channels * samplesize;

  507. 			set_fragment(outfd, fragsize, driver->nperiods);

  508. 		}

  509. 		else outfd = -1;

  510. 	}

  511. 	else

  512. 	{

  513. 		if (driver->capture_channels != 0 &&

  514. 			driver->playback_channels == 0)

  515. 		{

  516. 			infd = open(indev, O_RDWR|O_EXCL);

  517. 			outfd = -1;

  518. 			if (infd < 0)

  519. 			{

  520. 				jack_error(

  521. 					"OSS: failed to open device %s: %s@%i, errno=%d",

  522. 					indev, __FILE__, __LINE__, errno);

  523. 				return -1;

  524. 			}

  525. #ifndef OSS_NO_COOKED_MODE

  526. 			ioctl(infd, SNDCTL_DSP_COOKEDMODE, &flags);

  527. #endif

  528. 		}

  529. 		else if (driver->capture_channels == 0 &&

  530. 			driver->playback_channels != 0)

  531. 		{

  532. 			infd = -1;

  533. 			outfd = open(outdev, O_RDWR|O_EXCL);

  534. 			if (outfd < 0)

  535. 			{

  536. 				jack_error(

  537. 					"OSS: failed to open device %s: %s@%i, errno=%d",

  538. 					outdev, __FILE__, __LINE__, errno);

  539. 				return -1;

  540. 			}

  541. #ifndef OSS_NO_COOKED_MODE

  542. 			ioctl(outfd, SNDCTL_DSP_COOKEDMODE, &flags);

  543. #endif

  544. 		}

  545. 		else

  546. 		{

  547. 			infd = outfd = open(indev, O_RDWR|O_EXCL);

  548. 			if (infd < 0)

  549. 			{

  550. 				jack_error(

  551. 					"OSS: failed to open device %s: %s@%i, errno=%d",

  552. 					indev, __FILE__, __LINE__, errno);

  553. 				return -1;

  554. 			}

  555. #ifndef OSS_NO_COOKED_MODE

  556. 			ioctl(infd, SNDCTL_DSP_COOKEDMODE, &flags);

  557. #endif

  558. 		}

  559. 		if (infd >= 0 && outfd >= 0)

  560. 		{

  561. 			ioctl(outfd, SNDCTL_DSP_SETTRIGGER, &driver->trigger);

  562. 			driver->trigger = (PCM_ENABLE_INPUT|PCM_ENABLE_OUTPUT);

  563. 			if (ioctl(infd, SNDCTL_DSP_SETDUPLEX, 0) < 0)

  564. 			{

  565. 				if (errno != EINVAL) /* Dont care */

  566. 					jack_error(

  567. 						"OSS: failed to enable full duplex for %s: %s@%i, errno=%d",

  568. 						indev, __FILE__, __LINE__,

  569. 						errno);

  570. 			}

  571. 		}

  572. 		if (infd >= 0)

  573. 		{

  574. 			fragsize = driver->period_size * 

  575. 				driver->capture_channels * samplesize;

  576. 			set_fragment(infd, fragsize, driver->nperiods);

  577. 		}

  578. 		if (outfd >= 0 && infd < 0)

  579. 		{

  580. 			fragsize = driver->period_size * 

  581. 				driver->playback_channels * samplesize;

  582. 			set_fragment(outfd, fragsize, driver->nperiods);

  583. 		}

  584. 	}

  585. 	driver->infd = infd;

  586. 	driver->outfd = outfd;

  587. 	

  588. 	if (infd >= 0)

  589. 	{

  590. 		format = driver->format;

  591. 		if (ioctl(infd, SNDCTL_DSP_SETFMT, &format) < 0)

  592. 			jack_error(

  593. 				"OSS: failed to set format for %s: %s@%i, errno=%d", 

  594. 				indev, __FILE__, __LINE__, errno);

  595. 		channels = driver->capture_channels;

  596. 		if (ioctl(infd, SNDCTL_DSP_CHANNELS, &channels) < 0)

  597. 			jack_error(

  598. 				"OSS: failed to set channels for %s: %s@%i, errno=%d", 

  599. 				indev, __FILE__, __LINE__, errno);

  600. 		samplerate = driver->sample_rate;

  601. 		if (ioctl(infd, SNDCTL_DSP_SPEED, &samplerate) < 0)

  602. 			jack_error(

  603. 				"OSS: failed to set samplerate for %s: %s@%i, errno=%d", 

  604. 				indev, __FILE__, __LINE__, errno);

  605. 		jack_info("oss_driver: %s : 0x%x/%i/%i (%i)", indev, 

  606. 			format, channels, samplerate, get_fragment(infd));

  607. 		

  608. 		period_size = get_fragment(infd) / samplesize / channels;

  609. 		if (period_size != driver->period_size && 

  610. 			!driver->ignorehwbuf)

  611. 		{

  612. 			jack_info("oss_driver: period size update: %u",

  613. 				period_size);

  614. 			driver->period_size = period_size;

  615. 			driver->period_usecs = 

  616. 				((double) driver->period_size / 

  617. 				 (double) driver->sample_rate) * 1e6;

  618. 			if (driver->engine->set_buffer_size(driver->engine, 

  619. 							    driver->period_size)) {

  620. 				jack_error ("OSS: cannot set engine buffer size to %d (check MIDI)", driver->period_size);

  621. 				return -1;

  622. 			}

  623. 		}

  624. 	}

  625. 

  626. 	if (outfd >= 0 && infd != outfd)

  627. 	{

  628. 		format = driver->format;

  629. 		if (ioctl(outfd, SNDCTL_DSP_SETFMT, &format) < 0)

  630. 			jack_error(

  631. 				"OSS: failed to set format for %s: %s@%i, errno=%d", 

  632. 				outdev, __FILE__, __LINE__, errno);

  633. 		channels = driver->playback_channels;

  634. 		if (ioctl(outfd, SNDCTL_DSP_CHANNELS, &channels) < 0)

  635. 			jack_error(

  636. 				"OSS: failed to set channels for %s: %s@%i, errno=%d", 

  637. 				outdev, __FILE__, __LINE__, errno);

  638. 		samplerate = driver->sample_rate;

  639. 		if (ioctl(outfd, SNDCTL_DSP_SPEED, &samplerate) < 0)

  640. 			jack_error(

  641. 				"OSS: failed to set samplerate for %s: %s@%i, errno=%d", 

  642. 				outdev, __FILE__, __LINE__, errno);

  643. 		jack_info("oss_driver: %s : 0x%x/%i/%i (%i)", outdev, 

  644. 			format, channels, samplerate, 

  645. 			get_fragment(outfd));

  646. 

  647. 		period_size = get_fragment(outfd) / samplesize / channels;

  648. 		if (period_size != driver->period_size &&

  649. 			!driver->ignorehwbuf)

  650. 		{

  651. 			jack_info("oss_driver: period size update: %u",

  652. 				period_size);

  653. 			driver->period_size = period_size;

  654. 			driver->period_usecs = 

  655. 				((double) driver->period_size / 

  656. 				 (double) driver->sample_rate) * 1e6;

  657. 			if (driver->engine->set_buffer_size(driver->engine, 

  658. 							    driver->period_size)) {

  659. 				jack_error ("OSS: cannot set engine buffer size to %d (check MIDI)", driver->period_size);

  660. 				return -1;

  661. 			}

  662. 		}

  663. 	}

  664. 

  665. 	if (driver->capture_channels > 0)

  666. 	{

  667. 		driver->indevbufsize = driver->period_size * 

  668. 			driver->capture_channels * samplesize;

  669. 		driver->indevbuf = malloc(driver->indevbufsize);

  670. 		if (driver->indevbuf == NULL)

  671. 		{

  672. 			jack_error( "OSS: malloc() failed: %s@%i", 

  673. 				__FILE__, __LINE__);

  674. 			return -1;

  675. 		}

  676. 		memset(driver->indevbuf, 0x00, driver->indevbufsize);

  677. 	}

  678. 	else

  679. 	{

  680. 		driver->indevbufsize = 0;

  681. 		driver->indevbuf = NULL;

  682. 	}

  683. 

  684. 	if (driver->playback_channels > 0)

  685. 	{

  686. 		driver->outdevbufsize = driver->period_size * 

  687. 			driver->playback_channels * samplesize;

  688. 		driver->outdevbuf = malloc(driver->outdevbufsize);

  689. 		if (driver->outdevbuf == NULL)

  690. 		{

  691. 			jack_error("OSS: malloc() failed: %s@%i", 

  692. 				__FILE__, __LINE__);

  693. 			return -1;

  694. 		}

  695. 		memset(driver->outdevbuf, 0x00, driver->outdevbufsize);

  696. 	}

  697. 	else

  698. 	{

  699. 		driver->outdevbufsize = 0;

  700. 		driver->outdevbuf = NULL;

  701. 	}

  702. 

  703. 	jack_info("oss_driver: indevbuf %zd B, outdevbuf %zd B",

  704. 		driver->indevbufsize, driver->outdevbufsize);

  705. 

  706. 	pthread_mutex_init(&driver->mutex_in, NULL);

  707. 	pthread_mutex_init(&driver->mutex_out, NULL);

  708. #	ifdef USE_BARRIER

  709. 	puts("oss_driver: using barrier mode, (dual thread)");

  710. 	pthread_barrier_init(&driver->barrier, NULL, 2);

  711. #	else

  712. 	puts("oss_driver: not using barrier mode, (single thread)");

  713. #	endif

  714. 	sem_init(&driver->sem_start, 0, 0);

  715. 	driver->run = 1;

  716. 	driver->threads = 0;

  717. 	if (infd >= 0)

  718. 	{

  719. 		if (jack_client_create_thread(NULL, &driver->thread_in, 

  720. 			driver->engine->rtpriority, 

  721. 			driver->engine->control->real_time, 

  722. 			io_thread, driver) < 0)

  723. 		{

  724. 			jack_error("OSS: jack_client_create_thread() failed: %s@%i",

  725. 				__FILE__, __LINE__);

  726. 			return -1;

  727. 		}

  728. 		driver->threads |= 1;

  729. 	}

  730. #	ifdef USE_BARRIER

  731. 	if (outfd >= 0)

  732. 	{

  733. 		if (jack_client_create_thread(NULL, &driver->thread_out, 

  734. 			driver->engine->rtpriority, 

  735. 			driver->engine->control->real_time, 

  736. 			io_thread, driver) < 0)

  737. 		{

  738. 			jack_error("OSS: jack_client_create_thread() failed: %s@%i",

  739. 				__FILE__, __LINE__);

  740. 			return -1;

  741. 		}

  742. 		driver->threads |= 2;

  743. 	}

  744. #	endif

  745. 

  746. 	if (driver->threads & 1) sem_post(&driver->sem_start);

  747. 	if (driver->threads & 2) sem_post(&driver->sem_start);

  748. 

  749. 	driver->last_periodtime = jack_get_microseconds();

  750. 	driver->next_periodtime = 0;

  751. 	driver->iodelay = 0.0F;

  752. 

  753. 	return 0;

  754. }

  755. 

  756. 

  757. static int oss_driver_stop (oss_driver_t *driver)

  758. {

  759. 	void *retval;

  760. 

  761. 	driver->run = 0;

  762. 	if (driver->threads & 1)

  763. 	{

  764. 		if (pthread_join(driver->thread_in, &retval) < 0)

  765. 		{

  766. 			jack_error("OSS: pthread_join() failed: %s@%i",

  767. 				__FILE__, __LINE__);

  768. 			return -1;

  769. 		}

  770. 	}

  771. 	if (driver->threads & 2)

  772. 	{

  773. 		if (pthread_join(driver->thread_out, &retval) < 0)

  774. 		{

  775. 			jack_error("OSS: pthread_join() failed: %s@%i",

  776. 				__FILE__, __LINE__);

  777. 			return -1;

  778. 		}

  779. 	}

  780. 	sem_destroy(&driver->sem_start);

  781. #	ifdef USE_BARRIER

  782. 	pthread_barrier_destroy(&driver->barrier);

  783. #	endif

  784. 	pthread_mutex_destroy(&driver->mutex_in);

  785. 	pthread_mutex_destroy(&driver->mutex_out);

  786. 

  787. 	if (driver->outfd >= 0 && driver->outfd != driver->infd)

  788. 	{

  789. 		close(driver->outfd);

  790. 		driver->outfd = -1;

  791. 	}

  792. 	if (driver->infd >= 0)

  793. 	{

  794. 		close(driver->infd);

  795. 		driver->infd = -1;

  796. 	}

  797. 

  798. 	if (driver->indevbuf != NULL)

  799. 	{

  800. 		free(driver->indevbuf);

  801. 		driver->indevbuf = NULL;

  802. 	}

  803. 	if (driver->outdevbuf != NULL)

  804. 	{

  805. 		free(driver->outdevbuf);

  806. 		driver->outdevbuf = NULL;

  807. 	}

  808. 

  809. 	return 0;

  810. }

  811. 

  812. 

  813. static int oss_driver_read (oss_driver_t *driver, jack_nframes_t nframes)

  814. {

  815. 	int channel;

  816. 	jack_sample_t *portbuf;

  817. 	JSList *node;

  818. 	jack_port_t *port;

  819. 

  820. 	if (!driver->run) return 0;

  821. 	if (nframes != driver->period_size)

  822. 	{

  823. 		jack_error(

  824. 			"OSS: read failed nframes != period_size  (%u/%u): %s@%i",

  825. 			nframes, driver->period_size, __FILE__, __LINE__);

  826. 		return -1;

  827. 	}

  828. 

  829. 	pthread_mutex_lock(&driver->mutex_in);

  830. 

  831. 	node = driver->capture_ports;

  832. 	channel = 0;

  833. 	while (node != NULL)

  834. 	{

  835. 		port = (jack_port_t *) node->data;

  836. 

  837. 		if (jack_port_connected(port))

  838. 		{

  839. 			portbuf = jack_port_get_buffer(port, nframes);

  840. 			copy_and_convert_in(portbuf, driver->indevbuf, 

  841. 				nframes, channel, 

  842. 				driver->capture_channels,

  843. 				driver->bits);

  844. 		}

  845. 

  846. 		node = jack_slist_next(node);

  847. 		channel++;

  848. 	}

  849. 

  850. 	pthread_mutex_unlock(&driver->mutex_in);

  851. 

  852. 	return 0;

  853. }

  854. 

  855. 

  856. static int oss_driver_write (oss_driver_t *driver, jack_nframes_t nframes)

  857. {

  858. 	int channel;

  859. 	jack_sample_t *portbuf;

  860. 	JSList *node;

  861. 	jack_port_t *port;

  862. 

  863. 	if (!driver->run) return 0;

  864. 	if (nframes != driver->period_size)

  865. 	{

  866. 		jack_error(

  867. 			"OSS: write failed nframes != period_size  (%u/%u): %s@%i",

  868. 			nframes, driver->period_size, __FILE__, __LINE__);

  869. 		return -1;

  870. 	}

  871. 

  872. 	pthread_mutex_lock(&driver->mutex_out);

  873. 

  874. 	node = driver->playback_ports;

  875. 	channel = 0;

  876. 	while (node != NULL)

  877. 	{

  878. 		port = (jack_port_t *) node->data;

  879. 

  880. 		if (jack_port_connected(port))

  881. 		{

  882. 			portbuf = jack_port_get_buffer(port, nframes);

  883. 			copy_and_convert_out(driver->outdevbuf, portbuf, 

  884. 				nframes, channel,

  885. 				driver->playback_channels,

  886. 				driver->bits);

  887. 		}

  888. 

  889. 		node = jack_slist_next(node);

  890. 		channel++;

  891. 	}

  892. 

  893. 	pthread_mutex_unlock(&driver->mutex_out);

  894. 

  895. 	return 0;

  896. }

  897. 

  898. 

  899. static int oss_driver_null_cycle (oss_driver_t *driver, jack_nframes_t nframes)

  900. {

  901. 	pthread_mutex_lock(&driver->mutex_in);

  902. 	memset(driver->indevbuf, 0x00, driver->indevbufsize);

  903. 	pthread_mutex_unlock(&driver->mutex_in);

  904. 

  905. 	pthread_mutex_lock(&driver->mutex_out);

  906. 	memset(driver->outdevbuf, 0x00, driver->outdevbufsize);

  907. 	pthread_mutex_unlock(&driver->mutex_out);

  908. 

  909. 	return 0;

  910. }

  911. 

  912. 

  913. static int oss_driver_bufsize (oss_driver_t *driver, jack_nframes_t nframes)

  914. {

  915. 	oss_driver_stop(driver);

  916. 

  917. 	set_period_size(driver, nframes);

  918. 	if (driver->engine->set_buffer_size(driver->engine, driver->period_size)) {

  919. 		jack_error ("OSS: cannot set engine buffer size to %d (check MIDI)", driver->period_size);

  920. 		return -1;

  921. 	}

  922. 	jack_info("oss_driver: period size update: %u", nframes);

  923. 

  924. 	oss_driver_start(driver);

  925. 

  926. 	return 0;

  927. }

  928. 

  929. 

  930. /* internal driver thread */

  931. 

  932. 

  933. #ifdef USE_BARRIER

  934. static inline void synchronize (oss_driver_t *driver)

  935. {

  936. 	if (driver->threads == 3)

  937. 	{

  938. 		if (pthread_barrier_wait(&driver->barrier) ==

  939. 			PTHREAD_BARRIER_SERIAL_THREAD)

  940. 		{

  941. 			driver_cycle(driver);

  942. 		}

  943. 	}

  944. 	else

  945. 	{

  946. 		driver_cycle(driver);

  947. 	}

  948. }

  949. #endif

  950. 

  951. 

  952. static void *io_thread (void *param)

  953. {

  954. 	size_t localsize;

  955. 	ssize_t io_res;

  956. 	void *localbuf;

  957. 	oss_driver_t *driver = (oss_driver_t *) param;

  958. 

  959. 	sem_wait(&driver->sem_start);

  960. 

  961. #	ifdef USE_BARRIER

  962. 	if (pthread_self() == driver->thread_in)

  963. 	{

  964. 		localsize = driver->indevbufsize;

  965. 		localbuf = malloc(localsize);

  966. 		if (localbuf == NULL)

  967. 		{

  968. 			jack_error("OSS: malloc() failed: %s@%i",

  969. 				__FILE__, __LINE__);

  970. 			return NULL;

  971. 		}

  972. 

  973. 		while (driver->run)

  974. 		{

  975. 			io_res = read(driver->infd, localbuf, localsize);

  976. 			if (io_res < (ssize_t) localsize)

  977. 			{

  978. 				jack_error(

  979. 					"OSS: read() failed: %s@%i, count=%d/%d, errno=%d",

  980. 					__FILE__, __LINE__, io_res, localsize,

  981. 					errno);

  982. 				break;

  983. 			}

  984. 

  985. 			pthread_mutex_lock(&driver->mutex_in);

  986. 			memcpy(driver->indevbuf, localbuf, localsize);

  987. 			pthread_mutex_unlock(&driver->mutex_in);

  988. 

  989. 			synchronize(driver);

  990. 		}

  991. 

  992. 		free(localbuf);

  993. 	}

  994. 	else if (pthread_self() == driver->thread_out)

  995. 	{

  996. 		localsize = driver->outdevbufsize;

  997. 		localbuf = malloc(localsize);

  998. 		if (localbuf == NULL)

  999. 		{

  1000. 			jack_error("OSS: malloc() failed: %s@%i",

  1001. 				__FILE__, __LINE__);

  1002. 			return NULL;

  1003. 		}

  1004. 		if (driver->trigger)

  1005. 		{

  1006. 			/* don't care too much if this fails */

  1007. 			memset(localbuf, 0x00, localsize);

  1008. 			write(driver->outfd, localbuf, localsize);

  1009. 			ioctl(driver->outfd, SNDCTL_DSP_SETTRIGGER, &driver->trigger);

  1010. 		}

  1011. 

  1012. 		while (driver->run)

  1013. 		{

  1014. 			pthread_mutex_lock(&driver->mutex_out);

  1015. 			memcpy(localbuf, driver->outdevbuf, localsize);

  1016. 			pthread_mutex_unlock(&driver->mutex_out);

  1017. 

  1018. 			io_res = write(driver->outfd, localbuf, localsize);

  1019. 			if (io_res < (ssize_t) localsize)

  1020. 			{

  1021. 				jack_error(

  1022. 					"OSS: write() failed: %s@%i, count=%d/%d, errno=%d",

  1023. 					__FILE__, __LINE__, io_res, localsize,

  1024. 					errno);

  1025. 				break;

  1026. 			}

  1027. 

  1028. 			synchronize(driver);

  1029. 		}

  1030. 

  1031. 		free(localbuf);

  1032. 	}

  1033. #	else

  1034. 	localsize = (driver->indevbufsize >= driver->outdevbufsize) ?

  1035. 		driver->indevbufsize : driver->outdevbufsize;

  1036. 	localbuf = malloc(localsize);

  1037. 	if (localbuf == NULL)

  1038. 	{

  1039. 		jack_error("OSS: malloc() failed: %s@%i", __FILE__, __LINE__);

  1040. 		return NULL;

  1041. 	}

  1042. 	if (driver->trigger)

  1043. 	{

  1044. 		/* don't care too much if this fails */

  1045. 		memset(localbuf, 0x00, localsize);

  1046. 		write(driver->outfd, localbuf, driver->outdevbufsize);

  1047. 		ioctl(driver->outfd, SNDCTL_DSP_SETTRIGGER, &driver->trigger);

  1048. 	}

  1049. 

  1050. 	while (driver->run)

  1051. 	{

  1052. 		if (driver->playback_channels > 0)

  1053. 		{

  1054. 			pthread_mutex_lock(&driver->mutex_out);

  1055. 			memcpy(localbuf, driver->outdevbuf, 

  1056. 				driver->outdevbufsize);

  1057. 			pthread_mutex_unlock(&driver->mutex_out);

  1058. 

  1059. 			io_res = write(driver->outfd, localbuf, 

  1060. 				driver->outdevbufsize);

  1061. 			if (io_res < (ssize_t) driver->outdevbufsize)

  1062. 			{

  1063. 				jack_error(

  1064. 					"OSS: write() failed: %s@%i, count=%d/%d, errno=%d",

  1065. 					__FILE__, __LINE__, io_res,

  1066. 					driver->outdevbufsize, errno);

  1067. 				break;

  1068. 			}

  1069. 		}

  1070. 

  1071. 		if (driver->capture_channels > 0)

  1072. 		{

  1073. 			io_res = read(driver->infd, localbuf, 

  1074. 				driver->indevbufsize);

  1075. 			if (io_res < (ssize_t) driver->indevbufsize)

  1076. 			{

  1077. 				jack_error(

  1078. 					"OSS: read() failed: %s@%i, count=%d/%d, errno=%d",

  1079. 					__FILE__, __LINE__, io_res,

  1080. 					driver->indevbufsize, errno);

  1081. 				break;

  1082. 			}

  1083. 

  1084. 			pthread_mutex_lock(&driver->mutex_in);

  1085. 			memcpy(driver->indevbuf, localbuf, 

  1086. 				driver->indevbufsize);

  1087. 			pthread_mutex_unlock(&driver->mutex_in);

  1088. 		}

  1089. 

  1090. 		driver_cycle(driver);

  1091. 	}

  1092. 

  1093. 	free(localbuf);

  1094. #	endif

  1095. 

  1096. 	return NULL;

  1097. }

  1098. 

  1099. 

  1100. /* jack driver published interface */

  1101. 

  1102. 

  1103. const char driver_client_name[] = "oss";

  1104. 

  1105. 

  1106. void driver_finish (jack_driver_t *);

  1107. 

  1108. 

  1109. jack_driver_desc_t * driver_get_descriptor ()

  1110. {

  1111. 	jack_driver_desc_t *desc;

  1112. 	jack_driver_param_desc_t *params;

  1113. 

  1114. 	desc = (jack_driver_desc_t *) calloc(1, sizeof(jack_driver_desc_t));

  1115. 	if (desc == NULL)

  1116. 	{

  1117. 		jack_error("oss_driver: calloc() failed: %s@%i, errno=%d",

  1118. 			__FILE__, __LINE__, errno);

  1119. 		return NULL;

  1120. 	}

  1121. 	strcpy(desc->name, driver_client_name);

  1122. 	desc->nparams = OSS_DRIVER_N_PARAMS;

  1123. 

  1124. 	params = calloc(desc->nparams, sizeof(jack_driver_param_desc_t));

  1125. 	if (params == NULL)

  1126. 	{

  1127. 		jack_error("oss_driver: calloc() failed: %s@%i, errno=%d",

  1128. 			__FILE__, __LINE__, errno);

  1129. 		return NULL;

  1130. 	}

  1131. 	memcpy(params, oss_params, 

  1132. 		desc->nparams * sizeof(jack_driver_param_desc_t));

  1133. 	desc->params = params;

  1134. 

  1135. 	return desc;

  1136. }

  1137. 

  1138. 

  1139. jack_driver_t * driver_initialize (jack_client_t *client, 

  1140. 	JSList * params)

  1141. {

  1142. 	int bits = OSS_DRIVER_DEF_BITS;

  1143. 	jack_nframes_t sample_rate = OSS_DRIVER_DEF_FS;

  1144. 	jack_nframes_t period_size = OSS_DRIVER_DEF_BLKSIZE;

  1145. 	jack_nframes_t in_latency = 0;

  1146. 	jack_nframes_t out_latency = 0;

  1147. 	unsigned int nperiods = OSS_DRIVER_DEF_NPERIODS;

  1148. 	unsigned int capture_channels = OSS_DRIVER_DEF_INS;

  1149. 	unsigned int playback_channels = OSS_DRIVER_DEF_OUTS;

  1150. 	const JSList *pnode;

  1151. 	const jack_driver_param_t *param;

  1152. 	oss_driver_t *driver;

  1153. 

  1154. 	driver = (oss_driver_t *) malloc(sizeof(oss_driver_t));

  1155. 	if (driver == NULL)

  1156. 	{

  1157. 		jack_error("OSS: malloc() failed: %s@%i, errno=%d",

  1158. 			__FILE__, __LINE__, errno);

  1159. 		return NULL;

  1160. 	}

  1161. 	jack_driver_init((jack_driver_t *) driver);

  1162. 

  1163. 	driver->attach = (JackDriverAttachFunction) oss_driver_attach;

  1164. 	driver->detach = (JackDriverDetachFunction) oss_driver_detach;

  1165. 	driver->start = (JackDriverStartFunction) oss_driver_start;

  1166. 	driver->stop = (JackDriverStopFunction) oss_driver_stop;

  1167. 	driver->read = (JackDriverReadFunction) oss_driver_read;

  1168. 	driver->write = (JackDriverWriteFunction) oss_driver_write;

  1169. 	driver->null_cycle = (JackDriverNullCycleFunction) 

  1170. 		oss_driver_null_cycle;

  1171. 	driver->bufsize = (JackDriverBufSizeFunction) oss_driver_bufsize;

  1172. 

  1173. 	driver->indev = NULL;

  1174. 	driver->outdev = NULL;

  1175. 	driver->ignorehwbuf = 0;

  1176. 	driver->trigger = 0;

  1177. 

  1178. 	pnode = params;

  1179. 	while (pnode != NULL)

  1180. 	{

  1181. 		param = (const jack_driver_param_t *) pnode->data;

  1182. 

  1183. 		switch (param->character)

  1184. 		{

  1185. 			case 'r':

  1186. 				sample_rate = param->value.ui;

  1187. 				break;

  1188. 			case 'p':

  1189. 				period_size = param->value.ui;

  1190. 				break;

  1191. 			case 'n':

  1192. 				nperiods = param->value.ui;

  1193. 				break;

  1194. 			case 'w':

  1195. 				bits = param->value.i;

  1196. 				break;

  1197. 			case 'i':

  1198. 				capture_channels = param->value.ui;

  1199. 				break;

  1200. 			case 'o':

  1201. 				playback_channels = param->value.ui;

  1202. 				break;

  1203. 			case 'C':

  1204. 				driver->indev = strdup(param->value.str);

  1205. 				break;

  1206. 			case 'P':

  1207. 				driver->outdev = strdup(param->value.str);

  1208. 				break;

  1209. 			case 'b':

  1210. 				driver->ignorehwbuf = 1;

  1211. 				break;

  1212. 			case 'I':

  1213. 				in_latency = param->value.ui;

  1214. 				break;

  1215. 			case 'O':

  1216. 				out_latency = param->value.ui;

  1217. 				break;

  1218. 		}

  1219. 		pnode = jack_slist_next(pnode);

  1220. 	}

  1221. 	

  1222. 	driver->sample_rate = sample_rate;

  1223. 	driver->period_size = period_size;

  1224. 	driver->nperiods = nperiods;

  1225. 	driver->bits = bits;

  1226. 	driver->capture_channels = capture_channels;

  1227. 	driver->playback_channels = playback_channels;

  1228. 	driver->sys_in_latency = in_latency;

  1229. 	driver->sys_out_latency = out_latency;

  1230. 

  1231. 	set_period_size(driver, period_size);

  1232. 	

  1233. 	driver->finish = driver_finish;

  1234. 

  1235. 	if (driver->indev == NULL)

  1236. 		driver->indev = strdup(OSS_DRIVER_DEF_DEV);

  1237. 	if (driver->outdev == NULL)

  1238. 		driver->outdev = strdup(OSS_DRIVER_DEF_DEV);

  1239. 	driver->infd = -1;

  1240. 	driver->outfd = -1;

  1241. 	switch (driver->bits)

  1242. 	{

  1243. #		ifndef OSS_ENDIAN

  1244. #		ifdef __GNUC__

  1245. #		if (defined(__i386__) || defined(__alpha__) || defined(__arm__) || defined(__x86_64__))

  1246. #		define OSS_LITTLE_ENDIAN 1234

  1247. #		define OSS_ENDIAN OSS_LITTLE_ENDIAN

  1248. #		else

  1249. #		define OSS_BIG_ENDIAN 4321

  1250. #		define OSS_ENDIAN OSS_BIG_ENDIAN

  1251. #		endif

  1252. #		else /* __GNUC__ */

  1253. #		if (defined(_AIX) || defined(AIX) || defined(sparc) || defined(__hppa) || defined(PPC) || defined(__powerpc__) && !defined(i386) && !defined(__i386) && !defined(__i386__))

  1254. #		define OSS_BIG_ENDIAN 4321

  1255. #		define OSS_ENDIAN OSS_BIG_ENDIAN

  1256. #		else

  1257. #		define OSS_LITTLE_ENDIAN 1234

  1258. #		define OSS_ENDIAN OSS_LITTLE_ENDIAN

  1259. #		endif

  1260. #		endif /* __GNUC__ */

  1261. #		endif /* OSS_ENDIAN */

  1262. #		if (OSS_ENDIAN == 1234)

  1263. 		/* little-endian architectures */

  1264. 		case 24:	/* little-endian LSB aligned 24-bits in 32-bits  integer */

  1265. 			driver->format = 0x00008000;

  1266. 			break;

  1267. 		case 32:	/* little-endian 32-bit integer */

  1268. 			driver->format = 0x00001000;

  1269. 			break;

  1270. 		case 64:	/* native-endian 64-bit float */

  1271. 			driver->format = 0x00004000;

  1272. 			break;

  1273. 		case 16:	/* little-endian 16-bit integer */

  1274. 		default:

  1275. 			driver->format = 0x00000010;

  1276. 			break;

  1277. 		/* big-endian architectures */

  1278. #		else

  1279. 		case 24:	/* big-endian LSB aligned 24-bits in 32-bits integer */

  1280. 			break;

  1281. 			driver->format = 0x00010000;

  1282. 		case 32:	/* big-endian 32-bit integer */

  1283. 			driver->format = 0x00002000;

  1284. 			break;

  1285. 		case 64:	/* native-endian 64-bit float */

  1286. 			driver->format = 0x00004000;

  1287. 			break;

  1288. 		case 16:	/* big-endian 16-bit integer */

  1289. 		default:

  1290. 			driver->format = 0x00000020;

  1291. #		endif

  1292. 	}

  1293. 

  1294. 	driver->indevbuf = driver->outdevbuf = NULL;

  1295. 

  1296. 	driver->capture_ports = NULL;

  1297. 	driver->playback_ports = NULL;

  1298. 

  1299. 	driver->engine = NULL;

  1300. 	driver->client = client;

  1301. 

  1302. 	return ((jack_driver_t *) driver);

  1303. }

  1304. 

  1305. 

  1306. void driver_finish (jack_driver_t *driver)

  1307. {

  1308. 	oss_driver_t *oss_driver = (oss_driver_t *) driver;

  1309. 

  1310. 	oss_driver = (oss_driver_t *) driver;

  1311. 	if (oss_driver->indev != NULL)

  1312. 		free(oss_driver->indev);

  1313. 	if (oss_driver->outdev != NULL)

  1314. 		free(oss_driver->outdev);

  1315. 	free(driver);

  1316. }