| | | | | | envelope.cpp // Syntopia. See http://Syntopia.sourceforge.net for details and documentation. // // Author of this file: Mikael Hvidtfeldt Christensen (mikaelc@users.sourceforge.net) #include "envelope.h" #include "math.h" #include <iostream> #include "SynthVoice.h" // Envelope ---------------------------------------------------------------------------------------------------------- namespace SynthCore { Envelope3::Envelope3(SynthVoice * s) { // If we are part of a voice. hostVoice = s; // Init envelope section with some standard values for Attack, Decay, Sustain, Release. Input1 = new Input(this); Output1 = new Output(this); myData = new EnvData(); amp = 0; time = 0; killVoice = false; OldNoteOn=false; } Module * Envelope3::sharedClone() { Envelope3 * Env = new Envelope3(hostVoice); Env->killVoice = killVoice; // This is considered a Hack if (Env->myData != 0) delete Env->myData; Env->myData = myData; Env->ModID = ModID; Env->firstVoice = false; return Env; } Envelope3::~Envelope3() { delete(Input1); delete(Output1); delete(myData); } std::string Envelope3::getXML(int indent ) { std::string S = Utils::space(indent) + "<Module ID=\""+Utils::intToString((int)this)+"\" >"+ Utils::newline(); S += Utils::space(indent+2) + "<TypeID>" + typeid(*this).name() + "</TypeID>" + Utils::newline(); S += myData->getXML(indent+2); S += Output1->getXML("Output1", indent+2); S += Input1->getXML("Input1", indent+2); S += saveParameter("killVoice",killVoice); S += saveID(indent+2); S += Utils::space(indent) + "</Module>" + Utils::newline(); return S; } void Envelope3::loadXML(XMLNode * n, bool firstPass) { cout << "Parsing Envelope XML" << endl; string TypeID = n->getTagText("TypeID") ; if (typeid(*this).name() != TypeID) { throw parseError("Trying to put "+TypeID+" into "+typeid(*this).name()); } if (firstPass) { loadParameter("killVoice",killVoice, n); Output1->loadXML("Output1", n); } else { Input1->loadXML("Input1", n); } // TODO : what about the envelope? }; void Envelope3::setDuration(int calls) { myData->sampleLength = calls; } void Envelope3::update() { time++; // Has our situtation changed? Key pressed or Key released? if (hostVoice->noteOn != OldNoteOn) { OldNoteOn=hostVoice->noteOn; if (hostVoice->noteOn) { // We have just recieved a NoteOn event. time = 0; myData->endOfEnvelope = false; // Ensure that hostVoice is alive if (killVoice) hostVoice->aLive = true; } } if (hostVoice->noteOn) { // Key pressed amp = myData->getValue(time,true); } else { // Key released amp = myData->getValue(time,false); if (myData->endOfEnvelope) { // We have reached end of envelope. if (killVoice) hostVoice->aLive = false; } } if (Input1->ConFrom != 0) { // Multiply the envelope with the input. Output1->value = Input1->ConFrom->value*amp; } else { // Just output envelope Output1->value = amp; } } // EnvData starts here --------------------------------------------------------------------------------------------- void EnvData::getLimits(float &x0, float &y0, float &x1, float &y1) { if (points.size()>1) { // Must be some points... x0 = points[0]->x; x1 = points[0]->x; y0 = points[0]->y; y1 = points[0]->y; } for(int i = 0; i < points.size(); i++) { float x = points[i]->x; float y = points[i]->y; if ( x < x0) { x0=x; } if ( x > x1) { x1=x; } if ( y < y0) { y0=y; } if ( y > y1) { y1=y; } } } std::string EnvData::getXML(int indent ) { std::string S = Utils::space(indent) + "<EnvData ID=\""+Utils::intToString((int)this)+"\" >"+ Utils::newline(); S += Utils::space(indent+2) + "<TypeID>" + typeid(*this).name() + "</TypeID>" + Utils::newline(); S += Module::saveParameter("beginLP",beginLP, indent+2); S += Module::saveParameter("endLP",endLP, indent+2); S += Module::saveParameter("envSize",envsize, indent+2); S += Module::saveParameter("sampleLength",sampleLength, indent+2); S += Utils::space(indent+2) + "<ControlPoints>" + Utils::newline(); for (int j = 0; j < points.size();j++) { S += Utils::space(indent+4) + "<Point><x>" + Utils::floatToString(points[j]->x) + "</x><y>" + Utils::floatToString(points[j]->y) + "</y></Point>" + Utils::newline(); } S += Utils::space(indent+2) + "</ControlPoints>" + Utils::newline(); S += Utils::space(indent) + "</EnvData>" + Utils::newline(); return S; } EnvData::EnvData() { endOfEnvelope = false; envsize = 1024; sampleLength = 100.0f; // The envelope spans 1 second beginLP = 2; endLP = 3; setChoosen(-1); envdata = new float[envsize]; // Init with a standard envelope. points.push_back(new coord(0.0f,0.0f)); points.push_back(new coord(0.2f,1.0f)); points.push_back(new coord(0.4f,0.5f)); points.push_back(new coord(0.7f,0.1f)); points.push_back(new coord(0.8f,0.9f)); points.push_back(new coord(1.0f,0.0f)); loopStart = -1; loopEnd = -1; loopState = sustainedLoop; interpolateSpline(); } void EnvData::clearEnvelope() { // Clean up after points. for (int i=0; i < points.size(); i++) delete points[i]; points.clear(); // This probably doesnt matter at all. beginLP = endLP = loopStart = loopEnd = -1; } void EnvData::setADSR(float A, float D, float S, float R) { clearEnvelope(); points.push_back(new coord(0.0f,0.0f)); points.push_back(new coord(A,1.0f)); points.push_back(new coord(A+D,S)); points.push_back(new coord(A+D+A,S)); points.push_back(new coord(A+D+A+R,0.0f)); beginLP = 2; endLP = 3; interpolate(); } EnvData::~EnvData() { delete[] envdata; clearEnvelope(); } inline float EnvData::getValue(long &time, bool loop) { // The actual envelope module will access data through this routine. // This must be updated to at least ASM-boosted linear interpolation. // Possible OVERFLOW! // Convert time to array-index int idx = (int)((time*envsize)/sampleLength); // should we loop? if ((loop) && (loopEnd != -1) && (loopStart != -1)) { // Are we in a loopzone? while (idx > loopEnd) { // MODIFY TIME INSTEAD time -= ((loopEnd-loopStart)*sampleLength/envsize); idx = (int)((time*envsize)/sampleLength); } } if (idx > envsize -1) { idx = envsize -1 ; endOfEnvelope = true;} if (idx < 0) {idx = 0;} return envdata[idx]; } void EnvData::addPoint(float x, float y) { int before = 0; for (int j = 1; j < points.size();j++) { if (x>points[j]->x) { before = j; } } points.insert(points.begin() + before + 1, new coord(x,y)); std::cout << " POINTS: " << std::endl; { for (int j = 0; j < points.size();j++) { std::cout << " I: " << j << " X: " << points[j]->x << " Y:" << points[j]->y << std::endl; }} } void EnvData::removePoint(int p) { delete points[p]; points.erase(points.begin() + p); } void EnvData::interpolateLinear() { float x0,y0,x1,y1; getLimits(x0,y0,x1,y1); int nr = 1; for (int i=0; i<envsize; i++) { float xpos = (((float) i/(float) envsize)-x0)*(x1-x0); if (points[nr]->x < xpos) {nr++;} envdata[i] = (points[nr]->y - points[nr-1]->y) * (xpos - points[nr-1]->x) /(points[nr]->x - points[nr-1]->x) + points[nr-1]->y; } } void EnvData::interpolateSpline() { float x0,y0,x1,y1; getLimits(x0,y0,x1,y1); int nr = 1; loopStart = -1; loopEnd = -1; if (beginLP != -1 ) { loopStart = (int) ((float)envsize* (points[beginLP]->x - x0)/(x1-x0) ); } if (endLP != -1 ) { loopEnd = (int) ((float)envsize* (points[endLP]->x - x0)/(x1-x0) ); } for (int i=0; i<envsize; i++) { float xpos = x0 + (((float) i/(float) envsize))*(x1-x0); if (points[nr]->x < xpos) {nr++;} float xd = (xpos - points[nr-1]->x) /(points[nr]->x - points[nr-1]->x); float y0, y3; if (nr-2>=0) { y0 = points[nr-1]->y; } else {y0 = points[0]->y; ;} float y1 = points[nr-1]->y; float y2 = points[nr]->y; if (nr+1<points.size()) { y3 = points[nr+1]->y; } else {y3 = points[points.size()-1]->y;} float t = xd; float t2 = t * t; float t3 = t2 * t; float alpha = 0.0; float m0 = ((1 - alpha) / 2.0f) * ((y1 - y0) + y2 - y1); float m1 = ((1 - alpha) / 2.0f) * ((y2 - y1) + y3 - y2); envdata[i] = (((2 * t3) - (3 * t2) + 1) * y1) + ((t3 - (2 * t2) + t) * m0) + ((t3 - t2) * m1) + (((-2 * t3) + (3 * t2)) * y2); } } }; // end of namespace: SynthCore Syntopia Project. Visit the web page, or the SourceForge page. Docs made by Doxygen. Email: Mikael Christensen