libs/midi++2/midnam_patch.cc

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