Ticket #8363: mt32.endian.v3.patch

File mt32.endian.v3.patch, 10.0 KB (added by fingolfin, 20 years ago)

Endian patch for V3

  • CSynthMT32.cpp 

    diff -ru old/CSynthMT32.cpp new/CSynthMT32.cpp
    old new  
    29762976                //LOG_MSG("f num %d freq %d and fa %d", f, freq, fa);
    29772977
    29782978
    2979                 waveforms[0][f] = (Bit16s *)malloc(fa*2);
    2980                 waveforms[1][f] = (Bit16s *)malloc(fa*2);
    2981                 waveforms[2][f] = (Bit16s *)malloc(fa*2);
    2982                 waveforms[3][f] = (Bit16s *)malloc(fa*4);
    2983 
    29842979                waveformsize[0][f] = waveformsize[1][f] = waveformsize[2][f] = fa*2;
    29852980                waveformsize[3][f] = fa*4;
    29862981               
    2987                 memcpy(waveforms[0][f], &tmpforms[0][0],fa*2);
    2988                 memcpy(waveforms[1][f], &tmpforms[1][0],fa*2);
    2989                 memcpy(waveforms[2][f], &tmpforms[2][0],fa*2);
    2990                 memcpy(waveforms[3][f], &tmpforms[3][0],fa*4);
    2991                
    2992                
    2993                 int out;
    2994                
    2995                 out = fp.write(waveforms[0][f],divtable[f]>>13);
    2996                 out = fp.write(waveforms[1][f],divtable[f]>>13);
    2997                 out = fp.write(waveforms[2][f],divtable[f]>>13);
    2998                 out = fp.write(waveforms[3][f],divtable[f]>>12);
    2999                
    3000 
     2982                for (int i = 0; i < 4; ++i) {
     2983                        waveforms[i][f] = (Bit16s *)malloc(waveformsize[i][f]);
     2984                        memcpy(waveforms[i][f], &tmpforms[i][0],waveformsize[i][f]);
     2985                        // TODO / FIXME: The following code is not endian safe!
     2986                        out = fp.write(waveforms[i][f],waveformsize[i][f]);
     2987                }
    30012988#else
    3002                 waveforms[0][f] = (Bit16s *)malloc(divtable[f]>>13);
    3003                 waveforms[1][f] = (Bit16s *)malloc(divtable[f]>>13);
    3004                 waveforms[2][f] = (Bit16s *)malloc(divtable[f]>>13);
    3005                 waveforms[3][f] = (Bit16s *)malloc(divtable[f]>>12);
    3006 
    30072989                waveformsize[0][f] = waveformsize[1][f] = waveformsize[2][f] = divtable[f]>>13;
    30082990                waveformsize[3][f] = divtable[f]>>12;
    30092991
    3010                 fp.read(waveforms[0][f],divtable[f]>>13);
    3011                 fp.read(waveforms[1][f],divtable[f]>>13);
    3012                 fp.read(waveforms[2][f],divtable[f]>>13);
    3013                 fp.read(waveforms[3][f],divtable[f]>>12);
     2992                for (int i = 0; i < 4; ++i) {
     2993                        waveforms[i][f] = (Bit16s *)malloc(waveformsize[i][f]);
     2994                        for (int j = 0; j < waveformsize[i][f]/2; ++j)
     2995                                waveforms[i][f][j] = fp.readSint16LE();
     2996                }
    30142997#endif
    30152998
    30162999
    … …  
    36003583                }
    36013584
    36023585                while(!fp.eof()) {
    3603                         fp.read(&c, 1);
     3586                        c = fp.readByte();
    36043587                        sysexBuf[syslen] = c;
    36053588                        syslen++;
    36063589                        if(c==0xf0) {
    … …  
    38593842        //Bit32s maxamp = 0;
    38603843        while (!fIn.eof()) {
    38613844                Bit16s s, c1;
    3862        
    3863                 fIn.read(&s, 1);
    3864                 fIn.read(&c1, 1);
     3845               
     3846                s = fIn.readByte();
     3847                c1 = fIn.readByte();
     3848
    38653849                /*
    38663850                int e,z,u,bit;
    38673851               
    … …  
    38963880                int bit;
    38973881                int u;
    38983882       
    3899                 int order[16] = {0, 9,1 ,2, 3, 4, 5, 6, 7, 10, 11,  12,13, 14, 15,8};
     3883                static const int order[16] = {0, 9,1 ,2, 3, 4, 5, 6, 7, 10, 11,  12,13, 14, 15,8};
    39003884               
    39013885                e=0;
    39023886                z = 15;
    … …  
    39603944        }
    39613945
    39623946        // For resetting mt32 mid-execution
    3963         memcpy(&mt32default, &mt32ram,sizeof(mt32ram));
     3947        memcpy(&mt32default, &mt32ram, sizeof(mt32ram));
    39643948
    39653949        if (!InitTables(baseDir)) return false;
    39663950        if(myProp.UseDefault) {
    … …  
    39773961        }
    39783962        activeChannels = 0;
    39793963
     3964#ifdef HAVE_X86
    39803965        bool useSSE = false, use3DNow = false;
    39813966
    3982 #ifdef HAVE_X86
    39833967        use3DNow = Detect3DNow();
    39843968        useSSE = DetectSIMD();
    39853969       
    … …  
    40033987
    40043988#endif
    40053989
    4006         _audioStream = makeAppendableAudioStream(32000, SoundMixer::FLAG_STEREO | SoundMixer::FLAG_16BITS | SoundMixer::FLAG_LITTLE_ENDIAN, 4096);
    4007         _rateConverter = makeRateConverter(32000, myProp.OutRate, true, false);
    4008 
    40093990        return true;
    40103991}
    40113992
    … …  
    40214002        }
    40224003
    40234004#endif
    4024         delete _rateConverter;
    4025         delete _audioStream;
    40264005
    40274006        isOpen=false;
    40284007
    … …  
    41554134
    41564135        Bit32u addr;
    41574136        Bit32u *header;
    4158         unsigned int off,m;
     4137        unsigned int off;
     4138        int m;
    41594139        header = (Bit32u *)(sysex+1);
    4160         mt32ramFormat *myMem;
    4161         myMem = &mt32ram;
    41624140        //int dummy = 0;                                                                 
    41634141        Bit32s lens = len;                                                             
    41644142
    … …  
    43814359
    43824360
    43834361
    4384 static Bit16s tmpBuffer[4096], tmpBuffer2[4096];
     4362static Bit16s tmpBuffer[4096];
    43854363static float sndbufl[4096];
    43864364static float sndbufr[4096];
    43874365static float outbufl[4096];
    … …  
    44004378        snd = (Bit16s *)stream;
    44014379        if(!isEnabled) return;
    44024380        memset(stream,0,len*4);
    4403         memset(tmpBuffer2,0,4096);
    4404         useBuf = &tmpBuffer[0];
     4381        useBuf = snd;
    44054382
    4406         if (myProp.OutRate != 32000)
    4407                 outlen = len * 32000 / myProp.OutRate;
    4408         else
    4409                 outlen = len;
     4383        outlen = len;
    44104384
    44114385        assert(len < 1024); // tmpBuffer is 4096 bytes
    44124386        /*
    … …  
    44284402
    44294403                if(partTable[i]->produceOutput(tmpBuffer,outlen)==true) {
    44304404#if USE_MMX == 0
    4431                         Bit16s *tmpoff = tmpBuffer2;
     4405                        Bit16s *tmpoff = snd;
    44324406                        int q = 0;
    44334407                        for(m=0;m<(Bit32s)outlen;m++) {
    44344408                                tmpoff[q] += (Bit16s)(((Bit32s)tmpBuffer[q] * (Bit32s)mastervolume)>>15);
    … …  
    44504424                                psllq mm3, 32
    44514425                                por mm3,mm2
    44524426                                mov esi, useBuf
    4453                                 mov edi, tmpBuffer2
     4427                                mov edi, snd
    44544428mixloop4:
    44554429                                movq mm1, [esi]
    44564430                                movq mm2, [edi]
    … …  
    44674441                                emms
    44684442                        }
    44694443#else
    4470                         atti386_produceOutput1(tmplen, mastervolume, useBuf, tmpBuffer2);                       
     4444                        atti386_produceOutput1(tmplen, mastervolume, useBuf, snd);                     
    44714445#endif
    44724446#endif
    44734447                }
    44744448        }
    44754449
    4476         //memcpy(snd, tmpBuffer2, len * 4);
    4477         _audioStream->append((byte *)tmpBuffer2, outlen * 4);
    4478         _rateConverter->flow(*_audioStream, snd, len, volume, volume);
    4479 
    44804450        if(myProp.UseReverb) {
    44814451#if USE_MMX == 3
    44824452                if(!usingSIMD) {

  • MT32Structures.h 

    diff -ru old/MT32Structures.h new/MT32Structures.h
    old new  
    603603union soundaddr {
    604604        Bit32u pcmabs;
    605605        struct offsets {
     606#if defined(SCUMM_LITTLE_ENDIAN)
    606607                Bit16u pcmoffset;
    607608                Bit16u pcmplace;
     609#else
     610                Bit16u pcmplace;
     611                Bit16u pcmoffset;
     612#endif
    608613        } pcmoffs;
    609614};
    610615

  • SynthMT32.h 

    diff -ru old/SynthMT32.h new/SynthMT32.h
    old new  
    5454//#define WGAMP (8192)
    5555
    5656#include "backends/midi/MT32Structures.h"
    57 #include "sound/audiostream.h"
    58 #include "sound/rate.h"
    5957#include "sound/mixer.h"
    6058
    6159// Function that detects the availablity of SSE SIMD instructions
    … …  
    6866struct SynthProperties {
    6967        // Sample rate to use in mixing
    7068        int SampleRate;
    71 
    72         // Sample rate for output
    73         int OutRate;
    74 
    7569        // Flag to activate reverb.  True = use reverb, False = no reverb
    7670        bool UseReverb;
    7771        // Flag True to use software set reverb settings, Flag False to set reverb settings in
    … …  
    143137        unsigned char initmode;
    144138        bool isOpen;
    145139        SynthProperties myProp;
    146         AppendableAudioStream *_audioStream;
    147         RateConverter *_rateConverter;
    148140       
    149141        bool InitTables(const char * baseDir);
    150142

  • mt32.cpp 

    diff -ru old/mt32.cpp new/mt32.cpp
    old new  
    2525#include "stdafx.h"
    2626#include "common/util.h"
    2727#include "common/file.h"
     28#include "sound/audiostream.h"
    2829#include "sound/mididrv.h"
    2930#include "sound/mixer.h"
    3031
    3132#include "SynthMT32.h"
    3233
    3334#define BASE_FREQ 250
     35#define FIXP_SHIFT 16
    3436
    35 const char *rom_path;
    36 bool enabledSSE   = true;
    37 bool enabled3DNow = false;
    38 
    39 class MidiDriver_MT32;
    40 
    41 class MidiDriver_MT32 : public MidiDriver {
     37class MidiDriver_MT32 : public AudioStream, public MidiDriver {
    4238private:
    4339        CSynthMT32 *_synth;
    4440        SoundMixer *_mixer;
    4541        bool _isOpen;
    46         int _tempo;
    4742
    48         typedef void TimerCallback(void *);
    49         TimerCallback *_timer_proc;
     43        const char *rom_path;
     44
     45        Timer::TimerProc _timer_proc;
    5046        void *_timer_param;
    5147
     48        int _next_tick;
     49        int _samples_per_tick;
     50
    5251protected:
    5352        void generate_samples(int16 *buf, int len);
    54         static void premix_proc(void *param, int16 *buf, uint len);
    5553
    5654public:
    5755        MidiDriver_MT32(SoundMixer *mixer, const char *path);
    … …  
    6664        void sysEx(byte *msg, uint16 length);
    6765
    6866        void setTimerCallback(void *timer_param, Timer::TimerProc timer_proc);
    69         uint32 getBaseTempo() { return 8000; } // 32000->8000 11025->11025
     67        uint32 getBaseTempo() { return 1000000 / BASE_FREQ; } // 32000->8000 11025->11025
    7068
    7169        MidiChannel *allocateChannel() { return 0; }
    7270        MidiChannel *getPercussionChannel() { return 0; }
     71
     72        // AudioStream API
     73        int readBuffer(int16 *buffer, const int numSamples) {
     74                generate_samples(buffer, numSamples / 2);
     75                return numSamples;
     76        }
     77        int16 read() {
     78                error("ProcInputStream::read not supported");
     79        }
     80        bool isStereo() const { return true; }
     81        bool endOfData() const { return false; }
     82       
     83        int getRate() const { return 32000; }
    7384};
    7485
    7586
    … …  
    8495_mixer(mixer) {
    8596        _synth = new CSynthMT32();
    8697        _isOpen = false;
    87         _tempo = _mixer->getOutputRate(); //32000; // Do not change this
    8898        rom_path = path;
    8999        _timer_proc = NULL;
     100        _next_tick = 0;
     101        _samples_per_tick = 0;
    90102        File::addDefaultDirectory(path);
    91103}
    92104
    … …  
    100112        if (_isOpen)
    101113                return MERR_ALREADY_OPEN;
    102114       
    103         prop.SampleRate = 32000; // 32000;
     115        prop.SampleRate = getRate(); // 32000;
    104116        prop.UseReverb = true;
    105117        prop.UseDefault = true;
    106118        //prop.RevType = 0;
    107119        //prop.RevTime = 5;
    108120        //prop.RevLevel = 3;
    109         prop.OutRate = _tempo;
    110 
    111         _mixer->setupPremix(premix_proc, this);
    112121
    113122        _synth->ClassicOpen(rom_path, prop);
    114123
     124        _samples_per_tick = (getRate() << FIXP_SHIFT) / BASE_FREQ;
     125
     126        _mixer->setupPremix(this);
     127
    115128        _isOpen = true;
    116129        return 0;
    117130}
    … …  
    136149        _timer_param = timer_param;
    137150}
    138151
    139 void MidiDriver_MT32::premix_proc(void *param, int16 *buf, uint len) {
    140         ((MidiDriver_MT32 *) param)->generate_samples(buf, len);
    141 }
    142 
    143152void MidiDriver_MT32::generate_samples(int16 *data, int len) {
    144         int16 *p = data;
    145 
    146         memset(data, 0, len * 4);
     153        int step;
    147154
    148         // With original frequency sound
    149         for (int i = 0; i < 8; i++) {
    150                 _synth->MT32_CallBack((Bit8u *)p, len >> 3, _mixer->getMusicVolume());
    151                 if (_timer_proc)
    152                         (*_timer_proc)(_timer_param);
    153                 p += len >> 2;
    154         }
     155        do {
     156                step = len;
     157                if (step > (_next_tick >> FIXP_SHIFT))
     158                        step = (_next_tick >> FIXP_SHIFT);
     159                _synth->MT32_CallBack((Bit8u *)data, step, _mixer->getMusicVolume());
     160
     161                _next_tick -= step << FIXP_SHIFT;
     162                if (!(_next_tick >> FIXP_SHIFT)) {
     163                        if (_timer_proc)
     164                                (*_timer_proc)(_timer_param);
     165                        _next_tick += _samples_per_tick;
     166                }
     167                data += step * 2; // Stereo means * 2
     168                len -= step;
     169        } while (len);
    155170}
    156171
    157172
    … …  
    164179MidiDriver *MidiDriver_MT32_create(SoundMixer *mixer, const char *path) {
    165180        return new MidiDriver_MT32(mixer, path);
    166181}
    167