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
  19 #include <stdlib.h>
  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 static int
  46 string_to_int(const XMLTree& tree, const std::string& str)
  47 {
  48         char*     endptr = NULL;
  49         const int i      = strtol(str.c_str(), &endptr, 10);
  50         if (str.empty() || *endptr != '\0') {
  51                 PBD::error << string_compose("%1: Bad number `%2'", tree.filename(), str)
  52                            << endmsg;
  53         }
  54         return i;
  55 }
  56
  57 static int
  58 initialize_primary_key_from_commands (
  59         const XMLTree& tree, PatchPrimaryKey& id, const XMLNode* node)
  60 {
  61         uint16_t bank    = 0;
  62         uint8_t  program = 0;
  63
  64         const XMLNodeList events = node->children();
  65         for (XMLNodeList::const_iterator i = events.begin(); i != events.end(); ++i) {
  66
  67                 XMLNode* node = *i;
  68                 if (node->name() == "ControlChange") {
  69                         const string& control = node->property("Control")->value();
  70                         const string& value   = node->property("Value")->value();
  71
  72                         if (control == "0") {
  73                                 bank |= string_to_int(tree, value) << 7;
  74                         } else if (control == "32") {
  75                                 bank |= string_to_int(tree, value);
  76                         }
  77
  78                 } else if (node->name() == "ProgramChange") {
  79                         const string& number = node->property("Number")->value();
  80                         assert(number != "");
  81                         program = string_to_int(tree, number);
  82                 }
  83         }
  84
  85         id = PatchPrimaryKey(program, bank);
  86         return 0;
  87 }
  88
  89 XMLNode&
  90 Patch::get_state (void)
  91 {
  92         XMLNode* node = new XMLNode("Patch");
  93
  94         /* XXX this is totally wrong */
  95
  96         node->set_property("Number", _id.program());
  97         node->set_property("Name",   _name);
  98
  99         /*
 100         typedef std::list< boost::shared_ptr< Evoral::Event<Evoral::Beats> > > PatchMidiCommands;
 101         XMLNode* commands = node->add_child("PatchMIDICommands");
 102         for (PatchMidiCommands::const_iterator event = _patch_midi_commands.begin();
 103             event != _patch_midi_commands.end();
 104             ++event) {
 105                 commands->add_child_copy(Evoral::MIDIXML::midi_to_xml(*event));
 106         }
 107         */
 108
 109         return *node;
 110 }
 111
 112 int
 113 Patch::set_state (const XMLTree& tree, const XMLNode& node)
 114 {
 115         if (node.name() != "Patch") {
 116                 cerr << "Incorrect node " << node.name() << " handed to Patch" << endl;
 117                 return -1;
 118         }
 119
 120         /* Note there is a "Number" attribute, but it's really more like a label
 121            and is often not numeric.  We currently do not use it. */
 122
 123         const XMLProperty* program_change = node.property("ProgramChange");
 124         if (program_change) {
 125                 _id = PatchPrimaryKey(string_to_int(tree, program_change->value()), _id.bank());
 126         }
 127
 128         const XMLProperty* name = node.property("Name");
 129         if (!name) {
 130                 return -1;
 131         }
 132         _name = name->value();
 133
 134         XMLNode* commands = node.child("PatchMIDICommands");
 135         if (commands) {
 136                 if (initialize_primary_key_from_commands(tree, _id, commands) &&
 137                     !program_change) {
 138                         return -1;  // Failed to find a program number anywhere
 139                 }
 140         }
 141
 142         XMLNode* use_note_name_list = node.child("UsesNoteNameList");
 143         if (use_note_name_list) {
 144                 _note_list_name = use_note_name_list->property ("Name")->value();
 145         }
 146
 147         return 0;
 148 }
 149
 150 XMLNode&
 151 Note::get_state (void)
 152 {
 153         XMLNode* node = new XMLNode("Note");
 154         node->set_property("Number", _number);
 155         node->set_property("Name",   _name);
 156
 157         return *node;
 158 }
 159
 160 int
 161 Note::set_state (const XMLTree& tree, const XMLNode& node)
 162 {
 163         assert(node.name() == "Note");
 164
 165         const int num = string_to_int(tree, node.property("Number")->value());
 166         if (num > 127) {
 167                 PBD::warning << string_compose("%1: Note number %2 (%3) out of range",
 168                                                tree.filename(), num, _name)
 169                              << endmsg;
 170                 return -1;
 171         }
 172
 173         _number = num;
 174         _name   = node.property("Name")->value();
 175
 176         return 0;
 177 }
 178
 179 XMLNode&
 180 NoteNameList::get_state (void)
 181 {
 182         XMLNode* node = new XMLNode("NoteNameList");
 183         node->set_property("Name", _name);
 184
 185         return *node;
 186 }
 187
 188 static void
 189 add_note_from_xml (NoteNameList::Notes& notes, const XMLTree& tree, const XMLNode& node)
 190 {
 191         boost::shared_ptr<Note> note(new Note());
 192         if (!note->set_state (tree, node)) {
 193                 if (!notes[note->number()]) {
 194                         notes[note->number()] = note;
 195                 } else {
 196                         PBD::warning
 197                                 << string_compose("%1: Duplicate note number %2 (%3) ignored",
 198                                                   tree.filename(), (int)note->number(), note->name())
 199                                 << endmsg;
 200                 }
 201         }
 202 }
 203
 204 int
 205 NoteNameList::set_state (const XMLTree& tree, const XMLNode& node)
 206 {
 207         assert(node.name() == "NoteNameList");
 208         _name = node.property("Name")->value();
 209         _notes.clear();
 210         _notes.resize(128);
 211
 212         for (XMLNodeList::const_iterator i = node.children().begin();
 213              i != node.children().end(); ++i) {
 214                 if ((*i)->name() == "Note") {
 215                         add_note_from_xml(_notes, tree, **i);
 216                 } else if ((*i)->name() == "NoteGroup") {
 217                         for (XMLNodeList::const_iterator j = (*i)->children().begin();
 218                              j != (*i)->children().end(); ++j) {
 219                                 if ((*j)->name() == "Note") {
 220                                         add_note_from_xml(_notes, tree, **j);
 221                                 } else {
 222                                         PBD::warning << string_compose("%1: Invalid NoteGroup child %2 ignored",
 223                                                                        tree.filename(), (*j)->name())
 224                                                      << endmsg;
 225                                 }
 226                         }
 227                 }
 228         }
 229
 230         return 0;
 231 }
 232
 233 XMLNode&
 234 Control::get_state (void)
 235 {
 236         XMLNode* node = new XMLNode("Control");
 237         node->set_property("Type",   _type);
 238         node->set_property("Number", _number);
 239         node->set_property("Name",   _name);
 240
 241         return *node;
 242 }
 243
 244 int
 245 Control::set_state (const XMLTree& tree, const XMLNode& node)
 246 {
 247         assert(node.name() == "Control");
 248         if (node.property("Type")) {
 249                 _type = node.property("Type")->value();
 250         } else {
 251                 _type = "7bit";
 252         }
 253         _number = string_to_int(tree, node.property("Number")->value());
 254         _name   = node.property("Name")->value();
 255
 256         for (XMLNodeList::const_iterator i = node.children().begin();
 257              i != node.children().end(); ++i) {
 258                 if ((*i)->name() == "Values") {
 259                         // <Values> has Min and Max properties, but we don't care
 260                         for (XMLNodeList::const_iterator j = (*i)->children().begin();
 261                              j != (*i)->children().end(); ++j) {
 262                                 if ((*j)->name() == "ValueNameList") {
 263                                         _value_name_list = boost::shared_ptr<ValueNameList>(new ValueNameList());
 264                                         _value_name_list->set_state(tree, **j);
 265                                 } else if ((*j)->name() == "UsesValueNameList") {
 266                                         _value_name_list_name = (*j)->property("Name")->value();
 267                                 }
 268                         }
 269                 }
 270         }
 271
 272         return 0;
 273 }
 274
 275 XMLNode&
 276 ControlNameList::get_state (void)
 277 {
 278         XMLNode* node = new XMLNode("ControlNameList");
 279         node->set_property("Name", _name);
 280
 281         return *node;
 282 }
 283
 284 int
 285 ControlNameList::set_state (const XMLTree& tree, const XMLNode& node)
 286 {
 287         assert(node.name() == "ControlNameList");
 288         _name = node.property("Name")->value();
 289
 290         _controls.clear();
 291         for (XMLNodeList::const_iterator i = node.children().begin();
 292              i != node.children().end(); ++i) {
 293                 if ((*i)->name() == "Control") {
 294                         boost::shared_ptr<Control> control(new Control());
 295                         control->set_state (tree, *(*i));
 296                         if (_controls.find(control->number()) == _controls.end()) {
 297                                 _controls.insert(make_pair(control->number(), control));
 298                         } else {
 299                                 PBD::warning << string_compose("%1: Duplicate control %2 ignored",
 300                                                                tree.filename(), control->number())
 301                                              << endmsg;
 302                         }
 303                 }
 304         }
 305
 306         return 0;
 307 }
 308
 309 boost::shared_ptr<const Control>
 310 ControlNameList::control(uint16_t num) const
 311 {
 312         Controls::const_iterator i = _controls.find(num);
 313         if (i != _controls.end()) {
 314                 return i->second;
 315         }
 316         return boost::shared_ptr<const Control>();
 317 }
 318
 319 XMLNode&
 320 Value::get_state (void)
 321 {
 322         XMLNode* node = new XMLNode("Value");
 323         node->set_property("Number", _number);
 324         node->set_property("Name",   _name);
 325
 326         return *node;
 327 }
 328
 329 int
 330 Value::set_state (const XMLTree& tree, const XMLNode& node)
 331 {
 332         assert(node.name() == "Value");
 333         _number = string_to_int(tree, node.property("Number")->value());
 334         _name   = node.property("Name")->value();
 335
 336         return 0;
 337 }
 338
 339 XMLNode&
 340 ValueNameList::get_state (void)
 341 {
 342         XMLNode* node = new XMLNode("ValueNameList");
 343         node->set_property("Name", _name);
 344
 345         return *node;
 346 }
 347
 348 int
 349 ValueNameList::set_state (const XMLTree& tree, const XMLNode& node)
 350 {
 351         assert(node.name() == "ValueNameList");
 352         const XMLProperty* name_prop = node.property("Name");
 353         if (name_prop) {
 354                 // May be anonymous if written inline within a single <Control> tag
 355                 _name = name_prop->value();
 356         }
 357
 358         _values.clear();
 359         for (XMLNodeList::const_iterator i = node.children().begin();
 360              i != node.children().end(); ++i) {
 361                 if ((*i)->name() == "Value") {
 362                         boost::shared_ptr<Value> value(new Value());
 363                         value->set_state (tree, *(*i));
 364                         if (_values.find(value->number()) == _values.end()) {
 365                                 _values.insert(make_pair(value->number(), value));
 366                         } else {
 367                                 PBD::warning << string_compose("%1: Duplicate value %2 ignored",
 368                                                                tree.filename(), value->number())
 369                                              << endmsg;
 370                         }
 371                 }
 372         }
 373
 374         return 0;
 375 }
 376
 377 boost::shared_ptr<const Value>
 378 ValueNameList::value(uint16_t num) const
 379 {
 380         Values::const_iterator i = _values.find(num);
 381         if (i != _values.end()) {
 382                 return i->second;
 383         }
 384         return boost::shared_ptr<const Value>();
 385 }
 386
 387 boost::shared_ptr<const Value>
 388 ValueNameList::max_value_below(uint16_t num) const
 389 {
 390         Values::const_iterator i = _values.lower_bound(num);
 391         if (i->first == num) {
 392                 // Exact match
 393                 return i->second;
 394         } else if (i == _values.begin()) {
 395                 // No value is < num
 396                 return boost::shared_ptr<const Value>();
 397         } else {
 398                 // Found the smallest element >= num, so the previous one is our result
 399                 --i;
 400                 return i->second;
 401         }
 402 }
 403
 404 XMLNode&
 405 PatchBank::get_state (void)
 406 {
 407         XMLNode* node = new XMLNode("PatchBank");
 408         node->set_property("Name",   _name);
 409         XMLNode* patch_name_list = node->add_child("PatchNameList");
 410         for (PatchNameList::iterator patch = _patch_name_list.begin();
 411             patch != _patch_name_list.end();
 412             ++patch) {
 413                 patch_name_list->add_child_nocopy((*patch)->get_state());
 414         }
 415
 416         return *node;
 417 }
 418
 419 int
 420 PatchBank::set_state (const XMLTree& tree, const XMLNode& node)
 421 {
 422         assert(node.name() == "PatchBank");
 423         _name   = node.property("Name")->value();
 424
 425         XMLNode* commands = node.child("MIDICommands");
 426         if (commands) {
 427                 PatchPrimaryKey id (0, 0);
 428                 if (initialize_primary_key_from_commands (tree, id, commands)) {
 429                         return -1;
 430                 }
 431                 _number = id.bank();
 432         }
 433
 434         XMLNode* patch_name_list = node.child("PatchNameList");
 435
 436         if (patch_name_list) {
 437                 const XMLNodeList patches = patch_name_list->children();
 438                 for (XMLNodeList::const_iterator i = patches.begin(); i != patches.end(); ++i) {
 439                         boost::shared_ptr<Patch> patch (new Patch (string(), 0, _number));
 440                         patch->set_state(tree, *(*i));
 441                         _patch_name_list.push_back(patch);
 442                 }
 443         } else {
 444                 XMLNode* use_patch_name_list = node.child ("UsesPatchNameList");
 445                 if (use_patch_name_list) {
 446                         _patch_list_name = use_patch_name_list->property ("Name")->value();
 447                 } else {
 448                         error << "Patch without patch name list - patchfile will be ignored" << endmsg;
 449                         return -1;
 450                 }
 451         }
 452
 453         return 0;
 454 }
 455
 456 int
 457 PatchBank::set_patch_name_list (const PatchNameList& pnl)
 458 {
 459         _patch_name_list = pnl;
 460         _patch_list_name = "";
 461
 462         for (PatchNameList::iterator p = _patch_name_list.begin(); p != _patch_name_list.end(); p++) {
 463                 (*p)->set_bank_number (_number);
 464         }
 465
 466         return 0;
 467 }
 468
 469 std::ostream&
 470 operator<< (std::ostream& os, const ChannelNameSet& cns)
 471 {
 472         os << "Channel Name Set: name = " << cns._name << endl
 473            << "Map size " << cns._patch_map.size () << endl
 474            << "List size " << cns._patch_list.size() << endl
 475            << "Patch list name = [" << cns._patch_list_name << ']' << endl
 476            << "Available channels : ";
 477         for (set<uint8_t>::const_iterator x = cns._available_for_channels.begin(); x != cns._available_for_channels.end(); ++x) {
 478                 os << (int) (*x) << ' ';
 479         }
 480         os << endl;
 481
 482         for (ChannelNameSet::PatchBanks::const_iterator pbi = cns._patch_banks.begin(); pbi != cns._patch_banks.end(); ++pbi) {
 483                 os << "\tPatch Bank " << (*pbi)->name() << " with " << (*pbi)->patch_name_list().size() << " patches\n";
 484                 for (PatchNameList::const_iterator pni = (*pbi)->patch_name_list().begin(); pni != (*pbi)->patch_name_list().end(); ++pni) {
 485                         os << "\t\tPatch name " << (*pni)->name() << " prog " << (int) (*pni)->program_number() << " bank " << (*pni)->bank_number() << endl;
 486                 }
 487         }
 488
 489         return os;
 490 }
 491
 492 void
 493 ChannelNameSet::set_patch_banks (const ChannelNameSet::PatchBanks& pb)
 494 {
 495         _patch_banks = pb;
 496
 497         _patch_map.clear ();
 498         _patch_list.clear ();
 499         _patch_list_name = "";
 500         _available_for_channels.clear ();
 501
 502         for (PatchBanks::const_iterator pbi = _patch_banks.begin(); pbi != _patch_banks.end(); ++pbi) {
 503                 for (PatchNameList::const_iterator pni = (*pbi)->patch_name_list().begin(); pni != (*pbi)->patch_name_list().end(); ++pni) {
 504                         _patch_map[(*pni)->patch_primary_key()] = (*pni);
 505                         _patch_list.push_back ((*pni)->patch_primary_key());
 506                 }
 507         }
 508
 509         for (uint8_t n = 0; n < 16; ++n) {
 510                 _available_for_channels.insert (n);
 511         }
 512 }
 513
 514 void
 515 ChannelNameSet::use_patch_name_list (const PatchNameList& pnl)
 516 {
 517         for (PatchNameList::const_iterator p = pnl.begin(); p != pnl.end(); ++p) {
 518                 _patch_map[(*p)->patch_primary_key()] = (*p);
 519                 _patch_list.push_back ((*p)->patch_primary_key());
 520         }
 521 }
 522
 523 XMLNode&
 524 ChannelNameSet::get_state (void)
 525 {
 526         XMLNode* node = new XMLNode("ChannelNameSet");
 527         node->set_property("Name",   _name);
 528
 529         XMLNode* available_for_channels = node->add_child("AvailableForChannels");
 530         assert(available_for_channels);
 531
 532         for (uint8_t channel = 0; channel < 16; ++channel) {
 533                 XMLNode* available_channel = available_for_channels->add_child("AvailableChannel");
 534                 assert(available_channel);
 535
 536                 available_channel->set_property("Channel", channel);
 537
 538                 if (_available_for_channels.find(channel) != _available_for_channels.end()) {
 539                         available_channel->set_property("Available", "true");
 540                 } else {
 541                         available_channel->set_property("Available", "false");
 542                 }
 543         }
 544
 545         for (PatchBanks::iterator patch_bank = _patch_banks.begin();
 546             patch_bank != _patch_banks.end();
 547             ++patch_bank) {
 548                 node->add_child_nocopy((*patch_bank)->get_state());
 549         }
 550
 551         return *node;
 552 }
 553
 554 int
 555 ChannelNameSet::set_state (const XMLTree& tree, const XMLNode& node)
 556 {
 557         assert(node.name() == "ChannelNameSet");
 558         _name = node.property("Name")->value();
 559
 560         const XMLNodeList children = node.children();
 561         for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
 562                 XMLNode* node = *i;
 563                 assert(node);
 564                 if (node->name() == "AvailableForChannels") {
 565                         boost::shared_ptr<XMLSharedNodeList> channels =
 566                                 tree.find("//AvailableChannel[@Available = 'true']/@Channel", node);
 567                         for (XMLSharedNodeList::const_iterator i = channels->begin();
 568                             i != channels->end();
 569                             ++i) {
 570                                 _available_for_channels.insert(
 571                                         string_to_int(tree, (*i)->attribute_value()));
 572                         }
 573                 } else if (node->name() == "PatchBank") {
 574                         boost::shared_ptr<PatchBank> bank (new PatchBank ());
 575                         bank->set_state(tree, *node);
 576                         _patch_banks.push_back(bank);
 577                         const PatchNameList& patches = bank->patch_name_list();
 578                         for (PatchNameList::const_iterator patch = patches.begin();
 579                              patch != patches.end();
 580                              ++patch) {
 581                                 _patch_map[(*patch)->patch_primary_key()] = *patch;
 582                                 _patch_list.push_back((*patch)->patch_primary_key());
 583                         }
 584                 } else if (node->name() == "UsesNoteNameList") {
 585                         _note_list_name = node->property ("Name")->value();
 586                 } else if (node->name() == "UsesControlNameList") {
 587                         _control_list_name = node->property ("Name")->value();
 588                 }
 589         }
 590
 591         return 0;
 592 }
 593
 594 int
 595 CustomDeviceMode::set_state(const XMLTree& tree, const XMLNode& a_node)
 596 {
 597         assert(a_node.name() == "CustomDeviceMode");
 598
 599         _name = a_node.property("Name")->value();
 600
 601         boost::shared_ptr<XMLSharedNodeList> channel_name_set_assignments =
 602                 tree.find("//ChannelNameSetAssign", const_cast<XMLNode *>(&a_node));
 603         for (XMLSharedNodeList::const_iterator i = channel_name_set_assignments->begin();
 604             i != channel_name_set_assignments->end();
 605             ++i) {
 606                 const int     channel  = string_to_int(tree, (*i)->property("Channel")->value());
 607                 const string& name_set = (*i)->property("NameSet")->value();
 608                 assert( 1 <= channel && channel <= 16 );
 609                 _channel_name_set_assignments[channel - 1] = name_set;
 610         }
 611         return 0;
 612 }
 613
 614 XMLNode&
 615 CustomDeviceMode::get_state(void)
 616 {
 617         XMLNode* custom_device_mode = new XMLNode("CustomDeviceMode");
 618         custom_device_mode->set_property("Name",   _name);
 619         XMLNode* channel_name_set_assignments =
 620                 custom_device_mode->add_child("ChannelNameSetAssignments");
 621         for (int i = 0; i < 15 && !_channel_name_set_assignments[i].empty(); i++) {
 622                 XMLNode* channel_name_set_assign =
 623                         channel_name_set_assignments->add_child("ChannelNameSetAssign");
 624                 channel_name_set_assign->set_property("Channel", i + 1);
 625                 channel_name_set_assign->set_property("NameSet", _channel_name_set_assignments[i]);
 626         }
 627
 628         return *custom_device_mode;
 629 }
 630
 631 boost::shared_ptr<const ValueNameList>
 632 MasterDeviceNames::value_name_list_by_control(const std::string& mode, uint8_t channel, uint8_t number)
 633 {
 634         boost::shared_ptr<ChannelNameSet> chan_names = channel_name_set_by_channel(mode, channel);
 635         if (!chan_names) {
 636                 return boost::shared_ptr<const ValueNameList>();
 637         }
 638
 639         boost::shared_ptr<ControlNameList> control_names = control_name_list(chan_names->control_list_name());
 640         if (!control_names) {
 641                 return boost::shared_ptr<const ValueNameList>();
 642         }
 643
 644         boost::shared_ptr<const Control> control = control_names->control(number);
 645         if (!control) {
 646                 return boost::shared_ptr<const ValueNameList>();
 647         }
 648
 649         if (!control->value_name_list_name().empty()) {
 650                 return value_name_list(control->value_name_list_name());
 651         } else {
 652                 return control->value_name_list();
 653         }
 654 }
 655
 656 boost::shared_ptr<CustomDeviceMode>
 657 MasterDeviceNames::custom_device_mode_by_name(const std::string& mode_name)
 658 {
 659         return _custom_device_modes[mode_name];
 660 }
 661
 662 boost::shared_ptr<ChannelNameSet>
 663 MasterDeviceNames::channel_name_set_by_channel(const std::string& mode, uint8_t channel)
 664 {
 665         boost::shared_ptr<CustomDeviceMode> cdm = custom_device_mode_by_name(mode);
 666         boost::shared_ptr<ChannelNameSet> cns =  _channel_name_sets[cdm->channel_name_set_name_by_channel(channel)];
 667         return cns;
 668 }
 669
 670 boost::shared_ptr<Patch>
 671 MasterDeviceNames::find_patch(const std::string& mode, uint8_t channel, const PatchPrimaryKey& key)
 672 {
 673         boost::shared_ptr<ChannelNameSet> cns = channel_name_set_by_channel(mode, channel);
 674         if (!cns) return boost::shared_ptr<Patch>();
 675         return cns->find_patch(key);
 676 }
 677
 678 boost::shared_ptr<ChannelNameSet>
 679 MasterDeviceNames::channel_name_set(const std::string& name)
 680 {
 681         ChannelNameSets::const_iterator i = _channel_name_sets.find(name);
 682         if (i != _channel_name_sets.end()) {
 683                 return i->second;
 684         }
 685         return boost::shared_ptr<ChannelNameSet>();
 686 }
 687
 688 boost::shared_ptr<ControlNameList>
 689 MasterDeviceNames::control_name_list(const std::string& name)
 690 {
 691         ControlNameLists::const_iterator i = _control_name_lists.find(name);
 692         if (i != _control_name_lists.end()) {
 693                 return i->second;
 694         }
 695         return boost::shared_ptr<ControlNameList>();
 696 }
 697
 698 boost::shared_ptr<ValueNameList>
 699 MasterDeviceNames::value_name_list(const std::string& name)
 700 {
 701         ValueNameLists::const_iterator i = _value_name_lists.find(name);
 702         if (i != _value_name_lists.end()) {
 703                 return i->second;
 704         }
 705         return boost::shared_ptr<ValueNameList>();
 706 }
 707
 708 boost::shared_ptr<NoteNameList>
 709 MasterDeviceNames::note_name_list(const std::string& name)
 710 {
 711         NoteNameLists::const_iterator i = _note_name_lists.find(name);
 712         if (i != _note_name_lists.end()) {
 713                 return i->second;
 714         }
 715         return boost::shared_ptr<NoteNameList>();
 716 }
 717
 718 std::string
 719 MasterDeviceNames::note_name(const std::string& mode_name,
 720                              uint8_t            channel,
 721                              uint16_t           bank,
 722                              uint8_t            program,
 723                              uint8_t            number)
 724 {
 725         if (number > 127) {
 726                 return "";
 727         }
 728
 729         boost::shared_ptr<const NoteNameList> note_names;
 730         boost::shared_ptr<const Patch> patch(
 731                 find_patch(mode_name, channel, PatchPrimaryKey(program, bank)));
 732         if (patch) {
 733                 note_names = note_name_list(patch->note_list_name());
 734         }
 735
 736         if (!note_names) {
 737                 /* No note names specific to this patch, check the ChannelNameSet */
 738                 boost::shared_ptr<ChannelNameSet> chan_names = channel_name_set_by_channel(
 739                         mode_name, channel);
 740                 if (chan_names) {
 741                         note_names = note_name_list(chan_names->note_list_name());
 742                 }
 743         }
 744         if (!note_names) {
 745                 return "";
 746         }
 747
 748         boost::shared_ptr<const Note> note(note_names->notes()[number]);
 749         return note ? note->name() : "";
 750 }
 751
 752 int
 753 MasterDeviceNames::set_state(const XMLTree& tree, const XMLNode&)
 754 {
 755         // Manufacturer
 756         boost::shared_ptr<XMLSharedNodeList> manufacturer = tree.find("//Manufacturer");
 757         assert(manufacturer->size() == 1);
 758         _manufacturer = manufacturer->front()->children().front()->content();
 759
 760         // Models
 761         boost::shared_ptr<XMLSharedNodeList> models = tree.find("//Model");
 762         assert(models->size() >= 1);
 763         for (XMLSharedNodeList::iterator i = models->begin();
 764              i != models->end();
 765              ++i) {
 766                 const XMLNodeList& contents = (*i)->children();
 767                 assert(contents.size() == 1);
 768                 XMLNode * content = *(contents.begin());
 769                 assert(content->is_content());
 770                 _models.insert(content->content());
 771         }
 772
 773         // CustomDeviceModes
 774         boost::shared_ptr<XMLSharedNodeList> custom_device_modes = tree.find("//CustomDeviceMode");
 775         for (XMLSharedNodeList::iterator i = custom_device_modes->begin();
 776              i != custom_device_modes->end();
 777              ++i) {
 778                 boost::shared_ptr<CustomDeviceMode> custom_device_mode(new CustomDeviceMode());
 779                 custom_device_mode->set_state(tree, *(*i));
 780
 781                 _custom_device_modes[custom_device_mode->name()] = custom_device_mode;
 782                 _custom_device_mode_names.push_back(custom_device_mode->name());
 783         }
 784
 785         // ChannelNameSets
 786         boost::shared_ptr<XMLSharedNodeList> channel_name_sets = tree.find("//ChannelNameSet");
 787         for (XMLSharedNodeList::iterator i = channel_name_sets->begin();
 788              i != channel_name_sets->end();
 789              ++i) {
 790                 boost::shared_ptr<ChannelNameSet> channel_name_set(new ChannelNameSet());
 791                 channel_name_set->set_state(tree, *(*i));
 792                 _channel_name_sets[channel_name_set->name()] = channel_name_set;
 793         }
 794
 795         // NoteNameLists
 796         boost::shared_ptr<XMLSharedNodeList> note_name_lists = tree.find("//NoteNameList");
 797         for (XMLSharedNodeList::iterator i = note_name_lists->begin();
 798              i != note_name_lists->end();
 799              ++i) {
 800                 boost::shared_ptr<NoteNameList> note_name_list(new NoteNameList());
 801                 note_name_list->set_state (tree, *(*i));
 802                 _note_name_lists[note_name_list->name()] = note_name_list;
 803         }
 804
 805         // ControlNameLists
 806         boost::shared_ptr<XMLSharedNodeList> control_name_lists = tree.find("//ControlNameList");
 807         for (XMLSharedNodeList::iterator i = control_name_lists->begin();
 808              i != control_name_lists->end();
 809              ++i) {
 810                 boost::shared_ptr<ControlNameList> control_name_list(new ControlNameList());
 811                 control_name_list->set_state (tree, *(*i));
 812                 _control_name_lists[control_name_list->name()] = control_name_list;
 813         }
 814
 815         // ValueNameLists
 816         boost::shared_ptr<XMLSharedNodeList> value_name_lists = tree.find("/child::MIDINameDocument/child::MasterDeviceNames/child::ValueNameList");
 817         for (XMLSharedNodeList::iterator i = value_name_lists->begin();
 818              i != value_name_lists->end();
 819              ++i) {
 820                 boost::shared_ptr<ValueNameList> value_name_list(new ValueNameList());
 821                 value_name_list->set_state (tree, *(*i));
 822                 _value_name_lists[value_name_list->name()] = value_name_list;
 823         }
 824
 825         // global/post-facto PatchNameLists
 826         boost::shared_ptr<XMLSharedNodeList> patch_name_lists = tree.find("/child::MIDINameDocument/child::MasterDeviceNames/child::PatchNameList");
 827         for (XMLSharedNodeList::iterator i = patch_name_lists->begin();
 828              i != patch_name_lists->end();
 829              ++i) {
 830
 831                 PatchNameList patch_name_list;
 832                 const XMLNodeList patches = (*i)->children();
 833
 834                 for (XMLNodeList::const_iterator p = patches.begin(); p != patches.end(); ++p) {
 835                         boost::shared_ptr<Patch> patch (new Patch ());
 836                         patch->set_state(tree, *(*p));
 837                         patch_name_list.push_back(patch);
 838                 }
 839
 840                 if (!patch_name_list.empty()) {
 841                         _patch_name_lists[(*i)->property ("Name")->value()] = patch_name_list;
 842                 }
 843         }
 844
 845         /* now traverse patches and hook up anything that used UsePatchNameList
 846          * to the right patch list
 847          */
 848
 849         for (ChannelNameSets::iterator cns = _channel_name_sets.begin(); cns != _channel_name_sets.end(); ++cns) {
 850                 ChannelNameSet::PatchBanks pbs = cns->second->patch_banks();
 851                 PatchNameLists::iterator p;
 852
 853                 for (ChannelNameSet::PatchBanks::iterator pb = pbs.begin(); pb != pbs.end(); ++pb) {
 854                         const std::string& pln = (*pb)->patch_list_name();
 855                         if (!pln.empty()) {
 856                                 if ((p = _patch_name_lists.find (pln)) != _patch_name_lists.end()) {
 857                                         if ((*pb)->set_patch_name_list (p->second)) {
 858                                                 return -1;
 859                                         }
 860                                         cns->second->use_patch_name_list (p->second);
 861                                 } else {
 862                                         error << string_compose ("Patch list name %1 was not found - patch file ignored", pln) << endmsg;
 863                                         return -1;
 864                                 }
 865                         }
 866                 }
 867
 868         }
 869
 870         return 0;
 871 }
 872
 873 XMLNode&
 874 MasterDeviceNames::get_state(void)
 875 {
 876         static XMLNode nothing("<nothing>");
 877         return nothing;
 878 }
 879
 880 MIDINameDocument::MIDINameDocument (const string& file_path)
 881         : _file_path(file_path)
 882 {
 883         XMLTree document;
 884         if (!document.read (file_path)) {
 885                 throw failed_constructor ();
 886         }
 887
 888         document.set_filename (file_path);
 889         set_state (document, *document.root());
 890 }
 891
 892 int
 893 MIDINameDocument::set_state (const XMLTree& tree, const XMLNode&)
 894 {
 895         // Author
 896
 897         boost::shared_ptr<XMLSharedNodeList> author = tree.find("//Author");
 898         if (author->size() < 1) {
 899                 error << "No author information in MIDNAM file" << endmsg;
 900                 return -1;
 901         }
 902
 903         if (author->front()->children().size() > 0) {
 904                 _author = author->front()->children().front()->content();
 905         }
 906
 907         // MasterDeviceNames
 908
 909         boost::shared_ptr<XMLSharedNodeList> master_device_names_list = tree.find ("//MasterDeviceNames");
 910
 911         for (XMLSharedNodeList::iterator i = master_device_names_list->begin();
 912              i != master_device_names_list->end();
 913              ++i) {
 914                 boost::shared_ptr<MasterDeviceNames> master_device_names(new MasterDeviceNames());
 915
 916                 if (master_device_names->set_state(tree, *(*i))) {
 917                         return -1;
 918                 }
 919
 920                 for (MasterDeviceNames::Models::const_iterator model = master_device_names->models().begin();
 921                      model != master_device_names->models().end();
 922                      ++model) {
 923                         _master_device_names_list.insert(
 924                                 std::pair<std::string, boost::shared_ptr<MasterDeviceNames> >
 925                                 (*model,      master_device_names));
 926
 927                         _all_models.insert(*model);
 928                 }
 929         }
 930
 931         return 0;
 932 }
 933
 934 XMLNode&
 935 MIDINameDocument::get_state(void)
 936 {
 937         static XMLNode nothing("<nothing>");
 938         return nothing;
 939 }
 940
 941 boost::shared_ptr<MasterDeviceNames>
 942 MIDINameDocument::master_device_names(const std::string& model)
 943 {
 944         MasterDeviceNamesList::const_iterator m = _master_device_names_list.find(model);
 945         if (m != _master_device_names_list.end()) {
 946                 return boost::shared_ptr<MasterDeviceNames>(m->second);
 947         }
 948         return boost::shared_ptr<MasterDeviceNames>();
 949 }
 950
 951 const char* general_midi_program_names[128] = {
 952         "Acoustic Grand Piano",
 953         "Bright Acoustic Piano",
 954         "Electric Grand Piano",
 955         "Honky-tonk Piano",
 956         "Rhodes Piano",
 957         "Chorused Piano",
 958         "Harpsichord",
 959         "Clavinet",
 960         "Celesta",
 961         "Glockenspiel",
 962         "Music Box",
 963         "Vibraphone",
 964         "Marimba",
 965         "Xylophone",
 966         "Tubular Bells",
 967         "Dulcimer",
 968         "Hammond Organ",
 969         "Percussive Organ",
 970         "Rock Organ",
 971         "Church Organ",
 972         "Reed Organ",
 973         "Accordion",
 974         "Harmonica",
 975         "Tango Accordion",
 976         "Acoustic Guitar (nylon)",
 977         "Acoustic Guitar (steel)",
 978         "Electric Guitar (jazz)",
 979         "Electric Guitar (clean)",
 980         "Electric Guitar (muted)",
 981         "Overdriven Guitar",
 982         "Distortion Guitar",
 983         "Guitar Harmonics",
 984         "Acoustic Bass",
 985         "Electric Bass (finger)",
 986         "Electric Bass (pick)",
 987         "Fretless Bass",
 988         "Slap Bass 1",
 989         "Slap Bass 2",
 990         "Synth Bass 1",
 991         "Synth Bass 2",
 992         "Violin",
 993         "Viola",
 994         "Cello",
 995         "Contrabass",
 996         "Tremolo Strings",
 997         "Pizzicato Strings",
 998         "Orchestral Harp",
 999         "Timpani",
1000         "String Ensemble 1",
1001         "String Ensemble 2",
1002         "SynthStrings 1",
1003         "SynthStrings 2",
1004         "Choir Aahs",
1005         "Voice Oohs",
1006         "Synth Voice",
1007         "Orchestra Hit",
1008         "Trumpet",
1009         "Trombone",
1010         "Tuba",
1011         "Muted Trumpet",
1012         "French Horn",
1013         "Brass Section",
1014         "Synth Brass 1",
1015         "Synth Brass 2",
1016         "Soprano Sax",
1017         "Alto Sax",
1018         "Tenor Sax",
1019         "Baritone Sax",
1020         "Oboe",
1021         "English Horn",
1022         "Bassoon",
1023         "Clarinet",
1024         "Piccolo",
1025         "Flute",
1026         "Recorder",
1027         "Pan Flute",
1028         "Bottle Blow",
1029         "Shakuhachi",
1030         "Whistle",
1031         "Ocarina",
1032         "Lead 1 (square)",
1033         "Lead 2 (sawtooth)",
1034         "Lead 3 (calliope lead)",
1035         "Lead 4 (chiff lead)",
1036         "Lead 5 (charang)",
1037         "Lead 6 (voice)",
1038         "Lead 7 (fifths)",
1039         "Lead 8 (bass + lead)",
1040         "Pad 1 (new age)",
1041         "Pad 2 (warm)",
1042         "Pad 3 (polysynth)",
1043         "Pad 4 (choir)",
1044         "Pad 5 (bowed)",
1045         "Pad 6 (metallic)",
1046         "Pad 7 (halo)",
1047         "Pad 8 (sweep)",
1048         "FX 1 (rain)",
1049         "FX 2 (soundtrack)",
1050         "FX 3 (crystal)",
1051         "FX 4 (atmosphere)",
1052         "FX 5 (brightness)",
1053         "FX 6 (goblins)",
1054         "FX 7 (echoes)",
1055         "FX 8 (sci-fi)",
1056         "Sitar",
1057         "Banjo",
1058         "Shamisen",
1059         "Koto",
1060         "Kalimba",
1061         "Bagpipe",
1062         "Fiddle",
1063         "Shanai",
1064         "Tinkle Bell",
1065         "Agogo",
1066         "Steel Drums",
1067         "Woodblock",
1068         "Taiko Drum",
1069         "Melodic Tom",
1070         "Synth Drum",
1071         "Reverse Cymbal",
1072         "Guitar Fret Noise",
1073         "Breath Noise",
1074         "Seashore",
1075         "Bird Tweet",
1076         "Telephone Ring",
1077         "Helicopter",
1078         "Applause",
1079         "Gunshot",
1080 };
1081
1082 } //namespace Name
1083
1084 } //namespace MIDI
1085