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.
1791 Commits
4 Branches
6.5MB
Tree: 08c6f50706
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '08c6f50706'
${ noResults }
jack1/drivers/oss/oss_driver.c

1258 lines
32KB
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/thread.h>

  62. 

  63. #include "internal.h"

  64. #include "engine.h"

  65. 

  66. #include <sysdeps/time.h>

  67. 

  68. #include "oss_driver.h"

  69. 

  70. 

  71. #ifndef SNDCTL_DSP_COOKEDMODE

  72. #ifdef _SIOWR

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

  74. #else  /* _SIOWR */

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

  76. #define OSS_NO_COOKED_MODE

  77. #endif  /* _SIOWR */

  78. #endif  /* SNDCTL_DSP_COOKEDMODE */

  79. 

  80. #define OSS_DRIVER_N_PARAMS     11

  81. const static jack_driver_param_desc_t oss_params[OSS_DRIVER_N_PARAMS] = {

  82. 	{ "rate",

  83. 	    'r',

  84. 	    JackDriverParamUInt,

  85. 	    { .ui = OSS_DRIVER_DEF_FS },

  86. 	    NULL,

  87. 	    "sample rate",

  88. 	    "sample rate" },

  89. 	{ "period",

  90. 	    'p',

  91. 	    JackDriverParamUInt,

  92. 	    { .ui = OSS_DRIVER_DEF_BLKSIZE },

  93. 	    NULL,

  94. 	    "period size",

  95. 	    "period size" },

  96. 	{ "nperiods",

  97. 	    'n',

  98. 	    JackDriverParamUInt,

  99. 	    { .ui = OSS_DRIVER_DEF_NPERIODS },

  100. 	    NULL,

  101. 	    "number of periods in buffer",

  102. 	    "number of periods in buffer" },

  103. 	{ "wordlength",

  104. 	    'w',

  105. 	    JackDriverParamInt,

  106. 	    { .i = OSS_DRIVER_DEF_BITS },

  107. 	    NULL,

  108. 	    "word length",

  109. 	    "word length" },

  110. 	{ "inchannels",

  111. 	    'i',

  112. 	    JackDriverParamUInt,

  113. 	    { .ui = OSS_DRIVER_DEF_INS },

  114. 	    NULL,

  115. 	    "capture channels",

  116. 	    "capture channels" },

  117. 	{ "outchannels",

  118. 	    'o',

  119. 	    JackDriverParamUInt,

  120. 	    { .ui = OSS_DRIVER_DEF_OUTS },

  121. 	    NULL,

  122. 	    "playback channels",

  123. 	    "playback channels" },

  124. 	{ "capture",

  125. 	    'C',

  126. 	    JackDriverParamString,

  127. 	    { .str = OSS_DRIVER_DEF_DEV },

  128. 	    NULL,

  129. 	    "input device",

  130. 	    "input device" },

  131. 	{ "playback",

  132. 	    'P',

  133. 	    JackDriverParamString,

  134. 	    { .str = OSS_DRIVER_DEF_DEV },

  135. 	    NULL,

  136. 	    "output device",

  137. 	    "output device" },

  138. 	{ "ignorehwbuf",

  139. 	    'b',

  140. 	    JackDriverParamBool,

  141. 	    { },

  142. 	    NULL,

  143. 	    "ignore hardware period size",

  144. 	    "ignore hardware period size" },

  145. 	{ "input latency",

  146. 	    'I',

  147. 	    JackDriverParamUInt,

  148. 	    { .ui = 0 },

  149. 	    NULL,

  150. 	    "system input latency",

  151. 	    "system input latency" },

  152. 	{ "output latency",

  153. 	    'O',

  154. 	    JackDriverParamUInt,

  155. 	    { .ui = 0 },

  156. 	    NULL,

  157. 	    "system output latency",

  158. 	    "system output latency" }

  159. };

  160. 

  161. 

  162. 

  163. /* internal functions */

  164. 

  165. 

  166. static void set_period_size (oss_driver_t *driver,

  167. 			     jack_nframes_t new_period_size)

  168. {

  169. 	driver->period_size = new_period_size;

  170. 

  171. 	driver->period_usecs =

  172. 		((double)driver->period_size /

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

  174. 	driver->last_wait_ust = 0;

  175. 	driver->last_periodtime = driver->engine->get_microseconds ();

  176. 	driver->next_periodtime = 0;

  177. 	driver->iodelay = 0.0F;

  178. }

  179. 

  180. 

  181. static inline void update_times (oss_driver_t *driver)

  182. {

  183. 	driver->last_periodtime = driver->engine->get_microseconds ();

  184. 	if (driver->next_periodtime > 0) {

  185. 		driver->iodelay = (float)

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

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

  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. 	case 16:

  220. 		scale = 1.0f / 0x7fff;

  221. 		for (dstidx = 0; dstidx < nframes; dstidx++) {

  222. 			dst[dstidx] = (jack_sample_t)

  223. 				      s16src[srcidx] * scale;

  224. 			srcidx += chcount;

  225. 		}

  226. 		break;

  227. 	case 24:

  228. 		scale = 1.0f / 0x7fffff;

  229. 		for (dstidx = 0; dstidx < nframes; dstidx++) {

  230. 			dst[dstidx] = (jack_sample_t)

  231. 				      s32src[srcidx] * scale;

  232. 			srcidx += chcount;

  233. 		}

  234. 		break;

  235. 	case 32:

  236. 		scale = 1.0f / 0x7fffffff;

  237. 		for (dstidx = 0; dstidx < nframes; dstidx++) {

  238. 			dst[dstidx] = (jack_sample_t)

  239. 				      s32src[srcidx] * scale;

  240. 			srcidx += chcount;

  241. 		}

  242. 		break;

  243. 	case 64:

  244. 		for (dstidx = 0; dstidx < nframes; dstidx++) {

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

  246. 			srcidx += chcount;

  247. 		}

  248. 		break;

  249. 	}

  250. }

  251. 

  252. 

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

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

  255. {

  256. 	int srcidx;

  257. 	int dstidx;

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

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

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

  261. 	jack_sample_t scale;

  262. 

  263. 	dstidx = channel;

  264. 	switch (bits) {

  265. 	case 16:

  266. 		scale = 0x7fff;

  267. 		for (srcidx = 0; srcidx < nframes; srcidx++) {

  268. 			s16dst[dstidx] = (signed short)

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

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

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

  272. 			dstidx += chcount;

  273. 		}

  274. 		break;

  275. 	case 24:

  276. 		scale = 0x7fffff;

  277. 		for (srcidx = 0; srcidx < nframes; srcidx++) {

  278. 			s32dst[dstidx] = (signed int)

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

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

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

  282. 			dstidx += chcount;

  283. 		}

  284. 		break;

  285. 	case 32:

  286. 		scale = 0x7fffffff;

  287. 		for (srcidx = 0; srcidx < nframes; srcidx++) {

  288. 			s32dst[dstidx] = (signed int)

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

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

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

  292. 			dstidx += chcount;

  293. 		}

  294. 		break;

  295. 	case 64:

  296. 		for (srcidx = 0; srcidx < nframes; srcidx++) {

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

  298. 			dstidx += chcount;

  299. 		}

  300. 		break;

  301. 	}

  302. }

  303. 

  304. 

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

  306. {

  307. 	int fragsize_2p;

  308. 	int fragments;

  309. 

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

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

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

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

  314. 			    __FILE__, __LINE__, errno);

  315. 	}

  316. }

  317. 

  318. 

  319. static int get_fragment (int fd)

  320. {

  321. 	int fragsize;

  322. 

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

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

  325. 			    __FILE__, __LINE__, errno);

  326. 		return 0;

  327. 	}

  328. 	return fragsize;

  329. }

  330. 

  331. 

  332. static void *io_thread(void *);

  333. 

  334. 

  335. /* jack driver interface */

  336. 

  337. 

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

  339. {

  340. 	int port_flags;

  341. 	unsigned int channel;

  342. 	char channel_name[64];

  343. 	jack_port_t *port;

  344. 	jack_latency_range_t range;

  345. 

  346. 	driver->engine = engine;

  347. 	set_period_size (driver, driver->period_size);

  348. 

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

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

  351. 		return -1;

  352. 	}

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

  354. 

  355. 	port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  357. 		snprintf (channel_name, sizeof(channel_name),

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

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

  360. 					   JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);

  361. 		if (port == NULL) {

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

  363. 				    channel_name, __FILE__, __LINE__);

  364. 			break;

  365. 		}

  366. 

  367. 		range.min = range.max = driver->period_size + driver->sys_in_latency;

  368. 		jack_port_set_latency_range (port, JackCaptureLatency, &range);

  369. 		driver->capture_ports =

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

  371. 	}

  372. 

  373. 	port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  375. 		snprintf (channel_name, sizeof(channel_name),

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

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

  378. 					   JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);

  379. 		if (port == NULL) {

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

  381. 				    channel_name, __FILE__, __LINE__);

  382. 			break;

  383. 		}

  384. 		range.min = range.max = driver->period_size + driver->sys_out_latency;

  385. 		jack_port_set_latency_range (port, JackPlaybackLatency, &range);

  386. 		driver->playback_ports =

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

  388. 	}

  389. 

  390. 	jack_activate (driver->client);

  391. 

  392. 	return 0;

  393. }

  394. 

  395. 

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

  397. {

  398. 	JSList *node;

  399. 

  400. 	if (driver->engine == NULL) {

  401. 		return -1;

  402. 	}

  403. 

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

  405. 

  406. 	node = driver->capture_ports;

  407. 	while (node != NULL) {

  408. 		jack_port_unregister (driver->client,

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

  410. 		node = jack_slist_next (node);

  411. 	}

  412. 	jack_slist_free (driver->capture_ports);

  413. 	driver->capture_ports = NULL;

  414. 

  415. 	node = driver->playback_ports;

  416. 	while (node != NULL) {

  417. 		jack_port_unregister (driver->client,

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

  419. 		node = jack_slist_next (node);

  420. 	}

  421. 	jack_slist_free (driver->playback_ports);

  422. 	driver->playback_ports = NULL;

  423. 

  424. 	driver->engine = NULL;

  425. 

  426. 	return 0;

  427. }

  428. 

  429. 

  430. static int oss_driver_start (oss_driver_t *driver)

  431. {

  432. 	int flags = 0;

  433. 	int format;

  434. 	int channels;

  435. 	int samplerate;

  436. 	int infd = driver->infd;

  437. 	int outfd = driver->outfd;

  438. 	unsigned int period_size;

  439. 	size_t samplesize;

  440. 	size_t fragsize;

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

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

  443. 

  444. 	switch (driver->bits) {

  445. 	case 24:

  446. 	case 32:

  447. 		samplesize = sizeof(int);

  448. 		break;

  449. 	case 64:

  450. 		samplesize = sizeof(double);

  451. 		break;

  452. 	case 16:

  453. 	default:

  454. 		samplesize = sizeof(short);

  455. 		break;

  456. 	}

  457. 	driver->trigger = 0;

  458. 	if (strcmp (indev, outdev) != 0) {

  459. 		if (driver->capture_channels > 0) {

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

  461. 			if (infd < 0) {

  462. 				jack_error (

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

  464. 					indev, __FILE__, __LINE__, errno);

  465. 			}

  466. #ifndef OSS_NO_COOKED_MODE

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

  468. #endif

  469. 			fragsize = driver->period_size *

  470. 				   driver->capture_channels * samplesize;

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

  472. 		} else { infd = -1; }

  473. 

  474. 		if (driver->playback_channels > 0) {

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

  476. 			if (outfd < 0) {

  477. 				jack_error (

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

  479. 					outdev, __FILE__, __LINE__, errno);

  480. 			}

  481. #ifndef OSS_NO_COOKED_MODE

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

  483. #endif

  484. 			fragsize = driver->period_size *

  485. 				   driver->playback_channels * samplesize;

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

  487. 		} else { outfd = -1; }

  488. 	} else {

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

  490. 		    driver->playback_channels == 0) {

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

  492. 			outfd = -1;

  493. 			if (infd < 0) {

  494. 				jack_error (

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

  496. 					indev, __FILE__, __LINE__, errno);

  497. 				return -1;

  498. 			}

  499. #ifndef OSS_NO_COOKED_MODE

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

  501. #endif

  502. 		} else if (driver->capture_channels == 0 &&

  503. 			   driver->playback_channels != 0) {

  504. 			infd = -1;

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

  506. 			if (outfd < 0) {

  507. 				jack_error (

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

  509. 					outdev, __FILE__, __LINE__, errno);

  510. 				return -1;

  511. 			}

  512. #ifndef OSS_NO_COOKED_MODE

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

  514. #endif

  515. 		} else {

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

  517. 			if (infd < 0) {

  518. 				jack_error (

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

  520. 					indev, __FILE__, __LINE__, errno);

  521. 				return -1;

  522. 			}

  523. #ifndef OSS_NO_COOKED_MODE

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

  525. #endif

  526. 		}

  527. 		if (infd >= 0 && outfd >= 0) {

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

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

  530. 			if (ioctl (infd, SNDCTL_DSP_SETDUPLEX, 0) < 0) {

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

  532. 					jack_error (

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

  534. 						indev, __FILE__, __LINE__,

  535. 						errno);

  536. 				}

  537. 			}

  538. 		}

  539. 		if (infd >= 0) {

  540. 			fragsize = driver->period_size *

  541. 				   driver->capture_channels * samplesize;

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

  543. 		}

  544. 		if (outfd >= 0 && infd < 0) {

  545. 			fragsize = driver->period_size *

  546. 				   driver->playback_channels * samplesize;

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

  548. 		}

  549. 	}

  550. 	driver->infd = infd;

  551. 	driver->outfd = outfd;

  552. 

  553. 	if (infd >= 0) {

  554. 		format = driver->format;

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

  556. 			jack_error (

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

  558. 				indev, __FILE__, __LINE__, errno);

  559. 		}

  560. 		channels = driver->capture_channels;

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

  562. 			jack_error (

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

  564. 				indev, __FILE__, __LINE__, errno);

  565. 		}

  566. 		samplerate = driver->sample_rate;

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

  568. 			jack_error (

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

  570. 				indev, __FILE__, __LINE__, errno);

  571. 		}

  572. 		if (samplerate != driver->sample_rate) {

  573. 			jack_error (

  574. 				"OSS: failed to set the recording sample-rate for %s: %s@%i, requested-sample-rate=%d, obtained-sample-rate=%d",

  575. 				indev, __FILE__, __LINE__, driver->sample_rate, samplerate);

  576. 			jack_error ("OSS: please consider configuring with --enable-oss-cookedmode");

  577. 			return -1;

  578. 		}

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

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

  581. 

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

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

  584. 		    !driver->ignorehwbuf) {

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

  586. 				   period_size);

  587. 			driver->period_size = period_size;

  588. 			driver->period_usecs =

  589. 				((double)driver->period_size /

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

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

  592. 							     driver->period_size)) {

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

  594. 				return -1;

  595. 			}

  596. 		}

  597. 	}

  598. 

  599. 	if (outfd >= 0 && infd != outfd) {

  600. 		format = driver->format;

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

  602. 			jack_error (

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

  604. 				outdev, __FILE__, __LINE__, errno);

  605. 		}

  606. 		channels = driver->playback_channels;

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

  608. 			jack_error (

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

  610. 				outdev, __FILE__, __LINE__, errno);

  611. 		}

  612. 		samplerate = driver->sample_rate;

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

  614. 			jack_error (

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

  616. 				outdev, __FILE__, __LINE__, errno);

  617. 		}

  618. 		if (samplerate != driver->sample_rate) {

  619. 			jack_error (

  620. 				"OSS: failed to set the playback sample-rate for %s: %s@%i, requested-sample-rate=%d, obtained-sample-rate=%d",

  621. 				indev, __FILE__, __LINE__, driver->sample_rate, samplerate);

  622. 			jack_error ("OSS: please consider configuring with --enable-oss-cookedmode");

  623. 			return -1;

  624. 		}

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

  626. 			   format, channels, samplerate,

  627. 			   get_fragment (outfd));

  628. 

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

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

  631. 		    !driver->ignorehwbuf) {

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

  633. 				   period_size);

  634. 			driver->period_size = period_size;

  635. 			driver->period_usecs =

  636. 				((double)driver->period_size /

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

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

  639. 							     driver->period_size)) {

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

  641. 				return -1;

  642. 			}

  643. 		}

  644. 	}

  645. 

  646. 	if (driver->capture_channels > 0) {

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

  648. 				       driver->capture_channels * samplesize;

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

  650. 		if (driver->indevbuf == NULL) {

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

  652. 				     __FILE__, __LINE__);

  653. 			return -1;

  654. 		}

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

  656. 	} else {

  657. 		driver->indevbufsize = 0;

  658. 		driver->indevbuf = NULL;

  659. 	}

  660. 

  661. 	if (driver->playback_channels > 0) {

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

  663. 					driver->playback_channels * samplesize;

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

  665. 		if (driver->outdevbuf == NULL) {

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

  667. 				    __FILE__, __LINE__);

  668. 			return -1;

  669. 		}

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

  671. 	} else {

  672. 		driver->outdevbufsize = 0;

  673. 		driver->outdevbuf = NULL;

  674. 	}

  675. 

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

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

  678. 

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

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

  681. #       ifdef USE_BARRIER

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

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

  684. #       else

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

  686. #       endif

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

  688. 	driver->run = 1;

  689. 	driver->threads = 0;

  690. 	if (infd >= 0) {

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

  692. 					       driver->engine->rtpriority,

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

  694. 					       io_thread, driver) < 0) {

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

  696. 				    __FILE__, __LINE__);

  697. 			return -1;

  698. 		}

  699. 		driver->threads |= 1;

  700. 	}

  701. #       ifdef USE_BARRIER

  702. 	if (outfd >= 0) {

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

  704. 					       driver->engine->rtpriority,

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

  706. 					       io_thread, driver) < 0) {

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

  708. 				    __FILE__, __LINE__);

  709. 			return -1;

  710. 		}

  711. 		driver->threads |= 2;

  712. 	}

  713. #       endif

  714. 

  715. 	if (driver->threads & 1) {

  716. 		sem_post (&driver->sem_start);

  717. 	}

  718. 	if (driver->threads & 2) {

  719. 		sem_post (&driver->sem_start);

  720. 	}

  721. 

  722. 	driver->last_periodtime = driver->engine->get_microseconds ();

  723. 	driver->next_periodtime = 0;

  724. 	driver->iodelay = 0.0F;

  725. 

  726. 	return 0;

  727. }

  728. 

  729. 

  730. static int oss_driver_stop (oss_driver_t *driver)

  731. {

  732. 	void *retval;

  733. 

  734. 	driver->run = 0;

  735. 	if (driver->threads & 1) {

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

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

  738. 				    __FILE__, __LINE__);

  739. 			return -1;

  740. 		}

  741. 	}

  742. 	if (driver->threads & 2) {

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

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

  745. 				    __FILE__, __LINE__);

  746. 			return -1;

  747. 		}

  748. 	}

  749. 	sem_destroy (&driver->sem_start);

  750. #       ifdef USE_BARRIER

  751. 	pthread_barrier_destroy (&driver->barrier);

  752. #       endif

  753. 	pthread_mutex_destroy (&driver->mutex_in);

  754. 	pthread_mutex_destroy (&driver->mutex_out);

  755. 

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

  757. 		close (driver->outfd);

  758. 		driver->outfd = -1;

  759. 	}

  760. 	if (driver->infd >= 0) {

  761. 		close (driver->infd);

  762. 		driver->infd = -1;

  763. 	}

  764. 

  765. 	if (driver->indevbuf != NULL) {

  766. 		free (driver->indevbuf);

  767. 		driver->indevbuf = NULL;

  768. 	}

  769. 	if (driver->outdevbuf != NULL) {

  770. 		free (driver->outdevbuf);

  771. 		driver->outdevbuf = NULL;

  772. 	}

  773. 

  774. 	return 0;

  775. }

  776. 

  777. 

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

  779. {

  780. 	int channel;

  781. 	jack_sample_t *portbuf;

  782. 	JSList *node;

  783. 	jack_port_t *port;

  784. 

  785. 	if (!driver->run) {

  786. 		return 0;

  787. 	}

  788. 	if (nframes != driver->period_size) {

  789. 		jack_error (

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

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

  792. 		return -1;

  793. 	}

  794. 

  795. 	pthread_mutex_lock (&driver->mutex_in);

  796. 

  797. 	node = driver->capture_ports;

  798. 	channel = 0;

  799. 	while (node != NULL) {

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

  801. 

  802. 		if (jack_port_connected (port)) {

  803. 			portbuf = jack_port_get_buffer (port, nframes);

  804. 			copy_and_convert_in (portbuf, driver->indevbuf,

  805. 					     nframes, channel,

  806. 					     driver->capture_channels,

  807. 					     driver->bits);

  808. 		}

  809. 

  810. 		node = jack_slist_next (node);

  811. 		channel++;

  812. 	}

  813. 

  814. 	pthread_mutex_unlock (&driver->mutex_in);

  815. 

  816. 	return 0;

  817. }

  818. 

  819. 

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

  821. {

  822. 	int channel;

  823. 	jack_sample_t *portbuf;

  824. 	JSList *node;

  825. 	jack_port_t *port;

  826. 

  827. 	if (!driver->run) {

  828. 		return 0;

  829. 	}

  830. 	if (nframes != driver->period_size) {

  831. 		jack_error (

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

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

  834. 		return -1;

  835. 	}

  836. 

  837. 	pthread_mutex_lock (&driver->mutex_out);

  838. 

  839. 	node = driver->playback_ports;

  840. 	channel = 0;

  841. 	while (node != NULL) {

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

  843. 

  844. 		if (jack_port_connected (port)) {

  845. 			portbuf = jack_port_get_buffer (port, nframes);

  846. 			copy_and_convert_out (driver->outdevbuf, portbuf,

  847. 					      nframes, channel,

  848. 					      driver->playback_channels,

  849. 					      driver->bits);

  850. 		}

  851. 

  852. 		node = jack_slist_next (node);

  853. 		channel++;

  854. 	}

  855. 

  856. 	pthread_mutex_unlock (&driver->mutex_out);

  857. 

  858. 	return 0;

  859. }

  860. 

  861. 

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

  863. {

  864. 	pthread_mutex_lock (&driver->mutex_in);

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

  866. 	pthread_mutex_unlock (&driver->mutex_in);

  867. 

  868. 	pthread_mutex_lock (&driver->mutex_out);

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

  870. 	pthread_mutex_unlock (&driver->mutex_out);

  871. 

  872. 	return 0;

  873. }

  874. 

  875. 

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

  877. {

  878. 	oss_driver_stop (driver);

  879. 

  880. 	set_period_size (driver, nframes);

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

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

  883. 		return -1;

  884. 	}

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

  886. 

  887. 	oss_driver_start (driver);

  888. 

  889. 	return 0;

  890. }

  891. 

  892. 

  893. /* internal driver thread */

  894. 

  895. 

  896. #ifdef USE_BARRIER

  897. static inline void synchronize (oss_driver_t *driver)

  898. {

  899. 	if (driver->threads == 3) {

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

  901. 		    PTHREAD_BARRIER_SERIAL_THREAD) {

  902. 			driver_cycle (driver);

  903. 		}

  904. 	} else {

  905. 		driver_cycle (driver);

  906. 	}

  907. }

  908. #endif

  909. 

  910. 

  911. static void *io_thread (void *param)

  912. {

  913. 	size_t localsize;

  914. 	ssize_t io_res;

  915. 	void *localbuf;

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

  917. 

  918. 	sem_wait (&driver->sem_start);

  919. 

  920. #       ifdef USE_BARRIER

  921. 	if (pthread_self () == driver->thread_in) {

  922. 		localsize = driver->indevbufsize;

  923. 		localbuf = malloc (localsize);

  924. 		if (localbuf == NULL) {

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

  926. 				    __FILE__, __LINE__);

  927. 			return NULL;

  928. 		}

  929. 

  930. 		while (driver->run) {

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

  932. 			if (io_res < (ssize_t)localsize) {

  933. 				jack_error (

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

  935. 					__FILE__, __LINE__, io_res, localsize,

  936. 					errno);

  937. 				break;

  938. 			}

  939. 

  940. 			pthread_mutex_lock (&driver->mutex_in);

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

  942. 			pthread_mutex_unlock (&driver->mutex_in);

  943. 

  944. 			synchronize (driver);

  945. 		}

  946. 

  947. 		free (localbuf);

  948. 	} else if (pthread_self () == driver->thread_out) {

  949. 		localsize = driver->outdevbufsize;

  950. 		localbuf = malloc (localsize);

  951. 		if (localbuf == NULL) {

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

  953. 				    __FILE__, __LINE__);

  954. 			return NULL;

  955. 		}

  956. 		if (driver->trigger) {

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

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

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

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

  961. 		}

  962. 

  963. 		while (driver->run) {

  964. 			pthread_mutex_lock (&driver->mutex_out);

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

  966. 			pthread_mutex_unlock (&driver->mutex_out);

  967. 

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

  969. 			if (io_res < (ssize_t)localsize) {

  970. 				jack_error (

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

  972. 					__FILE__, __LINE__, io_res, localsize,

  973. 					errno);

  974. 				break;

  975. 			}

  976. 

  977. 			synchronize (driver);

  978. 		}

  979. 

  980. 		free (localbuf);

  981. 	}

  982. #       else

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

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

  985. 	localbuf = malloc (localsize);

  986. 	if (localbuf == NULL) {

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

  988. 		return NULL;

  989. 	}

  990. 	if (driver->trigger) {

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

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

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

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

  995. 	}

  996. 

  997. 	while (driver->run) {

  998. 		if (driver->playback_channels > 0) {

  999. 			pthread_mutex_lock (&driver->mutex_out);

  1000. 			memcpy (localbuf, driver->outdevbuf,

  1001. 				driver->outdevbufsize);

  1002. 			pthread_mutex_unlock (&driver->mutex_out);

  1003. 

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

  1005. 					driver->outdevbufsize);

  1006. 			if (io_res < (ssize_t)driver->outdevbufsize) {

  1007. 				jack_error (

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

  1009. 					__FILE__, __LINE__, io_res,

  1010. 					driver->outdevbufsize, errno);

  1011. 				break;

  1012. 			}

  1013. 		}

  1014. 

  1015. 		if (driver->capture_channels > 0) {

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

  1017. 				       driver->indevbufsize);

  1018. 			if (io_res < (ssize_t)driver->indevbufsize) {

  1019. 				jack_error (

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

  1021. 					__FILE__, __LINE__, io_res,

  1022. 					driver->indevbufsize, errno);

  1023. 				break;

  1024. 			}

  1025. 

  1026. 			pthread_mutex_lock (&driver->mutex_in);

  1027. 			memcpy (driver->indevbuf, localbuf,

  1028. 				driver->indevbufsize);

  1029. 			pthread_mutex_unlock (&driver->mutex_in);

  1030. 		}

  1031. 

  1032. 		driver_cycle (driver);

  1033. 	}

  1034. 

  1035. 	free (localbuf);

  1036. #       endif

  1037. 

  1038. 	return NULL;

  1039. }

  1040. 

  1041. 

  1042. /* jack driver published interface */

  1043. 

  1044. 

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

  1046. 

  1047. 

  1048. void driver_finish(jack_driver_t *);

  1049. 

  1050. 

  1051. jack_driver_desc_t * driver_get_descriptor ()

  1052. {

  1053. 	jack_driver_desc_t *desc;

  1054. 	jack_driver_param_desc_t *params;

  1055. 

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

  1057. 	if (desc == NULL) {

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

  1059. 			    __FILE__, __LINE__, errno);

  1060. 		return NULL;

  1061. 	}

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

  1063. 	desc->nparams = OSS_DRIVER_N_PARAMS;

  1064. 

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

  1066. 	if (params == NULL) {

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

  1068. 			    __FILE__, __LINE__, errno);

  1069. 		return NULL;

  1070. 	}

  1071. 	memcpy (params, oss_params,

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

  1073. 	desc->params = params;

  1074. 

  1075. 	return desc;

  1076. }

  1077. 

  1078. 

  1079. jack_driver_t * driver_initialize (jack_client_t *client,

  1080. 				   JSList * params)

  1081. {

  1082. 	int bits = OSS_DRIVER_DEF_BITS;

  1083. 	jack_nframes_t sample_rate = OSS_DRIVER_DEF_FS;

  1084. 	jack_nframes_t period_size = OSS_DRIVER_DEF_BLKSIZE;

  1085. 	jack_nframes_t in_latency = 0;

  1086. 	jack_nframes_t out_latency = 0;

  1087. 	unsigned int nperiods = OSS_DRIVER_DEF_NPERIODS;

  1088. 	unsigned int capture_channels = OSS_DRIVER_DEF_INS;

  1089. 	unsigned int playback_channels = OSS_DRIVER_DEF_OUTS;

  1090. 	const JSList *pnode;

  1091. 	const jack_driver_param_t *param;

  1092. 	oss_driver_t *driver;

  1093. 

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

  1095. 	if (driver == NULL) {

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

  1097. 			    __FILE__, __LINE__, errno);

  1098. 		return NULL;

  1099. 	}

  1100. 	memset (driver, 0x00, sizeof(oss_driver_t));

  1101. 	jack_driver_init ((jack_driver_t*)driver);

  1102. 

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

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

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

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

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

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

  1109. 	driver->null_cycle = (JackDriverNullCycleFunction)

  1110. 			     oss_driver_null_cycle;

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

  1112. 

  1113. 	driver->indev = NULL;

  1114. 	driver->outdev = NULL;

  1115. 	driver->ignorehwbuf = 0;

  1116. 	driver->trigger = 0;

  1117. 

  1118. 	pnode = params;

  1119. 	while (pnode != NULL) {

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

  1121. 

  1122. 		switch (param->character) {

  1123. 		case 'r':

  1124. 			sample_rate = param->value.ui;

  1125. 			break;

  1126. 		case 'p':

  1127. 			period_size = param->value.ui;

  1128. 			break;

  1129. 		case 'n':

  1130. 			nperiods = param->value.ui;

  1131. 			break;

  1132. 		case 'w':

  1133. 			bits = param->value.i;

  1134. 			break;

  1135. 		case 'i':

  1136. 			capture_channels = param->value.ui;

  1137. 			break;

  1138. 		case 'o':

  1139. 			playback_channels = param->value.ui;

  1140. 			break;

  1141. 		case 'C':

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

  1143. 			break;

  1144. 		case 'P':

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

  1146. 			break;

  1147. 		case 'b':

  1148. 			driver->ignorehwbuf = 1;

  1149. 			break;

  1150. 		case 'I':

  1151. 			in_latency = param->value.ui;

  1152. 			break;

  1153. 		case 'O':

  1154. 			out_latency = param->value.ui;

  1155. 			break;

  1156. 		}

  1157. 		pnode = jack_slist_next (pnode);

  1158. 	}

  1159. 

  1160. 	driver->sample_rate = sample_rate;

  1161. 	driver->period_size = period_size;

  1162. 	driver->nperiods = nperiods;

  1163. 	driver->bits = bits;

  1164. 	driver->capture_channels = capture_channels;

  1165. 	driver->playback_channels = playback_channels;

  1166. 	driver->sys_in_latency = in_latency;

  1167. 	driver->sys_out_latency = out_latency;

  1168. 	/* setting driver->period_usecs & co is delayed until attach */

  1169. 

  1170. 	driver->finish = driver_finish;

  1171. 

  1172. 	if (driver->indev == NULL) {

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

  1174. 	}

  1175. 	if (driver->outdev == NULL) {

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

  1177. 	}

  1178. 	driver->infd = -1;

  1179. 	driver->outfd = -1;

  1180. 	switch (driver->bits) {

  1181. #               ifndef OSS_ENDIAN

  1182. #               ifdef __GNUC__

  1183. #               if (defined(__i386__) || defined(__alpha__) || defined(__arm__) || defined(__x86_64__) || (defined(__sh__) && !defined(__LITTLE_ENDIAN__)))

  1184. #               define OSS_LITTLE_ENDIAN 1234

  1185. #               define OSS_ENDIAN OSS_LITTLE_ENDIAN

  1186. #               else

  1187. #               define OSS_BIG_ENDIAN 4321

  1188. #               define OSS_ENDIAN OSS_BIG_ENDIAN

  1189. #               endif

  1190. #               else /* __GNUC__ */

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

  1192. #               define OSS_BIG_ENDIAN 4321

  1193. #               define OSS_ENDIAN OSS_BIG_ENDIAN

  1194. #               else

  1195. #               define OSS_LITTLE_ENDIAN 1234

  1196. #               define OSS_ENDIAN OSS_LITTLE_ENDIAN

  1197. #               endif

  1198. #               endif   /* __GNUC__ */

  1199. #               endif   /* OSS_ENDIAN */

  1200. #               if (OSS_ENDIAN == 1234)

  1201. 	/* little-endian architectures */

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

  1203. 		driver->format = 0x00008000;

  1204. 		break;

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

  1206. 		driver->format = 0x00001000;

  1207. 		break;

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

  1209. 		driver->format = 0x00004000;

  1210. 		break;

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

  1212. 	default:

  1213. 		driver->format = 0x00000010;

  1214. 		break;

  1215. 		/* big-endian architectures */

  1216. #               else

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

  1218. 		break;

  1219. 		driver->format = 0x00010000;

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

  1221. 		driver->format = 0x00002000;

  1222. 		break;

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

  1224. 		driver->format = 0x00004000;

  1225. 		break;

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

  1227. 	default:

  1228. 		driver->format = 0x00000020;

  1229. #               endif

  1230. 	}

  1231. 

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

  1233. 

  1234. 	driver->capture_ports = NULL;

  1235. 	driver->playback_ports = NULL;

  1236. 

  1237. 	driver->engine = NULL;

  1238. 	driver->client = client;

  1239. 

  1240. 	return (jack_driver_t*)driver;

  1241. }

  1242. 

  1243. 

  1244. void driver_finish (jack_driver_t *driver)

  1245. {

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

  1247. 

  1248. 	oss_driver = (oss_driver_t*)driver;

  1249. 	if (oss_driver->indev != NULL) {

  1250. 		free (oss_driver->indev);

  1251. 	}

  1252. 	if (oss_driver->outdev != NULL) {

  1253. 		free (oss_driver->outdev);

  1254. 	}

  1255. 	free (driver);

  1256. }