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                                 try {
 571                                         _available_for_channels.insert(
 572                                                         string_to_int(tree, (*i)->attribute_value()));
 573                                 } catch (XMLException &e) {
 574                                         cerr << "ChannelNameSet::set_state: " << e.what () << endl;
 575                                 }
 576                         }
 577                 } else if (node->name() == "PatchBank") {
 578                         boost::shared_ptr<PatchBank> bank (new PatchBank ());
 579                         bank->set_state(tree, *node);
 580                         _patch_banks.push_back(bank);
 581                         const PatchNameList& patches = bank->patch_name_list();
 582                         for (PatchNameList::const_iterator patch = patches.begin();
 583                              patch != patches.end();
 584                              ++patch) {
 585                                 _patch_map[(*patch)->patch_primary_key()] = *patch;
 586                                 _patch_list.push_back((*patch)->patch_primary_key());
 587                         }
 588                 } else if (node->name() == "UsesNoteNameList") {
 589                         _note_list_name = node->property ("Name")->value();
 590                 } else if (node->name() == "UsesControlNameList") {
 591                         _control_list_name = node->property ("Name")->value();
 592                 }
 593         }
 594
 595         return 0;
 596 }
 597
 598 int
 599 CustomDeviceMode::set_state(const XMLTree& tree, const XMLNode& a_node)
 600 {
 601         assert(a_node.name() == "CustomDeviceMode");
 602
 603         _name = a_node.property("Name")->value();
 604
 605         boost::shared_ptr<XMLSharedNodeList> channel_name_set_assignments =
 606                 tree.find("//ChannelNameSetAssign", const_cast<XMLNode *>(&a_node));
 607         for (XMLSharedNodeList::const_iterator i = channel_name_set_assignments->begin();
 608             i != channel_name_set_assignments->end();
 609             ++i) {
 610                 const int     channel  = string_to_int(tree, (*i)->property("Channel")->value());
 611                 const string& name_set = (*i)->property("NameSet")->value();
 612                 assert( 1 <= channel && channel <= 16 );
 613                 _channel_name_set_assignments[channel - 1] = name_set;
 614         }
 615         return 0;
 616 }
 617
 618 XMLNode&
 619 CustomDeviceMode::get_state(void)
 620 {
 621         XMLNode* custom_device_mode = new XMLNode("CustomDeviceMode");
 622         custom_device_mode->set_property("Name",   _name);
 623         XMLNode* channel_name_set_assignments =
 624                 custom_device_mode->add_child("ChannelNameSetAssignments");
 625         for (int i = 0; i < 15 && !_channel_name_set_assignments[i].empty(); i++) {
 626                 XMLNode* channel_name_set_assign =
 627                         channel_name_set_assignments->add_child("ChannelNameSetAssign");
 628                 channel_name_set_assign->set_property("Channel", i + 1);
 629                 channel_name_set_assign->set_property("NameSet", _channel_name_set_assignments[i]);
 630         }
 631
 632         return *custom_device_mode;
 633 }
 634
 635 boost::shared_ptr<const ValueNameList>
 636 MasterDeviceNames::value_name_list_by_control(const std::string& mode, uint8_t channel, uint8_t number)
 637 {
 638         boost::shared_ptr<ChannelNameSet> chan_names = channel_name_set_by_channel(mode, channel);
 639         if (!chan_names) {
 640                 return boost::shared_ptr<const ValueNameList>();
 641         }
 642
 643         boost::shared_ptr<ControlNameList> control_names = control_name_list(chan_names->control_list_name());
 644         if (!control_names) {
 645                 return boost::shared_ptr<const ValueNameList>();
 646         }
 647
 648         boost::shared_ptr<const Control> control = control_names->control(number);
 649         if (!control) {
 650                 return boost::shared_ptr<const ValueNameList>();
 651         }
 652
 653         if (!control->value_name_list_name().empty()) {
 654                 return value_name_list(control->value_name_list_name());
 655         } else {
 656                 return control->value_name_list();
 657         }
 658 }
 659
 660 boost::shared_ptr<CustomDeviceMode>
 661 MasterDeviceNames::custom_device_mode_by_name(const std::string& mode_name)
 662 {
 663         return _custom_device_modes[mode_name];
 664 }
 665
 666 boost::shared_ptr<ChannelNameSet>
 667 MasterDeviceNames::channel_name_set_by_channel(const std::string& mode, uint8_t channel)
 668 {
 669         boost::shared_ptr<CustomDeviceMode> cdm = custom_device_mode_by_name(mode);
 670         boost::shared_ptr<ChannelNameSet> cns =  _channel_name_sets[cdm->channel_name_set_name_by_channel(channel)];
 671         return cns;
 672 }
 673
 674 boost::shared_ptr<Patch>
 675 MasterDeviceNames::find_patch(const std::string& mode, uint8_t channel, const PatchPrimaryKey& key)
 676 {
 677         boost::shared_ptr<ChannelNameSet> cns = channel_name_set_by_channel(mode, channel);
 678         if (!cns) return boost::shared_ptr<Patch>();
 679         return cns->find_patch(key);
 680 }
 681
 682 boost::shared_ptr<ChannelNameSet>
 683 MasterDeviceNames::channel_name_set(const std::string& name)
 684 {
 685         ChannelNameSets::const_iterator i = _channel_name_sets.find(name);
 686         if (i != _channel_name_sets.end()) {
 687                 return i->second;
 688         }
 689         return boost::shared_ptr<ChannelNameSet>();
 690 }
 691
 692 boost::shared_ptr<ControlNameList>
 693 MasterDeviceNames::control_name_list(const std::string& name)
 694 {
 695         ControlNameLists::const_iterator i = _control_name_lists.find(name);
 696         if (i != _control_name_lists.end()) {
 697                 return i->second;
 698         }
 699         return boost::shared_ptr<ControlNameList>();
 700 }
 701
 702 boost::shared_ptr<ValueNameList>
 703 MasterDeviceNames::value_name_list(const std::string& name)
 704 {
 705         ValueNameLists::const_iterator i = _value_name_lists.find(name);
 706         if (i != _value_name_lists.end()) {
 707                 return i->second;
 708         }
 709         return boost::shared_ptr<ValueNameList>();
 710 }
 711
 712 boost::shared_ptr<NoteNameList>
 713 MasterDeviceNames::note_name_list(const std::string& name)
 714 {
 715         NoteNameLists::const_iterator i = _note_name_lists.find(name);
 716         if (i != _note_name_lists.end()) {
 717                 return i->second;
 718         }
 719         return boost::shared_ptr<NoteNameList>();
 720 }
 721
 722 std::string
 723 MasterDeviceNames::note_name(const std::string& mode_name,
 724                              uint8_t            channel,
 725                              uint16_t           bank,
 726                              uint8_t            program,
 727                              uint8_t            number)
 728 {
 729         if (number > 127) {
 730                 return "";
 731         }
 732
 733         boost::shared_ptr<const NoteNameList> note_names;
 734         boost::shared_ptr<const Patch> patch(
 735                 find_patch(mode_name, channel, PatchPrimaryKey(program, bank)));
 736         if (patch) {
 737                 note_names = note_name_list(patch->note_list_name());
 738         }
 739
 740         if (!note_names) {
 741                 /* No note names specific to this patch, check the ChannelNameSet */
 742                 boost::shared_ptr<ChannelNameSet> chan_names = channel_name_set_by_channel(
 743                         mode_name, channel);
 744                 if (chan_names) {
 745                         note_names = note_name_list(chan_names->note_list_name());
 746                 }
 747         }
 748         if (!note_names) {
 749                 return "";
 750         }
 751
 752         boost::shared_ptr<const Note> note(note_names->notes()[number]);
 753         return note ? note->name() : "";
 754 }
 755
 756 int
 757 MasterDeviceNames::set_state(const XMLTree& tree, const XMLNode&)
 758 {
 759         // Manufacturer
 760         boost::shared_ptr<XMLSharedNodeList> manufacturer = tree.find("//Manufacturer");
 761         assert(manufacturer->size() == 1);
 762         _manufacturer = manufacturer->front()->children().front()->content();
 763
 764         // Models
 765         boost::shared_ptr<XMLSharedNodeList> models = tree.find("//Model");
 766         assert(models->size() >= 1);
 767         for (XMLSharedNodeList::iterator i = models->begin();
 768              i != models->end();
 769              ++i) {
 770                 const XMLNodeList& contents = (*i)->children();
 771                 assert(contents.size() == 1);
 772                 XMLNode * content = *(contents.begin());
 773                 assert(content->is_content());
 774                 _models.insert(content->content());
 775         }
 776
 777         // CustomDeviceModes
 778         boost::shared_ptr<XMLSharedNodeList> custom_device_modes = tree.find("//CustomDeviceMode");
 779         for (XMLSharedNodeList::iterator i = custom_device_modes->begin();
 780              i != custom_device_modes->end();
 781              ++i) {
 782                 boost::shared_ptr<CustomDeviceMode> custom_device_mode(new CustomDeviceMode());
 783                 custom_device_mode->set_state(tree, *(*i));
 784
 785                 _custom_device_modes[custom_device_mode->name()] = custom_device_mode;
 786                 _custom_device_mode_names.push_back(custom_device_mode->name());
 787         }
 788
 789         // ChannelNameSets
 790         boost::shared_ptr<XMLSharedNodeList> channel_name_sets = tree.find("//ChannelNameSet");
 791         for (XMLSharedNodeList::iterator i = channel_name_sets->begin();
 792              i != channel_name_sets->end();
 793              ++i) {
 794                 boost::shared_ptr<ChannelNameSet> channel_name_set(new ChannelNameSet());
 795                 channel_name_set->set_state(tree, *(*i));
 796                 _channel_name_sets[channel_name_set->name()] = channel_name_set;
 797         }
 798
 799         // NoteNameLists
 800         boost::shared_ptr<XMLSharedNodeList> note_name_lists = tree.find("//NoteNameList");
 801         for (XMLSharedNodeList::iterator i = note_name_lists->begin();
 802              i != note_name_lists->end();
 803              ++i) {
 804                 boost::shared_ptr<NoteNameList> note_name_list(new NoteNameList());
 805                 note_name_list->set_state (tree, *(*i));
 806                 _note_name_lists[note_name_list->name()] = note_name_list;
 807         }
 808
 809         // ControlNameLists
 810         boost::shared_ptr<XMLSharedNodeList> control_name_lists = tree.find("//ControlNameList");
 811         for (XMLSharedNodeList::iterator i = control_name_lists->begin();
 812              i != control_name_lists->end();
 813              ++i) {
 814                 boost::shared_ptr<ControlNameList> control_name_list(new ControlNameList());
 815                 control_name_list->set_state (tree, *(*i));
 816                 _control_name_lists[control_name_list->name()] = control_name_list;
 817         }
 818
 819         // ValueNameLists
 820         boost::shared_ptr<XMLSharedNodeList> value_name_lists = tree.find("/child::MIDINameDocument/child::MasterDeviceNames/child::ValueNameList");
 821         for (XMLSharedNodeList::iterator i = value_name_lists->begin();
 822              i != value_name_lists->end();
 823              ++i) {
 824                 boost::shared_ptr<ValueNameList> value_name_list(new ValueNameList());
 825                 value_name_list->set_state (tree, *(*i));
 826                 _value_name_lists[value_name_list->name()] = value_name_list;
 827         }
 828
 829         // global/post-facto PatchNameLists
 830         boost::shared_ptr<XMLSharedNodeList> patch_name_lists = tree.find("/child::MIDINameDocument/child::MasterDeviceNames/child::PatchNameList");
 831         for (XMLSharedNodeList::iterator i = patch_name_lists->begin();
 832              i != patch_name_lists->end();
 833              ++i) {
 834
 835                 PatchNameList patch_name_list;
 836                 const XMLNodeList patches = (*i)->children();
 837
 838                 for (XMLNodeList::const_iterator p = patches.begin(); p != patches.end(); ++p) {
 839                         boost::shared_ptr<Patch> patch (new Patch ());
 840                         patch->set_state(tree, *(*p));
 841                         patch_name_list.push_back(patch);
 842                 }
 843
 844                 if (!patch_name_list.empty()) {
 845                         _patch_name_lists[(*i)->property ("Name")->value()] = patch_name_list;
 846                 }
 847         }
 848
 849         /* now traverse patches and hook up anything that used UsePatchNameList
 850          * to the right patch list
 851          */
 852
 853         for (ChannelNameSets::iterator cns = _channel_name_sets.begin(); cns != _channel_name_sets.end(); ++cns) {
 854                 ChannelNameSet::PatchBanks pbs = cns->second->patch_banks();
 855                 PatchNameLists::iterator p;
 856
 857                 for (ChannelNameSet::PatchBanks::iterator pb = pbs.begin(); pb != pbs.end(); ++pb) {
 858                         const std::string& pln = (*pb)->patch_list_name();
 859                         if (!pln.empty()) {
 860                                 if ((p = _patch_name_lists.find (pln)) != _patch_name_lists.end()) {
 861                                         if ((*pb)->set_patch_name_list (p->second)) {
 862                                                 return -1;
 863                                         }
 864                                         cns->second->use_patch_name_list (p->second);
 865                                 } else {
 866                                         error << string_compose ("Patch list name %1 was not found - patch file ignored", pln) << endmsg;
 867                                         return -1;
 868                                 }
 869                         }
 870                 }
 871
 872         }
 873
 874         return 0;
 875 }
 876
 877 XMLNode&
 878 MasterDeviceNames::get_state(void)
 879 {
 880         static XMLNode nothing("<nothing>");
 881         return nothing;
 882 }
 883
 884 MIDINameDocument::MIDINameDocument (const string& file_path)
 885         : _file_path(file_path)
 886 {
 887         XMLTree document;
 888         if (!document.read (file_path)) {
 889                 throw failed_constructor ();
 890         }
 891
 892         document.set_filename (file_path);
 893         set_state (document, *document.root());
 894 }
 895
 896 int
 897 MIDINameDocument::set_state (const XMLTree& tree, const XMLNode&)
 898 {
 899         // Author
 900
 901         boost::shared_ptr<XMLSharedNodeList> author = tree.find("//Author");
 902         if (author->size() < 1) {
 903                 error << "No author information in MIDNAM file" << endmsg;
 904                 return -1;
 905         }
 906
 907         if (author->front()->children().size() > 0) {
 908                 _author = author->front()->children().front()->content();
 909         }
 910
 911         // MasterDeviceNames
 912
 913         boost::shared_ptr<XMLSharedNodeList> master_device_names_list = tree.find ("//MasterDeviceNames");
 914
 915         for (XMLSharedNodeList::iterator i = master_device_names_list->begin();
 916              i != master_device_names_list->end();
 917              ++i) {
 918                 boost::shared_ptr<MasterDeviceNames> master_device_names(new MasterDeviceNames());
 919
 920                 if (master_device_names->set_state(tree, *(*i))) {
 921                         return -1;
 922                 }
 923
 924                 for (MasterDeviceNames::Models::const_iterator model = master_device_names->models().begin();
 925                      model != master_device_names->models().end();
 926                      ++model) {
 927                         _master_device_names_list.insert(
 928                                 std::pair<std::string, boost::shared_ptr<MasterDeviceNames> >
 929                                 (*model,      master_device_names));
 930
 931                         _all_models.insert(*model);
 932                 }
 933         }
 934
 935         return 0;
 936 }
 937
 938 XMLNode&
 939 MIDINameDocument::get_state(void)
 940 {
 941         static XMLNode nothing("<nothing>");
 942         return nothing;
 943 }
 944
 945 boost::shared_ptr<MasterDeviceNames>
 946 MIDINameDocument::master_device_names(const std::string& model)
 947 {
 948         MasterDeviceNamesList::const_iterator m = _master_device_names_list.find(model);
 949         if (m != _master_device_names_list.end()) {
 950                 return boost::shared_ptr<MasterDeviceNames>(m->second);
 951         }
 952         return boost::shared_ptr<MasterDeviceNames>();
 953 }
 954
 955 const char* general_midi_program_names[128] = {
 956         "Acoustic Grand Piano",
 957         "Bright Acoustic Piano",
 958         "Electric Grand Piano",
 959         "Honky-tonk Piano",
 960         "Rhodes Piano",
 961         "Chorused Piano",
 962         "Harpsichord",
 963         "Clavinet",
 964         "Celesta",
 965         "Glockenspiel",
 966         "Music Box",
 967         "Vibraphone",
 968         "Marimba",
 969         "Xylophone",
 970         "Tubular Bells",
 971         "Dulcimer",
 972         "Hammond Organ",
 973         "Percussive Organ",
 974         "Rock Organ",
 975         "Church Organ",
 976         "Reed Organ",
 977         "Accordion",
 978         "Harmonica",
 979         "Tango Accordion",
 980         "Acoustic Guitar (nylon)",
 981         "Acoustic Guitar (steel)",
 982         "Electric Guitar (jazz)",
 983         "Electric Guitar (clean)",
 984         "Electric Guitar (muted)",
 985         "Overdriven Guitar",
 986         "Distortion Guitar",
 987         "Guitar Harmonics",
 988         "Acoustic Bass",
 989         "Electric Bass (finger)",
 990         "Electric Bass (pick)",
 991         "Fretless Bass",
 992         "Slap Bass 1",
 993         "Slap Bass 2",
 994         "Synth Bass 1",
 995         "Synth Bass 2",
 996         "Violin",
 997         "Viola",
 998         "Cello",
 999         "Contrabass",
1000         "Tremolo Strings",
1001         "Pizzicato Strings",
1002         "Orchestral Harp",
1003         "Timpani",
1004         "String Ensemble 1",
1005         "String Ensemble 2",
1006         "SynthStrings 1",
1007         "SynthStrings 2",
1008         "Choir Aahs",
1009         "Voice Oohs",
1010         "Synth Voice",
1011         "Orchestra Hit",
1012         "Trumpet",
1013         "Trombone",
1014         "Tuba",
1015         "Muted Trumpet",
1016         "French Horn",
1017         "Brass Section",
1018         "Synth Brass 1",
1019         "Synth Brass 2",
1020         "Soprano Sax",
1021         "Alto Sax",
1022         "Tenor Sax",
1023         "Baritone Sax",
1024         "Oboe",
1025         "English Horn",
1026         "Bassoon",
1027         "Clarinet",
1028         "Piccolo",
1029         "Flute",
1030         "Recorder",
1031         "Pan Flute",
1032         "Bottle Blow",
1033         "Shakuhachi",
1034         "Whistle",
1035         "Ocarina",
1036         "Lead 1 (square)",
1037         "Lead 2 (sawtooth)",
1038         "Lead 3 (calliope lead)",
1039         "Lead 4 (chiff lead)",
1040         "Lead 5 (charang)",
1041         "Lead 6 (voice)",
1042         "Lead 7 (fifths)",
1043         "Lead 8 (bass + lead)",
1044         "Pad 1 (new age)",
1045         "Pad 2 (warm)",
1046         "Pad 3 (polysynth)",
1047         "Pad 4 (choir)",
1048         "Pad 5 (bowed)",
1049         "Pad 6 (metallic)",
1050         "Pad 7 (halo)",
1051         "Pad 8 (sweep)",
1052         "FX 1 (rain)",
1053         "FX 2 (soundtrack)",
1054         "FX 3 (crystal)",
1055         "FX 4 (atmosphere)",
1056         "FX 5 (brightness)",
1057         "FX 6 (goblins)",
1058         "FX 7 (echoes)",
1059         "FX 8 (sci-fi)",
1060         "Sitar",
1061         "Banjo",
1062         "Shamisen",
1063         "Koto",
1064         "Kalimba",
1065         "Bagpipe",
1066         "Fiddle",
1067         "Shanai",
1068         "Tinkle Bell",
1069         "Agogo",
1070         "Steel Drums",
1071         "Woodblock",
1072         "Taiko Drum",
1073         "Melodic Tom",
1074         "Synth Drum",
1075         "Reverse Cymbal",
1076         "Guitar Fret Noise",
1077         "Breath Noise",
1078         "Seashore",
1079         "Bird Tweet",
1080         "Telephone Ring",
1081         "Helicopter",
1082         "Applause",
1083         "Gunshot",
1084 };
1085
1086 } //namespace Name
1087
1088 } //namespace MIDI
1089