MuseScore/aeolus/model.h

/*
    Copyright (C) 2003-2008 Fons Adriaensen <fons@kokkinizita.net>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __MODEL_H
#define __MODEL_H

#include "messages.h"
#include "addsynth.h"
#include "rankwave.h"
#include "global.h"

class Aeolus;

class Asect
{
public:

    Asect (void) { *_label = 0; }

    char _label[64];
};

class Rank
{
public:

    int _count;
    Addsynth* _sdef;
    Rankwave* _wave;
};

class Divis
{
public:

    enum {
        HAS_SWELL = 1, HAS_TREM = 2, NRANK = 32
    };
    enum {
        SWELL, TFREQ, TMODD, NPARAM
    };

    Divis();

    char _label[16];
    int _flags;
    int _dmask;
    int _nrank;
    int _asect;
    int _keybd;
    SyntiParameter _param[NPARAM];
    Rank _ranks[NRANK];
};

class Keybd
{
public:

    enum {
        IS_PEDAL = 256
    };

    Keybd ();

    char _label[16];
    int _flags;
};

class Ifelm
{
public:

    enum {
        DIVRANK, KBDRANK, COUPLER, TREMUL
    };

    Ifelm ();

    char _label[32];
    char _mnemo[8];
    int _type;
    int _keybd;
    int _state;
    uint32_t _action0;
    uint32_t _action1;
};

class Group
{
public:

    enum {
        NIFELM = 32
    };

    Group();

    char _label[16];
    int _nifelm;
    Ifelm _ifelms[NIFELM];
};

class Chconf
{
public:

    Chconf () { memset(_bits, 0, 16 * sizeof(uint16_t)); }

    uint16_t _bits[16];
};

//---------------------------------------------------------
//   Preset
//---------------------------------------------------------

class Preset
{
public:

    Preset () { memset(_bits, 0, NGROUP * sizeof(uint32_t)); }

    uint32_t _bits[NGROUP];
};

//---------------------------------------------------------
//   Model
//---------------------------------------------------------

class Model
{
    Aeolus* _aeolus;
    uint16_t* _midimap;
    const char* _stops;
    char _instr[1024];
    const char* _waves;
    bool _ready;

    Asect _asect[NASECT];
    Keybd _keybd[NKEYBD];
    Divis _divis[NDIVIS];
    Group _group[NGROUP];

    int _nasect;
    int _ndivis;
    int _nkeybd;
    int _ngroup;
    float _fbase;
    int _itemp;
    int _count;
    int _bank;
    int _pres;
    int _client;
    int _portid;
    int _sc_cmode;               // stop control command mode
    int _sc_group;               // stop control group number
    Chconf _chconf[8];
    Preset* _preset[NBANK][NPRES];

    void init_audio();
    void init_iface();
    void init_ranks(int comm);
    void proc_rank(int g, int i, int comm);
    void set_mconf(int i, uint16_t* d);
    void get_state(uint32_t* bits);
    void set_state(int bank, int pres);
    void midi_off(int mask);
    void retune(float freq, int temp);
    void recalc(int g, int i);
    void save();
    Rank* find_rank(int g, int i);
    int  read_instr();
    int  write_instr();
    int  get_preset(int bank, int pres, uint32_t* bits);
    void set_preset(int bank, int pres, uint32_t* bits);
    void ins_preset(int bank, int pres, uint32_t* bits);
    void del_preset(int bank, int pres);
    int  read_presets();
    bool writePresets();

public:
    Model (Aeolus* aeolus, uint16_t* midimap, const char* stops,const char* instr, const char* waves);

    virtual ~Model() {}

    void set_ifelm(int g, int i, int m);
    void clr_group(int g);
    void init();
};

#endif