raze-gles/libraries/timidityplus/timiditypp/instrum.h

565 lines
17 KiB
C
Raw Normal View History

2019-11-10 22:58:51 +00:00
/*
TiMidity++ -- MIDI to WAVE converter and player
Copyright (C) 1999-2002 Masanao Izumo <mo@goice.co.jp>
Copyright (C) 1995 Tuukka Toivonen <tt@cgs.fi>
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
instrum.h
*/
#ifndef ___INSTRUM_H_
#define ___INSTRUM_H_
#include <string>
#include "common.h"
#include "sysdep.h"
#include "sffile.h"
#include "sflayer.h"
#include "sfitem.h"
#include "../../music_common/fileio.h"
namespace TimidityPlus
{
using timidity_file = MusicIO::FileInterface;
enum
{
READ_CONFIG_SUCCESS = 0,
READ_CONFIG_ERROR = 1,
READ_CONFIG_RECURSION = 2, /* Too much recursion */
READ_CONFIG_FILE_NOT_FOUND = 3, /* Returned only w. allow_missing_file */
};
struct Sample
{
splen_t
loop_start, loop_end, data_length;
int32_t
sample_rate, low_freq, high_freq, root_freq;
int8_t panning, note_to_use;
int32_t
envelope_rate[6], envelope_offset[6],
modenv_rate[6], modenv_offset[6];
double
volume;
sample_t
*data;
int32_t
tremolo_sweep_increment, tremolo_phase_increment,
vibrato_sweep_increment, vibrato_control_ratio;
int16_t
tremolo_depth;
int16_t vibrato_depth;
uint8_t
modes, data_alloced,
low_vel, high_vel;
int32_t cutoff_freq; /* in Hz, [1, 20000] */
int16_t resonance; /* in centibels, [0, 960] */
/* in cents, [-12000, 12000] */
int16_t tremolo_to_pitch, tremolo_to_fc, modenv_to_pitch, modenv_to_fc,
envelope_keyf[6], envelope_velf[6], modenv_keyf[6], modenv_velf[6],
vel_to_fc, key_to_fc;
int16_t vel_to_resonance; /* in centibels, [-960, 960] */
int8_t envelope_velf_bpo, modenv_velf_bpo,
key_to_fc_bpo, vel_to_fc_threshold; /* in notes */
int32_t vibrato_delay, tremolo_delay, envelope_delay, modenv_delay; /* in samples */
int16_t scale_freq; /* in notes */
int16_t scale_factor; /* in 1024divs/key */
int8_t inst_type;
int32_t sf_sample_index, sf_sample_link; /* for stereo SoundFont */
uint16_t sample_type; /* 1 = Mono, 2 = Right, 4 = Left, 8 = Linked, $8000 = ROM */
double root_freq_detected; /* root freq from pitch detection */
int transpose_detected; /* note offset from detected root */
int chord; /* type of chord for detected pitch */
};
/* Bits in modes: */
enum
{
MODES_16BIT = (1 << 0),
MODES_UNSIGNED = (1 << 1),
MODES_LOOPING = (1 << 2),
MODES_PINGPONG = (1 << 3),
MODES_REVERSE = (1 << 4),
MODES_SUSTAIN = (1 << 5),
MODES_ENVELOPE = (1 << 6),
MODES_CLAMPED = (1 << 7), /* ?? (for last envelope??) */
INST_GUS = 0,
INST_SF2 = 1,
INST_MOD = 2,
INST_PCM = 3, /* %sample */
/* sfSampleType */
SF_SAMPLETYPE_MONO = 1,
SF_SAMPLETYPE_RIGHT = 2,
SF_SAMPLETYPE_LEFT = 4,
SF_SAMPLETYPE_LINKED = 8,
SF_SAMPLETYPE_ROM = 0x8000,
};
struct Instrument
{
int type;
int samples;
Sample *sample;
char *instname;
};
struct ToneBankElement
{
char *name;
char *comment;
Instrument *instrument;
int8_t note, pan, strip_loop, strip_envelope, strip_tail, loop_timeout,
font_preset, font_keynote, legato, tva_level, play_note, damper_mode;
uint8_t font_bank;
uint8_t instype; /* 0: Normal
1: %font
2: %sample
3-255: reserved
*/
int16_t amp;
int16_t rnddelay;
int tunenum;
float *tune;
int sclnotenum;
int16_t *sclnote;
int scltunenum;
int16_t *scltune;
int fcnum;
int16_t *fc;
int resonum;
int16_t *reso;
int trempitchnum, tremfcnum, modpitchnum, modfcnum;
int16_t *trempitch, *tremfc, *modpitch, *modfc;
int envratenum, envofsnum;
int **envrate, **envofs;
int modenvratenum, modenvofsnum;
int **modenvrate, **modenvofs;
int envvelfnum, envkeyfnum;
int **envvelf, **envkeyf;
int modenvvelfnum, modenvkeyfnum;
int **modenvvelf, **modenvkeyf;
int tremnum, vibnum;
struct Quantity_ **trem, **vib;
int16_t vel_to_fc, key_to_fc, vel_to_resonance;
int8_t reverb_send, chorus_send, delay_send;
};
/* A hack to delay instrument loading until after reading the
entire MIDI file. */
#define MAGIC_LOAD_INSTRUMENT ((Instrument *)(-1))
#define MAGIC_ERROR_INSTRUMENT ((Instrument *)(-2))
#define IS_MAGIC_INSTRUMENT(ip) ((ip) == MAGIC_LOAD_INSTRUMENT || (ip) == MAGIC_ERROR_INSTRUMENT)
#define DYNAMIC_INSTRUMENT_NAME ""
struct AlternateAssign
{
/* 128 bit vector:
* bits[(note >> 5) & 0x3] & (1 << (note & 0x1F))
*/
uint32_t bits[4];
AlternateAssign* next;
};
struct ToneBank
{
ToneBankElement tone[128];
AlternateAssign *alt;
};
struct SpecialPatch /* To be used MIDI Module play mode */
{
int type;
int samples;
Sample *sample;
char *name;
int32_t sample_offset;
};
enum instrument_mapID
{
INST_NO_MAP = 0,
SC_55_TONE_MAP,
SC_55_DRUM_MAP,
SC_88_TONE_MAP,
SC_88_DRUM_MAP,
SC_88PRO_TONE_MAP,
SC_88PRO_DRUM_MAP,
SC_8850_TONE_MAP,
SC_8850_DRUM_MAP,
XG_NORMAL_MAP,
XG_SFX64_MAP,
XG_SFX126_MAP,
XG_DRUM_MAP,
GM2_TONE_MAP,
GM2_DRUM_MAP,
NUM_INST_MAP
};
enum
{
MAP_BANK_COUNT = 256,
NSPECIAL_PATCH = 256,
SPECIAL_PROGRAM = -1,
MAX_MREL = 5000,
DEFAULT_MREL = 800,
};
struct SFInsts;
struct InstList;
struct SampleList;
struct AIFFCommonChunk;
struct AIFFSoundDataChunk;
struct SampleImporter;
class Instruments
{
std::string configFileName;
MusicIO::SoundFontReaderInterface *sfreader;
ToneBank standard_tonebank, standard_drumset;
enum
{
INSTRUMENT_HASH_SIZE = 128,
};
struct InstrumentCache
{
char *name;
int panning, amp, note_to_use, strip_loop, strip_envelope, strip_tail;
Instrument *ip;
InstrumentCache *next;
};
InstrumentCache *instrument_cache[INSTRUMENT_HASH_SIZE] = { nullptr };
/* bank mapping (mapped bank) */
struct bank_map_elem
{
int16_t used = 0, mapid = 0;
int bankno = 0;
};
bank_map_elem map_bank[MAP_BANK_COUNT], map_drumset[MAP_BANK_COUNT];
int map_bank_counter = 0;
struct inst_map_elem
{
int set, elem, mapped;
};
inst_map_elem *inst_map_table[NUM_INST_MAP][128] = { { nullptr} };
struct UserInstrument
{
int8_t bank;
int8_t prog;
int8_t source_map;
int8_t source_bank;
int8_t source_prog;
int8_t vibrato_rate;
int8_t vibrato_depth;
int8_t cutoff_freq;
int8_t resonance;
int8_t env_attack;
int8_t env_decay;
int8_t env_release;
int8_t vibrato_delay;
UserInstrument *next;
};
UserInstrument *userinst_first = (UserInstrument *)NULL;
UserInstrument *userinst_last = (UserInstrument *)NULL;
struct UserDrumset {
int8_t bank;
int8_t prog;
int8_t play_note;
int8_t level;
int8_t assign_group;
int8_t pan;
int8_t reverb_send_level;
int8_t chorus_send_level;
int8_t rx_note_off;
int8_t rx_note_on;
int8_t delay_send_level;
int8_t source_map;
int8_t source_prog;
int8_t source_note;
UserDrumset *next;
};
struct SFBags
{
int nbags;
uint16_t *bag;
int ngens;
SFGenRec *gen;
};
SFBags prbags, inbags;
UserDrumset *userdrum_first = (UserDrumset *)NULL;
UserDrumset *userdrum_last = (UserDrumset *)NULL;
AlternateAssign alt[2];
/* Some functions get aggravated if not even the standard banks are available. */
ToneBank
*tonebank[128 + MAP_BANK_COUNT] = { &standard_tonebank },
*drumset[128 + MAP_BANK_COUNT] = { &standard_drumset };
Instrument *default_instrument = 0;
SpecialPatch *special_patch[NSPECIAL_PATCH] = { nullptr };
int default_program[MAX_CHANNELS] = { 0 }; /* This is only used for tracks that don't specify a program */
char *default_instrument_name = nullptr;
int progbase = 0;
int32_t modify_release = 0;
bool opt_sf_close_each_file = true;
char def_instr_name[256] = { '\0' };
SFInsts *sfrecs = nullptr;
SFInsts *current_sfrec = nullptr;
int last_sample_type = 0;
int last_sample_instrument = 0;
int last_sample_keyrange = 0;
SampleList *last_sample_list = nullptr;
LayerItem layer_items[SF_EOF];
/* convert from 8bit value to fractional offset (15.15) */
int32_t to_offset_22(int offset)
{
return (int32_t)offset << (7 + 15);
}
int32_t calc_rate_i(int diff, double msec);
int32_t convert_envelope_rate(uint8_t rate);
int32_t convert_envelope_offset(uint8_t offset);
int32_t convert_tremolo_sweep(uint8_t sweep);
int32_t convert_vibrato_sweep(uint8_t sweep, int32_t vib_control_ratio);
int32_t convert_tremolo_rate(uint8_t rate);
int32_t convert_vibrato_rate(uint8_t rate);
void reverse_data(int16_t *sp, int32_t ls, int32_t le);
int name_hash(char *name);
Instrument *search_instrument_cache(char *name, int panning, int amp, int note_to_use, int strip_loop, int strip_envelope, int strip_tail);
void store_instrument_cache(Instrument *ip, char *name, int panning, int amp, int note_to_use, int strip_loop, int strip_envelope, int strip_tail);
int32_t to_rate(int rate);
void apply_bank_parameter(Instrument *ip, ToneBankElement *tone);
Instrument *load_gus_instrument(char *name, ToneBank *bank, int dr, int prog);
int fill_bank(int dr, int b, int *rc);
void free_tone_bank_list(ToneBank *tb[]);
void free_tone_bank(void);
void free_instrument_map(void);
int set_default_instrument(char *name);
void *safe_memdup(void *s, size_t size);
void MarkInstrument(int banknum, int percussion, int instr);
//smplfile.c
Instrument *extract_sample_file(char *);
int32_t convert_envelope_rate_s(uint8_t rate);
void initialize_sample(Instrument *inst, int frames, int sample_bits, int sample_rate);
int get_importers(const char *sample_file, int limit, SampleImporter **importers);
int get_next_importer(char *sample_file, int start, int count, SampleImporter **importers);
int import_wave_discriminant(char *sample_file);
int import_wave_load(char *sample_file, Instrument *inst);
int import_aiff_discriminant(char *sample_file);
int import_aiff_load(char *sample_file, Instrument *inst);
int read_AIFFCommonChunk(timidity_file *tf, AIFFCommonChunk *comm, int csize, int compressed);
int read_AIFFSoundData(timidity_file *tf, Instrument *inst, AIFFCommonChunk *common);
int read_AIFFSoundDataChunk(timidity_file *tf, AIFFSoundDataChunk *sound, int csize, int mode);
// sndfont.cpp
SFInsts *find_soundfont(char *sf_file);
SFInsts *new_soundfont(char *sf_file);
void init_sf(SFInsts *rec);
void end_soundfont(SFInsts *rec);
Instrument *try_load_soundfont(SFInsts *rec, int order, int bank, int preset, int keynote);
Instrument *load_from_file(SFInsts *rec, InstList *ip);
int is_excluded(SFInsts *rec, int bank, int preset, int keynote);
int is_ordered(SFInsts *rec, int bank, int preset, int keynote);
int load_font(SFInfo *sf, int pridx);
int parse_layer(SFInfo *sf, int pridx, LayerTable *tbl, int level);
int is_global(SFGenLayer *layer);
void clear_table(LayerTable *tbl);
void set_to_table(SFInfo *sf, LayerTable *tbl, SFGenLayer *lay, int level);
void add_item_to_table(LayerTable *tbl, int oper, int amount, int level);
void merge_table(SFInfo *sf, LayerTable *dst, LayerTable *src);
void init_and_merge_table(SFInfo *sf, LayerTable *dst, LayerTable *src);
int sanity_range(LayerTable *tbl);
int make_patch(SFInfo *sf, int pridx, LayerTable *tbl);
void make_info(SFInfo *sf, SampleList *vp, LayerTable *tbl);
double calc_volume(LayerTable *tbl);
void set_sample_info(SFInfo *sf, SampleList *vp, LayerTable *tbl);
void set_init_info(SFInfo *sf, SampleList *vp, LayerTable *tbl);
void reset_last_sample_info(void);
int abscent_to_Hz(int abscents);
void set_rootkey(SFInfo *sf, SampleList *vp, LayerTable *tbl);
void set_rootfreq(SampleList *vp);
int32_t to_offset(int32_t offset);
int32_t to_rate(int32_t diff, int timecent);
int32_t calc_rate(int32_t diff, double msec);
double to_msec(int timecent);
int32_t calc_sustain(int sust_cB);
void convert_volume_envelope(SampleList *vp, LayerTable *tbl);
void convert_tremolo(SampleList *vp, LayerTable *tbl);
void convert_vibrato(SampleList *vp, LayerTable *tbl);
void set_envelope_parameters(SampleList *vp);
// configfile
int set_patchconf(const char *name, int line, ToneBank *bank, char *w[], int dr, int mapid, int bankmapfrom, int bankno);
int strip_trailing_comment(char *string, int next_token_index);
char *expand_variables(char *string, MBlockList *varbuf, const char *basedir);
int set_gus_patchconf(const char *name, int line, ToneBankElement *tone, char *pat, char **opts);
void reinit_tone_bank_element(ToneBankElement *tone);
int set_gus_patchconf_opts(const char *name, int line, char *opts, ToneBankElement *tone);
int copymap(int mapto, int mapfrom, int isdrum);
void copybank(ToneBank *to, ToneBank *from, int mapid, int bankmapfrom, int bankno);
// sffile.cpp
int chunkid(char *id);
int process_list(int size, SFInfo *sf, timidity_file *fd);
int process_info(int size, SFInfo *sf, timidity_file *fd);
int process_sdta(int size, SFInfo *sf, timidity_file *fd);
int process_pdta(int size, SFInfo *sf, timidity_file *fd);
void load_sample_names(int size, SFInfo *sf, timidity_file *fd);
void load_preset_header(int size, SFInfo *sf, timidity_file *fd);
void load_inst_header(int size, SFInfo *sf, timidity_file *fd);
void load_bag(int size, SFBags *bagp, timidity_file *fd);
void load_gen(int size, SFBags *bagp, timidity_file *fd);
void load_sample_info(int size, SFInfo *sf, timidity_file *fd);
void convert_layers(SFInfo *sf);
void generate_layers(SFHeader *hdr, SFHeader *next, SFBags *bags);
void free_layer(SFHeader *hdr);
int load_soundfont(SFInfo *sf, timidity_file *fd);
void free_soundfont(SFInfo *sf);
void correct_samples(SFInfo *sf);
public:
Instruments();
bool load(MusicIO::SoundFontReaderInterface *);
~Instruments();
const ToneBank *toneBank(int i) const
{
return tonebank[i];
}
int defaultProgram(int i) const
{
return default_program[i];
}
const ToneBank *drumSet(int i) const
{
return drumset[i];
}
const SpecialPatch *specialPatch(int i) const
{
return special_patch[i];
}
void setSpecialPatchOffset(int i, int32_t ofs)
{
special_patch[i]->sample_offset = ofs;
}
Instrument *defaultInstrument() const
{
return default_instrument;
}
/* instrum.c */
int load_missing_instruments(int *rc);
void free_instruments(int reload_default_inst);
void free_special_patch(int id);
void clear_magic_instruments(void);
Instrument *load_instrument(int dr, int b, int prog);
int find_instrument_map_bank(int dr, int map, int bk);
int alloc_instrument_map_bank(int dr, int map, int bk);
void alloc_instrument_bank(int dr, int bankset);
int instrument_map(int mapID, int *set_in_out, int *elem_in_out) const;
void set_instrument_map(int mapID, int set_from, int elem_from, int set_to, int elem_to);
AlternateAssign *add_altassign_string(AlternateAssign *old, char **params, int n);
AlternateAssign *find_altassign(AlternateAssign *altassign, int note);
void copy_tone_bank_element(ToneBankElement *elm, const ToneBankElement *src);
void free_tone_bank_element(ToneBankElement *elm);
void free_instrument(Instrument *ip);
void squash_sample_16to8(Sample *sp);
Instrument *play_midi_load_instrument(int dr, int bk, int prog, bool *pLoad_success);
void recompute_userinst(int bank, int prog);
Instrument *recompute_userdrum(int bank, int prog);
UserInstrument *get_userinst(int bank, int prog);
UserDrumset *get_userdrum(int bank, int prog);
void recompute_userdrum_altassign(int bank, int group);
/*! initialize GS user drumset. */
void init_userdrum();
void free_userdrum();
void init_userinst() { free_userinst(); }
void free_userinst();
void mark_instrument(int newbank, int newprog)
{
if (!(tonebank[newbank]->tone[newprog].instrument))
tonebank[newbank]->tone[newprog].instrument =
MAGIC_LOAD_INSTRUMENT;
}
void mark_drumset(int newbank, int newprog)
{
if (!(drumset[newbank]->tone[newprog].instrument))
drumset[newbank]->tone[newprog].instrument =
MAGIC_LOAD_INSTRUMENT;
}
/* sndfont.c */
void add_soundfont(char *sf_file, int sf_order, int cutoff_allowed, int resonance_allowed, int amp);
void remove_soundfont(char *sf_file);
void init_load_soundfont(void);
Instrument *load_soundfont_inst(int order, int bank, int preset, int keynote);
Instrument *extract_soundfont(char *sf_file, int bank, int preset, int keynote);
int exclude_soundfont(int bank, int preset, int keynote);
int order_soundfont(int bank, int preset, int keynote, int order);
char *soundfont_preset_name(int bank, int preset, int keynote, char **sndfile);
void free_soundfonts(void);
void PrecacheInstruments(const uint16_t *instruments, int count);
int read_config_file(const char *name, int self, int allow_missing_file);
void set_default_instrument()
{
set_default_instrument(def_instr_name);
}
};
}
#endif /* ___INSTRUM_H_ */