zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2024-11-28 06:53:40 +00:00
Code Issues Projects Releases Packages Wiki Activity

parameters. These seem to be used primarily to restrict percussion

Browse source 
instruments to specific notes.
- Changed note velocity to not use the volume curve in recompute_amp(), since
  this sounds closer to TiMidity++, although I don't believe it's correct
  MIDI behavior. Also changed expression so that it scales the channel volume
  before going through the curve.
- Reworked load_instrument to be less opaque.
- Went through the TiMidity code and removed pretty much all of the SDL_mixer
  extensions. The only exception would be kill_others(), which I reworked
  into a kill_key_group() function, which should be useful for DLS
  instruments in the future.


SVN r918 (trunk)
This commit is contained in:
Randy Heit 2008-04-16 05:41:03 +00:00
parent 52eeff6db8
commit 9450db3cec
8 changed files with 789 additions and 1959 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
docs/rh-log.txt
View file

@ -1,3 +1,17 @@
April 15, 2008
- Added support for the GUS patch format's scale_frequency and scale_factor
parameters. These seem to be used primarily to restrict percussion
instruments to specific notes.
- Changed note velocity to not use the volume curve in recompute_amp(), since
this sounds closer to TiMidity++, although I don't believe it's correct
MIDI behavior. Also changed expression so that it scales the channel volume
before going through the curve.
- Reworked load_instrument to be less opaque.
- Went through the TiMidity code and removed pretty much all of the SDL_mixer
extensions. The only exception would be kill_others(), which I reworked
into a kill_key_group() function, which should be useful for DLS
instruments in the future.
April 15, 2008 (Changes by Graf Zahl)
- Added translation support to multipatch textures. Not tested yet!
- Added Martin Howe's morph weapon update.

673
src/timidity/instrum.cpp
View file

