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 (PatchBank* b)
  40 {
  41         use_bank_info (b);
  42 }
  43
  44 Patch::Patch (std::string a_number, std::string a_name, PatchBank* a_bank)
  45         : _number (a_number)
  46         , _name (a_name)
  47 {
  48         use_bank_info (a_bank);
  49 }
  50
  51 XMLNode&
  52 Patch::get_state (void)
  53 {
  54         XMLNode* node = new XMLNode("Patch");
  55         node->add_property("Number", _number);
  56         node->add_property("Name",   _name);
  57         /*
  58         typedef std::list< boost::shared_ptr< Evoral::MIDIEvent<double> > > PatchMidiCommands;
  59         XMLNode* commands = node->add_child("PatchMIDICommands");
  60         for (PatchMidiCommands::const_iterator event = _patch_midi_commands.begin();
  61             event != _patch_midi_commands.end();
  62             ++event) {
  63                 commands->add_child_copy(*((((Evoral::MIDIEvent&)*event)).to_xml()));
  64         }
  65         */
  66
  67         return *node;
  68 }
  69
  70 int initialize_primary_key_from_commands (PatchPrimaryKey& id, const XMLNode* node)
  71 {
  72         const XMLNodeList events = node->children();
  73         for (XMLNodeList::const_iterator i = events.begin(); i != events.end(); ++i) {
  74                 XMLNode* node = *i;
  75                 if (node->name() == "ControlChange") {
  76                         string control = node->property("Control")->value();
  77                         assert(control != "");
  78                         string value = node->property("Value")->value();
  79                         assert(value != "");
  80
  81                         id.bank_number = 0;
  82
  83                         if (control == "0") {
  84                                 id.bank_number |= (PBD::atoi (value)<<7);
  85                         } else if (control == "32") {
  86                                 id.bank_number |= PBD::atoi (value);
  87                         }
  88                 } else if (node->name() == "ProgramChange") {
  89                         string number = node->property("Number")->value();
  90                         assert(number != "");
  91                         id.program_number = PBD::atoi(number);
  92                 }
  93         }
  94
  95         return 0;
  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         _number = 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         return 0;
 133 }
 134
 135 int
 136 Patch::use_bank_info (PatchBank* bank)
 137 {
 138         if (bank) {
 139                 if (bank->patch_primary_key() ) {
 140                         _id.bank_number = bank->patch_primary_key()->bank_number;
 141                 } else {
 142                         return -1;
 143                 }
 144         }
 145
 146         if (!_id.is_sane()) {
 147                 return -1;
 148         }
 149
 150         return 0;
 151 }
 152
 153 XMLNode&
 154 Note::get_state (void)
 155 {
 156         XMLNode* node = new XMLNode("Note");
 157         node->add_property("Number", _number);
 158         node->add_property("Name",   _name);
 159
 160         return *node;
 161 }
 162
 163 int
 164 Note::set_state (const XMLTree&, const XMLNode& node)
 165 {
 166         assert(node.name() == "Note");
 167         _number = node.property("Number")->value();
 168         _name   = node.property("Name")->value();
 169
 170         return 0;
 171 }
 172
 173 XMLNode&
 174 NoteNameList::get_state (void)
 175 {
 176         XMLNode* node = new XMLNode("NoteNameList");
 177         node->add_property("Name",   _name);
 178
 179         return *node;
 180 }
 181
 182 int
 183 NoteNameList::set_state (const XMLTree& tree, const XMLNode& node)
 184 {
 185         assert(node.name() == "NoteNameList");
 186         _name   = node.property("Name")->value();
 187
 188         boost::shared_ptr<XMLSharedNodeList> notes = tree.find("//Note");
 189         for (XMLSharedNodeList::const_iterator i = notes->begin(); i != notes->end(); ++i) {
 190                 boost::shared_ptr<Note> note(new Note());
 191                 note->set_state (tree, *(*i));
 192                 _notes.push_back(note);
 193         }
 194
 195         return 0;
 196 }
 197
 198
 199 XMLNode&
 200 PatchBank::get_state (void)
 201 {
 202         XMLNode* node = new XMLNode("PatchBank");
 203         node->add_property("Name",   _name);
 204         XMLNode* patch_name_list = node->add_child("PatchNameList");
 205         for (PatchNameList::iterator patch = _patch_name_list.begin();
 206             patch != _patch_name_list.end();
 207             ++patch) {
 208                 patch_name_list->add_child_nocopy((*patch)->get_state());
 209         }
 210
 211         return *node;
 212 }
 213
 214 int
 215 PatchBank::set_state (const XMLTree& tree, const XMLNode& node)
 216 {
 217         assert(node.name() == "PatchBank");
 218         _name   = node.property("Name")->value();
 219
 220         XMLNode* commands = node.child("MIDICommands");
 221         if (commands) {
 222                 _id = new PatchPrimaryKey();
 223                 if (initialize_primary_key_from_commands(*_id, commands)) {
 224                         return -1;
 225                 }
 226         }
 227
 228         XMLNode* patch_name_list = node.child("PatchNameList");
 229
 230         if (patch_name_list) {
 231                 const XMLNodeList patches = patch_name_list->children();
 232                 for (XMLNodeList::const_iterator i = patches.begin(); i != patches.end(); ++i) {
 233                         boost::shared_ptr<Patch> patch(new Patch(this));
 234                         patch->set_state(tree, *(*i));
 235                         _patch_name_list.push_back(patch);
 236                 }
 237         } else {
 238                 XMLNode* use_patch_name_list = node.child ("UsesPatchNameList");
 239                 if (use_patch_name_list) {
 240                         _patch_list_name = use_patch_name_list->property ("Name")->value();
 241                 } else {
 242                         error << "Patch without patch name list - patchfile will be ignored" << endmsg;
 243                         return -1;
 244                 }
 245         }
 246
 247         return 0;
 248 }
 249
 250 int
 251 PatchBank::set_patch_name_list (const PatchNameList& pnl)
 252 {
 253         _patch_name_list = pnl;
 254         _patch_list_name = "";
 255
 256         for (PatchNameList::iterator p = _patch_name_list.begin(); p != _patch_name_list.end(); p++) {
 257                 if ((*p)->use_bank_info (this)) {
 258                         return -1;
 259                 }
 260         }
 261
 262         return 0;
 263 }
 264
 265 XMLNode&
 266 ChannelNameSet::get_state (void)
 267 {
 268         XMLNode* node = new XMLNode("ChannelNameSet");
 269         node->add_property("Name",   _name);
 270
 271         XMLNode* available_for_channels = node->add_child("AvailableForChannels");
 272         assert(available_for_channels);
 273
 274         for (uint8_t channel = 0; channel < 16; ++channel) {
 275                 XMLNode* available_channel = available_for_channels->add_child("AvailableChannel");
 276                 assert(available_channel);
 277
 278                 available_channel->add_property("Channel", (long) channel);
 279
 280                 if (_available_for_channels.find(channel) != _available_for_channels.end()) {
 281                         available_channel->add_property("Available", "true");
 282                 } else {
 283                         available_channel->add_property("Available", "false");
 284                 }
 285         }
 286
 287         for (PatchBanks::iterator patch_bank = _patch_banks.begin();
 288             patch_bank != _patch_banks.end();
 289             ++patch_bank) {
 290                 node->add_child_nocopy((*patch_bank)->get_state());
 291         }
 292
 293         return *node;
 294 }
 295
 296 int
 297 ChannelNameSet::set_state (const XMLTree& tree, const XMLNode& node)
 298 {
 299         assert(node.name() == "ChannelNameSet");
 300         _name   = node.property("Name")->value();
 301         const XMLNodeList children = node.children();
 302         for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
 303                 XMLNode* node = *i;
 304                 assert(node);
 305                 if (node->name() == "AvailableForChannels") {
 306                         boost::shared_ptr<XMLSharedNodeList> channels =
 307                                 tree.find("//AvailableChannel[@Available = 'true']/@Channel");
 308                         for(XMLSharedNodeList::const_iterator i = channels->begin();
 309                             i != channels->end();
 310                             ++i) {
 311                                 _available_for_channels.insert(atoi((*i)->attribute_value().c_str()));
 312                         }
 313                 }
 314
 315                 if (node->name() == "PatchBank") {
 316                         boost::shared_ptr<PatchBank> bank(new PatchBank());
 317                         bank->set_state(tree, *node);
 318                         _patch_banks.push_back(bank);
 319                         const PatchBank::PatchNameList& patches = bank->patch_name_list();
 320                         for (PatchBank::PatchNameList::const_iterator patch = patches.begin();
 321                              patch != patches.end();
 322                              ++patch) {
 323                                 _patch_map[(*patch)->patch_primary_key()] = *patch;
 324                                 _patch_list.push_back((*patch)->patch_primary_key());
 325                         }
 326                 }
 327         }
 328
 329         return 0;
 330 }
 331
 332 int
 333 CustomDeviceMode::set_state(const XMLTree& tree, const XMLNode& a_node)
 334 {
 335         assert(a_node.name() == "CustomDeviceMode");
 336
 337         _name = a_node.property("Name")->value();
 338
 339         boost::shared_ptr<XMLSharedNodeList> channel_name_set_assignments =
 340                 tree.find("//ChannelNameSetAssign");
 341         for(XMLSharedNodeList::const_iterator i = channel_name_set_assignments->begin();
 342             i != channel_name_set_assignments->end();
 343             ++i) {
 344                 int channel = atoi((*i)->property("Channel")->value().c_str());
 345                 string name_set = (*i)->property("NameSet")->value();
 346                 assert( 1 <= channel && channel <= 16 );
 347                 _channel_name_set_assignments[channel - 1] = name_set;
 348         }
 349         return 0;
 350 }
 351
 352 XMLNode&
 353 CustomDeviceMode::get_state(void)
 354 {
 355         XMLNode* custom_device_mode = new XMLNode("CustomDeviceMode");
 356         custom_device_mode->add_property("Name",   _name);
 357         XMLNode* channel_name_set_assignments =
 358                 custom_device_mode->add_child("ChannelNameSetAssignments");
 359         for (int i = 0; i < 15 && !_channel_name_set_assignments[i].empty(); i++) {
 360                 XMLNode* channel_name_set_assign =
 361                         channel_name_set_assignments->add_child("ChannelNameSetAssign");
 362                 channel_name_set_assign->add_property("Channel", i + 1);
 363                 channel_name_set_assign->add_property("NameSet", _channel_name_set_assignments[i]);
 364         }
 365
 366         return *custom_device_mode;
 367 }
 368
 369 int
 370 MasterDeviceNames::set_state(const XMLTree& tree, const XMLNode& a_node)
 371 {
 372         // Manufacturer
 373         boost::shared_ptr<XMLSharedNodeList> manufacturer = tree.find("//Manufacturer");
 374         assert(manufacturer->size() == 1);
 375         _manufacturer = manufacturer->front()->content();
 376
 377         // Models
 378         boost::shared_ptr<XMLSharedNodeList> models = tree.find("//Model");
 379         assert(models->size() >= 1);
 380         for (XMLSharedNodeList::iterator i = models->begin();
 381              i != models->end();
 382              ++i) {
 383                 const XMLNodeList& contents = (*i)->children();
 384                 assert(contents.size() == 1);
 385                 XMLNode * content = *(contents.begin());
 386                 assert(content->is_content());
 387                 _models.push_back(content->content());
 388         }
 389
 390         // CustomDeviceModes
 391         boost::shared_ptr<XMLSharedNodeList> custom_device_modes = tree.find("//CustomDeviceMode");
 392         for (XMLSharedNodeList::iterator i = custom_device_modes->begin();
 393              i != custom_device_modes->end();
 394              ++i) {
 395                 boost::shared_ptr<CustomDeviceMode> custom_device_mode(new CustomDeviceMode());
 396                 custom_device_mode->set_state(tree, *(*i));
 397
 398                 _custom_device_modes[custom_device_mode->name()] = custom_device_mode;
 399                 _custom_device_mode_names.push_back(custom_device_mode->name());
 400         }
 401
 402         // ChannelNameSets
 403         boost::shared_ptr<XMLSharedNodeList> channel_name_sets = tree.find("//ChannelNameSet");
 404         for (XMLSharedNodeList::iterator i = channel_name_sets->begin();
 405              i != channel_name_sets->end();
 406              ++i) {
 407                 boost::shared_ptr<ChannelNameSet> channel_name_set(new ChannelNameSet());
 408                 channel_name_set->set_state(tree, *(*i));
 409                 _channel_name_sets[channel_name_set->name()] = channel_name_set;
 410         }
 411
 412         // NoteNameLists
 413         boost::shared_ptr<XMLSharedNodeList> note_name_lists = tree.find("//NoteNameList");
 414         for (XMLSharedNodeList::iterator i = note_name_lists->begin();
 415              i != note_name_lists->end();
 416              ++i) {
 417                 boost::shared_ptr<NoteNameList> note_name_list(new NoteNameList());
 418                 note_name_list->set_state (tree, *(*i));
 419                 _note_name_lists.push_back(note_name_list);
 420         }
 421
 422         // global/post-facto PatchNameLists
 423         boost::shared_ptr<XMLSharedNodeList> patch_name_lists = tree.find("/child::MIDINameDocument/child::MasterDeviceNames/child::PatchNameList");
 424         for (XMLSharedNodeList::iterator i = patch_name_lists->begin();
 425              i != patch_name_lists->end();
 426              ++i) {
 427
 428                 PatchBank::PatchNameList patch_name_list;
 429                 const XMLNodeList patches = (*i)->children();
 430
 431                 for (XMLNodeList::const_iterator p = patches.begin(); p != patches.end(); ++p) {
 432                         boost::shared_ptr<Patch> patch(new Patch());
 433                         patch->set_state(tree, *(*p));
 434                         patch_name_list.push_back(patch);
 435                 }
 436
 437                 if (!patch_name_list.empty()) {
 438                         _patch_name_lists[(*i)->property ("Name")->value()] = patch_name_list;
 439                 }
 440         }
 441
 442         /* now traverse patches and hook up anything that used UsePatchNameList
 443          * to the right patch list
 444          */
 445
 446         for (ChannelNameSets::iterator cns = _channel_name_sets.begin(); cns != _channel_name_sets.end(); ++cns) {
 447                 ChannelNameSet::PatchBanks pbs = cns->second->patch_banks();
 448                 for (ChannelNameSet::PatchBanks::iterator pb = pbs.begin(); pb != pbs.end(); ++pb) {
 449                         std::string pln = (*pb)->patch_list_name();
 450                         if (!pln.empty()) {
 451                                 PatchNameLists::iterator p = _patch_name_lists.find (pln);
 452                                 if (p != _patch_name_lists.end()) {
 453                                         if ((*pb)->set_patch_name_list (p->second)) {
 454                                                 return -1;
 455                                         }
 456                                 } else {
 457                                         error << string_compose ("Patch list name %1 was not found - patch file ignored", pln) << endmsg;
 458                                         return -1;
 459                                 }
 460                         }
 461                 }
 462         }
 463
 464         return 0;
 465 }
 466
 467 XMLNode&
 468 MasterDeviceNames::get_state(void)
 469 {
 470         static XMLNode nothing("<nothing>");
 471         return nothing;
 472 }
 473
 474 MIDINameDocument::MIDINameDocument (const string& filename)
 475 {
 476         if (!_document.read (filename)) {
 477                 throw failed_constructor ();
 478         }
 479
 480         set_state (_document, *_document.root());
 481 }
 482
 483 int
 484 MIDINameDocument::set_state (const XMLTree& tree, const XMLNode& a_node)
 485 {
 486         // Author
 487
 488         boost::shared_ptr<XMLSharedNodeList> author = tree.find("//Author");
 489         if (author->size() < 1) {
 490                 error << "No author information in MIDNAM file" << endmsg;
 491                 return -1;
 492         }
 493         _author = author->front()->content();
 494
 495         // MasterDeviceNames
 496
 497         boost::shared_ptr<XMLSharedNodeList> master_device_names_list = tree.find ("//MasterDeviceNames");
 498
 499         for (XMLSharedNodeList::iterator i = master_device_names_list->begin();
 500              i != master_device_names_list->end();
 501              ++i) {
 502                 boost::shared_ptr<MasterDeviceNames> master_device_names(new MasterDeviceNames());
 503
 504                 if (master_device_names->set_state(tree, *(*i))) {
 505                         return -1;
 506                 }
 507
 508                 for (MasterDeviceNames::Models::const_iterator model = master_device_names->models().begin();
 509                      model != master_device_names->models().end();
 510                      ++model) {
 511                         _master_device_names_list.insert(
 512                                 std::pair<std::string, boost::shared_ptr<MasterDeviceNames> >
 513                                 (*model,      master_device_names));
 514
 515                         _all_models.push_back(*model);
 516                 }
 517         }
 518
 519         return 0;
 520 }
 521
 522 XMLNode&
 523 MIDINameDocument::get_state(void)
 524 {
 525         static XMLNode nothing("<nothing>");
 526         return nothing;
 527 }
 528
 529
 530 } //namespace Name
 531
 532 } //namespace MIDI
 533