diff options
Diffstat (limited to 'backends/midi/mt32/synth.cpp')
-rw-r--r-- | backends/midi/mt32/synth.cpp | 5053 |
1 files changed, 942 insertions, 4111 deletions
diff --git a/backends/midi/mt32/synth.cpp b/backends/midi/mt32/synth.cpp index 138ca29cb7..26448ac3d1 100644 --- a/backends/midi/mt32/synth.cpp +++ b/backends/midi/mt32/synth.cpp @@ -1,4446 +1,1277 @@ -/* ScummVM - Scumm Interpreter - * Copyright (C) 2004 The ScummVM project - * Based on Tristan's conversion of Canadacow's code +/* Copyright (c) 2003-2004 Various contributors * - * 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. + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: * - * $Header$ + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. */ -#include "stdafx.h" - -#include "backends/midi/mt32/synth.h" -#include "backends/midi/mt32/partial.h" -#include "backends/midi/mt32/freeverb.h" -#include "common/system.h" -#include "common/file.h" - -#define NOMANSLAND - -// ************************** -// CSynth reporting codes -// ************************** - -// files missing -#define ERR_PRESET1 1 -#define ERR_PRESET2 2 -#define ERR_DRUMPAT 3 -#define ERR_PATCHLOG 4 -#define ERR_MT32ROM 5 - -// HW spec -#define PRESENT_SSE 6 -#define PRESENT_3DNOW 7 -#define USING_SSE 8 -#define USING_3DNOW 9 - -// General info -#define LCD_MESSAGE 10 -#define DEV_RESET 11 -#define DEV_RECONFIG 12 -#define NEW_REVERB_MODE 13 -#define NEW_REVERB_TIME 14 -#define NEW_REVERB_LEVEL 15 - -#if !defined(__GNUC__) - #pragma START_PACK_STRUCTS -#endif - -static union mt32ramFormat { - memParams params; - memBanks patchabs; - memAbsolute memabs; - // System memory 10 - // Display 20 - // Reset 7F -} ALIGN_PACKED mt32ram, mt32default; +#define BENCHMARK 0 -#if !defined(__GNUC__) - #pragma END_PACK_STRUCTS +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include <errno.h> +#if BENCHMARK > 0 +#include <time.h> #endif -int axtoi(char *str) { - int result = 0; - - while (*str) { - char hex = *str++; - int digit; - - if (hex >= '0' && hex <= '9') - digit = hex - '0'; - else if (hex >= 'a' && hex <= 'f') - digit = 10 + hex - 'a'; - else if (hex >= 'A' && hex <= 'F') - digit = 10 + hex - 'A'; - else - break; - - result = (result << 4) | digit; - } - - return result; -} - -struct FILTER { - unsigned int length; // size of filter - float *history; // pointer to history in filter - float *coef; // pointer to coefficients of filter -}; - -#define FILTER_SECTIONS 2 // 2 filter sections for 24 db/oct filter - -struct BIQUAD { - double a0, a1, a2; // numerator coefficients - double b0, b1, b2; // denominator coefficients -}; - -// Filter prototype coefficients, 1 for each filter section -BIQUAD ProtoCoef[FILTER_SECTIONS]; - -/** - * Pre-warp the coefficients of a numerator or denominator. Note that a0 is - * assumed to be 1, so there is no wrapping of it. - */ - -void prewarp(double *a0, double *a1, double *a2, double fc, double fs) { - double wp; - - wp = 2.0 * fs * tan(PI * fc / fs); - - *a2 = (*a2) / (wp * wp); - *a1 = (*a1) / wp; -} - -/** - * Transform the numerator and denominator coefficients of s-domain biquad - * section into corresponding z-domain coefficients. - * - * Store the 4 IIR coefficients in array pointed by coef in following order: - * beta1, beta2 (denominator) - * alpha1, alpha2 (numerator) - * - * @param a0-a2 s-domain numerator coefficients - * @param b0-b2 s-domain denominator coefficients - * @param k filter gain factor. initially set to 1 and modified by each - * biquad section in such a way, as to make it the coefficient by - * which to multiply the overall filter gain in order to achieve a - * desired overall filter gain, specified in initial value of k. - * @param fs sampling rate (Hz) - * @param coef array of z-domain coefficients to be filled in. - * - * @returns On return, set coef z-domain coefficients - */ - -void bilinear(double a0, double a1, double a2, double b0, double b1, double b2, double *k, double fs, float *coef) { - double ad, bd; - - // alpha (Numerator in s-domain) - ad = 4. * a2 * fs * fs + 2. * a1 * fs + a0; - // beta (Denominator in s-domain) - bd = 4. * b2 * fs * fs + 2. * b1 * fs + b0; - - // update gain constant for this section - *k *= ad / bd; - - // Denominator - *coef++ = (2. * b0 - 8. * b2 * fs * fs) / bd; // beta1 - *coef++ = (4. * b2 * fs * fs - 2. * b1 * fs + b0) / bd; // beta2 - - // Nominator - *coef++ = (2. * a0 - 8. * a2 * fs * fs) / ad; // alpha1 - *coef = (4. * a2 * fs * fs - 2. * a1 * fs + a0) / ad; // alpha2 -} - -/** - * @param a0-a2 numerator coefficients - * @param b0-b2 denominator coefficients - * @param fc filter cutoff frequency - * @param fs sampling rate - * @param coef pointer to 4 iir coefficients - */ - -void szxform(double *a0, double *a1, double *a2, double *b0, double *b1, double *b2, double fc, double fs, double *k, float *coef) { - // Calculate a1 and a2 and overwrite the original values - prewarp(a0, a1, a2, fc, fs); - prewarp(b0, b1, b2, fc, fs); - bilinear(*a0, *a1, *a2, *b0, *b1, *b2, k, fs, coef); -} - -#ifdef HAVE_X86 -#if defined(WIN32) && !(defined(__CYGWIN__) || defined(__MINGW32__)) -bool DetectSIMD() { - bool found_simd = false; - - _asm { - pushfd - pop eax // get EFLAGS into eax - mov ebx,eax // keep a copy - xor eax,0x200000 - // toggle CPUID bit - - push eax - popfd // set new EFLAGS - pushfd - pop eax // EFLAGS back into eax - - xor eax,ebx - // have we changed the ID bit? - - je NO_SIMD - // No, no CPUID instruction - - // we could toggle the - // ID bit so CPUID is present - mov eax,1 - - cpuid // get processor features - test edx,1<<25 // check the SIMD bit - jz NO_SIMD - mov found_simd,1 - jmp DONE - NO_SIMD: - mov found_simd,0 -DONE: - } - - return found_simd; -} - -bool Detect3DNow() { - bool found3D = false; - - __asm { - pushfd - pop eax - mov edx, eax - xor eax, 00200000h - push eax - popfd - pushfd - pop eax - xor eax, edx - jz NO_3DNOW - - mov eax, 80000000h - cpuid - - cmp eax, 80000000h - jbe NO_3DNOW - - mov eax, 80000001h - cpuid - test edx, 80000000h - jz NO_3DNOW - mov found3D, 1 -NO_3DNOW: - } - - return found3D; -} -#else -bool DetectSIMD() { - return atti386_DetectSIMD(); -} - -bool Detect3DNow() { - return atti386_Detect3DNow(); -} -#endif -#endif - -#ifdef NOMANSLAND - -// #define SETRATE 32000 -#define SETRATE myProp.SampleRate -// #define SETRATE 44100 - -// Used to regenerate waveform file after sampling rate change -#define MAKEWAVES 0 +#include "mt32emu.h" +// Debugging stuff // Used to dump drum patches to syx file for viewing #define DUMPDRUMS 0 -#define USEREVERB 1 - -// Debuging stuff -// Shows the instruments played -#define DISPLAYINSTR 0 -// Shows number of partials MT-32 is playing -#define MONITORPARTIALS 1 -// Dump syx file of temp tibres right before reset -#define SAVECUSTOM 0 - -// Constant tuning for now -#define TUNING 440.0 -#define SAMPLETUNING 207.64 -#define MIDDLEC 60 - -#define ROMSIZE 512*1024 -#define PCMSIZE ROMSIZE/2 -#define GRAN 512 -#define LN 2.30258509 - -#define MAXPOLY 64 -#define MAXPARTIALS 32 - -// Reverb room sizes (in metres) - -#define REV_ROOMSIZE 2.50f -#define REV_HALLSIZE 3.60f -#define REV_PLATESIZE 1.50f -#define REV_TAPSIZE 1.0f - -// Reverb t60 coeff - -#define REV_ROOMT60 ( REV_ROOMSIZE * REV_ROOMSIZE * REV_ROOMSIZE ) / 5 -#define REV_HALLT60 ( REV_HALLSIZE * REV_HALLSIZE * REV_HALLSIZE ) / 5 -#define REV_PLATET60 ( REV_PLATESIZE * REV_PLATESIZE * REV_PLATESIZE ) / 7 -#define REV_TAPT60 ( REV_TAPSIZE * REV_TAPSIZE * REV_TAPSIZE ) / 1 - -// #define HLRATIO 2.0f - #define SYSEX_SIZE 512 -// These are all the filters I tried without much success - -int16 Moog1(int16 wg, float *hist, float usefilt, float res) { - float f, p, q; // filter coefficients - float t1, t2; // temporary buffers - - // Set coefficients given frequency & resonance [0.0...1.0] - - float frequency = usefilt; - float in = (float)wg / 32767.0; - float resonance = res / 31.0; - resonance = resonance * resonance; - - q = 1.0f - frequency; - //p = frequency + 0.8f * frequency * q; - p = frequency + 0.8f * frequency * q; - - f = p + p - 1.0f; - q = resonance * (1.0f + 0.5f * q * (1.0f - q + 5.6f * q * q)); - - // Filter (in [-1.0...+1.0]) - - // feedback - in -= q * hist[4]; - t1 = hist[1]; - hist[1] = (in + hist[0]) * p - hist[1] * f; - t2 = hist[2]; - hist[2] = (hist[1] + t1) * p - hist[2] * f; - t1 = hist[3]; - hist[3] = (hist[2] + t2) * p - hist[3] * f; - hist[4] = (hist[3] + t1) * p - hist[4] * f; - - // clipping - hist[4] = hist[4] - hist[4] * hist[4] * hist[4] * 0.166667f; - hist[0] = in; - //LOG_MSG("In %d Hist: %f", wg, hist[4]*32767); - - return (int16)(hist[4] * 32767.0); -} - -int16 Moog2(int16 wg, float *hist, float usefilt, float resonance) { - float res = resonance / 30.0; - double f = usefilt; - double invf = 1.0 - f; - double fb = res * (1.0 - 0.15 * f * f); - float input = (float)wg / 32767.0; - - input -= hist[4] * fb; - input *= 0.35013 * (f*f)*(f*f); - hist[1] = input + 0.3 * hist[5] + (invf) * hist[1]; // Pole 1 - hist[5] = input; - hist[2] = hist[1] + 0.3 * hist[6] + (invf) * hist[2]; // Pole 2 - hist[6] = hist[1]; - hist[3] = hist[2] + 0.3 * hist[7] + (invf) * hist[3]; // Pole 3 - hist[7] = hist[2]; - hist[4] = hist[3] + 0.3 * hist[0] + (invf) * hist[4]; // Pole 4 - hist[0] = hist[3]; - - return (int16)(hist[4] * 32767.0); -} - -int16 simpleLowpass(int16 wg, float *hist, float usefilt, float resonance) { - float in = (float)wg / 32767.0; - float res_lp = resonance / 31.0; - res_lp = res_lp * res_lp; - float cut_lp = usefilt; - float n1, n2, fb_lp; - - n1 = hist[0]; - n2 = hist[1]; - - fb_lp = res_lp + res_lp / (1 - cut_lp); - n1 = n1 + cut_lp * (in - n1 + fb_lp * (n1 - n2)); - n2 = n2 + cut_lp * (n1 - n2); - - hist[0] = n1; - hist[1] = n2; - - return (int)(n2 * 32767.0); -} - -/* Reverb stuff */ - -#define NUM_COMBS 6 +namespace MT32Emu { -struct LOWPASS_STATE { - float coef; - float lastval; -}; +iir_filter_type usefilter; -struct COMB_STATE { - float tau; - float g; - float gsqu; - float *delbuf; - int bufsiz; - int bufpos; +static const Bit8u InitPatches[8] = { + 68, 48, 95, 78, 41, 3, 110, 122 }; -struct ST_REVERB { - int lastsamp; - int cursamp; - int done; - LOWPASS_STATE lowpass[NUM_COMBS]; - COMB_STATE comb[NUM_COMBS]; - COMB_STATE allpass[2]; +// Maps MIDI channel numbers to MT-32 parts (not to be confused with "partials") +// This is the default (FIXME: the mapping from 11->9 is undocumented, is this correct?): +static const Bit8s InitChanTable[16] = { + -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, -1, -1, -1, -1, -1 }; +// This alternative configuration can be selected by holding "Master Volume" +// and pressing "PART button 1" on the real MT-32's frontpanel. +//static const Bit8s InitChanTable[16] = { +// 0, 1, 2, 3, 4, 5, 6, 7, -1, 8, -1, -1, -1, -1, -1, -1 +//}; -class Reverb { -private: - ST_REVERB *revstate; - int SR; - -public: - Reverb(float t60, float hlratio, float dur, float hall_f, int smpr); - ~Reverb(); - - void run(float *lchan, float *rchan, float revfrac); - - float lowpass(float input, LOWPASS_STATE *state); - - float lpcomb(float input, LOWPASS_STATE *lpstate, COMB_STATE *cstate); - float allpassfilt(float input, COMB_STATE *state); -}; - -/** - * @param t60 reverb time - * @param hlratio ratio of low freq t60 to high freq t60 - * @param dur duration of event/dealloc. on last samp - * @param hall_fact mult. factor for delay times - * @param revstate running values for event reverb - */ - -Reverb::Reverb(float t60, float hlratio, float dur, float hall_fact, int sampling_rate) { - revstate = new ST_REVERB; - SR = sampling_rate; - int i; - float glow[NUM_COMBS], ghi[NUM_COMBS]; - // initialize sample counter and compute last sample - revstate->cursamp=0; - revstate->lastsamp = (int)(dur * (float)SR); - revstate->done=0; - - // ALLPASS INITIALIZATIONS - revstate->allpass[0].tau = .006 * hall_fact; - revstate->allpass[1].tau = .0065 * hall_fact; - - // allocate allpass delay buffers and head/tail ptr. - for (i = 0; i < 2; i++) { - revstate->allpass[i].bufsiz = (int) (revstate->allpass[i].tau * SR + .5); - revstate->allpass[i].delbuf = new float[revstate->allpass[i].bufsiz]; - memset(revstate->allpass[i].delbuf, 0, revstate->allpass[i].bufsiz * sizeof(float)); - revstate->allpass[i].bufpos = -1; - } - - revstate->allpass[0].g = .71f; - revstate->allpass[1].g = .7f; - - revstate->allpass[0].gsqu = revstate->allpass[0].g * revstate->allpass[0].g; - revstate->allpass[1].gsqu = revstate->allpass[1].g * revstate->allpass[1].g; - - // COMB AND IIR LOWPASS FILTER INITIALIZATIONS - - revstate->comb[0].tau = .0050 * hall_fact; - revstate->comb[1].tau = .0068 * hall_fact; - revstate->comb[2].tau = .0056 * hall_fact; - revstate->comb[3].tau = .0072 * hall_fact; - revstate->comb[4].tau = .0061 * hall_fact; - revstate->comb[5].tau = .0078 * hall_fact; - - // allocate comb delay buffers and head/tail ptr. - for (i = 0; i < NUM_COMBS; i++) { - revstate->comb[i].bufsiz = (int)(revstate->comb[i].tau * SR + .5); - - revstate->comb[i].delbuf = new float[revstate->comb[i].bufsiz]; - memset(revstate->comb[i].delbuf, 0, revstate->comb[i].bufsiz * sizeof(float)); - - revstate->comb[i].bufpos = -1; - - revstate->lowpass[i].lastval = 0.; - } - - // if hlratio set by user, set various values - // else, use default g's and coef's - if (hlratio != 0.) { - for (i = 0; i < NUM_COMBS; i++) { - - // compute reverb attenuation factor for hi and low - // frequency reverberation times - glow[i] = pow(10.,(-3. * revstate->comb[i].tau) / t60); - ghi[i] = pow(10.,(-3. * revstate->comb[i].tau) / ( t60 * hlratio)); - - // compute recursive lowpass factor and comb - // attenuation factor to produce the correct - // reverberation time for both hi and low frequencies - revstate->lowpass[i].coef = (glow[i] - ghi[i]) / (glow[i] + ghi[i]); - revstate->comb[i].g = glow[i] * (1. - revstate->lowpass[i].coef); - } - } else { - revstate->lowpass[0].coef = .24f; - revstate->lowpass[1].coef = .26f; - revstate->lowpass[2].coef = .28f; - revstate->lowpass[3].coef = .29f; - revstate->lowpass[4].coef = .30f; - revstate->lowpass[5].coef = .32f; - - for (i = 0; i < 6; i++) { - // compute reverb attenuation factor and comb - // attenuation factor based on default coef - glow[i] = pow(10., (-3. * revstate->comb[i].tau) / t60); - revstate->comb[i].g = glow[i] * (1. - revstate->lowpass[i].coef); - } - } -} - -Reverb:: ~Reverb() { - int i; - - for (i = 0; i < NUM_COMBS; i++) - delete[] revstate->comb[i].delbuf; - for (i = 0; i < 2; i++) - delete[] revstate->allpass[i].delbuf; - delete revstate; -} - -/** - * @param lchan non-reverberated input sample - * @param rchan non-reverberated input sample - * @param revfrac percent of output to be reverberated - */ - -INLINE void Reverb::run(float *lchan, float *rchan, float revfrac) { - int i; - float lchanrev, rchanrev, tot = 0; - - if (revstate->done) { - *lchan = 0.0; - *rchan = 0.0; - return; - } - - for (i = 0; i < NUM_COMBS; i++) - tot = tot + lpcomb((*lchan) + (*rchan), &(revstate->lowpass[i]), &(revstate->comb[i])); - - tot = tot / (float)NUM_COMBS; - - lchanrev = allpassfilt(tot * .7, &(revstate->allpass[0])); - rchanrev = allpassfilt(tot * .7, &(revstate->allpass[1])); - - if (revstate->cursamp == revstate->lastsamp) { - for (i = 0; i < NUM_COMBS; i++) - delete[] revstate->comb[i].delbuf; - for (i = 0; i < 2; i++) - delete[] revstate->allpass[i].delbuf; - revstate->done = 1; - } - - revstate->cursamp++; - - *lchan = lchanrev * revfrac + (*lchan) * (1. - revfrac); - *rchan = rchanrev * revfrac + (*rchan) * (1. - revfrac); -} - -INLINE float Reverb::lowpass(float input, LOWPASS_STATE *state) { - // simple IIR lowpass filter algorithm - // y(n) = x(n) + coef * y(n - 1) - state->lastval = (input + state->coef * state->lastval); - return state->lastval; -} - -INLINE float Reverb::lpcomb(float input, LOWPASS_STATE *lpstate, COMB_STATE *cstate) { - float temp; - - // move head-tail pointer in circular queue - cstate->bufpos = (cstate->bufpos + 1) % cstate->bufsiz; - - // pop circular queue - temp = cstate->delbuf[cstate->bufpos]; - - // add new value to end of queue - lpstate->lastval = (cstate->delbuf[cstate->bufpos] + lpstate->coef * lpstate->lastval); - - cstate->delbuf[cstate->bufpos] = input + cstate->g * lpstate->lastval; - - // return popped value - return temp; -} - -INLINE float Reverb::allpassfilt(float input, COMB_STATE* state) { - float temp; - - // move head-tail pointer in circular queue - state->bufpos = (state->bufpos + 1) % state->bufsiz; - - // pop circular queue - temp = state->delbuf[state->bufpos]; - - // add new value to end of queue - state->delbuf[state->bufpos] = input + state->g * state->delbuf[state->bufpos]; - - // return a sum of the current in with the delay out - return -1. * state->g * input + (1. - state->gsqu) * temp; -} - -// End reverb stuff - -// Begin filter stuff - -void InitFilter(float fs, float fc, float *icoeff, float Q, float resfac) { - float *coef; - unsigned nInd; - double a0, a1, a2, b0, b1, b2; - double k; // overall gain factor - - // Section 1 - ProtoCoef[0].a0 = 1.0; - ProtoCoef[0].a1 = 0; - ProtoCoef[0].a2 = 0; - ProtoCoef[0].b0 = 1.0; - ProtoCoef[0].b1 = 0.765367; - ProtoCoef[0].b2 = 1.0; - - // Section 2 - ProtoCoef[1].a0 = 1.0; - ProtoCoef[1].a1 = 0; - ProtoCoef[1].a2 = 0; - ProtoCoef[1].b0 = 1.0; - ProtoCoef[1].b1 = 1.847759; - ProtoCoef[1].b2 = 1.0; - - k = 1.5; // Set overall filter gain - coef = icoeff + 1; // Skip k, or gain - - for (nInd = 0; nInd < 2; nInd++) { - a0 = ProtoCoef[nInd].a0; - a1 = ProtoCoef[nInd].a1; - a2 = ProtoCoef[nInd].a2; - - b0 = ProtoCoef[nInd].b0; - b1 = ProtoCoef[nInd].b1 / Q; // Divide by resonance or Q - b2 = ProtoCoef[nInd].b2; - - szxform(&a0, &a1, &a2, &b0, &b1, &b2, fc, fs, &k, coef); - coef += 4; // Point to next filter section - } - icoeff[0] = k; -} - -#if FILTER_FLOAT == 1 - -iir_filter_type usefilter; - -#if defined(WIN32) && !(defined(__CYGWIN__) || defined(__MINGW32__)) - -float iir_filter_sse(float input,float *hist1_ptr, float *coef_ptr, int revLevel) { - float *hist2_ptr; - float output; - - hist2_ptr = hist1_ptr + 1; // next history - - // 1st number of coefficients array is overall input scale factor, or - // filter gain - output = input * (*coef_ptr++); - - __asm { - movss xmm1, output - - mov eax, coef_ptr - movups xmm2, [eax] - - mov eax, hist1_ptr - movlps xmm3, [eax] - shufps xmm3, xmm3, 44h - // hist2_ptr, hist1_ptr, hist2_ptr, hist1_ptr - - mulps xmm2, xmm3 - - subss xmm1, xmm2 - // Rotate elements right - shufps xmm2, xmm2, 39h - subss xmm1, xmm2 - - // Store new_hist - movss DWORD PTR [eax], xmm1 - - // Rotate elements right - shufps xmm2, xmm2, 39h - addss xmm1, xmm2 - - // Rotate elements right - shufps xmm2, xmm2, 39h - addss xmm1, xmm2 - - // Store previous hist - movss DWORD PTR [eax+4], xmm3 - - add coef_ptr, 16 - add hist1_ptr, 8 - - mov eax, coef_ptr - movups xmm2, [eax] - - mov eax, hist1_ptr - movlps xmm3, [eax] - shufps xmm3, xmm3, 44h - // hist2_ptr, hist1_ptr, hist2_ptr, hist1_ptr - - mulps xmm2, xmm3 - - subss xmm1, xmm2 - // Rotate elements right - shufps xmm2, xmm2, 39h - subss xmm1, xmm2 - - // Store new_hist - movss DWORD PTR [eax], xmm1 - - // Rotate elements right - shufps xmm2, xmm2, 39h - addss xmm1, xmm2 - - // Rotate elements right - shufps xmm2, xmm2, 39h - addss xmm1, xmm2 - - // Store previous hist - movss DWORD PTR [eax+4], xmm3 - - movss output, xmm1 - } - - output *= ResonInv[revLevel]; - - return output; -} - -float iir_filter_3dnow(float input,float *hist1_ptr, float *coef_ptr, int revLevel) { - float *hist2_ptr; - float output; - float tmp; - - hist2_ptr = hist1_ptr + 1; // next history - - // 1st number of coefficients array is overall input scale factor, or - // filter gain - output = input * (*coef_ptr++); - - // I find it very sad that 3DNow requires twice as many instructions as - // Intel's SSE. Intel does have the upper hand here. - - __asm { - movq mm1, output - mov ebx, coef_ptr - movq mm2, [ebx] - - mov eax, hist1_ptr; - movq mm3, [eax] - - pfmul mm2, mm3 - pfsub mm1, mm2 - - psrlq mm2, 32 - pfsub mm1, mm2 - - // Store new hist - movd tmp, mm1 - - add ebx, 8 - movq mm2, [ebx] - movq mm3, [eax] - - pfmul mm2, mm3 - pfadd mm1, mm2 - - psrlq mm2, 32 - pfadd mm1, mm2 - - push tmp - pop DWORD PTR [eax] - - movd DWORD PTR [eax+4], mm3 - - add ebx, 8 - add eax, 8 - - movq mm2, [ebx] - movq mm3, [eax] - - pfmul mm2, mm3 - pfsub mm1, mm2 - - psrlq mm2, 32 - pfsub mm1, mm2 - - // Store new hist - movd tmp, mm1 - - add ebx, 8 - movq mm2, [ebx] - movq mm3, [eax] - - pfmul mm2, mm3 - pfadd mm1, mm2 - - psrlq mm2, 32 - pfadd mm1, mm2 - - push tmp - pop DWORD PTR [eax] - movd DWORD PTR [eax+4], mm3 - - movd output, mm1 - - femms +static int axtoi(char *str) { + int result = 0; + while (*str) { + char ch = *str++; + if (ch >= '0' && ch <= '9') + ch -= '0'; + else if (ch >= 'a' && ch <= 'f') + ch = ch + 10 - 'a'; + else if (ch >= 'A' && ch <= 'F') + ch = ch + 10 - 'A'; + else + break; + result = (result << 4) | ch; } - - output *= ResonInv[revLevel]; - - return output; -} - -#elif defined(HAVE_X86) - -float iir_filter_sse(float input,float *hist1_ptr, float *coef_ptr, int revLevel) { - float *hist2_ptr; - float output; - - hist2_ptr = hist1_ptr + 1; // next history - - // 1st number of coefficients array is overall input scale factor, or - // filter gain - output = input * (*coef_ptr++); - output = atti386_iir_filter_sse(&output, hist1_ptr, coef_ptr); - output *= ResonInv[revLevel]; - - return output; -} - -float iir_filter_3dnow(float input,float *hist1_ptr, float *coef_ptr, int revLevel) { - float *hist2_ptr; - float output; - - hist2_ptr = hist1_ptr + 1; // next history - - /* 1st number of coefficients array is overall input scale factor, - * or filter gain */ - output = input * (*coef_ptr++); - output = atti386_iir_filter_3DNow(output, hist1_ptr, coef_ptr); - output *= ResonInv[revLevel]; - - return output; + return result; } -#endif - float iir_filter_normal(float input,float *hist1_ptr, float *coef_ptr, int revLevel) { float *hist2_ptr; - float output, new_hist; + float output,new_hist; - hist2_ptr = hist1_ptr + 1; // next history + hist2_ptr = hist1_ptr + 1; // next history - // 1st number of coefficients array is overall input scale factor, or - // filter gain + // 1st number of coefficients array is overall input scale factor, or filter gain output = input * (*coef_ptr++); output = output - *hist1_ptr * (*coef_ptr++); - new_hist = output - *hist2_ptr * (*coef_ptr++); // poles + new_hist = output - *hist2_ptr * (*coef_ptr++); // poles output = new_hist + *hist1_ptr * (*coef_ptr++); - output = output + *hist2_ptr * (*coef_ptr++); // zeros + output = output + *hist2_ptr * (*coef_ptr++); // zeros *hist2_ptr++ = *hist1_ptr; *hist1_ptr++ = new_hist; hist1_ptr++; hist2_ptr++; + // i = 1 output = output - *hist1_ptr * (*coef_ptr++); - new_hist = output - *hist2_ptr * (*coef_ptr++); // poles + new_hist = output - *hist2_ptr * (*coef_ptr++); // poles output = new_hist + *hist1_ptr * (*coef_ptr++); - output = output + *hist2_ptr * (*coef_ptr++); // zeros - + output = output + *hist2_ptr * (*coef_ptr++); // zeros + *hist2_ptr++ = *hist1_ptr; *hist1_ptr++ = new_hist; output *= ResonInv[revLevel]; - return output; + return(output); } -#endif - -#if FILTER_64BIT == 1 - -// 64-bit version -long iir_filter(long input, int64 *hist1_ptr, int64 *coef_ptr) { - int64 *hist2_ptr; - int64 output, new_hist, history1, history2; - - hist2_ptr = hist1_ptr + 1; // next history - - // 1st number of coefficients array is overall input scale factor, or - // filter gain - output = input * (*coef_ptr++); - - for (int i = 0 ; i < 2; i++) { - history1 = *hist1_ptr; // history values - history2 = *hist2_ptr; - - output = output - ((history1 * (*coef_ptr++)) >> 20); - new_hist = output - ((history2 * (*coef_ptr++)) >> 20); // poles +Synth::Synth() { + isOpen = false; + reverbModel = NULL; + partialManager = NULL; + memset(waveforms, 0, sizeof(waveforms)); + memset(parts, 0, sizeof(parts)); +} - output = new_hist + ((history1 * (*coef_ptr++)) >> 20); - output = output + ((history2 * (*coef_ptr++)) >> 20); // zeros +Synth::~Synth() { + close(); // Make sure we're closed and everything is freed +} - *hist2_ptr++ = *hist1_ptr; - *hist1_ptr++ = new_hist; - hist1_ptr++; - hist2_ptr++; +void Synth::report(ReportType type, void *data) { + if (myProp.report != NULL) { + myProp.report(myProp.userData, type, data); } - - return output >> 20; } -#endif - -#if FILTER_INT == 1 - -long iir_filter(long input, signed long *hist1_ptr, signed long *coef_ptr) { - signed long *hist2_ptr; - signed long output, new_hist, history1, history2; - - hist2_ptr = hist1_ptr + 1; // next history - - // 1st number of coefficients array is overall input scale factor, or - // filter gain - output = input * (*coef_ptr++); - - for (int i = 0 ; i < 2; i++) { - history1 = *hist1_ptr; // history values - history2 = *hist2_ptr; - - output = output - ((history1 * (*coef_ptr++)) >> 10); - new_hist = output - ((history2 * (*coef_ptr++))>>10); // poles - - output = new_hist + ((history1 * (*coef_ptr++)) >> 10); - output = output + ((history2 * (*coef_ptr++)) >> 10); // zeros - - *hist2_ptr++ = *hist1_ptr; - *hist1_ptr++ = new_hist; - hist1_ptr++; - hist2_ptr++; +void Synth::printDebug(const char *fmt, ...) { + va_list ap; + va_start(ap, fmt); + if (myProp.printDebug != NULL) { + myProp.printDebug(myProp.userData, fmt, ap); + } else { + vprintf(fmt, ap); + printf("\n"); } - - return output >> 10; + va_end(ap); } -#endif - -// End filter stuff - -partialFormat PCM[54]; -partialTable PCMList[128]; -uint32 PCMReassign[55]; -int32 PCMLoopTable[55]; - -timbreParam drums[30]; - -int16 romfile[PCMSIZE+GRAN]; // 256K -static int16 chantable[32]; // 64 bytes -static int16 miditable[9]; // 18 bytes - -static CPartialMT32 *partTable[MAXPARTIALS]; -static int32 PartialReserveTable[32]; +void Synth::initReverb(char newRevMode, char newRevTime) { + // FIXME:KG: I don't think it's necessary to recreate the reverbModel... Just set the parameters + if (reverbModel != NULL) + delete reverbModel; + reverbModel = new revmodel(); -// For debuging partial allocation -//static FILE *pInfo; -struct partUsage { - int active[32]; - int assign[32]; - int owner[32]; - int status[32]; -}; - -static int32 activeChannels; - -// Some optimization stuff -int32 divtable[256]; // 1K -int32 smalldivtable[256]; // 1K -static int16 freqtable[256]; // 512 bytes -static uint32 sqrtable[101]; // 404 bytes -static int32 keytable[256]; // 1K -static uint32 wavtable[256]; // 1K -uint32 wavtabler[64][256]; // 64K -uint32 looptabler[16][16][256]; // 256K -static uint32 drumdelta[256]; // 1K -int16 sintable[65536]; // 128K -static int32 ptable[101]; // 404 bytes -static int32 lfotable[101]; // 404 bytes -int32 penvtable[16][128]; // 8K -static int32 fildeptable[5][128]; // 3K -static int32 timekeytable[5][128]; // 3K -static int32 filveltable[128][128]; // 64K -static int32 veltkeytable[5][128]; // 3K -int32 pulsetable[101]; // 400 bytes -int32 pulseoffset[101]; // 400 bytes -int32 sawtable[128][128]; // 64K -static int32 restable[201]; // 804 bytes -//static int32 biastable[13]; // 56 bytes -static int32 ampbiastable[16][128]; // 8K -static int32 fbiastable[16][128]; // 8K -static int filttable[2][128][256]; // 256K -static int nfilttable[128][128][128]; // 64K -float filtcoeff[FILTERGRAN][32][16]; // 512K - hmmm -#if FILTER_64BIT == 1 -static int64 filtcoefffix[FILTERGRAN][32][16]; -#endif -#if FILTER_INT == 1 -static int32 filtcoefffix[FILTERGRAN][32][16]; -#endif -static float revtable[8]; // 16 bytes -static int32 finetable[201]; // 804 bytes -uint32 lfoptable[101][128]; // 32K -int32 ampveltable[128][64]; // 32K -int32 pwveltable[15][128]; -static int32 envtimetable[101]; // 404 bytes -static int32 decaytimetable[101]; // 404 bytes -static int32 lasttimetable[101]; // 404 bytes -int32 amptable[129]; // 516 bytes -static int32 voltable[129]; // 516 bytes -static float padjtable[51]; // 204 bytes -static int32 bendtable[49]; // 195 bytes -float ResonFactor[32]; -float ResonInv[32]; - -int16 smallnoise[441]; // 4410 bytes at 44Khz -int32 samplepos = 0; - -int16* waveforms[4][256]; // 2K -uint32 waveformsize[4][256]; -int16 tmpforms[4][65536]; // 128K -int16 finalforms[4][8192]; // 64K - -// Corresponding drum patches as matched to keyboard -int8 DrumTable[42] = { - 0, 0, 10, 1, 11, 5, 4, 6, 4, 29, 3, 7, 3, 2, 8, 2, 9, -1, -1, 22, - -1, 12, -1, -1, -1, 18, 19, 13, 14, 15, 16, 17, 20, 21, 27, 24, - 26, 25, 28, -1, 23, -1 }; - -// Pan-pot position of drums -int16 drmPanTable[42] = { - 64, 64, 72, 64, 48, 72, 24, 72, 24, 72, 48, 72, 48, 96, 72, 96, 48, 1, 1, 40, - 1, 64, 1, 1, 1, 104, 88, 48, 40, 32, 64, 80, 104 , 104, 40, 88, - 40, 40, 32, 1, 16, 1 }; - -uint8 PartialStruct[13] = { - 0, 0, 2, 2, 1, 3, - 3, 0, 3, 0, 2, 1, 3 }; - -uint8 PartMixStruct[13] = { - 0, 1, 0, 1, 1, 0, - 1, 3, 3, 2, 2, 2, 2 }; - -uint8 InitInstr[8] = { - 68, 48, 95, 78, 41, 3, 110, 122}; - -int8 LoopPatterns[16][16] = { - { 2,3,4,5,6,7,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { 8,9,10,11,12,13,14,15,16,-1,-1,-1,-1,-1,-1,-1 }, - { 17,18,19,20,21,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { 22,23,24,25,26,27,28,29,-1,-1,-1,-1,-1,-1,-1,-1 }, - { 30,31,32,33,34,35,36,37,-1,-1,-1,-1,-1,-1,-1,-1 }, - { 45,46,47,48,49,50,51,52,53,-1,-1,-1,-1,-1,-1,-1 }, - { 15,11,12,13,14,15,16,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { 30,35,32,33,34,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { 2,3,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 } -}; - - -int32 LoopPatternTuning[16][16] = { - { 0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { 0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A, 0x1294A,-1,-1,-1,-1,-1,-1,-1 }, - { 0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A, 0x1294A,-1,-1,-1,-1,-1,-1,-1 }, - { 0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A, 0x1294A,-1,-1,-1,-1,-1,-1,-1 }, - { 0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A, 0x1294A,-1,-1,-1,-1,-1,-1,-1 }, - { 0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A, 0x1294A,-1,-1,-1,-1,-1,-1,-1 }, - { 0x2590B,0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { 0x1294A,0x1294A,0x1294A,0x1294A,0x1294A,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { 0x1294A,0x1294A,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }, - { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 } - -}; - - -// These are division constants for the TVF depth key follow -uint32 depexp[5] = {3000,950,485,255,138}; - -//Amplitude time velocity follow exponential coefficients -double tvcatconst[5] = {0.0, 0.002791309, 0.005942882, 0.012652792, 0.026938637}; -double tvcatmult[5] = {1.0, 1.072662811, 1.169129367, 1.288579123, 1.229630539}; - -//Envelope time keyfollow exponential coefficients -double tkcatconst[5] = {0.0, 0.005853144, 0.011148054, 0.019086143, 0.043333215}; -double tkcatmult[5] = {1.0, 1.058245688, 1.048488989, 1.016049301, 1.097538067}; - -// This caches the drum information -patchCache drumCache[30][4]; -int drumPan[30][2]; - -bool isEnabled; - - -Reverb *myReverb; -revmodel *newReverb; -bool usingSIMD; - -int16 mastervolume; - -uint32 curRevMode; -uint32 curRevTime; -uint32 curRevLevel; - -uint32 partialsPlayed; // Variable containing the whole count of partials played -uint32 avgPartials; // Tally of average number of partials a second -int32 partialChan[9]; // The count of partials played per channel - -#if SAVECUSTOM == 1 -uint32 filenum = 0; -#endif - -/* -t60 = reverb time -hlratio = ratio of low freq t60 to high freq t60 -dur = duration of event/dealloc. on last samp -hall_fact= mult. factor for delay times -revstate = running values for event reverb -*/ - -// t60 follows standard sabine equation -// t60 = .049 * (V / A) -// Where V = is the volume of the enclosure in cubic feet -// And A is the absorbtion of the room in square feet -// Using metric measurements (metres) the .049 is replaced with 0.161 - - - -void InitReverb(uint32 newRevMode, uint32 newRevTime, uint32 sampRate) { - if(newReverb != NULL) delete newReverb; - newReverb = new revmodel(); - - /* - if(myReverb != NULL) delete myReverb; - - float t60; - switch(newRevMode) { - case 0: - t60 = .161f * REV_ROOMT60; - break; - case 1: - t60 = .161f * REV_HALLT60; - break; - case 2: - t60 = .161f * REV_PLATET60; - break; - case 3: - t60 = .161f * REV_TAPT60; - break; - default: - t60 = .161f * REV_ROOMT60; - break; - } - - t60 = t60 * 0.625; - myReverb = new Reverb(t60,HLRATIO,sampRate/(8/(newRevTime+1)),(newRevTime+1),sampRate); - */ curRevTime = newRevTime; curRevMode = newRevMode; switch(newRevMode) { case 0: - newReverb->setroomsize((float).1); - newReverb->setdamp((float).75); + reverbModel->setroomsize(.1f); + reverbModel->setdamp(.75f); break; case 1: - newReverb->setroomsize((float).5); - newReverb->setdamp((float).5); + reverbModel->setroomsize(.5f); + reverbModel->setdamp(.5f); break; case 2: - newReverb->setroomsize((float).5); - newReverb->setdamp((float).1); + reverbModel->setroomsize(.5f); + reverbModel->setdamp(.1f); break; case 3: - newReverb->setroomsize((float)1); - newReverb->setdamp((float).75); + reverbModel->setroomsize(1.0f); + reverbModel->setdamp(.75f); break; default: - newReverb->setroomsize((float).1); - newReverb->setdamp((float).5); + reverbModel->setroomsize(.1f); + reverbModel->setdamp(.5f); break; } - newReverb->setdry(1); - newReverb->setwet((float)mt32ram.params.system.reverbLevel / 8.0); - newReverb->setwidth((float)curRevTime / 8.0); - - -} - -class MidiChannel { -public: - bool isPlaying; - - volset volumesetting; - - int reverbat, reverbleft, reverbright; - int panpot; - - patchCache pcache[4]; - - uint32 bend; - int32 volume; - - dpoly polyTable[MAXPOLY]; - - -private: - bool isRy; - int sampRate; - int freq; - int channum; - int partialCount; - int velocity; - long sndoff; - int octave; - int note; - - int patch; - char currentInstr[20]; - - int keyshift; - int assignmode; - int storedpatch; - bool sustain; - bool init; - - uint32 P1Mix; - uint32 P2Mix; - - bool holdpedal; - - -public: - MidiChannel(int samp, int cnum); - //short getSample(short *lspecial, short *rspecial); - void PlayPoly(int m, int f,int vel); - void PlayDrum(int m, int f,int vel); - void InitKeyFollow(dpoly *tpoly); - void PlayNote(int f, int vel); - void StopNote(int f, int vel); - void AllStop(); - void SetVolume(int vol); - void SetPan(int vol); - void SetBend(int vol); - void SetModulation(int vol); - void SetPatch(int patchnum,int drumNum); - void SetHoldPedal(bool pedalval); - void StopPedalHold(); - void RefreshPatch(); - void CheckNoteList(); - - int FixKeyfollow(int srckey, int *dir); - int FixBiaslevel(int srcpnt, int *dir); - - //int32 getPitchEnvelope(dpoly::partialStatus *pStat, dpoly *poly, bool inDecay); - //int32 getAmpEnvelope(dpoly::partialStatus *pStat, dpoly *poly, bool inDecay); - //int32 getFiltEnvelope(int16 wg, dpoly::partialStatus *pStat, dpoly *poly, bool inDecay); - - //void StartDecay(int envnum, int32 startval, dpoly::partialStatus *pStat, dpoly *poly); - -}; - -void MidiChannel::SetHoldPedal(bool pedalval) { - holdpedal = pedalval; + reverbModel->setdry(1); + reverbModel->setwet((float)mt32ram.params.system.reverbLevel / 8.0f); + reverbModel->setwidth((float)curRevTime / 8.0f); } -void MidiChannel::SetBend(int vol) { - - //int tmpbend = ((vol - 0x2000) * (int)mt32ram.params.pSettings[storedpatch].benderRange) >> 13; - //bend = bendtable[tmpbend+24]; - - float bend_range = (float)mt32ram.params.pSettings[storedpatch].benderRange / 24; - bend = 4096 + (int)((float)(vol - 8192) * bend_range); -} - -void MidiChannel::SetModulation(int vol) { - - // Just a bloody guess, as always, before I get things figured out - int t; - for(t=0;t<4;t++) { - if(pcache[t].playPartial) { - int newrate = (pcache[t].modsense * vol) >> 7; - //pcache[t].lfoperiod = lfotable[newrate]; - pcache[t].lfodepth = newrate; - } +File *Synth::openFile(const char *filename, File::OpenMode mode) { + if (myProp.openFile != NULL) { + return myProp.openFile(myProp.userData, filename, mode); } - -} - -INLINE void StartDecay(int envnum, int32 startval, dpoly::partialStatus *pStat, dpoly *poly) { - - patchCache *tcache = pStat->tcache; - dpoly::partialStatus::envstatus *tStat = &pStat->envs[envnum]; - - tStat->sustaining = false; - tStat->decaying = true; - tStat->envpos = 0; - tStat->envbase = startval; - - switch(envnum) { - case AMPENV: - tStat->envsize = (decaytimetable[(int)tcache->ampEnv.envtime[4]] * timekeytable[(int)tcache->ampEnv.envtkf][poly->freqnum]) >> 8; - tStat->envdist = -startval; - break; - case FILTENV: - tStat->envsize = (decaytimetable[(int)tcache->filtEnv.envtime[4]] * timekeytable[(int)tcache->filtEnv.envtkf][poly->freqnum]) >> 8; - tStat->envdist = -startval; - break; - case PITCHENV: - tStat->envsize = (decaytimetable[(int)tcache->pitchEnv.time[3]] * timekeytable[(int)tcache->pitchEnv.timekeyfollow][poly->freqnum]) >> 8 ; - tStat->envdist = tcache->pitchEnv.level[4] - startval; - break; - default: - break; + char pathBuf[2048]; + if (myProp.baseDir != NULL) { + strcpy(&pathBuf[0], myProp.baseDir); + strcat(&pathBuf[0], filename); + filename = pathBuf; } - tStat->envsize++; - - + ANSIFile *file = new ANSIFile(); + if (!file->open(filename, mode)) { + delete file; + return NULL; + } + return file; } - - - - -INLINE int32 getAmpEnvelope(dpoly::partialStatus *pStat, dpoly *poly) { - int32 tc; - - patchCache *tcache = pStat->tcache; - dpoly::partialStatus::envstatus *tStat = &pStat->envs[AMPENV]; - - if(!pStat->playPartial) return 0; - - if(tStat->decaying) { - - if(pStat->isDecayed) { - pStat->playPartial = false; - - tc = 0; - } else { - tc = tStat->envbase; - tc = (tc + ((tStat->envdist * tStat->envpos) / tStat->envsize)); - - // TRISTAN - if (tc < 0) - tc = 0; - - if((tStat->envpos >= tStat->envsize) || (tc == 0)){ - pStat->PCMDone = true; - pStat->isDecayed = true; - pStat->playPartial = false; - } - } - +void Synth::closeFile(File *file) { + if (myProp.closeFile != NULL) { + myProp.closeFile(myProp.userData, file); } else { - - if((tStat->envstat==-1) || (tStat->envpos >= tStat->envsize)) { - if(tStat->envstat==-1) { - tStat->envbase = 0; - } else { - tStat->envbase = tcache->ampEnv.envlevel[tStat->envstat]; - } - tStat->envstat++; - tStat->envpos = 0; - - switch(tStat->envstat) { - case 0: - //Spot for velocity time follow - //Only used for first attack - tStat->envsize = (envtimetable[(int)tcache->ampEnv.envtime[tStat->envstat]] * veltkeytable[(int)tcache->ampEnv.envvkf][poly->vel]) >> 8; - //LOG_MSG("Envstat %d, size %d, %d %d", tStat->envstat, tStat->envsize, tcache->ampEnv.envtime[tStat->envstat], veltkeytable[tcache->ampEnv.envvkf][poly->vel]); - break; - case 3: - // Final attack envelope uses same time table as the decay - //tStat->envsize = decaytimetable[tcache->ampEnv.envtime[tStat->envstat]]; - tStat->envsize = lasttimetable[(int)tcache->ampEnv.envtime[(int)tStat->envstat]]; - //LOG_MSG("Envstat %d, size %d", tStat->envstat, tStat->envsize); - break; - case 4: - //LOG_MSG("Envstat %d, size %d", tStat->envstat, tStat->envsize); - tc =tcache->ampsustain; - if(!poly->sustain) - StartDecay(AMPENV, tc, pStat, poly); - else - tStat->sustaining = true; - - goto PastCalc; - default: - //Spot for timekey follow - //Only used in subsquent envelope parameters, including the decay - tStat->envsize = (envtimetable[(int)tcache->ampEnv.envtime[tStat->envstat]] * timekeytable[(int)tcache->ampEnv.envtkf][poly->freqnum]) >> 8; - - //LOG_MSG("Envstat %d, size %d", tStat->envstat, tStat->envsize); - break; - } - - tStat->envsize++; - tStat->envdist = tcache->ampEnv.envlevel[tStat->envstat] - tStat->envbase; - - if(tStat->envdist != 0) { - tStat->counter = abs(tStat->envsize / tStat->envdist); - //LOG_MSG("Pos %d, envsize %d envdist %d", tStat->envstat, tStat->envsize, tStat->envdist); - } else { - tStat->counter = 0; - //LOG_MSG("Pos %d, envsize %d envdist %d", tStat->envstat, tStat->envsize, tStat->envdist); - } - } - - tc = tStat->envbase; - tc = (tc + ((tStat->envdist * tStat->envpos) / tStat->envsize)); - tStat->count = tStat->counter; - - -PastCalc: - - tc = (tc * (int32)tcache->amplevel) >> 7; - + file->close(); + delete file; } - - // Prevlevel storage is bottle neck - tStat->prevlevel = tc; - - //Bias level crap stuff now - //I unrolled the loop - - int dist,bias; - - // Bias 1 - if(tcache->ampblevel[0]!=0) { - bias = tcache->ampbias[0]; - if(tcache->ampdir[0]==0) { - // < Bias - if(poly->freqnum < bias) { - dist = bias-poly->freqnum; - tc = (tc * ampbiastable[tcache->ampblevel[0]][dist]) >> 8; +} - } - } else { - // > Bias - if(poly->freqnum > bias) { - dist = poly->freqnum-bias; - tc = (tc * ampbiastable[tcache->ampblevel[0]][dist]) >> 8; - } - } +bool Synth::loadPreset(const char *filename) { + File *file = openFile(filename, File::OpenMode_read); + if (file == NULL) { + printDebug("*** Error: Failed to load preset %s", filename); + return false; } - - //Bias 2 - if(tcache->ampblevel[1]!=0) { - bias = tcache->ampbias[1]; - if(tcache->ampdir[1]==0) { - // < Bias - if(poly->freqnum < bias) { - dist = bias-poly->freqnum; - tc = (tc * ampbiastable[tcache->ampblevel[1]][dist]) >> 8; - - } - } else { - // > Bias - if(poly->freqnum > bias) { - dist = poly->freqnum-bias; - tc = (tc * ampbiastable[tcache->ampblevel[1]][dist]) >> 8; + bool inSys = false; + Bit8u sysexBuf[SYSEX_SIZE]; + Bit16u syslen = 0; + int filePos = 0; + bool rc = true; + for (;;) { + int fc = file->readByte(); + if (fc == -1) { + if (!file->isEOF()) { + rc = false; } + break; } - } - - - - return tc; -} - - -INLINE int32 getPitchEnvelope(dpoly::partialStatus *pStat, dpoly *poly) { - patchCache *tcache = pStat->tcache; - dpoly::partialStatus::envstatus *tStat = &pStat->envs[PITCHENV]; - - int32 tc; - pStat->pitchsustain = false; - if(tStat->decaying) { - - if((pStat->isDecayed) || (tStat->envpos >= tStat->envsize)) { - tc = tcache->pitchEnv.level[4]; - } else { - tc = tStat->envbase; - tc = (tc + ((tStat->envdist * tStat->envpos) / tStat->envsize)); - } - } else { - - if(tStat->envstat==3) { - tc =tcache->pitchsustain; - if(poly->sustain) { - pStat->pitchsustain = true; - } else { - StartDecay(PITCHENV, tc, pStat, poly); - } - - } else { - - if((tStat->envstat==-1) || (tStat->envpos >= tStat->envsize)) { - tStat->envstat++; - - tStat->envbase = tcache->pitchEnv.level[tStat->envstat]; - tStat->envsize = (envtimetable[(int)tcache->pitchEnv.time[tStat->envstat]] * timekeytable[(int)tcache->pitchEnv.timekeyfollow][poly->freqnum]) >> 8; - - - tStat->envpos = 0; - tStat->envsize++; - tStat->envdist = tcache->pitchEnv.level[tStat->envstat+1] - tStat->envbase; - } - - tc = tStat->envbase; - tc = (tc + ((tStat->envdist * tStat->envpos) / tStat->envsize)); - + Bit8u c = (Bit8u)fc; + sysexBuf[syslen] = c; + syslen++; + filePos++; + if (c==0xf0) + inSys = true; + if ((c==0xf7) && (inSys)) { + playSysex(&sysexBuf[0],syslen); + inSys = false; + syslen = 0; } - tStat->prevlevel = tc; - - } - - return tc; - + closeFile(file); + return rc; } - -INLINE int32 getFiltEnvelope(int16 wg, dpoly::partialStatus *pStat, dpoly *poly) { - - int reshigh; - - //float *hist = pStat->history; - //int64 *hist = pStat->history; - //long *hist = pStat->history; - int filt,cutoff,depth,keyfollow, realfollow; - - patchCache *tcache = pStat->tcache; - dpoly::partialStatus::envstatus *tStat = &pStat->envs[FILTENV]; - - keyfollow = pStat->filtval; - realfollow = pStat->realval; - - int fr = poly->freqnum; - - if(tStat->decaying) { - if(pStat->isDecayed) { - reshigh = 0; - } else { - reshigh = tStat->envbase; - reshigh = (reshigh + ((tStat->envdist * tStat->envpos) / tStat->envsize)); - if(tStat->envpos >= tStat->envsize) reshigh = 0; - } - - } else { - if(tStat->envstat==4) { - reshigh =tcache->filtsustain; - if(!poly->sustain) StartDecay(FILTENV, reshigh, pStat, poly); - } else { - - if((tStat->envstat==-1) || (tStat->envpos >= tStat->envsize)) { - if(tStat->envstat==-1) { - tStat->envbase = 0; - } else { - tStat->envbase = tcache->filtEnv.envlevel[tStat->envstat]; - } - tStat->envstat++; - tStat->envpos = 0; - if(tStat->envstat==3) { - tStat->envsize = lasttimetable[(int)tcache->filtEnv.envtime[tStat->envstat]]; - } else { - tStat->envsize = (envtimetable[(int)tcache->filtEnv.envtime[tStat->envstat]] * timekeytable[(int)tcache->filtEnv.envtkf][poly->freqnum]) >> 8; - } - - tStat->envsize++; - tStat->envdist = tcache->filtEnv.envlevel[tStat->envstat] - tStat->envbase; - } - - reshigh = tStat->envbase; - reshigh = (reshigh + ((tStat->envdist * tStat->envpos) / tStat->envsize)); - - } - tStat->prevlevel = reshigh; +unsigned char calcChecksum(unsigned char *data, unsigned int len, unsigned char checksum) { + for (unsigned int i = 0; i < len; i++) { + checksum = checksum + data[i]; } - - cutoff = (tcache->filtEnv.cutoff); - - //if(tcache->waveform==1) reshigh = (reshigh * 3) >> 2; - - depth = (tcache->filtEnv.envdepth); - - //int sensedep = (depth * 127-tcache->filtEnv.envsense) >> 7; - depth = (depth * filveltable[poly->vel][(int)tcache->filtEnv.envsense]) >> 8; - - int bias = tcache->tvfbias; - int dist; - - - if(bias!=0) { - //LOG_MSG("Cutoff before %d", cutoff); - if(tcache->tvfdir == 0) { - if(fr < bias) { - dist = bias - fr; - cutoff = (cutoff * fbiastable[tcache->tvfblevel][dist]) >> 8; - - } - } else { - // > Bias - if(fr > bias) { - dist = fr - bias; - cutoff = (cutoff * fbiastable[tcache->tvfblevel][dist]) >> 8; - } - - } - //LOG_MSG("Cutoff after %d", cutoff); - - } - - - - depth = (depth * fildeptable[tcache->tvfdepth][fr]) >> 8; - reshigh = (reshigh * depth) >> 7; - - - int32 tmp; - - cutoff *= keyfollow; - cutoff /= realfollow; - - reshigh *= keyfollow; - reshigh /= realfollow; - - if(cutoff>100) cutoff = 100; - if(reshigh>100) reshigh = 100; - if(cutoff<0) cutoff = 0; - if(reshigh<0) reshigh = 0; - tmp = nfilttable[fr][cutoff][reshigh]; - //tmp *= keyfollow; - //tmp /= realfollow; - - //LOG_MSG("Cutoff %d, tmp %d, freq %d", cutoff, tmp, tmp * 256); - - return tmp; - //reshigh = (reshigh * depth * 6)>>10; - - filt = (cutoff + reshigh) * keyfollow; - filt = filt / realfollow; - - - - - if(filt<0) filt = 0; - if(filt>=200) filt = 199; - tmp = filttable[(int)tcache->waveform][fr][filt]; - return tmp; - + checksum = checksum & 0x7f; + if (checksum) + checksum = 0x80 - checksum; + return checksum; } -MidiChannel::MidiChannel(int samp, int cnum) { - isRy = holdpedal = isPlaying = false; - volumesetting.rightvol = volumesetting.leftvol = volumesetting.rightvol2 = volumesetting.leftvol2 = 32767; - patch = storedpatch = 0; - sampRate = samp; - channum = cnum; - volume = 102; - panpot = 64; - init = true; - bend = 0x1000; - memset(polyTable,0,sizeof(polyTable)); - memset(pcache, 0, sizeof(pcache)); - - if(cnum==8) { - isRy = true; - int pan; - volume = 102; - // Cache drum patches - int q,m; - for(q=0;q<30;q++) { - SetPatch(0,q); - for(m=0;m<42;m++) { - if(DrumTable[m]==q) { - pan = drmPanTable[m]; - if(pan<64) { - drumPan[q][0] = 32767; // lv - drumPan[q][1] = pan << 9; // rv - } else { - drumPan[q][0] = (63-(pan-63)) << 9; // lv - drumPan[q][1] = 32767; // rv - } +bool Synth::loadDrums(const char *filename) { + File *file = openFile(filename, File::OpenMode_read); + if (file == NULL) { + return false; + } + int drumnum = 0; + for (;;) { + //Read common area + TimbreParam *timbre = &mt32ram.params.timbres[drumnum + 192].timbre; + if (file->read(&timbre->common, 14) != 14) + break; + char drumname[11]; + strncpy(drumname, timbre->common.name, 10); + drumname[10] = 0; + bool breakout = false; + for (int t=0;t<4;t++) { + if (((timbre->common.pmute >> t) & 0x1) == 0x1) { + if (file->read(&timbre->partial[t], 58) != 58) { + breakout = true; break; } + //printDebug("Loaded drum #%d (%s) - t %d", drumnum, drumname, t); } } + if (breakout) { + break; + } + //printDebug("Loaded drum #%d (%s)", drumnum, drumname); + drumnum++; } - init = false; -} - -INLINE int MidiChannel::FixBiaslevel(int srcpnt, int *dir) { - int noteat = srcpnt & 63; - int outnote; - *dir = 1; - if(srcpnt < 64) *dir = 0; - outnote = 33 + noteat; - //LOG_MSG("Bias note %d, dir %d", outnote, *dir); - - return outnote; - -} - -INLINE int MidiChannel::FixKeyfollow(int srckey, int *dir) { - if (srckey>=0 && srckey<=16) { - //int keyfix[17] = { 256, 128, 64, 0, 32, 64, 96, 128, 128+32, 192, 192+32, 256, 256+64, 256+128, 512, 259, 269 }; - int keyfix[17] = { 256*16, 128*16, 64*16, 0, 32*16, 64*16, 96*16, 128*16, (128+32)*16, 192*16, (192+32)*16, 256*16, (256+64)*16, (256+128)*16, (512)*16, 4100, 4116}; - - if (srckey<3) - *dir = -1; - else if (srckey==3) - *dir = 0; - else - *dir = 1; - - return keyfix[srckey]; - } else { - //LOG_MSG("Missed key: %d", srckey); - return 256; - } -} - - -void MidiChannel::RefreshPatch() { - SetPatch(storedpatch,-1); + closeFile(file); + return true; } -void MidiChannel::SetPatch(int patchnum,int drumNum) { - int i, j, k, pcm,t; - - //int chanoff = channum; - /* TRISTAN: flush all partials on this channel. This is a hack. */ -// for(i=0; i < MAXPARTIALS; i++) -// if(partTable[i]->ownerChan == channum) -// partTable[i]->isActive = false; - - /* TRISTAN: check if any partials are still playing on this channel, if * - * so then duplicate the cached data from the channel to the partial so that * - * we can change the channels cache without affecting the partial. Hopefully * - * this is fairly rare. */ - if (storedpatch != patchnum) - for (i = 0; i < MAXPARTIALS; i++) - if(partTable[i]->ownerChan == channum) - if (partTable[i]->isActive) - { - /* copy cache data */ - for (j = 0; j < 4; j++) - partTable[i]->cachebackup[j] = pcache[j]; - - /* update pointers */ - for (j = 0; j < partTable[i]->timbreNum; j++) - for (k = 0; k < 4; k++) - partTable[i]->tmppoly[j].pStatus[k].tcache = partTable[i]->cachebackup + k; - - partTable[i]->tcache = partTable[i]->cachebackup; - } - - storedpatch = patchnum; - - patch = (mt32ram.params.pSettings[patchnum].timbreGroup * 64) + mt32ram.params.pSettings[patchnum].timbreNum; - - timbreParam timSrc; - //timSrc = mt32ram.params.patch[patch]; - if (drumNum==-1) { - timSrc = mt32ram.params.timTemp[channum]; - memset(¤tInstr,0,16); - memcpy(¤tInstr,timSrc.common.name,10); - - - } else { - // This is to cache all the drum tibres ahead of time - timSrc = drums[drumNum]; - } - //LOG_MSG("Reloading patch %d", channum); - sustain = (timSrc.common.nosustain == 0); - P1Mix = PartMixStruct[(int)timSrc.common.pstruct12]; - P2Mix = PartMixStruct[(int)timSrc.common.pstruct34]; - - //sustain = true; - partialCount = 0; - - for(t=0;t<4;t++) { - - // Calculate and cache common parameters - pcm = timSrc.partial[t].wg.pcmwave; - pcache[t].rawPCM = pcm; - - pcache[t].convPCM = PCMList[pcm]; - pcache[t].useBender = (timSrc.partial[t].wg.bender == 1); - - // pcm > -1 - switch (t) { - case 0: - pcache[t].PCMPartial = (PartialStruct[(int)timSrc.common.pstruct12] >> 1) & 0x1; +void Synth::dumpDrums(const char *filename) { + File *file = openFile(filename, File::OpenMode_write); + if (file == NULL) + return; + char dumbtext[10]; + memset(dumbtext,0,10); + for (int drumnum=0;drumnum<30;drumnum++) { + // Sysex header + if (!file->writeByte(0xf0)) break; - case 1: - pcache[t].PCMPartial = PartialStruct[(int)timSrc.common.pstruct12] & 0x1; + if (!file->writeByte(0x41)) break; - case 2: - pcache[t].PCMPartial = (PartialStruct[(int)timSrc.common.pstruct34] >> 1) & 0x1; + if (!file->writeByte(0x10)) break; - case 3: - pcache[t].PCMPartial = PartialStruct[(int)timSrc.common.pstruct34] & 0x1; + if (!file->writeByte(0x16)) break; - default: + if (!file->writeByte(0x12)) break; - } - - - if( ((timSrc.common.pmute >> (t)) & 0x1) == 1 ) { - pcache[t].playPartial = true; - pcache[t].usePartial = true; - - // Hack and a half... needed so drum partial numbers come through - pcache[0].partCount = t+1; - - partialCount++; - } else { - pcache[t].playPartial = false; - pcache[t].usePartial = false; - continue; - } - - pcache[t].sustain = (timSrc.common.nosustain == 0); - pcache[t].waveform = timSrc.partial[t].wg.waveform; - pcache[t].pulsewidth = timSrc.partial[t].wg.pulsewid; - pcache[t].pwsens = timSrc.partial[t].wg.pwvelo; - pcache[t].pitchkeyfollow = FixKeyfollow(timSrc.partial[t].wg.keyfollow, &pcache[t].pitchkeydir); - - // Calculate and cache pitch stuff - pcache[t].pitchshift = (timSrc.partial[t].wg.coarse+mt32ram.params.pSettings[patchnum].keyShift); - int32 pFine, tFine, fShift; - pFine = (int32)timSrc.partial[t].wg.fine; - tFine = (int32)mt32ram.params.pSettings[patchnum].fineTune; - fShift = ((pFine - 50) + (tFine - 50)) + 100; - pcache[t].fineshift = finetable[fShift]; - - keyshift = mt32ram.params.pSettings[patchnum].keyShift-24; - assignmode = mt32ram.params.pSettings[patchnum].assignMode; - - pcache[t].pitchEnv = timSrc.partial[t].env; - pcache[t].pitchEnv.sensitivity = (int)((float)pcache[t].pitchEnv.sensitivity*1.27); - pcache[t].pitchsustain = pcache[t].pitchEnv.level[3]; - - // Calculate and cache TVA envelope stuff - pcache[t].ampEnv = timSrc.partial[t].tva; - int l; - for(l=0;l<4;l++) { - pcache[t].ampEnv.envlevel[l] = (int)((float)pcache[t].ampEnv.envlevel[l]*1.27); - } - pcache[t].ampEnv.level = (int)((float)pcache[t].ampEnv.level*1.27); - float tvelo = ((float)pcache[t].ampEnv.velosens/100.0); - float velo = (fabs(tvelo-.5)/.5); - pcache[t].ampenvdir = 0; - if(tvelo<.5) pcache[t].ampenvdir = 1; - velo *= 63.0; - pcache[t].ampEnv.velosens = (int)(velo); - - pcache[t].ampbias[0] = FixBiaslevel(pcache[t].ampEnv.biaspoint1, &pcache[t].ampdir[0]); - pcache[t].ampblevel[0] = 12-pcache[t].ampEnv.biaslevel1; - pcache[t].ampbias[1] = FixBiaslevel(pcache[t].ampEnv.biaspoint2, &pcache[t].ampdir[1]); - pcache[t].ampblevel[1] = 12-pcache[t].ampEnv.biaslevel2; - pcache[t].ampdepth = pcache[t].ampEnv.envvkf * pcache[t].ampEnv.envvkf; - pcache[t].ampsustain = pcache[t].ampEnv.envlevel[3]; - pcache[t].amplevel = pcache[t].ampEnv.level; - - - // Calculate and cache filter stuff - pcache[t].filtEnv = timSrc.partial[t].tvf; - pcache[t].tvfdepth = pcache[t].filtEnv.envdkf; - pcache[t].filtkeyfollow = FixKeyfollow(pcache[t].filtEnv.keyfollow, &pcache[t].keydir); - pcache[t].filtEnv.envdepth = (int)((float)pcache[t].filtEnv.envdepth * 1.27); - pcache[t].tvfbias = FixBiaslevel(pcache[t].filtEnv.biaspoint, &pcache[t].tvfdir); - pcache[t].tvfblevel = pcache[t].filtEnv.biaslevel; - pcache[t].filtsustain = pcache[t].filtEnv.envlevel[3]; - - // Calculate and cache LFO stuff - //pcache[t].lfodepth = (int)((float)timSrc.partial[t].lfo.depth * 1.27); - pcache[t].lfodepth = timSrc.partial[t].lfo.depth; - pcache[t].lfoperiod = lfotable[(int)timSrc.partial[t].lfo.rate]; - pcache[t].lforate = timSrc.partial[t].lfo.rate; - pcache[t].modsense = timSrc.partial[t].lfo.modsense; - - } - //LOG_MSG("Res 1: %d 2: %d 3: %d 4: %d", pcache[0].waveform, pcache[1].waveform, pcache[2].waveform, pcache[3].waveform); - - if(drumNum!=-1) memcpy(drumCache[drumNum],pcache,sizeof(pcache)); - if(!init) AllStop(); - - //LOG_MSG("Channel #%d set instrument: %s - %d - %d - %d - %d - pc %d", chanoff, currentInstr, timSrc.partial[0].wg.pcmwave, timSrc.partial[1].wg.pcmwave, timSrc.partial[2].wg.pcmwave, timSrc.partial[3].wg.pcmwave, pcache[0].partCount); - -} - -void MidiChannel::SetVolume(int vol) { - - volume = voltable[vol]; - -} - -void MidiChannel::SetPan(int pan) { - panpot = pan; - - if(pan<64) { - volumesetting.leftvol = 32767; - volumesetting.rightvol = pan << 9; - - } - if(pan>=64) { - volumesetting.rightvol = 32767; - volumesetting.leftvol = (63-(pan-63)) << 9; - - } - - - - //LOG(LOG_ERROR|LOG_MISC,"Pan %d",panpot); -} - -INLINE int16 RingMod(int16 p1, int16 p2, bool useFirst) { - if(useFirst) { - //return (int16)( ( ((float)p1/32767.0) * ((float)p2/32767.0) ) * 32767); - return (int16)( ((int32)p1 * (int32)p2) >> 15); - - } else { - // An interesting undocumented feature of the MT-32 - // Putting ring mod on a muted partial introduces noise to the ring modulator - // Dune 2 makes use of this - return (int16)( ((int32)smallnoise[samplepos/100] * (int32)p2) >> 15); - } -} - - -INLINE void MidiChannel::InitKeyFollow(dpoly *tpoly) { - // Setup partial keyfollow - int keyfollow = 0; - int tmpval = tpoly->freqnum,t; - int keyedval; - - // Note follow relative to middle C - for(t=0;t<4;t++) { - - // Calculate keyfollow for pitch - switch(pcache[t].pitchkeydir) { - case -1: - keyfollow = ((int)((MIDDLEC*2-tmpval*2)/2) * pcache[t].pitchkeyfollow) >> 12; + int useaddr = drumnum * 256; + char lsb = (char)(useaddr & 0x7f); + char isb = (char)((useaddr >> 7) & 0x7f); + char msb = (char)(((useaddr >> 14) & 0x7f) | 0x08); + //Address + if (!file->writeByte(msb)) break; - case 0: - keyfollow = 0; + if (!file->writeByte(isb)) break; - case 1: - keyfollow = ((int)((tmpval*2-MIDDLEC*2)/2)*pcache[t].pitchkeyfollow)>>12; + if (!file->writeByte(lsb)) break; - } - if((pcache[t].pitchkeyfollow>4096) && (pcache[t].pitchkeyfollow<4200)) { - // Be sure to round up on keys below MIDDLEC - if(((tmpval*2-MIDDLEC*2)/2) < 0) keyfollow++; - } - keyedval = (keyfollow + pcache[t].pitchshift); - if(keyedval>108) keyedval = 108; - if(keyedval<12) keyedval = 12; - - tpoly->pStatus[t].keyedval = keyedval; - tpoly->pStatus[t].noteval = tmpval; - // Calculate keyfollow for filter - - int realfol = ((tmpval*2)-(MIDDLEC*2))/2; - switch(pcache[t].keydir) { - case -1: - keyfollow = ((int)((MIDDLEC*2-tmpval*2)/2) * pcache[t].filtkeyfollow )>>12; + TimbreParam *timbre = &mt32ram.params.timbres[192 + drumnum].timbre; + //Data + if (file->write(&timbre->common,0xE) != 0xE) break; - case 0: - keyfollow = tmpval; + if (file->write(&timbre->partial[0],0x3A) != 0x3A) break; - case 1: - keyfollow = ((int)((tmpval*2-(MIDDLEC*2))/2) * pcache[t].filtkeyfollow )>>12; + if (file->write(&timbre->partial[1],0x3A) != 0x3A) break; - } - - if (keyfollow>108) keyfollow=108; - if (keyfollow<-108) keyfollow =-108; - tpoly->pStatus[t].filtnoval = keyfollow+108; - tpoly->pStatus[t].filtval = keytable[keyfollow+108]; - tpoly->pStatus[t].realval = keytable[realfol+108]; - - } - - -} - -CPartialMT32 * AllocPartial(int chanNum) { - int i; - - CPartialMT32 *outPart = NULL; - -#if MAXPARTIALS == 32 - for(i=0;i<MAXPARTIALS;i++) { - if(PartialReserveTable[i] == chanNum) { - if(outPart == NULL) { - if(!partTable[i]->isActive) { - outPart = partTable[i]; - } - } - } - } - if(outPart != NULL) { - outPart->isActive = true; - outPart->age = 0; - } else { - for(i=0;i<MAXPARTIALS;i++) { - if(!partTable[i]->isActive) { - outPart = partTable[i]; - outPart->isActive = true; - outPart->age = 0; - break; - } - } - } -#else - for(i=0;i<MAXPARTIALS;i++) { - if(outPart == NULL) { - if(!partTable[i]->isActive) { - outPart = partTable[i]; - } - } - } - if(outPart != NULL) { - outPart->isActive = true; - outPart->age = 0; - } - -#endif - return outPart; -} - -int GetFreePartialCount(void) { - int i; - int count = 0; - memset(partialChan,0,sizeof(partialChan)); - for(i=0;i<MAXPARTIALS;i++) { - if(!partTable[i]->isActive) { - count++; - } else { - partialChan[partTable[i]->ownerChan]++; - } - } - return count; -} - - -INLINE void MidiChannel::PlayPoly(int m, int f,int vel) { - - CPartialMT32 *tmpParts[4]; - f += keyshift; - if((f<0) || (f >255)) return; - freq = freqtable[f]; - dpoly *tpoly = &polyTable[m]; - - tpoly->isPlaying = true; - tpoly->isDecay = false; - tpoly->isActive = true; - tpoly->pcmoff.pcmabs = 0; - tpoly->freq = freq; - tpoly->freqnum = f; - tpoly->pcmdelta = 0x100; - tpoly->age = 0; - tpoly->vel = vel; - tpoly->chan = this->channum; - tpoly->pedalhold = false; - tpoly->firstsamp = true; - memset(tpoly->pStatus,0,sizeof(tpoly->pStatus)); - int x,e; - - for(x=0;x<4;x++) { - - tpoly->pStatus[x].partNum = x; - tpoly->pStatus[x].lfopos = 0; - tpoly->pStatus[x].playPartial = pcache[x].playPartial; - tpoly->pStatus[x].usePartial = pcache[x].usePartial; - tpoly->pStatus[x].tcache = &pcache[x]; - tpoly->pStatus[x].pulsewidth = pcache[x].pulsewidth + pwveltable[pcache[x].pwsens][vel]; - - if(tpoly->pStatus[x].pulsewidth > 100) tpoly->pStatus[x].pulsewidth = 100; - if(tpoly->pStatus[x].pulsewidth < 0) tpoly->pStatus[x].pulsewidth = 0; - - if(pcache[x].playPartial) { - tmpParts[x] = AllocPartial(channum); - } else { - tmpParts[x] = NULL; - } - tpoly->pStatus[x].myPart = (void *)tmpParts[x]; - - for(e=0;e<4;e++) { - tpoly->pStatus[x].envs[e].envstat = -1; - tpoly->pStatus[x].envs[e].sustaining = false; - tpoly->pStatus[x].envs[e].decaying = false; - tpoly->pStatus[x].envs[e].envpos = 0; - tpoly->pStatus[x].envs[e].count = 0; - tpoly->pStatus[x].envs[e].counter = 0; - - - } - } - - bool allnull = true; - for(x=0;x<4;x++) { - //if(tmpParts[x] != NULL) allnull = false; - if(pcache[x].playPartial) allnull = false; - } - //if(allnull) LOG_MSG("No paritals to play for %s", this->currentInstr); - - tpoly->partCount = pcache[0].partCount; - tpoly->P1Mix = P1Mix; - tpoly->P2Mix = P2Mix; - tpoly->sustain = sustain; - tpoly->isRy = false; - tpoly->bendptr = &bend; - tpoly->volumeptr = &volume; - tpoly->pansetptr = &volumesetting; - - InitKeyFollow(tpoly); - - for(x=0;x<4;x++) { - if(tmpParts[x] != NULL) { - int pairPart, useMix, partNum; - switch(x) { - case 0: - useMix = P1Mix; - partNum = 0; - pairPart = 1; - break; - case 1: - useMix = P1Mix; - partNum = 1; - pairPart = 0; - break; - case 2: - useMix = P2Mix; - partNum = 0; - pairPart = 3; - break; - case 3: - useMix = P2Mix; - partNum = 1; - pairPart = 2; - break; - default: - useMix = P1Mix; - partNum = 0; - pairPart = 0; - break; - } - tmpParts[x]->startPartial(tpoly,tpoly->pStatus[x].tcache,&tpoly->pStatus[x],tmpParts[pairPart],useMix,partNum,channum,x); - tpoly->partActive[x] = true; - } else { - tpoly->partActive[x] = false; - } - } - -#if DISPLAYINSTR == 1 - memset(¤tInstr,0,16); - memcpy(¤tInstr,mt32ram.params.patch[patch].common.name,10); - //LOG_MSG("MT32 chan %d (\"%s\") s note poly %d - Vel %d Freq %d Vol %d", channum, currentInstr, m, vel, f, volume); -#endif -} - -INLINE void MidiChannel::PlayDrum(int m, int f,int vel) { - if(!((f>=35) && (f<= 76))) return; - CPartialMT32 *tmpParts[4]; - freq = freqtable[60]; - dpoly *tpoly = &polyTable[m]; - - tpoly->drumnum = f; - tpoly->isPlaying = true; - tpoly->isDecay = false; - tpoly->isActive = true; - tpoly->pcmnum = DrumTable[f-35]; - tpoly->pcmoff.pcmabs = 0; - tpoly->freq = freq; - tpoly->freqnum = 60; - tpoly->pcmdelta = 0x100; - tpoly->age = 0; - tpoly->vel = vel; - tpoly->chan = this->channum; - tpoly->pedalhold = false; - tpoly->firstsamp = true; - memset(tpoly->pStatus,0,sizeof(tpoly->pStatus)); - memcpy(pcache,drumCache[tpoly->pcmnum],sizeof(pcache)); - int x,e; - for(x=0;x<4;x++) { - tpoly->pStatus[x].partNum = x; - tpoly->pStatus[x].playPartial = pcache[x].playPartial; - tpoly->pStatus[x].usePartial = pcache[x].usePartial; - tpoly->pStatus[x].tcache = &drumCache[tpoly->pcmnum][x]; - - if(pcache[x].playPartial) { - tmpParts[x] = AllocPartial(channum); - } else { - tmpParts[x] = NULL; - } - tpoly->pStatus[x].myPart = (void *)tmpParts[x]; - - for(e=0;e<4;e++) { - tpoly->pStatus[x].envs[e].envstat = -1; - tpoly->pStatus[x].envs[e].count = 0; - tpoly->pStatus[x].envs[e].counter = 0; - } - } - - tpoly->P1Mix = PartMixStruct[(int)drums[tpoly->pcmnum].common.pstruct12]; - tpoly->P2Mix = PartMixStruct[(int)drums[tpoly->pcmnum].common.pstruct34]; - tpoly->sustain = (drums[tpoly->pcmnum].common.nosustain == 0); - tpoly->isRy = true; - tpoly->bendptr = &tpoly->drumbend; - tpoly->drumbend = 0x1000; - - tpoly->partCount = pcache[0].partCount; - tpoly->volumeptr = &volume; - tpoly->pansetptr = &volumesetting; - - InitKeyFollow(tpoly); - - for(x=0;x<4;x++) { - if(tmpParts[x] != NULL) { - int pairPart, useMix, partNum; - switch(x) { - case 0: - useMix = P1Mix; - partNum = 0; - pairPart = 1; - break; - case 1: - useMix = P1Mix; - partNum = 1; - pairPart = 0; - break; - case 2: - useMix = P2Mix; - partNum = 0; - pairPart = 3; - break; - case 3: - useMix = P2Mix; - partNum = 1; - pairPart = 2; - break; - default: - useMix = P1Mix; - partNum = 0; - pairPart = 0; - break; - } - tmpParts[x]->startPartial(tpoly,tpoly->pStatus[x].tcache,&tpoly->pStatus[x],tmpParts[pairPart],useMix,partNum,channum,x); - } - } - -#if DISPLAYINSTR == 1 - memset(¤tInstr,0,16); - memcpy(¤tInstr,drums[tpoly->pcmnum].common.name,10); - //LOG_MSG("MT32 drum chan (f %d = %d) (\"%s\") starting note poly %d - Velocity %d", f, tpoly->pcmnum, currentInstr, m, vel); -#endif -} - -/* -bool FreePartials(int needed, int chanNum) { - int i; - int myChanPrior = (int)mt32ram.params.system.reserveSettings[chanNum]; - if(myChanPrior<partialChan[chanNum]) { - //This can have more channels, must kill off those with less priority - int most, mostchan; - while(needed > 0) { - int selectChan = -1; - //Find the worst offender with more partials than allocated and kill them - most = -1; - mostchan = -1; - int diff; - - for(i=0;i<9;i++) { - diff = partialChan[i] - (int)mt32ram.params.system.reserveSettings[i]; - - if(diff>0) { - if(diff>most) { - most = diff; - mostchan = i; - } - } - } - selectChan = mostchan; - if(selectChan==-1) { - // All channels are within the allocated limits, you suck - // Look for first partial not of this channel that's decaying perhaps? - return false; - } - bool found; - int oldest; - int oldnum; - while(partialChan[selectChan] > (int)mt32ram.params.system.reserveSettings[selectChan]) { - oldest = -1; - oldnum = -1; - found = false; - for(i=0;i<32;i++) { - if(partTable[i]->isActive) { - if(partTable[i]->ownerChan == selectChan) { - found = true; - if(partTable[i]->age > oldest) { - oldest = partTable[i]->age; - oldnum = i; - } - } - } - } - if(!found) break; - partTable[oldnum]->stopPartial(); - --partialChan[selectChan]; - --needed; - } - - } - return true; - - } else { - //This channel has reached its max, must kill off its own - bool found; - int oldest; - int oldnum; - while(needed > 0) { - oldest = -1; - oldnum = -1; - found = false; - for(i=0;i<32;i++) { - if(partTable[i]->isActive) { - if(partTable[i]->ownerChan == chanNum) { - found = true; - if(partTable[i]->age > oldest) { - oldest = partTable[i]->age; - oldnum = i; - } - } - } - } - if(!found) break; - partTable[oldnum]->stopPartial(); - --needed; - } - // Couldn't free enough partials, sorry - if(needed>0) return false; - return true; - } - -} -*/ -bool FreePartials(int needed, int chanNum) { - - int i; -#if MAXPARTIALS == 32 - // Reclaim partials reserved for this channel - // Kill those that are already decaying first - /* - for(i=0;i<32;i++) { - if(PartialReserveTable[i] == chanNum) { - if(partTable[i]->ownerChan != chanNum) { - if(partTable[i]->partCache->envs[AMPENV].decaying) { - partTable[i]->isActive = false; - --needed; - if(needed<=0) return true; - } - } - } - - }*/ - // Then kill those with the lowest channel priority --- oldest at the moment - bool found; - int64 prior, priornum; - dpoly *killPoly; - found = true; - while(found) { - found = false; - prior = -1; - priornum = -1; - - for(i=0;i<32;i++) { - if(PartialReserveTable[i] == chanNum) { - if(partTable[i]->isActive) { - if(partTable[i]->ownerChan != chanNum) { - /* - if(mt32ram.params.system.reserveSettings[partTable[i]->ownerChan] < prior) { - prior = mt32ram.params.system.reserveSettings[partTable[i]->ownerChan]; - priornum = i; - }*/ - if(partTable[i]->age > prior) { - prior = partTable[i]->age; - priornum = i; - } - - found = true; - } - } - } - } - if(priornum != -1) { - partTable[priornum]->isActive = false; - - killPoly = partTable[priornum]->tmppoly; - killPoly->partActive[partTable[priornum]->timbreNum] = false; - killPoly->isActive = killPoly->partActive[0] || killPoly->partActive[1] || killPoly->partActive[2] || killPoly->partActive[3]; - --needed; - if(needed<=0) return true; - } - } - - - // Kill off the oldest partials within this channel - int64 oldest, oldlist; - - while(needed>0) { - oldest = -1; - oldlist = -1; - for(i=0;i<32;i++) { - if(partTable[i]->isActive) { - if(partTable[i]->ownerChan == chanNum) { - if(partTable[i]->age > oldest) { - oldest = partTable[i]->age; - oldlist = i; - } - } - } - } - if(oldlist != -1) { - partTable[oldlist]->isActive = false; - killPoly = partTable[oldlist]->tmppoly; - killPoly->partActive[partTable[oldlist]->timbreNum] = false; - killPoly->isActive = killPoly->partActive[0] || killPoly->partActive[1] || killPoly->partActive[2] || killPoly->partActive[3]; - --needed; - } else { + if (file->write(&timbre->partial[2],0x3A) != 0x3A) break; - } - } - if(needed<=0) return true; - - - return false; -#else - //No priority table when not using standard MT-32 configuration - // Kill off the oldest partials within this channel - int oldest, oldlist; - dpoly *killPoly; - oldest = -1; - oldlist = -1; - while(needed>0) { - for(i=0;i<MAXPARTIALS;i++) { - if(partTable[i]->ownerChan == chanNum) { - if(partTable[i]->age > oldest) { - oldest = partTable[i]->age; - oldlist = i; - } - } - } - if(oldlist != -1) { - partTable[oldlist]->isActive = false; - killPoly = partTable[oldlist]->tmppoly; - killPoly->partActive[partTable[oldlist]->timbreNum] = false; - killPoly->isActive = killPoly->partActive[0] || killPoly->partActive[1] || killPoly->partActive[2] || killPoly->partActive[3]; - --needed; - } else { + if (file->write(&timbre->partial[3],0x3A) != 0x3A) break; - } - } - if(needed<=0) return true; - //LOG_MSG("Out of paritals!"); - return false; -#endif - - -} - - -void MidiChannel::CheckNoteList() { - int q,t; - for(q=0;q<MAXPOLY;q++) { - if(polyTable[q].isActive) { - bool isActive = false; - CPartialMT32 * tmpPart; - for(t=0;t<4;t++) { - tmpPart = (CPartialMT32 *)polyTable[q].pStatus[t].myPart; - if(tmpPart != NULL) { - if(tmpPart->ownerChan == channum) { - isActive = isActive || tmpPart->isActive; - } - } - } - polyTable[q].isActive = isActive; - - } - } -} - -INLINE void MidiChannel::PlayNote(int f,int vel) { - int m; - sndoff=0; - velocity = vel; - - isPlaying = false; - - //if(channum!=0) return; - - if(isRy) memcpy(pcache,drumCache[DrumTable[f-35]],sizeof(pcache)); - - // POLY1 mode, Single Assign - // Haven't found any software that uses any of the other poly modes - if(!isRy) { - for(m=0;m<MAXPOLY;m++) { - if((polyTable[m].isActive) && (polyTable[m].freqnum == f)) { - StopNote(f,vel); - break; - } - } - } - - int needPartials = pcache[0].partCount; - - if(needPartials > GetFreePartialCount()) { - if(!FreePartials(needPartials, channum)) { - // Before we quit, see if there are other channels willing to donate - if(needPartials > GetFreePartialCount()) { - // Unable to get needed partials to play this note - return; - } - } - } - - // Find free note allocator - for(m=0;m<MAXPOLY;m++) { - if(!polyTable[m].isActive){ - isPlaying=true; - if (!isRy) { - PlayPoly(m,f,vel); - } else { - if(DrumTable[f-35]>-1) PlayDrum(m,f,vel); - } + //Checksum + unsigned char *dat = (unsigned char *)timbre; + unsigned char checksum = calcChecksum(dat, 246, msb + isb + lsb); + if (!file->writeByte(checksum)) break; - } - } - - -} -void MidiChannel::AllStop() { - int q,t; - for(q=0;q<MAXPOLY;q++) { - dpoly *tpoly = &polyTable[q]; - if(tpoly->isPlaying) { - tpoly->isDecay = true; - for(t=0;t<4;t++) { - - //memset(tpoly->pStatus[t].decay,0,sizeof(tpoly->pStatus[t].decay)); - //tpoly->pStatus[t].isDecayed = 0; - //memset(tpoly->pStatus[t].decaying,true,sizeof(tpoly->pStatus[t].decaying)); - - StartDecay(AMPENV,tpoly->pStatus[t].envs[AMPENV].prevlevel, &tpoly->pStatus[t], tpoly); - StartDecay(FILTENV,tpoly->pStatus[t].envs[FILTENV].prevlevel, &tpoly->pStatus[t], tpoly); - StartDecay(PITCHENV,tpoly->pStatus[t].envs[PITCHENV].prevlevel, &tpoly->pStatus[t], tpoly); - - tpoly->pStatus[t].pitchsustain = false; - } - tpoly->isPlaying = false; - } - - } - -} - -void MidiChannel::StopPedalHold() { - int q; - for(q=0;q<MAXPOLY;q++) { - dpoly *tpoly; - tpoly = &polyTable[q]; - if (tpoly->pedalhold) StopNote(tpoly->freqnum,0); - } - -} - -void MidiChannel::StopNote(int f,int vel) { - // Find oldest note... yes, the MT-32 can be reconfigured to kill different note first - // This is simplest - int oldest = -1; - int oldage = 0; - int count = 0; - int q,t; - bool found = false; - dpoly *tpoly; - - // Non-sustaining instruments ignore stop note commands. - // They die away eventually anyway - //if(!tpoly->sustain) return; - - //LOG_MSG("MT32 chan %d (\"%s\") stopping note %d", this->channum, currentInstr, f); - - for(q=0;q<MAXPOLY;q++) { - tpoly = &polyTable[q]; - - if(tpoly->isPlaying) { - if(tpoly->freqnum == f) { - if (holdpedal) { - tpoly->pedalhold = true; - - } else { - if(tpoly->sustain) { - tpoly->isDecay = true; - - - for(t=0;t<4;t++) { - //memset(tpoly->pStatus[t].decay,0,sizeof(tpoly->pStatus[t].decay)); - //tpoly->pStatus[t].isDecayed = 0; - //memset(tpoly->pStatus[t].decaying,true,sizeof(tpoly->pStatus[t].decaying)); - StartDecay(AMPENV,tpoly->pStatus[t].envs[AMPENV].prevlevel, &tpoly->pStatus[t], tpoly); - StartDecay(FILTENV,tpoly->pStatus[t].envs[FILTENV].prevlevel, &tpoly->pStatus[t], tpoly); - StartDecay(PITCHENV,tpoly->pStatus[t].envs[PITCHENV].prevlevel, &tpoly->pStatus[t], tpoly); - tpoly->pStatus[t].pitchsustain = false; - } - tpoly->isPlaying = false; - } - //return; - } - found = true; - - - } - } - - } - - if(f!=-1) return; - oldest = -1; - for(q=0;q<MAXPOLY;q++) { - tpoly = &polyTable[q]; - - if((tpoly->isPlaying) && (!tpoly->isDecay) && (tpoly->chan==channum)) { - if(tpoly->age>=oldage) { - oldage = tpoly->age; - oldest = q; - } - count++; - } - } - - if(oldest!=-1) { - tpoly = &polyTable[oldest]; - tpoly->isDecay = true; - for(t=0;t<4;t++) { - //memset(tpoly->pStatus[t].decay,0,sizeof(tpoly->pStatus[t].decay)); - //tpoly->pStatus[t].isDecayed = 0; - //memset(tpoly->pStatus[t].decaying,true,sizeof(tpoly->pStatus[t].decaying)); - StartDecay(AMPENV,tpoly->pStatus[t].envs[AMPENV].prevlevel, &tpoly->pStatus[t], tpoly); - StartDecay(FILTENV,tpoly->pStatus[t].envs[FILTENV].prevlevel, &tpoly->pStatus[t], tpoly); - StartDecay(PITCHENV,tpoly->pStatus[t].envs[PITCHENV].prevlevel, &tpoly->pStatus[t], tpoly); - - tpoly->pStatus[t].pitchsustain = false; - } - tpoly->isPlaying = false; - //LOG(LOG_MISC|LOG_ERROR,"MT32 chan %d stopping note %d, %d remaining", this->channum, oldest, count-1); + //End of sysex + if (!file->writeByte(0xf7)) + break; } - + closeFile(file); } -MidiChannel *mchan[16]; - -#endif - - -bool CSynthMT32::InitTables() { +bool Synth::loadPCMToROMMap(const char *filename) { + File *file = openFile(filename, File::OpenMode_read); // Original specified text mode -#ifdef NOMANSLAND - - int noteat,f; - - //LOG_MSG("MT-32 Initializing Pitch Tables"); - for(f=-108;f<109;f++) { - keytable[f + 108] = (int)(256 * pow((float)2, (float)f / (float)24.0)); - //LOG_MSG("KT %d = %d", f, keytable[f+108]); - - } - float ff = 0; - for(f=0;f<=101;f++) { - ff = (float)f/100.00; - sqrtable[f] = (int)(100*sqrt(ff)); - float crapff = ff * (22000.0/32000.0); - if (crapff>1.0) crapff = 1.0; - //filttable[f] = (ff) * (22000.0/16000.0); - - } - - for(f=0;f<8;f++) { - ff = (float)f/14.00; - revtable[f] = (ff); - } - File fp; -#if MAKEWAVES == 1 - fp.open("waveforms.raw", File::kFileWriteMode); -#else - fp.open("waveforms.raw"); -#endif - if(!fp.isOpen()) { - error("Unable to open waveforms.raw"); + if (file == NULL) { return false; } - for(f=12;f<109;f++) { - - //int octave = (f / 12) - 6; - //int note = f % 12; - - //int cents = (octave * 100) + (note * 100); - //int freq = (int)((double)262 * pow((double)2,(double)((double)cents/1200))); - int freq = (int)(TUNING * pow( 2.0, ((double)f - 69.0) / 12.0 )); - freqtable[f] = freq; - divtable[f] = (int)( ((float)SETRATE / (float)(freq))); - smalldivtable[f] = divtable[f] << 8; - divtable[f] = divtable[f] << 16; - int rsaw,dep; - - for(rsaw=0;rsaw<=100;rsaw++) { - //(66-(((A8-50)/50)^.63)*50)/132 - float fsaw = (float)rsaw; - if(rsaw<50) fsaw = 50.0; - int tmpdiv = divtable[f] << 1; - - float sawfact = (66.0-(pow((fsaw-50.0)/50,.63)*50.0))/132.0; - sawtable[f][rsaw] = (int)(sawfact * (float)tmpdiv) >> 16; - //LOG_MSG("F %d divtable %d saw %d sawtable %d", f, divtable[f]>>16, rsaw, sawtable[f][rsaw]); - - } - - - for(dep=0;dep<5;dep++) { - if(dep>0) { - float depfac = 3000; - float ff1, tempdep; - depfac = (float)depexp[dep]; - - ff1 = ((float)f - (float)MIDDLEC) / depfac; - tempdep = pow((float)2,(float)ff) * 256; - fildeptable[dep][f] = (int)tempdep; - - ff1 = exp(tkcatconst[dep] * ((float)MIDDLEC-(float)f)) * tkcatmult[dep]; - timekeytable[dep][f] = (int)(ff1 * 256); - - } else { - fildeptable[dep][f] = 256; - timekeytable[dep][f] = 256; - } - } - //LOG_MSG("F %d d1 %x d2 %x d3 %x d4 %x d5 %x", f, fildeptable[0][f],fildeptable[1][f],fildeptable[2][f],fildeptable[3][f],fildeptable[4][f]); - - - - - noteat = 69-12; - -#if MAKEWAVES ==1 - double ampsize = WGAMP; - int halfdiv = divtable[f] >> 1; - int fa=0; - - float period = ((float)SETRATE / ((float)freq)); - float m=2*(int)(period/2)+1.0f; - float k=(int)(((float)50.0/100.0)*period); - double sd = (2.0*PI)/((((float)divtable[f]/65536.0)) * 4.0); - double sa = 0.0; - - //LOG_MSG("F %d sd %f div %d", f, sd, divtable[f]); - - int j; - float dumbfire; - double square=0.0f; - double saw = 0.0f; - - memset(waveformsize, 0,sizeof(tmpforms)); - - while(sa<=(2.0*PI)) { - float sqp; - - if(sa<PI) { - sqp = -1; - sqp = sqp + (.25 * (sa/PI)); - } else { - sqp=1; - sqp = sqp - (.25 * ((sa-PI)/PI)); - } - - square=0; - saw = 0; - bool odd = true; - for(int32 sinus=1;(sinus*freq)<(SETRATE);sinus++) { - float sinusval = (((1.0/((float)sinus))*(sin(((float)sinus)*sa)))); - saw=saw + sinusval; - } - - - dumbfire = sa/2; - - //This works pretty good - tmpforms[2][fa] += cos(dumbfire) * -ampsize; - tmpforms[3][(fa*2)] += cos(sa-PI) * -ampsize; - tmpforms[3][(fa*2)+1] += cos((sa+(sd/2))-PI) * -ampsize; - - tmpforms[0][fa] += (saw * -ampsize)/2; - tmpforms[1][fa] += (saw * ampsize)/2; - - //tmpforms[1][fa>>4] += saw * ampsize; - - - //waveforms[1][f][fa] = ((prevv2 - prevv)) * ampsize; - - - fa++; - sa+=sd; - } - //LOG_MSG("f num %d freq %d and fa %d", f, freq, fa); - - - waveformsize[0][f] = waveformsize[1][f] = waveformsize[2][f] = fa*2; - waveformsize[3][f] = fa*4; - - for (int i = 0; i < 4; ++i) { - waveforms[i][f] = (int16 *)malloc(waveformsize[i][f]); - memcpy(waveforms[i][f], &tmpforms[i][0],waveformsize[i][f]); - // TODO / FIXME: The following code is not endian safe! - out = fp.write(waveforms[i][f],waveformsize[i][f]); - } -#else - waveformsize[0][f] = waveformsize[1][f] = waveformsize[2][f] = divtable[f]>>13; - waveformsize[3][f] = divtable[f]>>12; - - for (int i = 0; i < 4; ++i) { - waveforms[i][f] = (int16 *)malloc(waveformsize[i][f]); - for (uint j = 0; j < waveformsize[i][f]/2; ++j) - waveforms[i][f][j] = fp.readSint16LE(); - } -#endif - - - // Create the pitch tables - - float tuner = (32000.0 / (float)SETRATE) * 65536.0; - - wavtable[f] = (int)(tuner * ((float)freq/(float)SAMPLETUNING)); // C4 Tuning?; - drumdelta[f] = (int)(tuner * ((float)freq/(float)SAMPLETUNING)); // C4 Tuning?; - int pc,lp,tr,ln; - for(pc=0;pc<54;pc++) { - wavtabler[pc][f] = (int)(tuner * ((float)freq/PCM[pc].tune)); - } - for(lp=0;lp<16;lp++) { - for(ln=0;ln<16;ln++) { - looptabler[lp][ln][f] = (int)((float)LoopPatternTuning[lp][ln] * ((float)freq/(float)220.0)); - } - } - - for(tr=0;tr<=200;tr++) { - float brsq, brsa; - float ftr = (float)tr; - - // Verified exact on MT-32 - if(tr>100) ftr=100+(pow(((ftr-100)/100),3)*100); - brsq = exp(0.0464 * ftr) / 5; - //EXP((90*0.0175)^2) - brsq = exp(pow(((float)tr * 0.0153),2)); - - // I think this is the one - brsq = pow((float)10,((float)(tr/50.0)-1)); - - //brsa = exp(0.04 * ftr) / 5; - - //Last good one that worked - //brsa = exp(pow(((float)tr * 0.0133),2)); - brsa = exp(pow(((float)tr * 0.005),3)) * 125; - - //brsa = pow((float)10,((float)(tr/46.5)-1))/2; - brsa = pow((float)10,((float)(tr/55)-1))/2; - - //brsa = pow(exp((ftr-40)/40),1.15); - //brsq = exp((ftr-35)/35); - //brsq = exp((ftr-35)/23); - //brsa = exp((ftr-35)/23); - //brsq = pow((ftr / 200), LN) * 48.0; - //brsa = pow((ftr / 200), LN) * 32.0; - //brsq = brsa = - - filttable[0][f][tr] = (int)(((float)freq * brsq)/(float)(SETRATE/2)*FILTERGRAN); - if(filttable[0][f][tr]>=((FILTERGRAN*15)/16)) filttable[0][f][tr] = ((FILTERGRAN*15)/16); - filttable[1][f][tr] = (int)(((float)freq * brsa)/(float)(SETRATE/2)*FILTERGRAN); - if(filttable[1][f][tr]>=((FILTERGRAN*15)/16)) filttable[1][f][tr] = ((FILTERGRAN*15)/16); - - } - - int cf, tf; - for(cf=0;cf<=100;cf++) { - float cfmult = (float)cf; - - for(tf=0;tf<=100;tf++) { - - //float tfadd = exp((((float)tf / 100.0) - 1.03) * 3.0) * 100; - //float tfadd = (pow(((float)tf /100.0),4) * 100.0) - 10; - float tfadd = tf - 0; - - if (tfadd < 0) tfadd = 0; - float freqsum = exp((cfmult + tfadd) / 30.0) / 4.0; - //float freqsum = exp((cfmult + tfadd) / 33.7) / 3.0; - - - nfilttable[f][cf][tf] = (int)(((float)freq * freqsum)/(float)(SETRATE/2)*FILTERGRAN); - if(nfilttable[f][cf][tf]>=((FILTERGRAN*15)/16)) nfilttable[f][cf][tf] = ((FILTERGRAN*15)/16); - } - } - } - - fp.close(); - - int j,res; - float fres = 0, tres = 0; - for(res=0;res<31;res++) { - fres = (float)res/30.0; - ResonFactor[res] = (pow((float)2,log(pow((float)fres,(float)16))) * 2.5)+1.0; - ResonInv[res] = 1 / ResonFactor[res]; - - } - - for(j=0;j<FILTERGRAN;j++) { - for(res=0;res<31;res++) { - tres = ResonFactor[res]; - InitFilter((float)SETRATE, (((float)(j+1.0)/FILTERGRAN)) * ((float)SETRATE/2), filtcoeff[j][res],tres, fres); - - // 64-bit variant -#if FILTER_64BIT == 1 - for(int co=0;co<9;co++) { - filtcoefffix[j][res][co] = (int64)(filtcoeff[j][res][co] * pow(2,20)); - - } -#endif - -#if FILTER_INT == 1 - for(int co=0;co<9;co++) { - filtcoefffix[j][res][co] = (long)(filtcoeff[j][res][co] * pow(2,10)); - - } -#endif - } - - } - - int period = 65536; - - int ang; - for(ang=0;ang<period;ang++) { - int halfang = (period / 2); - int angval = ang % halfang; - float tval = (((float)angval / (float)halfang) - 0.5) * 2; - if(ang>=halfang) tval = -tval; - sintable[ang] = (int)(tval * 50.0)+50; - - } - - - //for(ang=0;ang<period;ang++) sintable[period] *= 50; - int velt, dep; - float tempdep; - for(velt=0;velt<128;velt++) { - for(dep=0;dep<5;dep++) { - if(dep>0) { - float ff1 = exp(3.5*tvcatconst[dep] * (59.0-(float)velt)) * tvcatmult[dep]; - tempdep = 256.0 * ff1; - veltkeytable[dep][velt] = (int)tempdep; - if((velt % 16) == 0) { - //LOG_MSG("Key %d, depth %d, factor %d", velt, dep, (int)tempdep); - } - } else { - veltkeytable[dep][velt] = 256; - } - } -#define divpart 14.285714285714285714285714285714 - - for(dep=-7;dep<8;dep++) { - float fldep = fabs((float)dep) / 7.0; - fldep = pow((float)fldep,(float)2.5); - if(dep<0) fldep = fldep * -1.0; - pwveltable[dep+7][velt] = int32((fldep * (float)velt * 100) / 128.0); - - } - } - - for(dep=0;dep<=100;dep++) { - for(velt=0;velt<128;velt++) { - float fdep = (float)dep * 0.000347013; // Another MT-32 constant - float fv = ((float)velt - 64.0)/7.26; - float flogdep = pow((float)10, (float)(fdep * fv)); - float fbase; - - if(velt>64) { - filveltable[velt][dep] = (int)(flogdep * 256.0); - } else { - //lff = 1 - (pow(((128.0 - (float)lf) / 64.0),.25) * ((float)velt / 96)); - fbase = 1 - (pow(((float)dep / 100.0),.25) * ((float)(64-velt) / 96.0)); - filveltable[velt][dep] = (int)(fbase * 256.0); - - } - - //LOG_MSG("Filvel dep %d velt %d = %x", dep, velt, filveltable[velt][dep]); - } - } - - int lf; - for(lf=0;lf<=100;lf++) { - float elf = (float)lf; - - // General envelope - float logtime = elf * 0.088362939; - envtimetable[lf] = (int)((exp(logtime)/312.12) * (float)SETRATE); - - // Decay envelope -- shorter for some reason - // This is also the timing for the envelope right before the - // amp and filter envelope sustains - - lasttimetable[lf] = decaytimetable[lf] = (int)((exp(logtime)/(312.12*2)) * (float)SETRATE); - - //lasttimetable[lf] = (int)((exp(logtime)/(312.12*6)) * (float)SETRATE); - - // Finetuning table - //finetable[lf] = (int) ((pow(2, (((float)lf/100.0)-0.5)/6.0))*4096.0); - - } - for(lf=0;lf<=200;lf++) { - finetable[lf] = (int) ((pow((float)2, (float)((((float)lf/200.0)-1.0)/12.0))*4096.0)); - - } - for(lf=0;lf<=48;lf++) { - bendtable[lf] = (int) ((pow((float)2, (float)((((float)lf/12.0)-2.0)))*4096.0)); - - } - - float lff; - for(lf=0;lf<128;lf++) { - for(velt = 0;velt<64;velt++) { - lff = 1 - (pow(((128.0 - (float)lf) / 64.0),.25) * ((float)velt / 96)); - //lff = ((128.0 - (float)lf) / 128.0) * ((float)velt / 64); - //lff = 1.0 / pow(10, lff/2); - - - - ampveltable[lf][velt] =(int)(lff * 256.0); - //LOG_MSG("Ampveltable: %d, %d = %d", lf, velt, ampveltable[lf][velt]); - } - } - for(lf=0;lf<=127;lf++) { - restable[lf] = (int)( (pow((float)2,pow((float)(lf/127.0),(float)2.5))-1)*100 ); - //LOG_MSG("lf %d = amp %d", lf, restable[lf]); - } - - for(lf=0;lf<=127;lf++) { - //amptable[lf] = (int)( (pow(2,pow((float)lf/127.0,1))-1)*127 ); - //amptable[lf] = lf; - //float pubical = (float)lf/127.0; // Yes, as in boobical pubical (because its cubical!) - - // Converting MIDI to volume. - // Thanks Microsoft DDK - // value = 2^(log10((index/127)^4))*127 where index = 0..127 - amptable[lf] = voltable[lf] = (int)(127.0 * pow((float)2,log(pow((float)(lf/127.0),(float)4)))); - - // Nope, lets try this again - //amptable[lf] = voltable[lf] = (int)(127.0 * log10((float)lf/12.70)); - - //amptable[lf] = (int)(pubical * pubical * pubical * 127.0); - - // Once more... - - //float indec = 128.0 - (float)lf; - //indec = -(indec / 1.33333); - voltable[lf] = amptable[lf] = (int)(127.0 * pow((float)lf/127.0,LN)); - - //indec = 40 * log((float)lf / 127.0); - //voltable[lf] = (int)(127.0 * exp(indec/40.0)); - - //LOG_MSG("lf %d = vol %d", lf, voltable[lf]); - } - for(lf=0;lf<441;lf++) { - int myRand; - myRand = rand(); - myRand = ((myRand - 16383) * WGAMP) >> 18; - smallnoise[lf] = (int16)myRand; - } - - for(lf=0;lf<=100;lf++) { - ptable[lf] = (int)(pow((float)2,(float)((float)(lf-50)/25.0)) * 256); - - } - float tdist; - for(lf=0;lf<=50;lf++) { - if(lf==0) - padjtable[lf] = 7; - else if (lf==1) - padjtable[lf] = 6; - else if (lf==2) - padjtable[lf] = 5; - else if (lf==3) - padjtable[lf] = 4; - else if (lf==4) - padjtable[lf] = 4-(.333333f); - else if (lf==5) - padjtable[lf] = 4-(.333333f*2); - else if (lf==6) - padjtable[lf] = 3; - else if ((lf>6) && (lf<=12)) { - tdist = (lf-6.0) / 6.0; - padjtable[lf] = 3.0 - tdist; - } else if ((lf>12) && (lf<=25)) { - tdist = (lf-12.0) / 13.0; - padjtable[lf] = 2.0 - tdist; - - } else { - tdist = (lf-25.0) / 25.0; - padjtable[lf] = 1.0 - tdist; - } - //LOG_MSG("lf %d = padj %f", lf, padjtable[lf]); - } - for(lf=0;lf<=100;lf++) { - float mv = (float)lf / 100.0; - float pt = mv-0.5; - if(pt<0) pt = 0; - - pulsetable[lf] = (int)((pt) * 215.04) + 128; - pulseoffset[lf] = (int)(pt * WGAMP); - - /* - // I am certain of this: Verified by hand LFO log */ - lfotable[lf] = (int32)(((float)SETRATE) / (pow((float)1.088883372,(float)lf) * 0.021236044)); - - //LOG_MSG("lf %d = lfo %d pulsetable %d", lf, lfotable[lf], pulsetable[lf]); - } - - float lfp, depf, finalval, tlf; - int depat, pval, depti; - for(lf=0;lf<=10;lf++) { - // I believe the depth is cubed or something - - for(depat=0;depat<=100;depat++) { - if(lf>0) { - depti = abs(depat-50); - tlf = (float)lf - padjtable[depti]; - if(tlf<0) tlf = 0; - lfp = exp(0.713619942 * tlf) / 407.4945111; - - if(depat<50) - finalval = 4096.0 * pow((float)2,(float)-lfp); - else - finalval = 4096.0 * pow((float)2, (float)lfp); - pval = (int)(finalval); - - penvtable[lf][depat] = pval; - } else { - penvtable[lf][depat] = 4096; - - } - - //LOG_MSG("lf %d depat %d pval %d tlf %f lfp %f", lf,depat,pval, tlf, lfp); - - } - } - for(lf=0;lf<=100;lf++) { - // Maybe its linear - // It is - verified on MT-32 - one of the few things linear - lfp = ((float)lf * .1904) / 310.55; - - for(depat=0;depat<=100;depat++) { - depf = ((float)depat - 50.0) / 50.0; - //finalval = pow(2, lfp * depf * .5); - finalval = 4096.0 + (4096.0 * lfp * depf); - - pval = (int)(finalval); - - lfoptable[lf][depat] = pval; - - //LOG_MSG("lf %d depat %d pval %x", lf,depat,pval); - - } - } - - - int distval; - float amplog, dval; - - for(lf=0;lf<=12;lf++) { - for(distval=0;distval<128;distval++) { - if(lf==0) { - amplog = 0; - dval = 1; - ampbiastable[lf][distval] = 256; - } else { - amplog = pow((float)1.431817011,(float)lf) / PI; - dval = ((128.0-(float)distval)/128.0); - amplog = exp(amplog); - dval = pow(amplog,dval)/amplog; - ampbiastable[lf][distval] = (int)(dval * 256.0); - } - //LOG_MSG("Ampbias lf %d distval %d = %f (%x) %f", lf, distval, dval, ampbiastable[lf][distval],amplog); - } - - - - } - - for(lf=0;lf<=14;lf++) { - for(distval=0;distval<128;distval++) { - float filval = fabs((((float)lf - 7.0) * 12.0) / 7.0); - - if(lf==7) { - amplog = 0; - dval = 1; - fbiastable[lf][distval] = 256; - } else { - //amplog = pow(1.431817011,filval) / PI; - amplog = pow((float)1.531817011, (float)filval) / PI; - dval = ((128.0-(float)distval)/128.0); - amplog = exp(amplog); - dval = pow(amplog,dval)/amplog; - if(lf<8) { - fbiastable[lf][distval] = (int)(dval * 256.0); - } else { - dval = pow((float)dval, (float).3333333); - if(dval<.01) dval = .01f; - dval = 1 / dval; - fbiastable[lf][distval] = (int)(dval * 256.0); - } - } - //LOG_MSG("Fbias lf %d distval %d = %f (%x) %f", lf, distval, dval, fbiastable[lf][distval],amplog); - } - - - - } - - // Benchmark 3DNow, Floating point, and SSE filters -/* - uint32 bench; - __time64_t start, end; - float histval[50]; - - _time64(&start); - for(bench=0;bench<20000000;bench++) { - iir_filter_sse(0,&histval[0],filtcoeff[0][0],0); - } - _time64(&end); - //LOG_MSG("Bench completed in %ld seconds", end - start); -*/ - - -#endif - - return true; -} - -bool RecalcWaveforms(int sampRate, recalcStatusCallback callBack) { - -#ifdef NOMANSLAND - - File fp; - fp.open("waveforms.raw", File::kFileWriteMode); - - if(!fp.isOpen()) return false; - - double ampsize = WGAMP; - int f; - for(f=12;f<109;f++) { - - if(callBack != NULL) { - int perc = ((f - 12) * 100) / 96; - (callBack)(perc); - } - - //int octave = (f / 12) - 6; - //int note = f % 12; - - //int cents = (octave * 100) + (note * 100); - int freq = (int)(TUNING * pow( 2.0, ((double)f - 69.0) / 12.0 )); - freqtable[f] = freq; - divtable[f] = (int)( ((float)sampRate / (float)freq) ); - smalldivtable[f] = divtable[f] << 8; - divtable[f] = divtable[f] << 16; - - //int halfdiv = divtable[f] >> 1; - - //float period = ((float)sampRate / ((float)freq)); - //float m=2*(int)(period/2)+1.0f; - //float k=(int)(((float)50.0/100.0)*period); - - - double sd = (2.0*PI)/((float)divtable[f]/4096.0); - double sa = 0.0; - - - int fa=0; - - - int j; - float dumbfire; - double square=0.0f; - double saw = 0.0f; - - memset(tmpforms, 0,sizeof(tmpforms)); - - while(sa<=(2.0*PI)) { - float sqp; - - if(sa<PI) { - sqp = -1; - sqp = sqp + (.25 * (sa/PI)); - } else { - sqp=1; - sqp = sqp - (.25 * ((sa-PI)/PI)); - } - - square=0; - saw = 0; - //bool odd = true; - for(double sinus=1.0;sinus<256.0;sinus++) { - float sinusval = (((1/(sinus))*(sin(sinus*sa)))); - if((sinus*freq)<(sampRate*2)) saw=saw + sinusval; - } - - dumbfire = sa /2 ; - - //This works pretty good - tmpforms[2][fa>>4] += (int16)(cos(dumbfire) * -ampsize); - tmpforms[3][fa>>3] += (int16)(cos(sa-PI) * -ampsize); - - tmpforms[0][fa>>4] += (int16)(saw * -ampsize); - tmpforms[1][fa>>4] += (int16)(saw * ampsize); - - fa++; - sa+=sd; - } - - for(j=0;j<=(divtable[f]>>16);j++) { - finalforms[0][j] = tmpforms[0][j] >> 5; - finalforms[1][j] = tmpforms[1][j] >> 5; - finalforms[2][j] = tmpforms[2][j] >> 4; - } - for(j=0;j<=(divtable[f]>>15);j++) { - finalforms[3][j] = tmpforms[3][j] >> 3; - } - - int out; - - out = fp.write(finalforms[0],divtable[f]>>15); - out = fp.write(finalforms[1],divtable[f]>>15); - out = fp.write(finalforms[2],divtable[f]>>15); - out = fp.write(finalforms[3],divtable[f]>>14); - - - } - fp.close(); -#endif - - return true; -} - -bool CSynthMT32::ClassicOpen(SynthProperties useProp) { - -#ifdef NOMANSLAND - - if (isOpen) return false; - int i; - // Initalize patch information - uint8 sysexBuf[SYSEX_SIZE]; - uint16 syslen = 0; - - bool inSys = false; - - File fp; - uint8 c; - - myProp = useProp; - - usefilter = &iir_filter_normal; - - - for(i=0;i<MAXPARTIALS;i++) { - partTable[i] = new CPartialMT32(i); - } - - //pInfo = fopen("partial.nfo","wb"); - - - //LOG_MSG("MT-32 Initializing patch banks"); - - for(initmode=0;initmode<2;initmode++) { - - switch(initmode) { - case 0: - fp.open("Preset1.syx"); - if(!fp.isOpen()) { - // TODO : Fail driver init - error("Unable to open Preset1.syx"); - return false; - } - break; - case 1: - fp.open("Preset2.syx"); - if(!fp.isOpen()) { - // TODO : Fail driver init - error("Unable to open Preset2.syx"); - return false; - } - break; - default: - - // TODO : Fail driver init - return false; - - break; - } - - while(!fp.eof()) { - c = fp.readByte(); - sysexBuf[syslen] = c; - syslen++; - if(c==0xf0) { - inSys = true; - } - if ((c==0xf7) && (inSys)) { - PlaySysex(&sysexBuf[0],syslen); - inSys = false; - syslen = 0; - } - } - fp.close(); - + for (int i=0;i<54;i++) { + PCMReassign[i] = i; + PCM[i].tune = 220.0f; + PCM[i].ampval = 256; } + //PCM[53].ampval = 128; - //LOG_MSG("MT-32 Initializing Drums"); - - File fDrums; - fDrums.open("drumpat.rom"); - if(!fDrums.isOpen()) { - // TODO : Fail driver init - // printf("MT-32 Init Error - Missing drumpat.rom\n"); - error("Unable to open drumpat.rom"); + char tbuf[512]; + char *cp; + if (!file->readLine(tbuf,sizeof(tbuf))) { return false; } - int drumnum=0; - while(!fDrums.eof()) { - //Read common area - fDrums.read(&drums[drumnum].common,14); - int t; - for(t=0;t<4;t++) { - if (((drums[drumnum].common.pmute >> t) & 0x1) == 0x1) { - fDrums.read(&drums[drumnum].partial[t],58); - //LOG_MSG("Loaded drum #%d - t %d", drumnum,t); + Bit32u patchstart = 0; //axtoi(tbuf); + Bit32u patchend = 0; + Bit32u patchcount = 0; + bool rc = true; + for (;;) { + if (!file->readLine(tbuf,sizeof(tbuf))) { + if (!file->isEOF()) { + rc = false; } + break; } - //LOG_MSG("Loaded drum #%d - %s", drumnum,drums[drumnum].common.name); - drumnum++; - } - fDrums.close(); - -#if DUMPDRUMS == 1 - fp.open("drumsys.syx", File::kFileWriteMode); - char dumbtext[10], tmpb; - memset(dumbtext,0,10); - for(drumnum=0;drumnum<30;drumnum++) { - // Sysex header - tmpb = 0xf0; fp.write(&tmpb,1); - tmpb = 0x41; fp.write(&tmpb,1); - tmpb = 0x10; fp.write(&tmpb,1); - tmpb = 0x16; fp.write(&tmpb,1); - tmpb = 0x12; fp.write(&tmpb,1); - - int useaddr = drumnum * 256; - char lsb = useaddr & 0x7f; - char isb = (useaddr >> 7) & 0x7f; - char msb = ((useaddr >> 14) & 0x7f) | 0x08; - //Address - fp.write(&msb, 1); - fp.write(&isb, 1); - fp.write(&lsb, 1); - unsigned int checksum = msb + isb + lsb; - - //Data - fp.write(&drums[drumnum].common,0xe); - fp.write(&drums[drumnum].partial[0],0x3a); - fp.write(&drums[drumnum].partial[1],0x3a); - fp.write(&drums[drumnum].partial[2],0x3a); - fp.write(&drums[drumnum].partial[3],0x3a); - //Checksum - char *dat = (char *)&drums[drumnum]; - int ch; - for(ch=0;ch<246;ch++) checksum += *dat++; - checksum = (checksum & 0x7f); - if(checksum) checksum = 0x80 - checksum; - - fp.write(&checksum,1); - - //End of sysex - tmpb = 0xf7; fp.write(&tmpb,1); - } - fp.close(); -#endif - - //LOG_MSG("MT-32 Initializing Partials"); - - File fPatch; - fPatch.open("patchlog.cfg"); - - if(!fPatch.isOpen()) { - // TODO : Fail driver init - // printf("MT-32 Init Error - Missing patchlog.cfg\n"); - error("Unable to open patchlog.cfg"); - return false; - } - - for(i=0;i<54;i++) { - PCMReassign[i] = i; - PCM[i].tune = 220.0; - PCM[i].ampval = 256; - - } - //PCM[53].ampval = 128; - if (!fPatch.eof()) { - char tbuf[512]; - char *cp; - fPatch.gets(tbuf,sizeof(tbuf)); - uint32 patchstart = 0; //axtoi(tbuf); - uint32 patchend = 0; - uint32 patchcount = 0; - //int16 *romaddr = &romfile[0]; - while (!fPatch.eof()) { - fPatch.gets(tbuf,sizeof(tbuf)); - cp = strtok(tbuf," \n\r"); - PCM[patchcount].loop = false; - if(cp != NULL) { - patchend = axtoi(cp); + cp = strtok(tbuf," \n\r"); + PCM[patchcount].loop = false; + if (cp != NULL) { + patchend = axtoi(cp); + cp = strtok(NULL," \n\r"); + if (cp != NULL) { cp = strtok(NULL," \n\r"); - if(cp != NULL) { + if (cp != NULL) { cp = strtok(NULL," \n\r"); - if(cp != NULL) { + if (cp !=NULL) { + int newpcm = atoi(cp); + PCMReassign[newpcm] = patchcount; cp = strtok(NULL," \n\r"); - if (cp !=NULL) { - int newpcm = atoi(cp); - PCMReassign[newpcm] = patchcount; + if (cp != NULL) { + if (atoi(cp)==1) + PCM[patchcount].loop = true; cp = strtok(NULL," \n\r"); - if(cp != NULL) { - if(atoi(cp)==1) PCM[patchcount].loop = true; - cp = strtok(NULL," \n\r"); - if(cp != NULL) { - PCM[patchcount].tune = (float)atoi(cp) / 100.0; - //LOG_MSG("PCM %d tuning at %f", patchcount, PCM[patchcount].tune); - } + if (cp != NULL) { + PCM[patchcount].tune = (float)atoi(cp) / 100.0f; + //printDebug("PCM %d tuning at %f", patchcount, PCM[patchcount].tune); } } } } } - if (patchend==0) break; - - PCM[patchcount].addr = patchstart; - PCM[patchcount].len = patchend - patchstart; - patchcount++; - //printf("Patch %d %d %d %d\n", patchcount, patchstart, patchend, mt32ram.PCM[patchcount].len); - patchstart = patchend; - } - } else { - // TODO : Fail driver init - return false; + if (patchend==0) + break; - //exit(0); + PCM[patchcount].addr = patchstart; + PCM[patchcount].len = patchend - patchstart; + patchcount++; + //printf("Patch %d %d %d %d", patchcount, patchstart, patchend, mt32ram.PCM[patchcount].len); + patchstart = patchend; } - - fPatch.close(); - + closeFile(file); + if (!rc) + return rc; PCM[53].len = 1950; - int pat = 0; - int p; - for(p=0;p<54;p++) { - int pr = PCMReassign[p]; - if(!PCM[pr].loop) { - PCMLoopTable[pat] = p; - pat++; - } - if(pat==7) { - PCMLoopTable[pat] = p; - pat++; - } - } - // These are the special combination loop patches - for(p=46;p<=54;p++) { - PCMLoopTable[pat] = -(p - 45); - pat++; - } - - //for(p=0;p<54;p++) LOG_MSG("Loop table %d = %d (%d)", p, PCMLoopTable[p], PCM[p].loop); - // Generate official PCM list // Normal sounds - pat = 0; - for(p=0;p<54;p++) { + int pat = 0; + for (int p = 0; p < 54; p++) { PCMList[pat].addr = PCM[PCMReassign[p]].addr; PCMList[pat].len = PCM[PCMReassign[p]].len; PCMList[pat].loop = PCM[PCMReassign[p]].loop; PCMList[pat].aggSound = -1; PCMList[pat].pcmnum = PCMReassign[p]; - PCMList[pat].ampval = PCM[PCMReassign[p]].ampval; pat++; } // Drum specific sounds. Not exactly sure yet how these are different - for(p=0;p<20;p++) { + for (int p = 0; p < 20; p++) { PCMList[pat] = PCMList[p]; pat++; } - + // Looped PCM sounds. The last remaining 9 are aggregate sounds; - for(p=0;p<54;p++) { - if(PCMLoopTable[p]>-1) { - PCMList[pat].addr = PCM[PCMReassign[PCMLoopTable[p]]].addr; - PCMList[pat].ampval = PCM[PCMReassign[PCMLoopTable[p]]].ampval; - PCMList[pat].len = PCM[PCMReassign[PCMLoopTable[p]]].len; - PCMList[pat].pcmnum = PCMReassign[PCMLoopTable[p]]; + // FIXME:KG: I hope this is correct; the original was heavily broken, + // and it was hard to determine the author's intention. + for (int p = 0; p < 54; p++) { + if (p < 45) { + int pcmNum = p > 7 ? p - 1 : p; + PCMList[pat].addr = PCM[PCMReassign[pcmNum]].addr; + PCMList[pat].len = PCM[PCMReassign[pcmNum]].len; + PCMList[pat].pcmnum = PCMReassign[pcmNum]; PCMList[pat].loop = true; PCMList[pat].aggSound = -1; } else { - PCMList[pat].addr = 0; - //Calculate aggregate length - int aggsnd = (-PCMLoopTable[p])-1; + int aggsnd = p - 45; int tmplen = 0; int sndpos = 0; - while(LoopPatterns[aggsnd][sndpos] != -1) { + while (LoopPatterns[aggsnd][sndpos] != -1) { tmplen += PCM[LoopPatterns[aggsnd][sndpos]].len; sndpos++; } - + PCMList[pat].addr = 0; PCMList[pat].len = tmplen; PCMList[pat].loop = true; PCMList[pat].aggSound = aggsnd; - PCMList[pat].ampval = 0x100; } pat++; - } - //for(p=0;p<128;p++) LOG_MSG("PCM #%d addr 0x%x len %d loop %d aggSound %d pcmnum %d", p, PCMList[p].addr, PCMList[p].len, PCMList[p].loop, PCMList[p].aggSound, PCMList[p].pcmnum); + //for (p=0;p<128;p++) + // printDebug("PCM #%d addr 0x%x len %d loop %d aggSound %d pcmnum %d", p, PCMList[p].addr, PCMList[p].len, PCMList[p].loop, PCMList[p].aggSound, PCMList[p].pcmnum); + return true; +} - //LOG_MSG("MT-32 Initializing ROM"); - File fIn; - fIn.open("MT32_PCM.ROM"); -#ifdef MT32OUT - File fOut, fOutb; - char tmpc; - fOut.open("mt32out.raw",File::kFileWriteMode); - fOutb.open("mt32out2.raw",File::kFileWriteMode); -#endif - - if(!fIn.isOpen()) { - // TODO : Fail driver init - // printf("MT-32 Init Error - Missing MT32_PCM.ROM\n"); - error("Unable to open MT32_PCM.ROM"); +bool Synth::loadROM(const char *filename) { + File *file = openFile(filename, File::OpenMode_read); // ROM File + if (file == NULL) { return false; } - i=0; - //int32 maxamp = 0; - while (!fIn.eof()) { - int16 s, c1; - - s = fIn.readByte(); - c1 = fIn.readByte(); - - /* - int e,z,u,bit; - - int order[16] = {0, 9,1 ,2, 3, 4, 5, 6, 7, 10, 11, 12,13, 14, 15,8}; - - e=0; - z = 15; - for(u=0;u<15;u++) { - if((order[u]<8) && (order[u]>=0)) { - bit = (s >> (7-order[u])) & 0x1; +#ifdef MT32OUT + File *outFile = openFile("mt32out.raw", File::OpenMode_write); + File *outFileB = openFile("mt32out2.raw", File::OpenMode_write); +#endif + bool rc = true; + for (int i = 0; ; i++) { + int fc = file->readByte(); + if (fc == -1) { + if (!file->isEOF()) { + rc = false; + } + break; + } + Bit16s s = (Bit16s)fc; + fc = file->readByte(); + if (fc == -1) { + if (!file->isEOF()) { + rc = false; } else { - if(order[u]>=8) { - bit = (c1 >> (7-(order[u]-8))) & 0x1; - } else { - bit = 0; - } + printDebug("ROM file has an odd number of bytes! Ignoring last"); } - e = e | (bit << z); - --z; + break; } - - //if( (e & 0x1) != 0) printf("Last bit = %d\n", e & 0x1); - //int16 e = ( ((s & 0x7f) << 4) | ((c1 & 0x40) << 6) | ((s & 0x80) << 6) | ((c1 & 0x3f))) << 2; - if(e<0) e = -32767 - e; - int ut = abs(e); - int dif = 0x7fff - ut; - x = exp(((float)((float)0x8000-(float)dif) / (float)0x1000)); - e = (int)((float)e * (x/3200));*/ + Bit16s c = (Bit16s)fc; short e; - int z; int bit; int u; - - static const int order[16] = {0, 9,1 ,2, 3, 4, 5, 6, 7, 10, 11, 12,13, 14, 15,8}; - + + int order[16] = {0, 9, 1 ,2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 8}; + e=0; - z = 15; - for(u=0;u<15;u++) { - if((order[u]<8) && (order[u]>=0)) { + for (u=0;u<15;u++) { + if (order[u]<8) bit = (s >> (7-order[u])) & 0x1; - } else { - if(order[u]>=8) { - bit = (c1 >> (7-(order[u]-8))) & 0x1; - } else { - bit = 0; - } - } - e = e | (bit << z); - --z; + else + bit = (c >> (7-(order[u]-8))) & 0x1; + e = e | (short)(bit << (15 - u)); } + /* + //Bit16s e = ( ((s & 0x7f) << 4) | ((c & 0x40) << 6) | ((s & 0x80) << 6) | ((c & 0x3f))) << 2; + if (e<0) + e = -32767 - e; + int ut = abs(e); + int dif = 0x7fff - ut; + x = exp(((float)((float)0x8000-(float)dif) / (float)0x1000)); + e = (int)((float)e * (x/3200)); + */ + #ifdef MT32OUT - tmpc = e & 0xff; fOut.write(&tmpc, 1); - tmpc = (e >> 8) & 0x7f; fOut.write(&tmpc, 1); -#endif + outFile->writeByte(e & 0xff); + outFile->writeByte(((e >> 8) & 0x7f)); +#endif // File is encoded in dB, convert to PCM // MINDB = -96 // MAXDB = -15 float testval; testval = (float)((~e) & 0x7fff); - testval = -(testval / 400.00); + testval = -(testval / 400.00f); //testval = -(testval / 341.32291666666666666666666666667); - //testval = -(testval / 400.00); - float vol = pow((float)8,(float)(testval / 20)) * 32767; - - if (e>0) vol = -vol; - - romfile[i] = (int16)vol; + float vol = powf(8,(testval / 20)) * 32767.0f; -#ifdef MT32OUT - tmpc = (int16)vol & 0xff; fOutb.write(&tmpc, 1); - tmpc = (int16)vol >> 8; fOutb.write(&tmpc, 1); -#endif + if (e>0) + vol = -vol; - i++; + romfile[i] = (Bit16s)vol; + +#ifdef MT32OUT + outFileB->writeByte(romfile[i] & 0xff); + outFileB->writeByte(romfile[i] >> 8); +#endif } - //LOG_MSG("PCM amp = %d", maxamp); #ifdef MT32OUT - fOutb.close(); - fOut.close(); + closeFile(outFileB); + closeFile(outFile); #endif - fIn.close(); - int tmp; - for(tmp=0;tmp<16;tmp++) { - if((tmp>=1) && (tmp<=9)) { - chantable[tmp] = tmp-1; - } else { - chantable[tmp] = -1; - } + closeFile(file); + return rc; +} + +bool Synth::open(SynthProperties &useProp) { + if (isOpen) + return false; + + // Initalise patch information + + myProp = useProp; + + usefilter = &iir_filter_normal; + + partialManager = new PartialManager(this); + + // This is so that names won't be garbage during early setup debug output, but we can detect bugs + memset(&mt32ram, '?', sizeof(mt32ram)); + + printDebug("Initialising patch banks"); + initmode = 0; + if (!loadPreset("Preset1.syx")) { + report(ReportType_errorPreset1, &errno); + return false; } - chantable[10] = 8; - for(i=0;i<128;i++) { - mt32ram.params.pSettings[i].timbreGroup = i >> 6; - mt32ram.params.pSettings[i].timbreNum = i & 63; + initmode = 1; + if (!loadPreset("Preset2.syx")) { + report(ReportType_errorPreset2, &errno); + return false; } + initmode = 2; - // For resetting mt32 mid-execution - memcpy(&mt32default, &mt32ram, sizeof(mt32ram)); + printDebug("Initialising Drums"); + if (!loadDrums("drumpat.rom")) { + report(ReportType_errorDrumpat, &errno); + return false; + } - if (!InitTables()) return false; - if(myProp.UseDefault) { - InitReverb(0,5,SETRATE); - } else { - InitReverb(myProp.RevType, myProp.RevTime,SETRATE); +#if DUMPDRUMS == 1 + strcpy(&pathBuf[0], baseDir); + dumpDrums(strcat(&pathBuf[0],"drumsys.syx")); +#endif + + printDebug("Initialising PCM-to-ROM map"); + if (!loadPCMToROMMap("patchlog.cfg")) { + printDebug("Init Error - Missing patchlog.cfg"); + report(ReportType_errorPatchlog, &errno); + return false; + } + + printDebug("Initialising ROM"); + if (!loadROM("MT32_PCM.ROM")) { + printDebug("Init Error - Missing MT32_PCM.ROM"); + report(ReportType_errorMT32ROM, &errno); + return false; + } + memcpy(chantable, InitChanTable, sizeof (chantable)); + for (unsigned char i = 0; i < 128; i++) { + mt32ram.params.patches[i].timbreGroup = i >> 6; + mt32ram.params.patches[i].timbreNum = i & 63; } - for(i=0;i<10;i++) { - mchan[i] = new MidiChannel(SETRATE,i); + TableInitialiser tableInitialiser; + tableInitialiser.initMT32Tables(this, PCM, (float)myProp.SampleRate); + if (myProp.UseDefault) + initReverb(0,5); + else + initReverb(myProp.RevType, myProp.RevTime); + + for (int i = 0; i < 9; i++) { + parts[i] = new Part(this, i); - if(i<8) mchan[i]->SetPatch(InitInstr[i],-1); - if(i>8) mchan[i]->SetPatch(InitInstr[i-9],-1); + if (i<8) { + // The patch is already set by the presets, now set the timbre it wants + parts[i]->setTimbre(&mt32ram.params.timbres[parts[i]->getAbsTimbreNum()].timbre); + // And refresh the part's cache + parts[i]->RefreshPatch(); + } } - activeChannels = 0; + + // For resetting mt32 mid-execution + mt32default = mt32ram; #ifdef HAVE_X86 - bool useSSE = false, use3DNow = false; + bool availableSSE = DetectSIMD(); + bool available3DNow = Detect3DNow(); + + if (availableSSE) + report(ReportType_availableSSE, NULL); + if (available3DNow) + report(ReportType_available3DNow, NULL); - use3DNow = Detect3DNow(); - useSSE = DetectSIMD(); - - if (useSSE) debug(1, "MT-32: SSE detected and enabled"); - if (use3DNow) debug(1, "MT-32: 3DNow! detected and enabled"); - - if(use3DNow) { - debug(1, "MT-32 using use SIMD (AMD 3DNow) extensions"); + if (available3DNow) { + printDebug("Detected and using SIMD (AMD 3DNow) extensions"); usefilter = &iir_filter_3dnow; + } else if (availableSSE) { + printDebug("Detected and using SIMD (Intel SSE) extensions"); + usefilter = &iir_filter_sse; } +#endif - if(useSSE) { - debug(1, "MT-32 using SIMD (Intel SSE) extensions\n"); - usefilter = &iir_filter_sse; - usingSIMD = true; +#if BENCHMARK > 1 + // Benchmark 3DNow, Floating point, and SSE filters + clock_t start, end; + float histval[50]; + + for (int bench = 0; bench < 3; bench++) { + start = clock(); + for (int benchcnt=0;benchcnt<2000000;benchcnt++) { + switch (bench) { + case 0: + iir_filter_normal(0,&histval[0],filtcoeff[0][0],0); + break; + case 1: + if (!availableSSE) { + printDebug("Skipping SSE benchmark, SSE not available"); + continue; + } + iir_filter_sse(0,&histval[0],filtcoeff[0][0],0); + break; + case 2: + if (!available3DNow) { + printDebug("Skipping 3DNow benchmark, 3DNow not available"); + continue; + } + iir_filter_3dnow(0,&histval[0],filtcoeff[0][0],0); + break; + } + } + end = clock(); + printDebug("Bench %ld completed in %ld milliseconds", bench, (end - start) * 1000 / CLOCKS_PER_SEC); } #endif isOpen=true; isEnabled=false; -#endif - + printDebug("**************** Initialisation complete ****************"); return true; -} +}; -void CSynthMT32::Close(void) { - if (!isOpen) return; +void Synth::close(void) { + if (!isOpen) + return; -#ifdef NOMANSLAND - int t, m; - for(t=0;t<4;t++) { - for(m=0;m<256;m++) { - if(waveforms[t][m]!=NULL) free(waveforms[t][m]); + for (int t = 0; t < 4; t++) { + for (int m = 0; m < 128; m++) { + if (waveforms[t][m]!=NULL) { + delete[] waveforms[t][m]; + waveforms[t][m] = NULL; + } } } + if (partialManager != NULL) { + partialManager = NULL; + delete partialManager; + } -#endif - - isOpen=false; + if (reverbModel != NULL) { + reverbModel = NULL; + delete reverbModel; + } + for (int i = 0; i < 9; i++) { + if (parts[i] != NULL) { + delete parts[i]; + parts[i] = NULL; + } + } -} + isOpen=false; +}; -void CSynthMT32::PlayMsg(uint32 msg) { +void Synth::playMsg(Bit32u msg) { + unsigned char code = (unsigned char)((msg & 0xf0) >> 4); + unsigned char chan = (unsigned char)(msg & 0xf); + unsigned char note = (unsigned char)((msg & 0xff00) >> 8); + unsigned char velocity = (unsigned char)((msg & 0xff0000) >> 16); + isEnabled = true; -#ifdef NOMANSLAND + //if (code!=0xf) printDebug("Playing chan %d, code 0x%01x note: 0x%02x", chan, code, note); - int h; - int code = msg & 0xf0; - int chan = msg & 0xf; - int note = (msg & 0xff00) >> 8; - int velocity = (msg & 0xff0000) >> 16; - isEnabled= true; - - //if(chan!=0x9) { - // if(chan==12) return; - // chan = chan & 0x7; - // - //} else { - // chan = 8; - //} - //if (chan==0) return; - //int prechan = chan; - //if(code!=0xf0) LOG_MSG("Playing chan %d, code 0x%x note: 0x%x", chan, code, note); - - chan = chantable[chan]; - //LOG_MSG("Play msg on chan: %d = %d note: %x velocity: %x", chan, msg & 0xf, note, velocity); - if(chan<0) { - //LOG_MSG("Play msg 0x%x on unreg chan: %d = %x", chan, msg & 0xf); + char part = chantable[chan]; + if (part < 0 || part > 8) { + printDebug("Play msg on unreg chan %d (%d): code=0x%01x, vel=%d", chan, part, code, velocity); return; - } - if(chan>8) return; - + playMsgOnPart(part, code, note, velocity); +} - int patch; - uint32 bend; +void Synth::playMsgOnPart(unsigned char part, unsigned char code, unsigned char note, unsigned char velocity) { + Bit32u bend; - //LOG_MSG("Midi code: 0x%x",msg); + //printDebug("Synth::playMsg(0x%02x)",msg); switch (code) { - case 0x80: - //LOG_MSG("Note OFF - Channel %d",chan); - mchan[chan]->StopNote(note,velocity); + case 0x8: + //printDebug("Note OFF - Part %d", part); + // The MT-32 ignores velocity for note off + parts[part]->StopNote(note); break; - case 0x90: - //if(chan!=4) return; - //LOG_MSG("Note ON - Channel %d, Note %d Vel %d",chan, note, velocity); - - if(velocity>0) { - mchan[chan]->PlayNote(note,velocity); + case 0x9: + //printDebug("Note ON - Part %d, Note %d Vel %d", part, note, velocity); + if (velocity == 0) { + // MIDI defines note-on with velocity 0 as being the same as note-off with velocity 40 + parts[part]->StopNote(note); } else { - mchan[chan]->StopNote(note,velocity); + parts[part]->PlayNote(partialManager, note, velocity); } - - break; - case 0xb0: // Control change + case 0xB: // Control change switch (note) { - case 0x1: // Modulation - //LOG_MSG("Modulation: %d", velocity); - mchan[chan]->SetModulation(velocity); + case 0x01: // Modulation + //printDebug("Modulation: %d", velocity); + parts[part]->SetModulation(velocity); break; - case 0xb: - //LOG_MSG("Expression set: %d", velocity); - mchan[chan]->SetVolume(velocity); + case 0x0B: + //printDebug("Expression set: %d", velocity); + parts[part]->SetVolume(velocity); break; - case 0x7: // Set volume - //if(chan!=3) return; - //LOG_MSG("Volume set: %d", velocity); - mchan[chan]->SetVolume(velocity); + case 0x07: // Set volume + //if (part!=3) return; + //printDebug("Volume set: %d", velocity); + parts[part]->SetVolume(velocity); break; - case 0xa: // Pan - mchan[chan]->SetPan(velocity); + case 0x0A: // Pan + //printDebug("Pan set: %d", velocity); + parts[part]->SetPan(velocity); break; case 0x40: // Hold pedal - if(velocity<64) { - mchan[chan]->SetHoldPedal(false); - mchan[chan]->StopPedalHold(); - } else { - mchan[chan]->SetHoldPedal(true); - } + //printDebug("Hold pedal set: %d", velocity); + parts[part]->SetHoldPedal(velocity>=64); break; - case 0x7b: // All notes off - - for(h=0;h<MAXPOLY;h++) { - mchan[chan]->StopNote(-1,0); - } + case 0x7B: // All notes off + //printDebug("All notes off"); + parts[part]->AllStop(); break; case 0x79: // Reset all controllers + printDebug("Reset all controllers (NYI)"); break; default: - //LOG_MSG("Control code: 0x%x - vel %x",note, velocity); + printDebug("Unknown MIDI Control code: 0x%02x - vel %02x",note, velocity); break; } break; - case 0xc0: // Patch setting - char currentInstr[32]; - patch = (mt32ram.params.pSettings[note].timbreGroup * 64) + mt32ram.params.pSettings[note].timbreNum; - memset(¤tInstr,0,16); - memcpy(¤tInstr,mt32ram.params.patch[patch].common.name,10); - - //LOG_MSG("Set patch (%s) %d (%d) chan %d (%d) from ng %d, t %d", currentInstr, patch, note, chan, msg & 0xf, mt32ram.params.pSettings[note].timbreGroup, mt32ram.params.pSettings[note].timbreNum); - if((chan>=0) && (chan<8)) mt32ram.params.timTemp[chan] = mt32ram.params.patch[patch]; - mchan[chan]->SetPatch(note,-1); + case 0xC: // Program change + //printDebug("Program change %01x", note); + if (part < 8) { + parts[part]->SetPatch(note); + } else { + printDebug("Program change attempted on rhythm part"); + } break; - case 0xe0: // Pitch bender + case 0xE: // Pitch bender bend = (velocity << 7) | (note); - //LOG_MSG("Pitch bender %x", bend); - mchan[chan]->SetBend(bend); + //printDebug("Pitch bender %02x", bend); + parts[part]->SetBend(bend); break; default: - //LOG_MSG("Undef Midi code: 0x%x - %x - %x",code, note, velocity); - + printDebug("Unknown Midi code: 0x%01x - %02x - %02x", code, note, velocity); break; } -#endif //midiOutShortMsg(m_out, msg); +}; + +void Synth::playSysex(Bit8u * sysex,Bit32u len) { + if (len < 3) { + printDebug("playSysex: Message is too short for sysex (%d bytes)", len); + } + if (sysex[0] != 0xf0) { + printDebug("playSysex: Message lacks start-of-sysex (0xf0)"); + return; + } + if (sysex[len - 1] != 0xf7) { + printDebug("playSysex: Message lacks end-of-sysex (0xf7)"); + return; + } + playSysexWithoutFraming(sysex + 1, len - 2); } -void CSynthMT32::PlaySysex(uint8 * sysex,uint32 len) { +void Synth::playSysexWithoutFraming(Bit8u * sysex, Bit32u len) { + if (len < 4) { + printDebug("playSysexWithoutFraming: Message is too short (%d bytes)!", len); + return; + } + if (sysex[0] != 0x41) { + printDebug("playSysexWithoutFraming: Header not intended for this device manufacturer: %02x %02x %02x %02x", (int)sysex[0], (int)sysex[1], (int)sysex[2], (int)sysex[3]); + return; + } + if (sysex[2] == 0x14) { + printDebug("playSysexWithoutFraming: Header is intended for Roland D-50 (not yet supported): %02x %02x %02x %02x", (int)sysex[0], (int)sysex[1], (int)sysex[2], (int)sysex[3]); + return; + } + else if (sysex[2] != 0x16) { + printDebug("playSysexWithoutFraming: Header not intended for MT-32: %02x %02x %02x %02x", (int)sysex[0], (int)sysex[1], (int)sysex[2], (int)sysex[3]); + return; + } + if (sysex[3] != 0x12) { + printDebug("playSysexWithoutFraming: Unsupported command %02x", sysex[3]); + return; + } + playSysexWithoutHeader(sysex[1], sysex + 4, len - 4); +} -#ifdef NOMANSLAND +// MEMADDR() converts from sysex-padded, SYSEXMEMADDR converts to it +// Roland provides documentation using the sysex-padded addresses, so we tend to use that int code and output +#define MEMADDR(x) ((((x) & 0x7f0000) >> 2) | (((x) & 0x7f00) >> 1) | ((x) & 0x7f)) +#define SYSEXMEMADDR(x) ((((x) & 0x1FC000) << 2) | (((x) & 0x3F80) << 1) | ((x) & 0x7f)) - uint32 addr; - uint32 *header; - unsigned int off; - int m; - header = (uint32 *)(sysex+1); - //int dummy = 0; - int32 lens = len; +#define NUMTOUCHED(x,y) (((x) + sizeof(y) - 1) / sizeof(y)) - // HACK: For some reason commands in IMuseInternal::initMT32 do not have prefix byte - // Also in some cases, particularly in mi2 "glop" sound at difficulty select screen - // header is wrong. I don't know what causes this as original has neither of these - // problems. - if((READ_BE_UINT32(header) != 0x41101612) || (READ_BE_UINT32(header) == 0x41001612)) { - if((READ_LE_UINT32(sysex) == 0x41101612) || (READ_BE_UINT32(sysex) == 0x41001612)) { - header = (uint32 *)sysex; - sysex--; // We don't access sysex[0], so it's safe - } +void Synth::playSysexWithoutHeader(unsigned char device, Bit8u *sysex, Bit32u len) { + if (device > 0x10) { + // We have device ID 0x10 (default, but changeable, on real MT-32), < 0x10 is for channels + printDebug("playSysexWithoutHeader: Message is not intended for this device ID (provided: %02x, expected: 0x10 or channel)", (int)device); + return; } - - if(READ_BE_UINT32(header) == 0x41101612) { - addr = (sysex[5] << 16) | (sysex[6] << 8) | (sysex[7]); - //LOG_MSG("Sysex addr: %x", addr); - if (addr<0x30000) { - //LOG_MSG("Channel temp area %x", addr); - } - if ((addr>=0x30000) && (addr<0x40000)) { - off = ((addr & 0x7f00) >> 1) | (addr & 0xff); - for(m=0;m<(lens-10);m++) { - mt32ram.memabs.mt32memory[off+m] = sysex[8+m]; + if (len < 4) { + printDebug("playSysexWithoutHeader: Message is too short (%d bytes)!", len); + return; + } + unsigned char checksum = calcChecksum(sysex, len - 1, 0); + if (checksum != sysex[len - 1]) { + printDebug("playSysexWithoutHeader: Message checksum is incorrect (provided: %02x, expected: %02x)!", sysex[len - 1], checksum); + return; + } + len -= 1; // Exclude checksum + Bit32u addr = (sysex[0] << 16) | (sysex[1] << 8) | (sysex[2]); + addr = MEMADDR(addr); + sysex += 3; + len -= 3; + printDebug("Sysex addr: 0x%06x", SYSEXMEMADDR(addr)); + // NOTE: Please keep both lower and upper bounds in each check, for ease of reading + if (device < 0x10) { + printDebug("WRITE-CHANNEL: Channel %d temp area 0x%06x", device, SYSEXMEMADDR(addr)); + if (/*addr >= MEMADDR(0x000000) && */addr < MEMADDR(0x010000)) { + int offset; + if (chantable[device] == -1) { + printDebug(" (Channel not mapped to a partial... 0 offset)"); + offset = 0; + } else if (chantable[device] == 8) { + printDebug(" (Channel mapped to rhythm... 0 offset)"); + offset = 0; + } else { + offset = chantable[device] * sizeof(MemParams::PatchTemp); + printDebug(" (Setting extra offset to %d)", offset); + } + addr += MEMADDR(0x030000) + offset; + } else if (/*addr >= 0x010000 && */ addr < MEMADDR(0x020000)) { + addr += MEMADDR(0x030110) - MEMADDR(0x010000); + } else if (/*addr >= 0x020000 && */ addr < MEMADDR(0x030000)) { + int offset; + if (chantable[device] == -1) { + printDebug(" (Channel not mapped to a partial... 0 offset)"); + offset = 0; + } else if (chantable[device] == 8) { + printDebug(" (Channel mapped to rhythm... 0 offset)"); + offset = 0; + } else { + offset = chantable[device] * sizeof(TimbreParam); + printDebug(" (Setting extra offset to %d)", offset); } - //LOG_MSG("Patch temp %d at %x - len %d", off/16, off % 16, len-10); - - if(initmode>1) { - for(m=0;m<8;m++) { - int tmppat; - for(tmppat=0;tmppat<128;tmppat++) { - if(mt32ram.params.pSettings[tmppat].timbreGroup == mt32ram.params.tmpSettings[m].timbreGroup) { - if(mt32ram.params.pSettings[tmppat].timbreNum == mt32ram.params.tmpSettings[m].timbreNum) { - //LOG_MSG("Setting %d to patch %d", m, tmppat); - this->PlayMsg((tmppat << 8) | 0xc0 | m); - - break; - } - } + addr += MEMADDR(0x040000) - MEMADDR(0x020000) + offset; + } else { + printDebug("PlaySysexWithoutHeader: Invalid channel %d address 0x%06x", device, SYSEXMEMADDR(addr)); + return; + } + } + if (addr >= MEMADDR(0x030000) && addr < MEMADDR(0x030110)) { + int off = addr - MEMADDR(0x030000); + if (off + len > sizeof(mt32ram.banks.pTemp)) { + printDebug("playSysexWithoutHeader: Message goes beyond bounds of memory region (addr=0x%06x, len=%d)!", SYSEXMEMADDR(addr), len); + return; + } + int firstPart = off / sizeof(MemParams::PatchTemp); + off %= sizeof(MemParams::PatchTemp); + for (unsigned int m = 0; m < len; m++) + mt32ram.banks.pTemp[firstPart][off + m] = sysex[m]; + //printDebug("Patch temp: Patch %d, offset %x, len %d", off/16, off % 16, len); + + int lastPart = firstPart + NUMTOUCHED(off + len, MemParams::PatchTemp) - 1; + for (int i = firstPart; i <= lastPart; i++) { + int absTimbreNum = mt32ram.params.patchSettings[i].patch.timbreGroup * 64 + mt32ram.params.patchSettings[i].patch.timbreNum; + char timbreName[11]; + memcpy(timbreName, mt32ram.params.timbres[absTimbreNum].timbre.common.name, 10); + timbreName[10] = 0; + printDebug("WRITE-PARTPATCH (%d-%d@%d..%d): %d; timbre=%d (%s)", firstPart, lastPart, off, off + len, i, absTimbreNum, timbreName); + if (parts[i] != NULL) { + parts[i]->setTimbre(&mt32ram.params.timbres[parts[i]->getAbsTimbreNum()].timbre); + parts[i]->RefreshPatch(); + } + } + } else if (addr >= MEMADDR(0x030110) && addr < MEMADDR(0x040000)) { + int off = addr - MEMADDR(0x030110); + if (off + len > sizeof(mt32ram.banks.rTemp)) { + printDebug("playSysexWithoutHeader: Message goes beyond bounds of memory region (addr=0x%06x, len=%d)!", SYSEXMEMADDR(addr), len); + return; + } + int firstDrum = off / sizeof(MemParams::RhythmTemp); + off %= sizeof(MemParams::RhythmTemp); + for (unsigned int m = 0; m < len; m++) + mt32ram.banks.rTemp[firstDrum][off + m] = sysex[m]; + int lastDrum = firstDrum + NUMTOUCHED(off + len, MemParams::RhythmTemp) - 1; + for (int i = firstDrum; i <= lastDrum; i++) { + int timbreNum = mt32ram.params.rhythmSettings[i].timbre; + char timbreName[11]; + if (timbreNum < 94) { + memcpy(timbreName, mt32ram.params.timbres[128 + timbreNum].timbre.common.name, 10); + timbreName[10] = 0; + } else { + strcpy(timbreName, "[None]"); + } + printDebug("WRITE-RHYTHM (%d-%d@%d..%d): %d; level=%02x, panpot=%02x, reverb=%02x, timbre=%d (%s)", firstDrum, lastDrum, off, off + len, i, mt32ram.params.rhythmSettings[i].outlevel, mt32ram.params.rhythmSettings[i].panpot, mt32ram.params.rhythmSettings[i].reverbSwitch, mt32ram.params.rhythmSettings[i].timbre, timbreName); + } + if (parts[8] != NULL) { + parts[8]->RefreshDrumCache(); + } + } else if (addr >= MEMADDR(0x040000) && addr < MEMADDR(0x050000)) { + int off = addr - MEMADDR(0x040000); + if (off + len > sizeof(mt32ram.banks.tTemp)) { + printDebug("playSysexWithoutHeader: Message goes beyond bounds of memory region (addr=0x%06x, len=%d)!", SYSEXMEMADDR(addr), len); + return; + } + int firstPart = off / sizeof(TimbreParam); + off %= sizeof(TimbreParam); + for (unsigned int m = 0; m < len; m++) + mt32ram.banks.tTemp[firstPart][off + m] = sysex[m]; + int lastPart = firstPart + NUMTOUCHED(off + len, TimbreParam) - 1; + for (int i = firstPart; i <= lastPart; i++) { + char instrumentName[11]; + memcpy(instrumentName, mt32ram.params.timbreSettings[i].common.name, 10); + instrumentName[10] = 0; + printDebug("WRITE-PARTTIMBRE (%d-%d@%d..%d): timbre=%d (%s)", firstPart, lastPart, off, off + len, i, instrumentName); + if (parts[i] != NULL) { + parts[i]->RefreshPatch(); + } + } + } + else if (addr >= MEMADDR(0x050000) && addr < MEMADDR(0x060000)) { + int off = addr - MEMADDR(0x050000); + if (off + len > sizeof(mt32ram.banks.patchBank)) { + printDebug("playSysexWithoutHeader: Message goes beyond bounds of memory region (addr=0x%06x, len=%d)!", SYSEXMEMADDR(addr), len); + return; + } + int firstPatch = off / sizeof(PatchParam); + off %= sizeof(PatchParam); + for (unsigned int m = 0; m < len; m++) + mt32ram.banks.patchBank[firstPatch][off + m] = sysex[m]; + int lastPatch = firstPatch + NUMTOUCHED(off + len, PatchParam) - 1; + for (int i = firstPatch; i <= lastPatch; i++) { + PatchParam *patch = &mt32ram.params.patches[i]; + int patchAbsTimbreNum = patch->timbreGroup * 64 + patch->timbreNum; + char instrumentName[11]; + memcpy(instrumentName, mt32ram.params.timbres[patchAbsTimbreNum].timbre.common.name, 10); + instrumentName[10] = 0; + printDebug("WRITE-PATCH (%d-%d@%d..%d): %d; timbre=%d (%s)", firstPatch, lastPatch, off, off + len, i, patchAbsTimbreNum, instrumentName); + // FIXME:KG: The below is definitely dodgy. We just guess that this is the patch that the part was using + // based on a timbre match (but many patches could have the same timbre!) + // If this refresh is really correct, we should store the patch number in use by each part. + /* + for (int part = 0; part < 8; part++) { + if (parts[part] != NULL) { + int partPatchAbsTimbreNum = mt32ram.params.patchSettings[part].patch.timbreGroup * 64 + mt32ram.params.patchSettings[part].patch.timbreNum; + if (partPatchAbsTimbreNum == patchAbsTimbreNum) { + parts[part]->setPatch(patch); + parts[part]->RefreshPatch(); } - //LOG_MSG("Patch chan %d - Assign mode %d", m,mt32ram.params.tmpSettings[m].fineTune); } } + */ } - if ((addr>=0x40000) && (addr<0x50000)) { - int toffat = sizeof(mt32ram.patchabs.pTemp) + sizeof(mt32ram.patchabs.rTemp); - off = ((addr & 0x7f00) >> 1) | (addr & 0x7f); - for(m=0;m<(lens-10);m++) { - mt32ram.memabs.mt32memory[off+m+toffat] = sysex[8+m]; - } - int chanoff = off / sizeof(timbreParam); - - //LOG_MSG("Timbre temp off %x offdiv %x - len %d", off, chanoff, len-10); - if(mchan[chanoff]!=NULL) mchan[chanoff]->RefreshPatch(); - } - - if ((addr>=0x50000) && (addr<0x60000)) { - off = (((addr & 0x7f00) >> 1) | (addr & 0xff)) + sizeof(mt32ram.patchabs.pTemp) + sizeof(mt32ram.patchabs.rTemp) + sizeof(mt32ram.patchabs.tTemp); - - for(m=0;m<(lens-10);m++) { - mt32ram.memabs.mt32memory[off+m] = sysex[8+m]; - } - //LOG_MSG("Patch area %d, assigning to %d, patch %d - len %d", off/16, mt32ram.params.pSettings[off/16].timbreGroup, mt32ram.params.pSettings[off/16].timbreNum, len-10); + } else if (addr >= MEMADDR(0x080000) && addr < MEMADDR(0x090000)) { + // Timbre patches + int off = addr - MEMADDR(0x080000); + if (off + len > sizeof(MemParams::PaddedTimbre) * 64) { + // You can only write to one group at a time + printDebug("playSysexWithoutHeader: Message goes beyond bounds of memory region (addr=0x%06x, len=%d)!", SYSEXMEMADDR(addr), len); + return; } - if ((addr>=0x80000) && (addr<0x90000)) { - // Timbre patches - int tc = (addr & 0xfe00) >> 9; - off = ((addr & 0x100) >> 1) | (addr & 0xff); - int calcoff; - int pn=0; - - switch(initmode) { + unsigned int firstTimbre = off / sizeof (MemParams::PaddedTimbre); + off %= sizeof (MemParams::PaddedTimbre); + switch (initmode) { case 0: - calcoff = tc * sizeof(timbreParam); - pn = tc; + // Write into first built-in timbre group break; case 1: - calcoff = (tc+ 64) * sizeof(timbreParam); - pn = tc + 64; + // Write into second built-in timbre group + firstTimbre += 64; break; default: - calcoff = (tc + 128) * sizeof(timbreParam); - pn = tc + 128; - break; - } - - // Transfer sysex parameter data into MT-32 memory - calcoff += (off + sizeof(mt32ram.patchabs.pTemp) + sizeof(mt32ram.patchabs.rTemp) + sizeof(mt32ram.patchabs.tTemp) + sizeof(mt32ram.patchabs.patchmemory)); - for(m=0;m<(lens-10);m++) { - mt32ram.memabs.mt32memory[calcoff+m] = sysex[8+m]; + firstTimbre += 128; + // Write into user timbre group + } + for (unsigned int m = 0; m < len; m++) + mt32ram.banks.timbreBank[firstTimbre][off + m] = sysex[m]; + unsigned int lastTimbre = firstTimbre + NUMTOUCHED(len + off, MemParams::PaddedTimbre) - 1; + for (unsigned int i = firstTimbre; i <= lastTimbre; i++) { + char instrumentName[11]; + memcpy(instrumentName, mt32ram.params.timbres[i].timbre.common.name, 10); + instrumentName[10] = 0; + printDebug("WRITE-TIMBRE (%d-%d@%d..%d): %d; name=\"%s\"", firstTimbre, lastTimbre, off, off + len, i, instrumentName); + // FIXME:KG: Not sure if the stuff below should be done (for rhythm and/or parts)... + // Does the real MT-32 automatically do this? + if (i >= 128 && parts[8] != NULL) { + // FIXME:KG: Only bother to re-cache when this timbre's actually in the rhythm map + parts[8]->SetPatch(i); // Re-cache this timbre + } + for (unsigned int part = 0; part < 8; part++) { + if (parts[part] != NULL) { + if (parts[part]->getAbsTimbreNum() == i) { + parts[part]->RefreshPatch(); + } + } } - //LOG_MSG("Loaded patch %s at pn %d", mt32ram.params.patch[pn].common.name, pn); } - if ((addr>=0x100000) && (addr<=0x1fffff)) { - off = ((addr & 0x100) >> 1) | (addr & 0xff); - for(m=0;m<(lens-10);m++) { - mt32ram.patchabs.systemBank[m+off] = sysex[8+m]; - } - - //LOG_MSG("System Reconfiguration:"); - memset(chantable,-1,sizeof(chantable)); - memset(miditable,-1,sizeof(miditable)); + } else if (addr >= MEMADDR(0x100000) && addr < MEMADDR(0x200000)) { + int off = addr - MEMADDR(0x100000); + if (off + len > sizeof(mt32ram.banks.systemBank)) { + printDebug("playSysexWithoutHeader: Message goes beyond bounds of memory region (addr=0x%06x, len=%d)!", SYSEXMEMADDR(addr), len); + return; + } + for (unsigned int m = 0; m < len; m++) + mt32ram.banks.systemBank[m + off] = sysex[m]; - for(m=0;m<9;m++) { - //LOG_MSG("Channel %d set to MIDI channel %d",m,mt32ram.params.system.chanAssign[m]); - if(mt32ram.params.system.chanAssign[m]==16) { - mchan[m]->AllStop(); - } else { - chantable[(int)mt32ram.params.system.chanAssign[m]]=m; - miditable[m] = mt32ram.params.system.chanAssign[m]; - } - } + report(ReportType_devReconfig, NULL); - //LOG_MSG("Master Tune: %f", ((float)mt32ram.params.system.masterTune)*0.2+432.1); - //LOG_MSG("Reverb mode: %d", mt32ram.params.system.reverbMode); - //LOG_MSG("Reverb time: %d", mt32ram.params.system.reverbTime); - //LOG_MSG("Reverb level: %d", mt32ram.params.system.reverbLevel); - - if(((uint32)mt32ram.params.system.reverbMode != curRevMode) || ((uint32)mt32ram.params.system.reverbTime!=curRevTime)) { - if(myProp.UseDefault) { - InitReverb(mt32ram.params.system.reverbMode, mt32ram.params.system.reverbTime,SETRATE); - curRevLevel = mt32ram.params.system.reverbLevel; - } else { - InitReverb(myProp.RevType, myProp.RevTime,SETRATE); - curRevLevel = myProp.RevLevel; - } - } + printDebug("System Reconfiguration:"); + memset(chantable,-1,sizeof(chantable)); - - char *rset = mt32ram.params.system.reserveSettings; - //LOG_MSG("Partial reserve: 1=%d 2=%d 3=%d 4=%d 5=%d 6=%d 7=%d 8=%d 9=%d", rset[0], rset[1], rset[2], rset[3], rset[4], rset[5], rset[6], rset[7], rset[8]); - int x,y,pr; - pr = 0; - for(x=0;x<9;x++) { - for(y=0;y<rset[x];y++) { - PartialReserveTable[pr] = x; - pr++; - } + for (unsigned int i = 0; i < 9; i++) { + //LOG(LOG_MISC|LOG_ERROR,"Part %d set to MIDI channel %d",i,mt32ram.params.system.chanAssign[i]); + if (mt32ram.params.system.chanAssign[i] == 16) { + parts[i]->AllStop(); + } else { + chantable[(int)mt32ram.params.system.chanAssign[i]] = (char)i; } - //if(pr != 32) LOG_MSG("Partial Reserve Table with less than 32 partials reserved!"); - rset = mt32ram.params.system.chanAssign; - //LOG_MSG("Chan assign: 1=%d 2=%d 3=%d 4=%d 5=%d 6=%d 7=%d 8=%d 9=%d", rset[0], rset[1], rset[2], rset[3], rset[4], rset[5], rset[6], rset[7], rset[8]); - //LOG_MSG("Master volume: %d",mt32ram.params.system.masterVol); - int16 tv = (int16)((float)mt32ram.params.system.masterVol * 327.0); - mastervolume = tv; - - } - if (addr==0x200000) { - char buf[SYSEX_SIZE]; - memset(&buf,0,SYSEX_SIZE); - memcpy(&buf,&sysex[8],lens-10); - //LOG_MSG("MT-32 LCD Display: %s", buf); - g_system->displayMessageOnOSD(buf); - } - if ((addr & 0xff0000) == 0x7f0000) { - //LOG_MSG("MT-32 Reset"); - for (uint32 m1=0;m1<MAXPARTIALS;m1++) partTable[m1]->isActive = false; - - memcpy(&mt32ram, &mt32default, sizeof(mt32ram)); - isEnabled = false; } + printDebug(" Master Tune: %f", ((float)mt32ram.params.system.masterTune)*0.2+432.1); + printDebug(" Reverb: mode=%d, time=%d, level=%d", mt32ram.params.system.reverbMode, mt32ram.params.system.reverbTime, mt32ram.params.system.reverbLevel); + report(ReportType_newReverbMode, &mt32ram.params.system.reverbMode); + report(ReportType_newReverbTime, &mt32ram.params.system.reverbTime); + report(ReportType_newReverbLevel, &mt32ram.params.system.reverbLevel); + if ((mt32ram.params.system.reverbMode != curRevMode) || (mt32ram.params.system.reverbTime != curRevTime)) { + if (myProp.UseDefault) { + initReverb(mt32ram.params.system.reverbMode, mt32ram.params.system.reverbTime); + curRevLevel = mt32ram.params.system.reverbLevel; + } else { + initReverb(myProp.RevType, myProp.RevTime); + curRevLevel = myProp.RevLevel; + } + } + + char *rset = mt32ram.params.system.reserveSettings; + printDebug(" Partial reserve: 1=%02d 2=%02d 3=%02d 4=%02d 5=%02d 6=%02d 7=%02d 8=%02d Rhythm=%02d", rset[0], rset[1], rset[2], rset[3], rset[4], rset[5], rset[6], rset[7], rset[8]); + int pr = partialManager->SetReserve(rset); + if (pr != 32) + printDebug(" (Partial Reserve Table with less than 32 partials reserved!)"); + rset = mt32ram.params.system.chanAssign; + printDebug(" Part assign: 1=%02d 2=%02d 3=%02d 4=%02d 5=%02d 6=%02d 7=%02d 8=%02d Rhythm=%02d", rset[0], rset[1], rset[2], rset[3], rset[4], rset[5], rset[6], rset[7], rset[8]); + printDebug(" Master volume: %d", mt32ram.params.system.masterVol); + mastervolume = (Bit16s)((float)mt32ram.params.system.masterVol * 327.0); + } else if (addr == MEMADDR(0x200000)) { + char buf[SYSEX_SIZE]; + memset(&buf, 0, SYSEX_SIZE); + memcpy(&buf, &sysex[0], len); + printDebug("LCD Display: %s", buf); + report(ReportType_lcdMessage, buf); + } else if (addr >= MEMADDR(0x7f0000)) { + printDebug("Reset"); + report(ReportType_devReset, NULL); + partialManager->DeactivateAll(); + mt32ram = mt32default; + for (int i = 0; i < 8; i++) { + parts[i]->RefreshPatch(); + } + parts[8]->RefreshDrumCache(); + isEnabled = false; } else { - // Header not intended for Roland MT-32 + printDebug("Sysex write to unrecognised address %06x", SYSEXMEMADDR(addr)); } +}; -#endif - -} - - -int CSynthMT32::DumpSysex(char *filename) { - File fp; - byte tmpc; - fp.open(filename,File::kFileWriteMode); - if(!fp.isOpen()) +int Synth::dumpSysex(char *filename) { + File *file = openFile(filename, File::OpenMode_write); + if (file == NULL) return -1; - + int patchnum; - for(patchnum=0;patchnum<64;patchnum++) { + for (patchnum=0;patchnum<64;patchnum++) { // Sysex header - tmpc = 0xf0; fp.write(&tmpc, 1); - tmpc = 0x41; fp.write(&tmpc, 1); - tmpc = 0x10; fp.write(&tmpc, 1); - tmpc = 0x16; fp.write(&tmpc, 1); - tmpc = 0x12; fp.write(&tmpc, 1); - + if (!file->writeByte(0xF0)) + break; + if (!file->writeByte(0x41)) + break; + if (!file->writeByte(0x10)) + break; + if (!file->writeByte(0x16)) + break; + if (!file->writeByte(0x12)) + break; + int useaddr = patchnum * 256; - char lsb = useaddr & 0x7f; - char isb = (useaddr >> 7) & 0x7f; - char msb = ((useaddr >> 14) & 0x7f) | 0x08; + char lsb = (char)(useaddr & 0x7f); + char isb = (char)((useaddr >> 7) & 0x7f); + char msb = (char)(((useaddr >> 14) & 0x7f) | 0x08); //Address - fp.write(&msb, 1); - fp.write(&isb, 1); - fp.write(&lsb, 1); - unsigned int checksum = msb + isb + lsb; - + if (!file->writeByte(msb)) + break; + if (!file->writeByte(isb)) + break; + if (!file->writeByte(lsb)) + break; + //Data - fp.write(&mt32ram.params.patch[patchnum+128].common,0xe); - fp.write(&mt32ram.params.patch[patchnum+128].partial[0],0x3a); - fp.write(&mt32ram.params.patch[patchnum+128].partial[1],0x3a); - fp.write(&mt32ram.params.patch[patchnum+128].partial[2],0x3a); - fp.write(&mt32ram.params.patch[patchnum+128].partial[3],0x3a); + if (file->write(&mt32ram.params.timbres[patchnum + 128].timbre.common,0xE) != 0xE) + break; + if (file->write(&mt32ram.params.timbres[patchnum + 128].timbre.partial[0],0x3A) != 0x3A) + break; + if (file->write(&mt32ram.params.timbres[patchnum + 128].timbre.partial[1],0x3A) != 0x3A) + break; + if (file->write(&mt32ram.params.timbres[patchnum + 128].timbre.partial[2],0x3A) != 0x3A) + break; + if (file->write(&mt32ram.params.timbres[patchnum + 128].timbre.partial[3],0x3A) != 0x3A) + break; //Checksum - char *dat = (char *)&mt32ram.params.patch[patchnum+128]; - int ch; - for(ch=0;ch<246;ch++) checksum += *dat++; - checksum = (checksum & 0x7f); - if(checksum) checksum = 0x80 - checksum; - - fp.write(&checksum,1); - + unsigned char *dat = (unsigned char *)&mt32ram.params.timbres[patchnum + 128].timbre; + unsigned char checksum = calcChecksum(dat, 246, msb + isb + lsb); + + if (!file->writeByte(checksum)) + break; + //End of sysex - tmpc = 0xf7; fp.write(&tmpc, 1); + if (!file->writeByte(0xF7)) + break; } - fp.close(); - //LOG_MSG("Wrote temp patches to %s", usefile); - + closeFile(file); + printDebug("Wrote temp patches to %s", filename); return 0; } - - -static int16 tmpBuffer[4096]; -static float sndbufl[4096]; -static float sndbufr[4096]; -static float outbufl[4096]; -static float outbufr[4096]; - -#if USE_MMX == 3 -static float multFactor[4] = { 32767.0, 32767.0, 32767.0, 32767.0 }; +void ProduceOutput1(Bit16s *useBuf, Bit16s *stream, Bit32u len, Bit16s volume) { +#if USE_MMX > 2 + //FIXME:KG: This appears to introduce crackle + int donelen = i386_produceOutput1(useBuf, stream, len, volume); + len -= donelen; + stream += donelen * 2; + useBuf += donelen * 2; #endif - -void CSynthMT32::MT32_CallBack(uint8 * stream,uint32 len, int volume) { - -#ifdef NOMANSLAND - int32 i,m; - int16 *snd, *useBuf; - uint32 outlen; - snd = (int16 *)stream; - memset(stream,0,len*4); - if(!isEnabled) return; - useBuf = snd; - - outlen = len; - - assert(len < 1024); // tmpBuffer is 4096 bytes - /* - partUsage outUsage; - for(i=0;i<32;i++) { - if(partTable[i]->isActive) { - outUsage.active[i] = -1; - } else { - outUsage.active[i] = 0; - } - outUsage.owner[i] = partTable[i]->ownerChan; - outUsage.assign[i] = PartialReserveTable[i]; + int end = len * 2; + while (end--) { + *stream = *stream + (Bit16s)(((Bit32s)*useBuf++ * (Bit32s)volume)>>15); + stream++; } - fwrite(&outUsage,sizeof(outUsage),1,pInfo);*/ - - for(i=0;i<MAXPARTIALS;i++) partTable[i]->age++; +} - for(i=0;i<MAXPARTIALS;i++) { +void Synth::render(Bit16s *stream, Bit32u len) { + memset(stream, 0, len * sizeof (Bit16s) * 2); + if (!isEnabled) + return; + while (len > 0) { + Bit32u thisLen = len > MAX_SAMPLE_OUTPUT ? MAX_SAMPLE_OUTPUT : len; + doRender(stream, thisLen); + len -= thisLen; + stream += 2 * thisLen; + } +} - if(partTable[i]->produceOutput(tmpBuffer,outlen)==true) { -#if USE_MMX == 0 - int16 *tmpoff = snd; - int q = 0; - for(m=0;m<(int32)outlen;m++) { - tmpoff[q] += (int16)(((int32)tmpBuffer[q] * (int32)mastervolume)>>15); - q++; - tmpoff[q] += (int16)(((int32)tmpBuffer[q] * (int32)mastervolume)>>15); - q++; +void Synth::doRender(Bit16s * stream,Bit32u len) { + Bit32u m; - } -#else - int tmplen = (outlen >> 1) + 4; -#ifdef I_ASM - __asm { - mov ecx, tmplen - mov ax,mastervolume - shl eax,16 - mov ax,mastervolume - movd mm3,eax - movd mm2,eax - psllq mm3, 32 - por mm3,mm2 - mov esi, useBuf - mov edi, snd -mixloop4: - movq mm1, [esi] - movq mm2, [edi] - pmulhw mm1, mm3 - paddw mm1,mm2 - movq [edi], mm1 - - add esi,8 - add edi,8 + partialManager->AgeAll(); - dec ecx - cmp ecx,0 - jg mixloop4 - emms + if (myProp.UseReverb) { + bool hasOutput = false; + for (unsigned int i = 0; i < MAXPARTIALS; i++) { + if (partialManager->shouldReverb(i)) { + if (partialManager->ProduceOutput(i, &tmpBuffer[0], len)) { + ProduceOutput1(&tmpBuffer[0], stream, len, mastervolume); + hasOutput = true; + } } -#else - atti386_produceOutput1(tmplen, mastervolume, useBuf, snd); -#endif -#endif } - } - - if(myProp.UseReverb) { -#if USE_MMX == 3 - if(!usingSIMD) { -#endif + // No point in doing reverb on a mute buffer... + if (hasOutput) { m=0; - for(i=0;i<(int32)len;i++) { - sndbufl[i] = (float)snd[m] / 32767.0; + for (unsigned int i = 0; i < len; i++) { + sndbufl[i] = (float)stream[m] / 32767.0f; m++; - sndbufr[i] = (float)snd[m] / 32767.0; + sndbufr[i] = (float)stream[m] / 32767.0f; m++; } - newReverb->processreplace(sndbufl, sndbufr, outbufl, outbufr, len, 1); + reverbModel->processreplace(sndbufl, sndbufr, outbufl, outbufr, len, 1); m=0; - for(i=0;i<(int32)len;i++) { - snd[m] = (int16)(outbufl[i] * 32767.0); + for (unsigned int i = 0; i < len; i++) { + stream[m] = (Bit16s)(outbufl[i] * 32767.0f); m++; - snd[m] = (int16)(outbufr[i] * 32767.0); + stream[m] = (Bit16s)(outbufr[i] * 32767.0f); m++; } -#if USE_MMX == 3 - } else { -#ifdef I_ASM - // Use SIMD instructions to quickly convert between integer and floating point - __asm { - mov ecx, len - shr ecx, 1 - add ecx, 4 - push ecx - - mov esi, multFactor - movups xmm1, [esi] - - // One speaker at a time - mov esi, snd - mov edi, sndbufl - -convloop1: - xor eax,eax - mov ax,[snd] - cwde // Sign extended ax - inc snd - inc snd - movd mm1,eax - psrlq mm1, 32 - mov ax,[snd] - inc snd - inc snd - movd mm2,eax - por mm1,mm2 - - dec ecx - jnz convloop1 - - pop ecx - mov esi, snd - mov edi, sndbufr - inc esi -convloop2: - - dec ecx - jnz convloop2 - - } -#else - atti386_produceOutput2(len, snd, sndbufl, sndbufr, multFactor); -#endif } -#endif - } - - // for(i=0;i<9;i++) { mchan[i]->CheckNoteList(); } - - for(i=0;i<MAXPARTIALS;i++) { partTable[i]->alreadyOutputed = false; } - - -#if MAXPARTIALS == 0 - // Reorganize partials - CPartialMT32 *tmpPartial; - int y; -resetSearch: - for(i=0;i<MAXPARTIALS;i++) { - // Try to relocate partials not assigned to the right channel - if((partTable[i]->isActive) && (partTable[i]->ownerChan != PartialReserveTable[i])) { - for(y=0;y<MAXPARTIALS;y++) { - if((!partTable[y]->isActive) && (PartialReserveTable[y] == partTable[i]->ownerChan)) { - // Found a free channel that can use this partial - swap it out - tmpPartial = partTable[y]; - partTable[y] = partTable[i]; - partTable[i] = tmpPartial; - goto resetSearch; + for (unsigned int i = 0; i < MAXPARTIALS; i++) { + if (!partialManager->shouldReverb(i)) { + if (partialManager->ProduceOutput(i, &tmpBuffer[0], len)) { + ProduceOutput1(&tmpBuffer[0], stream, len, mastervolume); } } } + } else { + for (unsigned int i = 0; i < MAXPARTIALS; i++) { + if (partialManager->ProduceOutput(i, &tmpBuffer[0], len)) + ProduceOutput1(&tmpBuffer[0], stream, len, mastervolume); + } } -#endif + + partialManager->ClearAlreadyOutputed(); #if MONITORPARTIALS == 1 - samplepos+=outlen; - if(samplepos>SETRATE*5) { + samplepos += len; + if (samplepos > myProp.SampleRate * 5) { samplepos = 0; - int partUse[9]; - memset(partUse,0,sizeof(partUse)); - for(i=0;i<MAXPARTIALS;i++) { - if(partTable[i]->isActive) partUse[partTable[i]->ownerChan]++; - } - //LOG_MSG("C1: %d C2: %d C3: %d C4 %d", partUse[0], partUse[1], partUse[2], partUse[3]); - //LOG_MSG("C5: %d C6: %d C7: %d C8 %d", partUse[4], partUse[5], partUse[6], partUse[7]); - //LOG_MSG("Rythmn: %d", partUse[8]); - + int partialUsage[9]; + partialManager->GetPerPartPartialUsage(partialUsage); + printDebug("1:%02d 2:%02d 3:%02d 4:%02d 5:%02d 6:%02d 7:%02d 8:%02d", partialUsage[0], partialUsage[1], partialUsage[2], partialUsage[3], partialUsage[4], partialUsage[5], partialUsage[6], partialUsage[7]); + printDebug("Rhythm: %02d TOTAL: %02d", partialUsage[8], MAXPARTIALS - partialManager->GetFreePartialCount()); } - #endif - - -#endif - +} } |