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

1175 lines
26KB
Raw Blame History 

  1. /*

  2. 

  3. 	OSS driver for Jack

  4. 	Copyright (C) 2003-2004 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. #include <config.h>

  24. 

  25. #include <stdio.h>

  26. #include <stdlib.h>

  27. #include <string.h>

  28. #include <unistd.h>

  29. #include <fcntl.h>

  30. #include <errno.h>

  31. #include <math.h>

  32. #include <float.h>

  33. #include <sys/types.h>

  34. #include <sys/stat.h>

  35. #include <sys/ioctl.h>

  36. #include <sys/soundcard.h>

  37. #include <stdarg.h>

  38. #include <getopt.h>

  39. #include <pthread.h>

  40. 

  41. #ifdef USE_BARRIER

  42. #include <semaphore.h>

  43. #endif

  44. 

  45. #include <jack/types.h>

  46. #include <jack/internal.h>

  47. #include <jack/engine.h>

  48. #include <jack/time.h>

  49. 

  50. #include "oss_driver.h"

  51. 

  52. 

  53. #define OSS_DRIVER_N_PARAMS	9

  54. const static jack_driver_param_desc_t oss_params[OSS_DRIVER_N_PARAMS] = {

  55. 	{ "samplerate",

  56. 	  's',

  57. 	  JackDriverParamUInt,

  58. 	  { .ui = OSS_DRIVER_DEF_FS },

  59. 	  "sample rate",

  60. 	  "sample rate"

  61. 	},

  62. 	{ "periodsize",

  63. 	  'b',

  64. 	  JackDriverParamUInt,

  65. 	  { .ui = OSS_DRIVER_DEF_BLKSIZE },

  66. 	  "period size",

  67. 	  "period size"

  68. 	},

  69. 	{ "wordlength",

  70. 	  'w',

  71. 	  JackDriverParamInt,

  72. 	  { .i = OSS_DRIVER_DEF_BITS },

  73. 	  "word length",

  74. 	  "word length"

  75. 	},

  76. 	{ "capturech",

  77. 	  'c',

  78. 	  JackDriverParamUInt,

  79. 	  { .ui = OSS_DRIVER_DEF_INS },

  80. 	  "capture channels",

  81. 	  "capture channels"

  82. 	},

  83. 	{ "playbackch",

  84. 	  'p',

  85. 	  JackDriverParamUInt,

  86. 	  { .ui = OSS_DRIVER_DEF_OUTS },

  87. 	  "playback channels",

  88. 	  "playback channels"

  89. 	},

  90. 	{ "inputdev",

  91. 	  'i',

  92. 	  JackDriverParamString,

  93. 	  { .str = "" },

  94. 	  "input device",

  95. 	  "input device"

  96. 	},

  97. 	{ "outputdev",

  98. 	  'o',

  99. 	  JackDriverParamString,

  100. 	  { .str = "" },

  101. 	  "output device",

  102. 	  "output device"

  103. 	},

  104. 	{ "ignorehwbuf",

  105. 	  'd',

  106. 	  JackDriverParamBool,

  107. 	  { },

  108. 	  "ignore hardware period size",

  109. 	  "ignore hardware period size"

  110. 	},

  111. 	{ "help",

  112. 	  'h',

  113. 	  JackDriverParamBool,

  114. 	  { },

  115. 	  "help",

  116. 	  "help"

  117. 	}

  118. };

  119. 

  120. 

  121. 

  122. /* internal functions */

  123. 

  124. 

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

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

  127. {

  128. 	int srcidx;

  129. 	int dstidx;

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

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

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

  133. 	jack_sample_t scale;

  134. 

  135. 	srcidx = channel;

  136. 	switch (bits)

  137. 	{

  138. 		case 16:

  139. 			scale = 1.0f / 0x7fff;

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

  141. 			{

  142. 				dst[dstidx] = (jack_sample_t) 

  143. 					s16src[srcidx] * scale;

  144. 				srcidx += chcount;

  145. 			}

  146. 			break;

  147. 		case 24:

  148. 			scale = 1.0f / 0x7fffff;

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

  150. 			{

  151. 				dst[dstidx] = (jack_sample_t)

  152. 					s32src[srcidx] * scale;

  153. 				srcidx += chcount;

  154. 			}

  155. 			break;

  156. 		case 32:

  157. 			scale = 1.0f / 0x7fffffff;

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

  159. 			{

  160. 				dst[dstidx] = (jack_sample_t)

  161. 					s32src[srcidx] * scale;

  162. 				srcidx += chcount;

  163. 			}

  164. 			break;

  165. 		case 64:

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

  167. 			{

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

  169. 				srcidx += chcount;

  170. 			}

  171. 			break;

  172. 	}

  173. }

  174. 

  175. 

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

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

  178. {

  179. 	int srcidx;

  180. 	int dstidx;

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

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

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

  184. 	jack_sample_t scale;

  185. 

  186. 	dstidx = channel;

  187. 	switch (bits)

  188. 	{

  189. 		case 16:

  190. 			scale = 0x7fff;

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

  192. 			{

  193. 				s16dst[dstidx] = (signed short) 

  194. 					(src[srcidx] * scale + 0.5f);

  195. 				dstidx += chcount;

  196. 			}

  197. 			break;

  198. 		case 24:

  199. 			scale = 0x7fffff;

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

  201. 			{

  202. 				s32dst[dstidx] = (signed int)

  203. 					(src[srcidx] * scale + 0.5f);

  204. 				dstidx += chcount;

  205. 			}

  206. 			break;

  207. 		case 32:

  208. 			scale = 0x7fffffff;

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

  210. 			{

  211. 				s32dst[dstidx] = (signed int)

  212. 					(src[srcidx] * scale + 0.5f);

  213. 				dstidx += chcount;

  214. 			}

  215. 			break;

  216. 		case 64:

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

  218. 			{

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

  220. 				dstidx += chcount;

  221. 			}

  222. 			break;

  223. 	}

  224. }

  225. 

  226. 

  227. static void set_fragment (int fd, int fragsize)

  228. {

  229. 	int fragcount;

  230. 	int fragsize_2p;

  231. 	int fragments;

  232. 

  233. 	fragcount = 2;

  234. 	//fragcount = 3;

  235. 	//fragcount = 0xffff / fragsize;

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

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

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

  239. 	{

  240. 		jack_error("OSS: failed to set fragment size: %s@%i",

  241. 			__FILE__, __LINE__);

  242. 	}

  243. }

  244. 

  245. 

  246. static int get_fragment (int fd)

  247. {

  248. 	int fragsize;

  249. 

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

  251. 	{

  252. 		jack_error("OSS: failed to get fragment size: %s@%i",

  253. 			__FILE__, __LINE__);

  254. 		return 0;

  255. 	}

  256. 	return fragsize;

  257. }

  258. 

  259. 

  260. static void *io_thread (void *);

  261. 

  262. 

  263. /* jack driver interface */

  264. 

  265. 

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

  267. {

  268. 	int port_flags;

  269. 	unsigned int channel;

  270. 	char channel_name[64];

  271. 	jack_port_t *port;

  272. 

  273. 	driver->engine = engine;

  274. 

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

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

  277. 

  278. 	port_flags = JackPortIsOutput|JackPortIsPhysical|JackPortIsTerminal;

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

  280. 	{

  281. 		snprintf(channel_name, sizeof(channel_name), 

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

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

  284. 			JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);

  285. 		if (port == NULL)

  286. 		{

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

  288. 				channel_name, __FILE__, __LINE__);

  289. 			break;

  290. 		}

  291. 		driver->capture_ports = 

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

  293. 	}

  294. 

  295. 	port_flags = JackPortIsInput|JackPortIsPhysical|JackPortIsTerminal;

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

  297. 	{

  298. 		snprintf(channel_name, sizeof(channel_name),

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

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

  301. 			JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);

  302. 		if (port == NULL)

  303. 		{

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

  305. 				channel_name, __FILE__, __LINE__);

  306. 			break;

  307. 		}

  308. 		driver->playback_ports =

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

  310. 	}

  311. 

  312. 	jack_activate(driver->client);

  313. 

  314. 	return 0;

  315. }

  316. 

  317. 

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

  319. {

  320. 	JSList *node;

  321. 

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

  323. 		return -1;

  324. 

  325. 	node = driver->capture_ports;

  326. 	while (node != NULL)

  327. 	{

  328. 		jack_port_unregister(driver->client, 

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

  330. 		node = jack_slist_next(node);

  331. 	}

  332. 	jack_slist_free(driver->capture_ports);

  333. 	driver->capture_ports = NULL;

  334. 

  335. 	node = driver->playback_ports;

  336. 	while (node != NULL)

  337. 	{

  338. 		jack_port_unregister(driver->client,

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

  340. 		node = jack_slist_next(node);

  341. 	}

  342. 	jack_slist_free(driver->playback_ports);

  343. 	driver->playback_ports = NULL;

  344. 

  345. 	driver->engine = NULL;

  346. 

  347. 	return 0;

  348. }

  349. 

  350. 

  351. static int oss_driver_start (oss_driver_t *driver)

  352. {

  353. 	int format;

  354. 	int channels;

  355. 	int samplerate;

  356. 	int infd = driver->infd;

  357. 	int outfd = driver->outfd;

  358. 	unsigned int period_size;

  359. 	size_t samplesize;

  360. 	size_t fragsize;

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

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

  363. 

  364. 	switch (driver->bits)

  365. 	{

  366. 		case 24:

  367. 		case 32:

  368. 			samplesize = sizeof(int);

  369. 			break;

  370. 		case 64:

  371. 			samplesize = sizeof(double);

  372. 			break;

  373. 		case 16:

  374. 		default:

  375. 			samplesize = sizeof(short);

  376. 			break;

  377. 	}

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

  379. 	{

  380. 		if (driver->capture_channels > 0)

  381. 		{

  382. 			infd = open(indev, O_RDONLY);

  383. 			if (infd < 0)

  384. 			{

  385. 				jack_error(

  386. 					"OSS: failed to open input device %s: %s@%i",

  387. 					indev, __FILE__, __LINE__);

  388. 			}

  389. 			fragsize = driver->period_size * 

  390. 				driver->capture_channels * samplesize;

  391. 			set_fragment(infd, fragsize);

  392. 		}

  393. 		else infd = -1;

  394. 

  395. 		if (driver->playback_channels > 0)

  396. 		{

  397. 			outfd = open(outdev, O_WRONLY);

  398. 			if (outfd < 0)

  399. 			{

  400. 				jack_error(

  401. 					"OSS: failed to open output device %s: %s@%i",

  402. 					outdev, __FILE__, __LINE__);

  403. 			}

  404. 			fragsize = driver->period_size * 

  405. 				driver->playback_channels * samplesize;

  406. 			set_fragment(outfd, fragsize);

  407. 		}

  408. 		else outfd = -1;

  409. 	}

  410. 	else

  411. 	{

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

  413. 			driver->playback_channels == 0)

  414. 		{

  415. 			infd = open(indev, O_RDWR);

  416. 			outfd = -1;

  417. 			if (infd < 0)

  418. 			{

  419. 				jack_error(

  420. 					"OSS: failed to open device %s: %s@%i",

  421. 					indev, __FILE__, __LINE__);

  422. 				return -1;

  423. 			}

  424. 		}

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

  426. 			driver->playback_channels != 0)

  427. 		{

  428. 			infd = -1;

  429. 			outfd = open(outdev, O_RDWR);

  430. 			if (outfd < 0)

  431. 			{

  432. 				jack_error(

  433. 					"OSS: failed to open device %s: %s@%i",

  434. 					outdev, __FILE__, __LINE__);

  435. 				return -1;

  436. 			}

  437. 		}

  438. 		else

  439. 		{

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

  441. 			if (infd < 0)

  442. 			{

  443. 				jack_error(

  444. 					"OSS: failed to open device %s: %s@%i",

  445. 					indev, __FILE__, __LINE__);

  446. 				return -1;

  447. 			}

  448. 		}

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

  450. 		{

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

  452. 			{

  453. 				jack_error(

  454. 					"OSS: failed to enable full duplex for %s: %s@%i",

  455. 					indev, __FILE__, __LINE__);

  456. 			}

  457. 		}

  458. 		if (infd >= 0)

  459. 		{

  460. 			fragsize = driver->period_size * 

  461. 				driver->capture_channels * samplesize;

  462. 			set_fragment(infd, fragsize);

  463. 		}

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

  465. 		{

  466. 			fragsize = driver->period_size * 

  467. 				driver->playback_channels * samplesize;

  468. 			set_fragment(outfd, fragsize);

  469. 		}

  470. 	}

  471. 	driver->infd = infd;

  472. 	driver->outfd = outfd;

  473. 	

  474. 	if (infd >= 0)

  475. 	{

  476. 		format = driver->format;

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

  478. 			jack_error(

  479. 				"OSS: failed to set format for %s: %s@%i", 

  480. 				indev, __FILE__, __LINE__);

  481. 		channels = driver->capture_channels;

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

  483. 			jack_error(

  484. 				"OSS: failed to set channels for %s: %s@%i", 

  485. 				indev, __FILE__, __LINE__);

  486. 		samplerate = driver->sample_rate;

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

  488. 			jack_error(

  489. 				"OSS: failed to set samplerate for %s: %s@%i", 

  490. 				indev, __FILE__, __LINE__);

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

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

  493. 		

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

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

  496. 			!driver->ignorehwbuf)

  497. 		{

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

  499. 				period_size);

  500. 			driver->period_size = period_size;

  501. 			driver->period_usecs = 

  502. 				((double) driver->period_size / 

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

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

  505. 				driver->period_size);

  506. 		}

  507. 	}

  508. 

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

  510. 	{

  511. 		format = driver->format;

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

  513. 			jack_error(

  514. 				"OSS: failed to set format for %s: %s@%i", 

  515. 				outdev, __FILE__, __LINE__);

  516. 		channels = driver->playback_channels;

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

  518. 			jack_error(

  519. 				"OSS: failed to set channels for %s: %s@%i", 

  520. 				outdev, __FILE__, __LINE__);

  521. 		samplerate = driver->sample_rate;

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

  523. 			jack_error(

  524. 				"OSS: failed to set samplerate for %s: %s@%i", 

  525. 				outdev, __FILE__, __LINE__);

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

  527. 			format, channels, samplerate, 

  528. 			get_fragment(outfd));

  529. 

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

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

  532. 			!driver->ignorehwbuf)

  533. 		{

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

  535. 				period_size);

  536. 			driver->period_size = period_size;

  537. 			driver->period_usecs = 

  538. 				((double) driver->period_size / 

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

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

  541. 				driver->period_size);

  542. 		}

  543. 	}

  544. 

  545. 	if (driver->capture_channels > 0)

  546. 	{

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

  548. 			driver->capture_channels * samplesize;

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

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

  551. 		{

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

  553. 				__FILE__, __LINE__);

  554. 			return -1;

  555. 		}

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

  557. 	}

  558. 	else

  559. 	{

  560. 		driver->indevbufsize = 0;

  561. 		driver->indevbuf = NULL;

  562. 	}

  563. 

  564. 	if (driver->playback_channels > 0)

  565. 	{

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

  567. 			driver->playback_channels * samplesize;

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

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

  570. 		{

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

  572. 				__FILE__, __LINE__);

  573. 			return -1;

  574. 		}

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

  576. 	}

  577. 	else

  578. 	{

  579. 		driver->outdevbufsize = 0;

  580. 		driver->outdevbuf = NULL;

  581. 	}

  582. 

  583. 	printf("oss_driver: indevbuf %u B, outdevbuf %u B\n",

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

  585. 

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

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

  588. #	ifdef USE_BARRIER

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

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

  591. #	endif

  592. 	driver->run = 1;

  593. 	driver->threads = 0;

  594. 	if (infd >= 0)

  595. 	{

  596. 		if (pthread_create(&driver->thread_in, NULL, io_thread, 

  597. 			driver) < 0)

  598. 		{

  599. 			jack_error("OSS: pthread_create() failed: %s@%i",

  600. 				__FILE__, __LINE__);

  601. 			return -1;

  602. 		}

  603. 		driver->threads |= 1;

  604. 	}

  605. #	ifdef USE_BARRIER

  606. 	if (outfd >= 0)

  607. #	else

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

  609. #	endif

  610. 	{

  611. 		if (pthread_create(&driver->thread_out, NULL, io_thread,

  612. 			driver) < 0)

  613. 		{

  614. 			jack_error("OSS: pthread_create() failed: %s@%i",

  615. 				__FILE__, __LINE__);

  616. 			return -1;

  617. 		}

  618. 		driver->threads |= 2;

  619. 	}

  620. 

  621. #	ifdef USE_BARRIER

  622. 	sem_post(&driver->sem_start);

  623. 	sem_post(&driver->sem_start);

  624. #	endif

  625. 

  626. 	return 0;

  627. }

  628. 

  629. 

  630. static int oss_driver_stop (oss_driver_t *driver)

  631. {

  632. 	void *retval;

  633. 

  634. 	driver->run = 0;

  635. 	if (driver->threads & 1)

  636. 	{

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

  638. 		{

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

  640. 				__FILE__, __LINE__);

  641. 			return -1;

  642. 		}

  643. 	}

  644. 	if (driver->threads & 2)

  645. 	{

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

  647. 		{

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

  649. 				__FILE__, __LINE__);

  650. 			return -1;

  651. 		}

  652. 	}

  653. #	ifdef USE_BARRIER

  654. 	sem_destroy(&driver->sem_start);

  655. 	pthread_barrier_destroy(&driver->barrier);

  656. #	endif

  657. 	pthread_mutex_destroy(&driver->mutex_in);

  658. 	pthread_mutex_destroy(&driver->mutex_out);

  659. 

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

  661. 	{

  662. 		close(driver->outfd);

  663. 		driver->outfd = -1;

  664. 	}

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

  666. 	{

  667. 		close(driver->infd);

  668. 		driver->infd = -1;

  669. 	}

  670. 

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

  672. 	{

  673. 		free(driver->indevbuf);

  674. 		driver->indevbuf = NULL;

  675. 	}

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

  677. 	{

  678. 		free(driver->outdevbuf);

  679. 		driver->outdevbuf = NULL;

  680. 	}

  681. 

  682. 	return 0;

  683. }

  684. 

  685. 

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

  687. {

  688. 	int channel;

  689. 	jack_sample_t *portbuf;

  690. 	JSList *node;

  691. 	jack_port_t *port;

  692. 

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

  694. 	{

  695. 		jack_error(

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

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

  698. 		return -1;

  699. 	}

  700. 

  701. 	pthread_mutex_lock(&driver->mutex_in);

  702. 

  703. 	node = driver->capture_ports;

  704. 	channel = 0;

  705. 	while (node != NULL)

  706. 	{

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

  708. 

  709. 		if (jack_port_connected(port))

  710. 		{

  711. 			portbuf = jack_port_get_buffer(port, nframes);

  712. 			copy_and_convert_in(portbuf, driver->indevbuf, 

  713. 				nframes, channel, 

  714. 				driver->capture_channels,

  715. 				driver->bits);

  716. 		}

  717. 

  718. 		node = jack_slist_next(node);

  719. 		channel++;

  720. 	}

  721. 

  722. 	pthread_mutex_unlock(&driver->mutex_in);

  723. 

  724. 	return 0;

  725. }

  726. 

  727. 

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

  729. {

  730. 	int channel;

  731. 	jack_sample_t *portbuf;

  732. 	JSList *node;

  733. 	jack_port_t *port;

  734. 

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

  736. 	{

  737. 		jack_error(

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

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

  740. 		return -1;

  741. 	}

  742. 

  743. 	pthread_mutex_lock(&driver->mutex_out);

  744. 

  745. 	node = driver->playback_ports;

  746. 	channel = 0;

  747. 	while (node != NULL)

  748. 	{

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

  750. 

  751. 		if (jack_port_connected(port))

  752. 		{

  753. 			portbuf = jack_port_get_buffer(port, nframes);

  754. 			copy_and_convert_out(driver->outdevbuf, portbuf, 

  755. 				nframes, channel,

  756. 				driver->playback_channels,

  757. 				driver->bits);

  758. 		}

  759. 

  760. 		node = jack_slist_next(node);

  761. 		channel++;

  762. 	}

  763. 

  764. 	pthread_mutex_unlock(&driver->mutex_out);

  765. 

  766. 	return 0;

  767. }

  768. 

  769. 

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

  771. {

  772. 	pthread_mutex_lock(&driver->mutex_in);

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

  774. 	pthread_mutex_unlock(&driver->mutex_in);

  775. 

  776. 	pthread_mutex_lock(&driver->mutex_out);

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

  778. 	pthread_mutex_unlock(&driver->mutex_out);

  779. 

  780. 	return 0;

  781. }

  782. 

  783. 

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

  785. {

  786. 	oss_driver_stop(driver);

  787. 

  788. 	driver->period_size = nframes;

  789. 	driver->period_usecs = 

  790. 		((double) driver->period_size / 

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

  792. 	printf("oss_driver: period size update: %u\n", driver->period_size);

  793. 

  794. 	oss_driver_start(driver);

  795. 

  796. 	return 0;

  797. }

  798. 

  799. 

  800. /* internal driver thread */

  801. 

  802. static inline void start_process_cycle (oss_driver_t *driver)

  803. {

  804. 	driver->last_wait_ust = jack_get_microseconds();

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

  806. 					      driver->last_wait_ust);

  807. 	/* what is the actual delay value? (not zero) */

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

  809. 				  driver->period_size, 0);

  810. }

  811. 

  812. #ifdef USE_BARRIER

  813. static inline void synchronize (oss_driver_t *driver)

  814. {

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

  816. 	{

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

  818. 			PTHREAD_BARRIER_SERIAL_THREAD)

  819. 		{

  820. 			start_process_cycle(driver);

  821. 		}

  822. 	}

  823. 	else

  824. 	{

  825. 		start_process_cycle(driver);

  826. 	}

  827. }

  828. #endif

  829. 

  830. 

  831. static void *io_thread (void *param)

  832. {

  833. 	int schedpol;

  834. 	size_t localsize;

  835. 	void *localbuf;

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

  837. 	struct sched_param schedp;

  838. 

  839. 	if (pthread_getschedparam(pthread_self(), &schedpol, &schedp) == 0)

  840. 	{

  841. 		schedpol = SCHED_FIFO;

  842. 		schedp.sched_priority = sched_get_priority_max(SCHED_FIFO) - 1;

  843. 		if (pthread_setschedparam(pthread_self(), schedpol, 

  844. 			&schedp) < 0)

  845. 		{

  846. 			puts("oss_driver: pthread_setschedparam() failed\n");

  847. 		}

  848. 	}

  849. 	else

  850. 	{

  851. 		puts("oss_driver: pthread_getschedparam() failed\n");

  852. 	}

  853. 

  854. #	ifdef USE_BARRIER

  855. 	sem_wait(&driver->sem_start);

  856. 

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

  858. 	{

  859. 		localsize = driver->indevbufsize;

  860. 		localbuf = malloc(localsize);

  861. 		if (localbuf == NULL)

  862. 		{

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

  864. 				__FILE__, __LINE__);

  865. 			return NULL;

  866. 		}

  867. 

  868. 		while (driver->run)

  869. 		{

  870. 			if (read(driver->infd, localbuf, localsize) <

  871. 				(ssize_t) localsize)

  872. 			{

  873. 				/*jack_error("OSS: read() failed: %s@%i", 

  874. 					__FILE__, __LINE__);*/

  875. 				break;

  876. 			}

  877. 

  878. 			pthread_mutex_lock(&driver->mutex_in);

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

  880. 			pthread_mutex_unlock(&driver->mutex_in);

  881. 

  882. 			synchronize(driver);

  883. 		}

  884. 

  885. 		free(localbuf);

  886. 	}

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

  888. 	{

  889. 		localsize = driver->outdevbufsize;

  890. 		localbuf = malloc(localsize);

  891. 		if (localbuf == NULL)

  892. 		{

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

  894. 				__FILE__, __LINE__);

  895. 			return NULL;

  896. 		}

  897. 

  898. 		while (driver->run)

  899. 		{

  900. 			pthread_mutex_lock(&driver->mutex_out);

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

  902. 			pthread_mutex_unlock(&driver->mutex_out);

  903. 

  904. 			if (write(driver->outfd, localbuf, localsize) < 

  905. 				(ssize_t) localsize)

  906. 			{

  907. 				/*jack_error("OSS: write() failed: %s@%i", 

  908. 					__FILE__, __LINE__);*/

  909. 				break;

  910. 			}

  911. 

  912. 			synchronize(driver);

  913. 		}

  914. 

  915. 		free(localbuf);

  916. 	}

  917. #	else

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

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

  920. 	localbuf = malloc(localsize);

  921. 	if (localbuf == NULL)

  922. 	{

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

  924. 		return NULL;

  925. 	}

  926. 

  927. 	while (driver->run)

  928. 	{

  929. 		if (driver->playback_channels > 0)

  930. 		{

  931. 			pthread_mutex_lock(&driver->mutex_out);

  932. 			memcpy(localbuf, driver->outdevbuf, 

  933. 				driver->outdevbufsize);

  934. 			pthread_mutex_unlock(&driver->mutex_out);

  935. 

  936. 			if (write(driver->outfd, localbuf, 

  937. 				driver->outdevbufsize) <

  938. 				(ssize_t) driver->outdevbufsize)

  939. 			{

  940. 				jack_error("OSS: write() failed: %s@%i",

  941. 					__FILE__, __LINE__);

  942. 				break;

  943. 			}

  944. 		}

  945. 

  946. 		if (driver->capture_channels > 0)

  947. 		{

  948. 			if (read(driver->infd, localbuf, 

  949. 				driver->indevbufsize) <

  950. 				(ssize_t) driver->indevbufsize)

  951. 			{

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

  953. 					__FILE__, __LINE__);

  954. 				break;

  955. 			}

  956. 

  957. 			pthread_mutex_lock(&driver->mutex_in);

  958. 			memcpy(driver->indevbuf, localbuf, 

  959. 				driver->indevbufsize);

  960. 			pthread_mutex_unlock(&driver->mutex_in);

  961. 		}

  962. 

  963. 		start_process_cycle(driver);

  964. 	}

  965. 

  966. 	free(localbuf);

  967. #	endif

  968. 

  969. 	return NULL;

  970. }

  971. 

  972. 

  973. /* jack driver published interface */

  974. 

  975. 

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

  977. 

  978. 

  979. void driver_finish (jack_driver_t *);

  980. 

  981. 

  982. jack_driver_desc_t * driver_get_descriptor ()

  983. {

  984. 	jack_driver_desc_t *desc;

  985. 	jack_driver_param_desc_t *params;

  986. 

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

  988. 	if (desc == NULL)

  989. 	{

  990. 		printf("oss_driver: malloc() failed: %s@%i\n", 

  991. 			__FILE__, __LINE__);

  992. 		return NULL;

  993. 	}

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

  995. 	desc->nparams = 8;

  996. 

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

  998. 	memcpy(params, oss_params, 

  999. 		OSS_DRIVER_N_PARAMS * sizeof(jack_driver_param_desc_t));

  1000. 	desc->params = params;

  1001. 

  1002. 	return desc;

  1003. }

  1004. 

  1005. 

  1006. jack_driver_t * driver_initialize (jack_client_t *client, 

  1007. 	JSList * params)

  1008. {

  1009. 	int bits = OSS_DRIVER_DEF_BITS;

  1010. 	jack_nframes_t sample_rate = OSS_DRIVER_DEF_FS;

  1011. 	jack_nframes_t period_size = OSS_DRIVER_DEF_BLKSIZE;

  1012. 	unsigned int capture_channels = OSS_DRIVER_DEF_INS;

  1013. 	unsigned int playback_channels = OSS_DRIVER_DEF_OUTS;

  1014. 	const JSList *pnode;

  1015. 	const jack_driver_param_t *param;

  1016. 	oss_driver_t *driver;

  1017. 

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

  1019. 	if (driver == NULL)

  1020. 	{

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

  1022. 		return NULL;

  1023. 	}

  1024. 	jack_driver_init((jack_driver_t *) driver);

  1025. 

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

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

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

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

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

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

  1032. 	driver->null_cycle = (JackDriverNullCycleFunction) 

  1033. 		oss_driver_null_cycle;

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

  1035. 

  1036. 	driver->indev = NULL;

  1037. 	driver->outdev = NULL;

  1038. 	driver->ignorehwbuf = 0;

  1039. 

  1040. 	pnode = params;

  1041. 	while (pnode != NULL)

  1042. 	{

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

  1044. 

  1045. 		switch (param->character)

  1046. 		{

  1047. 			case 's':

  1048. 				sample_rate = param->value.ui;

  1049. 				break;

  1050. 			case 'b':

  1051. 				period_size = param->value.ui;

  1052. 				break;

  1053. 			case 'w':

  1054. 				bits = param->value.i;

  1055. 				break;

  1056. 			case 'c':

  1057. 				capture_channels = param->value.ui;

  1058. 				break;

  1059. 			case 'p':

  1060. 				playback_channels = param->value.ui;

  1061. 				break;

  1062. 			case 'i':

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

  1064. 				break;

  1065. 			case 'o':

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

  1067. 				break;

  1068. 			case 'd':

  1069. 				driver->ignorehwbuf = 1;

  1070. 				break;

  1071. 			case 'h':

  1072. 				puts("-s <fs>\tsample rate");

  1073. 				puts("-b <size>\tperiod size");

  1074. 				puts("-w <bits>\tword length");

  1075. 				puts("-c <chs>\tcapture channels");

  1076. 				puts("-p <chs>\tplayback channels");

  1077. 				puts("-i <dev>\tcapture device");

  1078. 				puts("-o <dev>\tplayback device");

  1079. 				puts("-h\tthis help");

  1080. 				break;

  1081. 		}

  1082. 		pnode = jack_slist_next(pnode);

  1083. 	}

  1084. 	

  1085. 	driver->sample_rate = sample_rate;

  1086. 	driver->period_size = period_size;

  1087. 	driver->bits = bits;

  1088. 	driver->capture_channels = capture_channels;

  1089. 	driver->playback_channels = playback_channels;

  1090. 

  1091. 	driver->period_usecs = 

  1092. 		((double) period_size / (double) sample_rate) * 1e6;

  1093. 	driver->last_wait_ust = 0;

  1094. 	

  1095. 	driver->finish = driver_finish;

  1096. 

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

  1098. 		driver->indev = strdup("/dev/dsp");

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

  1100. 		driver->outdev = strdup(driver->indev);

  1101. 	driver->infd = -1;

  1102. 	driver->outfd = -1;

  1103. 	switch (driver->bits)

  1104. 	{

  1105. #		ifndef OSS_ENDIAN

  1106. #		ifdef __GNUC__

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

  1108. #		define OSS_LITTLE_ENDIAN 1234

  1109. #		define OSS_ENDIAN OSS_LITTLE_ENDIAN

  1110. #		else

  1111. #		define OSS_BIG_ENDIAN 4321

  1112. #		define OSS_ENDIAN OSS_BIG_ENDIAN

  1113. #		endif

  1114. #		else /* __GNUC__ */

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

  1116. #		define OSS_BIG_ENDIAN 4321

  1117. #		define OSS_ENDIAN OSS_BIG_ENDIAN

  1118. #		else

  1119. #		define OSS_LITTLE_ENDIAN 1234

  1120. #		define OSS_ENDIAN OSS_LITTLE_ENDIAN

  1121. #		endif

  1122. #		endif /* __GNUC__ */

  1123. #		endif /* OSS_ENDIAN */

  1124. #		if (OSS_ENDIAN == 1234)

  1125. 		/* little-endian architectures */

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

  1127. 			driver->format = 0x00008000;

  1128. 			break;

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

  1130. 			driver->format = 0x00001000;

  1131. 			break;

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

  1133. 			driver->format = 0x00004000;

  1134. 			break;

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

  1136. 		default:

  1137. 			driver->format = 0x00000010;

  1138. 			break;

  1139. 		/* big-endian architectures */

  1140. #		else

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

  1142. 			break;

  1143. 			driver->format = 0x00010000;

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

  1145. 			driver->format = 0x00002000;

  1146. 			break;

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

  1148. 			driver->format = 0x00004000;

  1149. 			break;

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

  1151. 		default:

  1152. 			driver->format = 0x00000020;

  1153. #		endif

  1154. 	}

  1155. 

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

  1157. 

  1158. 	driver->capture_ports = NULL;

  1159. 	driver->playback_ports = NULL;

  1160. 

  1161. 	driver->engine = NULL;

  1162. 	driver->client = client;

  1163. 

  1164. 	return ((jack_driver_t *) driver);

  1165. }

  1166. 

  1167. 

  1168. void driver_finish (jack_driver_t *driver)

  1169. {

  1170. 	free(((oss_driver_t *) driver)->indev);

  1171. 	free(((oss_driver_t *) driver)->outdev);

  1172. 	free(driver);

  1173. }