2 Copyright (C) 2008 Hans Baier
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.
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.
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., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #include "midi++/midnam_patch.h"
25 #include "pbd/compose.h"
26 #include "pbd/convert.h"
27 #include "pbd/error.h"
28 #include "pbd/failed_constructor.h"
39 Patch::Patch (std::string name, uint8_t p_number, uint16_t b_number)
41 , _id (p_number, b_number)
45 int initialize_primary_key_from_commands (PatchPrimaryKey& id, const XMLNode* node)
49 const XMLNodeList events = node->children();
50 for (XMLNodeList::const_iterator i = events.begin(); i != events.end(); ++i) {
53 if (node->name() == "ControlChange") {
54 string control = node->property("Control")->value();
55 assert(control != "");
56 string value = node->property("Value")->value();
60 id.bank_number |= (PBD::atoi (value)) << 7;
61 } else if (control == "32") {
62 id.bank_number |= PBD::atoi (value);
65 } else if (node->name() == "ProgramChange") {
66 string number = node->property("Number")->value();
68 id.program_number = PBD::atoi(number);
76 Patch::get_state (void)
78 XMLNode* node = new XMLNode("Patch");
80 /* XXX this is totally wrong */
82 node->add_property("Number", string_compose ("%1", _id.program_number));
83 node->add_property("Name", _name);
86 typedef std::list< boost::shared_ptr< Evoral::MIDIEvent<double> > > PatchMidiCommands;
87 XMLNode* commands = node->add_child("PatchMIDICommands");
88 for (PatchMidiCommands::const_iterator event = _patch_midi_commands.begin();
89 event != _patch_midi_commands.end();
91 commands->add_child_copy(*((((Evoral::MIDIEvent&)*event)).to_xml()));
99 Patch::set_state (const XMLTree&, const XMLNode& node)
101 if (node.name() != "Patch") {
102 cerr << "Incorrect node " << node.name() << " handed to Patch" << endl;
106 const XMLProperty* prop = node.property ("Number");
111 _id.program_number = PBD::atoi (prop->value());
113 prop = node.property ("Name");
118 _name = prop->value();
120 XMLNode* commands = node.child("PatchMIDICommands");
123 if (initialize_primary_key_from_commands(_id, commands)) {
127 string program_change = node.property("ProgramChange")->value();
128 assert(program_change.length());
129 _id.program_number = PBD::atoi(program_change);
137 Note::get_state (void)
139 XMLNode* node = new XMLNode("Note");
140 node->add_property("Number", _number);
141 node->add_property("Name", _name);
148 Note::set_state (const XMLTree&, const XMLNode& node)
150 assert(node.name() == "Note");
151 _number = node.property("Number")->value();
152 _name = node.property("Name")->value();
158 NoteNameList::get_state (void)
160 XMLNode* node = new XMLNode("NoteNameList");
161 node->add_property("Name", _name);
167 NoteNameList::set_state (const XMLTree& tree, const XMLNode& node)
169 assert(node.name() == "NoteNameList");
170 _name = node.property("Name")->value();
172 boost::shared_ptr<XMLSharedNodeList> notes = tree.find("//Note");
173 for (XMLSharedNodeList::const_iterator i = notes->begin(); i != notes->end(); ++i) {
174 boost::shared_ptr<Note> note(new Note());
175 note->set_state (tree, *(*i));
176 _notes.push_back(note);
184 PatchBank::get_state (void)
186 XMLNode* node = new XMLNode("PatchBank");
187 node->add_property("Name", _name);
188 XMLNode* patch_name_list = node->add_child("PatchNameList");
189 for (PatchNameList::iterator patch = _patch_name_list.begin();
190 patch != _patch_name_list.end();
192 patch_name_list->add_child_nocopy((*patch)->get_state());
199 PatchBank::set_state (const XMLTree& tree, const XMLNode& node)
201 assert(node.name() == "PatchBank");
202 _name = node.property("Name")->value();
204 XMLNode* commands = node.child("MIDICommands");
206 PatchPrimaryKey id (0, 0);
207 if (initialize_primary_key_from_commands (id, commands)) {
210 _number = id.bank_number;
213 XMLNode* patch_name_list = node.child("PatchNameList");
215 if (patch_name_list) {
216 const XMLNodeList patches = patch_name_list->children();
217 for (XMLNodeList::const_iterator i = patches.begin(); i != patches.end(); ++i) {
218 boost::shared_ptr<Patch> patch (new Patch (string(), 0, _number));
219 patch->set_state(tree, *(*i));
220 _patch_name_list.push_back(patch);
223 XMLNode* use_patch_name_list = node.child ("UsesPatchNameList");
224 if (use_patch_name_list) {
225 _patch_list_name = use_patch_name_list->property ("Name")->value();
227 error << "Patch without patch name list - patchfile will be ignored" << endmsg;
236 PatchBank::set_patch_name_list (const PatchNameList& pnl)
238 _patch_name_list = pnl;
239 _patch_list_name = "";
241 for (PatchNameList::iterator p = _patch_name_list.begin(); p != _patch_name_list.end(); p++) {
242 (*p)->set_bank_number (_number);
249 operator<< (std::ostream& os, const ChannelNameSet& cns)
251 os << "Channel Name Set: name = " << cns._name << endl
252 << "Map size " << cns._patch_map.size () << endl
253 << "List size " << cns._patch_list.size() << endl
254 << "Patch list name = [" << cns._patch_list_name << ']' << endl
255 << "Available channels : ";
256 for (set<uint8_t>::iterator x = cns._available_for_channels.begin(); x != cns._available_for_channels.end(); ++x) {
257 os << (int) (*x) << ' ';
261 for (ChannelNameSet::PatchBanks::const_iterator pbi = cns._patch_banks.begin(); pbi != cns._patch_banks.end(); ++pbi) {
262 os << "\tPatch Bank " << (*pbi)->name() << " with " << (*pbi)->patch_name_list().size() << " patches\n";
263 for (PatchBank::PatchNameList::const_iterator pni = (*pbi)->patch_name_list().begin(); pni != (*pbi)->patch_name_list().end(); ++pni) {
264 os << "\t\tPatch name " << (*pni)->name() << " prog " << (int) (*pni)->program_number() << " bank " << (*pni)->bank_number() << endl;
272 ChannelNameSet::set_patch_banks (const ChannelNameSet::PatchBanks& pb)
277 _patch_list.clear ();
278 _patch_list_name = "";
279 _available_for_channels.clear ();
281 for (PatchBanks::const_iterator pbi = _patch_banks.begin(); pbi != _patch_banks.end(); ++pbi) {
282 for (PatchBank::PatchNameList::const_iterator pni = (*pbi)->patch_name_list().begin(); pni != (*pbi)->patch_name_list().end(); ++pni) {
283 _patch_map[(*pni)->patch_primary_key()] = (*pni);
284 _patch_list.push_back ((*pni)->patch_primary_key());
288 for (uint8_t n = 0; n < 16; ++n) {
289 _available_for_channels.insert (n);
294 ChannelNameSet::use_patch_name_list (const PatchBank::PatchNameList& pnl)
296 for (PatchBank::PatchNameList::const_iterator p = pnl.begin(); p != pnl.end(); ++p) {
297 _patch_map[(*p)->patch_primary_key()] = (*p);
298 _patch_list.push_back ((*p)->patch_primary_key());
303 ChannelNameSet::get_state (void)
305 XMLNode* node = new XMLNode("ChannelNameSet");
306 node->add_property("Name", _name);
308 XMLNode* available_for_channels = node->add_child("AvailableForChannels");
309 assert(available_for_channels);
311 for (uint8_t channel = 0; channel < 16; ++channel) {
312 XMLNode* available_channel = available_for_channels->add_child("AvailableChannel");
313 assert(available_channel);
315 available_channel->add_property("Channel", (long) channel);
317 if (_available_for_channels.find(channel) != _available_for_channels.end()) {
318 available_channel->add_property("Available", "true");
320 available_channel->add_property("Available", "false");
324 for (PatchBanks::iterator patch_bank = _patch_banks.begin();
325 patch_bank != _patch_banks.end();
327 node->add_child_nocopy((*patch_bank)->get_state());
334 ChannelNameSet::set_state (const XMLTree& tree, const XMLNode& node)
336 assert(node.name() == "ChannelNameSet");
337 _name = node.property("Name")->value();
339 const XMLNodeList children = node.children();
340 for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
343 if (node->name() == "AvailableForChannels") {
344 boost::shared_ptr<XMLSharedNodeList> channels =
345 tree.find("//AvailableChannel[@Available = 'true']/@Channel", node);
346 for(XMLSharedNodeList::const_iterator i = channels->begin();
347 i != channels->end();
349 _available_for_channels.insert(atoi((*i)->attribute_value().c_str()));
353 if (node->name() == "PatchBank") {
354 boost::shared_ptr<PatchBank> bank (new PatchBank ());
355 bank->set_state(tree, *node);
356 _patch_banks.push_back(bank);
357 const PatchBank::PatchNameList& patches = bank->patch_name_list();
358 for (PatchBank::PatchNameList::const_iterator patch = patches.begin();
359 patch != patches.end();
361 _patch_map[(*patch)->patch_primary_key()] = *patch;
362 _patch_list.push_back((*patch)->patch_primary_key());
371 CustomDeviceMode::set_state(const XMLTree& tree, const XMLNode& a_node)
373 assert(a_node.name() == "CustomDeviceMode");
375 _name = a_node.property("Name")->value();
377 boost::shared_ptr<XMLSharedNodeList> channel_name_set_assignments =
378 tree.find("//ChannelNameSetAssign", (XMLNode *)&a_node);
379 for(XMLSharedNodeList::const_iterator i = channel_name_set_assignments->begin();
380 i != channel_name_set_assignments->end();
382 int channel = atoi((*i)->property("Channel")->value().c_str());
383 string name_set = (*i)->property("NameSet")->value();
384 assert( 1 <= channel && channel <= 16 );
385 _channel_name_set_assignments[channel - 1] = name_set;
391 CustomDeviceMode::get_state(void)
393 XMLNode* custom_device_mode = new XMLNode("CustomDeviceMode");
394 custom_device_mode->add_property("Name", _name);
395 XMLNode* channel_name_set_assignments =
396 custom_device_mode->add_child("ChannelNameSetAssignments");
397 for (int i = 0; i < 15 && !_channel_name_set_assignments[i].empty(); i++) {
398 XMLNode* channel_name_set_assign =
399 channel_name_set_assignments->add_child("ChannelNameSetAssign");
400 channel_name_set_assign->add_property("Channel", i + 1);
401 channel_name_set_assign->add_property("NameSet", _channel_name_set_assignments[i]);
404 return *custom_device_mode;
407 boost::shared_ptr<CustomDeviceMode>
408 MasterDeviceNames::custom_device_mode_by_name(std::string mode_name)
410 // can't assert this, since in many of the patch files the mode name is empty
411 //assert(mode_name != "");
412 return _custom_device_modes[mode_name];
415 boost::shared_ptr<ChannelNameSet>
416 MasterDeviceNames::channel_name_set_by_device_mode_and_channel(std::string mode, uint8_t channel)
418 boost::shared_ptr<CustomDeviceMode> cdm = custom_device_mode_by_name(mode);
419 boost::shared_ptr<ChannelNameSet> cns = _channel_name_sets[cdm->channel_name_set_name_by_channel(channel)];
423 boost::shared_ptr<Patch>
424 MasterDeviceNames::find_patch(std::string mode, uint8_t channel, PatchPrimaryKey& key)
426 return channel_name_set_by_device_mode_and_channel(mode, channel)->find_patch(key);
430 MasterDeviceNames::set_state(const XMLTree& tree, const XMLNode& a_node)
433 boost::shared_ptr<XMLSharedNodeList> manufacturer = tree.find("//Manufacturer");
434 assert(manufacturer->size() == 1);
435 _manufacturer = manufacturer->front()->children().front()->content();
438 boost::shared_ptr<XMLSharedNodeList> models = tree.find("//Model");
439 assert(models->size() >= 1);
440 for (XMLSharedNodeList::iterator i = models->begin();
443 const XMLNodeList& contents = (*i)->children();
444 assert(contents.size() == 1);
445 XMLNode * content = *(contents.begin());
446 assert(content->is_content());
447 _models.push_back(content->content());
451 boost::shared_ptr<XMLSharedNodeList> custom_device_modes = tree.find("//CustomDeviceMode");
452 for (XMLSharedNodeList::iterator i = custom_device_modes->begin();
453 i != custom_device_modes->end();
455 boost::shared_ptr<CustomDeviceMode> custom_device_mode(new CustomDeviceMode());
456 custom_device_mode->set_state(tree, *(*i));
458 _custom_device_modes[custom_device_mode->name()] = custom_device_mode;
459 _custom_device_mode_names.push_back(custom_device_mode->name());
463 boost::shared_ptr<XMLSharedNodeList> channel_name_sets = tree.find("//ChannelNameSet");
464 for (XMLSharedNodeList::iterator i = channel_name_sets->begin();
465 i != channel_name_sets->end();
467 boost::shared_ptr<ChannelNameSet> channel_name_set(new ChannelNameSet());
468 channel_name_set->set_state(tree, *(*i));
469 _channel_name_sets[channel_name_set->name()] = channel_name_set;
473 boost::shared_ptr<XMLSharedNodeList> note_name_lists = tree.find("//NoteNameList");
474 for (XMLSharedNodeList::iterator i = note_name_lists->begin();
475 i != note_name_lists->end();
477 boost::shared_ptr<NoteNameList> note_name_list(new NoteNameList());
478 note_name_list->set_state (tree, *(*i));
479 _note_name_lists.push_back(note_name_list);
482 // global/post-facto PatchNameLists
483 boost::shared_ptr<XMLSharedNodeList> patch_name_lists = tree.find("/child::MIDINameDocument/child::MasterDeviceNames/child::PatchNameList");
484 for (XMLSharedNodeList::iterator i = patch_name_lists->begin();
485 i != patch_name_lists->end();
488 PatchBank::PatchNameList patch_name_list;
489 const XMLNodeList patches = (*i)->children();
491 for (XMLNodeList::const_iterator p = patches.begin(); p != patches.end(); ++p) {
492 boost::shared_ptr<Patch> patch (new Patch ());
493 patch->set_state(tree, *(*p));
494 patch_name_list.push_back(patch);
497 if (!patch_name_list.empty()) {
498 _patch_name_lists[(*i)->property ("Name")->value()] = patch_name_list;
502 /* now traverse patches and hook up anything that used UsePatchNameList
503 * to the right patch list
506 for (ChannelNameSets::iterator cns = _channel_name_sets.begin(); cns != _channel_name_sets.end(); ++cns) {
507 ChannelNameSet::PatchBanks pbs = cns->second->patch_banks();
508 PatchNameLists::iterator p;
510 for (ChannelNameSet::PatchBanks::iterator pb = pbs.begin(); pb != pbs.end(); ++pb) {
511 std::string pln = (*pb)->patch_list_name();
513 if ((p = _patch_name_lists.find (pln)) != _patch_name_lists.end()) {
514 if ((*pb)->set_patch_name_list (p->second)) {
517 cns->second->use_patch_name_list (p->second);
519 error << string_compose ("Patch list name %1 was not found - patch file ignored", pln) << endmsg;
531 MasterDeviceNames::get_state(void)
533 static XMLNode nothing("<nothing>");
537 MIDINameDocument::MIDINameDocument (const string& filename)
539 if (!_document.read (filename)) {
540 throw failed_constructor ();
543 set_state (_document, *_document.root());
547 MIDINameDocument::set_state (const XMLTree& tree, const XMLNode& a_node)
551 boost::shared_ptr<XMLSharedNodeList> author = tree.find("//Author");
552 if (author->size() < 1) {
553 error << "No author information in MIDNAM file" << endmsg;
557 if (author->front()->children().size() > 0) {
558 _author = author->front()->children().front()->content();
563 boost::shared_ptr<XMLSharedNodeList> master_device_names_list = tree.find ("//MasterDeviceNames");
565 for (XMLSharedNodeList::iterator i = master_device_names_list->begin();
566 i != master_device_names_list->end();
568 boost::shared_ptr<MasterDeviceNames> master_device_names(new MasterDeviceNames());
570 if (master_device_names->set_state(tree, *(*i))) {
574 for (MasterDeviceNames::Models::const_iterator model = master_device_names->models().begin();
575 model != master_device_names->models().end();
577 _master_device_names_list.insert(
578 std::pair<std::string, boost::shared_ptr<MasterDeviceNames> >
579 (*model, master_device_names));
581 _all_models.push_back(*model);
589 MIDINameDocument::get_state(void)
591 static XMLNode nothing("<nothing>");
595 const char* general_midi_program_names[128] = {
596 "Acoustic Grand Piano",
597 "Bright Acoustic Piano",
598 "Electric Grand Piano",
620 "Acoustic Guitar (nylon)",
621 "Acoustic Guitar (steel)",
622 "Electric Guitar (jazz)",
623 "Electric Guitar (clean)",
624 "Electric Guitar (muted)",
629 "Electric Bass (finger)",
630 "Electric Bass (pick)",
678 "Lead 3 (calliope lead)",
679 "Lead 4 (chiff lead)",
683 "Lead 8 (bass + lead)",