non
/
spiralsynthmodular
mirror of https://github.com/original-male/spiralsynthmodular
1
0
Fork 0
Code Releases 0 Activity
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.
290 Commits
1 Branch
1.8MB
Tree: 6391be6c9f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6391be6c9f'
${ noResults }
spiralsynthmodular/SpiralSound/Plugins/OutputPlugin/OutputPlugin.C

586 lines
13KB
Raw Blame History 

  1. /*  SpiralSound

  2.  *  Copyleft (C) 2001 David Griffiths <dave@pawfal.org>

  3.  *

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

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

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

  7.  *  (at your option) any later version.

  8.  *

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

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

  11.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  12.  *  GNU General Public License for more details.

  13.  *

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

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

  16.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

  17. */ 

  18. 

  19. // for lrintf()

  20. #define	_ISOC9X_SOURCE	1

  21. #define _ISOC99_SOURCE	1

  22. #include  <math.h>

  23. 

  24. #include <sys/types.h>

  25. #include <stdio.h>

  26. #include <fcntl.h>

  27. #include <unistd.h>

  28. #include <limits.h>

  29. #if defined (__FreeBSD__)

  30. 	#include <machine/soundcard.h>

  31. #else

  32. #if defined (__NetBSD__) || defined (__OpenBSD__)

  33. 	#include <soundcard.h>            /* OSS emulation */

  34. #undef ioctl

  35. #else 	                              /* BSDI, Linux, Solaris */

  36. 	#include <sys/soundcard.h>

  37. #endif                                /* __NetBSD__ or __OpenBSD__ */

  38. #endif                                /* __FreeBSD__ */

  39. #include <sys/ioctl.h>

  40. #include <limits.h>

  41. 

  42. #include "OutputPlugin.h"

  43. #include "OutputPluginGUI.h"

  44. #include <FL/fl_file_chooser.H>

  45. #include "SpiralIcon.xpm"

  46. 

  47. using namespace std;

  48. 

  49. static const int IN_FREQ  = 0;

  50. static const int IN_PW    = 1;

  51. static const int IN_SHLEN = 2;

  52. 

  53. static const int OUT_MAIN = 0;

  54. 

  55. static const HostInfo* host;

  56. OSSClient* OSSClient::m_Singleton = NULL;

  57. int OutputPlugin::m_RefCount=0;

  58. int OutputPlugin::m_NoExecuted=0;

  59. OutputPlugin::Mode OutputPlugin::m_Mode=NO_MODE;

  60. 

  61. #define CHECK_AND_REPORT_ERROR	if (result<0)         \

  62. 								{                     \

  63. 									perror("Sound device did not accept settings"); \

  64. 									m_OutputOk=false; \

  65. 									return false;     \

  66. 								}

  67. 

  68. extern "C"

  69. {

  70. SpiralPlugin* SpiralPlugin_CreateInstance()

  71. {

  72. 	return new OutputPlugin;

  73. }

  74. 

  75. char** SpiralPlugin_GetIcon()

  76. {	

  77. 	return SpiralIcon_xpm;

  78. }

  79. 

  80. int SpiralPlugin_GetID()

  81. {

  82. 	return 0x0000;

  83. }

  84. 

  85. string SpiralPlugin_GetGroupName()

  86. {

  87. 	return "InputOutput";

  88. }

  89. }

  90. 

  91. ///////////////////////////////////////////////////////

  92. 

  93. OutputPlugin::OutputPlugin() :

  94. m_Volume(1.0f)

  95. {

  96. 	m_RefCount++;

  97. 	// we are an output.

  98. 	m_IsTerminal=true;

  99.         m_NotifyOpenOut=false;

  100. 	m_PluginInfo.Name="OSS";

  101. 	m_PluginInfo.Width=100;

  102. 	m_PluginInfo.Height=100;

  103. 	m_PluginInfo.NumInputs=2;

  104. 	m_PluginInfo.NumOutputs=2;

  105. 	m_PluginInfo.PortTips.push_back("Left Out");

  106. 	m_PluginInfo.PortTips.push_back("Right Out");

  107. 	//m_PluginInfo.PortTips.push_back("Record Controller");

  108. 	m_PluginInfo.PortTips.push_back("Left In");

  109. 	m_PluginInfo.PortTips.push_back("Right In");

  110. 	m_AudioCH->Register ("Volume", &m_Volume);

  111.         m_AudioCH->Register ("OpenOut", &m_NotifyOpenOut, ChannelHandler::OUTPUT);

  112. }

  113. 

  114. OutputPlugin::~OutputPlugin()

  115. {

  116. 	m_RefCount--;

  117. 	if (m_RefCount==0)

  118. 	{

  119. 		cb_Blocking(m_Parent,false);

  120. 		OSSClient::PackUpAndGoHome();

  121. 		m_Mode=NO_MODE;

  122. 	}

  123. }

  124. 

  125. PluginInfo &OutputPlugin::Initialise(const HostInfo *Host)

  126. {

  127. 	PluginInfo& Info= SpiralPlugin::Initialise(Host);

  128. 	host=Host;

  129. 	OSSClient::Get()->AllocateBuffer();

  130. 

  131. 	return Info;

  132. }

  133. 

  134. SpiralGUIType *OutputPlugin::CreateGUI()

  135. {

  136. 	return new OutputPluginGUI(m_PluginInfo.Width, m_PluginInfo.Height, this, m_AudioCH, m_HostInfo);

  137. }

  138. 

  139. 

  140. bool OutputPlugin::Kill()

  141. {

  142. 	m_IsDead=true;

  143. 	OSSClient::Get()->Kill();

  144. 	m_Mode=CLOSED;

  145. 	cb_Blocking(m_Parent,false);

  146. 	return true;

  147. }

  148. 

  149. void OutputPlugin::Reset()

  150. {

  151. 	if (m_IsDead) return;

  152. 	m_IsDead=true;

  153. 	OSSClient::Get()->Kill();

  154. 	cb_Blocking(m_Parent,false);

  155. 	ResetPorts();

  156. 	OSSClient::Get()->AllocateBuffer();

  157. 	

  158. 	switch (m_Mode)

  159. 	{

  160. 		case INPUT :

  161. 			OSSClient::Get()->OpenRead();

  162. 			cb_Blocking(m_Parent,true);

  163. 		break;

  164. 		case OUTPUT :

  165. 			OSSClient::Get()->OpenWrite();

  166. 			cb_Blocking(m_Parent,true);

  167. 		break;

  168. 		case DUPLEX :

  169. 			OSSClient::Get()->OpenReadWrite();

  170. 			cb_Blocking(m_Parent,true);

  171. 		break;

  172. 		

  173. 		default:{}

  174. 	}

  175. 	

  176. 	m_IsDead=false;

  177. }

  178. 

  179. void OutputPlugin::Execute()

  180. {

  181. 	if (m_IsDead) 

  182. 		return;

  183. 	

  184.         if (m_Mode==NO_MODE && m_RefCount==1)

  185. 	{

  186. 		if (OSSClient::Get()->OpenWrite())

  187. 		{

  188. 			cb_Blocking(m_Parent,true);

  189. 			m_Mode=OUTPUT;

  190.                         m_NotifyOpenOut=true;

  191. 		}

  192. 	}

  193. 

  194. 	if (m_Mode==OUTPUT || m_Mode==DUPLEX)

  195. 	{

  196. 		OSSClient::Get()->SendStereo(GetInput(0),GetInput(1));

  197. 	}

  198. 

  199. 	if (m_Mode==INPUT || m_Mode==DUPLEX)

  200.            OSSClient::Get()->GetStereo(GetOutputBuf(0),GetOutputBuf(1));

  201. }

  202. 

  203. void OutputPlugin::ExecuteCommands()

  204. {

  205. 	if (m_IsDead) 

  206. 		return;

  207. 

  208. 	if (m_AudioCH->IsCommandWaiting())

  209. 	{

  210. 		switch(m_AudioCH->GetCommand())

  211. 		{

  212. 			case OPENREAD :

  213. 				if (OSSClient::Get()->OpenRead())

  214. 				{

  215. 					m_Mode=INPUT;

  216. 					//cb_Blocking(m_Parent,true);

  217. 				}

  218. 			break;

  219. 			case OPENWRITE :

  220. 				if (OSSClient::Get()->OpenWrite())

  221. 				{

  222. 					m_Mode=OUTPUT;

  223. 					cb_Blocking(m_Parent,true);

  224. 				}

  225. 			break;

  226. 			case OPENDUPLEX :

  227. 				if (OSSClient::Get()->OpenReadWrite())

  228. 				{

  229. 					m_Mode=DUPLEX;

  230. 					cb_Blocking(m_Parent,true);

  231. 				}

  232. 			break;

  233. 			case CLOSE :

  234. 				m_Mode=CLOSED;

  235. 				cb_Blocking(m_Parent,false);

  236. 				OSSClient::Get()->Close();

  237. 			break;

  238. 			case SET_VOLUME :

  239.                                 OSSClient::Get()->SetVolume(m_Volume);

  240.                                 break;

  241.                         case CLEAR_NOTIFY:

  242.                                 m_NotifyOpenOut=false;

  243.                                 break;

  244.                         default: break;

  245. 		}

  246.         }

  247. }

  248. 

  249. void OutputPlugin::ProcessAudio()

  250. {

  251. 	if (m_IsDead) 

  252. 		return;

  253. 

  254. 	// Only Play() once per set of plugins

  255. 	m_NoExecuted--;

  256. 	if (m_NoExecuted<=0)

  257. 	{

  258. 		if (m_Mode==INPUT || m_Mode==DUPLEX) OSSClient::Get()->Read();

  259. 		if (m_Mode==OUTPUT || m_Mode==DUPLEX) OSSClient::Get()->Play();

  260. 		m_NoExecuted=m_RefCount;

  261. 	}

  262. }

  263. 

  264. //////////////////////////////////////////////////////////////////////

  265. //////////////////////////////////////////////////////////////////////

  266. 

  267. OSSClient::OSSClient() :

  268. m_Amp(0.5),

  269. m_Channels(2),

  270. m_ReadBufferNum(0),

  271. m_WriteBufferNum(0),

  272. m_OutputOk(false),

  273. m_IsDead(false)

  274. 

  275. {

  276. 	m_Buffer[0]=NULL;

  277. 	m_Buffer[1]=NULL;

  278. 	m_InBuffer[0]=NULL;

  279. 	m_InBuffer[1]=NULL;

  280. }

  281. 

  282. //////////////////////////////////////////////////////////////////////

  283. 

  284. OSSClient::~OSSClient()

  285. {

  286. 	Close();

  287. 	DeallocateBuffer();

  288. }

  289. 

  290. //////////////////////////////////////////////////////////////////////

  291. 

  292. void OSSClient::AllocateBuffer()

  293. {

  294. 	if (m_Buffer[0]==NULL)

  295. 	{

  296. 		m_BufSizeBytes=host->BUFSIZE*m_Channels*2;

  297. 		

  298. 		// initialise for stereo

  299. 		m_Buffer[0] = (short*) calloc(m_BufSizeBytes/2,m_BufSizeBytes);

  300. 		m_Buffer[1] = (short*) calloc(m_BufSizeBytes/2,m_BufSizeBytes);

  301. 		m_InBuffer[0] = (short*) calloc(m_BufSizeBytes/2,m_BufSizeBytes);

  302. 		m_InBuffer[1] = (short*) calloc(m_BufSizeBytes/2,m_BufSizeBytes);

  303. 	}

  304. }

  305. 

  306. void OSSClient::DeallocateBuffer()

  307. {

  308. 	if (m_Buffer[0]!=NULL)

  309. 	{

  310. 		m_BufSizeBytes=0;

  311. 		

  312. 		// initialise for stereo

  313. 		free(m_Buffer[0]);

  314. 		free(m_Buffer[1]);

  315. 		free(m_InBuffer[0]);

  316. 		free(m_InBuffer[1]);

  317. 	}

  318. }

  319. 

  320. //////////////////////////////////////////////////////////////////////

  321. 

  322. void OSSClient::SendStereo(const Sample *ldata,const Sample *rdata) 

  323. {

  324. 	if (m_Channels!=2) return;

  325. 	

  326. 	int on=0;

  327. 	float t;

  328. 	for (int n=0; n<host->BUFSIZE; n++)

  329. 	{

  330. 		if (m_IsDead) return;

  331. 

  332. 		// stereo channels - interleave	

  333. 		if (ldata) 

  334. 		{

  335. 			t=(*ldata)[n]*m_Amp;

  336. 			if (t>1) t=1;

  337. 			if (t<-1) t=-1;

  338. 			m_Buffer[m_WriteBufferNum][on]+=lrintf(t*SHRT_MAX);

  339. 		}

  340. 		on++;

  341. 		

  342. 		if (rdata) 

  343. 		{

  344. 			t=(*rdata)[n]*m_Amp;

  345. 			if (t>1) t=1;

  346. 			if (t<-1) t=-1;

  347. 			m_Buffer[m_WriteBufferNum][on]+=lrintf(t*SHRT_MAX);

  348. 		}		

  349. 		on++;

  350. 	}

  351. }

  352. 

  353. //////////////////////////////////////////////////////////////////////

  354. 

  355. void OSSClient::Play()

  356. {

  357.     int BufferToSend=!m_WriteBufferNum;

  358. 	

  359.     #if __BYTE_ORDER == BIG_ENDIAN

  360.     for (int n=0; n<host->BUFSIZE*m_Channels; n++)

  361.     {		

  362. 		m_Buffer[BufferToSend][n]=(short)((m_Buffer[BufferToSend][n]<<8)&0xff00)|

  363. 		                                 ((m_Buffer[BufferToSend][n]>>8)&0xff);

  364.     }

  365.     #endif	

  366. 	if (m_OutputOk)

  367. 	{

  368. 		write(m_Dspfd,m_Buffer[BufferToSend],m_BufSizeBytes);

  369. 	}

  370. 		

  371. 	memset(m_Buffer[BufferToSend],0,m_BufSizeBytes);

  372. 	m_WriteBufferNum=BufferToSend;

  373. }

  374. 

  375. //////////////////////////////////////////////////////////////////////

  376. 

  377. void OSSClient::GetStereo(Sample *ldata,Sample *rdata) 

  378. {

  379. 	if (m_Channels!=2) return;

  380. 	

  381. 	int on=0;

  382. 	for (int n=0; n<host->BUFSIZE; n++)

  383. 	{

  384. 		if (m_IsDead) return;

  385. 

  386. 		// stereo channels - interleave	

  387. 		if (ldata) ldata->Set(n,(m_InBuffer[m_ReadBufferNum][on]*m_Amp)/(float)SHRT_MAX);

  388. 		on++;

  389. 		if (rdata) rdata->Set(n,(m_InBuffer[m_ReadBufferNum][on]*m_Amp)/(float)SHRT_MAX);

  390. 		on++;

  391. 	}

  392. }

  393. 

  394. //////////////////////////////////////////////////////////////////////

  395. 

  396. void OSSClient::Read()

  397. {

  398.     int BufferToRead=!m_ReadBufferNum;

  399. 

  400. 	if (m_OutputOk)

  401. 		read(m_Dspfd,m_InBuffer[BufferToRead],m_BufSizeBytes);

  402. 	

  403.     #if __BYTE_ORDER == BIG_ENDIAN

  404.     for (int n=0; n<host->BUFSIZE*m_Channels; n++)

  405.     {		

  406. 		m_InBuffer[BufferToRead][n]=(short)((m_InBuffer[BufferToRead][n]<<8)&0xff00)|

  407. 		                                   ((m_InBuffer[BufferToRead][n]>>8)&0xff);

  408.     }

  409.     #endif	

  410.     

  411. 	m_ReadBufferNum=BufferToRead;

  412. }

  413. 

  414. //////////////////////////////////////////////////////////////////////

  415. 

  416. bool OSSClient::Close()

  417. { 	

  418. 	cerr<<"Closing dsp output"<<endl;

  419. 	close(m_Dspfd);

  420. 	

  421. 	return true;

  422. }

  423. 

  424. //////////////////////////////////////////////////////////////////////

  425. 

  426. bool OSSClient::OpenWrite()

  427. { 	

  428. 	int result,val;

  429. 	cerr<<"Opening dsp output"<<endl;

  430.   

  431. 	m_Dspfd = open(host->OUTPUTFILE.c_str(),O_WRONLY);  

  432. 	if(m_Dspfd<0) 

  433. 	{

  434. 		fprintf(stderr,"Can't open audio driver for writing.\n");

  435. 		m_OutputOk=false;

  436. 		return false;

  437. 	}

  438.    

  439. 	result = ioctl(m_Dspfd,SNDCTL_DSP_RESET,NULL);

  440. 

  441. 	CHECK_AND_REPORT_ERROR;

  442. 			 

  443. 	short fgmtsize=0;

  444. 	int numfgmts=host->FRAGCOUNT;	 	 

  445. 	if (host->FRAGCOUNT==-1) numfgmts=0x7fff;

  446. 	

  447. 	for (int i=0; i<32; i++)

  448. 	{	 	

  449. 		if ((host->FRAGSIZE)==(1<<i)) 

  450. 		{

  451. 			fgmtsize=i; 

  452. 			break;

  453. 		}

  454. 	}

  455. 

  456. 	if (fgmtsize==0)

  457. 	{

  458. 		cerr<<"Fragment size ["<<host->FRAGSIZE<<"] must be power of two!"<<endl;

  459. 		fgmtsize=256;

  460. 	}

  461.  	 	

  462. 	numfgmts=numfgmts<<16;

  463. 	val=numfgmts|(int)fgmtsize;

  464. 	result=ioctl(m_Dspfd, SNDCTL_DSP_SETFRAGMENT, &val);

  465. 	CHECK_AND_REPORT_ERROR;

  466. 	

  467. 	val = 1;

  468. 	result = ioctl(m_Dspfd, SOUND_PCM_WRITE_CHANNELS, &val);

  469. 	CHECK_AND_REPORT_ERROR;

  470. 	

  471. 	val = AFMT_S16_LE;

  472. 	result = ioctl(m_Dspfd,SNDCTL_DSP_SETFMT,&val);	 

  473. 	CHECK_AND_REPORT_ERROR;

  474. 

  475. 	if (m_Channels==2) val=1;

  476. 	else val=0;

  477. 	result = ioctl(m_Dspfd,SNDCTL_DSP_STEREO,&val);

  478. 	CHECK_AND_REPORT_ERROR;

  479. 		

  480. 	val = host->SAMPLERATE;

  481. 	result = ioctl(m_Dspfd,SNDCTL_DSP_SPEED,&val);

  482. 	CHECK_AND_REPORT_ERROR;

  483. 	

  484. 	m_OutputOk=true;

  485. 	return true;

  486. }

  487. 

  488. //////////////////////////////////////////////////////////////////////

  489. 

  490. bool OSSClient::OpenRead()

  491. { 	

  492. 	int result,val;

  493.   

  494. 	cerr<<"Opening dsp input"<<endl;

  495. 

  496. 	m_Dspfd = open(host->OUTPUTFILE.c_str(),O_RDONLY);  

  497. 	if(m_Dspfd<0) 

  498. 	{

  499. 		fprintf(stderr,"Can't open audio driver for reading.\n");

  500. 		m_OutputOk=false;

  501. 		return false;

  502. 	}

  503.    

  504. 	result = ioctl(m_Dspfd,SNDCTL_DSP_RESET,NULL);

  505. 	CHECK_AND_REPORT_ERROR;

  506. 	

  507. 	val = 1;

  508. 	result = ioctl(m_Dspfd, SOUND_PCM_READ_CHANNELS, &val);

  509. 	CHECK_AND_REPORT_ERROR;

  510. 	

  511. 	val = AFMT_S16_LE;

  512. 	result = ioctl(m_Dspfd,SNDCTL_DSP_SETFMT,&val);	 

  513. 	CHECK_AND_REPORT_ERROR;

  514. 	

  515. 	val = host->SAMPLERATE;

  516. 	result = ioctl(m_Dspfd,SNDCTL_DSP_SPEED,&val);

  517. 	CHECK_AND_REPORT_ERROR;

  518. 	m_OutputOk=true;

  519. 	

  520. 	return true;

  521. }

  522. 

  523. //////////////////////////////////////////////////////////////////////

  524. 

  525. bool OSSClient::OpenReadWrite()

  526. { 	

  527. 	int result,val;

  528. 	cerr<<"Opening dsp output (duplex)"<<endl;

  529.   

  530. 	m_Dspfd = open(host->OUTPUTFILE.c_str(),O_RDWR);  

  531. 	if(m_Dspfd<0) 

  532. 	{

  533. 		fprintf(stderr,"Can't open audio driver for writing.\n");

  534. 		m_OutputOk=false;

  535. 		return false;

  536. 	}

  537.    

  538. 	result = ioctl(m_Dspfd,SNDCTL_DSP_RESET,NULL);

  539. 

  540. 	CHECK_AND_REPORT_ERROR;

  541. 			 

  542. 	short fgmtsize=0;

  543. 	int numfgmts=host->FRAGCOUNT;	 	 

  544. 	if (host->FRAGCOUNT==-1) numfgmts=0x7fff;

  545. 	

  546. 	for (int i=0; i<32; i++)

  547. 	{	 	

  548. 		if ((host->FRAGSIZE)==(1<<i)) 

  549. 		{

  550. 			fgmtsize=i; 

  551. 			break;

  552. 		}

  553. 	}

  554. 

  555. 	if (fgmtsize==0)

  556. 	{

  557. 		cerr<<"Fragment size ["<<host->FRAGSIZE<<"] must be power of two!"<<endl;

  558. 		fgmtsize=256;

  559. 	}

  560.  	 	

  561. 	numfgmts=numfgmts<<16;

  562. 	val=numfgmts|(int)fgmtsize;

  563. 	result=ioctl(m_Dspfd, SNDCTL_DSP_SETFRAGMENT, &val);

  564. 	CHECK_AND_REPORT_ERROR;

  565. 	

  566. 	val = 1;

  567. 	result = ioctl(m_Dspfd, SOUND_PCM_WRITE_CHANNELS, &val);

  568. 	CHECK_AND_REPORT_ERROR;

  569. 	

  570. 	val = AFMT_S16_LE;

  571. 	result = ioctl(m_Dspfd,SNDCTL_DSP_SETFMT,&val);	 

  572. 	CHECK_AND_REPORT_ERROR;

  573. 

  574. 	if (m_Channels==2) val=1;

  575. 	else val=0;

  576. 	result = ioctl(m_Dspfd,SNDCTL_DSP_STEREO,&val);

  577. 	CHECK_AND_REPORT_ERROR;

  578. 		

  579. 	val = host->SAMPLERATE;

  580. 	result = ioctl(m_Dspfd,SNDCTL_DSP_SPEED,&val);

  581. 	CHECK_AND_REPORT_ERROR;

  582. 	m_OutputOk=true;

  583. 	

  584.     return true;

  585. }