Ticket #8363: mt32.endian.v4.patch

File mt32.endian.v4.patch, 9.7 KB (added by fingolfin, 20 years ago)

Endian patch for Sev's patch V3 (revised)

  • 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  
    2222 * $Header$
    2323 */
    2424
    25 #include "stdafx.h"
     25#include "emumidi.h"
     26
    2627#include "common/util.h"
    2728#include "common/file.h"
    28 #include "sound/mididrv.h"
    29 #include "sound/mixer.h"
    3029
    3130#include "SynthMT32.h"
    3231
    33 #define BASE_FREQ 250
    34 
    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 {
     32class MidiDriver_MT32 : public MidiDriver_Emulated {
    4233private:
    4334        CSynthMT32 *_synth;
    44         SoundMixer *_mixer;
    45         bool _isOpen;
    46         int _tempo;
    47 
    48         typedef void TimerCallback(void *);
    49         TimerCallback *_timer_proc;
    50         void *_timer_param;
     35
     36        const char *rom_path;
    5137
    5238protected:
    5339        void generate_samples(int16 *buf, int len);
    54         static void premix_proc(void *param, int16 *buf, uint len);
    5540
    5641public:
    5742        MidiDriver_MT32(SoundMixer *mixer, const char *path);
    … …  
    6550        void setPitchBendRange(byte channel, uint range) { }
    6651        void sysEx(byte *msg, uint16 length);
    6752
    68         void setTimerCallback(void *timer_param, Timer::TimerProc timer_proc);
    69         uint32 getBaseTempo() { return 8000; } // 32000->8000 11025->11025
    70 
    7153        MidiChannel *allocateChannel() { return 0; }
    7254        MidiChannel *getPercussionChannel() { return 0; }
     55
     56
     57        // AudioStream API
     58        bool isStereo() const { return true; }
     59        int getRate() const { return 32000; }
    7360};
    7461
    7562
    … …  
    8067////////////////////////////////////////
    8168
    8269
    83 MidiDriver_MT32::MidiDriver_MT32(SoundMixer *mixer, const char *path) :
    84 _mixer(mixer) {
     70MidiDriver_MT32::MidiDriver_MT32(SoundMixer *mixer, const char *path)
     71        : MidiDriver_Emulated(mixer) {
    8572        _synth = new CSynthMT32();
    86         _isOpen = false;
    87         _tempo = _mixer->getOutputRate(); //32000; // Do not change this
    8873        rom_path = path;
    89         _timer_proc = NULL;
    9074        File::addDefaultDirectory(path);
    9175}
    9276
    … …  
    10084        if (_isOpen)
    10185                return MERR_ALREADY_OPEN;
    10286       
    103         prop.SampleRate = 32000; // 32000;
     87        MidiDriver_Emulated::open();
     88       
     89        prop.SampleRate = getRate(); // 32000;
    10490        prop.UseReverb = true;
    10591        prop.UseDefault = true;
    10692        //prop.RevType = 0;
    10793        //prop.RevTime = 5;
    10894        //prop.RevLevel = 3;
    109         prop.OutRate = _tempo;
    110 
    111         _mixer->setupPremix(premix_proc, this);
    11295
    11396        _synth->ClassicOpen(rom_path, prop);
    11497
    115         _isOpen = true;
     98        _mixer->setupPremix(this);
     99
    116100        return 0;
    117101}
    118102
    … …  
    125109}
    126110
    127111void MidiDriver_MT32::close() {
    128         if (_isOpen)
    129                 _synth->Close();
    130 
     112        if (!_isOpen)
     113                return;
    131114        _isOpen = false;
    132 }
    133115
    134 void MidiDriver_MT32::setTimerCallback(void *timer_param, Timer::TimerProc timer_proc) {
    135         _timer_proc = timer_proc;
    136         _timer_param = timer_param;
    137 }
     116        // Detach the premix callback handler
     117        _mixer->setupPremix(0);
    138118
    139 void MidiDriver_MT32::premix_proc(void *param, int16 *buf, uint len) {
    140         ((MidiDriver_MT32 *) param)->generate_samples(buf, len);
     119        _synth->Close();
    141120}
    142121
    143122void MidiDriver_MT32::generate_samples(int16 *data, int len) {
    144         int16 *p = data;
    145 
    146         memset(data, 0, len * 4);
    147 
    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         }
     123        _synth->MT32_CallBack((Bit8u *)data, len, _mixer->getMusicVolume());
    155124}
    156125
    157126
    … …  
    164133MidiDriver *MidiDriver_MT32_create(SoundMixer *mixer, const char *path) {
    165134        return new MidiDriver_MT32(mixer, path);
    166135}
    167