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

1197 lines
27KB
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. 

  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. #include <unistd.h>

  37. #include <pthread.h>

  38. #include <stdlib.h>

  39. #include <string.h>

  40. #include <stdio.h>

  41. #include <fcntl.h>

  42. #include <errno.h>

  43. #include <math.h>

  44. #include <float.h>

  45. #include <stdarg.h>

  46. #include <getopt.h>

  47. #include <semaphore.h>

  48. 

  49. #include <sys/types.h>

  50. #include <sys/stat.h>

  51. #include <sys/ioctl.h>

  52. #include <sys/soundcard.h>

  53. 

  54. #include <jack/types.h>

  55. #include <jack/internal.h>

  56. #include <jack/engine.h>

  57. #include <jack/thread.h>

  58. #include <sysdeps/time.h>

  59. 

  60. #include "oss_driver.h"

  61. 

  62. 

  63. #define OSS_DRIVER_N_PARAMS	9

  64. const static jack_driver_param_desc_t oss_params[OSS_DRIVER_N_PARAMS] = {

  65. 	{ "rate",

  66. 	  'r',

  67. 	  JackDriverParamUInt,

  68. 	  { .ui = OSS_DRIVER_DEF_FS },

  69. 	  "sample rate",

  70. 	  "sample rate"

  71. 	},

  72. 	{ "period",

  73. 	  'p',

  74. 	  JackDriverParamUInt,

  75. 	  { .ui = OSS_DRIVER_DEF_BLKSIZE },

  76. 	  "period size",

  77. 	  "period size"

  78. 	},

  79. 	{ "nperiods",

  80. 	  'n',

  81. 	  JackDriverParamUInt,

  82. 	  { .ui = OSS_DRIVER_DEF_NPERIODS },

  83. 	  "number of periods in buffer",

  84. 	  "number of periods in buffer"

  85. 	},

  86. 	{ "wordlength",

  87. 	  'w',

  88. 	  JackDriverParamInt,

  89. 	  { .i = OSS_DRIVER_DEF_BITS },

  90. 	  "word length",

  91. 	  "word length"

  92. 	},

  93. 	{ "inchannels",

  94. 	  'i',

  95. 	  JackDriverParamUInt,

  96. 	  { .ui = OSS_DRIVER_DEF_INS },

  97. 	  "capture channels",

  98. 	  "capture channels"

  99. 	},

  100. 	{ "outchannels",

  101. 	  'o',

  102. 	  JackDriverParamUInt,

  103. 	  { .ui = OSS_DRIVER_DEF_OUTS },

  104. 	  "playback channels",

  105. 	  "playback channels"

  106. 	},

  107. 	{ "capture",

  108. 	  'C',

  109. 	  JackDriverParamString,

  110. 	  { .str = OSS_DRIVER_DEF_DEV },

  111. 	  "input device",

  112. 	  "input device"

  113. 	},

  114. 	{ "playback",

  115. 	  'P',

  116. 	  JackDriverParamString,

  117. 	  { .str = OSS_DRIVER_DEF_DEV },

  118. 	  "output device",

  119. 	  "output device"

  120. 	},

  121. 	{ "ignorehwbuf",

  122. 	  'b',

  123. 	  JackDriverParamBool,

  124. 	  { },

  125. 	  "ignore hardware period size",

  126. 	  "ignore hardware period size"

  127. 	}

  128. };

  129. 

  130. 

  131. 

  132. /* internal functions */

  133. 

  134. 

  135. static void set_period_size (oss_driver_t *driver, 

  136. 	jack_nframes_t new_period_size)

  137. {

  138. 	driver->period_size = new_period_size;

  139. 

  140. 	driver->period_usecs = 

  141. 		((double) driver->period_size /

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

  143. 	driver->last_wait_ust = 0;

  144. 	driver->last_periodtime = jack_get_microseconds();

  145. 	driver->next_periodtime = 0;

  146. 	driver->iodelay = 0.0F;

  147. }

  148. 

  149. 

  150. static inline void update_times (oss_driver_t *driver)

  151. {

  152. 	driver->last_periodtime = jack_get_microseconds();

  153. 	if (driver->next_periodtime > 0)

  154. 	{

  155. 		driver->iodelay = (float)

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

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

  158. 	}

  159. 	else driver->iodelay = 0.0F;

  160. 	driver->next_periodtime = 

  161. 		driver->last_periodtime +

  162. 		driver->period_usecs;

  163. }

  164. 

  165. 

  166. static inline void driver_cycle (oss_driver_t *driver)

  167. {

  168. 	update_times(driver);

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

  170. 		driver->last_periodtime);

  171. 

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

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

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

  175. }

  176. 

  177. 

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

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

  180. {

  181. 	int srcidx;

  182. 	int dstidx;

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

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

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

  186. 	jack_sample_t scale;

  187. 

  188. 	srcidx = channel;

  189. 	switch (bits)

  190. 	{

  191. 		case 16:

  192. 			scale = 1.0f / 0x7fff;

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

  194. 			{

  195. 				dst[dstidx] = (jack_sample_t) 

  196. 					s16src[srcidx] * scale;

  197. 				srcidx += chcount;

  198. 			}

  199. 			break;

  200. 		case 24:

  201. 			scale = 1.0f / 0x7fffff;

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

  203. 			{

  204. 				dst[dstidx] = (jack_sample_t)

  205. 					s32src[srcidx] * scale;

  206. 				srcidx += chcount;

  207. 			}

  208. 			break;

  209. 		case 32:

  210. 			scale = 1.0f / 0x7fffffff;

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

  212. 			{

  213. 				dst[dstidx] = (jack_sample_t)

  214. 					s32src[srcidx] * scale;

  215. 				srcidx += chcount;

  216. 			}

  217. 			break;

  218. 		case 64:

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

  220. 			{

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

  222. 				srcidx += chcount;

  223. 			}

  224. 			break;

  225. 	}

  226. }

  227. 

  228. 

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

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

  231. {

  232. 	int srcidx;

  233. 	int dstidx;

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

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

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

  237. 	jack_sample_t scale;

  238. 

  239. 	dstidx = channel;

  240. 	switch (bits)

  241. 	{

  242. 		case 16:

  243. 			scale = 0x7fff;

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

  245. 			{

  246. 				s16dst[dstidx] = (signed short) 

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

  248. 				dstidx += chcount;

  249. 			}

  250. 			break;

  251. 		case 24:

  252. 			scale = 0x7fffff;

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

  254. 			{

  255. 				s32dst[dstidx] = (signed int)

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

  257. 				dstidx += chcount;

  258. 			}

  259. 			break;

  260. 		case 32:

  261. 			scale = 0x7fffffff;

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

  263. 			{

  264. 				s32dst[dstidx] = (signed int)

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

  266. 				dstidx += chcount;

  267. 			}

  268. 			break;

  269. 		case 64:

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

  271. 			{

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

  273. 				dstidx += chcount;

  274. 			}

  275. 			break;

  276. 	}

  277. }

  278. 

  279. 

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

  281. {

  282. 	int fragsize_2p;

  283. 	int fragments;

  284. 

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

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

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

  288. 	{

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

  290. 			__FILE__, __LINE__);

  291. 	}

  292. }

  293. 

  294. 

  295. static int get_fragment (int fd)

  296. {

  297. 	int fragsize;

  298. 

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

  300. 	{

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

  302. 			__FILE__, __LINE__);

  303. 		return 0;

  304. 	}

  305. 	return fragsize;

  306. }

  307. 

  308. 

  309. static void *io_thread (void *);

  310. 

  311. 

  312. /* jack driver interface */

  313. 

  314. 

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

  316. {

  317. 	int port_flags;

  318. 	unsigned int channel;

  319. 	char channel_name[64];

  320. 	jack_port_t *port;

  321. 

  322. 	driver->engine = engine;

  323. 

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

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

  326. 

  327. 	port_flags = JackPortIsOutput|JackPortIsPhysical|JackPortIsTerminal;

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

  329. 	{

  330. 		snprintf(channel_name, sizeof(channel_name), 

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

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

  333. 			JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);

  334. 		if (port == NULL)

  335. 		{

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

  337. 				channel_name, __FILE__, __LINE__);

  338. 			break;

  339. 		}

  340. 		driver->capture_ports = 

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

  342. 	}

  343. 

  344. 	port_flags = JackPortIsInput|JackPortIsPhysical|JackPortIsTerminal;

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

  346. 	{

  347. 		snprintf(channel_name, sizeof(channel_name),

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

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

  350. 			JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);

  351. 		if (port == NULL)

  352. 		{

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

  354. 				channel_name, __FILE__, __LINE__);

  355. 			break;

  356. 		}

  357. 		driver->playback_ports =

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

  359. 	}

  360. 

  361. 	jack_activate(driver->client);

  362. 

  363. 	return 0;

  364. }

  365. 

  366. 

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

  368. {

  369. 	JSList *node;

  370. 

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

  372. 		return -1;

  373. 

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

  375. 

  376. 	node = driver->capture_ports;

  377. 	while (node != NULL)

  378. 	{

  379. 		jack_port_unregister(driver->client, 

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

  381. 		node = jack_slist_next(node);

  382. 	}

  383. 	jack_slist_free(driver->capture_ports);

  384. 	driver->capture_ports = NULL;

  385. 

  386. 	node = driver->playback_ports;

  387. 	while (node != NULL)

  388. 	{

  389. 		jack_port_unregister(driver->client,

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

  391. 		node = jack_slist_next(node);

  392. 	}

  393. 	jack_slist_free(driver->playback_ports);

  394. 	driver->playback_ports = NULL;

  395. 

  396. 	driver->engine = NULL;

  397. 

  398. 	return 0;

  399. }

  400. 

  401. 

  402. static int oss_driver_start (oss_driver_t *driver)

  403. {

  404. 	int format;

  405. 	int channels;

  406. 	int samplerate;

  407. 	int infd = driver->infd;

  408. 	int outfd = driver->outfd;

  409. 	unsigned int period_size;

  410. 	size_t samplesize;

  411. 	size_t fragsize;

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

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

  414. 

  415. 	switch (driver->bits)

  416. 	{

  417. 		case 24:

  418. 		case 32:

  419. 			samplesize = sizeof(int);

  420. 			break;

  421. 		case 64:

  422. 			samplesize = sizeof(double);

  423. 			break;

  424. 		case 16:

  425. 		default:

  426. 			samplesize = sizeof(short);

  427. 			break;

  428. 	}

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

  430. 	{

  431. 		if (driver->capture_channels > 0)

  432. 		{

  433. 			infd = open(indev, O_RDONLY);

  434. 			if (infd < 0)

  435. 			{

  436. 				jack_error(

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

  438. 					indev, __FILE__, __LINE__);

  439. 			}

  440. 			fragsize = driver->period_size * 

  441. 				driver->capture_channels * samplesize;

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

  443. 		}

  444. 		else infd = -1;

  445. 

  446. 		if (driver->playback_channels > 0)

  447. 		{

  448. 			outfd = open(outdev, O_WRONLY);

  449. 			if (outfd < 0)

  450. 			{

  451. 				jack_error(

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

  453. 					outdev, __FILE__, __LINE__);

  454. 			}

  455. 			fragsize = driver->period_size * 

  456. 				driver->playback_channels * samplesize;

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

  458. 		}

  459. 		else outfd = -1;

  460. 	}

  461. 	else

  462. 	{

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

  464. 			driver->playback_channels == 0)

  465. 		{

  466. 			infd = open(indev, O_RDWR);

  467. 			outfd = -1;

  468. 			if (infd < 0)

  469. 			{

  470. 				jack_error(

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

  472. 					indev, __FILE__, __LINE__);

  473. 				return -1;

  474. 			}

  475. 		}

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

  477. 			driver->playback_channels != 0)

  478. 		{

  479. 			infd = -1;

  480. 			outfd = open(outdev, O_RDWR);

  481. 			if (outfd < 0)

  482. 			{

  483. 				jack_error(

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

  485. 					outdev, __FILE__, __LINE__);

  486. 				return -1;

  487. 			}

  488. 		}

  489. 		else

  490. 		{

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

  492. 			if (infd < 0)

  493. 			{

  494. 				jack_error(

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

  496. 					indev, __FILE__, __LINE__);

  497. 				return -1;

  498. 			}

  499. 		}

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

  501. 		{

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

  503. 			{

  504. 				jack_error(

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

  506. 					indev, __FILE__, __LINE__);

  507. 			}

  508. 		}

  509. 		if (infd >= 0)

  510. 		{

  511. 			fragsize = driver->period_size * 

  512. 				driver->capture_channels * samplesize;

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

  514. 		}

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

  516. 		{

  517. 			fragsize = driver->period_size * 

  518. 				driver->playback_channels * samplesize;

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

  520. 		}

  521. 	}

  522. 	driver->infd = infd;

  523. 	driver->outfd = outfd;

  524. 	

  525. 	if (infd >= 0)

  526. 	{

  527. 		format = driver->format;

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

  529. 			jack_error(

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

  531. 				indev, __FILE__, __LINE__);

  532. 		channels = driver->capture_channels;

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

  534. 			jack_error(

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

  536. 				indev, __FILE__, __LINE__);

  537. 		samplerate = driver->sample_rate;

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

  539. 			jack_error(

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

  541. 				indev, __FILE__, __LINE__);

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

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

  544. 		

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

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

  547. 			!driver->ignorehwbuf)

  548. 		{

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

  550. 				period_size);

  551. 			driver->period_size = period_size;

  552. 			driver->period_usecs = 

  553. 				((double) driver->period_size / 

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

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

  556. 				driver->period_size);

  557. 		}

  558. 	}

  559. 

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

  561. 	{

  562. 		format = driver->format;

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

  564. 			jack_error(

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

  566. 				outdev, __FILE__, __LINE__);

  567. 		channels = driver->playback_channels;

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

  569. 			jack_error(

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

  571. 				outdev, __FILE__, __LINE__);

  572. 		samplerate = driver->sample_rate;

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

  574. 			jack_error(

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

  576. 				outdev, __FILE__, __LINE__);

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

  578. 			format, channels, samplerate, 

  579. 			get_fragment(outfd));

  580. 

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

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

  583. 			!driver->ignorehwbuf)

  584. 		{

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

  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. 			driver->engine->set_buffer_size(driver->engine, 

  592. 				driver->period_size);

  593. 		}

  594. 	}

  595. 

  596. 	if (driver->capture_channels > 0)

  597. 	{

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

  599. 			driver->capture_channels * samplesize;

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

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

  602. 		{

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

  604. 				__FILE__, __LINE__);

  605. 			return -1;

  606. 		}

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

  608. 	}

  609. 	else

  610. 	{

  611. 		driver->indevbufsize = 0;

  612. 		driver->indevbuf = NULL;

  613. 	}

  614. 

  615. 	if (driver->playback_channels > 0)

  616. 	{

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

  618. 			driver->playback_channels * samplesize;

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

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

  621. 		{

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

  623. 				__FILE__, __LINE__);

  624. 			return -1;

  625. 		}

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

  627. 	}

  628. 	else

  629. 	{

  630. 		driver->outdevbufsize = 0;

  631. 		driver->outdevbuf = NULL;

  632. 	}

  633. 

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

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

  636. 

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

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

  639. #	ifdef USE_BARRIER

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

  641. #	endif

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

  643. 	driver->run = 1;

  644. 	driver->threads = 0;

  645. 	if (infd >= 0)

  646. 	{

  647. 		if (jack_create_thread(&driver->thread_in, 

  648. 			driver->engine->rtpriority, 

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

  650. 			io_thread, driver) < 0)

  651. 		{

  652. 			jack_error("OSS: jack_create_thread() failed: %s@%i",

  653. 				__FILE__, __LINE__);

  654. 			return -1;

  655. 		}

  656. 		driver->threads |= 1;

  657. 	}

  658. #	ifdef USE_BARRIER

  659. 	if (outfd >= 0)

  660. 	{

  661. 		if (jack_create_thread(&driver->thread_out, 

  662. 			driver->engine->rtpriority, 

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

  664. 			io_thread, driver) < 0)

  665. 		{

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

  667. 				__FILE__, __LINE__);

  668. 			return -1;

  669. 		}

  670. 		driver->threads |= 2;

  671. 	}

  672. #	endif

  673. 

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

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

  676. 

  677. 	driver->last_periodtime = jack_get_microseconds();

  678. 	driver->next_periodtime = 0;

  679. 	driver->iodelay = 0.0F;

  680. 

  681. 	return 0;

  682. }

  683. 

  684. 

  685. static int oss_driver_stop (oss_driver_t *driver)

  686. {

  687. 	void *retval;

  688. 

  689. 	driver->run = 0;

  690. 	if (driver->threads & 1)

  691. 	{

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

  693. 		{

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

  695. 				__FILE__, __LINE__);

  696. 			return -1;

  697. 		}

  698. 	}

  699. 	if (driver->threads & 2)

  700. 	{

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

  702. 		{

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

  704. 				__FILE__, __LINE__);

  705. 			return -1;

  706. 		}

  707. 	}

  708. 	sem_destroy(&driver->sem_start);

  709. #	ifdef USE_BARRIER

  710. 	pthread_barrier_destroy(&driver->barrier);

  711. #	endif

  712. 	pthread_mutex_destroy(&driver->mutex_in);

  713. 	pthread_mutex_destroy(&driver->mutex_out);

  714. 

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

  716. 	{

  717. 		close(driver->outfd);

  718. 		driver->outfd = -1;

  719. 	}

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

  721. 	{

  722. 		close(driver->infd);

  723. 		driver->infd = -1;

  724. 	}

  725. 

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

  727. 	{

  728. 		free(driver->indevbuf);

  729. 		driver->indevbuf = NULL;

  730. 	}

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

  732. 	{

  733. 		free(driver->outdevbuf);

  734. 		driver->outdevbuf = NULL;

  735. 	}

  736. 

  737. 	return 0;

  738. }

  739. 

  740. 

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

  742. {

  743. 	int channel;

  744. 	jack_sample_t *portbuf;

  745. 	JSList *node;

  746. 	jack_port_t *port;

  747. 

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

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

  750. 	{

  751. 		jack_error(

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

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

  754. 		return -1;

  755. 	}

  756. 

  757. 	pthread_mutex_lock(&driver->mutex_in);

  758. 

  759. 	node = driver->capture_ports;

  760. 	channel = 0;

  761. 	while (node != NULL)

  762. 	{

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

  764. 

  765. 		if (jack_port_connected(port))

  766. 		{

  767. 			portbuf = jack_port_get_buffer(port, nframes);

  768. 			copy_and_convert_in(portbuf, driver->indevbuf, 

  769. 				nframes, channel, 

  770. 				driver->capture_channels,

  771. 				driver->bits);

  772. 		}

  773. 

  774. 		node = jack_slist_next(node);

  775. 		channel++;

  776. 	}

  777. 

  778. 	pthread_mutex_unlock(&driver->mutex_in);

  779. 

  780. 	return 0;

  781. }

  782. 

  783. 

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

  785. {

  786. 	int channel;

  787. 	jack_sample_t *portbuf;

  788. 	JSList *node;

  789. 	jack_port_t *port;

  790. 

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

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

  793. 	{

  794. 		jack_error(

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

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

  797. 		return -1;

  798. 	}

  799. 

  800. 	pthread_mutex_lock(&driver->mutex_out);

  801. 

  802. 	node = driver->playback_ports;

  803. 	channel = 0;

  804. 	while (node != NULL)

  805. 	{

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

  807. 

  808. 		if (jack_port_connected(port))

  809. 		{

  810. 			portbuf = jack_port_get_buffer(port, nframes);

  811. 			copy_and_convert_out(driver->outdevbuf, portbuf, 

  812. 				nframes, channel,

  813. 				driver->playback_channels,

  814. 				driver->bits);

  815. 		}

  816. 

  817. 		node = jack_slist_next(node);

  818. 		channel++;

  819. 	}

  820. 

  821. 	pthread_mutex_unlock(&driver->mutex_out);

  822. 

  823. 	return 0;

  824. }

  825. 

  826. 

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

  828. {

  829. 	pthread_mutex_lock(&driver->mutex_in);

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

  831. 	pthread_mutex_unlock(&driver->mutex_in);

  832. 

  833. 	pthread_mutex_lock(&driver->mutex_out);

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

  835. 	pthread_mutex_unlock(&driver->mutex_out);

  836. 

  837. 	return 0;

  838. }

  839. 

  840. 

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

  842. {

  843. 	oss_driver_stop(driver);

  844. 

  845. 	set_period_size(driver, nframes);

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

  847. 	printf("oss_driver: period size update: %u\n", nframes);

  848. 

  849. 	oss_driver_start(driver);

  850. 

  851. 	return 0;

  852. }

  853. 

  854. 

  855. /* internal driver thread */

  856. 

  857. 

  858. #ifdef USE_BARRIER

  859. static inline void synchronize (oss_driver_t *driver)

  860. {

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

  862. 	{

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

  864. 			PTHREAD_BARRIER_SERIAL_THREAD)

  865. 		{

  866. 			driver_cycle(driver);

  867. 		}

  868. 	}

  869. 	else

  870. 	{

  871. 		driver_cycle(driver);

  872. 	}

  873. }

  874. #endif

  875. 

  876. 

  877. static void *io_thread (void *param)

  878. {

  879. 	size_t localsize;

  880. 	void *localbuf;

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

  882. 

  883. 	sem_wait(&driver->sem_start);

  884. 

  885. #	ifdef USE_BARRIER

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

  887. 	{

  888. 		localsize = driver->indevbufsize;

  889. 		localbuf = malloc(localsize);

  890. 		if (localbuf == NULL)

  891. 		{

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

  893. 				__FILE__, __LINE__);

  894. 			return NULL;

  895. 		}

  896. 

  897. 		while (driver->run)

  898. 		{

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

  900. 				(ssize_t) localsize)

  901. 			{

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

  903. 					__FILE__, __LINE__);

  904. 				break;

  905. 			}

  906. 

  907. 			pthread_mutex_lock(&driver->mutex_in);

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

  909. 			pthread_mutex_unlock(&driver->mutex_in);

  910. 

  911. 			synchronize(driver);

  912. 		}

  913. 

  914. 		free(localbuf);

  915. 	}

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

  917. 	{

  918. 		localsize = driver->outdevbufsize;

  919. 		localbuf = malloc(localsize);

  920. 		if (localbuf == NULL)

  921. 		{

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

  923. 				__FILE__, __LINE__);

  924. 			return NULL;

  925. 		}

  926. 

  927. 		while (driver->run)

  928. 		{

  929. 			pthread_mutex_lock(&driver->mutex_out);

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

  931. 			pthread_mutex_unlock(&driver->mutex_out);

  932. 

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

  934. 				(ssize_t) localsize)

  935. 			{

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

  937. 					__FILE__, __LINE__);

  938. 				break;

  939. 			}

  940. 

  941. 			synchronize(driver);

  942. 		}

  943. 

  944. 		free(localbuf);

  945. 	}

  946. #	else

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

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

  949. 	localbuf = malloc(localsize);

  950. 	if (localbuf == NULL)

  951. 	{

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

  953. 		return NULL;

  954. 	}

  955. 

  956. 	while (driver->run)

  957. 	{

  958. 		if (driver->playback_channels > 0)

  959. 		{

  960. 			pthread_mutex_lock(&driver->mutex_out);

  961. 			memcpy(localbuf, driver->outdevbuf, 

  962. 				driver->outdevbufsize);

  963. 			pthread_mutex_unlock(&driver->mutex_out);

  964. 

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

  966. 				driver->outdevbufsize) <

  967. 				(ssize_t) driver->outdevbufsize)

  968. 			{

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

  970. 					__FILE__, __LINE__);

  971. 				break;

  972. 			}

  973. 		}

  974. 

  975. 		if (driver->capture_channels > 0)

  976. 		{

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

  978. 				driver->indevbufsize) <

  979. 				(ssize_t) driver->indevbufsize)

  980. 			{

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

  982. 					__FILE__, __LINE__);

  983. 				break;

  984. 			}

  985. 

  986. 			pthread_mutex_lock(&driver->mutex_in);

  987. 			memcpy(driver->indevbuf, localbuf, 

  988. 				driver->indevbufsize);

  989. 			pthread_mutex_unlock(&driver->mutex_in);

  990. 		}

  991. 

  992. 		driver_cycle(driver);

  993. 	}

  994. 

  995. 	free(localbuf);

  996. #	endif

  997. 

  998. 	return NULL;

  999. }

  1000. 

  1001. 

  1002. /* jack driver published interface */

  1003. 

  1004. 

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

  1006. 

  1007. 

  1008. void driver_finish (jack_driver_t *);

  1009. 

  1010. 

  1011. jack_driver_desc_t * driver_get_descriptor ()

  1012. {

  1013. 	jack_driver_desc_t *desc;

  1014. 	jack_driver_param_desc_t *params;

  1015. 

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

  1017. 	if (desc == NULL)

  1018. 	{

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

  1020. 			__FILE__, __LINE__);

  1021. 		return NULL;

  1022. 	}

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

  1024. 	desc->nparams = OSS_DRIVER_N_PARAMS;

  1025. 

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

  1027. 	memcpy(params, oss_params, 

  1028. 		OSS_DRIVER_N_PARAMS * sizeof(jack_driver_param_desc_t));

  1029. 	desc->params = params;

  1030. 

  1031. 	return desc;

  1032. }

  1033. 

  1034. 

  1035. jack_driver_t * driver_initialize (jack_client_t *client, 

  1036. 	JSList * params)

  1037. {

  1038. 	int bits = OSS_DRIVER_DEF_BITS;

  1039. 	jack_nframes_t sample_rate = OSS_DRIVER_DEF_FS;

  1040. 	jack_nframes_t period_size = OSS_DRIVER_DEF_BLKSIZE;

  1041. 	unsigned int nperiods = OSS_DRIVER_DEF_NPERIODS;

  1042. 	unsigned int capture_channels = OSS_DRIVER_DEF_INS;

  1043. 	unsigned int playback_channels = OSS_DRIVER_DEF_OUTS;

  1044. 	const JSList *pnode;

  1045. 	const jack_driver_param_t *param;

  1046. 	oss_driver_t *driver;

  1047. 

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

  1049. 	if (driver == NULL)

  1050. 	{

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

  1052. 		return NULL;

  1053. 	}

  1054. 	jack_driver_init((jack_driver_t *) driver);

  1055. 

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

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

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

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

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

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

  1062. 	driver->null_cycle = (JackDriverNullCycleFunction) 

  1063. 		oss_driver_null_cycle;

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

  1065. 

  1066. 	driver->indev = NULL;

  1067. 	driver->outdev = NULL;

  1068. 	driver->ignorehwbuf = 0;

  1069. 

  1070. 	pnode = params;

  1071. 	while (pnode != NULL)

  1072. 	{

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

  1074. 

  1075. 		switch (param->character)

  1076. 		{

  1077. 			case 'r':

  1078. 				sample_rate = param->value.ui;

  1079. 				break;

  1080. 			case 'p':

  1081. 				period_size = param->value.ui;

  1082. 				break;

  1083. 			case 'n':

  1084. 				nperiods = param->value.ui;

  1085. 				break;

  1086. 			case 'w':

  1087. 				bits = param->value.i;

  1088. 				break;

  1089. 			case 'i':

  1090. 				capture_channels = param->value.ui;

  1091. 				break;

  1092. 			case 'o':

  1093. 				playback_channels = param->value.ui;

  1094. 				break;

  1095. 			case 'C':

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

  1097. 				break;

  1098. 			case 'P':

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

  1100. 				break;

  1101. 			case 'b':

  1102. 				driver->ignorehwbuf = 1;

  1103. 				break;

  1104. 		}

  1105. 		pnode = jack_slist_next(pnode);

  1106. 	}

  1107. 	

  1108. 	driver->sample_rate = sample_rate;

  1109. 	driver->period_size = period_size;

  1110. 	driver->nperiods = nperiods;

  1111. 	driver->bits = bits;

  1112. 	driver->capture_channels = capture_channels;

  1113. 	driver->playback_channels = playback_channels;

  1114. 

  1115. 	set_period_size(driver, period_size);

  1116. 	

  1117. 	driver->finish = driver_finish;

  1118. 

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

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

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

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

  1123. 	driver->infd = -1;

  1124. 	driver->outfd = -1;

  1125. 	switch (driver->bits)

  1126. 	{

  1127. #		ifndef OSS_ENDIAN

  1128. #		ifdef __GNUC__

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

  1130. #		define OSS_LITTLE_ENDIAN 1234

  1131. #		define OSS_ENDIAN OSS_LITTLE_ENDIAN

  1132. #		else

  1133. #		define OSS_BIG_ENDIAN 4321

  1134. #		define OSS_ENDIAN OSS_BIG_ENDIAN

  1135. #		endif

  1136. #		else /* __GNUC__ */

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

  1138. #		define OSS_BIG_ENDIAN 4321

  1139. #		define OSS_ENDIAN OSS_BIG_ENDIAN

  1140. #		else

  1141. #		define OSS_LITTLE_ENDIAN 1234

  1142. #		define OSS_ENDIAN OSS_LITTLE_ENDIAN

  1143. #		endif

  1144. #		endif /* __GNUC__ */

  1145. #		endif /* OSS_ENDIAN */

  1146. #		if (OSS_ENDIAN == 1234)

  1147. 		/* little-endian architectures */

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

  1149. 			driver->format = 0x00008000;

  1150. 			break;

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

  1152. 			driver->format = 0x00001000;

  1153. 			break;

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

  1155. 			driver->format = 0x00004000;

  1156. 			break;

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

  1158. 		default:

  1159. 			driver->format = 0x00000010;

  1160. 			break;

  1161. 		/* big-endian architectures */

  1162. #		else

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

  1164. 			break;

  1165. 			driver->format = 0x00010000;

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

  1167. 			driver->format = 0x00002000;

  1168. 			break;

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

  1170. 			driver->format = 0x00004000;

  1171. 			break;

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

  1173. 		default:

  1174. 			driver->format = 0x00000020;

  1175. #		endif

  1176. 	}

  1177. 

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

  1179. 

  1180. 	driver->capture_ports = NULL;

  1181. 	driver->playback_ports = NULL;

  1182. 

  1183. 	driver->engine = NULL;

  1184. 	driver->client = client;

  1185. 

  1186. 	return ((jack_driver_t *) driver);

  1187. }

  1188. 

  1189. 

  1190. void driver_finish (jack_driver_t *driver)

  1191. {

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

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

  1194. 	free(driver);

  1195. }