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);
132 XMLNode* use_note_name_list = node.child("UsesNoteNameList");
133 if (use_note_name_list) {
134 _note_list_name = use_note_name_list->property ("Name")->value();
141 Note::get_state (void)
143 XMLNode* node = new XMLNode("Note");
144 node->add_property("Number", _number);
145 node->add_property("Name", _name);
151 Note::set_state (const XMLTree&, const XMLNode& node)
153 assert(node.name() == "Note");
155 /* If the note number is junk, this will pull a number from the start, or
156 return zero if there isn't one. Better error detection would be a good
157 idea, but the duplicate check in NoteNameList::set_state() will probably
158 catch really broken files anyway. */
159 _number = atoi(node.property("Number")->value().c_str());
160 _name = node.property("Name")->value();
166 NoteNameList::get_state (void)
168 XMLNode* node = new XMLNode("NoteNameList");
169 node->add_property("Name", _name);
175 NoteNameList::set_state (const XMLTree& tree, const XMLNode& node)
177 assert(node.name() == "NoteNameList");
178 _name = node.property("Name")->value();
182 for (XMLNodeList::const_iterator i = node.children().begin();
183 i != node.children().end(); ++i) {
184 if ((*i)->name() != "Note") {
187 boost::shared_ptr<Note> note(new Note());
188 note->set_state (tree, *(*i));
189 if (note->number() > 127) {
190 PBD::warning << string_compose("Note number %1 in %3 out of range",
191 (int)note->number(), tree.filename())
193 } else if (_notes[note->number()]) {
195 string_compose("Duplicate note number %1 name %2 in %3 ignored",
196 (int)note->number(), note->name(), tree.filename())
199 _notes[note->number()] = note;
207 Control::get_state (void)
209 XMLNode* node = new XMLNode("Control");
210 node->add_property("Type", _type);
211 node->add_property("Number", _number);
212 node->add_property("Name", _name);
218 Control::set_state (const XMLTree&, const XMLNode& node)
220 assert(node.name() == "Control");
221 _type = node.property("Type")->value();
222 _number = node.property("Number")->value();
223 _name = node.property("Name")->value();
229 ControlNameList::get_state (void)
231 XMLNode* node = new XMLNode("ControlNameList");
232 node->add_property("Name", _name);
238 ControlNameList::set_state (const XMLTree& tree, const XMLNode& node)
240 assert(node.name() == "ControlNameList");
241 _name = node.property("Name")->value();
243 for (XMLNodeList::const_iterator i = node.children().begin();
244 i != node.children().end(); ++i) {
245 if ((*i)->name() != "comment") {
246 boost::shared_ptr<Control> control(new Control());
247 control->set_state (tree, *(*i));
248 _controls.push_back(control);
256 PatchBank::get_state (void)
258 XMLNode* node = new XMLNode("PatchBank");
259 node->add_property("Name", _name);
260 XMLNode* patch_name_list = node->add_child("PatchNameList");
261 for (PatchNameList::iterator patch = _patch_name_list.begin();
262 patch != _patch_name_list.end();
264 patch_name_list->add_child_nocopy((*patch)->get_state());
271 PatchBank::set_state (const XMLTree& tree, const XMLNode& node)
273 assert(node.name() == "PatchBank");
274 _name = node.property("Name")->value();
276 XMLNode* commands = node.child("MIDICommands");
278 PatchPrimaryKey id (0, 0);
279 if (initialize_primary_key_from_commands (id, commands)) {
282 _number = id.bank_number;
285 XMLNode* patch_name_list = node.child("PatchNameList");
287 if (patch_name_list) {
288 const XMLNodeList patches = patch_name_list->children();
289 for (XMLNodeList::const_iterator i = patches.begin(); i != patches.end(); ++i) {
290 boost::shared_ptr<Patch> patch (new Patch (string(), 0, _number));
291 patch->set_state(tree, *(*i));
292 _patch_name_list.push_back(patch);
295 XMLNode* use_patch_name_list = node.child ("UsesPatchNameList");
296 if (use_patch_name_list) {
297 _patch_list_name = use_patch_name_list->property ("Name")->value();
299 error << "Patch without patch name list - patchfile will be ignored" << endmsg;
308 PatchBank::set_patch_name_list (const PatchNameList& pnl)
310 _patch_name_list = pnl;
311 _patch_list_name = "";
313 for (PatchNameList::iterator p = _patch_name_list.begin(); p != _patch_name_list.end(); p++) {
314 (*p)->set_bank_number (_number);
321 operator<< (std::ostream& os, const ChannelNameSet& cns)
323 os << "Channel Name Set: name = " << cns._name << endl
324 << "Map size " << cns._patch_map.size () << endl
325 << "List size " << cns._patch_list.size() << endl
326 << "Patch list name = [" << cns._patch_list_name << ']' << endl
327 << "Available channels : ";
328 for (set<uint8_t>::iterator x = cns._available_for_channels.begin(); x != cns._available_for_channels.end(); ++x) {
329 os << (int) (*x) << ' ';
333 for (ChannelNameSet::PatchBanks::const_iterator pbi = cns._patch_banks.begin(); pbi != cns._patch_banks.end(); ++pbi) {
334 os << "\tPatch Bank " << (*pbi)->name() << " with " << (*pbi)->patch_name_list().size() << " patches\n";
335 for (PatchBank::PatchNameList::const_iterator pni = (*pbi)->patch_name_list().begin(); pni != (*pbi)->patch_name_list().end(); ++pni) {
336 os << "\t\tPatch name " << (*pni)->name() << " prog " << (int) (*pni)->program_number() << " bank " << (*pni)->bank_number() << endl;
344 ChannelNameSet::set_patch_banks (const ChannelNameSet::PatchBanks& pb)
349 _patch_list.clear ();
350 _patch_list_name = "";
351 _available_for_channels.clear ();
353 for (PatchBanks::const_iterator pbi = _patch_banks.begin(); pbi != _patch_banks.end(); ++pbi) {
354 for (PatchBank::PatchNameList::const_iterator pni = (*pbi)->patch_name_list().begin(); pni != (*pbi)->patch_name_list().end(); ++pni) {
355 _patch_map[(*pni)->patch_primary_key()] = (*pni);
356 _patch_list.push_back ((*pni)->patch_primary_key());
360 for (uint8_t n = 0; n < 16; ++n) {
361 _available_for_channels.insert (n);
366 ChannelNameSet::use_patch_name_list (const PatchBank::PatchNameList& pnl)
368 for (PatchBank::PatchNameList::const_iterator p = pnl.begin(); p != pnl.end(); ++p) {
369 _patch_map[(*p)->patch_primary_key()] = (*p);
370 _patch_list.push_back ((*p)->patch_primary_key());
375 ChannelNameSet::get_state (void)
377 XMLNode* node = new XMLNode("ChannelNameSet");
378 node->add_property("Name", _name);
380 XMLNode* available_for_channels = node->add_child("AvailableForChannels");
381 assert(available_for_channels);
383 for (uint8_t channel = 0; channel < 16; ++channel) {
384 XMLNode* available_channel = available_for_channels->add_child("AvailableChannel");
385 assert(available_channel);
387 available_channel->add_property("Channel", (long) channel);
389 if (_available_for_channels.find(channel) != _available_for_channels.end()) {
390 available_channel->add_property("Available", "true");
392 available_channel->add_property("Available", "false");
396 for (PatchBanks::iterator patch_bank = _patch_banks.begin();
397 patch_bank != _patch_banks.end();
399 node->add_child_nocopy((*patch_bank)->get_state());
406 ChannelNameSet::set_state (const XMLTree& tree, const XMLNode& node)
408 assert(node.name() == "ChannelNameSet");
409 _name = node.property("Name")->value();
411 const XMLNodeList children = node.children();
412 for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
415 if (node->name() == "AvailableForChannels") {
416 boost::shared_ptr<XMLSharedNodeList> channels =
417 tree.find("//AvailableChannel[@Available = 'true']/@Channel", node);
418 for(XMLSharedNodeList::const_iterator i = channels->begin();
419 i != channels->end();
421 _available_for_channels.insert(atoi((*i)->attribute_value().c_str()));
425 if (node->name() == "PatchBank") {
426 boost::shared_ptr<PatchBank> bank (new PatchBank ());
427 bank->set_state(tree, *node);
428 _patch_banks.push_back(bank);
429 const PatchBank::PatchNameList& patches = bank->patch_name_list();
430 for (PatchBank::PatchNameList::const_iterator patch = patches.begin();
431 patch != patches.end();
433 _patch_map[(*patch)->patch_primary_key()] = *patch;
434 _patch_list.push_back((*patch)->patch_primary_key());
443 CustomDeviceMode::set_state(const XMLTree& tree, const XMLNode& a_node)
445 assert(a_node.name() == "CustomDeviceMode");
447 _name = a_node.property("Name")->value();
449 boost::shared_ptr<XMLSharedNodeList> channel_name_set_assignments =
450 tree.find("//ChannelNameSetAssign", const_cast<XMLNode *>(&a_node));
451 for(XMLSharedNodeList::const_iterator i = channel_name_set_assignments->begin();
452 i != channel_name_set_assignments->end();
454 int channel = atoi((*i)->property("Channel")->value().c_str());
455 string name_set = (*i)->property("NameSet")->value();
456 assert( 1 <= channel && channel <= 16 );
457 _channel_name_set_assignments[channel - 1] = name_set;
463 CustomDeviceMode::get_state(void)
465 XMLNode* custom_device_mode = new XMLNode("CustomDeviceMode");
466 custom_device_mode->add_property("Name", _name);
467 XMLNode* channel_name_set_assignments =
468 custom_device_mode->add_child("ChannelNameSetAssignments");
469 for (int i = 0; i < 15 && !_channel_name_set_assignments[i].empty(); i++) {
470 XMLNode* channel_name_set_assign =
471 channel_name_set_assignments->add_child("ChannelNameSetAssign");
472 channel_name_set_assign->add_property("Channel", i + 1);
473 channel_name_set_assign->add_property("NameSet", _channel_name_set_assignments[i]);
476 return *custom_device_mode;
479 boost::shared_ptr<CustomDeviceMode>
480 MasterDeviceNames::custom_device_mode_by_name(std::string mode_name)
482 return _custom_device_modes[mode_name];
485 boost::shared_ptr<ChannelNameSet>
486 MasterDeviceNames::channel_name_set_by_device_mode_and_channel(std::string mode, uint8_t channel)
488 boost::shared_ptr<CustomDeviceMode> cdm = custom_device_mode_by_name(mode);
489 boost::shared_ptr<ChannelNameSet> cns = _channel_name_sets[cdm->channel_name_set_name_by_channel(channel)];
493 boost::shared_ptr<Patch>
494 MasterDeviceNames::find_patch(std::string mode, uint8_t channel, const PatchPrimaryKey& key)
496 return channel_name_set_by_device_mode_and_channel(mode, channel)->find_patch(key);
499 boost::shared_ptr<ChannelNameSet>
500 MasterDeviceNames::channel_name_set(const std::string& name)
502 ChannelNameSets::const_iterator i = _channel_name_sets.find(name);
503 if (i != _channel_name_sets.end()) {
506 return boost::shared_ptr<ChannelNameSet>();
509 boost::shared_ptr<NoteNameList>
510 MasterDeviceNames::note_name_list(const std::string& name)
512 NoteNameLists::const_iterator i = _note_name_lists.find(name);
513 if (i != _note_name_lists.end()) {
516 return boost::shared_ptr<NoteNameList>();
520 MasterDeviceNames::note_name(const std::string& mode_name,
530 boost::shared_ptr<const Patch> patch(
531 find_patch(mode_name, channel, PatchPrimaryKey(program, bank)));
536 boost::shared_ptr<const NoteNameList> note_names(
537 note_name_list(patch->note_list_name()));
542 boost::shared_ptr<const Note> note(note_names->notes()[number]);
543 return note ? note->name() : "";
547 MasterDeviceNames::set_state(const XMLTree& tree, const XMLNode&)
550 boost::shared_ptr<XMLSharedNodeList> manufacturer = tree.find("//Manufacturer");
551 assert(manufacturer->size() == 1);
552 _manufacturer = manufacturer->front()->children().front()->content();
555 boost::shared_ptr<XMLSharedNodeList> models = tree.find("//Model");
556 assert(models->size() >= 1);
557 for (XMLSharedNodeList::iterator i = models->begin();
560 const XMLNodeList& contents = (*i)->children();
561 assert(contents.size() == 1);
562 XMLNode * content = *(contents.begin());
563 assert(content->is_content());
564 _models.insert(content->content());
568 boost::shared_ptr<XMLSharedNodeList> custom_device_modes = tree.find("//CustomDeviceMode");
569 for (XMLSharedNodeList::iterator i = custom_device_modes->begin();
570 i != custom_device_modes->end();
572 boost::shared_ptr<CustomDeviceMode> custom_device_mode(new CustomDeviceMode());
573 custom_device_mode->set_state(tree, *(*i));
575 _custom_device_modes[custom_device_mode->name()] = custom_device_mode;
576 _custom_device_mode_names.push_back(custom_device_mode->name());
580 boost::shared_ptr<XMLSharedNodeList> channel_name_sets = tree.find("//ChannelNameSet");
581 for (XMLSharedNodeList::iterator i = channel_name_sets->begin();
582 i != channel_name_sets->end();
584 boost::shared_ptr<ChannelNameSet> channel_name_set(new ChannelNameSet());
585 channel_name_set->set_state(tree, *(*i));
586 _channel_name_sets[channel_name_set->name()] = channel_name_set;
590 boost::shared_ptr<XMLSharedNodeList> note_name_lists = tree.find("//NoteNameList");
591 for (XMLSharedNodeList::iterator i = note_name_lists->begin();
592 i != note_name_lists->end();
594 boost::shared_ptr<NoteNameList> note_name_list(new NoteNameList());
595 note_name_list->set_state (tree, *(*i));
596 _note_name_lists[(*i)->property ("Name")->value()] = note_name_list;
600 boost::shared_ptr<XMLSharedNodeList> control_name_lists = tree.find("//ControlNameList");
601 for (XMLSharedNodeList::iterator i = control_name_lists->begin();
602 i != control_name_lists->end();
604 boost::shared_ptr<ControlNameList> control_name_list(new ControlNameList());
605 control_name_list->set_state (tree, *(*i));
606 _control_name_lists.push_back(control_name_list);
609 // global/post-facto PatchNameLists
610 boost::shared_ptr<XMLSharedNodeList> patch_name_lists = tree.find("/child::MIDINameDocument/child::MasterDeviceNames/child::PatchNameList");
611 for (XMLSharedNodeList::iterator i = patch_name_lists->begin();
612 i != patch_name_lists->end();
615 PatchBank::PatchNameList patch_name_list;
616 const XMLNodeList patches = (*i)->children();
618 for (XMLNodeList::const_iterator p = patches.begin(); p != patches.end(); ++p) {
619 boost::shared_ptr<Patch> patch (new Patch ());
620 patch->set_state(tree, *(*p));
621 patch_name_list.push_back(patch);
624 if (!patch_name_list.empty()) {
625 _patch_name_lists[(*i)->property ("Name")->value()] = patch_name_list;
629 /* now traverse patches and hook up anything that used UsePatchNameList
630 * to the right patch list
633 for (ChannelNameSets::iterator cns = _channel_name_sets.begin(); cns != _channel_name_sets.end(); ++cns) {
634 ChannelNameSet::PatchBanks pbs = cns->second->patch_banks();
635 PatchNameLists::iterator p;
637 for (ChannelNameSet::PatchBanks::iterator pb = pbs.begin(); pb != pbs.end(); ++pb) {
638 std::string pln = (*pb)->patch_list_name();
640 if ((p = _patch_name_lists.find (pln)) != _patch_name_lists.end()) {
641 if ((*pb)->set_patch_name_list (p->second)) {
644 cns->second->use_patch_name_list (p->second);
646 error << string_compose ("Patch list name %1 was not found - patch file ignored", pln) << endmsg;
658 MasterDeviceNames::get_state(void)
660 static XMLNode nothing("<nothing>");
664 MIDINameDocument::MIDINameDocument (const string& filename)
666 if (!_document.read (filename)) {
667 throw failed_constructor ();
670 set_state (_document, *_document.root());
674 MIDINameDocument::set_state (const XMLTree& tree, const XMLNode&)
678 boost::shared_ptr<XMLSharedNodeList> author = tree.find("//Author");
679 if (author->size() < 1) {
680 error << "No author information in MIDNAM file" << endmsg;
684 if (author->front()->children().size() > 0) {
685 _author = author->front()->children().front()->content();
690 boost::shared_ptr<XMLSharedNodeList> master_device_names_list = tree.find ("//MasterDeviceNames");
692 for (XMLSharedNodeList::iterator i = master_device_names_list->begin();
693 i != master_device_names_list->end();
695 boost::shared_ptr<MasterDeviceNames> master_device_names(new MasterDeviceNames());
697 if (master_device_names->set_state(tree, *(*i))) {
701 for (MasterDeviceNames::Models::const_iterator model = master_device_names->models().begin();
702 model != master_device_names->models().end();
704 _master_device_names_list.insert(
705 std::pair<std::string, boost::shared_ptr<MasterDeviceNames> >
706 (*model, master_device_names));
708 _all_models.insert(*model);
716 MIDINameDocument::get_state(void)
718 static XMLNode nothing("<nothing>");
722 boost::shared_ptr<MasterDeviceNames>
723 MIDINameDocument::master_device_names(const std::string& model)
725 MasterDeviceNamesList::const_iterator m = _master_device_names_list.find(model);
726 if (m != _master_device_names_list.end()) {
727 return boost::shared_ptr<MasterDeviceNames>(m->second);
729 return boost::shared_ptr<MasterDeviceNames>();
732 const char* general_midi_program_names[128] = {
733 "Acoustic Grand Piano",
734 "Bright Acoustic Piano",
735 "Electric Grand Piano",
757 "Acoustic Guitar (nylon)",
758 "Acoustic Guitar (steel)",
759 "Electric Guitar (jazz)",
760 "Electric Guitar (clean)",
761 "Electric Guitar (muted)",
766 "Electric Bass (finger)",
767 "Electric Bass (pick)",
815 "Lead 3 (calliope lead)",
816 "Lead 4 (chiff lead)",
820 "Lead 8 (bass + lead)",