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

778 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 "../../NoteTable.h"

  23. 

  24. using namespace std;

  25. 

  26. // for note on's

  27. static const float TRIGGER_LEV=0.1;

  28. 

  29. //////////////////////////////////////////////////////////////////////////

  30. // base sequencing stuff

  31. 

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

  33. {

  34. 	Time = t;

  35. 	Length = l;

  36. 	MidiNote = n;

  37. 	Vol  = v;

  38. }

  39. 

  40. Note::~Note()

  41. {

  42. }

  43. 

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

  45. {

  46. 	int version=1;

  47. 	string dummy;

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

  49. 

  50. 	return s;

  51. }

  52. 

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

  54. {

  55. 	int version=1;

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

  57. 

  58. 	return s;

  59. }

  60. 

  61. /////////////////////////////////////////////////////////////////////////

  62. 

  63. Pattern::Pattern()

  64. {

  65. }

  66. 

  67. Pattern::~Pattern()

  68. {

  69. }

  70. 

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

  72. {

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

  74. 	//m_NoteMap=o->m_NoteMap;

  75. 

  76. 	int c=0;

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

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

  79. 	{

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

  81. 	}

  82. }

  83. 

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

  85. {

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

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

  88. 	{

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

  90. 		return;

  91. 	}

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

  93. 

  94. 	m_NoteMap[ID]=newnote;

  95. }

  96. 

  97. void  Pattern::RemoveNote(int ID)

  98. {

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

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

  101. 	{

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

  103. 		return;

  104. 	}

  105. 

  106. 	m_NoteMap.erase(i);

  107. }

  108. 

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

  110. {

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

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

  113. 	{

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

  115. 		return NULL;

  116. 	}

  117. 

  118. 	return &i->second;

  119. }

  120. 

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

  122. {

  123. 	int version=1,Num;

  124. 	string dummy;

  125. 	int id=0;

  126. 	s>>version>>dummy>>Num;

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

  128. 	{

  129. 		Note t;

  130. 		s>>t;

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

  132. 	}

  133. 

  134. 	return s;

  135. }

  136. 

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

  138. {

  139. 	int version=1;

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

  141. 

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

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

  144. 	{

  145. 		s<<i->second;

  146. 	}

  147. 	s<<endl;

  148. 

  149. 	return s;

  150. }

  151. 

  152. //////////////////////////////////////////////////////////////////////////

  153. 

  154. Sequence::Sequence(float st, int pat)

  155. {

  156. 	m_StartTime=st;

  157. 	m_Pattern=pat;

  158. }

  159. 

  160. Sequence::~Sequence()

  161. {

  162. }

  163. 

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

  165. {

  166. 	int version=1;

  167. 	string dummy;

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

  169. 	

  170. 	char Buf[4096];

  171. 	int size;

  172. 	s>>size;

  173. 	s.ignore(1);

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

  175. 	o.m_Name=Buf;

  176. 	

  177. 	return s;

  178. }

  179. 

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

  181. {	

  182. 	int version=1;

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

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

  185. 	

  186. 	return s;

  187. }	

  188. 

  189. //////////////////////////////////////////////////////////////////////////

  190. 

  191. Track::Track()

  192. {

  193. 	m_NextPatternID=0;

  194. }

  195. 

  196. Track::~Track()

  197. {

  198. }

  199. 

  200. void Track::AddSequence(int ID)

  201. {

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

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

  204. 	{

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

  206. 		return;

  207. 	}

  208. 		

  209. 	Sequence newsequence;

  210. 	AddPattern(m_NextPatternID);

  211. 	newsequence.SetPatternID(m_NextPatternID);

  212. 	newsequence.SetColour(0);

  213. 	newsequence.SetName("noname");

  214. 	newsequence.SetLength(10.0f);

  215. 	newsequence.SetYPos(1);	

  216. 	newsequence.SetChannel(0);

  217. 	m_NextPatternID++;

  218. 	

  219. 	m_SequenceMap[ID]=newsequence;

  220. }

  221. 

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

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

  224. {

  225. 	AddSequence(nID);

  226. 	Sequence *s=GetSequence(nID);

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

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

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

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

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

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

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

  234. }

  235. 

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

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

  238. {

  239. 	AddSequence(nID);

  240. 	Sequence *s=GetSequence(nID);

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

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

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

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

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

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

  247. 	AddPattern(m_NextPatternID);

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

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

  250. 	m_NextPatternID++;

  251. }

  252. 

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

  254. void Track::InstanceSequence(int ID)

  255. {

  256. 	AddPattern(m_NextPatternID);

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

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

  259. 	m_NextPatternID++;

  260. }

  261. 

  262. void Track::RemoveSequence(int ID)

  263. {

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

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

  266. 	{

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

  268. 		return;

  269. 	}

  270. 	

  271. 	// todo - refcount the patterns

  272. 	

  273. 	m_SequenceMap.erase(i);

  274. }

  275. 

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

  277. {

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

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

  280. 	{

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

  282. 		return NULL;

  283. 	}

  284. 	

  285. 	return &i->second;

  286. }

  287. 

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

  289. {

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

  291. }

  292. 

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

  294. {

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

  296. }

  297. 

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

  299. {

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

  301. 	note->Time = t;

  302. 	note->Length = l;

  303. 	note->MidiNote = n;

  304. 	note->Vol  = v;

  305. }

  306. 	

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

  308. {

  309. 	// for every sequence

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

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

  312. 	{

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

  314. 		{

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

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

  317. 		

  318. 			// for every note in the pattern

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

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

  321. 			{

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

  323. 				{

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

  325. 				}

  326. 			}

  327. 		}

  328. 	}

  329. }

  330. 

  331. //// private //////

  332. 

  333. void Track::AddPattern(int ID)

  334. {

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

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

  337. 	{

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

  339. 		return;

  340. 	}

  341. 	Pattern newpattern;

  342. 	m_PatternMap[ID]=newpattern;

  343. }

  344. 

  345. void Track::RemovePattern(int ID)

  346. {

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

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

  349. 	{

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

  351. 		return;

  352. 	}

  353. 	

  354. 	m_PatternMap.erase(i);

  355. }

  356. 

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

  358. {

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

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

  361. 	{

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

  363. 		return NULL;

  364. 	}

  365. 	

  366. 	return &i->second;

  367. }

  368. 

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

  370. {

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

  372. 	string dummy;

  373. 	s>>version>>dummy;

  374. 	

  375. 	s>>Num;

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

  377. 	{

  378. 		Pattern t;

  379. 		s>>t;

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

  381. 	}

  382. 	s>>Num;

  383. 	id=0;

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

  385. 	{

  386. 		Sequence t;

  387. 		s>>t;

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

  389. 		

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

  391. 	}

  392. 	s>>o.m_NextPatternID;

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

  394. 	return s;

  395. }

  396. 

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

  398. {	

  399. 	int version=1;

  400. 	

  401. 	s<<version<<" "<<"track"<<" ";

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

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

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

  405. 	{

  406. 		s<<i->second;

  407. 	}	

  408. 	

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

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

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

  412. 	{

  413. 		s<<i->second;

  414. 	}

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

  416. 	return s;

  417. }	

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

  419. ////////////////////////////////////////////////////////////////////////////////////

  420. 

  421. extern "C" {

  422. SpiralPlugin* SpiralPlugin_CreateInstance()

  423. {

  424. 	return new SequencerPlugin;

  425. }

  426. 

  427. char** SpiralPlugin_GetIcon()

  428. {

  429. 	return SpiralIcon_xpm;

  430. }

  431. 

  432. int SpiralPlugin_GetID()

  433. {

  434. 	return 0x0011;

  435. }

  436. 

  437. string SpiralPlugin_GetGroupName()

  438. {

  439. 	return "Sequencing";

  440. }

  441. }

  442. 

  443. ///////////////////////////////////////////////////////

  444. 

  445. SequencerPlugin::SequencerPlugin() :

  446. m_TransferPattern(-1),

  447. m_Time(0.0f),

  448. m_Length(4),

  449. m_BarLength(1.0f),

  450. m_BeatsPerBar(4),

  451. m_NextBeatTime(0.0f),

  452. m_BeatLevel(-1.0f),

  453. m_BeatCount(0),

  454. m_BarCount(0),

  455. m_SpeedMod(1.0f),

  456. m_InNoteDown(false),

  457. m_InNoteID(0),

  458. m_CurrentPattern(0),

  459. m_Triggered(false)

  460. {

  461. 	m_Version=1;

  462. 	

  463. 	m_PluginInfo.Name="Sequencer";

  464. 	m_PluginInfo.Width=540;

  465. 	m_PluginInfo.Height=290;

  466. 	m_PluginInfo.NumInputs=4;

  467. 	m_PluginInfo.NumOutputs=17;		

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  505. 	

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

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

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

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

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

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

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

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

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

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

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

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

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

  519. 	

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

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

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

  523. }

  524. 

  525. SequencerPlugin::~SequencerPlugin()

  526. {

  527. }

  528. 

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

  530. {	

  531. 	return SpiralPlugin::Initialise(Host);

  532. }

  533. 

  534. SpiralGUIType *SequencerPlugin::CreateGUI()

  535. {

  536. 	return new SequencerPluginGUI(m_PluginInfo.Width,

  537. 								  	    m_PluginInfo.Height,

  538. 										this,m_AudioCH,m_HostInfo);

  539. }

  540. 

  541. void SequencerPlugin::SetPattern(int s)          

  542. { 

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

  544. 	m_CurrentPattern=s;

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

  546. }

  547. 

  548. 

  549. void SequencerPlugin::Execute()

  550. {	

  551. 	float Speed;

  552. 	

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

  554. 	{

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

  556. 		{						

  557. 			if (!m_Triggered)

  558. 			{

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

  560. 		

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

  562. 				// No other notes catered for

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

  564. 				{

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

  566. 					{

  567. 						SetPattern(i);

  568. 						break;

  569. 					}

  570. 				}

  571. 				

  572. 				m_Time=0;

  573. 				m_Triggered=true;

  574. 			}

  575. 		}

  576. 		else

  577. 		{

  578. 			m_Triggered=false;

  579. 		}

  580. 

  581. 		

  582. 		if (InputExists(1))

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

  584. 		else

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

  586. 		

  587. 		if (!m_InNoteDown)

  588. 		{

  589. 			// Check trigger

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

  591. 			{

  592. 				m_InNoteDown=true;

  593. 				

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

  595. 

  596. 				int NoteNum=0;				

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

  598. 				{

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

  600. 					{				

  601. 						NoteNum=i;

  602. 						break;

  603. 					}

  604. 				}

  605. 				

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

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

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

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

  610. 				*/

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

  612. 				

  613. 				m_InNoteTime=m_Time;

  614. 			}			

  615. 		}

  616. 		else

  617. 		{

  618. 			// Check trigger

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

  620. 			{

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

  622. 				m_InNoteDown=false;

  623. 			}		

  624. 		}		

  625. 		

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

  627. 		{

  628. 			// Get the notes from the map		

  629. 			vector<Note> NoteVec;

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

  631. 			

  632. 			m_CurrentTriggerCV[channel]=0;

  633. 			//m_CurrentNoteCV=0;

  634. 			

  635. 			// play all the notes found

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

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

  638. 			{

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

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

  641. 								

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

  643. 				m_CurrentTriggerCV[channel]=1;			

  644. 			}

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

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

  647. 		}

  648. 	

  649. 		m_Time+=Speed*m_SpeedMod;

  650. 		

  651. 		// deal with the beat calculation

  652. 		if (m_Time>m_NextBeatTime)

  653. 		{

  654. 			float BeatTime=m_BarLength/m_BeatsPerBar;

  655. 			m_NextBeatTime=m_Time+BeatTime;

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

  657. 			else m_BeatLevel=-1.0f;

  658. 			

  659. 			m_BeatCount++;	

  660. 		}

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

  662. 		

  663. 		if (m_BeatCount>=m_BeatsPerBar) 

  664. 		{

  665. 			m_BeatCount=0;

  666. 			m_BarCount++;

  667. 		}

  668. 		

  669. 		if (m_BarCount>=m_Length)

  670. 		{

  671. 			m_Time=0;

  672. 			m_BeatCount=-1;

  673. 			m_BarCount=0;

  674. 			m_NextBeatTime=0;

  675. 		}

  676. 		

  677. 		if (m_Time<0)

  678. 		{

  679. 			m_Time=m_Length;

  680. 		}

  681. 	}

  682. }

  683. 

  684. void SequencerPlugin::ExecuteCommands()

  685. {

  686. 	if (m_AudioCH->IsCommandWaiting())

  687. 	{

  688. 		switch (m_AudioCH->GetCommand())

  689. 		{

  690. 			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;

  691. 			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;

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

  693. 			case NEW_SEQ     : 

  694. 			{	

  695. 				m_Track.AddSequence(m_GUIArgs.Num); 

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

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

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

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

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

  701. 			} break;

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

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

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

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

  706. 			case CHG_SEQ     : 

  707. 			{

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

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

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

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

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

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

  714. 			} break;

  715. 			case GET_PATTERN : 

  716. 			{

  717. 				// start of transfer

  718. 				if (m_TransferPattern==-1) 

  719. 				{

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

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

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

  723. 					

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

  725. 				}

  726. 				else

  727. 				{

  728. 					// last note gone

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

  730. 					{

  731. 						m_TransferPattern=-1;

  732. 					}

  733. 					else

  734. 					{

  735. 						// copy this note over

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

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

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

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

  740. 					

  741. 						m_TransferNote++;

  742. 					}

  743. 				}

  744. 			} break;

  745. 		 	default: break;

  746. 		}

  747. 	}

  748. }

  749. 

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

  751. {

  752. 	s<<m_Version<<" ";

  753. 	

  754. 	switch (m_Version)

  755. 	{

  756. 		case 1:

  757. 		{

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

  759. 			s<<m_Track;

  760. 		} break;

  761. 	}

  762. }

  763. 

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

  765. {

  766. 	int version;

  767. 	s>>version;

  768. 	

  769. 	switch (version)

  770. 	{

  771. 		case 1:

  772. 		{

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

  774. 			s>>m_Track;

  775. 		} break;

  776. 	}

  777. }