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.
99 Commits
1 Branch
1.8MB
Tree: 3c6be46311
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3c6be46311'
${ noResults }
spiralsynthmodular/SpiralSound/Plugins/OutputPlugin/OutputPlugin.C

550 lines
12KB
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. static const int IN_FREQ  = 0;

  48. static const int IN_PW    = 1;

  49. static const int IN_SHLEN = 2;

  50. 

  51. static const int OUT_MAIN = 0;

  52. 

  53. static const HostInfo* host;

  54. OSSOutput* OSSOutput::m_Singleton = NULL;

  55. int OutputPlugin::m_RefCount=0;

  56. int OutputPlugin::m_NoExecuted=0;

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

  58. 

  59. 

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

  61. 								{                     \

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

  63. 									m_OutputOk=false; \

  64. 									return false;     \

  65. 								}

  66. 

  67. extern "C"

  68. {

  69. SpiralPlugin* CreateInstance()

  70. {

  71. 	return new OutputPlugin;

  72. }

  73. 

  74. char** GetIcon()

  75. {	

  76. 	return SpiralIcon_xpm;

  77. }

  78. 

  79. int GetID()

  80. {

  81. 	return 0x0000;

  82. }

  83. }

  84. 

  85. ///////////////////////////////////////////////////////

  86. 

  87. OutputPlugin::OutputPlugin() :

  88. m_Volume(1.0f)

  89. {

  90. 	m_RefCount++;

  91. 	

  92. 	// we are an output.

  93. 	m_IsTerminal=true;

  94. 	

  95. 	m_PluginInfo.Name="OSS";

  96. 	m_PluginInfo.Width=100;

  97. 	m_PluginInfo.Height=100;

  98. 	m_PluginInfo.NumInputs=2;

  99. 	m_PluginInfo.NumOutputs=2;

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

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

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

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

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

  105. 	

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

  107. }

  108. 

  109. OutputPlugin::~OutputPlugin()

  110. {	

  111. 	m_RefCount--;

  112. 	if (m_RefCount==0)

  113. 	{	

  114. 		cb_Blocking(m_Parent,false);

  115. 		OSSOutput::PackUpAndGoHome();

  116. 	}

  117. }

  118. 

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

  120. {	

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

  122. 	host=Host;

  123. 	OSSOutput::Get()->AllocateBuffer();

  124. 

  125. 	return Info;

  126. }

  127. 

  128. SpiralGUIType *OutputPlugin::CreateGUI()

  129. {

  130. 	return new OutputPluginGUI(m_PluginInfo.Width,

  131. 										  m_PluginInfo.Height,

  132. 										  this,

  133. 										  m_AudioCH,

  134. 										  m_HostInfo);

  135. }

  136. 

  137. void OutputPlugin::Execute()

  138. {

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

  140. 	{

  141. 		if (OSSOutput::Get()->OpenWrite())

  142. 		{

  143. 			cb_Blocking(m_Parent,true); 

  144. 			m_Mode=OUTPUT;

  145. 		}		

  146. 	}

  147. 	

  148. 	//if (m_Mode==NO_MODE || m_Mode==CLOSED) cb_Blocking(m_Parent,false); 

  149. 	//else cb_Blocking(m_Parent,true); 

  150. 		

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

  152. 	{

  153. 		OSSOutput::Get()->SendStereo(GetInput(0),GetInput(1));

  154. 		

  155. 		// can't open GUI stuff here

  156. 	/*	for (int n=0; n<m_HostInfo->BUFSIZE;n++)

  157. 		{

  158. 			// can't open GUI stuff here

  159. 			if (GetInput(2,n)!=0)

  160. 			{

  161. 				if (! m_CheckedAlready)

  162. 				{

  163. 				m_CheckedAlready=true;

  164. //				an experimental line, should *theoretically* cut down on CPU time.

  165. 				n=m_HostInfo->BUFSIZE;

  166. 					if (! m_Recmode)

  167. 					{

  168. 						char *fn=fl_file_chooser("Pick a Wav file to save to", "*.wav", NULL);	

  169. 						if (fn && fn!="")

  170. 						{

  171. 							OSSOutput::Get()->WavOpen(fn);

  172. 						}

  173. 						m_Recmode=true;

  174. 					}

  175. 					else 

  176. 					{

  177. 						OSSOutput::Get()->WavClose();

  178. 						m_Recmode=false;

  179. 					}

  180. 						

  181. 				}

  182. 			}

  183. 			else

  184. 			m_CheckedAlready=false;

  185. 		}*/

  186. 	}

  187. 	

  188. 	if (m_Mode==INPUT || m_Mode==DUPLEX) OSSOutput::Get()->GetStereo(GetOutputBuf(0),GetOutputBuf(1));	

  189. }

  190. 

  191. void OutputPlugin::ExecuteCommands()

  192. {

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

  194. 	

  195. 	cerr<<m_RefCount<<" "<<m_NoExecuted<<endl;

  196. 	

  197. 	m_NoExecuted--;

  198. 	if (m_NoExecuted<=0)

  199. 	{	

  200. 		if (m_Mode==INPUT || m_Mode==DUPLEX) OSSOutput::Get()->Read();		

  201. 		if (m_Mode==OUTPUT || m_Mode==DUPLEX) OSSOutput::Get()->Play();		

  202. 		m_NoExecuted=m_RefCount;

  203. 	}

  204. 

  205. 

  206. 	if (m_AudioCH->IsCommandWaiting())

  207. 	{

  208. 		switch(m_AudioCH->GetCommand())

  209. 		{

  210. 			case OPENREAD : 

  211. 				if (OSSOutput::Get()->OpenRead())

  212. 				{

  213. 					m_Mode=INPUT;

  214. 					//cb_Blocking(m_Parent,true); 

  215. 				}

  216. 			break;

  217. 			case OPENWRITE : 

  218. 				if (OSSOutput::Get()->OpenWrite()) 

  219. 				{

  220. 					m_Mode=OUTPUT;

  221. 					cb_Blocking(m_Parent,true); 

  222. 				}

  223. 			break;

  224. 			case OPENDUPLEX : 

  225. 				if (OSSOutput::Get()->OpenReadWrite()) 

  226. 				{

  227. 					m_Mode=DUPLEX;

  228. 					cb_Blocking(m_Parent,true); 

  229. 				}

  230. 			break;

  231. 			case CLOSE : 

  232. 				m_Mode=CLOSED;

  233. 				cb_Blocking(m_Parent,false); 

  234. 				OSSOutput::Get()->Close(); 

  235. 			break;

  236. 			case SET_VOLUME : OSSOutput::Get()->SetVolume(m_Volume); break;			

  237. 			default : break;

  238. 		}

  239. 	}

  240. }

  241. 

  242. //////////////////////////////////////////////////////////////////////

  243. //////////////////////////////////////////////////////////////////////

  244. 

  245. OSSOutput::OSSOutput() :

  246. m_Amp(0.5),

  247. m_Channels(2),

  248. m_ReadBufferNum(0),

  249. m_WriteBufferNum(0),

  250. m_OutputOk(false)

  251. { 

  252. 	m_Buffer[0]=NULL;

  253. 	m_Buffer[1]=NULL;

  254. 	m_InBuffer[0]=NULL;

  255. 	m_InBuffer[1]=NULL;

  256. }

  257. 

  258. //////////////////////////////////////////////////////////////////////

  259. 

  260. OSSOutput::~OSSOutput()

  261. {

  262. 	Close();

  263. }

  264. 

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

  266. 

  267. void OSSOutput::AllocateBuffer()

  268. {

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

  270. 	{

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

  272. 		

  273. 		// initialise for stereo

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

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

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

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

  278. 	}

  279. 	

  280. 	m_Wav.SetSamplerate(host->SAMPLERATE);

  281. }

  282. 

  283. //////////////////////////////////////////////////////////////////////

  284. 

  285. void OSSOutput::SendStereo(const Sample *ldata,const Sample *rdata) 

  286. {

  287. 	if (m_Channels!=2) return;

  288. 	

  289. 	int on=0;

  290. 	float t;

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

  292. 	{

  293. 		// stereo channels - interleave	

  294. 		if (ldata) 

  295. 		{

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

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

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

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

  300. 		}

  301. 		on++;

  302. 		

  303. 		if (rdata) 

  304. 		{

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

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

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

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

  309. 		}		

  310. 		on++;

  311. 	}

  312. }

  313. 

  314. //////////////////////////////////////////////////////////////////////

  315. 

  316. void OSSOutput::Play()

  317. {

  318.     int BufferToSend=!m_WriteBufferNum;

  319. 	

  320.     #if __BYTE_ORDER == BIG_ENDIAN

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

  322.     {		

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

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

  325.     }

  326.     #endif	

  327. 	if (m_OutputOk)

  328. 	{

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

  330. 	}

  331. 		

  332.     if(m_Wav.Recording()) 

  333.     {

  334.         m_Wav.Save(m_Buffer[BufferToSend],m_BufSizeBytes);

  335.     }

  336. 

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

  338. 	m_WriteBufferNum=BufferToSend;

  339. }

  340. 

  341. //////////////////////////////////////////////////////////////////////

  342. 

  343. void OSSOutput::GetStereo(Sample *ldata,Sample *rdata) 

  344. {

  345. 	if (m_Channels!=2) return;

  346. 	

  347. 	int on=0;

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

  349. 	{

  350. 		// stereo channels - interleave	

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

  352. 		on++;

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

  354. 		on++;

  355. 	}

  356. }

  357. 

  358. //////////////////////////////////////////////////////////////////////

  359. 

  360. void OSSOutput::Read()

  361. {

  362.     int BufferToRead=!m_ReadBufferNum;

  363. 

  364. 	if (m_OutputOk)

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

  366. 	

  367.     #if __BYTE_ORDER == BIG_ENDIAN

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

  369.     {		

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

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

  372.     }

  373.     #endif	

  374.     

  375. 	m_ReadBufferNum=BufferToRead;

  376. }

  377. 

  378. //////////////////////////////////////////////////////////////////////

  379. 

  380. bool OSSOutput::Close()

  381. { 	

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

  383. 	close(m_Dspfd);

  384. 	

  385. 	return true;

  386. }

  387. 

  388. //////////////////////////////////////////////////////////////////////

  389. 

  390. bool OSSOutput::OpenWrite()

  391. { 	

  392. 	int result,val;

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

  394.   

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

  396. 	if(m_Dspfd<0) 

  397. 	{

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

  399. 		m_OutputOk=false;

  400. 		return false;

  401. 	}

  402.    

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

  404. 

  405. 	CHECK_AND_REPORT_ERROR;

  406. 			 

  407. 	short fgmtsize=0;

  408. 	int numfgmts=host->FRAGCOUNT;	 	 

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

  410. 	

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

  412. 	{	 	

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

  414. 		{

  415. 			fgmtsize=i; 

  416. 			break;

  417. 		}

  418. 	}

  419. 

  420. 	if (fgmtsize==0)

  421. 	{

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

  423. 		fgmtsize=256;

  424. 	}

  425.  	 	

  426. 	numfgmts=numfgmts<<16;

  427. 	val=numfgmts|(int)fgmtsize;

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

  429. 	CHECK_AND_REPORT_ERROR;

  430. 	

  431. 	val = 1;

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

  433. 	CHECK_AND_REPORT_ERROR;

  434. 	

  435. 	val = AFMT_S16_LE;

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

  437. 	CHECK_AND_REPORT_ERROR;

  438. 

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

  440. 	else val=0;

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

  442. 	CHECK_AND_REPORT_ERROR;

  443. 		

  444. 	val = host->SAMPLERATE;

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

  446. 	CHECK_AND_REPORT_ERROR;

  447. 	

  448. 	m_OutputOk=true;

  449. 	return true;

  450. }

  451. 

  452. //////////////////////////////////////////////////////////////////////

  453. 

  454. bool OSSOutput::OpenRead()

  455. { 	

  456. 	int result,val;

  457.   

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

  459. 

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

  461. 	if(m_Dspfd<0) 

  462. 	{

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

  464. 		m_OutputOk=false;

  465. 		return false;

  466. 	}

  467.    

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

  469. 	CHECK_AND_REPORT_ERROR;

  470. 	

  471. 	val = 1;

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

  473. 	CHECK_AND_REPORT_ERROR;

  474. 	

  475. 	val = AFMT_S16_LE;

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

  477. 	CHECK_AND_REPORT_ERROR;

  478. 	

  479. 	val = host->SAMPLERATE;

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

  481. 	CHECK_AND_REPORT_ERROR;

  482. 	m_OutputOk=true;

  483. 	

  484. 	return true;

  485. }

  486. 

  487. //////////////////////////////////////////////////////////////////////

  488. 

  489. bool OSSOutput::OpenReadWrite()

  490. { 	

  491. 	int result,val;

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

  493.   

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

  495. 	if(m_Dspfd<0) 

  496. 	{

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

  498. 		m_OutputOk=false;

  499. 		return false;

  500. 	}

  501.    

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

  503. 

  504. 	CHECK_AND_REPORT_ERROR;

  505. 			 

  506. 	short fgmtsize=0;

  507. 	int numfgmts=host->FRAGCOUNT;	 	 

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

  509. 	

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

  511. 	{	 	

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

  513. 		{

  514. 			fgmtsize=i; 

  515. 			break;

  516. 		}

  517. 	}

  518. 

  519. 	if (fgmtsize==0)

  520. 	{

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

  522. 		fgmtsize=256;

  523. 	}

  524.  	 	

  525. 	numfgmts=numfgmts<<16;

  526. 	val=numfgmts|(int)fgmtsize;

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

  528. 	CHECK_AND_REPORT_ERROR;

  529. 	

  530. 	val = 1;

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

  532. 	CHECK_AND_REPORT_ERROR;

  533. 	

  534. 	val = AFMT_S16_LE;

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

  536. 	CHECK_AND_REPORT_ERROR;

  537. 

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

  539. 	else val=0;

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

  541. 	CHECK_AND_REPORT_ERROR;

  542. 		

  543. 	val = host->SAMPLERATE;

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

  545. 	CHECK_AND_REPORT_ERROR;

  546. 	m_OutputOk=true;

  547. 	

  548.     return true;

  549. }