non
/
spiralsynthmodular
mirror of https://github.com/original-male/spiralsynthmodular
1
0
Fork 0
Code Releases 0 Activity
Browse Source

StreamPlugin rewrite - Stereo fixed - new trigs for play stop and finished

master
edgeeffect 22 years ago
parent
6e5dd8c32a
commit
2c3a9161b7
4 changed files with 442 additions and 518 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +130
    -180
      SpiralSound/Plugins/StreamPlugin/StreamPlugin.C
  2. +39
    -69
      SpiralSound/Plugins/StreamPlugin/StreamPlugin.h
  3. +220
    -197
      SpiralSound/Plugins/StreamPlugin/StreamPluginGUI.C
  4. +53
    -72
      SpiralSound/Plugins/StreamPlugin/StreamPluginGUI.h

+ 130
- 180
SpiralSound/Plugins/StreamPlugin/StreamPlugin.C View File

@@ -50,38 +50,35 @@ string GetGroupName()
///////////////////////////////////////////////////////

StreamPlugin::StreamPlugin() :
m_SampleSize(256),
m_Pos(0),
m_StreamPos(0),
m_GlobalPos(0),
m_SampleRate (44100),
m_SampleSize (256),
m_StreamPos (0),
m_GlobalPos (0),
m_Pitch (1.0f),
m_SamplePos (-1),
m_Pos (0),
m_Mode(STOPM)
{
m_PluginInfo.Name="Stream";
m_PluginInfo.Width=245;
m_PluginInfo.Height=165;
m_PluginInfo.NumInputs=1;
m_PluginInfo.NumOutputs=2;
m_PluginInfo.PortTips.push_back("Pitch CV");
m_PluginInfo.PortTips.push_back("Left Out");
m_PluginInfo.PortTips.push_back("Right Out");
m_StreamDesc.Volume = 1.0f;
m_StreamDesc.Pitch = 1.0f;
m_StreamDesc.PitchMod = 1.0f;
m_StreamDesc.SamplePos = -1;
m_StreamDesc.Loop = false;
m_StreamDesc.Note = 0;
m_StreamDesc.Pathname = "None";
m_StreamDesc.TriggerUp = true;
m_StreamDesc.SampleRate = 44100;
m_StreamDesc.Stereo = false;

m_AudioCH->Register("Volume",&m_StreamDesc.Volume);
m_AudioCH->Register("Pitch",&m_StreamDesc.PitchMod,ChannelHandler::INPUT);
m_AudioCH->RegisterData("FileName",ChannelHandler::INPUT,&m_FileNameArg,sizeof(m_FileNameArg));
m_AudioCH->Register("Time",&m_TimeArg);
m_AudioCH->Register("TimeOut",&m_TimeOut,ChannelHandler::OUTPUT);
m_AudioCH->Register("MaxTime",&m_MaxTime,ChannelHandler::OUTPUT);
m_PluginInfo.Name = "Stream";
m_PluginInfo.Width = 245;
m_PluginInfo.Height = 165;
m_PluginInfo.NumInputs = 3;
m_PluginInfo.NumOutputs = 3;
m_PluginInfo.PortTips.push_back ("Pitch CV");
m_PluginInfo.PortTips.push_back ("Play Trigger");
m_PluginInfo.PortTips.push_back ("Stop Trigger");
m_PluginInfo.PortTips.push_back ("Left Out");
m_PluginInfo.PortTips.push_back ("Right Out");
m_PluginInfo.PortTips.push_back ("Finish Trigger");
m_GUIArgs.Volume = 1.0f;
m_GUIArgs.PitchMod = 1.0f;
m_AudioCH->Register ("Volume", &m_GUIArgs.Volume);
m_AudioCH->Register ("Pitch", &m_GUIArgs.PitchMod, ChannelHandler::INPUT);
m_AudioCH->RegisterData ("FileName", ChannelHandler::INPUT,
&m_GUIArgs.FileName, sizeof (m_GUIArgs.FileName));
m_AudioCH->Register ("Time", &m_GUIArgs.Time);
m_AudioCH->Register ("TimeOut", &m_GUIArgs.TimeOut, ChannelHandler::OUTPUT);
m_AudioCH->Register ("MaxTime", &m_GUIArgs.MaxTime, ChannelHandler::OUTPUT);
}

StreamPlugin::~StreamPlugin()
@@ -89,172 +86,125 @@ StreamPlugin::~StreamPlugin()
}