@ -35,74 +35,48 @@
namespace Timidity
{
extern InstrumentLayer *load_instrument_dls(Renderer *song, int drum, int bank, int instrument);
extern Instrument *load_instrument_dls(Renderer *song, int drum, int bank, int instrument);
/* Some functions get aggravated if not even the standard banks are
available. */
ToneBank standard_tonebank, standard_drumset;
/* This is only used for tracks that don't specify a program */
int default_program = DEFAULT_PROGRAM;
extern int openmode;
Instrument::Instrument()
: type(INST_GUS), samples(0), sample(NULL)
{
}
static void free_instrument(Instrument *ip)
Instrument::~Instrument()
{
Sample *sp;
int i;
if (ip == NULL)
{
return;
}
for (i = 0, sp = &(ip->sample[0]); i < ip->samples; i++, sp++)
for (i = samples, sp = &(sample[0]); i != 0; i--, sp++)
{
if (sp->data != NULL)
{
free(sp->data);
}
}
for (i = 0, sp = &(ip->right_sample[0]); i < ip->right_samples; i++)
{
if (sp->data != NULL)
{
free(sp->data);
}
}
free(ip->sample);
if (ip->right_sample != NULL)
{
free(ip->right_sample);
}
free(ip);
free(sample);
}
static void free_layer(InstrumentLayer *lp)
ToneBank::ToneBank()
{
InstrumentLayer *next;
for (; lp; lp = next)
tone = new ToneBankElement[128];;
for (int i = 0; i < MAXPROG; ++i)
{
next = lp->next;
free_instrument(lp->instrument);
free(lp);
instrument[i] = 0;
}
}
static void free_bank(int dr, int b)
ToneBank::~ToneBank()
{
int i;
ToneBank *bank = ((dr) ? drumset[b] : tonebank[b]);
for (i = 0; i < MAXPROG; i++)
delete[] tone;
for (int i = 0; i < MAXPROG; i++)
{
if (bank->tone[i].layer != NULL)
if (instrument[i] != NULL && instrument[i] != MAGIC_LOAD_INSTRUMENT)
{
/* Not that this could ever happen, of course */
if (bank->tone[i].layer != MAGIC_LOAD_INSTRUMENT)
{
free_layer(bank->tone[i].layer);
bank->tone[i].layer = NULL;
}
delete instrument[i];
instrument[i] = NULL;
}
}
}
@ -110,7 +84,6 @@ static void free_bank(int dr, int b)
int convert_envelope_rate(Renderer *song, BYTE rate)
{
#if 1
int r;
r = 3 - ((rate>>6) & 0x3);
@ -118,12 +91,7 @@ int convert_envelope_rate(Renderer *song, BYTE rate)
r = (int)(rate & 0x3f) << r; /* 6.9 fixed point */
/* 15.15 fixed point. */
return int(((r * 44100) / song->rate) * song->control_ratio) << ((song->fast_decay) ? 10 : 9);
#else
double frameadd = (double)(rate & 63) / (double)(1 << (3 * (rate >> 6)));
double realadd = (frameadd * 19293 / song->rate) * (1 << 15) * song->control_ratio;
return (int)realadd;
#endif
return int(((r * 44100) / song->rate) * song->control_ratio) << 9;
}
int convert_envelope_offset(BYTE offset)
@ -137,7 +105,7 @@ int convert_envelope_offset(BYTE offset)
int convert_tremolo_sweep(Renderer *song, BYTE sweep)
{
if (!sweep)
if (sweep == 0)
return 0;
return
@ -146,7 +114,7 @@ int convert_tremolo_sweep(Renderer *song, BYTE sweep)
int convert_vibrato_sweep(Renderer *song, BYTE sweep, int vib_control_ratio)
{
if (!sweep)
if (sweep == 0)
return 0;
return
@ -195,21 +163,20 @@ For other parameters, 1 means yes, 0 means no, other values are
undefined.
TODO: do reverse loops right */
static InstrumentLayer *load_instrument(Renderer *song, const char *name, int font_type, int percussion,
int panning, int amp, int cfg_tuning, int note_to_use,
static Instrument *load_instrument(Renderer *song, const char *name, int percussion,
int panning, int amp, int note_to_use,
int strip_loop, int strip_envelope,
int strip_tail, int bank, int gm_num, int sf_ix)
int strip_tail)
{
InstrumentLayer *lp, *lastlp, *headlp;
Instrument *ip;
Sample *sp;
FileReader *fp;
BYTE tmp[239];
GF1PatchHeader header;
GF1InstrumentData idata;
GF1LayerData layer_data;
GF1PatchData patch_data;
int i, j;
bool noluck = false;
bool sf2flag = false;
int right_samples = 0;
int stereo_channels = 1, stereo_layer;
int vlayer_list[19][4], vlayer, vlayer_count;
if (!name) return 0;
@ -233,436 +200,226 @@ static InstrumentLayer *load_instrument(Renderer *song, const char *name, int fo
if (noluck)
{
cmsg(CMSG_ERROR, VERB_NORMAL, "Instrument `%s' can't be found.", name);
cmsg(CMSG_ERROR, VERB_NORMAL, "Instrument `%s' can't be found.\n", name);
return 0;
}
/*cmsg(CMSG_INFO, VERB_NOISY, "Loading instrument %s", current_filename);*/
cmsg(CMSG_INFO, VERB_NOISY, "Loading instrument %s\n", name);
/* Read some headers and do cursory sanity checks. There are loads
of magic offsets. This could be rewritten... */
/* Read some headers and do cursory sanity checks. */
if ((239 != fp->Read(tmp, 239)) ||
(memcmp(tmp, "GF1PATCH110\0ID#000002", 22) &&
memcmp(tmp, "GF1PATCH100\0ID#000002", 22))) /* don't know what the
differences are */
if (sizeof(header) != fp->Read(&header, sizeof(header)))
{
cmsg(CMSG_ERROR, VERB_NORMAL, "%s: not an instrument", name);
failread:
cmsg(CMSG_ERROR, VERB_NORMAL, "%s: Error reading instrument.\n", name);
delete fp;
return 0;
}
if (strncmp(header.Header, GF1_HEADER_TEXT, HEADER_SIZE - 4) != 0)
{
cmsg(CMSG_ERROR, VERB_NORMAL, "%s: Not an instrument.\n", name);
delete fp;
return 0;
}
if (strcmp(header.Header + 8, "110") < 0)
{
cmsg(CMSG_ERROR, VERB_NORMAL, "%s: Is an old and unsupported patch version.\n", name);
delete fp;
return 0;
}
if (sizeof(idata) != fp->Read(&idata, sizeof(idata)))
{
goto failread;
}
header.WaveForms = LittleShort(header.WaveForms);
header.MasterVolume = LittleShort(header.MasterVolume);
header.DataSize = LittleLong(header.DataSize);
idata.Instrument = LittleShort(idata.Instrument);
if (header.Instruments != 1 && header.Instruments != 0) /* instruments. To some patch makers, 0 means 1 */
{
cmsg(CMSG_ERROR, VERB_NORMAL, "Can't handle patches with %d instruments.\n", header.Instruments);
delete fp;
return 0;
}
/* patch layout:
* bytes: info: starts at offset:
* 12 header (see above) 0
* 10 Gravis ID 12
* 60 description 22
* 1 instruments 82
* 1 voices 83
* 1 channels 84
* 2 number of waveforms 85
* 2 master volume 87
* 4 datasize 89
* 36 reserved, but now: 93
* 7 "SF2EXT\0" id 93
* 1 right samples 100
* 28 reserved 101
* 2 instrument number 129
* 16 instrument name 131
* 4 instrument size 147
* 1 number of layers 151
* 40 reserved 152
* 1 layer duplicate 192
* 1 layer number 193
* 4 layer size 194
* 1 number of samples 198
* 40 reserved 199
* 239
* THEN, for each sample, see below
*/
vlayer_count = 0; // Silence, GCC
if (!memcmp(tmp + 93, "SF2EXT", 6))
if (idata.Layers != 1 && idata.Layers != 0) /* layers. What's a layer? */
{
sf2flag = true;
vlayer_count = tmp[152];
}
if (tmp[82] != 1 && tmp[82] != 0) /* instruments. To some patch makers, 0 means 1 */
{
cmsg(CMSG_ERROR, VERB_NORMAL, "Can't handle patches with %d instruments", tmp[82]);
cmsg(CMSG_ERROR, VERB_NORMAL, "Can't handle instruments with %d layers.\n", idata.Layers);
delete fp;
return 0;
}
if (tmp[151] != 1 && tmp[151] != 0) /* layers. What's a layer? */
if (sizeof(layer_data) != fp->Read(&layer_data, sizeof(layer_data)))
{
cmsg(CMSG_ERROR, VERB_NORMAL, "Can't handle instruments with %d layers", tmp[151]);
goto failread;
}
if (layer_data.Samples == 0)
{
cmsg(CMSG_ERROR, VERB_NORMAL, "Instrument has 0 samples.\n");
delete fp;
return 0;
}
if (sf2flag && vlayer_count > 0)
ip = new Instrument;
ip->samples = layer_data.Samples;
ip->sample = (Sample *)safe_malloc(sizeof(Sample) * layer_data.Samples);
memset(ip->sample, 0, sizeof(Sample) * layer_data.Samples);
ip->type = INST_GUS;
for (i = 0; i < layer_data.Samples; ++i)
{
for (i = 0; i < 9; i++)
for (j = 0; j < 4; j++)
vlayer_list[i][j] = tmp[153+i*4+j];
for (i = 9; i < 19; i++)
for (j = 0; j < 4; j++)
vlayer_list[i][j] = tmp[199+(i-9)*4+j];
}
else
{
for (i = 0; i < 19; i++)
for (j = 0; j < 4; j++)
vlayer_list[i][j] = 0;
vlayer_list[0][0] = 0;
vlayer_list[0][1] = 127;
vlayer_list[0][2] = tmp[198];
vlayer_list[0][3] = 0;
vlayer_count = 1;
}
lastlp = NULL;
headlp = NULL; // Silence, GCC
for (vlayer = 0; vlayer < vlayer_count; vlayer++)
{
lp = (InstrumentLayer *)safe_malloc(sizeof(InstrumentLayer));
lp->lo = vlayer_list[vlayer][0];
lp->hi = vlayer_list[vlayer][1];
ip = (Instrument *)safe_malloc(sizeof(Instrument));
lp->instrument = ip;
lp->next = 0;
if (lastlp != NULL)
{
lastlp->next = lp;
}
else
{
headlp = lp;
}
lastlp = lp;
ip->type = sf2flag ? INST_SF2 : INST_GUS;
ip->samples = vlayer_list[vlayer][2];
ip->sample = (Sample *)safe_malloc(sizeof(Sample) * ip->samples);
ip->left_samples = ip->samples;
ip->left_sample = ip->sample;
right_samples = vlayer_list[vlayer][3];
ip->right_samples = right_samples;
if (right_samples)
{
ip->right_sample = (Sample *)safe_malloc(sizeof(Sample) * right_samples);
stereo_channels = 2;
}
else
{
ip->right_sample = NULL;
}
cmsg(CMSG_INFO, VERB_NOISY, "%s%s[%d,%d] %s(%d-%d layer %d of %d)",
(percussion)? " ":"", name,
(percussion)? note_to_use : gm_num, bank,
(right_samples)? "(2) " : "",
lp->lo, lp->hi, vlayer+1, vlayer_count);
for (stereo_layer = 0; stereo_layer < stereo_channels; stereo_layer++)
{
int sample_count;
if (stereo_layer == 0)
{
sample_count = ip->left_samples;
}
else if (stereo_layer == 1)
{
sample_count = ip->right_samples;
}
else
{
sample_count = 0;
}
for (i = 0; i < sample_count; i++)
{
BYTE fractions;
int tmplong;
WORD tmpshort;
WORD sample_volume;
BYTE tmpchar;
Sample *sp;
BYTE sf2delay;
#define READ_CHAR(thing) \
if (1 != fp->Read(&tmpchar,1)) goto fail; \
thing = tmpchar;
#define READ_SHORT(thing) \
if (2 != fp->Read(&tmpshort, 2)) goto fail; \
thing = LittleShort(tmpshort);
#define READ_LONG(thing) \
if (4 != fp->Read(&tmplong, 4)) goto fail; \
thing = LittleLong(tmplong);
/*
* 7 sample name
* 1 fractions
* 4 length
* 4 loop start
* 4 loop end
* 2 sample rate
* 4 low frequency
* 4 high frequency
* 4 root frequency
* 2 finetune
* 1 panning
* 6 envelope rates |
* 6 envelope offsets | 18 bytes
* 3 tremolo sweep, rate, depth |
* 3 vibrato sweep, rate, depth |
* 1 sample mode
* 2 scale frequency
* 2 scale factor | from 0 to 2048 or 0 to 2
* 2 sample volume (??)
* 34 reserved
* Now: 1 delay
* 33 reserved
*/
fp->Seek(7, SEEK_CUR);
if (1 != fp->Read(&fractions, 1))
if (sizeof(patch_data) != fp->Read(&patch_data, sizeof(patch_data)))
{
fail:
cmsg(CMSG_ERROR, VERB_NORMAL, "Error reading sample %d", i);
if (stereo_layer == 1)
{
for (j = 0; j < i; j++)
{
free(ip->right_sample[j].data);
}
free(ip->right_sample);
i = ip->left_samples;
}
for (j = 0; j < i; j++)
{
free(ip->left_sample[j].data);
}
free(ip->left_sample);
free(ip);
free(lp);
cmsg(CMSG_ERROR, VERB_NORMAL, "Error reading sample %d.\n", i);
delete ip;
delete fp;
return 0;
}
if (stereo_layer == 0)
{
sp = &(ip->left_sample[i]);
}
else if (stereo_layer == 1)
{
sp = &(ip->right_sample[i]);
}
else
{
assert(0);
sp = NULL;
}
sp = &(ip->sample[i]);
READ_LONG(sp->data_length);
READ_LONG(sp->loop_start);
READ_LONG(sp->loop_end);
READ_SHORT(sp->sample_rate);
READ_LONG(sp->low_freq);
READ_LONG(sp->high_freq);
READ_LONG(sp->root_freq);
fp->Seek(2, SEEK_CUR); /* Unused by GUS: Why have a "root frequency" and then "tuning"?? */
sp->low_vel = 0;
sp->data_length = LittleLong(patch_data.WaveSize);
sp->loop_start = LittleLong(patch_data.StartLoop);
sp->loop_end = LittleLong(patch_data.EndLoop);
sp->sample_rate = LittleShort(patch_data.SampleRate);
sp->low_freq = LittleLong(patch_data.LowFrequency);
sp->high_freq = LittleLong(patch_data.HighFrequency);
sp->root_freq = LittleLong(patch_data.RootFrequency);
sp->high_vel = 127;
READ_CHAR(tmp[0]);
if (panning == -1)
sp->panning = (tmp[0] * 8 + 4) & 0x7f;
{
sp->panning = patch_data.Balance & 0x0F;
sp->panning = (sp->panning << 3) | (sp->panning >> 1);
}
else
sp->panning = (BYTE)(panning & 0x7F);
{
sp->panning = panning & 0x7f;
}
sp->panning |= sp->panning << 7;
sp->resonance = 0;
sp->cutoff_freq = 0;
sp->reverberation = 0;
sp->chorusdepth = 0;
sp->exclusiveClass = 0;
sp->keyToModEnvHold = 0;
sp->keyToModEnvDecay = 0;
sp->keyToVolEnvHold = 0;
sp->keyToVolEnvDecay = 0;
if (cfg_tuning)
{
double tune_factor = (double)(cfg_tuning) / 1200.0;
tune_factor = pow(2.0, tune_factor);
sp->root_freq = (uint32)( tune_factor * (double)sp->root_freq );
}
/* envelope, tremolo, and vibrato */
if (18 != fp->Read(tmp, 18)) goto fail;
if (!tmp[13] || !tmp[14])
/* tremolo */
if (patch_data.TremoloRate == 0 || patch_data.TremoloDepth == 0)
{
sp->tremolo_sweep_increment = 0;
sp->tremolo_phase_increment = 0;
sp->tremolo_depth = 0;
cmsg(CMSG_INFO, VERB_DEBUG, " * no tremolo");
cmsg(CMSG_INFO, VERB_DEBUG, " * no tremolo\n");
}
else
{
sp->tremolo_sweep_increment = convert_tremolo_sweep(song, tmp[12]);
sp->tremolo_phase_increment = convert_tremolo_rate(song, tmp[13]);
sp->tremolo_depth = tmp[14];
cmsg(CMSG_INFO, VERB_DEBUG,
" * tremolo: sweep %d, phase %d, depth %d",
sp->tremolo_sweep_increment, sp->tremolo_phase_increment,
sp->tremolo_depth);
sp->tremolo_sweep_increment = convert_tremolo_sweep(song, patch_data.TremoloSweep);
sp->tremolo_phase_increment = convert_tremolo_rate(song, patch_data.TremoloRate);
sp->tremolo_depth = patch_data.TremoloDepth;
cmsg(CMSG_INFO, VERB_DEBUG, " * tremolo: sweep %d, phase %d, depth %d\n",
sp->tremolo_sweep_increment, sp->tremolo_phase_increment, sp->tremolo_depth);
}
if (!tmp[16] || !tmp[17])
/* vibrato */
if (patch_data.VibratoRate == 0 || patch_data.VibratoDepth == 0)
{
sp->vibrato_sweep_increment = 0;
sp->tremolo_sweep_increment = 0;
sp->vibrato_control_ratio = 0;
sp->vibrato_depth = 0;
cmsg(CMSG_INFO, VERB_DEBUG, " * no vibrato");
cmsg(CMSG_INFO, VERB_DEBUG, " * no vibrato\n");
}
else
{
sp->vibrato_control_ratio = convert_vibrato_rate(song, tmp[16]);
sp->vibrato_sweep_increment= convert_vibrato_sweep(song, tmp[15], sp->vibrato_control_ratio);
sp->vibrato_depth = tmp[17];
cmsg(CMSG_INFO, VERB_DEBUG,
" * vibrato: sweep %d, ctl %d, depth %d",
sp->vibrato_sweep_increment, sp->vibrato_control_ratio,
sp->vibrato_depth);
sp->vibrato_control_ratio = convert_vibrato_rate(song, patch_data.VibratoRate);
sp->tremolo_sweep_increment = convert_vibrato_sweep(song, patch_data.VibratoSweep, sp->vibrato_control_ratio);
sp->vibrato_depth = patch_data.VibratoDepth;
cmsg(CMSG_INFO, VERB_DEBUG, " * vibrato: sweep %d, ctl %d, depth %d\n",
sp->vibrato_sweep_increment, sp->vibrato_control_ratio, sp->vibrato_depth);
}
READ_CHAR(sp->modes);
READ_SHORT(sp->freq_center);
READ_SHORT(sp->freq_scale);
if (sf2flag)
{
READ_SHORT(sample_volume);
READ_CHAR(sf2delay);
READ_CHAR(sp->exclusiveClass);
fp->Seek(32, SEEK_CUR);
}
else
{
fp->Seek(36, SEEK_CUR);
sample_volume = 0;
sf2delay = 0;
}
sp->modes = patch_data.Modes;
/* Mark this as a fixed-pitch instrument if such a deed is desired. */
if (note_to_use != -1)
sp->note_to_use = (BYTE)(note_to_use);
{
sp->scale_note = note_to_use;
sp->scale_factor = 0;
}
else
sp->note_to_use = 0;
{
sp->scale_note = LittleShort(patch_data.ScaleFrequency);
sp->scale_factor = LittleShort(patch_data.ScaleFactor);
if (sp->scale_factor != 1024)
{
cmsg(CMSG_INFO, VERB_DEBUG, " * Scale: note %d, factor %d\n",
sp->scale_note, sp->scale_factor);
}
}
/* seashore.pat in the Midia patch set has no Sustain. I don't
understand why, and fixing it by adding the Sustain flag to
all looped patches probably breaks something else. We do it
anyway. */
if (sp->modes & MODES_LOOPING)
sp->modes |= MODES_SUSTAIN;
if (sp->modes & PATCH_LOOPEN)
{
sp->modes |= PATCH_SUSTAIN;
}
/* Strip any loops and envelopes we're permitted to */
if ((strip_loop == 1) &&
(sp->modes & (MODES_SUSTAIN | MODES_LOOPING | MODES_PINGPONG | MODES_REVERSE)))
(sp->modes & (PATCH_SUSTAIN | PATCH_LOOPEN | PATCH_BIDIR | PATCH_BACKWARD)))
{
cmsg(CMSG_INFO, VERB_DEBUG, " - Removing loop and/or sustain");
sp->modes &=~(MODES_SUSTAIN | MODES_LOOPING | MODES_PINGPONG | MODES_REVERSE);
cmsg(CMSG_INFO, VERB_DEBUG, " - Removing loop and/or sustain\n");
sp->modes &= ~(PATCH_SUSTAIN | PATCH_LOOPEN | PATCH_BIDIR | PATCH_BACKWARD);
}
if (strip_envelope == 1)
{
if (sp->modes & MODES_ENVELOPE)
cmsg(CMSG_INFO, VERB_DEBUG, " - Removing envelope");
sp->modes &= ~MODES_ENVELOPE;
if (sp->modes & PATCH_NO_SRELEASE)
{
cmsg(CMSG_INFO, VERB_DEBUG, " - Removing envelope\n");
}
sp->modes &= ~PATCH_NO_SRELEASE;
}
else if (strip_envelope != 0)
{
/* Have to make a guess. */
if (!(sp->modes & (MODES_LOOPING | MODES_PINGPONG | MODES_REVERSE)))
if (!(sp->modes & (PATCH_LOOPEN | PATCH_BIDIR | PATCH_BACKWARD)))
{
/* No loop? Then what's there to sustain? No envelope needed either... */
sp->modes &= ~(MODES_SUSTAIN|MODES_ENVELOPE);
cmsg(CMSG_INFO, VERB_DEBUG,
" - No loop, removing sustain and envelope");
sp->modes &= ~(PATCH_SUSTAIN | PATCH_NO_SRELEASE);
cmsg(CMSG_INFO, VERB_DEBUG, " - No loop, removing sustain and envelope\n");
}
else if (!memcmp(tmp, "??????", 6) || tmp[11] >= 100)
else if (memcmp(patch_data.EnvelopeRate, "??????", 6) == 0 || patch_data.EnvelopeOffset[RELEASEC] >= 100)
{
/* Envelope rates all maxed out? Envelope end at a high "offset"?
That's a weird envelope. Take it out. */
sp->modes &= ~MODES_ENVELOPE;
cmsg(CMSG_INFO, VERB_DEBUG, " - Weirdness, removing envelope");
sp->modes &= ~PATCH_NO_SRELEASE;
cmsg(CMSG_INFO, VERB_DEBUG, " - Weirdness, removing envelope\n");
}
else if (!(sp->modes & MODES_SUSTAIN))
else if (!(sp->modes & PATCH_SUSTAIN))
{
/* No sustain? Then no envelope. I don't know if this is
justified, but patches without sustain usually don't need the
envelope either... at least the Gravis ones. They're mostly
drums. I think. */
sp->modes &= ~MODES_ENVELOPE;
cmsg(CMSG_INFO, VERB_DEBUG, " - No sustain, removing envelope");
sp->modes &= ~PATCH_NO_SRELEASE;
cmsg(CMSG_INFO, VERB_DEBUG, " - No sustain, removing envelope\n");
}
}
sp->attenuation = 0;
for (j = ATTACK; j < DELAY; j++)
for (j = 0; j < 6; j++)
{
sp->envelope_rate[j] = convert_envelope_rate(song, tmp[j]);
sp->envelope_offset[j] = convert_envelope_offset(tmp[6+j]);
sp->envelope_rate[j] = convert_envelope_rate(song, patch_data.EnvelopeRate[j]);
sp->envelope_offset[j] = convert_envelope_offset(patch_data.EnvelopeOffset[j]);
}
if (sf2flag)
{
if (sf2delay > 5)
{
sf2delay = 5;
}
sp->envelope_rate[DELAY] = (int)( (sf2delay * song->rate) / 1000 );
}
else
{
sp->envelope_rate[DELAY] = 0;
}
sp->envelope_offset[DELAY] = 0;
for (j = ATTACK; j < DELAY; j++)
{
sp->modulation_rate[j] = float(sp->envelope_rate[j]);
sp->modulation_offset[j] = float(sp->envelope_offset[j]);
}
sp->modulation_rate[DELAY] = sp->modulation_offset[DELAY] = 0;
sp->modEnvToFilterFc = 0;
sp->modEnvToPitch = 0;
sp->lfo_sweep_increment = 0;
sp->lfo_phase_increment = 0;
sp->modLfoToFilterFc = 0;
/* Then read the sample data */
if (((sp->modes & MODES_16BIT) && sp->data_length/2 > MAX_SAMPLE_SIZE) ||
(!(sp->modes & MODES_16BIT) && sp->data_length > MAX_SAMPLE_SIZE))
if (((sp->modes & PATCH_16) && sp->data_length/2 > MAX_SAMPLE_SIZE) ||
(!(sp->modes & PATCH_16) && sp->data_length > MAX_SAMPLE_SIZE))
{
goto fail;
}
sp->data = (sample_t *)safe_malloc(sp->data_length + 1);
sp->data = (sample_t *)safe_malloc(sp->data_length);
if (sp->data_length != fp->Read(sp->data, sp->data_length))
goto fail;
@ -670,13 +427,13 @@ fail:
convert_sample_data(sp, sp->data);
/* Reverse reverse loops and pass them off as normal loops */
if (sp->modes & MODES_REVERSE)
if (sp->modes & PATCH_BACKWARD)
{
int t;
/* The GUS apparently plays reverse loops by reversing the
whole sample. We do the same because the GUS does not SUCK. */
cmsg(CMSG_WARNING, VERB_NORMAL, "Reverse loop in %s", name);
cmsg(CMSG_WARNING, VERB_NORMAL, "Reverse loop in %s\n", name);
reverse_data((sample_t *)sp->data, 0, sp->data_length);
sp->data[sp->data_length] = sp->data[sp->data_length - 1];
@ -684,35 +441,31 @@ fail:
sp->loop_start = sp->data_length - sp->loop_end;
sp->loop_end = sp->data_length - t;
sp->modes &= ~MODES_REVERSE;
sp->modes |= MODES_LOOPING; /* just in case */
sp->modes &= ~PATCH_BACKWARD;
sp->modes |= PATCH_LOOPEN; /* just in case */
}
if (amp != -1)
{
sp->volume = (amp) / 100.f;
}
else if (sf2flag)
{
sp->volume = (sample_volume) / 255.f;
}
else
{
#if defined(ADJUST_SAMPLE_VOLUMES)
/* Try to determine a volume scaling factor for the sample.
This is a very crude adjustment, but things sound more
balanced with it. Still, this should be a runtime option. */
int i, numsamps = sp->data_length;
int i;
sample_t maxamp = 0, a;
sample_t *tmp;
for (i = numsamps, tmp = sp->data; i; --i)
for (i = sp->data_length, tmp = sp->data; i; --i)
{
a = abs(*tmp++);
if (a > maxamp)
maxamp = a;
}
sp->volume = 1 / maxamp;
cmsg(CMSG_INFO, VERB_DEBUG, " * volume comp: %f", sp->volume);
cmsg(CMSG_INFO, VERB_DEBUG, " * volume comp: %f\n", sp->volume);
#else
sp->volume = 1;
#endif
@ -724,27 +477,25 @@ fail:
sp->loop_end <<= FRACTION_BITS;
/* Adjust for fractional loop points. */
sp->loop_start |= (fractions & 0x0F) << (FRACTION_BITS-4);
sp->loop_end |= ((fractions>>4) & 0x0F) << (FRACTION_BITS-4);
sp->loop_start |= (patch_data.Fractions & 0x0F) << (FRACTION_BITS-4);
sp->loop_end |= (patch_data.Fractions & 0xF0) << (FRACTION_BITS-4-4);
/* If this instrument will always be played on the same note,
and it's not looped, we can resample it now. */
if (sp->note_to_use && !(sp->modes & MODES_LOOPING))
if (sp->scale_factor == 0 && !(sp->modes & PATCH_LOOPEN))
{
pre_resample(song, sp);
}
if (strip_tail == 1)
{
/* Let's not really, just say we did. */
cmsg(CMSG_INFO, VERB_DEBUG, " - Stripping tail");
cmsg(CMSG_INFO, VERB_DEBUG, " - Stripping tail\n");
sp->data_length = sp->loop_end;
}
} /* end of sample loop */
} /* end of stereo layer loop */
} /* end of vlayer loop */
}
delete fp;
return headlp;
return ip;
}
void convert_sample_data(Sample *sp, const void *data)
@ -752,7 +503,7 @@ void convert_sample_data(Sample *sp, const void *data)
/* convert everything to 32-bit floating point data */
sample_t *newdata = NULL;
switch (sp->modes & (MODES_16BIT | MODES_UNSIGNED))
switch (sp->modes & (PATCH_16 | PATCH_UNSIGNED))
{
case 0:
{ /* 8-bit, signed */
@ -772,7 +523,7 @@ void convert_sample_data(Sample *sp, const void *data)
break;
}
case MODES_UNSIGNED:
case PATCH_UNSIGNED:
{ /* 8-bit, unsigned */
BYTE *cp = (BYTE *)data;
newdata = (sample_t *)safe_malloc((sp->data_length + 1) * sizeof(sample_t));
@ -791,7 +542,7 @@ void convert_sample_data(Sample *sp, const void *data)
break;
}
case MODES_16BIT:
case PATCH_16:
{ /* 16-bit, signed */
SWORD *cp = (SWORD *)data;
/* Convert these to samples */
@ -814,7 +565,7 @@ void convert_sample_data(Sample *sp, const void *data)
break;
}
case MODES_16BIT | MODES_UNSIGNED:
case PATCH_16 | PATCH_UNSIGNED:
{ /* 16-bit, unsigned */
WORD *cp = (WORD *)data;
/* Convert these to samples */
@ -853,23 +604,23 @@ static int fill_bank(Renderer *song, int dr, int b)
if (bank == NULL)
{
cmsg(CMSG_ERROR, VERB_NORMAL,
"Huh. Tried to load instruments in non-existent %s %d",
"Huh. Tried to load instruments in non-existent %s %d\n",
(dr) ? "drumset" : "tone bank", b);
return 0;
}
for (i = 0; i < MAXPROG; i++)
{
if (bank->tone[i].layer == MAGIC_LOAD_INSTRUMENT)
if (bank->instrument[i] == MAGIC_LOAD_INSTRUMENT)
{
bank->tone[i].layer = load_instrument_dls(song, dr, b, i);
if (bank->tone[i].layer != NULL)
bank->instrument[i] = load_instrument_dls(song, dr, b, i);
if (bank->instrument[i] != NULL)
{
continue;
}
if (bank->tone[i].name.IsEmpty())
{
cmsg(CMSG_WARNING, (b != 0) ? VERB_VERBOSE : VERB_NORMAL,
"No instrument mapped to %s %d, program %d%s",
"No instrument mapped to %s %d, program %d%s\n",
(dr) ? "drum set" : "tone bank", b, i,
(b != 0) ? "" : " - this instrument will not be heard");
if (b != 0)
@ -878,44 +629,34 @@ static int fill_bank(Renderer *song, int dr, int b)
bank / drumset for loading (if it isn't already) */
if (!dr)
{
if (!(standard_tonebank.tone[i].layer))
standard_tonebank.tone[i].layer=
MAGIC_LOAD_INSTRUMENT;
if (tonebank[0]->instrument[i] != NULL)
{
tonebank[0]->instrument[i] = MAGIC_LOAD_INSTRUMENT;
}
}
else
{
if (!(standard_drumset.tone[i].layer))
standard_drumset.tone[i].layer=
MAGIC_LOAD_INSTRUMENT;
if (drumset[0]->instrument[i] != NULL)
{
drumset[0]->instrument[i] = MAGIC_LOAD_INSTRUMENT;
}
}
bank->tone[i].layer=0;
}
bank->instrument[i] = NULL;
errors++;
}
else if (!(bank->tone[i].layer=
else if (!(bank->instrument[i] =
load_instrument(song, bank->tone[i].name,
bank->tone[i].font_type,
(dr) ? 1 : 0,
bank->tone[i].pan,
bank->tone[i].amp,
bank->tone[i].tuning,
(bank->tone[i].note!=-1) ?
bank->tone[i].note :
((dr) ? i : -1),
(bank->tone[i].strip_loop!=-1) ?
bank->tone[i].strip_loop :
((dr) ? 1 : -1),
(bank->tone[i].strip_envelope != -1) ?
bank->tone[i].strip_envelope :
((dr) ? 1 : -1),
bank->tone[i].strip_tail,
b,
((dr) ? i + 128 : i),
bank->tone[i].sf_ix
)))
(bank->tone[i].note != -1) ? bank->tone[i].note : ((dr) ? i : -1),
(bank->tone[i].strip_loop != -1) ? bank->tone[i].strip_loop : ((dr) ? 1 : -1),
(bank->tone[i].strip_envelope != -1) ? bank->tone[i].strip_envelope : ((dr) ? 1 : -1),
bank->tone[i].strip_tail)))
{
cmsg(CMSG_ERROR, VERB_NORMAL,
"Couldn't load instrument %s (%s %d, program %d)",
"Couldn't load instrument %s (%s %d, program %d)\n",
bank->tone[i].name.GetChars(),
(dr) ? "drum set" : "tone bank", b, i);
errors++;
@ -940,24 +681,34 @@ int Renderer::load_missing_instruments()
void free_instruments()
{
int i = 128;
int i = MAXBANK;
while (i--)
{
if (tonebank[i] != NULL)
free_bank(0,i);
{
delete tonebank[i];
tonebank[i] = NULL;
}
if (drumset[i] != NULL)
free_bank(1,i);
{
delete drumset[i];
drumset[i] = NULL;
}
}
}
int Renderer::set_default_instrument(const char *name)
{
InstrumentLayer *lp;
if (!(lp = load_instrument(this, name, FONT_NORMAL, 0, -1, -1, 0, -1, -1, -1, -1, 0, -1, -1)))
Instrument *ip;
if ((ip = load_instrument(this, name, 0, -1, -1, -1, 0, 0, 0)) == NULL)
{
return -1;
if (default_instrument)
free_layer(default_instrument);
default_instrument = lp;
}
if (default_instrument != NULL)
{
delete default_instrument;
}
default_instrument = ip;
default_program = SPECIAL_PROGRAM;
return 0;
}

66
src/timidity/instrum_dls.cpp
View file

@ -1121,29 +1121,29 @@ static void load_region_dls(Renderer *song, Sample *sample, DLS_Instrument *ins,
DLS_Region *rgn = &ins->regions[index];
DLS_Wave *wave = &song->patches->waveList[rgn->wlnk->ulTableIndex];
if (!(rgn->header->fusOptions & F_RGN_OPTION_SELFNONEXCLUSIVE))
{
sample->exclusiveClass = (SBYTE)rgn->header->usKeyGroup;
}
sample->self_nonexclusive = !!(rgn->header->fusOptions & F_RGN_OPTION_SELFNONEXCLUSIVE);
sample->key_group = (SBYTE)rgn->header->usKeyGroup;
sample->low_freq = SDWORD(note_to_freq(rgn->header->RangeKey.usLow));
sample->high_freq = SDWORD(note_to_freq(rgn->header->RangeKey.usHigh));
sample->root_freq = SDWORD(note_to_freq(rgn->wsmp->usUnityNote));
sample->low_vel = rgn->header->RangeVelocity.usLow;
sample->high_vel = rgn->header->RangeVelocity.usHigh;
sample->modes = wave->format->wBitsPerSample == 8 ? MODES_UNSIGNED : MODES_16BIT;
sample->modes = wave->format->wBitsPerSample == 8 ? PATCH_UNSIGNED : PATCH_16;
sample->sample_rate = wave->format->dwSamplesPerSec;
sample->data = NULL;
sample->data_length = wave->length;
convert_sample_data(sample, wave->data);
if (rgn->wsmp->cSampleLoops) {
sample->modes |= (MODES_LOOPING|MODES_SUSTAIN);
if (rgn->wsmp->cSampleLoops)
{
sample->modes |= (PATCH_LOOPEN | PATCH_SUSTAIN);
sample->loop_start = rgn->wsmp_loop->ulStart / 2;
sample->loop_end = sample->loop_start + (rgn->wsmp_loop->ulLength / 2);
}
sample->volume = 1.0f;
if (sample->modes & MODES_SUSTAIN) {
if (sample->modes & PATCH_SUSTAIN)
{
int value;
double attack, hold, decay, release; int sustain;
CONNECTIONLIST *art = NULL;
@ -1192,12 +1192,7 @@ static void load_region_dls(Renderer *song, Sample *sample, DLS_Instrument *ins,
sample->envelope_offset[RELEASEC] = to_offset(0);
sample->envelope_rate[RELEASEC] = to_offset(1);
sample->modes |= MODES_ENVELOPE;
}
for (int j = ATTACK; j < DELAY; j++)
{
sample->modulation_rate[j] = float(sample->envelope_rate[j]);
sample->modulation_offset[j] = float(sample->envelope_offset[j]);
sample->modes |= PATCH_NO_SRELEASE;
}
sample->data_length <<= FRACTION_BITS;
@ -1205,55 +1200,54 @@ static void load_region_dls(Renderer *song, Sample *sample, DLS_Instrument *ins,
sample->loop_end <<= FRACTION_BITS;
}
InstrumentLayer *load_instrument_dls(Renderer *song, int drum, int bank, int instrument)
Instrument *load_instrument_dls(Renderer *song, int drum, int bank, int instrument)
{
InstrumentLayer *layer;
Instrument *inst;
DWORD i;
DLS_Instrument *dls_ins = NULL;
if (song->patches == NULL)
{
return NULL;
}
drum = drum ? 0x80000000 : 0;
for (i = 0; i < song->patches->cInstruments; ++i) {
for (i = 0; i < song->patches->cInstruments; ++i)
{
dls_ins = &song->patches->instruments[i];
if ((dls_ins->header->Locale.ulBank & 0x80000000) == (ULONG)drum &&
((dls_ins->header->Locale.ulBank >> 8) & 0xFF) == (ULONG)bank &&
dls_ins->header->Locale.ulInstrument == (ULONG)instrument)
break;
}
if (i == song->patches->cInstruments && !bank) {
for (i = 0; i < song->patches->cInstruments; ++i) {
if (i == song->patches->cInstruments && bank == 0)
{
for (i = 0; i < song->patches->cInstruments; ++i)
{
dls_ins = &song->patches->instruments[i];
if ((dls_ins->header->Locale.ulBank & 0x80000000) == (ULONG)drum &&
dls_ins->header->Locale.ulInstrument == (ULONG)instrument)
break;
}
}
if (i == song->patches->cInstruments) {
if (i == song->patches->cInstruments)
{
// SNDDBG(("Couldn't find %s instrument %d in bank %d\n", drum ? "drum" : "melodic", instrument, bank));
return NULL;
}
layer = (InstrumentLayer *)safe_malloc(sizeof(InstrumentLayer));
layer->lo = 0;
layer->hi = 127;
layer->instrument = (Instrument *)safe_malloc(sizeof(Instrument));
layer->instrument->type = INST_DLS;
layer->instrument->samples = dls_ins->header->cRegions;
layer->instrument->sample = (Sample *)safe_malloc(layer->instrument->samples * sizeof(Sample));
layer->instrument->left_samples = layer->instrument->samples;
layer->instrument->left_sample = layer->instrument->sample;
layer->instrument->right_samples = 0;
layer->instrument->right_sample = NULL;
memset(layer->instrument->sample, 0, layer->instrument->samples * sizeof(Sample));
inst = (Instrument *)safe_malloc(sizeof(Instrument));
inst->type = INST_DLS;
inst->samples = dls_ins->header->cRegions;
inst->sample = (Sample *)safe_malloc(inst->samples * sizeof(Sample));
memset(inst->sample, 0, inst->samples * sizeof(Sample));
/*
printf("Found %s instrument %d in bank %d named %s with %d regions\n", drum ? "drum" : "melodic", instrument, bank, dls_ins->name, inst->samples);
*/
for (i = 0; i < dls_ins->header->cRegions; ++i) {
load_region_dls(song, &layer->instrument->sample[i], dls_ins, i);
for (i = 0; i < dls_ins->header->cRegions; ++i)
{
load_region_dls(song, &inst->sample[i], dls_ins, i);
}
return layer;
return inst;
}
#endif /* !TEST_MAIN_DLS */

36
src/timidity/mix.cpp
View file

@ -37,15 +37,14 @@ int recompute_envelope(Voice *v)
stage = v->envelope_stage;
if (stage >= DELAY)
if (stage > RELEASEC)
{
/* Envelope ran out. */
int tmp = (v->status == VOICE_DIE); /* Already displayed as dead */
v->status = VOICE_FREE;
return 1;
}
if (v->sample->modes & MODES_ENVELOPE)
if (v->sample->modes & PATCH_NO_SRELEASE)
{
if (v->status == VOICE_ON || v->status == VOICE_SUSTAINED)
{
@ -60,7 +59,9 @@ int recompute_envelope(Voice *v)
v->envelope_stage = stage + 1;
if (v->envelope_volume == v->sample->envelope_offset[stage])
{
return recompute_envelope(v);
}
v->envelope_target = v->sample->envelope_offset[stage];
v->envelope_increment = v->sample->envelope_rate[stage];
if (v->envelope_target < v->envelope_volume)
@ -75,28 +76,30 @@ void apply_envelope_to_amp(Voice *v)
{
ramp = v->right_amp;
if (v->tremolo_phase_increment)
if (v->tremolo_phase_increment != 0)
{
lamp *= v->tremolo_volume;
ramp *= v->tremolo_volume;
}
if (v->sample->modes & MODES_ENVELOPE)
if (v->sample->modes & PATCH_NO_SRELEASE)
{
double vol = calc_vol(v->envelope_volume / float(1 << 30));
lamp *= vol;
ramp *= vol;
}
v->left_mix = float(lamp);
v->right_mix = float(ramp);
}
else
{
if (v->tremolo_phase_increment)
if (v->tremolo_phase_increment != 0)
{
lamp *= v->tremolo_volume;
if (v->sample->modes & MODES_ENVELOPE)
}
if (v->sample->modes & PATCH_NO_SRELEASE)
{
lamp *= calc_vol(v->envelope_volume / float(1 << 30));
}
v->left_mix = float(lamp);
}
}
@ -104,14 +107,15 @@ void apply_envelope_to_amp(Voice *v)
static int update_envelope(Voice *v)
{
v->envelope_volume += v->envelope_increment;
/* Why is there no ^^ operator?? */
if (((v->envelope_increment < 0) && (v->envelope_volume <= v->envelope_target)) ||
((v->envelope_increment > 0) && (v->envelope_volume >= v->envelope_target)))
{
v->envelope_volume = v->envelope_target;
if (recompute_envelope(v))
{
return 1;
}
}
return 0;
}
@ -119,7 +123,7 @@ static void update_tremolo(Voice *v)
{
int depth = v->sample->tremolo_depth << 7;
if (v->tremolo_sweep)
if (v->tremolo_sweep != 0)
{
/* Update sweep position */
@ -151,12 +155,14 @@ static void update_tremolo(Voice *v)
/* Returns 1 if the note died */
static int update_signal(Voice *v)
{
if (v->envelope_increment && update_envelope(v))
if (v->envelope_increment != 0 && update_envelope(v))
{
return 1;
if (v->tremolo_phase_increment)
}
if (v->tremolo_phase_increment != 0)
{
update_tremolo(v);
}
apply_envelope_to_amp(v);
return 0;
}

1115
src/timidity/playmidi.cpp
View file

File diff suppressed because it is too large Load diff

31
src/timidity/resample.cpp
View file

@ -217,8 +217,8 @@ static int vib_phase_to_inc_ptr(int phase)
{
if (phase < VIBRATO_SAMPLE_INCREMENTS / 2)
return VIBRATO_SAMPLE_INCREMENTS / 2 - 1 - phase;
else if (phase >= 3*VIBRATO_SAMPLE_INCREMENTS/2)
return 5*VIBRATO_SAMPLE_INCREMENTS/2-1-phase;
else if (phase >= VIBRATO_SAMPLE_INCREMENTS * 3 / 2)
return VIBRATO_SAMPLE_INCREMENTS * 5 / 2 - 1 - phase;
else
return phase - VIBRATO_SAMPLE_INCREMENTS / 2;
}
@ -244,7 +244,7 @@ static int update_vibrato(float output_rate, Voice *vp, int sign)
/* Need to compute this sample increment. */
depth = vp->sample->vibrato_depth << 7;
if (vp->vibrato_sweep)
if (vp->vibrato_sweep != 0)
{
/* Need to update sweep */
vp->vibrato_sweep_position += vp->vibrato_sweep;
@ -265,7 +265,7 @@ static int update_vibrato(float output_rate, Voice *vp, int sign)
pb = (sine(vp->vibrato_phase * (1.0/(2*VIBRATO_SAMPLE_INCREMENTS)))
* (double)(depth) * VIBRATO_AMPLITUDE_TUNING);
a *= pow(2.0, pb / (8191 * 12.f));
a *= pow(2.0, pb / (8192 * 12.f));
/* If the sweep's over, we can store the newly computed sample_increment */
if (!vp->vibrato_sweep)
@ -511,11 +511,11 @@ sample_t *resample_voice(Renderer *song, Voice *vp, int *countptr)
if (vp->vibrato_control_ratio)
{
if ((modes & MODES_LOOPING) &&
((modes & MODES_ENVELOPE) ||
if ((modes & PATCH_LOOPEN) &&
((modes & PATCH_NO_SRELEASE) ||
(vp->status == VOICE_ON || vp->status == VOICE_SUSTAINED)))
{
if (modes & MODES_PINGPONG)
if (modes & PATCH_BIDIR)
return rs_vib_bidir(song->resample_buffer, song->rate, vp, *countptr);
else
return rs_vib_loop(song->resample_buffer, song->rate, vp, *countptr);
@ -527,11 +527,11 @@ sample_t *resample_voice(Renderer *song, Voice *vp, int *countptr)
}
else
{
if ((modes & MODES_LOOPING) &&
((modes & MODES_ENVELOPE) ||
if ((modes & PATCH_LOOPEN) &&
((modes & PATCH_NO_SRELEASE) ||
(vp->status == VOICE_ON || vp->status == VOICE_SUSTAINED)))
{
if (modes & MODES_PINGPONG)
if (modes & PATCH_BIDIR)
return rs_bidir(song->resample_buffer, vp, *countptr);
else
return rs_loop(song->resample_buffer, vp, *countptr);
@ -554,11 +554,14 @@ void pre_resample(Renderer *song, Sample *sp)
"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"
};
cmsg(CMSG_INFO, VERB_NOISY, " * pre-resampling for note %d (%s%d)",
sp->note_to_use,
note_name[sp->note_to_use % 12], (sp->note_to_use & 0x7F) / 12);
if (sp->scale_factor != 0)
return;
a = (sp->sample_rate * note_to_freq(sp->note_to_use)) / (sp->root_freq * song->rate);
cmsg(CMSG_INFO, VERB_NOISY, " * pre-resampling for note %d (%s%d)\n",
sp->scale_note,
note_name[sp->scale_note % 12], (sp->scale_note & 0x7F) / 12);
a = (sp->sample_rate * note_to_freq(sp->scale_note)) / (sp->root_freq * song->rate);
if (a <= 0)
return;
newlen = (int)(sp->data_length / a);

52
src/timidity/timidity.cpp
View file

@ -413,6 +413,13 @@ void FreeAll()
int LoadConfig(const char *filename)
{
/* !!! FIXME: This may be ugly, but slightly less so than requiring the
* default search path to have only one element. I think.
*
* We only need to include the likely locations for the config
* file itself since that file should contain any other directory
* that needs to be added to the search path.
*/
clear_pathlist();
#ifdef _WIN32
add_to_pathlist("C:\\TIMIDITY");
@ -443,25 +450,21 @@ Renderer::Renderer(float sample_rate)
{
rate = sample_rate;
patches = NULL;
default_instrument = NULL;
#ifdef FAST_DECAY
fast_decay = true;
#else
fast_decay = false;
#endif
resample_buffer_size = 0;
resample_buffer = NULL;
adjust_panning_immediately = false;
control_ratio = clamp(int(rate / CONTROLS_PER_SECOND), 1, MAX_CONTROL_RATIO);
lost_notes = 0;
cut_notes = 0;
default_instrument = NULL;
default_program = DEFAULT_PROGRAM;
if (def_instr_name.IsNotEmpty())
set_default_instrument(def_instr_name);
voices = DEFAULT_VOICES;
memset(voice, 0, sizeof(voice));
memset(drumvolume, 0, sizeof(drumvolume));
memset(drumpanpot, 0, sizeof(drumpanpot));
memset(drumreverberation, 0, sizeof(drumreverberation));
memset(drumchorusdepth, 0, sizeof(drumchorusdepth));
drumchannels = DEFAULT_DRUMCHANNELS;
}
@ -491,26 +494,11 @@ void Renderer::ComputeOutput(float *buffer, int count)
for (int i = 0; i < voices; i++, v++)
{
if (v->status != VOICE_FREE)
{
if (v->sample_offset == 0 && v->echo_delay_count)
{
if (v->echo_delay_count >= count)
{
v->echo_delay_count -= count;
}
else
{
mix_voice(this, buffer + v->echo_delay_count, v, count - v->echo_delay_count);
v->echo_delay_count = 0;
}
}
else
{
mix_voice(this, buffer, v, count);
}
}
}
}
void Renderer::MarkInstrument(int banknum, int percussion, int instr)
{
@ -520,6 +508,11 @@ void Renderer::MarkInstrument(int banknum, int percussion, int instr)
{
return;
}
if (banknum != 0)
{
/* Mark the standard bank in case it's not defined by this one. */
MarkInstrument(0, percussion, instr);
}
if (percussion)
{
bank = drumset[banknum];
@ -532,9 +525,9 @@ void Renderer::MarkInstrument(int banknum, int percussion, int instr)
{
return;
}
if (bank->tone[instr].layer == NULL)
if (bank->instrument[instr] == NULL)
{
bank->tone[instr].layer = MAGIC_LOAD_INSTRUMENT;
bank->instrument[instr] = MAGIC_LOAD_INSTRUMENT;
}
}
@ -557,9 +550,6 @@ void cmsg(int type, int verbosity_level, const char *fmt, ...)
va_start(args, fmt);
vsprintf(buf, fmt, args);
va_end(args);
size_t l = strlen(buf);
buf[l] = '\n';
buf[l+1] = '\0';
OutputDebugString(buf);
#endif
}

419
src/timidity/timidity.h
View file

@ -43,11 +43,10 @@ config.h
#define DEFAULT_DRUMCHANNELS (1<<9)
/*#define DEFAULT_DRUMCHANNELS ((1<<9) | (1<<15))*/
/* Default sampling rate, default polyphony, and maximum polyphony.
All but the last can be overridden from the command line. */
#define DEFAULT_RATE 32000
/* Default polyphony, and maximum polyphony. */
#define DEFAULT_VOICES 32
#define MAX_VOICES 256
#define MAXCHAN 16
#define MAXNOTE 128
@ -56,11 +55,6 @@ config.h
of envelopes and tremolo. The cost is CPU time. */
#define CONTROLS_PER_SECOND 1000
/* Make envelopes twice as fast. Saves ~20% CPU time (notes decay
faster) and sounds more like a GUS. There is now a command line
option to toggle this as well. */
//#define FAST_DECAY
/* How many bits to use for the fractional part of sample positions.
This affects tonal accuracy. The entire position counter must fit
in 32 bits, so with FRACTION_BITS equal to 12, the maximum size of
@ -106,9 +100,9 @@ typedef float final_volume_t;
/* Vibrato and tremolo Choices of the Day */
#define SWEEP_TUNING 38
#define VIBRATO_AMPLITUDE_TUNING 1.0L
#define VIBRATO_AMPLITUDE_TUNING 1.0
#define VIBRATO_RATE_TUNING 38
#define TREMOLO_AMPLITUDE_TUNING 1.0L
#define TREMOLO_AMPLITUDE_TUNING 1.0
#define TREMOLO_RATE_TUNING 38
#define SWEEP_SHIFT 16
@ -188,21 +182,20 @@ FileReader *open_filereader(const char *name, int open, int *plumpnum);
controls.h
*/
#define CMSG_INFO 0
#define CMSG_WARNING 1
#define CMSG_ERROR 2
#define CMSG_FATAL 3
#define CMSG_TRACE 4
#define CMSG_TIME 5
#define CMSG_TOTAL 6
#define CMSG_FILE 7
#define CMSG_TEXT 8
enum
{
CMSG_INFO,
CMSG_WARNING,
CMSG_ERROR
};
#define VERB_NORMAL 0
#define VERB_VERBOSE 1
#define VERB_NOISY 2
#define VERB_DEBUG 3
#define VERB_DEBUG_SILLY 4
enum
{
VERB_NORMAL,
VERB_VERBOSE,
VERB_NOISY,
VERB_DEBUG
};
void cmsg(int type, int verbosity_level, const char *fmt, ...);
@ -217,110 +210,170 @@ struct Sample
loop_start, loop_end, data_length,
sample_rate, low_vel, high_vel, low_freq, high_freq, root_freq;
SDWORD
envelope_rate[7], envelope_offset[7];
envelope_rate[6], envelope_offset[6];
float
modulation_rate[7], modulation_offset[7];
float
volume, resonance,
modEnvToFilterFc, modEnvToPitch, modLfoToFilterFc;
volume;
sample_t *data;
SDWORD
tremolo_sweep_increment, tremolo_phase_increment,
lfo_sweep_increment, lfo_phase_increment,
vibrato_sweep_increment, vibrato_control_ratio,
cutoff_freq;
vibrato_sweep_increment, vibrato_control_ratio;
BYTE
reverberation, chorusdepth,
tremolo_depth, vibrato_depth,
modes,
attenuation;
modes;
WORD
freq_center, panning;
SBYTE
note_to_use, exclusiveClass;
panning, scale_factor;
SWORD
keyToModEnvHold, keyToModEnvDecay,
keyToVolEnvHold, keyToVolEnvDecay;
SDWORD
freq_scale;
scale_note;
bool
self_nonexclusive;
BYTE
key_group;
};
void convert_sample_data(Sample *sample, const void *data);
void free_instruments();
/* Bits in modes: */
#define MODES_16BIT (1<<0)
#define MODES_UNSIGNED (1<<1)
#define MODES_LOOPING (1<<2)
#define MODES_PINGPONG (1<<3)
#define MODES_REVERSE (1<<4)
#define MODES_SUSTAIN (1<<5)
#define MODES_ENVELOPE (1<<6)
#define MODES_FAST_RELEASE (1<<7)
/* Patch definition: */
enum
{
HEADER_SIZE = 12,
ID_SIZE = 10,
DESC_SIZE = 60,
RESERVED_SIZE = 40,
PATCH_HEADER_RESERVED_SIZE = 36,
LAYER_RESERVED_SIZE = 40,
PATCH_DATA_RESERVED_SIZE = 36,
INST_NAME_SIZE = 16,
ENVELOPES = 6,
MAX_LAYERS = 4
};
#define GF1_HEADER_TEXT "GF1PATCH110"
#define INST_GUS 0
#define INST_SF2 1
#define INST_DLS 2
enum
{
PATCH_16 = (1<<0),
PATCH_UNSIGNED = (1<<1),
PATCH_LOOPEN = (1<<2),
PATCH_BIDIR = (1<<3),
PATCH_BACKWARD = (1<<4),
PATCH_SUSTAIN = (1<<5),
PATCH_NO_SRELEASE = (1<<6),
PATCH_FAST_REL = (1<<7)
};
#ifdef _MSC_VER
#pragma pack(push, 1)
#define GCC_PACKED
#else
#define GCC_PACKED __attribute__((__packed__))
#endif
struct GF1PatchHeader
{
char Header[HEADER_SIZE];
char GravisID[ID_SIZE]; /* Id = "ID#000002" */
char Description[DESC_SIZE];
BYTE Instruments;
BYTE Voices;
BYTE Channels;
WORD WaveForms;
WORD MasterVolume;
DWORD DataSize;
BYTE Reserved[PATCH_HEADER_RESERVED_SIZE];
} GCC_PACKED;
struct GF1InstrumentData
{
WORD Instrument;
char InstrumentName[INST_NAME_SIZE];
int InstrumentSize;
BYTE Layers;
BYTE Reserved[RESERVED_SIZE];
} GCC_PACKED;
struct GF1LayerData
{
BYTE LayerDuplicate;
BYTE Layer;
int LayerSize;
BYTE Samples;
BYTE Reserved[LAYER_RESERVED_SIZE];
} GCC_PACKED;
struct GF1PatchData
{
char WaveName[7];
BYTE Fractions;
int WaveSize;
int StartLoop;
int EndLoop;
WORD SampleRate;
int LowFrequency;
int HighFrequency;
int RootFrequency;
SWORD Tune;
BYTE Balance;
BYTE EnvelopeRate[6];
BYTE EnvelopeOffset[6];
BYTE TremoloSweep;
BYTE TremoloRate;
BYTE TremoloDepth;
BYTE VibratoSweep;
BYTE VibratoRate;
BYTE VibratoDepth;
BYTE Modes;
SWORD ScaleFrequency;
WORD ScaleFactor; /* From 0 to 2048 or 0 to 2 */
BYTE Reserved[PATCH_DATA_RESERVED_SIZE];
} GCC_PACKED;
#ifdef _MSC_VER
#pragma pack(pop)
#endif
#undef GCC_PACKED
enum
{
INST_GUS,
INST_DLS
};
struct Instrument
{
Instrument();
~Instrument();
int type;
int samples;
Sample *sample;
int left_samples;
Sample *left_sample;
int right_samples;
Sample *right_sample;
};
struct InstrumentLayer
{
BYTE lo, hi;
Instrument *instrument;
InstrumentLayer *next;
};
struct cfg_type
{
int font_code;
int num;
const char *name;
};
#define FONT_NORMAL 0
#define FONT_FFF 1
#define FONT_SBK 2
#define FONT_TONESET 3
#define FONT_DRUMSET 4
#define FONT_PRESET 5
struct ToneBankElement
{
ToneBankElement() : layer(NULL), font_type(0), sf_ix(0), tuning(0),
ToneBankElement() :
note(0), amp(0), pan(0), strip_loop(0), strip_envelope(0), strip_tail(0)
{}
FString name;
InstrumentLayer *layer;
int font_type, sf_ix, tuning;
int note, amp, pan, strip_loop, strip_envelope, strip_tail;
};
/* A hack to delay instrument loading until after reading the
entire MIDI file. */
#define MAGIC_LOAD_INSTRUMENT ((InstrumentLayer *)(-1))
#define MAGIC_LOAD_INSTRUMENT ((Instrument *)(-1))
#define MAXPROG 128
#define MAXBANK 130
#define SFXBANK (MAXBANK-1)
#define SFXDRUM1 (MAXBANK-2)
#define SFXDRUM2 (MAXBANK-1)
#define XGDRUM 1
enum
{
MAXPROG = 128,
MAXBANK = 128
};
struct ToneBank
{
FString name;
ToneBankElement tone[MAXPROG];
ToneBank();
~ToneBank();
ToneBankElement *tone;
Instrument *instrument[MAXPROG];
};
@ -341,60 +394,55 @@ playmidi.h
*/
/* Midi events */
#define ME_NOTEOFF 0x80
#define ME_NOTEON 0x90
#define ME_KEYPRESSURE 0xA0
#define ME_CONTROLCHANGE 0xB0
#define ME_PROGRAM 0xC0
#define ME_CHANNELPRESSURE 0xD0
#define ME_PITCHWHEEL 0xE0
enum
{
ME_NOTEOFF = 0x80,
ME_NOTEON = 0x90,
ME_KEYPRESSURE = 0xA0,
ME_CONTROLCHANGE = 0xB0,
ME_PROGRAM = 0xC0,
ME_CHANNELPRESSURE = 0xD0,
ME_PITCHWHEEL = 0xE0
};
/* Controllers */
#define CTRL_BANK_SELECT 0
#define CTRL_DATA_ENTRY 6
#define CTRL_VOLUME 7
#define CTRL_PAN 10
#define CTRL_EXPRESSION 11
#define CTRL_SUSTAIN 64
#define CTRL_HARMONICCONTENT 71
#define CTRL_RELEASETIME 72
#define CTRL_ATTACKTIME 73
#define CTRL_BRIGHTNESS 74
#define CTRL_REVERBERATION 91
#define CTRL_CHORUSDEPTH 93
#define CTRL_NRPN_LSB 98
#define CTRL_NRPN_MSB 99
#define CTRL_RPN_LSB 100
#define CTRL_RPN_MSB 101
#define CTRL_ALL_SOUNDS_OFF 120
#define CTRL_RESET_CONTROLLERS 121
#define CTRL_ALL_NOTES_OFF 123
/* NRPNs */
#define NRPN_BRIGHTNESS 0x00A0
#define NRPN_HARMONICCONTENT 0x00A1
#define NRPN_DRUMVOLUME (26<<7) // drum number in low 7 bits
#define NRPN_DRUMPANPOT (28<<7) // "
#define NRPN_DRUMREVERBERATION (29<<7) // "
#define NRPN_DRUMCHORUSDEPTH (30<<7) // "
enum
{
CTRL_BANK_SELECT = 0,
CTRL_DATA_ENTRY = 6,
CTRL_VOLUME = 7,
CTRL_PAN = 10,
CTRL_EXPRESSION = 11,
CTRL_SUSTAIN = 64,
CTRL_HARMONICCONTENT = 71,
CTRL_RELEASETIME = 72,
CTRL_ATTACKTIME = 73,
CTRL_BRIGHTNESS = 74,
CTRL_REVERBERATION = 91,
CTRL_CHORUSDEPTH = 93,
CTRL_NRPN_LSB = 98,
CTRL_NRPN_MSB = 99,
CTRL_RPN_LSB = 100,
CTRL_RPN_MSB = 101,
CTRL_ALL_SOUNDS_OFF = 120,
CTRL_RESET_CONTROLLERS = 121,
CTRL_ALL_NOTES_OFF = 123
};
/* RPNs */
#define RPN_PITCH_SENS 0x0000
#define RPN_FINE_TUNING 0x0001
#define RPN_COARSE_TUNING 0x0002
#define RPN_RESET 0x3fff
#define SFX_BANKTYPE 64
enum
{
RPN_PITCH_SENS = 0x0000,
RPN_FINE_TUNING = 0x0001,
RPN_COARSE_TUNING = 0x0002,
RPN_RESET = 0x3fff
};
struct Channel
{
int
bank, program, sustain, pitchbend,
mono, /* one note only on this channel -- not implemented yet */
/* new stuff */
variationbank, reverberation, chorusdepth, harmoniccontent,
releasetime, attacktime, brightness, kit, sfx,
/* end new */
pitchsens;
WORD
volume, expression;
@ -404,8 +452,6 @@ struct Channel
rpn, nrpn;
bool
nrpn_mode;
char
transpose;
float
pitchfactor; /* precomputed pitch bend factor to save some fdiv's */
};
@ -413,75 +459,64 @@ struct Channel
/* Causes the instrument's default panning to be used. */
#define NO_PANNING -1
/* envelope points */
#define MAXPOINT 7
#define MAXPOINT 6
struct Voice
{
BYTE
status, channel, note, velocity, clone_type;
status, channel, note, velocity;
Sample *sample;
Sample *left_sample;
Sample *right_sample;
int clone_voice;
float
orig_frequency, frequency;
int
sample_offset, loop_start, loop_end;
int
envelope_volume, modulation_volume;
int
envelope_target, modulation_target;
int
tremolo_sweep, tremolo_sweep_position, tremolo_phase,
lfo_sweep, lfo_sweep_position, lfo_phase,
vibrato_sweep, vibrato_sweep_position, vibrato_depth,
echo_delay_count;
int
echo_delay,
sample_increment,
envelope_increment,
modulation_increment,
tremolo_phase_increment,
lfo_phase_increment;
sample_offset, sample_increment,
envelope_volume, envelope_target, envelope_increment,
tremolo_sweep, tremolo_sweep_position,
tremolo_phase, tremolo_phase_increment,
vibrato_sweep, vibrato_sweep_position;
final_volume_t left_mix, right_mix;
float
left_amp, right_amp,
volume, tremolo_volume, lfo_volume;
left_amp, right_amp, tremolo_volume;
int
vibrato_sample_increment[VIBRATO_SAMPLE_INCREMENTS];
int
envelope_rate[MAXPOINT], envelope_offset[MAXPOINT];
int
vibrato_phase, vibrato_control_ratio, vibrato_control_counter,
envelope_stage, modulation_stage, control_counter,
modulation_delay, modulation_counter, panning, panned;
envelope_stage, control_counter, panning, panned;
};
/* Voice status options: */
#define VOICE_FREE 0
#define VOICE_ON 1
#define VOICE_SUSTAINED 2
#define VOICE_OFF 3
#define VOICE_DIE 4
enum
{
VOICE_FREE,
VOICE_ON,
VOICE_SUSTAINED,
VOICE_OFF,
VOICE_DIE
};
/* Voice panned options: */
#define PANNED_MYSTERY 0
#define PANNED_LEFT 1
#define PANNED_RIGHT 2
#define PANNED_CENTER 3
enum
{
PANNED_MYSTERY,
PANNED_LEFT,
PANNED_RIGHT,
PANNED_CENTER
};
/* Anything but PANNED_MYSTERY only uses the left volume */
/* Envelope stages: */
#define ATTACK 0
#define HOLD 1
#define DECAY 2
#define RELEASE 3
#define RELEASEB 4
#define RELEASEC 5
#define DELAY 6
enum
{
ATTACK,
HOLD,
DECAY,
RELEASE,
RELEASEB,
RELEASEC
};
#define ISDRUMCHANNEL(c) ((drumchannels & (1<<(c))))
@ -500,8 +535,6 @@ tables.h
#define note_to_freq(x) (float(8175.7989473096690661233836992789 * pow(2.0, (x) / 12.0)))
#define calc_vol(x) (pow(2.0,((x)*6.0 - 6.0)))
#define XMAPMAX 800
/*
timidity.h
*/
@ -517,27 +550,16 @@ struct Renderer
{
float rate;
DLS_Data *patches;
InstrumentLayer *default_instrument;
Instrument *default_instrument;
int default_program;
bool fast_decay;
int resample_buffer_size;
sample_t *resample_buffer;
Channel channel[16];
Voice voice[MAX_VOICES];
signed char drumvolume[MAXCHAN][MAXNOTE];
signed char drumpanpot[MAXCHAN][MAXNOTE];
signed char drumreverberation[MAXCHAN][MAXNOTE];
signed char drumchorusdepth[MAXCHAN][MAXNOTE];
int control_ratio, amp_with_poly;
int drumchannels;
int adjust_panning_immediately;
int voices;
int GM_System_On;
int XG_System_On;
int GS_System_On;
int XG_System_reverb_type;
int XG_System_chorus_type;
int XG_System_variation_type;
int lost_notes, cut_notes;
Renderer(float sample_rate);
@ -558,10 +580,8 @@ struct Renderer
int convert_vibrato_rate(BYTE rate);
void recompute_amp(Voice *v);
int vc_alloc(int not_this_voice);
void kill_others(int voice);
void clone_voice(Instrument *ip, int v, int note, int vel, int clone_type, int variationbank);
void xremap(int *banknumpt, int *this_notept, int this_kit);
void kill_key_group(int voice);
float calculate_scaled_frequency(Sample *sample, int note);
void start_note(int chan, int note, int vel, int voice);
void note_on(int chan, int note, int vel);
@ -579,7 +599,6 @@ struct Renderer
void reset_midi();
void select_sample(int voice, Instrument *instr, int vel);
void select_stereo_samples(int voice, InstrumentLayer *layer, int vel);
void recompute_freq(int voice);
void kill_note(int voice);