libs/midi++2/midi++/midnam_patch.h

   1 /*
   2     Copyright (C) 2012 Paul Davis
   3     Author: Hans Baier
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #ifndef MIDNAM_PATCH_H_
  21 #define MIDNAM_PATCH_H_
  22
  23 #include <algorithm>
  24 #include <iostream>
  25 #include <string>
  26 #include <list>
  27 #include <set>
  28 #include <map>
  29 #include <vector>
  30
  31 #include <stdint.h>
  32
  33 #include "midi++/event.h"
  34 #include "pbd/xml++.h"
  35
  36 namespace MIDI
  37 {
  38
  39 namespace Name
  40 {
  41
  42 struct PatchPrimaryKey
  43 {
  44 public:
  45         int bank_number;
  46         int program_number;
  47
  48         PatchPrimaryKey (uint8_t a_program_number = 0, uint16_t a_bank_number = 0) {
  49                 bank_number = std::min (a_bank_number, (uint16_t) 16384);
  50                 program_number = std::min (a_program_number, (uint8_t) 127);
  51         }
  52
  53         bool is_sane() const {
  54                 return ((bank_number >= 0) && (bank_number <= 16384) &&
  55                         (program_number >=0 ) && (program_number <= 127));
  56         }
  57
  58         inline PatchPrimaryKey& operator=(const PatchPrimaryKey& id) {
  59                 bank_number = id.bank_number;
  60                 program_number = id.program_number;
  61                 return *this;
  62         }
  63
  64         inline bool operator==(const PatchPrimaryKey& id) const {
  65                 return (bank_number == id.bank_number && program_number == id.program_number);
  66         }
  67
  68         /**
  69          * obey strict weak ordering or crash in STL containers
  70          */
  71         inline bool operator<(const PatchPrimaryKey& id) const {
  72                 if (bank_number < id.bank_number) {
  73                         return true;
  74                 } else if (bank_number == id.bank_number && program_number < id.program_number) {
  75                         return true;
  76                 }
  77
  78                 return false;
  79         }
  80 };
  81
  82 class PatchBank;
  83
  84 class Patch
  85 {
  86 public:
  87
  88         Patch (std::string a_name = std::string(), uint8_t a_number = 0, uint16_t bank_number = 0);
  89         virtual ~Patch() {};
  90
  91         const std::string& name() const         { return _name; }
  92         void set_name(const std::string a_name) { _name = a_name; }
  93
  94         const std::string& note_list_name() const  { return _note_list_name; }
  95
  96         uint8_t program_number() const     { return _id.program_number; }
  97         void set_program_number(uint8_t n) { _id.program_number = n; }
  98
  99         uint16_t bank_number() const      { return _id.bank_number; }
 100         void set_bank_number (uint16_t n) { _id.bank_number = n; }
 101
 102         const PatchPrimaryKey&   patch_primary_key()   const { return _id; }
 103
 104         XMLNode& get_state (void);
 105         int      set_state (const XMLTree&, const XMLNode&);
 106
 107 private:
 108         std::string     _name;
 109         PatchPrimaryKey _id;
 110         std::string     _note_list_name;
 111 };
 112
 113 class PatchBank
 114 {
 115 public:
 116         typedef std::list<boost::shared_ptr<Patch> > PatchNameList;
 117
 118         PatchBank (uint16_t n = 0, std::string a_name = std::string()) : _name(a_name), _number (n) {};
 119         virtual ~PatchBank() { }
 120
 121         const std::string& name() const               { return _name; }
 122         void set_name(const std::string a_name)       { _name = a_name; }
 123
 124         int number() const { return _number; }
 125
 126         const PatchNameList& patch_name_list() const { return _patch_name_list; }
 127         const std::string& patch_list_name() const { return _patch_list_name; }
 128
 129         int set_patch_name_list (const PatchNameList&);
 130
 131         XMLNode& get_state (void);
 132         int      set_state (const XMLTree&, const XMLNode&);
 133
 134 private:
 135         std::string       _name;
 136         uint16_t          _number;
 137         PatchNameList     _patch_name_list;
 138         std::string       _patch_list_name;
 139 };
 140
 141 class ChannelNameSet
 142 {
 143 public:
 144         typedef std::set<uint8_t>                                    AvailableForChannels;
 145         typedef std::list<boost::shared_ptr<PatchBank> >             PatchBanks;
 146         typedef std::map<PatchPrimaryKey, boost::shared_ptr<Patch> > PatchMap;
 147         typedef std::list<PatchPrimaryKey>                           PatchList;
 148
 149         ChannelNameSet() {};
 150         virtual ~ChannelNameSet() {};
 151         ChannelNameSet(std::string a_name) : _name(a_name) {};
 152
 153         const std::string& name() const          { return _name; }
 154         void set_name(const std::string a_name)  { _name = a_name; }
 155
 156         const PatchBanks& patch_banks() const    { return _patch_banks; }
 157
 158         bool available_for_channel(uint8_t channel) const {
 159                 return _available_for_channels.find(channel) != _available_for_channels.end();
 160         }
 161
 162         boost::shared_ptr<Patch> find_patch(const PatchPrimaryKey& key) {
 163                 assert(key.is_sane());
 164                 return _patch_map[key];
 165         }
 166
 167         boost::shared_ptr<Patch> previous_patch(const PatchPrimaryKey& key) {
 168                 assert(key.is_sane());
 169                 for (PatchList::const_iterator i = _patch_list.begin();
 170                          i != _patch_list.end();
 171                          ++i) {
 172                         if ((*i) == key) {
 173                                 if (i != _patch_list.begin()) {
 174                                         --i;
 175                                         return  _patch_map[*i];
 176                                 }
 177                         }
 178                 }
 179
 180                 return boost::shared_ptr<Patch>();
 181         }
 182
 183         boost::shared_ptr<Patch> next_patch(const PatchPrimaryKey& key) {
 184                 assert(key.is_sane());
 185                 for (PatchList::const_iterator i = _patch_list.begin();
 186                          i != _patch_list.end();
 187                          ++i) {
 188                         if ((*i) == key) {
 189                                 if (++i != _patch_list.end()) {
 190                                         return  _patch_map[*i];
 191                                 } else {
 192                                         --i;
 193                                 }
 194                         }
 195                 }
 196
 197                 return boost::shared_ptr<Patch>();
 198         }
 199
 200         const std::string& note_list_name() const { return _note_list_name; }
 201
 202         XMLNode& get_state (void);
 203         int      set_state (const XMLTree&, const XMLNode&);
 204
 205         void set_patch_banks (const PatchBanks&);
 206         void use_patch_name_list (const PatchBank::PatchNameList&);
 207
 208 private:
 209         friend std::ostream& operator<< (std::ostream&, const ChannelNameSet&);
 210         std::string _name;
 211         AvailableForChannels _available_for_channels;
 212         PatchBanks           _patch_banks;
 213         PatchMap             _patch_map;
 214         PatchList            _patch_list;
 215         std::string          _patch_list_name;
 216         std::string          _note_list_name;
 217 };
 218
 219 std::ostream& operator<< (std::ostream&, const ChannelNameSet&);
 220
 221 class Note
 222 {
 223 public:
 224         Note() {}
 225         Note(uint8_t number, const std::string& name) : _number(number), _name(name) {}
 226
 227         const std::string& name() const        { return _name; }
 228         void set_name(const std::string& name) { _name = name; }
 229
 230         uint8_t number() const             { return _number; }
 231         void    set_number(uint8_t number) { _number = number; }
 232
 233         XMLNode& get_state (void);
 234         int      set_state (const XMLTree&, const XMLNode&);
 235
 236 private:
 237         uint8_t     _number;
 238         std::string _name;
 239 };
 240
 241 class NoteNameList
 242 {
 243 public:
 244         typedef std::vector< boost::shared_ptr<Note> > Notes;
 245
 246         NoteNameList() { _notes.resize(128); }
 247         NoteNameList (const std::string& name) : _name(name) { _notes.resize(128); }
 248
 249         const std::string& name() const  { return _name; }
 250         const Notes&       notes() const { return _notes; }
 251
 252         void set_name(const std::string& name) { _name = name; }
 253
 254         XMLNode& get_state (void);
 255         int      set_state (const XMLTree&, const XMLNode&);
 256
 257 private:
 258         std::string _name;
 259         Notes       _notes;
 260 };
 261
 262 class Control
 263 {
 264 public:
 265         Control() {}
 266         Control(const std::string& type,
 267                 const std::string& number,
 268                 const std::string& name)
 269                 : _type(type)
 270                 , _number(number)
 271                 , _name(name)
 272         {}
 273
 274         const std::string& type()   const { return _type; }
 275         const std::string& number() const { return _number; }
 276         const std::string& name()   const { return _name; }
 277
 278         void set_type(const std::string& type)     { _type = type; }
 279         void set_number(const std::string& number) { _number = number; }
 280         void set_name(const std::string& name)     { _name = name; }
 281
 282         XMLNode& get_state(void);
 283         int      set_state(const XMLTree&, const XMLNode&);
 284
 285 private:
 286         std::string _type;
 287         std::string _number;
 288         std::string _name;
 289 };
 290
 291 class ControlNameList
 292 {
 293 public:
 294         typedef std::list< boost::shared_ptr<Control> > Controls;
 295
 296         ControlNameList() {}
 297         ControlNameList(const std::string& name) : _name(name) {}
 298
 299         const std::string& name() const { return _name; }
 300
 301         void set_name(const std::string name) { _name = name; }
 302
 303         const Controls& controls() const { return _controls; }
 304
 305         XMLNode& get_state(void);
 306         int      set_state(const XMLTree&, const XMLNode&);
 307
 308 private:
 309         std::string _name;
 310         Controls    _controls;
 311 };
 312
 313 class CustomDeviceMode
 314 {
 315 public:
 316         CustomDeviceMode() {};
 317         virtual ~CustomDeviceMode() {};
 318
 319         const std::string& name() const          { return _name; }
 320         void set_name(const std::string a_name)  { _name = a_name; }
 321
 322
 323         XMLNode& get_state (void);
 324         int      set_state (const XMLTree&, const XMLNode&);
 325
 326         /// Note: channel here is 0-based while in the MIDNAM-file it's 1-based
 327         std::string channel_name_set_name_by_channel(uint8_t channel) {
 328                 assert(channel <= 15);
 329                 return _channel_name_set_assignments[channel];
 330         }
 331
 332 private:
 333         /// array index = channel number
 334         /// string contents = name of channel name set
 335         std::string _name;
 336         std::string _channel_name_set_assignments[16];
 337 };
 338
 339 class MasterDeviceNames
 340 {
 341 public:
 342         typedef std::set<std::string>                                        Models;
 343         /// maps name to CustomDeviceMode
 344         typedef std::map<std::string, boost::shared_ptr<CustomDeviceMode> >  CustomDeviceModes;
 345         typedef std::list<std::string>                                       CustomDeviceModeNames;
 346         /// maps name to ChannelNameSet
 347         typedef std::map<std::string, boost::shared_ptr<ChannelNameSet> >    ChannelNameSets;
 348         typedef std::map<std::string, boost::shared_ptr<NoteNameList> >      NoteNameLists;
 349         typedef std::list<boost::shared_ptr<ControlNameList> >               ControlNameLists;
 350         typedef std::map<std::string, PatchBank::PatchNameList>              PatchNameLists;
 351
 352         MasterDeviceNames() {};
 353         virtual ~MasterDeviceNames() {};
 354
 355         const std::string& manufacturer() const { return _manufacturer; }
 356         void set_manufacturer(const std::string a_manufacturer) { _manufacturer = a_manufacturer; }
 357
 358         const Models& models() const { return _models; }
 359         void set_models(const Models some_models) { _models = some_models; }
 360
 361         const ControlNameLists& controls() const { return _control_name_lists; }
 362
 363         const CustomDeviceModeNames& custom_device_mode_names() const { return _custom_device_mode_names; }
 364
 365         boost::shared_ptr<CustomDeviceMode> custom_device_mode_by_name(std::string mode_name);
 366         boost::shared_ptr<ChannelNameSet> channel_name_set_by_device_mode_and_channel(std::string mode, uint8_t channel);
 367         boost::shared_ptr<Patch> find_patch(std::string mode, uint8_t channel, const PatchPrimaryKey& key);
 368
 369         boost::shared_ptr<NoteNameList>   note_name_list(const std::string& name);
 370         boost::shared_ptr<ChannelNameSet> channel_name_set(const std::string& name);
 371
 372         std::string note_name(const std::string& mode_name,
 373                               uint8_t            channel,
 374                               uint16_t           bank,
 375                               uint8_t            program,
 376                               uint8_t            number);
 377
 378         XMLNode& get_state (void);
 379         int      set_state (const XMLTree&, const XMLNode&);
 380
 381 private:
 382         std::string           _manufacturer;
 383         Models                _models;
 384         CustomDeviceModes     _custom_device_modes;
 385         CustomDeviceModeNames _custom_device_mode_names;
 386         ChannelNameSets       _channel_name_sets;
 387         NoteNameLists         _note_name_lists;
 388         PatchNameLists        _patch_name_lists;
 389         ControlNameLists      _control_name_lists;
 390 };
 391
 392 class MIDINameDocument
 393 {
 394 public:
 395         // Maps Model names to MasterDeviceNames
 396         typedef std::map<std::string, boost::shared_ptr<MasterDeviceNames> > MasterDeviceNamesList;
 397
 398         MIDINameDocument() {}
 399         MIDINameDocument(const std::string &filename);
 400         virtual ~MIDINameDocument() {};
 401
 402         const std::string& author() const { return _author; }
 403         void set_author(const std::string an_author) { _author = an_author; }
 404
 405         boost::shared_ptr<MasterDeviceNames> master_device_names(const std::string& model);
 406
 407         const MasterDeviceNamesList& master_device_names_by_model() const { return _master_device_names_list; }
 408
 409         const MasterDeviceNames::Models& all_models() const { return _all_models; }
 410
 411         XMLNode& get_state (void);
 412         int      set_state (const XMLTree&, const XMLNode&);
 413
 414 private:
 415         std::string                   _author;
 416         MasterDeviceNamesList         _master_device_names_list;
 417         XMLTree                       _document;
 418         MasterDeviceNames::Models     _all_models;
 419 };
 420
 421 extern const char* general_midi_program_names[128]; /* 0 .. 127 */
 422
 423 }
 424
 425 }
 426 #endif /*MIDNAM_PATCH_H_*/