PluginInfo &StreamPlugin::Initialise(const HostInfo *Host)
{
{
PluginInfo& Info = SpiralPlugin::Initialise(Host);
return Info;
}

SpiralGUIType *StreamPlugin::CreateGUI()
{
return new StreamPluginGUI(m_PluginInfo.Width,
m_PluginInfo.Height,
this,m_AudioCH,m_HostInfo);
}

void StreamPlugin::Execute()
{
float CVPitch=0;
if (m_File.IsOpen())
{
for (int n=0; n<m_HostInfo->BUFSIZE; n++)
{
CVPitch=GetInput(0,n)*10.0f;
if (m_Pos<0)
{
m_Pos=m_SampleSize-1;
m_StreamPos-=m_SampleSize;
if (m_StreamPos<0)
{
m_StreamPos=m_File.GetSize()/2-m_SampleSize;
m_GlobalPos=m_StreamPos;
}
m_File.SeekToChunk(m_StreamPos);
m_File.LoadChunk(m_SampleSize, m_SampleL, m_SampleR);
}
else
{
if (m_Pos>=m_SampleSize)
{
//m_SampleSize=(int)(BUFSECONDS*m_HostInfo->SAMPLERATE*m_StreamDesc.PitchMod);
m_Pos=0;
m_StreamPos+=m_SampleSize;
if (m_StreamPos>=m_File.GetSize()/2)
{
m_StreamPos=0;
m_GlobalPos=0;
}
m_File.SeekToChunk(m_StreamPos);
m_File.LoadChunk(m_SampleSize, m_SampleL, m_SampleR);
}
}
SetOutput(0,n,m_SampleL[m_Pos]*m_StreamDesc.Volume);
SetOutput(1,n,m_SampleR[m_Pos]*m_StreamDesc.Volume);
m_Pos+=m_StreamDesc.PitchMod+CVPitch;
m_GlobalPos+=m_StreamDesc.PitchMod+CVPitch;
}

m_TimeOut=GetTime();
SpiralGUIType *StreamPlugin::CreateGUI() {
return new StreamPluginGUI(m_PluginInfo.Width, m_PluginInfo.Height, this, m_AudioCH, m_HostInfo);
}

void StreamPlugin::Execute() {
if (m_File.IsOpen()) {
for (int n=0; n<m_HostInfo->BUFSIZE; n++) {
bool FinTrig = false;
float CVPitch = GetInput(0, n)*10.0f;
if (GetInput (1, n) > 0) Play();
if (GetInput (2, n) > 0) Stop();
if (m_Pos<0) {
m_Pos = m_SampleSize - 1;
m_StreamPos -= m_SampleSize;
FinTrig = m_StreamPos < 0;
if (FinTrig) {
m_StreamPos = m_File.GetSize() - m_SampleSize;
m_GlobalPos = m_StreamPos;
}
m_File.SeekToChunk (m_StreamPos);
m_File.LoadChunk (m_SampleSize, m_SampleL, m_SampleR);
}
else if (m_Pos >= m_SampleSize) {
m_Pos = 0;
m_StreamPos += m_SampleSize;
FinTrig = m_StreamPos >= m_File.GetSize();
if (FinTrig) {
m_StreamPos = 0;
m_GlobalPos = 0;
}
m_File.SeekToChunk (m_StreamPos);
m_File.LoadChunk (m_SampleSize, m_SampleL, m_SampleR);
}
SetOutput (0, n, m_SampleL[m_Pos] * m_GUIArgs.Volume);
SetOutput (1, n, m_SampleR[m_Pos] * m_GUIArgs.Volume);
if (FinTrig) SetOutput (2, n, 1); else SetOutput (2, n, 0);
if (m_Mode==PLAYM) {
m_Pos += m_GUIArgs.PitchMod + CVPitch;
m_GlobalPos += m_GUIArgs.PitchMod + CVPitch;
}
}
m_GUIArgs.TimeOut = GetTime();
}
}

void StreamPlugin::ExecuteCommands() {
if (m_AudioCH->IsCommandWaiting()) {
switch (m_AudioCH->GetCommand()) {
case SET_TIME: SetTime(); break;
case LOAD: OpenStream(); break;
case RESTART: Restart(); break;
case STOP: Stop(); break;
case PLAY: Play(); break;
}
}
}

void StreamPlugin::ExecuteCommands()
{
if (m_AudioCH->IsCommandWaiting())
{
switch(m_AudioCH->GetCommand())
{
case (LOAD) : OpenStream(m_FileNameArg); break;
case (RESTART) : Restart(); break;
case (STOP) : Stop(); break;
case (PLAY) : Play(); break;
case (NUDGE) : Nudge(); break;
case (SET_TIME) : SetTime(m_TimeArg); break;
}
}
void StreamPlugin::SetTime (void) {
m_GlobalPos = m_SampleRate * m_GUIArgs.Time;
m_StreamPos = (int)(m_SampleRate * m_GUIArgs.Time);
m_Pos = m_SampleSize;
}

void StreamPlugin::StreamOut(ostream &s)
{
s<<m_Version<<" ";
s<<m_StreamDesc.Volume<<" "<<
m_StreamDesc.PitchMod<<" "<<
m_StreamDesc.Pathname.size()<<" "<<
m_StreamDesc.Pathname<<" ";
s<<m_Pos<<" ";
s<<m_StreamPos<<" ";
s<<m_GlobalPos<<" ";
s<<m_Pitch<<" "<<endl;
void StreamPlugin::OpenStream (void) {
m_StreamPos = 0;
m_GlobalPos = 0;
if (m_File.IsOpen ()) m_File.Close ();
m_File.Open (m_GUIArgs.FileName, WavFile::READ);
m_SampleL.Allocate (m_SampleSize);
m_SampleR.Allocate (m_SampleSize);
m_Pitch = m_SampleRate / (float)m_HostInfo->SAMPLERATE;
if (m_File.IsStereo ()) {
m_Pitch *= 2;
m_GUIArgs.MaxTime = GetLength();
}
else m_GUIArgs.MaxTime = GetLength() / 2;
}

void StreamPlugin::StreamIn(istream &s)
{
int version;
s>>version;
s>>m_StreamDesc.Volume>>
m_StreamDesc.PitchMod;
char Buf[4096];
int size;
s>>size;
s.ignore(1);
s.get(Buf,size+1);
m_StreamDesc.Pathname=Buf;
if (m_StreamDesc.Pathname!="None")
OpenStream(m_StreamDesc.Pathname);

s>>m_Pos;
s>>m_StreamPos;
s>>m_GlobalPos;
s>>m_Pitch;
float StreamPlugin::GetLength (void) {
if (m_File.IsStereo()) return m_File.GetSize() / (float)m_File.GetSamplerate ();
else return m_File.GetSize() / (float)m_File.GetSamplerate () * 2;
}

void StreamPlugin::OpenStream(const string &Name)
{
m_StreamPos=0;
m_GlobalPos=0;
if (m_File.IsOpen()) m_File.Close();
m_File.Open(Name,WavFile::READ);
m_SampleL.Allocate(m_SampleSize);
m_SampleR.Allocate(m_SampleSize);
m_StreamDesc.Pathname=Name;
m_StreamDesc.SampleRate=m_File.GetSamplerate();
m_StreamDesc.Stereo=m_File.IsStereo();
m_StreamDesc.Pitch = m_StreamDesc.SampleRate/(float)m_HostInfo->SAMPLERATE;
if (m_StreamDesc.Stereo)
{
m_StreamDesc.Pitch*=2;
m_MaxTime=GetLength();
}
else m_MaxTime=GetLength()/2;
void StreamPlugin::StreamOut (ostream &s) {
s << m_Version << " "
<< m_GUIArgs.Volume << " "
<< m_GUIArgs.PitchMod << " "
<< strlen (m_GUIArgs.FileName) << " "
<< m_GUIArgs.FileName << " "
// is it really necessary to save this lot??
<< m_Pos << " "
<< m_StreamPos << " "
<< m_GlobalPos << " "
<< m_Pitch << " " << endl;
}

void StreamPlugin::Restart()
{
m_StreamPos=0; m_GlobalPos=0;
}
void StreamPlugin::Play()
{
if (m_Mode==PLAYM) return;
m_StreamDesc.PitchMod=m_Pitch;
m_Mode=PLAYM;
}
void StreamPlugin::StreamIn(istream &s) {
int version;
s >> version;

void StreamPlugin::Stop()
{
if (m_Mode==STOPM) return;
m_Pitch=m_StreamDesc.PitchMod;
m_StreamDesc.PitchMod=0.0f;
m_Mode=STOPM;
s >> m_GUIArgs.Volume >> m_GUIArgs.PitchMod;
int size;
s >> size;
if (size > 255) size = 255;
s.ignore (1);
s.get (m_GUIArgs.FileName, size+1);
if (m_GUIArgs.FileName != "None") OpenStream ();
// is it really necessary to load this lot??
s >> m_Pos;
s >> m_StreamPos;
s >> m_GlobalPos;
s >> m_Pitch;
}

float StreamPlugin::GetLength()
{
if (m_StreamDesc.Stereo) return (m_File.GetSize()/(float)m_StreamDesc.SampleRate)*0.5f;
else return m_File.GetSize()/(float)m_StreamDesc.SampleRate;
}
void StreamPlugin::SetTime(float t)
{
m_GlobalPos=m_StreamDesc.SampleRate*t;
m_StreamPos=(int)(m_StreamDesc.SampleRate*t);
m_Pos=m_SampleSize;
}




+ 39
- 69
SpiralSound/Plugins/StreamPlugin/StreamPlugin.h View File

@@ -14,7 +14,7 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
*/

#include "../SpiralPlugin.h"
#include "../../RiffWav.h"
@@ -23,76 +23,46 @@
#ifndef StreamPLUGIN
#define StreamPLUGIN

static const int NUDGESIZE=44100/4;

struct SampleDesc
{
string Pathname;
class StreamPlugin : public SpiralPlugin {
public:
StreamPlugin();
virtual ~StreamPlugin();
virtual PluginInfo &Initialise (const HostInfo *Host);
virtual SpiralGUIType *CreateGUI();
virtual void Execute();
virtual void ExecuteCommands();
virtual void StreamOut (ostream &s);
virtual void StreamIn (istream &s);
enum GUICommands { NONE, SET_TIME, LOAD, RESTART, STOP, PLAY };
// has to be defined in the plugin
virtual void UpdateGUI() { Fl::check(); }
float GetVolume (void) { return m_GUIArgs.Volume; }
float GetPitch (void) { return m_GUIArgs.PitchMod; }
private:
struct GUIArgs {
float Volume;
float Pitch;
float PitchMod;
bool Loop;
int Note;
bool TriggerUp;
float SamplePos;
int SampleRate;
bool Stereo;
};

class StreamPlugin : public SpiralPlugin
{
public:
enum Mode{PLAYM,STOPM};

enum GUICommands{NONE,LOAD,RESTART,STOP,PLAY,HALF,RESET,DOUBLE,NUDGE,SET_TIME};

StreamPlugin();
virtual ~StreamPlugin();
virtual PluginInfo &Initialise(const HostInfo *Host);
virtual SpiralGUIType *CreateGUI();
virtual void Execute();
virtual void ExecuteCommands();
virtual void StreamOut(ostream &s);
virtual void StreamIn(istream &s);
// has to be defined in the plugin
virtual void UpdateGUI() { Fl::check(); }
void OpenStream(const string &Name);
void SetVolume(float s) { m_StreamDesc.Volume=s; }
float GetVolume() { return m_StreamDesc.Volume; }
void SetPitch(float s) { m_StreamDesc.PitchMod=s; }
float GetPitch() { return m_StreamDesc.PitchMod; }
void SetLoop(bool s) { m_StreamDesc.Loop=s; }
bool GetLoop() { return m_StreamDesc.Loop; }
float GetLength();
float GetTime() { return m_GlobalPos/(float)m_StreamDesc.SampleRate; }
void SetTime(float t);
void Nudge() { m_Pos-=NUDGESIZE; }
void Restart();
void Play();
void Stop();
private:
WavFile m_File;
Sample m_SampleL;
Sample m_SampleR;
SampleDesc m_StreamDesc;
int m_SampleSize;
float m_Pos;
int m_StreamPos;
float m_GlobalPos;
float m_Pitch;
Mode m_Mode;

char m_FileNameArg[256];
float m_TimeArg;
float m_TimeOut;
float m_MaxTime;
char FileName[256];
float Time;
float TimeOut;
float MaxTime;
};
GUIArgs m_GUIArgs;
WavFile m_File;
Sample m_SampleL, m_SampleR;
int m_SampleRate, m_SampleSize, m_StreamPos;
float m_GlobalPos, m_Pitch, m_SamplePos, m_Pos;
enum Mode { PLAYM, STOPM };
Mode m_Mode;
// Internal functions
float GetTime (void) { return m_GlobalPos / (float)m_SampleRate; }
float GetLength (void);
// Commands
void SetTime (void);
void OpenStream (void);
void Restart (void) { m_StreamPos = 0; m_GlobalPos = 0; }
void Stop (void) { m_Mode = STOPM; }
void Play (void) { m_Mode = PLAYM; }
};

#endif

+ 220
- 197
SpiralSound/Plugins/StreamPlugin/StreamPluginGUI.C View File

@@ -14,7 +14,7 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
*/

#include "StreamPluginGUI.h"
#include <FL/fl_draw.h>
@@ -24,86 +24,17 @@
static const int GUI_COLOUR = 179;
static const int GUIBG_COLOUR = 144;
static const int GUIBG2_COLOUR = 145;
char PitchLabel[256];

char PitchLabel[256];

////////////////////////////////////////////

StreamPluginGUI::StreamPluginGUI(int w, int h,StreamPlugin *o,ChannelHandler *ch,const HostInfo *Info) :
SpiralPluginGUI(w,h,o,ch)
{
m_PitchValue=1.0f;
m_TempPitch=1.0f;
m_Load = new Fl_Button(2, 130, 30, 30, "Load");
m_Load->labelsize(9);
m_Load->callback((Fl_Callback*)cb_Load);
add(m_Load);
int sx=32;
m_ToStart = new Fl_Button(sx, 130, 30, 30, "@|<");
m_ToStart->labelsize(10);
m_ToStart->labeltype(FL_SYMBOL_LABEL);
m_ToStart->callback((Fl_Callback*)cb_ToStart);
add(m_ToStart);
m_Stop = new Fl_Button(sx+30, 130, 30, 30, "@||");
m_Stop->labelsize(10);
m_Stop->labeltype(FL_SYMBOL_LABEL);
m_Stop->callback((Fl_Callback*)cb_Stop);
add(m_Stop);
m_Play = new Fl_Button(sx+60, 130, 30, 30, "@>");
m_Play->labelsize(10);
m_Play->labeltype(FL_SYMBOL_LABEL);
m_Play->callback((Fl_Callback*)cb_Play);
add(m_Play);
m_Div = new Fl_Button(sx+90, 130, 30, 30, "/2");
m_Div->labelsize(9);
m_Div->callback((Fl_Callback*)cb_Div);
add(m_Div);

m_Reset = new Fl_Button(sx+120, 130, 30, 30, "Reset");
m_Reset->labelsize(9);
m_Reset->callback((Fl_Callback*)cb_Reset);
add(m_Reset);
m_Loop = new Fl_Button(sx+150, 130, 30, 30, "X2");
m_Loop->labelsize(9);
m_Loop->callback((Fl_Callback*)cb_Loop);
add(m_Loop);
m_Nudge = new Fl_Repeat_Button(sx+180, 130, 30, 30, "Nudge");
m_Nudge->labelsize(9);
m_Nudge->callback((Fl_Callback*)cb_Nudge);
add(m_Nudge);
m_Volume = new Fl_Knob (180, 15, 50, 50, "Volume");
m_Volume->color(GUI_COLOUR);
m_Volume->type(Fl_Knob::LINELIN);
m_Volume->labelsize(10);
m_Volume->maximum(2);
m_Volume->step(0.001);
m_Volume->value(1);
m_Volume->callback((Fl_Callback*)cb_Volume);
add(m_Volume);
m_Pitch = new Fl_Slider(5,85,235,20, "");
m_Pitch->type(FL_HORIZONTAL);
m_Pitch->align(FL_ALIGN_INSIDE | FL_ALIGN_RIGHT);
m_Pitch->labelsize(10);
m_Pitch->labelcolor(GUI_COLOUR);
m_Pitch->maximum(20);
m_Pitch->step(0.001);
sprintf(PitchLabel,"%1.3f ",1.0);
m_Pitch->label(PitchLabel);
m_Pitch->value(11);
m_Pitch->callback((Fl_Callback*)cb_Pitch);
add(m_Pitch);

for (int dis=0; dis<6; dis++) {
SpiralPluginGUI(w,h,o,ch),
m_PitchValue (1.0f)
{
// 7 seg displays
for (int dis=0; dis<6; dis++) {
m_Display[dis] = new Fl_SevenSeg (5 + 28*dis, 20, 28, 60);
m_Display[dis] -> bar_width (4);
m_Display[dis] -> color (FL_WHITE);
@@ -111,160 +42,252 @@ SpiralPluginGUI(w,h,o,ch)
if (dis > 0 && dis % 2 == 0) m_Display[dis] -> dp (colon);
add (m_Display[dis]);
}
// volume control
m_Volume = new Fl_Knob (180, 15, 50, 50, "Volume");
m_Volume->color (GUI_COLOUR);
m_Volume->type (Fl_Knob::LINELIN);
m_Volume->labelsize (10);
m_Volume->maximum (2);
m_Volume->step (0.001);
m_Volume->value (1);
m_Volume->callback ((Fl_Callback*)cb_Volume);
add (m_Volume);
// pitch indicator
m_Pitch = new Fl_Slider (5, 85, 235, 20, "");
m_Pitch->type (FL_HORIZONTAL);
m_Pitch->align (FL_ALIGN_INSIDE | FL_ALIGN_RIGHT);
m_Pitch->labelsize (10);
m_Pitch->labelcolor (GUI_COLOUR);
m_Pitch->maximum (20);
m_Pitch->step (0.001);
UpdatePitch (true, false, false);
m_Pitch->callback ((Fl_Callback*)cb_Pitch);
add (m_Pitch);
// position indicator
m_Pos = new Fl_Slider (5, 108, 235, 20, "");
m_Pos->type (FL_HORIZONTAL);
m_Pos->maximum (1);
m_Pos->callback ((Fl_Callback*)cb_Pos);
add (m_Pos);
// load btn
m_Load = new Fl_Button (2, 130, 30, 30, "Load");
m_Load->labelsize (9);
m_Load->callback ((Fl_Callback*)cb_Load);
add (m_Load);
// reset btn
m_ToStart = new Fl_Button (32, 130, 30, 30, "@|<");
m_ToStart->labelsize (10);
m_ToStart->labeltype (FL_SYMBOL_LABEL);
m_ToStart->callback ((Fl_Callback*)cb_ToStart);
add (m_ToStart);
// stop btn
m_Stop = new Fl_Button (62, 130, 30, 30, "@||");
m_Stop->labelsize (10);
m_Stop->labeltype (FL_SYMBOL_LABEL);
m_Stop->callback ((Fl_Callback*)cb_Stop);
add (m_Stop);
// play btn
m_Play = new Fl_Button (92, 130, 30, 30, "@>");
m_Play->labelsize (10);
m_Play->labeltype (FL_SYMBOL_LABEL);
m_Play->callback ((Fl_Callback*)cb_Play);
add (m_Play);
// 1/2 speed btn
m_Div = new Fl_Button (122, 130, 30, 30, "/2");
m_Div->labelsize (9);
m_Div->callback ((Fl_Callback*)cb_Div);
add (m_Div);
// normal speed btn
m_Reset = new Fl_Button (152, 130, 30, 30, "Reset");
m_Reset->labelsize (9);
m_Reset->callback ((Fl_Callback*)cb_Reset);
add (m_Reset);
// dbl speed btn
m_Dbl = new Fl_Button (182, 130, 30, 30, "X2");
m_Dbl->labelsize (9);
m_Dbl->callback ((Fl_Callback*)cb_Dbl);
add (m_Dbl);
// nudge btn
m_Nudge = new Fl_Repeat_Button (212, 130, 30, 30, "Nudge");
m_Nudge->labelsize (9);
m_Nudge->callback ((Fl_Callback*)cb_Nudge);
add (m_Nudge);
}

StreamPluginGUI::~StreamPluginGUI () {
}

m_Pos = new Fl_Slider(5,108,235,20,"");
m_Pos->type(FL_HORIZONTAL);
m_Pos->maximum(1);
m_Pos->callback((Fl_Callback*)cb_Pos);
add(m_Pos);
// Update signalled from plugin

end();
void StreamPluginGUI::Update() {
float t=m_GUICH->GetFloat ("TimeOut");
m_Pos->value (t);
m_Display[5]->value ((int)(t*100) % 10);
m_Display[4]->value ((int)(t*10) % 10);
m_Display[3]->value ((int)t % 10);
m_Display[2]->value ((int)(t/10) % 6);
m_Display[1]->value ((int)(t/60) % 10);
m_Display[0]->value ((int)(t/600) % 10);
redraw();
SetMaxTime (m_GUICH->GetFloat ("MaxTime"));
}

StreamPluginGUI::~StreamPluginGUI()
{
// Update GUI on load

void StreamPluginGUI::UpdateValues (SpiralPlugin *o) {
StreamPlugin *Plugin = (StreamPlugin*)o;
m_Volume->value (Plugin->GetVolume());
m_Pitch->value (Plugin->GetPitch()+10);
}

void StreamPluginGUI::Update()
{
float t=m_GUICH->GetFloat("TimeOut");
// volume

m_Pos->value(t);
inline void StreamPluginGUI::cb_Volume_i (Fl_Knob* o, void* v) {
m_GUICH->Set ("Volume", (float)o->value ());
}

m_Display[5]->value((int)(t*100)%10);
m_Display[4]->value((int)(t*10)%10);
void StreamPluginGUI::cb_Volume (Fl_Knob* o, void* v) {
((StreamPluginGUI*)(o->parent ()))->cb_Volume_i (o, v);
}

m_Display[3]->value((int)t%10);
m_Display[2]->value((int)(t/10)%6);
// pitch

m_Display[1]->value((int)(t/60)%10);
m_Display[0]->value((int)(t/600)%10);
redraw();
void StreamPluginGUI::UpdatePitch (bool UpdateIt = true, bool DrawIt = true, bool SendIt = true) {
sprintf( PitchLabel, "%1.3f ", m_PitchValue);
m_Pitch->label (PitchLabel);
if (UpdateIt) m_Pitch->value (m_PitchValue+10);
if (DrawIt) redraw();
if (SendIt) m_GUICH->Set ("Pitch", m_PitchValue);
}

SetMaxTime(m_GUICH->GetFloat("MaxTime"));
inline void StreamPluginGUI::cb_Pitch_i (Fl_Slider* o, void* v) {
m_PitchValue=o->value()-10;
UpdatePitch (false, false);
}

void StreamPluginGUI::cb_Pitch (Fl_Slider* o, void* v) {
((StreamPluginGUI*)(o->parent ()))->cb_Pitch_i(o,v);
}

void StreamPluginGUI::UpdateValues(SpiralPlugin *o)
{
StreamPlugin *Plugin = (StreamPlugin*)o;
// position

inline void StreamPluginGUI::cb_Pos_i (Fl_Slider* o, void* v) {
m_GUICH->Set ("Time",(float)o->value());
m_GUICH->SetCommand (StreamPlugin::SET_TIME);
}

m_Volume->value(Plugin->GetVolume());
m_Pitch->value(Plugin->GetPitch()+10);
m_Loop->value(Plugin->GetLoop());
void StreamPluginGUI::cb_Pos (Fl_Slider* o, void* v) {
((StreamPluginGUI*)(o->parent ()))->cb_Pos_i (o, v);
}
inline void StreamPluginGUI::cb_Load_i(Fl_Button* o, void* v)
{
char *fn=fl_file_chooser("Load a sample", "{*.wav,*.WAV}", NULL);
if (fn && fn!='\0')
{
strcpy(m_TextBuf,fn);
m_GUICH->SetData("FileName",(void*)m_TextBuf);
m_GUICH->SetCommand(StreamPlugin::LOAD);
m_GUICH->Wait();
SetMaxTime(m_GUICH->GetFloat("MaxTime"));

// load

inline void StreamPluginGUI::cb_Load_i (Fl_Button* o, void* v) {
char *fn=fl_file_chooser("Load a sample", "{*.wav,*.WAV}", NULL);
if (fn && fn!='\0') {
strcpy (m_TextBuf, fn);
m_GUICH->SetData ("FileName", (void*)m_TextBuf);
m_GUICH->SetCommand (StreamPlugin::LOAD);
m_GUICH->Wait();
SetMaxTime (m_GUICH->GetFloat ("MaxTime"));
}
}
void StreamPluginGUI::cb_Load(Fl_Button* o, void* v)
{ ((StreamPluginGUI*)(o->parent()))->cb_Load_i(o,v);}

inline void StreamPluginGUI::cb_Volume_i(Fl_Knob* o, void* v)
{ m_GUICH->Set("Volume",(float)o->value()); }
void StreamPluginGUI::cb_Volume(Fl_Knob* o, void* v)
{ ((StreamPluginGUI*)(o->parent()))->cb_Volume_i(o,v);}

inline void StreamPluginGUI::cb_Pitch_i(Fl_Slider* o, void* v)
{
m_GUICH->Set("Pitch",(float)o->value()-10);
sprintf(PitchLabel,"%1.3f ",o->value()-10);
m_Pitch->label(PitchLabel);
m_PitchValue=o->value()-10;

void StreamPluginGUI::cb_Load (Fl_Button* o, void* v) {
((StreamPluginGUI*)(o->parent ()))->cb_Load_i (o, v);
}
void StreamPluginGUI::cb_Pitch(Fl_Slider* o, void* v)
{ ((StreamPluginGUI*)(o->parent()))->cb_Pitch_i(o,v);}

inline void StreamPluginGUI::cb_Loop_i(Fl_Button* o, void* v) //Why is this function named so.
{
m_PitchValue*=2.0f;
m_GUICH->Set("Pitch",m_PitchValue);
sprintf(PitchLabel,"%1.3f ",m_PitchValue);
m_Pitch->label(PitchLabel);
m_Pitch->value(m_PitchValue+10);
redraw();

// restart

inline void StreamPluginGUI::cb_ToStart_i (Fl_Button* o, void* v) {
m_GUICH->SetCommand (StreamPlugin::RESTART);
}
void StreamPluginGUI::cb_Loop(Fl_Button* o, void* v)
{ ((StreamPluginGUI*)(o->parent()))->cb_Loop_i(o,v);}

inline void StreamPluginGUI::cb_Div_i(Fl_Button* o, void* v)
{
m_PitchValue/=2.0f;
m_GUICH->Set("Pitch",m_PitchValue);
sprintf(PitchLabel,"%1.3f ",m_PitchValue);
m_Pitch->label(PitchLabel);
m_Pitch->value(m_PitchValue+10);
redraw();

void StreamPluginGUI::cb_ToStart (Fl_Button* o, void* v) {
((StreamPluginGUI*)(o->parent ()))->cb_ToStart_i (o, v);
}
void StreamPluginGUI::cb_Div(Fl_Button* o, void* v)
{ ((StreamPluginGUI*)(o->parent()))->cb_Div_i(o,v);}

inline void StreamPluginGUI::cb_ToStart_i(Fl_Button* o, void* v)
{ m_GUICH->SetCommand(StreamPlugin::RESTART); }
void StreamPluginGUI::cb_ToStart(Fl_Button* o, void* v)
{ ((StreamPluginGUI*)(o->parent()))->cb_ToStart_i(o,v);}

inline void StreamPluginGUI::cb_Stop_i(Fl_Button* o, void* v)
{
m_TempPitch=m_PitchValue;
m_PitchValue=0;
m_GUICH->Set("Pitch",m_PitchValue);

// stop

inline void StreamPluginGUI::cb_Stop_i (Fl_Button* o, void* v) {
m_GUICH->SetCommand (StreamPlugin::STOP);
}
void StreamPluginGUI::cb_Stop(Fl_Button* o, void* v)
{ ((StreamPluginGUI*)(o->parent()))->cb_Stop_i(o,v);}

inline void StreamPluginGUI::cb_Play_i(Fl_Button* o, void* v)
{
m_PitchValue=m_TempPitch;
m_GUICH->Set("Pitch",m_PitchValue);
void StreamPluginGUI::cb_Stop (Fl_Button* o, void* v) {
((StreamPluginGUI*)(o->parent ()))->cb_Stop_i (o, v);
}
void StreamPluginGUI::cb_Play(Fl_Button* o, void* v)
{ ((StreamPluginGUI*)(o->parent()))->cb_Play_i(o,v);}

inline void StreamPluginGUI::cb_Reset_i(Fl_Button* o, void* v)
{
m_GUICH->Set("Pitch",1.0f);
sprintf(PitchLabel,"%1.3f ",1.0);
m_Pitch->label(PitchLabel);
m_Pitch->value(11);
m_PitchValue=1.0f;
redraw();

// play

inline void StreamPluginGUI::cb_Play_i (Fl_Button* o, void* v) {
m_GUICH->SetCommand (StreamPlugin::PLAY);
}
void StreamPluginGUI::cb_Reset(Fl_Button* o, void* v)
{ ((StreamPluginGUI*)(o->parent()))->cb_Reset_i(o,v);}

inline void StreamPluginGUI::cb_Nudge_i(Fl_Button* o, void* v)
{
m_GUICH->SetCommand(StreamPlugin::NUDGE);
void StreamPluginGUI::cb_Play (Fl_Button* o, void* v) {
((StreamPluginGUI*)(o->parent ()))->cb_Play_i (o, v);
}
void StreamPluginGUI::cb_Nudge(Fl_Button* o, void* v)
{ ((StreamPluginGUI*)(o->parent()))->cb_Nudge_i(o,v);}

inline void StreamPluginGUI::cb_Pos_i(Fl_Slider* o, void* v)
{
m_GUICH->Set("Time",(float)o->value());
m_GUICH->SetCommand(StreamPlugin::SET_TIME);
// div 2

inline void StreamPluginGUI::cb_Div_i (Fl_Button* o, void* v) {
m_PitchValue /= 2.0f;
UpdatePitch ();
}

void StreamPluginGUI::cb_Div (Fl_Button* o, void* v) {
((StreamPluginGUI*)(o->parent()))->cb_Div_i (o, v);
}
void StreamPluginGUI::cb_Pos(Fl_Slider* o, void* v)
{ ((StreamPluginGUI*)(o->parent()))->cb_Pos_i(o,v);}

const string StreamPluginGUI::GetHelpText(const string &loc){
return string("")
+ "If you want to mix whole tracks and add effects etc, then this is the\n"
+ "way to do it. The StreamPlugin loads a wav in bit by bit, so it doesn't\n"
// reset

inline void StreamPluginGUI::cb_Reset_i (Fl_Button* o, void* v) {
m_PitchValue = 1.0f;
UpdatePitch ();
}

void StreamPluginGUI::cb_Reset (Fl_Button* o, void* v) {
((StreamPluginGUI*)(o->parent ()))->cb_Reset_i (o, v);
}

// mul 2

inline void StreamPluginGUI::cb_Dbl_i (Fl_Button* o, void* v) {
m_PitchValue *= 2.0f;
UpdatePitch ();
}

void StreamPluginGUI::cb_Dbl (Fl_Button* o, void* v) {
((StreamPluginGUI*)(o->parent ()))->cb_Dbl_i (o, v);
}

//nudge

inline void StreamPluginGUI::cb_Nudge_i (Fl_Button* o, void* v) {
int NudgeSize = 1;
if (m_PitchValue < 0) NudgeSize = -NudgeSize;
float P = m_Pos->value() + NudgeSize;
if (P < 0) P = 0;
if (P > m_Pos->maximum()) P = m_Pos->maximum();
m_Pos->value (P);
m_GUICH->Set ("Time", P);
m_GUICH->SetCommand (StreamPlugin::SET_TIME);
}

void StreamPluginGUI::cb_Nudge (Fl_Button* o, void* v) {
((StreamPluginGUI*)(o->parent ()))->cb_Nudge_i (o, v);
}

// help text

const string StreamPluginGUI::GetHelpText (const string &loc){
return string("")
+ "If you want to mix whole tracks and add effects etc, then this is the\n"
+ "way to do it. The StreamPlugin loads a wav in bit by bit, so it doesn't\n"
+ "use much memory. The track can be pitched for mixing.\n"
+ "Operates pretty much like a media player such as XMMS (only wav\n"
+ "format though).\n\n"
+ "Connect the finish trigger to the stop trigger to play the wav only\nonce.\n\n"
+ "Note: Not realtime safe, if you're using JACK, use a client such as\n"
+ "alsaplayer.";
}


+ 53
- 72
SpiralSound/Plugins/StreamPlugin/StreamPluginGUI.h View File

@@ -14,90 +14,71 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
*/

#include <FL/Fl.H>
#include <FL/Fl_Window.H>
#include <FL/Fl_Group.H>
#include <FL/Fl_Counter.H>
#include <FL/Fl_Slider.H>
#include <FL/Fl_Output.H>
#include <FL/Fl_Repeat_Button.H>

#include "StreamPlugin.h"
#include "../SpiralPluginGUI.h"
#include "../Widgets/Fl_Knob.H"
#include "../Widgets/Fl_SevenSeg.H"
#include "../Widgets/Fl_Knob.H"

#ifndef MixerGUI
#define MixerGUI

class StreamPluginGUI;

class StreamPluginGUI : public SpiralPluginGUI
{
public:
StreamPluginGUI(int w, int h, StreamPlugin *o,ChannelHandler *ch,const HostInfo *Info);
virtual ~StreamPluginGUI();
virtual void Update();
virtual void UpdateValues(SpiralPlugin *o);
//void SetTime();
void SetMaxTime(float t) { m_Pos->maximum(t); }

protected:
const string GetHelpText(const string &loc);
private:
Fl_Button* m_Load;
Fl_Knob* m_Volume;
Fl_Slider* m_Pitch;
Fl_Button* m_Loop;
Fl_Button* m_ToStart;
Fl_Button* m_Stop;
Fl_Button* m_Play;
Fl_Button* m_Reset;
Fl_Button* m_Div;
Fl_Repeat_Button* m_Nudge;
Fl_Output* m_Pout;
Fl_SevenSeg* m_Display[6];
Fl_Slider* m_Pos;

char m_TextBuf[256];

float m_PitchValue;
float m_TempPitch;
//// Callbacks ////
inline void cb_Load_i(Fl_Button* o, void* v);
static void cb_Load(Fl_Button* o, void* v);
inline void cb_Volume_i(Fl_Knob* o, void* v);
static void cb_Volume(Fl_Knob* o, void* v);
inline void cb_Pitch_i(Fl_Slider* o, void* v);
static void cb_Pitch(Fl_Slider* o, void* v);
inline void cb_Loop_i(Fl_Button* o, void* v);
static void cb_Loop(Fl_Button* o, void* v);
inline void cb_Div_i(Fl_Button* o, void* v);
static void cb_Div(Fl_Button* o, void* v);

inline void cb_ToStart_i(Fl_Button* o, void* v);
static void cb_ToStart(Fl_Button* o, void* v);
inline void cb_Stop_i(Fl_Button* o, void* v);
static void cb_Stop(Fl_Button* o, void* v);
inline void cb_Play_i(Fl_Button* o, void* v);
static void cb_Play(Fl_Button* o, void* v);
inline void cb_Reset_i(Fl_Button* o, void* v);
static void cb_Reset(Fl_Button* o, void* v);
inline void cb_Nudge_i(Fl_Button* o, void* v);
static void cb_Nudge(Fl_Button* o, void* v);

inline void cb_Pos_i(Fl_Slider* o, void* v);
static void cb_Pos(Fl_Slider* o, void* v);
#ifndef StreamGUI
#define StreamGUI

class StreamPluginGUI : public SpiralPluginGUI {
public:
StreamPluginGUI(int w, int h, StreamPlugin *o, ChannelHandler *ch, const HostInfo *Info);
virtual ~StreamPluginGUI ();
virtual void Update ();
virtual void UpdateValues (SpiralPlugin *o);
protected:
const string GetHelpText (const string &loc);
private:
float m_PitchValue;
char m_TextBuf[256];
void SetMaxTime (float t) { m_Pos->maximum(t); }
void UpdatePitch (bool UpdateIt = true, bool DrawIt = true, bool SendIt = true);
// Widgets
Fl_SevenSeg* m_Display[6];
Fl_Knob* m_Volume;
Fl_Slider* m_Pitch;
Fl_Slider* m_Pos;
Fl_Button* m_Load;
Fl_Button* m_ToStart;
Fl_Button* m_Stop;
Fl_Button* m_Play;
Fl_Button* m_Div;
Fl_Button* m_Reset;
Fl_Button* m_Dbl;
Fl_Repeat_Button* m_Nudge;
//// Callbacks ////
inline void cb_Volume_i (Fl_Knob* o, void* v);
static void cb_Volume (Fl_Knob* o, void* v);
inline void cb_Pitch_i (Fl_Slider* o, void* v);
static void cb_Pitch (Fl_Slider* o, void* v);
inline void cb_Pos_i (Fl_Slider* o, void* v);
static void cb_Pos (Fl_Slider* o, void* v);
inline void cb_Load_i (Fl_Button* o, void* v);
static void cb_Load (Fl_Button* o, void* v);
inline void cb_ToStart_i (Fl_Button* o, void* v);
static void cb_ToStart (Fl_Button* o, void* v);
inline void cb_Stop_i (Fl_Button* o, void* v);
static void cb_Stop (Fl_Button* o, void* v);
inline void cb_Play_i (Fl_Button* o, void* v);
static void cb_Play (Fl_Button* o, void* v);
inline void cb_Div_i (Fl_Button* o, void* v);
static void cb_Div (Fl_Button* o, void* v);
inline void cb_Reset_i (Fl_Button* o, void* v);
static void cb_Reset (Fl_Button* o, void* v);
inline void cb_Dbl_i (Fl_Button* o, void* v);
static void cb_Dbl (Fl_Button* o, void* v);
inline void cb_Nudge_i (Fl_Button* o, void* v);
static void cb_Nudge (Fl_Button* o, void* v);
};

#endif

Write Preview
Loading…
Cancel
Save