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

1281 lines
29KB
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. #define OSS_DRIVER_N_PARAMS	11

  70. const static jack_driver_param_desc_t oss_params[OSS_DRIVER_N_PARAMS] = {

  71. 	{ "rate",

  72. 	  'r',

  73. 	  JackDriverParamUInt,

  74. 	  { .ui = OSS_DRIVER_DEF_FS },

  75. 	  "sample rate",

  76. 	  "sample rate"

  77. 	},

  78. 	{ "period",

  79. 	  'p',

  80. 	  JackDriverParamUInt,

  81. 	  { .ui = OSS_DRIVER_DEF_BLKSIZE },

  82. 	  "period size",

  83. 	  "period size"

  84. 	},

  85. 	{ "nperiods",

  86. 	  'n',

  87. 	  JackDriverParamUInt,

  88. 	  { .ui = OSS_DRIVER_DEF_NPERIODS },

  89. 	  "number of periods in buffer",

  90. 	  "number of periods in buffer"

  91. 	},

  92. 	{ "wordlength",

  93. 	  'w',

  94. 	  JackDriverParamInt,

  95. 	  { .i = OSS_DRIVER_DEF_BITS },

  96. 	  "word length",

  97. 	  "word length"

  98. 	},

  99. 	{ "inchannels",

  100. 	  'i',

  101. 	  JackDriverParamUInt,

  102. 	  { .ui = OSS_DRIVER_DEF_INS },

  103. 	  "capture channels",

  104. 	  "capture channels"

  105. 	},

  106. 	{ "outchannels",

  107. 	  'o',

  108. 	  JackDriverParamUInt,

  109. 	  { .ui = OSS_DRIVER_DEF_OUTS },

  110. 	  "playback channels",

  111. 	  "playback channels"

  112. 	},

  113. 	{ "capture",

  114. 	  'C',

  115. 	  JackDriverParamString,

  116. 	  { .str = OSS_DRIVER_DEF_DEV },

  117. 	  "input device",

  118. 	  "input device"

  119. 	},

  120. 	{ "playback",

  121. 	  'P',

  122. 	  JackDriverParamString,

  123. 	  { .str = OSS_DRIVER_DEF_DEV },

  124. 	  "output device",

  125. 	  "output device"

  126. 	},

  127. 	{ "ignorehwbuf",

  128. 	  'b',

  129. 	  JackDriverParamBool,

  130. 	  { },

  131. 	  "ignore hardware period size",

  132. 	  "ignore hardware period size"

  133. 	},

  134. 	{ "input latency",

  135. 	  'I',

  136. 	  JackDriverParamUInt,

  137. 	  { .ui = 0 },

  138. 	  "system input latency",

  139. 	  "system input latency"

  140. 	},

  141. 	{ "output latency",

  142. 	  'O',

  143. 	  JackDriverParamUInt,

  144. 	  { .ui = 0 },

  145. 	  "system output latency",

  146. 	  "system output latency"

  147. 	}

  148. };

  149. 

  150. 

  151. 

  152. /* internal functions */

  153. 

  154. 

  155. static void set_period_size (oss_driver_t *driver, 

  156. 	jack_nframes_t new_period_size)

  157. {

  158. 	driver->period_size = new_period_size;

  159. 

  160. 	driver->period_usecs = 

  161. 		((double) driver->period_size /

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

  163. 	driver->last_wait_ust = 0;

  164. 	driver->last_periodtime = jack_get_microseconds();

  165. 	driver->next_periodtime = 0;

  166. 	driver->iodelay = 0.0F;

  167. }

  168. 

  169. 

  170. static inline void update_times (oss_driver_t *driver)

  171. {

  172. 	driver->last_periodtime = jack_get_microseconds();

  173. 	if (driver->next_periodtime > 0)

  174. 	{

  175. 		driver->iodelay = (float)

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

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

  178. 	}

  179. 	else driver->iodelay = 0.0F;

  180. 	driver->next_periodtime = 

  181. 		driver->last_periodtime +

  182. 		driver->period_usecs;

  183. }

  184. 

  185. 

  186. static inline void driver_cycle (oss_driver_t *driver)

  187. {

  188. 	update_times(driver);

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

  190. 		driver->last_periodtime);

  191. 

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

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

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

  195. }

  196. 

  197. 

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

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

  200. {

  201. 	int srcidx;

  202. 	int dstidx;

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

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

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

  206. 	jack_sample_t scale;

  207. 

  208. 	srcidx = channel;

  209. 	switch (bits)

  210. 	{

  211. 		case 16:

  212. 			scale = 1.0f / 0x7fff;

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

  214. 			{

  215. 				dst[dstidx] = (jack_sample_t) 

  216. 					s16src[srcidx] * scale;

  217. 				srcidx += chcount;

  218. 			}

  219. 			break;

  220. 		case 24:

  221. 			scale = 1.0f / 0x7fffff;

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

  223. 			{

  224. 				dst[dstidx] = (jack_sample_t)

  225. 					s32src[srcidx] * scale;

  226. 				srcidx += chcount;

  227. 			}

  228. 			break;

  229. 		case 32:

  230. 			scale = 1.0f / 0x7fffffff;

  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 64:

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

  240. 			{

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

  242. 				srcidx += chcount;

  243. 			}

  244. 			break;

  245. 	}

  246. }

  247. 

  248. 

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

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

  251. {

  252. 	int srcidx;

  253. 	int dstidx;

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

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

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

  257. 	jack_sample_t scale;

  258. 

  259. 	dstidx = channel;

  260. 	switch (bits)

  261. 	{

  262. 		case 16:

  263. 			scale = 0x7fff;

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

  265. 			{

  266. 				s16dst[dstidx] = (signed short)

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

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

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

  270. 				dstidx += chcount;

  271. 			}

  272. 			break;

  273. 		case 24:

  274. 			scale = 0x7fffff;

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

  276. 			{

  277. 				s32dst[dstidx] = (signed int)

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

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

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

  281. 				dstidx += chcount;

  282. 			}

  283. 			break;

  284. 		case 32:

  285. 			scale = 0x7fffffff;

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

  287. 			{

  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. 			{

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

  299. 				dstidx += chcount;

  300. 			}

  301. 			break;

  302. 	}

  303. }

  304. 

  305. 

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

  307. {

  308. 	int fragsize_2p;

  309. 	int fragments;

  310. 

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

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

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

  314. 	{

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

  316. 			__FILE__, __LINE__, errno);

  317. 	}

  318. }

  319. 

  320. 

  321. static int get_fragment (int fd)

  322. {

  323. 	int fragsize;

  324. 

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

  326. 	{

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

  328. 			__FILE__, __LINE__, errno);

  329. 		return 0;

  330. 	}

  331. 	return fragsize;

  332. }

  333. 

  334. 

  335. static void *io_thread (void *);

  336. 

  337. 

  338. /* jack driver interface */

  339. 

  340. 

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

  342. {

  343. 	int port_flags;

  344. 	unsigned int channel;

  345. 	char channel_name[64];

  346. 	jack_port_t *port;

  347. 

  348. 	driver->engine = engine;

  349. 

  350. 	engine->set_buffer_size(engine, driver->period_size);

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

  352. 

  353. 	port_flags = JackPortIsOutput|JackPortIsPhysical|JackPortIsTerminal;

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

  355. 	{

  356. 		snprintf(channel_name, sizeof(channel_name), 

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

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

  359. 			JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);

  360. 		if (port == NULL)

  361. 		{

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

  363. 				channel_name, __FILE__, __LINE__);

  364. 			break;

  365. 		}

  366. 		jack_port_set_latency(port,

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

  368. 		driver->capture_ports = 

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

  370. 	}

  371. 

  372. 	port_flags = JackPortIsInput|JackPortIsPhysical|JackPortIsTerminal;

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

  374. 	{

  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. 		{

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

  382. 				channel_name, __FILE__, __LINE__);

  383. 			break;

  384. 		}

  385. 		jack_port_set_latency(port,

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

  387. 		driver->playback_ports =

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

  389. 	}

  390. 

  391. 	jack_activate(driver->client);

  392. 

  393. 	return 0;

  394. }

  395. 

  396. 

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

  398. {

  399. 	JSList *node;

  400. 

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

  402. 		return -1;

  403. 

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

  405. 

  406. 	node = driver->capture_ports;

  407. 	while (node != NULL)

  408. 	{

  409. 		jack_port_unregister(driver->client, 

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

  411. 		node = jack_slist_next(node);

  412. 	}

  413. 	jack_slist_free(driver->capture_ports);

  414. 	driver->capture_ports = NULL;

  415. 

  416. 	node = driver->playback_ports;

  417. 	while (node != NULL)

  418. 	{

  419. 		jack_port_unregister(driver->client,

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

  421. 		node = jack_slist_next(node);

  422. 	}

  423. 	jack_slist_free(driver->playback_ports);

  424. 	driver->playback_ports = NULL;

  425. 

  426. 	driver->engine = NULL;

  427. 

  428. 	return 0;

  429. }

  430. 

  431. 

  432. static int oss_driver_start (oss_driver_t *driver)

  433. {

  434. 	int format;

  435. 	int channels;

  436. 	int samplerate;

  437. 	int infd = driver->infd;

  438. 	int outfd = driver->outfd;

  439. 	unsigned int period_size;

  440. 	size_t samplesize;

  441. 	size_t fragsize;

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

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

  444. 

  445. 	switch (driver->bits)

  446. 	{

  447. 		case 24:

  448. 		case 32:

  449. 			samplesize = sizeof(int);

  450. 			break;

  451. 		case 64:

  452. 			samplesize = sizeof(double);

  453. 			break;

  454. 		case 16:

  455. 		default:

  456. 			samplesize = sizeof(short);

  457. 			break;

  458. 	}

  459. 	driver->trigger = 0;

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

  461. 	{

  462. 		if (driver->capture_channels > 0)

  463. 		{

  464. 			infd = open(indev, O_RDONLY);

  465. 			if (infd < 0)

  466. 			{

  467. 				jack_error(

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

  469. 					indev, __FILE__, __LINE__, errno);

  470. 			}

  471. 			fragsize = driver->period_size * 

  472. 				driver->capture_channels * samplesize;

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

  474. 		}

  475. 		else infd = -1;

  476. 

  477. 		if (driver->playback_channels > 0)

  478. 		{

  479. 			outfd = open(outdev, O_WRONLY);

  480. 			if (outfd < 0)

  481. 			{

  482. 				jack_error(

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

  484. 					outdev, __FILE__, __LINE__, errno);

  485. 			}

  486. 			fragsize = driver->period_size * 

  487. 				driver->playback_channels * samplesize;

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

  489. 		}

  490. 		else outfd = -1;

  491. 	}

  492. 	else

  493. 	{

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

  495. 			driver->playback_channels == 0)

  496. 		{

  497. 			infd = open(indev, O_RDWR);

  498. 			outfd = -1;

  499. 			if (infd < 0)

  500. 			{

  501. 				jack_error(

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

  503. 					indev, __FILE__, __LINE__, errno);

  504. 				return -1;

  505. 			}

  506. 		}

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

  508. 			driver->playback_channels != 0)

  509. 		{

  510. 			infd = -1;

  511. 			outfd = open(outdev, O_RDWR);

  512. 			if (outfd < 0)

  513. 			{

  514. 				jack_error(

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

  516. 					outdev, __FILE__, __LINE__, errno);

  517. 				return -1;

  518. 			}

  519. 		}

  520. 		else

  521. 		{

  522. 			infd = outfd = open(indev, O_RDWR);

  523. 			if (infd < 0)

  524. 			{

  525. 				jack_error(

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

  527. 					indev, __FILE__, __LINE__, errno);

  528. 				return -1;

  529. 			}

  530. 		}

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

  532. 		{

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

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

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

  536. 			{

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

  538. 					jack_error(

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

  540. 						indev, __FILE__, __LINE__,

  541. 						errno);

  542. 			}

  543. 		}

  544. 		if (infd >= 0)

  545. 		{

  546. 			fragsize = driver->period_size * 

  547. 				driver->capture_channels * samplesize;

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

  549. 		}

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

  551. 		{

  552. 			fragsize = driver->period_size * 

  553. 				driver->playback_channels * samplesize;

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

  555. 		}

  556. 	}

  557. 	driver->infd = infd;

  558. 	driver->outfd = outfd;

  559. 	

  560. 	if (infd >= 0)

  561. 	{

  562. 		format = driver->format;

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

  564. 			jack_error(

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

  566. 				indev, __FILE__, __LINE__, errno);

  567. 		channels = driver->capture_channels;

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

  569. 			jack_error(

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

  571. 				indev, __FILE__, __LINE__, errno);

  572. 		samplerate = driver->sample_rate;

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

  574. 			jack_error(

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

  576. 				indev, __FILE__, __LINE__, errno);

  577. 		printf("oss_driver: %s : 0x%x/%i/%i (%i)\n", indev, 

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

  579. 		

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

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

  582. 			!driver->ignorehwbuf)

  583. 		{

  584. 			printf("oss_driver: period size update: %u\n",

  585. 				period_size);

  586. 			driver->period_size = period_size;

  587. 			driver->period_usecs = 

  588. 				((double) driver->period_size / 

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

  590. 			driver->engine->set_buffer_size(driver->engine, 

  591. 				driver->period_size);

  592. 		}

  593. 	}

  594. 

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

  596. 	{

  597. 		format = driver->format;

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

  599. 			jack_error(

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

  601. 				outdev, __FILE__, __LINE__, errno);

  602. 		channels = driver->playback_channels;

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

  604. 			jack_error(

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

  606. 				outdev, __FILE__, __LINE__, errno);

  607. 		samplerate = driver->sample_rate;

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

  609. 			jack_error(

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

  611. 				outdev, __FILE__, __LINE__, errno);

  612. 		printf("oss_driver: %s : 0x%x/%i/%i (%i)\n", outdev, 

  613. 			format, channels, samplerate, 

  614. 			get_fragment(outfd));

  615. 

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

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

  618. 			!driver->ignorehwbuf)

  619. 		{

  620. 			printf("oss_driver: period size update: %u\n",

  621. 				period_size);

  622. 			driver->period_size = period_size;

  623. 			driver->period_usecs = 

  624. 				((double) driver->period_size / 

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

  626. 			driver->engine->set_buffer_size(driver->engine, 

  627. 				driver->period_size);

  628. 		}

  629. 	}

  630. 

  631. 	if (driver->capture_channels > 0)

  632. 	{

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

  634. 			driver->capture_channels * samplesize;

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

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

  637. 		{

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

  639. 				__FILE__, __LINE__);

  640. 			return -1;

  641. 		}

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

  643. 	}

  644. 	else

  645. 	{

  646. 		driver->indevbufsize = 0;

  647. 		driver->indevbuf = NULL;

  648. 	}

  649. 

  650. 	if (driver->playback_channels > 0)

  651. 	{

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

  653. 			driver->playback_channels * samplesize;

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

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

  656. 		{

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

  658. 				__FILE__, __LINE__);

  659. 			return -1;

  660. 		}

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

  662. 	}

  663. 	else

  664. 	{

  665. 		driver->outdevbufsize = 0;

  666. 		driver->outdevbuf = NULL;

  667. 	}

  668. 

  669. 	printf("oss_driver: indevbuf %zd B, outdevbuf %zd B\n",

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

  671. 

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

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

  674. #	ifdef USE_BARRIER

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

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

  677. #	else

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

  679. #	endif

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

  681. 	driver->run = 1;

  682. 	driver->threads = 0;

  683. 	if (infd >= 0)

  684. 	{

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

  686. 			driver->engine->rtpriority, 

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

  688. 			io_thread, driver) < 0)

  689. 		{

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

  691. 				__FILE__, __LINE__);

  692. 			return -1;

  693. 		}

  694. 		driver->threads |= 1;

  695. 	}

  696. #	ifdef USE_BARRIER

  697. 	if (outfd >= 0)

  698. 	{

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

  700. 			driver->engine->rtpriority, 

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

  702. 			io_thread, driver) < 0)

  703. 		{

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

  705. 				__FILE__, __LINE__);

  706. 			return -1;

  707. 		}

  708. 		driver->threads |= 2;

  709. 	}

  710. #	endif

  711. 

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

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

  714. 

  715. 	driver->last_periodtime = jack_get_microseconds();

  716. 	driver->next_periodtime = 0;

  717. 	driver->iodelay = 0.0F;

  718. 

  719. 	return 0;

  720. }

  721. 

  722. 

  723. static int oss_driver_stop (oss_driver_t *driver)

  724. {

  725. 	void *retval;

  726. 

  727. 	driver->run = 0;

  728. 	if (driver->threads & 1)

  729. 	{

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

  731. 		{

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

  733. 				__FILE__, __LINE__);

  734. 			return -1;

  735. 		}

  736. 	}

  737. 	if (driver->threads & 2)

  738. 	{

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

  740. 		{

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

  742. 				__FILE__, __LINE__);

  743. 			return -1;

  744. 		}

  745. 	}

  746. 	sem_destroy(&driver->sem_start);

  747. #	ifdef USE_BARRIER

  748. 	pthread_barrier_destroy(&driver->barrier);

  749. #	endif

  750. 	pthread_mutex_destroy(&driver->mutex_in);

  751. 	pthread_mutex_destroy(&driver->mutex_out);

  752. 

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

  754. 	{

  755. 		close(driver->outfd);

  756. 		driver->outfd = -1;

  757. 	}

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

  759. 	{

  760. 		close(driver->infd);

  761. 		driver->infd = -1;

  762. 	}

  763. 

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

  765. 	{

  766. 		free(driver->indevbuf);

  767. 		driver->indevbuf = NULL;

  768. 	}

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

  770. 	{

  771. 		free(driver->outdevbuf);

  772. 		driver->outdevbuf = NULL;

  773. 	}

  774. 

  775. 	return 0;

  776. }

  777. 

  778. 

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

  780. {

  781. 	int channel;

  782. 	jack_sample_t *portbuf;

  783. 	JSList *node;

  784. 	jack_port_t *port;

  785. 

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

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

  788. 	{

  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. 	{

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

  802. 

  803. 		if (jack_port_connected(port))

  804. 		{

  805. 			portbuf = jack_port_get_buffer(port, nframes);

  806. 			copy_and_convert_in(portbuf, driver->indevbuf, 

  807. 				nframes, channel, 

  808. 				driver->capture_channels,

  809. 				driver->bits);

  810. 		}

  811. 

  812. 		node = jack_slist_next(node);

  813. 		channel++;

  814. 	}

  815. 

  816. 	pthread_mutex_unlock(&driver->mutex_in);

  817. 

  818. 	return 0;

  819. }

  820. 

  821. 

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

  823. {

  824. 	int channel;

  825. 	jack_sample_t *portbuf;

  826. 	JSList *node;

  827. 	jack_port_t *port;

  828. 

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

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

  831. 	{

  832. 		jack_error(

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

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

  835. 		return -1;

  836. 	}

  837. 

  838. 	pthread_mutex_lock(&driver->mutex_out);

  839. 

  840. 	node = driver->playback_ports;

  841. 	channel = 0;

  842. 	while (node != NULL)

  843. 	{

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

  845. 

  846. 		if (jack_port_connected(port))

  847. 		{

  848. 			portbuf = jack_port_get_buffer(port, nframes);

  849. 			copy_and_convert_out(driver->outdevbuf, portbuf, 

  850. 				nframes, channel,

  851. 				driver->playback_channels,

  852. 				driver->bits);

  853. 		}

  854. 

  855. 		node = jack_slist_next(node);

  856. 		channel++;

  857. 	}

  858. 

  859. 	pthread_mutex_unlock(&driver->mutex_out);

  860. 

  861. 	return 0;

  862. }

  863. 

  864. 

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

  866. {

  867. 	pthread_mutex_lock(&driver->mutex_in);

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

  869. 	pthread_mutex_unlock(&driver->mutex_in);

  870. 

  871. 	pthread_mutex_lock(&driver->mutex_out);

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

  873. 	pthread_mutex_unlock(&driver->mutex_out);

  874. 

  875. 	return 0;

  876. }

  877. 

  878. 

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

  880. {

  881. 	oss_driver_stop(driver);

  882. 

  883. 	set_period_size(driver, nframes);

  884. 	driver->engine->set_buffer_size(driver->engine, driver->period_size);

  885. 	printf("oss_driver: period size update: %u\n", 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. 	{

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

  902. 			PTHREAD_BARRIER_SERIAL_THREAD)

  903. 		{

  904. 			driver_cycle(driver);

  905. 		}

  906. 	}

  907. 	else

  908. 	{

  909. 		driver_cycle(driver);

  910. 	}

  911. }

  912. #endif

  913. 

  914. 

  915. static void *io_thread (void *param)

  916. {

  917. 	size_t localsize;

  918. 	ssize_t io_res;

  919. 	void *localbuf;

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

  921. 

  922. 	sem_wait(&driver->sem_start);

  923. 

  924. #	ifdef USE_BARRIER

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

  926. 	{

  927. 		localsize = driver->indevbufsize;

  928. 		localbuf = malloc(localsize);

  929. 		if (localbuf == NULL)

  930. 		{

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

  932. 				__FILE__, __LINE__);

  933. 			return NULL;

  934. 		}

  935. 

  936. 		while (driver->run)

  937. 		{

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

  939. 			if (io_res < (ssize_t) localsize)

  940. 			{

  941. 				jack_error(

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

  943. 					__FILE__, __LINE__, io_res, localsize,

  944. 					errno);

  945. 				break;

  946. 			}

  947. 

  948. 			pthread_mutex_lock(&driver->mutex_in);

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

  950. 			pthread_mutex_unlock(&driver->mutex_in);

  951. 

  952. 			synchronize(driver);

  953. 		}

  954. 

  955. 		free(localbuf);

  956. 	}

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

  958. 	{

  959. 		localsize = driver->outdevbufsize;

  960. 		localbuf = malloc(localsize);

  961. 		if (localbuf == NULL)

  962. 		{

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

  964. 				__FILE__, __LINE__);

  965. 			return NULL;

  966. 		}

  967. 		if (driver->trigger)

  968. 		{

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

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

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

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

  973. 		}

  974. 

  975. 		while (driver->run)

  976. 		{

  977. 			pthread_mutex_lock(&driver->mutex_out);

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

  979. 			pthread_mutex_unlock(&driver->mutex_out);

  980. 

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

  982. 			if (io_res < (ssize_t) localsize)

  983. 			{

  984. 				jack_error(

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

  986. 					__FILE__, __LINE__, io_res, localsize,

  987. 					errno);

  988. 				break;

  989. 			}

  990. 

  991. 			synchronize(driver);

  992. 		}

  993. 

  994. 		free(localbuf);

  995. 	}

  996. #	else

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

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

  999. 	localbuf = malloc(localsize);

  1000. 	if (localbuf == NULL)

  1001. 	{

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

  1003. 		return NULL;

  1004. 	}

  1005. 	if (driver->trigger)

  1006. 	{

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

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

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

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

  1011. 	}

  1012. 

  1013. 	while (driver->run)

  1014. 	{

  1015. 		if (driver->playback_channels > 0)

  1016. 		{

  1017. 			pthread_mutex_lock(&driver->mutex_out);

  1018. 			memcpy(localbuf, driver->outdevbuf, 

  1019. 				driver->outdevbufsize);

  1020. 			pthread_mutex_unlock(&driver->mutex_out);

  1021. 

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

  1023. 				driver->outdevbufsize);

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

  1025. 			{

  1026. 				jack_error(

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

  1028. 					__FILE__, __LINE__, io_res,

  1029. 					driver->outdevbufsize, errno);

  1030. 				break;

  1031. 			}

  1032. 		}

  1033. 

  1034. 		if (driver->capture_channels > 0)

  1035. 		{

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

  1037. 				driver->indevbufsize);

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

  1039. 			{

  1040. 				jack_error(

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

  1042. 					__FILE__, __LINE__, io_res,

  1043. 					driver->indevbufsize, errno);

  1044. 				break;

  1045. 			}

  1046. 

  1047. 			pthread_mutex_lock(&driver->mutex_in);

  1048. 			memcpy(driver->indevbuf, localbuf, 

  1049. 				driver->indevbufsize);

  1050. 			pthread_mutex_unlock(&driver->mutex_in);

  1051. 		}

  1052. 

  1053. 		driver_cycle(driver);

  1054. 	}

  1055. 

  1056. 	free(localbuf);

  1057. #	endif

  1058. 

  1059. 	return NULL;

  1060. }

  1061. 

  1062. 

  1063. /* jack driver published interface */

  1064. 

  1065. 

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

  1067. 

  1068. 

  1069. void driver_finish (jack_driver_t *);

  1070. 

  1071. 

  1072. jack_driver_desc_t * driver_get_descriptor ()

  1073. {

  1074. 	jack_driver_desc_t *desc;

  1075. 	jack_driver_param_desc_t *params;

  1076. 

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

  1078. 	if (desc == NULL)

  1079. 	{

  1080. 		printf("oss_driver: calloc() failed: %s@%i, errno=%d\n",

  1081. 			__FILE__, __LINE__, errno);

  1082. 		return NULL;

  1083. 	}

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

  1085. 	desc->nparams = OSS_DRIVER_N_PARAMS;

  1086. 

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

  1088. 	if (params == NULL)

  1089. 	{

  1090. 		printf("oss_driver: calloc() failed: %s@%i, errno=%d\n",

  1091. 			__FILE__, __LINE__, errno);

  1092. 		return NULL;

  1093. 	}

  1094. 	memcpy(params, oss_params, 

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

  1096. 	desc->params = params;

  1097. 

  1098. 	return desc;

  1099. }

  1100. 

  1101. 

  1102. jack_driver_t * driver_initialize (jack_client_t *client, 

  1103. 	JSList * params)

  1104. {

  1105. 	int bits = OSS_DRIVER_DEF_BITS;

  1106. 	jack_nframes_t sample_rate = OSS_DRIVER_DEF_FS;

  1107. 	jack_nframes_t period_size = OSS_DRIVER_DEF_BLKSIZE;

  1108. 	jack_nframes_t in_latency = 0;

  1109. 	jack_nframes_t out_latency = 0;

  1110. 	unsigned int nperiods = OSS_DRIVER_DEF_NPERIODS;

  1111. 	unsigned int capture_channels = OSS_DRIVER_DEF_INS;

  1112. 	unsigned int playback_channels = OSS_DRIVER_DEF_OUTS;

  1113. 	const JSList *pnode;

  1114. 	const jack_driver_param_t *param;

  1115. 	oss_driver_t *driver;

  1116. 

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

  1118. 	if (driver == NULL)

  1119. 	{

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

  1121. 			__FILE__, __LINE__, errno);

  1122. 		return NULL;

  1123. 	}

  1124. 	jack_driver_init((jack_driver_t *) driver);

  1125. 

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

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

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

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

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

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

  1132. 	driver->null_cycle = (JackDriverNullCycleFunction) 

  1133. 		oss_driver_null_cycle;

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

  1135. 

  1136. 	driver->indev = NULL;

  1137. 	driver->outdev = NULL;

  1138. 	driver->ignorehwbuf = 0;

  1139. 	driver->trigger = 0;

  1140. 

  1141. 	pnode = params;

  1142. 	while (pnode != NULL)

  1143. 	{

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

  1145. 

  1146. 		switch (param->character)

  1147. 		{

  1148. 			case 'r':

  1149. 				sample_rate = param->value.ui;

  1150. 				break;

  1151. 			case 'p':

  1152. 				period_size = param->value.ui;

  1153. 				break;

  1154. 			case 'n':

  1155. 				nperiods = param->value.ui;

  1156. 				break;

  1157. 			case 'w':

  1158. 				bits = param->value.i;

  1159. 				break;

  1160. 			case 'i':

  1161. 				capture_channels = param->value.ui;

  1162. 				break;

  1163. 			case 'o':

  1164. 				playback_channels = param->value.ui;

  1165. 				break;

  1166. 			case 'C':

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

  1168. 				break;

  1169. 			case 'P':

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

  1171. 				break;

  1172. 			case 'b':

  1173. 				driver->ignorehwbuf = 1;

  1174. 				break;

  1175. 			case 'I':

  1176. 				in_latency = param->value.ui;

  1177. 				break;

  1178. 			case 'O':

  1179. 				out_latency = param->value.ui;

  1180. 				break;

  1181. 		}

  1182. 		pnode = jack_slist_next(pnode);

  1183. 	}

  1184. 	

  1185. 	driver->sample_rate = sample_rate;

  1186. 	driver->period_size = period_size;

  1187. 	driver->nperiods = nperiods;

  1188. 	driver->bits = bits;

  1189. 	driver->capture_channels = capture_channels;

  1190. 	driver->playback_channels = playback_channels;

  1191. 	driver->sys_in_latency = in_latency;

  1192. 	driver->sys_out_latency = out_latency;

  1193. 

  1194. 	set_period_size(driver, period_size);

  1195. 	

  1196. 	driver->finish = driver_finish;

  1197. 

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

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

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

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

  1202. 	driver->infd = -1;

  1203. 	driver->outfd = -1;

  1204. 	switch (driver->bits)

  1205. 	{

  1206. #		ifndef OSS_ENDIAN

  1207. #		ifdef __GNUC__

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

  1209. #		define OSS_LITTLE_ENDIAN 1234

  1210. #		define OSS_ENDIAN OSS_LITTLE_ENDIAN

  1211. #		else

  1212. #		define OSS_BIG_ENDIAN 4321

  1213. #		define OSS_ENDIAN OSS_BIG_ENDIAN

  1214. #		endif

  1215. #		else /* __GNUC__ */

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

  1217. #		define OSS_BIG_ENDIAN 4321

  1218. #		define OSS_ENDIAN OSS_BIG_ENDIAN

  1219. #		else

  1220. #		define OSS_LITTLE_ENDIAN 1234

  1221. #		define OSS_ENDIAN OSS_LITTLE_ENDIAN

  1222. #		endif

  1223. #		endif /* __GNUC__ */

  1224. #		endif /* OSS_ENDIAN */

  1225. #		if (OSS_ENDIAN == 1234)

  1226. 		/* little-endian architectures */

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

  1228. 			driver->format = 0x00008000;

  1229. 			break;

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

  1231. 			driver->format = 0x00001000;

  1232. 			break;

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

  1234. 			driver->format = 0x00004000;

  1235. 			break;

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

  1237. 		default:

  1238. 			driver->format = 0x00000010;

  1239. 			break;

  1240. 		/* big-endian architectures */

  1241. #		else

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

  1243. 			break;

  1244. 			driver->format = 0x00010000;

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

  1246. 			driver->format = 0x00002000;

  1247. 			break;

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

  1249. 			driver->format = 0x00004000;

  1250. 			break;

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

  1252. 		default:

  1253. 			driver->format = 0x00000020;

  1254. #		endif

  1255. 	}

  1256. 

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

  1258. 

  1259. 	driver->capture_ports = NULL;

  1260. 	driver->playback_ports = NULL;

  1261. 

  1262. 	driver->engine = NULL;

  1263. 	driver->client = client;

  1264. 

  1265. 	return ((jack_driver_t *) driver);

  1266. }

  1267. 

  1268. 

  1269. void driver_finish (jack_driver_t *driver)

  1270. {

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

  1272. 

  1273. 	oss_driver = (oss_driver_t *) driver;

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

  1275. 		free(oss_driver->indev);

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

  1277. 		free(oss_driver->outdev);

  1278. 	free(driver);

  1279. }