summaryrefslogtreecommitdiffstats
path: root/arts/modules/synth/synth_midi_test_impl.cc
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commite2de64d6f1beb9e492daf5b886e19933c1fa41dd (patch)
tree9047cf9e6b5c43878d5bf82660adae77ceee097a /arts/modules/synth/synth_midi_test_impl.cc
downloadtdemultimedia-e2de64d6f1beb9e492daf5b886e19933c1fa41dd.tar.gz
tdemultimedia-e2de64d6f1beb9e492daf5b886e19933c1fa41dd.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdemultimedia@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'arts/modules/synth/synth_midi_test_impl.cc')
-rw-r--r--arts/modules/synth/synth_midi_test_impl.cc692
1 files changed, 692 insertions, 0 deletions
diff --git a/arts/modules/synth/synth_midi_test_impl.cc b/arts/modules/synth/synth_midi_test_impl.cc
new file mode 100644
index 00000000..91714cac
--- /dev/null
+++ b/arts/modules/synth/synth_midi_test_impl.cc
@@ -0,0 +1,692 @@
+#include "artsmodulessynth.h"
+#include "artsbuilder.h"
+#include "stdsynthmodule.h"
+#include "objectmanager.h"
+#include "connect.h"
+#include "flowsystem.h"
+#include "debug.h"
+#include "dynamicrequest.h"
+#include "audiosubsys.h"
+#include <fstream>
+#include <math.h>
+#include <stdlib.h>
+
+using namespace Arts;
+using namespace std;
+
+/*-------- instrument mapping ---------*/
+
+class InstrumentMap {
+protected:
+ struct InstrumentData;
+ class Tokenizer;
+ list<InstrumentData> instruments;
+ string directory;
+ void loadLine(const string& line);
+
+public:
+ struct InstrumentParam;
+
+ void loadFromList(const string& filename, const vector<string>& list);
+ StructureDesc getInstrument(mcopbyte channel, mcopbyte note,
+ mcopbyte velocity, mcopbyte program,
+ vector<InstrumentParam>*& params);
+};
+
+struct InstrumentMap::InstrumentParam
+{
+ string param;
+ Any value;
+
+ InstrumentParam()
+ {
+ }
+
+ InstrumentParam(const InstrumentParam& src)
+ : param(src.param), value(src.value)
+ {
+ }
+
+ InstrumentParam(const string& param, const string& strValue)
+ : param(param)
+ {
+ /* put the string into the any */
+ value.type = "string";
+
+ Buffer b;
+ b.writeString(strValue);
+ b.read(value.value, b.size());
+ }
+};
+
+struct InstrumentMap::InstrumentData
+{
+ struct Range
+ {
+ int minValue, maxValue;
+ Range() : minValue(0), maxValue(0)
+ {
+ }
+ Range(int minValue, int maxValue)
+ : minValue(minValue), maxValue(maxValue)
+ {
+ }
+ bool match(int value)
+ {
+ return (value >= minValue) && (value <= maxValue);
+ }
+ };
+ Range channel, pitch, program, velocity;
+ vector<InstrumentParam> params;
+ StructureDesc instrument;
+};
+
+class InstrumentMap::Tokenizer {
+protected:
+ bool haveToken, haveNextToken;
+ string token, nextToken, input;
+ string::iterator ii;
+public:
+ Tokenizer(const string& line)
+ : haveToken(false), haveNextToken(false),
+ input(line+"\n"), ii(input.begin())
+ {
+ /* adding a \n ensures that we will definitely find the last token */
+ }
+ string getToken()
+ {
+ if(!haveMore())
+ return "";
+
+ if(haveNextToken)
+ {
+ string t = token;
+ haveNextToken = false;
+ token = nextToken;
+ return t;
+ }
+ else
+ {
+ haveToken = false;
+ return token;
+ }
+ }
+ bool haveMore()
+ {
+ if(haveToken)
+ return true;
+
+ token = "";
+ while(ii != input.end() && !haveToken)
+ {
+ const char& c = *ii++;
+
+ if(c == ' ' || c == '\t' || c == '\n')
+ {
+ if(!token.empty()) haveToken = true;
+ }
+ else if(c == '=') /* || c == '-' || c == '+')*/
+ {
+ if(!token.empty())
+ {
+ haveNextToken = true;
+ nextToken = c;
+ }
+ else
+ {
+ token = c;
+ }
+ haveToken = true;
+ }
+ else
+ {
+ token += c;
+ }
+ }
+ return haveToken;
+ }
+};
+
+void InstrumentMap::loadLine(const string& line)
+{
+ Tokenizer t(line);
+ InstrumentData id;
+ /* default: no filtering */
+ id.channel = InstrumentData::Range(0,15);
+ id.pitch = id.program = id.velocity = InstrumentData::Range(0,127);
+
+ string s[3];
+ int i = 0;
+ bool seenDo = false;
+ bool loadOk = false;
+
+ if(t.getToken() != "ON")
+ {
+ arts_warning("error in arts-map: lines must start with ON (did start with %s)\n", t.getToken().c_str());
+ return;
+ }
+
+ while(t.haveMore())
+ {
+ const string& token = t.getToken();
+
+ if(token == "DO")
+ seenDo = true;
+ else
+ {
+ s[i] = token;
+ if(i == 2) /* evaluate */
+ {
+ if(s[1] != "=")
+ {
+ arts_warning("error in arts-map: no = operator\n");
+ return;
+ }
+
+ if(seenDo)
+ {
+ if(s[0] == "structure")
+ {
+ string filename = s[2];
+
+ /* if it's no absolute path, its relative to the map */
+ if(!filename.empty() && filename[0] != '/')
+ filename = directory + "/" + s[2];
+
+ ifstream infile(filename.c_str());
+ string line;
+ vector<string> strseq;
+
+ while(getline(infile,line))
+ strseq.push_back(line);
+
+ id.instrument.loadFromList(strseq);
+ if(id.instrument.name() != "unknown")
+ {
+ loadOk = true;
+ }
+ else
+ {
+ arts_warning("mapped instrument: "
+ "can't load structure %s",s[2].c_str());
+ }
+ }
+ else
+ {
+ /* TODO: handle different datatypes */
+ id.params.push_back(InstrumentParam(s[0], s[2]));
+ }
+ }
+ else
+ {
+ InstrumentData::Range range;
+ range.minValue = atoi(s[2].c_str());
+ range.maxValue = range.minValue;
+ int i = s[2].find("-",0);
+ if(i != 0)
+ {
+ range.minValue = atoi(s[2].substr(0,i).c_str());
+ range.maxValue =
+ atoi(s[2].substr(i+1,s[2].size()-(i+1)).c_str());
+ }
+ if(s[0] == "pitch") id.pitch = range;
+ if(s[0] == "channel") id.channel = range;
+ if(s[0] == "program") id.program = range;
+ if(s[0] == "velocity") id.velocity = range;
+ }
+ i = 0;
+ }
+ else i++;
+ }
+ }
+ if(loadOk) instruments.push_back(id);
+}
+
+void InstrumentMap::loadFromList(const string& filename,
+ const vector<string>& list)
+{
+ int r = filename.rfind('/');
+ if(r > 0)
+ directory = filename.substr(0,r);
+ else
+ directory = "";
+
+ vector<string>::const_iterator i;
+ instruments.clear();
+ for(i = list.begin(); i != list.end(); i++) loadLine(*i);
+}
+
+StructureDesc InstrumentMap::getInstrument(mcopbyte channel, mcopbyte note,
+ mcopbyte velocity, mcopbyte program,
+ vector<InstrumentParam>*& params)
+{
+ list<InstrumentData>::iterator i;
+ for(i = instruments.begin(); i != instruments.end(); i++)
+ {
+ InstrumentData &id = *i;
+
+ if(id.channel.match(channel) && id.pitch.match(note) &&
+ id.velocity.match(velocity) && id.program.match(program))
+ {
+ params = &id.params;
+ return id.instrument;
+ }
+ }
+
+ return StructureDesc::null();
+}
+
+
+/*-------instrument mapping end -------*/
+
+static SynthModule get_AMAN_PLAY(Object structure)
+{
+ Object resultObj = structure._getChild("play");
+ assert(!resultObj.isNull());
+
+ SynthModule result = DynamicCast(resultObj);
+ assert(!result.isNull());
+
+ return result;
+}
+
+struct TSNote {
+ MidiPort port;
+ MidiEvent event;
+ TSNote(MidiPort port, const MidiEvent& event) :
+ port(port), event(event)
+ {
+ }
+};
+
+class AutoMidiRelease : public TimeNotify {
+public:
+ vector<MidiReleaseHelper> impls;
+ AutoMidiRelease()
+ {
+ Dispatcher::the()->ioManager()->addTimer(10, this);
+ }
+ virtual ~AutoMidiRelease()
+ {
+ Dispatcher::the()->ioManager()->removeTimer(this);
+ }
+ void notifyTime()
+ {
+ vector<MidiReleaseHelper>::iterator i = impls.begin();
+ while(i != impls.end())
+ {
+ if(i->terminate())
+ {
+ MidiReleaseHelper& helper = *i;
+
+ arts_debug("one voice terminated");
+ // put the MidiReleaseHelper and the voice into the ObjectCache
+ // (instead of simply freeing it)
+ ObjectCache cache = helper.cache();
+ SynthModule voice = helper.voice();
+ get_AMAN_PLAY(voice).stop();
+ voice.stop();
+ cache.put(voice,helper.name());
+ impls.erase(i);
+ return;
+ } else i++;
+ }
+ }
+} *autoMidiRelease;
+
+// cache startup & shutdown
+static class AutoMidiReleaseStart :public StartupClass
+{
+public:
+ void startup() { autoMidiRelease = new AutoMidiRelease(); }
+ void shutdown() { delete autoMidiRelease; }
+} autoMidiReleaseStart;
+
+class MidiReleaseHelper_impl : virtual public MidiReleaseHelper_skel,
+ virtual public StdSynthModule
+{
+protected:
+ bool _terminate;
+ SynthModule _voice;
+ ObjectCache _cache;
+ string _name;
+
+public:
+ MidiReleaseHelper_impl()
+ {
+ autoMidiRelease->impls.push_back(MidiReleaseHelper::_from_base(_copy()));
+ }
+ ~MidiReleaseHelper_impl() {
+ artsdebug("MidiReleaseHelper: one voice is gone now\n");
+ }
+
+
+ SynthModule voice() { return _voice; }
+ void voice(SynthModule voice) { _voice = voice; }
+
+ ObjectCache cache() { return _cache; }
+ void cache(ObjectCache cache) { _cache = cache; }
+
+ string name() { return _name; }
+ void name(const string& name) { _name = name; }
+
+ bool terminate() { return _terminate; }
+ void streamStart() { _terminate = false; }
+
+ void calculateBlock(unsigned long /*samples*/)
+ {
+ if(done[0] > 0.5)
+ _terminate = true;
+ }
+};
+REGISTER_IMPLEMENTATION(MidiReleaseHelper_impl);
+
+class Synth_MIDI_TEST_impl : virtual public Synth_MIDI_TEST_skel,
+ virtual public StdSynthModule {
+protected:
+ struct ChannelData {
+ SynthModule voice[128];
+ string name[128];
+ float pitchShiftValue;
+ mcopbyte program;
+ ChannelData() {
+ // initialize all voices with NULL objects (no lazy create)
+ for(int i = 0; i < 128; i++) voice[i] = SynthModule::null();
+
+ pitchShiftValue = 0.0;
+ program = 0;
+ }
+ } *channelData; /* data for all 16 midi channels */
+
+ bool useMap;
+ InstrumentMap map;
+ StructureDesc instrument;
+ StructureBuilder builder;
+ AudioManagerClient amClient;
+ ObjectCache cache;
+ MidiClient client;
+ MidiTimer timer;
+
+ string _filename;
+ string _busname;
+ string _title;
+public:
+ Synth_MIDI_TEST self() { return Synth_MIDI_TEST::_from_base(_copy()); }
+
+ Synth_MIDI_TEST_impl();
+ ~Synth_MIDI_TEST_impl();
+
+ void filename(const string& newname);
+ string filename()
+ {
+ return _filename;
+ }
+ void busname(const string& newname);
+ string busname()
+ {
+ return _busname;
+ }
+ string title()
+ {
+ return _title;
+ }
+ void noteOn(mcopbyte channel, mcopbyte note, mcopbyte velocity);
+ void noteOff(mcopbyte channel, mcopbyte note);
+ void pitchWheel(mcopbyte channel, mcopbyte lsb, mcopbyte msb);
+
+ float getFrequency(mcopbyte note,mcopbyte channel);
+
+ void streamStart();
+ void streamEnd();
+
+ TimeStamp time()
+ {
+ return timer.time();
+ }
+ TimeStamp playTime()
+ {
+ /*
+ * what the user currently hears is exactly latencySec before our
+ * port timeStamp (as this is the size of the audio buffer)
+ */
+ double latencySec = AudioSubSystem::the()->outputDelay();
+ TimeStamp t = time();
+
+ int sec = int(latencySec);
+ t.sec -= sec;
+ latencySec -= double(sec);
+ t.usec -= int(latencySec * 1000000.0);
+
+ if (t.usec < 0)
+ {
+ t.usec += 1000000;
+ t.sec -= 1;
+ }
+
+ arts_assert(t.usec >= 0 && t.usec < 1000000);
+ return t;
+ }
+ void processEvent(const MidiEvent& event)
+ {
+ timer.queueEvent(self(),event);
+ }
+ void processCommand(const MidiCommand& command)
+ {
+ mcopbyte channel = command.status & mcsChannelMask;
+
+ switch(command.status & mcsCommandMask)
+ {
+ case mcsNoteOn: noteOn(channel,command.data1,command.data2);
+ return;
+ case mcsNoteOff: noteOff(channel,command.data1);
+ return;
+ case mcsPitchWheel: pitchWheel(channel,command.data1,command.data2);
+ return;
+ case mcsProgram: channelData[channel].program = command.data1;
+ return;
+ case mcsParameter:
+ if(command.data1 == mcpAllNotesOff && command.data2 == 0)
+ for(mcopbyte note=0; note<128; note++)
+ noteOff(channel,note);
+ return;
+ }
+ }
+};
+REGISTER_IMPLEMENTATION(Synth_MIDI_TEST_impl);
+
+
+void Synth_MIDI_TEST_impl::busname(const string& newname)
+{
+ // TODO:
+ _busname = newname;
+}
+
+void Synth_MIDI_TEST_impl::filename(const string& newname)
+{
+ ifstream infile(newname.c_str());
+ string line;
+ vector<string> strseq;
+
+ while(getline(infile,line))
+ strseq.push_back(line);
+
+ _filename = newname;
+
+/* search extension */
+ string::const_reverse_iterator i;
+ string extension;
+ bool extensionok = false;
+
+ for(i = newname.rbegin(); i != newname.rend() && !extensionok; i++)
+ {
+ if(*i == '.')
+ extensionok = true;
+ else
+ extension.insert(extension.begin(), (char)tolower(*i));
+ }
+
+ if(extensionok && extension == "arts")
+ {
+ instrument.loadFromList(strseq);
+ _title = "aRts Instrument ("+instrument.name()+")";
+ useMap = false;
+ }
+ else if(extensionok && extension == "arts-map")
+ {
+ map.loadFromList(newname, strseq);
+ _title = "aRts Instrument (mapped)";
+ useMap = true;
+ }
+
+ if(!client.isNull())
+ client.title(title());
+ amClient.title(title());
+}
+
+Synth_MIDI_TEST_impl::Synth_MIDI_TEST_impl()
+ : amClient(amPlay, "aRts Instrument","Synth_MIDI_TEST")
+{
+ useMap = false;
+ client = MidiClient::null();
+ timer = SubClass("Arts::AudioMidiTimer");
+ channelData = new ChannelData[16];
+}
+
+Synth_MIDI_TEST_impl::~Synth_MIDI_TEST_impl()
+{
+ delete[] channelData;
+}
+
+void Synth_MIDI_TEST_impl::streamStart()
+{
+ // register with the midi manager
+ MidiManager manager = Reference("global:Arts_MidiManager");
+ if(!manager.isNull())
+ {
+ client = manager.addClient(mcdRecord,mctDestination,title(),
+ "Arts::Synth_MIDI_TEST");
+ client.addInputPort(self());
+ }
+ else
+ arts_warning("Synth_MIDI_TEST: no midi manager found - not registered");
+}
+
+void Synth_MIDI_TEST_impl::streamEnd()
+{
+ client = MidiClient::null();
+}
+
+void Synth_MIDI_TEST_impl::noteOn(mcopbyte channel, mcopbyte note,
+ mcopbyte velocity)
+{
+ if(velocity == 0)
+ {
+ noteOff(channel,note);
+ return;
+ }
+ if(!channelData[channel].voice[note].isNull())
+ {
+ noteOff(channel,note);
+ arts_info("Synth_MIDI_TEST: duplicate noteOn (mixed channels?)");
+ }
+
+ vector<InstrumentMap::InstrumentParam> *params = 0;
+ if(useMap)
+ {
+ mcopbyte program = channelData[channel].program;
+ StructureDesc sd = map.getInstrument(channel,note,velocity,program,params);
+ if(sd.isNull()) return;
+ instrument = sd;
+ }
+
+ Object structureObject = cache.get(instrument.name());
+ if(structureObject.isNull())
+ {
+ arts_debug("creating new structure");
+ structureObject = builder.createObject(instrument);
+
+ SynthModule play;
+ // TODO: allow changing busname!
+ if(!_busname.empty())
+ {
+ Synth_BUS_UPLINK b;
+ b.busname(_busname);
+ play = b;
+ }
+ else
+ {
+ Synth_AMAN_PLAY a(amClient);
+ play = a;
+ }
+ structureObject._addChild(play,"play");
+ connect(structureObject,"left",play,"left");
+ connect(structureObject,"right",play,"right");
+ }
+ else
+ {
+ arts_debug("used cached structure");
+ }
+
+ SynthModule structure = DynamicCast(structureObject);
+ assert(!structure.isNull());
+
+ if(params)
+ {
+ vector<InstrumentMap::InstrumentParam>::iterator pi;
+ for(pi = params->begin(); pi != params->end(); pi++)
+ {
+ DynamicRequest req(structure);
+
+ req.method("_set_"+pi->param).param(pi->value).invoke();
+ }
+ }
+ setValue(structure,"frequency",getFrequency(note,channel));
+ setValue(structure,"velocity",(float)velocity/127.0);
+ setValue(structure,"pressed",1.0);
+
+ get_AMAN_PLAY(structure).start();
+ structure.start();
+
+ channelData[channel].voice[note] = structure;
+ channelData[channel].name[note] = instrument.name();
+}
+
+void Synth_MIDI_TEST_impl::noteOff(mcopbyte channel, mcopbyte note)
+{
+ if(!channelData[channel].voice[note].isNull())
+ {
+ setValue(channelData[channel].voice[note],"pressed",0.0);
+
+ MidiReleaseHelper h;
+
+ h.voice(channelData[channel].voice[note]);
+ h.cache(cache);
+ h.name(channelData[channel].name[note]);
+
+ connect(channelData[channel].voice[note],"done",h,"done");
+ h.start();
+ assert(!h.terminate());
+ channelData[channel].voice[note] = SynthModule::null();
+ }
+}
+
+float Synth_MIDI_TEST_impl::getFrequency(mcopbyte note, mcopbyte channel)
+{
+ /* 2 semitones pitchshift */
+ return 261.63 * pow(2,((float)(note)+(channelData[channel].pitchShiftValue*2.0))/12.0)/32.0;
+}
+
+void Synth_MIDI_TEST_impl::pitchWheel(mcopbyte channel,
+ mcopbyte lsb, mcopbyte msb)
+{
+ mcopbyte note;
+
+ channelData[channel].pitchShiftValue =
+ (float)((lsb + msb*128) - (0x40*128))/8192.0;
+
+ for(note = 0; note < 128; note++)
+ {
+ if(!channelData[channel].voice[note].isNull())
+ setValue(channelData[channel].voice[note],"frequency",getFrequency(note,channel));
+ }
+}