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

772 lines
19KB
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. #include "SequencerPlugin.h"

  19. #include "SequencerPluginGUI.h"

  20. #include <FL/Fl_Button.h>

  21. #include "SpiralIcon.xpm"

  22. #include "../../RiffWav.h"

  23. #include "../../NoteTable.h"

  24. 

  25. // for note on's

  26. static const float TRIGGER_LEV=0.1;

  27. 

  28. //////////////////////////////////////////////////////////////////////////

  29. // base sequencing stuff

  30. 

  31. Note::Note(float t=0, float l=0.1f, int n=0, float v=1.0f)

  32. {

  33. 	Time = t;

  34. 	Length = l;

  35. 	MidiNote = n;

  36. 	Vol  = v;

  37. }

  38. 

  39. Note::~Note()

  40. {

  41. }

  42. 	

  43. istream &operator>>(istream &s, Note &o)

  44. {

  45. 	int version=1;

  46. 	string dummy;

  47. 	s>>version>>dummy>>o.Time>>o.Length>>o.MidiNote>>o.Vol;

  48. 	

  49. 	return s;

  50. }

  51. 

  52. ostream &operator<<(ostream &s, Note &o)

  53. {	

  54. 	int version=1;

  55. 	s<<version<<" note "<<o.Time<<" "<<o.Length<<" "<<o.MidiNote<<" "<<o.Vol<<" ";

  56. 	

  57. 	return s;

  58. }	

  59. 

  60. /////////////////////////////////////////////////////////////////////////

  61. 

  62. Pattern::Pattern()

  63. {

  64. }

  65. 

  66. Pattern::~Pattern()

  67. {

  68. }

  69. 

  70. void  Pattern::Copy(const Pattern *o)

  71. {

  72. 	// can't do this as we don't want to preserve the id numbers

  73. 	//m_NoteMap=o->m_NoteMap;	

  74. 	

  75. 	int c=0;

  76. 	for (map<int,Note>::const_iterator i = o->m_NoteMap.begin();

  77. 		 i!=o->m_NoteMap.end(); i++)

  78. 	{

  79. 		m_NoteMap[c++]=i->second;

  80. 	}

  81. }

  82. 

  83. void  Pattern::AddNote(int ID, float t, float l, int n, float v)

  84. {

  85. 	map<int,Note>::iterator i = m_NoteMap.find(ID);

  86. 	if (i != m_NoteMap.end())

  87. 	{

  88. 		cerr<<"duplicate note "<<ID<<" not added"<<endl;

  89. 		return;

  90. 	}

  91. 	Note newnote(t,l,n,v);

  92. 		

  93. 	m_NoteMap[ID]=newnote;

  94. }

  95. 

  96. void  Pattern::RemoveNote(int ID)

  97. {

  98. 	map<int,Note>::iterator i = m_NoteMap.find(ID);

  99. 	if (i == m_NoteMap.end())

  100. 	{

  101. 		cerr<<"couldn't find note "<<ID<<" not removed"<<endl;

  102. 		return;

  103. 	}

  104. 	

  105. 	m_NoteMap.erase(i);

  106. }

  107. 

  108. Note *Pattern::GetNote(int ID)

  109. {

  110. 	map<int,Note>::iterator i = m_NoteMap.find(ID);

  111. 	if (i == m_NoteMap.end())

  112. 	{

  113. 		cerr<<"couldn't find note "<<ID<<endl;

  114. 		return NULL;

  115. 	}

  116. 	

  117. 	return &i->second;

  118. }

  119. 

  120. istream &operator>>(istream &s, Pattern &o)

  121. {

  122. 	int version=1,Num;

  123. 	string dummy;

  124. 	int id=0;

  125. 	s>>version>>dummy>>Num;

  126. 	for (int n=0; n<Num; n++)

  127. 	{

  128. 		Note t;

  129. 		s>>t;

  130. 		o.m_NoteMap[id++]=t;

  131. 	}

  132. 	

  133. 	return s;

  134. }

  135. 

  136. ostream &operator<<(ostream &s, Pattern &o)

  137. {	

  138. 	int version=1;

  139. 	s<<version<<" pattern "<<o.m_NoteMap.size()<<" ";

  140. 	

  141. 	for (map<int,Note>::iterator i = o.m_NoteMap.begin();

  142. 		 i!=o.m_NoteMap.end(); i++)

  143. 	{

  144. 		s<<i->second;

  145. 	}

  146. 	s<<endl;

  147. 	

  148. 	return s;

  149. }	

  150. 

  151. //////////////////////////////////////////////////////////////////////////

  152. 

  153. Sequence::Sequence(float st=0, int pat=0)

  154. {

  155. 	m_StartTime=st;

  156. 	m_Pattern=pat;

  157. }

  158. 

  159. Sequence::~Sequence()

  160. {

  161. }

  162. 

  163. istream &operator>>(istream &s, Sequence &o)

  164. {

  165. 	int version=1;

  166. 	string dummy;

  167. 	s>>version>>dummy>>o.m_StartTime>>o.m_Pattern>>o.m_Colour>>o.m_YPos>>o.m_Length>>o.m_Channel;

  168. 	

  169. 	char Buf[4096];

  170. 	int size;

  171. 	s>>size;

  172. 	s.ignore(1);

  173. 	s.get(Buf,size+1);

  174. 	o.m_Name=Buf;

  175. 	

  176. 	return s;

  177. }

  178. 

  179. ostream &operator<<(ostream &s, Sequence &o)

  180. {	

  181. 	int version=1;

  182. 	s<<version<<" sequence"<<" "<<o.m_StartTime<<" "<<o.m_Pattern<<" "<<o.m_Colour<<" "<<o.m_YPos<<" "<<o.m_Length<<" "<<o.m_Channel<<" ";

  183. 	s<<o.m_Name.size()<<" "<<o.m_Name<<endl;

  184. 	

  185. 	return s;

  186. }	

  187. 

  188. //////////////////////////////////////////////////////////////////////////

  189. 

  190. Track::Track()

  191. {

  192. 	m_NextPatternID=0;

  193. }

  194. 

  195. Track::~Track()

  196. {

  197. }

  198. 

  199. void Track::AddSequence(int ID)

  200. {

  201. 	map<int,Sequence>::iterator i = m_SequenceMap.find(ID);

  202. 	if (i != m_SequenceMap.end())

  203. 	{

  204. 		cerr<<"duplicate sequence "<<ID<<" not added"<<endl;

  205. 		return;

  206. 	}

  207. 		

  208. 	Sequence newsequence;

  209. 	AddPattern(m_NextPatternID);

  210. 	newsequence.SetPatternID(m_NextPatternID);

  211. 	newsequence.SetColour(0);

  212. 	newsequence.SetName("noname");

  213. 	newsequence.SetLength(10.0f);

  214. 	newsequence.SetYPos(1);	

  215. 	newsequence.SetChannel(0);

  216. 	m_NextPatternID++;

  217. 	

  218. 	m_SequenceMap[ID]=newsequence;

  219. }

  220. 

  221. // duplicate the sequence, but reference the same pattern

  222. void Track::CloneSequence(int ID, int nID)

  223. {

  224. 	AddSequence(nID);

  225. 	Sequence *s=GetSequence(nID);

  226. 	s->SetColour(GetSequence(ID)->GetColour());

  227. 	s->SetName(GetSequence(ID)->GetName());

  228. 	s->SetLength(GetSequence(ID)->GetLength());

  229. 	s->SetYPos(GetSequence(ID)->GetYPos());	

  230. 	s->SetPatternID(GetSequence(ID)->GetPatternID());

  231. 	s->SetStartTime(GetSequence(ID)->GetStartTime());	

  232. 	s->SetChannel(GetSequence(ID)->GetChannel());	

  233. }

  234. 

  235. // duplicate the sequence, and copy the pattern to it's own version

  236. void Track::CopySequence(int ID, int nID)

  237. {

  238. 	AddSequence(nID);

  239. 	Sequence *s=GetSequence(nID);

  240. 	s->SetColour(GetSequence(ID)->GetColour());

  241. 	s->SetName(GetSequence(ID)->GetName());

  242. 	s->SetLength(GetSequence(ID)->GetLength());

  243. 	s->SetYPos(GetSequence(ID)->GetYPos());

  244. 	s->SetStartTime(GetSequence(ID)->GetStartTime());	

  245. 	s->SetChannel(GetSequence(ID)->GetChannel());	

  246. 	AddPattern(m_NextPatternID);

  247. 	GetPattern(m_NextPatternID)->Copy(GetPattern(GetSequence(ID)->GetPatternID()));	

  248. 	GetSequence(nID)->SetPatternID(m_NextPatternID);

  249. 	m_NextPatternID++;

  250. }

  251. 

  252. // copy the sequences pattern, so it's got it's own version

  253. void Track::InstanceSequence(int ID)

  254. {

  255. 	AddPattern(m_NextPatternID);

  256. 	GetPattern(m_NextPatternID)->Copy(GetPattern(GetSequence(ID)->GetPatternID()));	

  257. 	GetSequence(ID)->SetPatternID(m_NextPatternID);

  258. 	m_NextPatternID++;

  259. }

  260. 

  261. void Track::RemoveSequence(int ID)

  262. {

  263. 	map<int,Sequence>::iterator i = m_SequenceMap.find(ID);

  264. 	if (i == m_SequenceMap.end())

  265. 	{

  266. 		cerr<<"couldn't find sequence "<<ID<<" not removed"<<endl;

  267. 		return;

  268. 	}

  269. 	

  270. 	// todo - refcount the patterns

  271. 	

  272. 	m_SequenceMap.erase(i);

  273. }

  274. 

  275. Sequence *Track::GetSequence(int ID)

  276. {

  277. 	map<int, Sequence>::iterator i = m_SequenceMap.find(ID);

  278. 	if (i == m_SequenceMap.end())

  279. 	{

  280. 		cerr<<"couldn't find sequence "<<ID<<endl;

  281. 		return NULL;

  282. 	}

  283. 	

  284. 	return &i->second;

  285. }

  286. 

  287. void Track::AddNote(int ID, int Sequence, float t, float l, int n, float v)

  288. {

  289. 	GetPattern(GetSequence(Sequence)->GetPatternID())->AddNote(ID,t,l,n,v);

  290. }

  291. 

  292. void Track::RemoveNote(int ID, int Sequence)

  293. {

  294. 	GetPattern(GetSequence(Sequence)->GetPatternID())->RemoveNote(ID);

  295. }

  296. 

  297. void Track::ChangeNote(int ID, int Sequence, float t, float l, int n, float v)

  298. {

  299. 	Note *note = GetPattern(GetSequence(Sequence)->GetPatternID())->GetNote(ID);

  300. 	note->Time = t;

  301. 	note->Length = l;

  302. 	note->MidiNote = n;

  303. 	note->Vol  = v;

  304. }

  305. 	

  306. void Track::ReadTrack(float t, int channel, vector<Note> &NoteVec)

  307. {

  308. 	// for every sequence

  309. 	for (map<int, Sequence>::iterator i = m_SequenceMap.begin();

  310. 		 i!=m_SequenceMap.end(); i++)

  311. 	{

  312. 		if (i->second.GetChannel()==channel)

  313. 		{

  314. 			Pattern *p=GetPattern(i->second.GetPatternID());

  315. 			float SeqTime=i->second.GetStartTime();

  316. 		

  317. 			// for every note in the pattern

  318. 			for (map<int, Note>::iterator n = p->m_NoteMap.begin();

  319. 			 	 n!=p->m_NoteMap.end(); n++)

  320. 			{

  321. 				if (n->second.Time+SeqTime<t && n->second.Time+n->second.Length+SeqTime>t)

  322. 				{

  323. 					NoteVec.push_back(n->second);

  324. 				}

  325. 			}

  326. 		}

  327. 	}

  328. }

  329. 

  330. //// private //////

  331. 

  332. void Track::AddPattern(int ID)

  333. {

  334. 	map<int,Pattern>::iterator i = m_PatternMap.find(ID);

  335. 	if (i != m_PatternMap.end())

  336. 	{

  337. 		cerr<<"duplicate pattern "<<ID<<" not added"<<endl;

  338. 		return;

  339. 	}

  340. 	Pattern newpattern;

  341. 	m_PatternMap[ID]=newpattern;

  342. }

  343. 

  344. void Track::RemovePattern(int ID)

  345. {

  346. 	map<int,Pattern>::iterator i = m_PatternMap.find(ID);

  347. 	if (i == m_PatternMap.end())

  348. 	{

  349. 		cerr<<"couldn't find pattern "<<ID<<" not removed"<<endl;

  350. 		return;

  351. 	}

  352. 	

  353. 	m_PatternMap.erase(i);

  354. }

  355. 

  356. Pattern *Track::GetPattern(int ID)

  357. {

  358. 	map<int,Pattern>::iterator i = m_PatternMap.find(ID);

  359. 	if (i == m_PatternMap.end())

  360. 	{

  361. 		cerr<<"couldn't find pattern "<<ID<<endl;

  362. 		return NULL;

  363. 	}

  364. 	

  365. 	return &i->second;

  366. }

  367. 

  368. istream &operator>>(istream &s, Track &o)

  369. {

  370. 	int version=1,Num,id=0;

  371. 	string dummy;

  372. 	s>>version>>dummy;

  373. 	

  374. 	s>>Num;

  375. 	for (int n=0; n<Num; n++)

  376. 	{

  377. 		Pattern t;

  378. 		s>>t;

  379. 		o.m_PatternMap[id++]=t;

  380. 	}

  381. 	s>>Num;

  382. 	id=0;

  383. 	for (int n=0; n<Num; n++)

  384. 	{

  385. 		Sequence t;

  386. 		s>>t;

  387. 		o.m_SequenceMap[id++]=t;

  388. 		

  389. 		cerr<<"Loaded sequence "<<t.GetName()<<endl;

  390. 	}

  391. 	s>>o.m_NextPatternID;

  392. 	o.m_NextPatternID=o.m_PatternMap.size();

  393. 	return s;

  394. }

  395. 

  396. ostream &operator<<(ostream &s, Track &o)

  397. {	

  398. 	int version=1;

  399. 	

  400. 	s<<version<<" "<<"track"<<" ";

  401. 	s<<o.m_PatternMap.size()<<endl;	

  402. 	for (map<int,Pattern>::iterator i = o.m_PatternMap.begin();

  403. 		 i!=o.m_PatternMap.end(); i++)

  404. 	{

  405. 		s<<i->second;

  406. 	}	

  407. 	

  408. 	s<<o.m_SequenceMap.size()<<endl;	

  409. 	for (map<int,Sequence>::iterator i = o.m_SequenceMap.begin();

  410. 		 i!=o.m_SequenceMap.end(); i++)

  411. 	{

  412. 		s<<i->second;

  413. 	}

  414. 	s<<o.m_NextPatternID<<" "<<endl;

  415. 	return s;

  416. }	

  417. ////////////////////////////////////////////////////////////////////////////////////

  418. ////////////////////////////////////////////////////////////////////////////////////

  419. 

  420. extern "C" {

  421. SpiralPlugin* CreateInstance()

  422. {

  423. 	return new SequencerPlugin;

  424. }

  425. 

  426. char** GetIcon()

  427. {

  428. 	return SpiralIcon_xpm;

  429. }

  430. 

  431. int GetID()

  432. {

  433. 	return 0x0011;

  434. }

  435. }

  436. 

  437. ///////////////////////////////////////////////////////

  438. 

  439. SequencerPlugin::SequencerPlugin() :

  440. m_TransferPattern(-1),

  441. m_Time(0.0f),

  442. m_Length(4),

  443. m_BarLength(1.0f),

  444. m_BeatsPerBar(4),

  445. m_NextBeatTime(0.0f),

  446. m_BeatLevel(-1.0f),

  447. m_BeatCount(0),

  448. m_BarCount(0),

  449. m_SpeedMod(1.0f),

  450. m_InNoteDown(false),

  451. m_InNoteID(0),

  452. m_CurrentPattern(0),

  453. m_Triggered(false)

  454. {

  455. 	m_Version=1;

  456. 	

  457. 	m_PluginInfo.Name="Sequencer";

  458. 	m_PluginInfo.Width=540;

  459. 	m_PluginInfo.Height=290;

  460. 	m_PluginInfo.NumInputs=4;

  461. 	m_PluginInfo.NumOutputs=17;		

  462. 	m_PluginInfo.PortTips.push_back("Play Trigger");	

  463. 	m_PluginInfo.PortTips.push_back("Speed CV");	

  464. 	m_PluginInfo.PortTips.push_back("Input Pitch CV");	

  465. 	m_PluginInfo.PortTips.push_back("Input Trigger CV");	

  466. 	m_PluginInfo.PortTips.push_back("Channel 0 Pitch");	

  467. 	m_PluginInfo.PortTips.push_back("Channel 0 Trigger");	

  468. 	m_PluginInfo.PortTips.push_back("Channel 1 Pitch");	

  469. 	m_PluginInfo.PortTips.push_back("Channel 1 Trigger");	

  470. 	m_PluginInfo.PortTips.push_back("Channel 2 Pitch");	

  471. 	m_PluginInfo.PortTips.push_back("Channel 2 Trigger");	

  472. 	m_PluginInfo.PortTips.push_back("Channel 3 Pitch");	

  473. 	m_PluginInfo.PortTips.push_back("Channel 3 Trigger");	

  474. 	m_PluginInfo.PortTips.push_back("Channel 4 Pitch");	

  475. 	m_PluginInfo.PortTips.push_back("Channel 4 Trigger");	

  476. 	m_PluginInfo.PortTips.push_back("Channel 5 Pitch");	

  477. 	m_PluginInfo.PortTips.push_back("Channel 5 Trigger");	

  478. 	m_PluginInfo.PortTips.push_back("Channel 6 Pitch");	

  479. 	m_PluginInfo.PortTips.push_back("Channel 6 Trigger");	

  480. 	m_PluginInfo.PortTips.push_back("Channel 7 Pitch");	

  481. 	m_PluginInfo.PortTips.push_back("Channel 7 Trigger");	

  482. 	/*m_PluginInfo.PortTips.push_back("Channel 8 Pitch");	

  483. 	m_PluginInfo.PortTips.push_back("Channel 8 Trigger");	

  484. 	m_PluginInfo.PortTips.push_back("Channel 9 Pitch");	

  485. 	m_PluginInfo.PortTips.push_back("Channel 9 Trigger");	

  486. 	m_PluginInfo.PortTips.push_back("Channel 10 Pitch");	

  487. 	m_PluginInfo.PortTips.push_back("Channel 10 Trigger");	

  488. 	m_PluginInfo.PortTips.push_back("Channel 11 Pitch");	

  489. 	m_PluginInfo.PortTips.push_back("Channel 11 Trigger");	

  490. 	m_PluginInfo.PortTips.push_back("Channel 12 Pitch");	

  491. 	m_PluginInfo.PortTips.push_back("Channel 12 Trigger");	

  492. 	m_PluginInfo.PortTips.push_back("Channel 13 Pitch");	

  493. 	m_PluginInfo.PortTips.push_back("Channel 13 Trigger");	

  494. 	m_PluginInfo.PortTips.push_back("Channel 14 Pitch");	

  495. 	m_PluginInfo.PortTips.push_back("Channel 14 Trigger");	

  496. 	m_PluginInfo.PortTips.push_back("Channel 15 Pitch");	

  497. 	m_PluginInfo.PortTips.push_back("Channel 15 Trigger");*/		

  498. 	m_PluginInfo.PortTips.push_back("Beat");	

  499. 	

  500. 	m_AudioCH->Register("ID",&m_GUIArgs.Num);

  501. 	m_AudioCH->Register("ID2",&m_GUIArgs.Num2);

  502. 	m_AudioCH->Register("Channel",&m_GUIArgs.Channel);

  503. 	m_AudioCH->Register("Sequence",&m_GUIArgs.Sequence);

  504. 	m_AudioCH->Register("Time",&m_GUIArgs.t);

  505. 	m_AudioCH->Register("Length",&m_GUIArgs.l);

  506. 	m_AudioCH->Register("Vol",&m_GUIArgs.v);

  507. 	m_AudioCH->Register("Note",&m_GUIArgs.n);

  508. 	m_AudioCH->Register("CurrentTime",&m_Time,ChannelHandler::OUTPUT);

  509. 	m_AudioCH->Register("TotalLength",&m_Length);

  510. 	m_AudioCH->Register("BeatsPerBar",&m_BeatsPerBar);

  511. 	m_AudioCH->Register("BarLength",&m_BarLength);

  512. 	m_AudioCH->RegisterData("Name",ChannelHandler::INPUT,m_GUIArgs.Name,sizeof(m_GUIArgs.Name));

  513. 	

  514. 	// use OUTPUT_REQUEST for these, as we don't have to copy them constantly (and the gui can request them)

  515. 	m_AudioCH->Register("TransCount",&m_TransferCount,ChannelHandler::OUTPUT_REQUEST);

  516. 	m_AudioCH->RegisterData("TransNote",ChannelHandler::OUTPUT_REQUEST,&m_Transfer,sizeof(m_Transfer));

  517. }

  518. 

  519. SequencerPlugin::~SequencerPlugin()

  520. {

  521. }

  522. 

  523. PluginInfo &SequencerPlugin::Initialise(const HostInfo *Host)

  524. {	

  525. 	return SpiralPlugin::Initialise(Host);

  526. }

  527. 

  528. SpiralGUIType *SequencerPlugin::CreateGUI()

  529. {

  530. 	return new SequencerPluginGUI(m_PluginInfo.Width,

  531. 								  	    m_PluginInfo.Height,

  532. 										this,m_AudioCH,m_HostInfo);

  533. }

  534. 

  535. void SequencerPlugin::SetPattern(int s)          

  536. { 

  537. 	//m_Eventmap[m_CurrentPattern]->hide();

  538. 	m_CurrentPattern=s;

  539. 	//m_Eventmap[m_CurrentPattern]->show();

  540. }

  541. 

  542. 

  543. void SequencerPlugin::Execute()

  544. {	

  545. 	float Speed;

  546. 	

  547. 	for (int n=0; n<m_HostInfo->BUFSIZE; n++)

  548. 	{

  549. 		if (GetInputPitch(0,n)>0) 		

  550. 		{						

  551. 			if (!m_Triggered)

  552. 			{

  553. 				float Freq=GetInputPitch(0,n);

  554. 		

  555. 				// Notes 0 to 16 trigger patterns 0 to 16

  556. 				// No other notes catered for

  557. 				for (int i=0; i<NUM_PATTERNS; i++)

  558. 				{

  559. 					if (feq(Freq,NoteTable[i],0.01f))

  560. 					{

  561. 						SetPattern(i);

  562. 						break;

  563. 					}

  564. 				}

  565. 				

  566. 				m_Time=0;

  567. 				m_Triggered=true;

  568. 			}

  569. 		}

  570. 		else

  571. 		{

  572. 			m_Triggered=false;

  573. 		}

  574. 

  575. 		

  576. 		if (InputExists(1))

  577. 			Speed =(1.1025f/m_HostInfo->SAMPLERATE) * (GetInput(1,n)+1.0f);

  578. 		else

  579. 			Speed =1.1025f/m_HostInfo->SAMPLERATE;

  580. 		

  581. 		if (!m_InNoteDown)

  582. 		{

  583. 			// Check trigger

  584. 			if (GetInput(3,n)>TRIGGER_LEV)

  585. 			{

  586. 				m_InNoteDown=true;

  587. 				

  588. 				float Freq=GetInputPitch(2,n);

  589. 

  590. 				int NoteNum=0;				

  591. 				for (int i=0; i<131; i++)

  592. 				{

  593. 					if (feq(Freq,NoteTable[i],0.01f))

  594. 					{				

  595. 						NoteNum=i;

  596. 						break;

  597. 					}

  598. 				}

  599. 				

  600. 				/*cerr<<"note recieved ="<<NoteNum<<" f="<<Freq

  601. 				<<" t-1="<<NoteTable[NoteNum-1]

  602. 				<<" t="<<NoteTable[NoteNum]

  603. 				<<" t+1="<<NoteTable[NoteNum+1]<<endl;

  604. 				*/

  605. 				//m_InNoteID=m_Eventmap[m_CurrentPattern]->AddEventTime(m_Time, NoteNum, 0.5, Fl_SEvent::MELODY, false);

  606. 				

  607. 				m_InNoteTime=m_Time;

  608. 			}			

  609. 		}

  610. 		else

  611. 		{

  612. 			// Check trigger

  613. 			if (GetInput(3,n)<TRIGGER_LEV)

  614. 			{

  615. 				//m_Eventmap[m_CurrentPattern]->SetEventLength(m_InNoteID, m_Time-m_InNoteTime);

  616. 				m_InNoteDown=false;

  617. 			}		

  618. 		}		

  619. 		

  620. 		for (int channel=0; channel<NUM_CHANNELS; channel++)

  621. 		{

  622. 			// Get the notes from the map		

  623. 			vector<Note> NoteVec;

  624. 			m_Track.ReadTrack(m_Time,channel,NoteVec);

  625. 			

  626. 			m_CurrentTriggerCV[channel]=0;

  627. 			//m_CurrentNoteCV=0;

  628. 			

  629. 			// play all the notes found

  630. 			for (vector<Note>::iterator i=NoteVec.begin();

  631. 			     i!=NoteVec.end(); i++)

  632. 			{

  633. 				//cerr<<"time = "<<m_Time<<endl;

  634. 				//cerr<<"found note "<<i->Time<<" "<<i->Length<<endl;

  635. 								

  636. 				m_CurrentNoteCV[channel]=NoteTable[i->MidiNote];

  637. 				m_CurrentTriggerCV[channel]=1;			

  638. 			}

  639. 			SetOutputPitch(channel*2,n,m_CurrentNoteCV[channel]);

  640. 			SetOutput(channel*2+1,n,m_CurrentTriggerCV[channel]);

  641. 		}

  642. 	

  643. 		m_Time+=Speed*m_SpeedMod;

  644. 		

  645. 		// deal with the beat calculation

  646. 		if (m_Time>m_NextBeatTime)

  647. 		{

  648. 			float BeatTime=m_BarLength/m_BeatsPerBar;

  649. 			m_NextBeatTime=m_Time+BeatTime;

  650. 			if (m_BeatLevel!=1.0f) m_BeatLevel=1.0f;

  651. 			else m_BeatLevel=-1.0f;

  652. 			

  653. 			m_BeatCount++;	

  654. 		}

  655. 		SetOutput(NUM_CHANNELS*2,n,m_BeatLevel);

  656. 		

  657. 		if (m_BeatCount>=m_BeatsPerBar) 

  658. 		{

  659. 			m_BeatCount=0;

  660. 			m_BarCount++;

  661. 		}

  662. 		

  663. 		if (m_BarCount>=m_Length)

  664. 		{

  665. 			m_Time=0;

  666. 			m_BeatCount=-1;

  667. 			m_BarCount=0;

  668. 			m_NextBeatTime=0;

  669. 		}

  670. 		

  671. 		if (m_Time<0)

  672. 		{

  673. 			m_Time=m_Length;

  674. 		}

  675. 	}

  676. }

  677. 

  678. void SequencerPlugin::ExecuteCommands()

  679. {

  680. 	if (m_AudioCH->IsCommandWaiting())

  681. 	{

  682. 		switch (m_AudioCH->GetCommand())

  683. 		{

  684. 			case NEW_NOTE    : m_Track.AddNote(m_GUIArgs.Num,m_GUIArgs.Sequence,m_GUIArgs.t,m_GUIArgs.l,m_GUIArgs.n,m_GUIArgs.v); break;

  685. 			case CHG_NOTE    : m_Track.ChangeNote(m_GUIArgs.Num,m_GUIArgs.Sequence,m_GUIArgs.t,m_GUIArgs.l,m_GUIArgs.n,m_GUIArgs.v); break;

  686. 			case REM_NOTE    : m_Track.RemoveNote(m_GUIArgs.Num,m_GUIArgs.Sequence); break;

  687. 			case NEW_SEQ     : 

  688. 			{	

  689. 				m_Track.AddSequence(m_GUIArgs.Num); 

  690. 				m_Track.GetSequence(m_GUIArgs.Num)->SetColour(m_GUIArgs.Num2);

  691. 				m_Track.GetSequence(m_GUIArgs.Num)->SetName(m_GUIArgs.Name);

  692. 				m_Track.GetSequence(m_GUIArgs.Num)->SetLength(m_GUIArgs.l);

  693. 				m_Track.GetSequence(m_GUIArgs.Num)->SetYPos(m_GUIArgs.n);

  694. 				m_Track.GetSequence(m_GUIArgs.Num)->SetChannel(m_GUIArgs.Channel);

  695. 			} break;

  696. 			case COPY_SEQ    : m_Track.CopySequence(m_GUIArgs.Num,m_GUIArgs.Num2); break;

  697. 			case INST_SEQ    : m_Track.InstanceSequence(m_GUIArgs.Num); break;

  698. 			case CLONE_SEQ   : m_Track.CloneSequence(m_GUIArgs.Num,m_GUIArgs.Num2); break;

  699. 			case REM_SEQ     : m_Track.RemoveSequence(m_GUIArgs.Num); break;

  700. 			case CHG_SEQ     : 

  701. 			{

  702. 				m_Track.GetSequence(m_GUIArgs.Num)->SetColour(m_GUIArgs.Num2);

  703. 				m_Track.GetSequence(m_GUIArgs.Num)->SetName(m_GUIArgs.Name);

  704. 				m_Track.GetSequence(m_GUIArgs.Num)->SetLength(m_GUIArgs.l);

  705. 				m_Track.GetSequence(m_GUIArgs.Num)->SetYPos(m_GUIArgs.n);

  706. 				m_Track.GetSequence(m_GUIArgs.Num)->SetChannel(m_GUIArgs.Channel);

  707. 				m_Track.GetSequence(m_GUIArgs.Num)->SetStartTime(m_GUIArgs.t);

  708. 			} break;

  709. 			case GET_PATTERN : 

  710. 			{

  711. 				// start of transfer

  712. 				if (m_TransferPattern==-1) 

  713. 				{

  714. 					m_TransferPattern=m_Track.GetSequence(m_GUIArgs.Num)->GetPatternID();

  715. 					m_TransferNote=m_Track.GetPattern(m_TransferPattern)->m_NoteMap.begin();

  716. 					m_TransferCount=m_Track.GetPattern(m_TransferPattern)->GetNoteCount();

  717. 					

  718. 					cerr<<"going to transfer "<<m_TransferCount<<" notes"<<endl;

  719. 				}

  720. 				else

  721. 				{

  722. 					// last note gone

  723. 					if (m_TransferNote==m_Track.GetPattern(m_TransferPattern)->m_NoteMap.end())

  724. 					{

  725. 						m_TransferPattern=-1;

  726. 					}

  727. 					else

  728. 					{

  729. 						// copy this note over

  730. 						m_Transfer.Time     = m_TransferNote->second.Time;

  731. 						m_Transfer.Length   = m_TransferNote->second.Length;

  732. 						m_Transfer.MidiNote = m_TransferNote->second.MidiNote;

  733. 						m_Transfer.Vol      = m_TransferNote->second.Vol;

  734. 					

  735. 						m_TransferNote++;

  736. 					}

  737. 				}

  738. 			} break;

  739. 		 	default: break;

  740. 		}

  741. 	}

  742. }

  743. 

  744. void SequencerPlugin::StreamOut(ostream &s)

  745. {

  746. 	s<<m_Version<<" ";

  747. 	

  748. 	switch (m_Version)

  749. 	{

  750. 		case 1:

  751. 		{

  752. 			s<<m_Time<<" "<<m_Length<<" "<<m_BarLength<<" "<<m_BeatsPerBar<<" ";

  753. 			s<<m_Track;

  754. 		} break;

  755. 	}

  756. }

  757. 

  758. void SequencerPlugin::StreamIn(istream &s)

  759. {

  760. 	int version;

  761. 	s>>version;

  762. 	

  763. 	switch (version)

  764. 	{

  765. 		case 1:

  766. 		{

  767. 			s>>m_Time>>m_Length>>m_BarLength>>m_BeatsPerBar;

  768. 			s>>m_Track;

  769. 		} break;

  770. 	}

  771. }