libs/midi++2/midnam_patch.cc

   1 /*
   2     Copyright (C) 2008 Hans Baier
   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., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18     $Id$
  19 */
  20
  21 #include <algorithm>
  22 #include <iostream>
  23
  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"
  29
  30 using namespace std;
  31 using PBD::error;
  32
  33 namespace MIDI
  34 {
  35
  36 namespace Name
  37 {
  38
  39 Patch::Patch (std::string name, uint8_t p_number, uint16_t b_number)
  40         : _name (name)
  41         , _id (p_number, b_number)
  42 {
  43 }
  44
  45 int initialize_primary_key_from_commands (PatchPrimaryKey& id, const XMLNode* node)
  46 {
  47         id.bank_number = 0;
  48
  49         const XMLNodeList events = node->children();
  50         for (XMLNodeList::const_iterator i = events.begin(); i != events.end(); ++i) {
  51
  52                 XMLNode* node = *i;
  53                 if (node->name() == "ControlChange") {
  54                         string control = node->property("Control")->value();
  55                         assert(control != "");
  56                         string value = node->property("Value")->value();
  57                         assert(value != "");
  58
  59                         if (control == "0") {
  60                                 id.bank_number |= (PBD::atoi (value)) << 7;
  61                         } else if (control == "32") {
  62                                 id.bank_number |= PBD::atoi (value);
  63                         }
  64
  65                 } else if (node->name() == "ProgramChange") {
  66                         string number = node->property("Number")->value();
  67                         assert(number != "");
  68                         id.program_number = PBD::atoi(number);
  69                 }
  70         }
  71
  72         return 0;
  73 }
  74
  75 XMLNode&
  76 Patch::get_state (void)
  77 {
  78         XMLNode* node = new XMLNode("Patch");
  79
  80         /* XXX this is totally wrong */
  81
  82         node->add_property("Number", string_compose ("%1", _id.program_number));
  83         node->add_property("Name",   _name);
  84
  85         /*
  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();
  90             ++event) {
  91                 commands->add_child_copy(*((((Evoral::MIDIEvent&)*event)).to_xml()));
  92         }
  93         */
  94
  95         return *node;
  96 }
  97
  98 int
  99 Patch::set_state (const XMLTree&, const XMLNode& node)
 100 {
 101         if (node.name() != "Patch") {
 102                 cerr << "Incorrect node " << node.name() << " handed to Patch" << endl;
 103                 return -1;
 104         }
 105
 106         const XMLProperty* prop = node.property ("Number");
 107
 108         if (!prop) {
 109                 return -1;
 110         }
 111         _id.program_number = PBD::atoi (prop->value());
 112
 113         prop = node.property ("Name");
 114
 115         if (!prop) {
 116                 return -1;
 117         }
 118         _name   = prop->value();
 119
 120         XMLNode* commands = node.child("PatchMIDICommands");
 121
 122         if (commands) {
 123                 if (initialize_primary_key_from_commands(_id, commands)) {
 124                         return -1;
 125                 }
 126         } else {
 127                 string program_change = node.property("ProgramChange")->value();
 128                 assert(program_change.length());
 129                 _id.program_number = PBD::atoi(program_change);
 130         }
 131
 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();
 135         }
 136
 137         return 0;
 138 }
 139
 140 XMLNode&
 141 Note::get_state (void)
 142 {
 143         XMLNode* node = new XMLNode("Note");
 144         node->add_property("Number", _number + 1);
 145         node->add_property("Name",   _name);
 146
 147         return *node;
 148 }
 149
 150 int
 151 Note::set_state (const XMLTree&, const XMLNode& node)
 152 {
 153         assert(node.name() == "Note");
 154
 155         /* If the note number is junk, this will pull a number from the start, or
 156            return zero if there isn't one.  The decrement will make that zero
 157            illegal since note numbers in the file are one-based.  Better error
 158            detection would be a good idea, but the duplicate check in
 159            NoteNameList::set_state() will probably catch most errors anyway. */
 160         _number = atoi(node.property("Number")->value().c_str()) - 1;
 161         _name   = node.property("Name")->value();
 162
 163         return 0;
 164 }
 165
 166 XMLNode&
 167 NoteNameList::get_state (void)
 168 {
 169         XMLNode* node = new XMLNode("NoteNameList");
 170         node->add_property("Name", _name);
 171
 172         return *node;
 173 }
 174
 175 int
 176 NoteNameList::set_state (const XMLTree& tree, const XMLNode& node)
 177 {
 178         assert(node.name() == "NoteNameList");
 179         _name = node.property("Name")->value();
 180         _notes.clear();
 181         _notes.resize(128);
 182
 183         for (XMLNodeList::const_iterator i = node.children().begin();
 184              i != node.children().end(); ++i) {
 185                 if ((*i)->name() != "Note") {
 186                         continue;
 187                 }
 188                 boost::shared_ptr<Note> note(new Note());
 189                 note->set_state (tree, *(*i));
 190                 if (note->number() > 127) {
 191                         PBD::warning << string_compose("%1: Note number %2 (%3) out of range",
 192                                                        tree.filename(), (int)note->number(), note->name())
 193                                      << endmsg;
 194                 } else if (_notes[note->number()]) {
 195                         PBD::warning <<
 196                                 string_compose("%1: Duplicate note number %2 (%3) ignored",
 197                                                tree.filename(), (int)note->number(), note->name())
 198                                      << endmsg;
 199                 } else {
 200                         _notes[note->number()] = note;
 201                 }
 202         }
 203
 204         return 0;
 205 }
 206
 207 XMLNode&
 208 Control::get_state (void)
 209 {
 210         XMLNode* node = new XMLNode("Control");
 211         node->add_property("Type",   _type);
 212         node->add_property("Number", _number);
 213         node->add_property("Name",   _name);
 214
 215         return *node;
 216 }
 217
 218 int
 219 Control::set_state (const XMLTree&, const XMLNode& node)
 220 {
 221         assert(node.name() == "Control");
 222         _type   = node.property("Type")->value();
 223         _number = node.property("Number")->value();
 224         _name   = node.property("Name")->value();
 225
 226         return 0;
 227 }
 228
 229 XMLNode&
 230 ControlNameList::get_state (void)
 231 {
 232         XMLNode* node = new XMLNode("ControlNameList");
 233         node->add_property("Name", _name);
 234
 235         return *node;
 236 }
 237
 238 int
 239 ControlNameList::set_state (const XMLTree& tree, const XMLNode& node)
 240 {
 241         assert(node.name() == "ControlNameList");
 242         _name = node.property("Name")->value();
 243
 244         for (XMLNodeList::const_iterator i = node.children().begin();
 245              i != node.children().end(); ++i) {
 246                 if ((*i)->name() != "comment") {
 247                         boost::shared_ptr<Control> control(new Control());
 248                         control->set_state (tree, *(*i));
 249                         _controls.push_back(control);
 250                 }
 251         }
 252
 253         return 0;
 254 }
 255
 256 XMLNode&
 257 PatchBank::get_state (void)
 258 {
 259         XMLNode* node = new XMLNode("PatchBank");
 260         node->add_property("Name",   _name);
 261         XMLNode* patch_name_list = node->add_child("PatchNameList");
 262         for (PatchNameList::iterator patch = _patch_name_list.begin();
 263             patch != _patch_name_list.end();
 264             ++patch) {
 265                 patch_name_list->add_child_nocopy((*patch)->get_state());
 266         }
 267
 268         return *node;
 269 }
 270
 271 int
 272 PatchBank::set_state (const XMLTree& tree, const XMLNode& node)
 273 {
 274         assert(node.name() == "PatchBank");
 275         _name   = node.property("Name")->value();
 276
 277         XMLNode* commands = node.child("MIDICommands");
 278         if (commands) {
 279                 PatchPrimaryKey id (0, 0);
 280                 if (initialize_primary_key_from_commands (id, commands)) {
 281                         return -1;
 282                 }
 283                 _number = id.bank_number;
 284         }
 285
 286         XMLNode* patch_name_list = node.child("PatchNameList");
 287
 288         if (patch_name_list) {
 289                 const XMLNodeList patches = patch_name_list->children();
 290                 for (XMLNodeList::const_iterator i = patches.begin(); i != patches.end(); ++i) {
 291                         boost::shared_ptr<Patch> patch (new Patch (string(), 0, _number));
 292                         patch->set_state(tree, *(*i));
 293                         _patch_name_list.push_back(patch);
 294                 }
 295         } else {
 296                 XMLNode* use_patch_name_list = node.child ("UsesPatchNameList");
 297                 if (use_patch_name_list) {
 298                         _patch_list_name = use_patch_name_list->property ("Name")->value();
 299                 } else {
 300                         error << "Patch without patch name list - patchfile will be ignored" << endmsg;
 301                         return -1;
 302                 }
 303         }
 304
 305         return 0;
 306 }
 307
 308 int
 309 PatchBank::set_patch_name_list (const PatchNameList& pnl)
 310 {
 311         _patch_name_list = pnl;
 312         _patch_list_name = "";
 313
 314         for (PatchNameList::iterator p = _patch_name_list.begin(); p != _patch_name_list.end(); p++) {
 315                 (*p)->set_bank_number (_number);
 316         }
 317
 318         return 0;
 319 }
 320
 321 std::ostream&
 322 operator<< (std::ostream& os, const ChannelNameSet& cns)
 323 {
 324         os << "Channel Name Set: name = " << cns._name << endl
 325            << "Map size " << cns._patch_map.size () << endl
 326            << "List size " << cns._patch_list.size() << endl
 327            << "Patch list name = [" << cns._patch_list_name << ']' << endl
 328            << "Available channels : ";
 329         for (set<uint8_t>::iterator x = cns._available_for_channels.begin(); x != cns._available_for_channels.end(); ++x) {
 330                 os << (int) (*x) << ' ';
 331         }
 332         os << endl;
 333
 334         for (ChannelNameSet::PatchBanks::const_iterator pbi = cns._patch_banks.begin(); pbi != cns._patch_banks.end(); ++pbi) {
 335                 os << "\tPatch Bank " << (*pbi)->name() << " with " << (*pbi)->patch_name_list().size() << " patches\n";
 336                 for (PatchBank::PatchNameList::const_iterator pni = (*pbi)->patch_name_list().begin(); pni != (*pbi)->patch_name_list().end(); ++pni) {
 337                         os << "\t\tPatch name " << (*pni)->name() << " prog " << (int) (*pni)->program_number() << " bank " << (*pni)->bank_number() << endl;
 338                 }
 339         }
 340
 341         return os;
 342 }
 343
 344 void
 345 ChannelNameSet::set_patch_banks (const ChannelNameSet::PatchBanks& pb)
 346 {
 347         _patch_banks = pb;
 348
 349         _patch_map.clear ();
 350         _patch_list.clear ();
 351         _patch_list_name = "";
 352         _available_for_channels.clear ();
 353
 354         for (PatchBanks::const_iterator pbi = _patch_banks.begin(); pbi != _patch_banks.end(); ++pbi) {
 355                 for (PatchBank::PatchNameList::const_iterator pni = (*pbi)->patch_name_list().begin(); pni != (*pbi)->patch_name_list().end(); ++pni) {
 356                         _patch_map[(*pni)->patch_primary_key()] = (*pni);
 357                         _patch_list.push_back ((*pni)->patch_primary_key());
 358                 }
 359         }
 360
 361         for (uint8_t n = 0; n < 16; ++n) {
 362                 _available_for_channels.insert (n);
 363         }
 364 }
 365
 366 void
 367 ChannelNameSet::use_patch_name_list (const PatchBank::PatchNameList& pnl)
 368 {
 369         for (PatchBank::PatchNameList::const_iterator p = pnl.begin(); p != pnl.end(); ++p) {
 370                 _patch_map[(*p)->patch_primary_key()] = (*p);
 371                 _patch_list.push_back ((*p)->patch_primary_key());
 372         }
 373 }
 374
 375 XMLNode&
 376 ChannelNameSet::get_state (void)
 377 {
 378         XMLNode* node = new XMLNode("ChannelNameSet");
 379         node->add_property("Name",   _name);
 380
 381         XMLNode* available_for_channels = node->add_child("AvailableForChannels");
 382         assert(available_for_channels);
 383
 384         for (uint8_t channel = 0; channel < 16; ++channel) {
 385                 XMLNode* available_channel = available_for_channels->add_child("AvailableChannel");
 386                 assert(available_channel);
 387
 388                 available_channel->add_property("Channel", (long) channel);
 389
 390                 if (_available_for_channels.find(channel) != _available_for_channels.end()) {
 391                         available_channel->add_property("Available", "true");
 392                 } else {
 393                         available_channel->add_property("Available", "false");
 394                 }
 395         }
 396
 397         for (PatchBanks::iterator patch_bank = _patch_banks.begin();
 398             patch_bank != _patch_banks.end();
 399             ++patch_bank) {
 400                 node->add_child_nocopy((*patch_bank)->get_state());
 401         }
 402
 403         return *node;
 404 }
 405
 406 int
 407 ChannelNameSet::set_state (const XMLTree& tree, const XMLNode& node)
 408 {
 409         assert(node.name() == "ChannelNameSet");
 410         _name   = node.property("Name")->value();
 411
 412         const XMLNodeList children = node.children();
 413         for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
 414                 XMLNode* node = *i;
 415                 assert(node);
 416                 if (node->name() == "AvailableForChannels") {
 417                         boost::shared_ptr<XMLSharedNodeList> channels =
 418                                 tree.find("//AvailableChannel[@Available = 'true']/@Channel", node);
 419                         for(XMLSharedNodeList::const_iterator i = channels->begin();
 420                             i != channels->end();
 421                             ++i) {
 422                                 _available_for_channels.insert(atoi((*i)->attribute_value().c_str()));
 423                         }
 424                 }
 425
 426                 if (node->name() == "PatchBank") {
 427                         boost::shared_ptr<PatchBank> bank (new PatchBank ());
 428                         bank->set_state(tree, *node);
 429                         _patch_banks.push_back(bank);
 430                         const PatchBank::PatchNameList& patches = bank->patch_name_list();
 431                         for (PatchBank::PatchNameList::const_iterator patch = patches.begin();
 432                              patch != patches.end();
 433                              ++patch) {
 434                                 _patch_map[(*patch)->patch_primary_key()] = *patch;
 435                                 _patch_list.push_back((*patch)->patch_primary_key());
 436                         }
 437                 }
 438         }
 439
 440         return 0;
 441 }
 442
 443 int
 444 CustomDeviceMode::set_state(const XMLTree& tree, const XMLNode& a_node)
 445 {
 446         assert(a_node.name() == "CustomDeviceMode");
 447
 448         _name = a_node.property("Name")->value();
 449
 450         boost::shared_ptr<XMLSharedNodeList> channel_name_set_assignments =
 451                 tree.find("//ChannelNameSetAssign", const_cast<XMLNode *>(&a_node));
 452         for(XMLSharedNodeList::const_iterator i = channel_name_set_assignments->begin();
 453             i != channel_name_set_assignments->end();
 454             ++i) {
 455                 int channel = atoi((*i)->property("Channel")->value().c_str());
 456                 string name_set = (*i)->property("NameSet")->value();
 457                 assert( 1 <= channel && channel <= 16 );
 458                 _channel_name_set_assignments[channel - 1] = name_set;
 459         }
 460         return 0;
 461 }
 462
 463 XMLNode&
 464 CustomDeviceMode::get_state(void)
 465 {
 466         XMLNode* custom_device_mode = new XMLNode("CustomDeviceMode");
 467         custom_device_mode->add_property("Name",   _name);
 468         XMLNode* channel_name_set_assignments =
 469                 custom_device_mode->add_child("ChannelNameSetAssignments");
 470         for (int i = 0; i < 15 && !_channel_name_set_assignments[i].empty(); i++) {
 471                 XMLNode* channel_name_set_assign =
 472                         channel_name_set_assignments->add_child("ChannelNameSetAssign");
 473                 channel_name_set_assign->add_property("Channel", i + 1);
 474                 channel_name_set_assign->add_property("NameSet", _channel_name_set_assignments[i]);
 475         }
 476
 477         return *custom_device_mode;
 478 }
 479
 480 boost::shared_ptr<CustomDeviceMode>
 481 MasterDeviceNames::custom_device_mode_by_name(std::string mode_name)
 482 {
 483         return _custom_device_modes[mode_name];
 484 }
 485
 486 boost::shared_ptr<ChannelNameSet>
 487 MasterDeviceNames::channel_name_set_by_device_mode_and_channel(std::string mode, uint8_t channel)
 488 {
 489         boost::shared_ptr<CustomDeviceMode> cdm = custom_device_mode_by_name(mode);
 490         boost::shared_ptr<ChannelNameSet> cns =  _channel_name_sets[cdm->channel_name_set_name_by_channel(channel)];
 491         return cns;
 492 }
 493
 494 boost::shared_ptr<Patch>
 495 MasterDeviceNames::find_patch(std::string mode, uint8_t channel, const PatchPrimaryKey& key)
 496 {
 497         return channel_name_set_by_device_mode_and_channel(mode, channel)->find_patch(key);
 498 }
 499
 500 boost::shared_ptr<ChannelNameSet>
 501 MasterDeviceNames::channel_name_set(const std::string& name)
 502 {
 503         ChannelNameSets::const_iterator i = _channel_name_sets.find(name);
 504         if (i != _channel_name_sets.end()) {
 505                 return i->second;
 506         }
 507         return boost::shared_ptr<ChannelNameSet>();
 508 }
 509
 510 boost::shared_ptr<NoteNameList>
 511 MasterDeviceNames::note_name_list(const std::string& name)
 512 {
 513         NoteNameLists::const_iterator i = _note_name_lists.find(name);
 514         if (i != _note_name_lists.end()) {
 515                 return i->second;
 516         }
 517         return boost::shared_ptr<NoteNameList>();
 518 }
 519
 520 std::string
 521 MasterDeviceNames::note_name(const std::string& mode_name,
 522                              uint8_t            channel,
 523                              uint16_t           bank,
 524                              uint8_t            program,
 525                              uint8_t            number)
 526 {
 527         if (number > 127) {
 528                 return "";
 529         }
 530
 531         boost::shared_ptr<const Patch> patch(
 532                 find_patch(mode_name, channel, PatchPrimaryKey(program, bank)));
 533         if (!patch) {
 534                 return "";
 535         }
 536
 537         boost::shared_ptr<const NoteNameList> note_names(
 538                 note_name_list(patch->note_list_name()));
 539         if (!note_names) {
 540                 return "";
 541         }
 542
 543         boost::shared_ptr<const Note> note(note_names->notes()[number]);
 544         return note ? note->name() : "";
 545 }
 546
 547 int
 548 MasterDeviceNames::set_state(const XMLTree& tree, const XMLNode&)
 549 {
 550         // Manufacturer
 551         boost::shared_ptr<XMLSharedNodeList> manufacturer = tree.find("//Manufacturer");
 552         assert(manufacturer->size() == 1);
 553         _manufacturer = manufacturer->front()->children().front()->content();
 554
 555         // Models
 556         boost::shared_ptr<XMLSharedNodeList> models = tree.find("//Model");
 557         assert(models->size() >= 1);
 558         for (XMLSharedNodeList::iterator i = models->begin();
 559              i != models->end();
 560              ++i) {
 561                 const XMLNodeList& contents = (*i)->children();
 562                 assert(contents.size() == 1);
 563                 XMLNode * content = *(contents.begin());
 564                 assert(content->is_content());
 565                 _models.insert(content->content());
 566         }
 567
 568         // CustomDeviceModes
 569         boost::shared_ptr<XMLSharedNodeList> custom_device_modes = tree.find("//CustomDeviceMode");
 570         for (XMLSharedNodeList::iterator i = custom_device_modes->begin();
 571              i != custom_device_modes->end();
 572              ++i) {
 573                 boost::shared_ptr<CustomDeviceMode> custom_device_mode(new CustomDeviceMode());
 574                 custom_device_mode->set_state(tree, *(*i));
 575
 576                 _custom_device_modes[custom_device_mode->name()] = custom_device_mode;
 577                 _custom_device_mode_names.push_back(custom_device_mode->name());
 578         }
 579
 580         // ChannelNameSets
 581         boost::shared_ptr<XMLSharedNodeList> channel_name_sets = tree.find("//ChannelNameSet");
 582         for (XMLSharedNodeList::iterator i = channel_name_sets->begin();
 583              i != channel_name_sets->end();
 584              ++i) {
 585                 boost::shared_ptr<ChannelNameSet> channel_name_set(new ChannelNameSet());
 586                 channel_name_set->set_state(tree, *(*i));
 587                 _channel_name_sets[channel_name_set->name()] = channel_name_set;
 588         }
 589
 590         // NoteNameLists
 591         boost::shared_ptr<XMLSharedNodeList> note_name_lists = tree.find("//NoteNameList");
 592         for (XMLSharedNodeList::iterator i = note_name_lists->begin();
 593              i != note_name_lists->end();
 594              ++i) {
 595                 boost::shared_ptr<NoteNameList> note_name_list(new NoteNameList());
 596                 note_name_list->set_state (tree, *(*i));
 597                 _note_name_lists[(*i)->property ("Name")->value()] = note_name_list;
 598         }
 599
 600         // ControlNameLists
 601         boost::shared_ptr<XMLSharedNodeList> control_name_lists = tree.find("//ControlNameList");
 602         for (XMLSharedNodeList::iterator i = control_name_lists->begin();
 603              i != control_name_lists->end();
 604              ++i) {
 605                 boost::shared_ptr<ControlNameList> control_name_list(new ControlNameList());
 606                 control_name_list->set_state (tree, *(*i));
 607                 _control_name_lists.push_back(control_name_list);
 608         }
 609
 610         // global/post-facto PatchNameLists
 611         boost::shared_ptr<XMLSharedNodeList> patch_name_lists = tree.find("/child::MIDINameDocument/child::MasterDeviceNames/child::PatchNameList");
 612         for (XMLSharedNodeList::iterator i = patch_name_lists->begin();
 613              i != patch_name_lists->end();
 614              ++i) {
 615
 616                 PatchBank::PatchNameList patch_name_list;
 617                 const XMLNodeList patches = (*i)->children();
 618
 619                 for (XMLNodeList::const_iterator p = patches.begin(); p != patches.end(); ++p) {
 620                         boost::shared_ptr<Patch> patch (new Patch ());
 621                         patch->set_state(tree, *(*p));
 622                         patch_name_list.push_back(patch);
 623                 }
 624
 625                 if (!patch_name_list.empty()) {
 626                         _patch_name_lists[(*i)->property ("Name")->value()] = patch_name_list;
 627                 }
 628         }
 629
 630         /* now traverse patches and hook up anything that used UsePatchNameList
 631          * to the right patch list
 632          */
 633
 634         for (ChannelNameSets::iterator cns = _channel_name_sets.begin(); cns != _channel_name_sets.end(); ++cns) {
 635                 ChannelNameSet::PatchBanks pbs = cns->second->patch_banks();
 636                 PatchNameLists::iterator p;
 637
 638                 for (ChannelNameSet::PatchBanks::iterator pb = pbs.begin(); pb != pbs.end(); ++pb) {
 639                         std::string pln = (*pb)->patch_list_name();
 640                         if (!pln.empty()) {
 641                                 if ((p = _patch_name_lists.find (pln)) != _patch_name_lists.end()) {
 642                                         if ((*pb)->set_patch_name_list (p->second)) {
 643                                                 return -1;
 644                                         }
 645                                         cns->second->use_patch_name_list (p->second);
 646                                 } else {
 647                                         error << string_compose ("Patch list name %1 was not found - patch file ignored", pln) << endmsg;
 648                                         return -1;
 649                                 }
 650                         }
 651                 }
 652
 653         }
 654
 655         return 0;
 656 }
 657
 658 XMLNode&
 659 MasterDeviceNames::get_state(void)
 660 {
 661         static XMLNode nothing("<nothing>");
 662         return nothing;
 663 }
 664
 665 MIDINameDocument::MIDINameDocument (const string& filename)
 666 {
 667         if (!_document.read (filename)) {
 668                 throw failed_constructor ();
 669         }
 670
 671         _document.set_filename (filename);
 672         set_state (_document, *_document.root());
 673 }
 674
 675 int
 676 MIDINameDocument::set_state (const XMLTree& tree, const XMLNode&)
 677 {
 678         // Author
 679
 680         boost::shared_ptr<XMLSharedNodeList> author = tree.find("//Author");
 681         if (author->size() < 1) {
 682                 error << "No author information in MIDNAM file" << endmsg;
 683                 return -1;
 684         }
 685
 686         if (author->front()->children().size() > 0) {
 687                 _author = author->front()->children().front()->content();
 688         }
 689
 690         // MasterDeviceNames
 691
 692         boost::shared_ptr<XMLSharedNodeList> master_device_names_list = tree.find ("//MasterDeviceNames");
 693
 694         for (XMLSharedNodeList::iterator i = master_device_names_list->begin();
 695              i != master_device_names_list->end();
 696              ++i) {
 697                 boost::shared_ptr<MasterDeviceNames> master_device_names(new MasterDeviceNames());
 698
 699                 if (master_device_names->set_state(tree, *(*i))) {
 700                         return -1;
 701                 }
 702
 703                 for (MasterDeviceNames::Models::const_iterator model = master_device_names->models().begin();
 704                      model != master_device_names->models().end();
 705                      ++model) {
 706                         _master_device_names_list.insert(
 707                                 std::pair<std::string, boost::shared_ptr<MasterDeviceNames> >
 708                                 (*model,      master_device_names));
 709
 710                         _all_models.insert(*model);
 711                 }
 712         }
 713
 714         return 0;
 715 }
 716
 717 XMLNode&
 718 MIDINameDocument::get_state(void)
 719 {
 720         static XMLNode nothing("<nothing>");
 721         return nothing;
 722 }
 723
 724 boost::shared_ptr<MasterDeviceNames>
 725 MIDINameDocument::master_device_names(const std::string& model)
 726 {
 727         MasterDeviceNamesList::const_iterator m = _master_device_names_list.find(model);
 728         if (m != _master_device_names_list.end()) {
 729                 return boost::shared_ptr<MasterDeviceNames>(m->second);
 730         }
 731         return boost::shared_ptr<MasterDeviceNames>();
 732 }
 733
 734 const char* general_midi_program_names[128] = {
 735         "Acoustic Grand Piano",
 736         "Bright Acoustic Piano",
 737         "Electric Grand Piano",
 738         "Honky-tonk Piano",
 739         "Rhodes Piano",
 740         "Chorused Piano",
 741         "Harpsichord",
 742         "Clavinet",
 743         "Celesta",
 744         "Glockenspiel",
 745         "Music Box",
 746         "Vibraphone",
 747         "Marimba",
 748         "Xylophone",
 749         "Tubular Bells",
 750         "Dulcimer",
 751         "Hammond Organ",
 752         "Percussive Organ",
 753         "Rock Organ",
 754         "Church Organ",
 755         "Reed Organ",
 756         "Accordion",
 757         "Harmonica",
 758         "Tango Accordion",
 759         "Acoustic Guitar (nylon)",
 760         "Acoustic Guitar (steel)",
 761         "Electric Guitar (jazz)",
 762         "Electric Guitar (clean)",
 763         "Electric Guitar (muted)",
 764         "Overdriven Guitar",
 765         "Distortion Guitar",
 766         "Guitar Harmonics",
 767         "Acoustic Bass",
 768         "Electric Bass (finger)",
 769         "Electric Bass (pick)",
 770         "Fretless Bass",
 771         "Slap Bass 1",
 772         "Slap Bass 2",
 773         "Synth Bass 1",
 774         "Synth Bass 2",
 775         "Violin",
 776         "Viola",
 777         "Cello",
 778         "Contrabass",
 779         "Tremolo Strings",
 780         "Pizzicato Strings",
 781         "Orchestral Harp",
 782         "Timpani",
 783         "String Ensemble 1",
 784         "String Ensemble 2",
 785         "SynthStrings 1",
 786         "SynthStrings 2",
 787         "Choir Aahs",
 788         "Voice Oohs",
 789         "Synth Voice",
 790         "Orchestra Hit",
 791         "Trumpet",
 792         "Trombone",
 793         "Tuba",
 794         "Muted Trumpet",
 795         "French Horn",
 796         "Brass Section",
 797         "Synth Brass 1",
 798         "Synth Brass 2",
 799         "Soprano Sax",
 800         "Alto Sax",
 801         "Tenor Sax",
 802         "Baritone Sax",
 803         "Oboe",
 804         "English Horn",
 805         "Bassoon",
 806         "Clarinet",
 807         "Piccolo",
 808         "Flute",
 809         "Recorder",
 810         "Pan Flute",
 811         "Bottle Blow",
 812         "Shakuhachi",
 813         "Whistle",
 814         "Ocarina",
 815         "Lead 1 (square)",
 816         "Lead 2 (sawtooth)",
 817         "Lead 3 (calliope lead)",
 818         "Lead 4 (chiff lead)",
 819         "Lead 5 (charang)",
 820         "Lead 6 (voice)",
 821         "Lead 7 (fifths)",
 822         "Lead 8 (bass + lead)",
 823         "Pad 1 (new age)",
 824         "Pad 2 (warm)",
 825         "Pad 3 (polysynth)",
 826         "Pad 4 (choir)",
 827         "Pad 5 (bowed)",
 828         "Pad 6 (metallic)",
 829         "Pad 7 (halo)",
 830         "Pad 8 (sweep)",
 831         "FX 1 (rain)",
 832         "FX 2 (soundtrack)",
 833         "FX 3 (crystal)",
 834         "FX 4 (atmosphere)",
 835         "FX 5 (brightness)",
 836         "FX 6 (goblins)",
 837         "FX 7 (echoes)",
 838         "FX 8 (sci-fi)",
 839         "Sitar",
 840         "Banjo",
 841         "Shamisen",
 842         "Koto",
 843         "Kalimba",
 844         "Bagpipe",
 845         "Fiddle",
 846         "Shanai",
 847         "Tinkle Bell",
 848         "Agogo",
 849         "Steel Drums",
 850         "Woodblock",
 851         "Taiko Drum",
 852         "Melodic Tom",
 853         "Synth Drum",
 854         "Reverse Cymbal",
 855         "Guitar Fret Noise",
 856         "Breath Noise",
 857         "Seashore",
 858         "Bird Tweet",
 859         "Telephone Ring",
 860         "Helicopter",
 861         "Applause",
 862         "Gunshot",
 863 };
 864
 865 } //namespace Name
 866
 867 } //namespace MIDI
 868