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

471 lines
17KB
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 "PoshSamplerPlugin.h"

  19. #include "PoshSamplerPluginGUI.h"

  20. #include <FL/Fl_Button.h>

  21. #include "SpiralIcon.xpm"

  22. #include "../../NoteTable.h"

  23. #include <stdio.h>

  24. 

  25. #include "../../RiffWav.h"

  26. 

  27. using namespace std;

  28. 

  29. static const int   NOTETRIG    = NUM_SAMPLES*2+1;

  30. static const int   REC_INPUT   = 16;

  31. 

  32. static const int   S1_INPUT   = 18;

  33. static const int   S2_INPUT   = 19;

  34. static const int   S3_INPUT   = 20;

  35. 

  36. extern "C" {

  37.    SpiralPlugin* SpiralPlugin_CreateInstance() { return new PoshSamplerPlugin; }

  38.    char** SpiralPlugin_GetIcon() { return SpiralIcon_xpm; }

  39.    int SpiralPlugin_GetID() { return 32; }

  40.    string SpiralPlugin_GetGroupName() { return "Delay/Sampling"; }

  41. }

  42. 

  43. ///////////////////////////////////////////////////////

  44. 

  45. static void InitializeSampleDescription (SampleDesc* NewDesc, const string &Pathname, int Note) {

  46.        if (NewDesc) {

  47.           NewDesc->Pathname = Pathname;

  48.           NewDesc->Volume = 1.0f;

  49.           NewDesc->Velocity = 1.0f;

  50.           NewDesc->Pitch = 1.0f;

  51.           NewDesc->PitchMod = 1.0f;

  52.           NewDesc->SamplePos = -1;

  53.           NewDesc->Loop = false;

  54.           NewDesc->PingPong = false;

  55.           NewDesc->Note = Note;

  56.           NewDesc->Octave = 0;

  57.           NewDesc->TriggerUp = true;

  58.           NewDesc->SamplePos = -1;

  59.           NewDesc->SampleRate = 44100;

  60.           NewDesc->Stereo = false;

  61.           NewDesc->PlayStart = 0;

  62.           NewDesc->LoopStart = 0;

  63.           NewDesc->LoopEnd = INT_MAX;

  64.           NewDesc->ReTrig = true;

  65.        }

  66. }

  67. 

  68. PoshSamplerPlugin::PoshSamplerPlugin() :

  69. m_Recording(false)

  70. {

  71. 	m_PluginInfo.Name="PoshSampler";

  72. 	m_PluginInfo.Width=400;

  73. 	m_PluginInfo.Height=215;

  74. 	m_PluginInfo.NumInputs=21;

  75. 	m_PluginInfo.NumOutputs=9;

  76. 	m_PluginInfo.PortTips.push_back("Sample 1 Pitch");

  77. 	m_PluginInfo.PortTips.push_back("Sample 1 Trigger");

  78. 	m_PluginInfo.PortTips.push_back("Sample 2 Pitch");

  79. 	m_PluginInfo.PortTips.push_back("Sample 2 Trigger");

  80. 	m_PluginInfo.PortTips.push_back("Sample 3 Pitch");

  81. 	m_PluginInfo.PortTips.push_back("Sample 3 Trigger");

  82. 	m_PluginInfo.PortTips.push_back("Sample 4 Pitch");

  83. 	m_PluginInfo.PortTips.push_back("Sample 4 Trigger");

  84. 	m_PluginInfo.PortTips.push_back("Sample 5 Pitch");

  85. 	m_PluginInfo.PortTips.push_back("Sample 5 Trigger");

  86. 	m_PluginInfo.PortTips.push_back("Sample 6 Pitch");

  87. 	m_PluginInfo.PortTips.push_back("Sample 6 Trigger");

  88. 	m_PluginInfo.PortTips.push_back("Sample 7 Pitch");

  89. 	m_PluginInfo.PortTips.push_back("Sample 7 Trigger");

  90. 	m_PluginInfo.PortTips.push_back("Sample 8 Pitch");

  91. 	m_PluginInfo.PortTips.push_back("Sample 8 Trigger");

  92. 	m_PluginInfo.PortTips.push_back("Input");

  93. 	m_PluginInfo.PortTips.push_back("Sample trigger pitch");

  94. 	m_PluginInfo.PortTips.push_back("Sample 1 Start Pos");

  95. 	m_PluginInfo.PortTips.push_back("Sample 2 Start Pos");

  96. 	m_PluginInfo.PortTips.push_back("Sample 3 Start Pos");

  97. 	m_PluginInfo.PortTips.push_back("Mixed Output");

  98. 	m_PluginInfo.PortTips.push_back("Sample 1 Output");

  99. 	m_PluginInfo.PortTips.push_back("Sample 2 Output");

  100. 	m_PluginInfo.PortTips.push_back("Sample 3 Output");

  101. 	m_PluginInfo.PortTips.push_back("Sample 4 Output");

  102. 	m_PluginInfo.PortTips.push_back("Sample 5 Output");

  103. 	m_PluginInfo.PortTips.push_back("Sample 6 Output");

  104. 	m_PluginInfo.PortTips.push_back("Sample 7 Output");

  105. 	m_PluginInfo.PortTips.push_back("Sample 8 Output");

  106. 	for (int n=0; n<NUM_SAMPLES; n++) {

  107. 		Sample* NewSample = new Sample;

  108. 		m_SampleVec.push_back(NewSample);

  109. 		SampleDesc* NewDesc = new SampleDesc;

  110. 		char temp[256];

  111. 		sprintf (temp, "PoshSampler%d_%d", GetID(), n);

  112.  		InitializeSampleDescription(NewDesc, temp, n);

  113. 		m_SampleDescVec.push_back(NewDesc);

  114. 	}

  115. 	m_Version = 4;

  116. 	m_Current = 0;

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

  118. 	m_AudioCH->Register("Value",&m_GUIArgs.Value);

  119. 	m_AudioCH->Register("Bool",&m_GUIArgs.Boole);

  120. 	m_AudioCH->Register("Int",&m_GUIArgs.Int);

  121. 	m_AudioCH->Register("Start",&m_GUIArgs.Start);

  122. 	m_AudioCH->Register("End",&m_GUIArgs.End);

  123. 	m_AudioCH->Register("LoopStart",&m_GUIArgs.LoopStart);

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

  125. 	m_AudioCH->Register("PlayPos",&m_CurrentPlayPos,ChannelHandler::OUTPUT);

  126. 	m_AudioCH->RegisterData("SampleBuffer",ChannelHandler::OUTPUT_REQUEST,&m_SampleBuffer,TRANSBUF_SIZE);

  127. 	m_AudioCH->Register("SampleSize",&m_SampleSize,ChannelHandler::OUTPUT_REQUEST);

  128. }

  129. 

  130. PoshSamplerPlugin::~PoshSamplerPlugin() {

  131.    for (vector<Sample*>::iterator i=m_SampleVec.begin(); i!=m_SampleVec.end(); i++)

  132.        delete(*i);

  133.    for (vector<SampleDesc*>::iterator i=m_SampleDescVec.begin(); i!=m_SampleDescVec.end(); i++)

  134.        delete(*i);

  135. }

  136. 

  137. PluginInfo &PoshSamplerPlugin::Initialise (const HostInfo *Host) {

  138.            return SpiralPlugin::Initialise (Host);

  139. }

  140. 

  141. SpiralGUIType *PoshSamplerPlugin::CreateGUI() {

  142.    return new PoshSamplerPluginGUI (m_PluginInfo.Width, m_PluginInfo.Height, this, m_AudioCH, m_HostInfo);

  143. }

  144. 

  145. void PoshSamplerPlugin::Reset() {

  146.      ResetPorts();

  147.      m_Current = 0;

  148.      for (int s=0; s<NUM_SAMPLES; s++) {

  149.          m_SampleDescVec[s]->Pitch = m_InitialPitch[s] * m_SampleDescVec[s]->SampleRate / (float)m_HostInfo->SAMPLERATE;

  150.          m_SampleDescVec[s]->LoopEnd = m_SampleVec[s]->GetLength() - 1;

  151.      }

  152. }

  153. 

  154. void PoshSamplerPlugin::Execute() {

  155.      static bool Pong = false;

  156.      for (int s=0; s<NUM_SAMPLES+1; s++) GetOutputBuf (s)->Zero();

  157.      float Freq = 0;

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

  159.          Freq = GetInputPitch (NOTETRIG, n);

  160.          for (int s=0; s<NUM_SAMPLES; s++) {

  161.              SampleDesc *S = m_SampleDescVec[s];

  162.              // if we have a sample here

  163.              if (m_SampleVec[s]->GetLength()) {

  164.                 // Convert the CV input into a useable trigger

  165.                 if (S->ReTrig || (S->SamplePos == -1)) {

  166.                    if (GetInput (s*2 + 1, n) > 0 || feq (Freq, NoteTable[S->Note], 0.01f)) {

  167.                       if (S->TriggerUp) {

  168.                          if (s==0 && InputExists (S1_INPUT))

  169.                             S->PlayStart = (long int)((GetInput (S1_INPUT, n) * 0.5 + 0.5f) * (S->LoopEnd-S->LoopStart)) + S->LoopStart;

  170.                          if (s==1 && InputExists (S2_INPUT))

  171.                             S->PlayStart = (long int)((GetInput (S2_INPUT, n) * 0.5 + 0.5f) * (S->LoopEnd-S->LoopStart)) + S->LoopStart;

  172.                          if (s==2 && InputExists (S3_INPUT))

  173.                             S->PlayStart = (long int)((GetInput (S3_INPUT, n) * 0.5 + 0.5f) * (S->LoopEnd-S->LoopStart)) + S->LoopStart;

  174.                          if (S->PlayStart < 0) S->PlayStart = 0;

  175.                          S->SamplePos = S->PlayStart;

  176.                          S->TriggerUp = false;

  177.                          S->Velocity = GetInput (s * 2 + 1, n);

  178.                       }

  179.                    }

  180.                    else {

  181.                       S->TriggerUp = true;

  182.                       // end it if it's looping

  183.                       if (S->Loop) S->SamplePos = -1;

  184.                    }

  185.                 }

  186.                 // if the sample has ended

  187.                 if (S->SamplePos >= S->LoopEnd || S->SamplePos >= m_SampleVec[s]->GetLength()) {

  188.                    if (S->Loop) {

  189.                       if (S->PingPong) Pong = true;

  190.                       else S->SamplePos = S->LoopStart;

  191.                    }

  192.                    else {

  193.                       S->SamplePos = -1;

  194.                    }

  195.                 }

  196.                 // if the sample has ended ponging

  197.                 if (Pong && S->SamplePos <= S->LoopStart)

  198.                    Pong = false;

  199.                 if (S->SamplePos != -1) {

  200.                    if (InputExists (s * 2)) {

  201.                       // Get the pitch from the CV

  202.                       float PlayFreq = GetInputPitch (s * 2, n);

  203.                       // assumtion: base frequency = 440 (middle A)

  204.                       S->Pitch = PlayFreq / 440;

  205.                       S->Pitch *= S->SampleRate / (float)m_HostInfo->SAMPLERATE;

  206.                    }

  207.                    // mix the sample to the output.

  208.                    MixOutput (0, n, (*m_SampleVec[s])[S->SamplePos] * S->Volume * S->Velocity);

  209.                    // copy the sample to it's individual output.

  210.                    SetOutput (s + 1, n, ((*m_SampleVec[s])[S->SamplePos] * S->Volume));

  211.                    float Freq = S->Pitch;

  212.                    if (S->Octave > 0) Freq *= 1 << (S->Octave);

  213.                    if (S->Octave < 0) Freq /= 1 << (-S->Octave);

  214.                    if (Pong) S->SamplePos -= Freq * S->PitchMod;

  215.                    else S->SamplePos += Freq * S->PitchMod;

  216.                 }

  217.              }

  218.          }

  219.      }

  220.      // record

  221.      static int LastRecording = false;

  222.      if (m_Recording && InputExists (REC_INPUT)) {

  223.         int s = 0; //GUI->GetCurrentSample();

  224.         if (!LastRecording) m_SampleVec[s]->Clear();

  225.         // new sample

  226.         if (m_SampleVec[s]->GetLength() == 0) {

  227.            *m_SampleVec[s] =* GetInput (REC_INPUT);

  228.            m_SampleDescVec[s]->SampleRate = m_HostInfo->SAMPLERATE;

  229.            m_SampleDescVec[s]->Stereo = false;

  230.            m_SampleDescVec[s]->Pitch *= 1.0f;

  231.            m_InitialPitch[s] = m_SampleDescVec[s]->Pitch;

  232.            m_SampleDescVec[s]->LoopEnd = m_SampleVec[s]->GetLength();

  233.         }

  234.         else {

  235.            m_SampleVec[s]->Add (*GetInput (REC_INPUT));

  236.            m_SampleDescVec[s]->LoopEnd = m_SampleVec[s]->GetLength();

  237.         }

  238.      }

  239.      LastRecording = m_Recording;

  240.      if (m_SampleDescVec[m_Current]->SamplePos > 0) {

  241.         m_CurrentPlayPos = (long)m_SampleDescVec[m_Current]->SamplePos;

  242.      }

  243. }

  244. 

  245. void PoshSamplerPlugin::ExecuteCommands() {

  246.      if (m_AudioCH->IsCommandWaiting()) {

  247.         switch (m_AudioCH->GetCommand()) {

  248.           case LOAD:

  249.              LoadSample(m_GUIArgs.Num,m_GUIArgs.Name);

  250.              break;

  251.           case SAVE:

  252.              SaveSample(m_GUIArgs.Num,m_GUIArgs.Name);

  253.              break;

  254.           case SETVOL:

  255.              m_SampleDescVec[m_GUIArgs.Num]->Volume=m_GUIArgs.Value;

  256.              break;

  257.           case SETPITCH:

  258.              m_SampleDescVec[m_GUIArgs.Num]->PitchMod=m_GUIArgs.Value;

  259.              break;

  260.           case SETLOOP:

  261.              m_SampleDescVec[m_GUIArgs.Num]->Loop=m_GUIArgs.Boole;

  262.              break;

  263.           case SETPING:

  264.              m_SampleDescVec[m_GUIArgs.Num]->PingPong=m_GUIArgs.Boole;

  265.              break;

  266.           case SETNOTE:

  267.              m_SampleDescVec[m_GUIArgs.Num]->Note=m_GUIArgs.Int;

  268.              break;

  269.           case SETOCT:

  270.              m_SampleDescVec[m_GUIArgs.Num]->Octave=m_GUIArgs.Int-6;

  271.              break;

  272.           case SETPLAYPOINTS:

  273.              m_SampleDescVec[m_GUIArgs.Num]->PlayStart=m_GUIArgs.Start;

  274.              m_SampleDescVec[m_GUIArgs.Num]->LoopStart=m_GUIArgs.LoopStart;

  275.              m_SampleDescVec[m_GUIArgs.Num]->LoopEnd=m_GUIArgs.End;

  276.              break;

  277.           case SETREC:

  278.              m_Recording=m_GUIArgs.Boole;

  279.              break;

  280.           case CUT:

  281.              Cut (m_GUIArgs.Num, m_GUIArgs.Start, m_GUIArgs.End);

  282.              break;

  283.           case COPY:

  284.              Copy (m_GUIArgs.Num, m_GUIArgs.Start, m_GUIArgs.End);

  285.              break;

  286.           case PASTE:

  287.              Paste (m_GUIArgs.Num, m_GUIArgs.Start, m_GUIArgs.End);

  288.              break;

  289.           case MIX:

  290.              Mix (m_GUIArgs.Num, m_GUIArgs.Start, m_GUIArgs.End);

  291.              break;

  292.           case CROP:

  293.              Crop (m_GUIArgs.Num, m_GUIArgs.Start, m_GUIArgs.End);

  294.              break;

  295.           case REV:

  296.              Reverse (m_GUIArgs.Num, m_GUIArgs.Start, m_GUIArgs.End);

  297.              break;

  298.           case AMP:

  299.              Amp (m_GUIArgs.Num, m_GUIArgs.Start, m_GUIArgs.End);

  300.              break;

  301.           case SETCURRENT:

  302.              m_Current = m_GUIArgs.Num;

  303.              break;

  304.           case GETSAMPLE:

  305.              m_AudioCH->SetupBulkTransfer ((void*)m_SampleVec[m_Current]->GetBuffer());

  306.              m_SampleSize = m_SampleVec[m_Current]->GetLengthInBytes();

  307.              break;

  308.           case SETRETRIG:

  309.              m_SampleDescVec[m_GUIArgs.Num]->ReTrig=m_GUIArgs.Boole;

  310.              break;

  311.         };

  312.      }

  313. }

  314. 

  315. void PoshSamplerPlugin::StreamOut (ostream &s) {

  316.      s << m_Version << " ";

  317.      for (int n=0; n<NUM_SAMPLES; n++) {

  318.          s << m_SampleDescVec[n]->Volume << " " <<

  319.               m_SampleDescVec[n]->PitchMod << " " <<

  320.               m_SampleDescVec[n]->Loop << " " <<

  321.               m_SampleDescVec[n]->PingPong << " " <<

  322.               m_SampleDescVec[n]->Note << " " <<

  323.               m_SampleDescVec[n]->Octave << " " <<

  324.               m_SampleDescVec[n]->SamplePos << " " <<

  325.               m_SampleDescVec[n]->PlayStart << " " <<

  326.               m_SampleDescVec[n]->LoopStart << " " <<

  327.               m_SampleDescVec[n]->LoopEnd << " " <<

  328.               m_SampleDescVec[n]->Note << " " <<

  329.               m_SampleDescVec[n]->ReTrig << " ";

  330.      }

  331. }

  332. 

  333. void PoshSamplerPlugin::StreamIn (istream &s) {

  334.      int version;

  335.      s >> version;

  336.      for (int n=0; n<NUM_SAMPLES; n++) {

  337.          s >> m_SampleDescVec[n]->Volume >>

  338.               m_SampleDescVec[n]->PitchMod >>

  339.               m_SampleDescVec[n]->Loop >>

  340.               m_SampleDescVec[n]->PingPong >>

  341.               m_SampleDescVec[n]->Note >>

  342.               m_SampleDescVec[n]->Octave >>

  343.               m_SampleDescVec[n]->SamplePos >>

  344.               m_SampleDescVec[n]->PlayStart >>

  345.               m_SampleDescVec[n]->LoopStart >>

  346.               m_SampleDescVec[n]->LoopEnd >>

  347.               m_SampleDescVec[n]->Note;

  348.               if (version < 3) {

  349.                  int size;

  350.                  s >> size;

  351.                  s.ignore (1);

  352.                  char Buf[4096];

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

  354.               }

  355.               if (version > 3) s >> m_SampleDescVec[n]->ReTrig;

  356.               else m_SampleDescVec[n]->ReTrig = true;

  357.      }

  358. }

  359. 

  360. void PoshSamplerPlugin::LoadSample(int n, const string &Name)

  361. {

  362. 	WavFile Wav;

  363. 	if (Wav.Open(Name,WavFile::READ))

  364. 	{

  365. 		m_SampleVec[n]->Allocate(Wav.GetSize());

  366. 		Wav.Load(*m_SampleVec[n]);

  367. 		InitializeSampleDescription(m_SampleDescVec[n], Name, n);

  368. 		m_SampleDescVec[n]->SampleRate=Wav.GetSamplerate();

  369. 		m_SampleDescVec[n]->Stereo=Wav.IsStereo();

  370. 		m_InitialPitch[n] = m_SampleDescVec[n]->Pitch;

  371. 		m_SampleDescVec[n]->Pitch = m_InitialPitch[n] * m_SampleDescVec[n]->SampleRate/(float)m_HostInfo->SAMPLERATE;

  372. 		m_SampleDescVec[n]->LoopEnd=m_SampleVec[n]->GetLength()-1;

  373. 	}

  374. }

  375. 

  376. void PoshSamplerPlugin::SaveSample(int n, const string &Name)

  377. {

  378. 	if (m_SampleVec[n]->GetLength()==0) return;

  379. 

  380. 	WavFile Wav;

  381. 	Wav.Open(Name,WavFile::WRITE,WavFile::MONO);

  382. 	Wav.Save(*m_SampleVec[n]);

  383. }

  384. 

  385. void PoshSamplerPlugin::Cut(int n, long s, long e)

  386. {

  387. 	if (m_SampleVec[n]->GetLength()==0) return;

  388. 	m_SampleVec[n]->GetRegion(m_CopyBuffer, s, e);

  389. 	m_SampleVec[n]->Remove(s, e);

  390. }

  391. 

  392. void PoshSamplerPlugin::Copy(int n, long s, long e)

  393. {

  394. 	if (m_SampleVec[n]->GetLength()==0) return;

  395. 	m_SampleVec[n]->GetRegion(m_CopyBuffer, s, e);

  396. }

  397. 

  398. void PoshSamplerPlugin::Paste(int n, long s, long e)

  399. {

  400. 	if (m_SampleVec[n]->GetLength()==0) return;

  401. 	m_SampleVec[n]->Insert(m_CopyBuffer, s);

  402. }

  403. 

  404. void PoshSamplerPlugin::Mix(int n, long s, long e)

  405. {

  406. 	if (m_SampleVec[n]->GetLength()==0) return;

  407. 	m_SampleVec[n]->Mix(m_CopyBuffer, s);

  408. }

  409. 

  410. void PoshSamplerPlugin::Crop(int n, long s, long e)

  411. {

  412. 	if (m_SampleVec[n]->GetLength()==0) return;

  413. 	m_SampleVec[n]->Remove(0, s);

  414. 	m_SampleVec[n]->Remove(e, m_SampleVec[n]->GetLength()-1);

  415. }

  416. 

  417. void PoshSamplerPlugin::Reverse(int n, long s, long e)

  418. {

  419. 	if (m_SampleVec[n]->GetLength()==0) return;

  420. 	m_SampleVec[n]->Reverse(s, e);

  421. }

  422. 

  423. void PoshSamplerPlugin::Amp(int n, long s, long e)

  424. {

  425. 	if (m_SampleVec[n]->GetLength()==0) return;

  426. 	for (int m=0; m<m_SampleVec[n]->GetLength(); m++)

  427. 	{

  428. 		m_SampleVec[n]->Set(m,(*m_SampleVec[n])[m]*m_SampleDescVec[n]->Volume);

  429. 	}

  430. }

  431. 

  432. 

  433. bool PoshSamplerPlugin::SaveExternalFiles(const string &Dir)

  434. {

  435. 	for (int n=0; n<NUM_SAMPLES; n++)

  436. 	{

  437. 		char temp[256];

  438.                 // Andy's fix for bug 766594

  439.                 // sprintf (temp, "PoshSampler%d_%d.wav", SpiralPlugin_GetID(), n);

  440. 		sprintf (temp, "PoshSampler%d_%d.wav", GetID(), n);

  441. 		m_SampleDescVec[n]->Pathname   = temp;

  442. 	}

  443. 

  444. 	for (int n=0; n<NUM_SAMPLES; n++)

  445. 	{

  446. 		// if it's not empty

  447. 		if (m_SampleVec[n]->GetLength()!=0)

  448. 		{

  449. 			SaveSample(n,Dir+m_SampleDescVec[n]->Pathname);

  450. 		}

  451. 	}

  452. 	return true;

  453. }

  454. 

  455. void PoshSamplerPlugin::LoadExternalFiles(const string &Dir, int withID)

  456. {

  457. 	for (int n=0; n<NUM_SAMPLES; n++)

  458. 	{

  459. 		char temp[256];

  460.                 // Andy's fix for bug 766594

  461. 		// sprintf (temp, "PoshSampler%d_%d.wav", SpiralPlugin_GetID(), n);

  462. 		sprintf (temp, "PoshSampler%d_%d.wav", ((withID==-1)?GetID():withID), n);

  463. 		m_SampleDescVec[n]->Pathname   = temp;

  464. 	}

  465. 

  466. 	for (int n=0; n<NUM_SAMPLES; n++)

  467. 	{

  468. 		LoadSample(n,Dir+m_SampleDescVec[n]->Pathname);

  469. 	}

  470. }