チェンジセット 3530

差分発生行の前後
無視リスト:
コミット日時:
2010/03/12 21:10:26 (2 年前)
コミッタ:
keim
ログメッセージ:

SiON ver0.59 updated. This version is only for development.

ファイル:

凡例:

変更無し
追加
削除
更新
コピー
移動
  • as3/SiOPM/trunk/src/org/si/sion/module/channels/SiOPMChannelFM.as

    r3504 r3530  
    5151    // valiables 
    5252    //-------------------------------------------------- 
    53         /** eg_out threshold to check idling */ static _sion_internal var idlingThreshold:int = 4096; // = 256*8*2 = volume<1/256 
     53        /** eg_out threshold to check idling */ static _sion_internal var idlingThreshold:int = 8192; // = 512*8*2 = volume<1/512 
    5454         
    5555        // Operators 
  • as3/SiOPM/trunk/src/org/si/sion/sequencer/SiMMLSequencer.as

    r3516 r3530  
    885885            e = MMLParser.parse(); 
    886886             
    887             if (e != null) { 
     887            if (e != null && e.next != null) { 
    888888                seq._cutout(e); 
    889889                for (prev = seq.headEvent; prev.next != null; prev = e) { 
  • as3/SiOPM/trunk/src/org/si/sion/utils/Translator.as

    r3504 r3530  
    1515    public class Translator 
    1616    { 
    17         /** constructor */ 
     17        /** constructor, do nothing. */ 
    1818        function Translator() 
    1919        { 
  • as3/SiOPM/trunk/src/org/si/sound/mdx/MDXData.as

    r3516 r3530  
    77 
    88package org.si.sound.mdx { 
     9    import org.si.sion.SiONData; 
     10    import org.si.sion.SiONVoice; 
    911    import org.si.sion.module.SiOPMChannelParam; 
    1012    import org.si.sion.module.SiOPMOperatorParam; 
    11     import org.si.sion.SiONVoice
     13    import org.si.sion.sequencer.base.MMLEvent
    1214    import flash.utils.ByteArray; 
    1315     
     
    2224        public var title:String = null; 
    2325        public var pdxFileName:String = null; 
    24         public var voices:Vector.<SiONVoice>  = new Vector.<SiONVoice>(); 
    25         public var tracks:Vector.<MDXTrack>  = new Vector.<MDXTrack>(); 
     26        public var voices:Vector.<SiONVoice>  = new Vector.<SiONVoice>(256, true); 
     27        public var tracks:Vector.<MDXTrack>  = new Vector.<MDXTrack>(16, true); 
     28        public var globalEvents:Vector.<MDXEvent> = new Vector.<MDXEvent>(); 
    2629         
    2730         
     
    5962        public function clear() : MDXData 
    6063        { 
     64            var i:int; 
    6165            isPCM8 = false; 
    6266            bpm = 0; 
    6367            title = null; 
    6468            pdxFileName = null; 
    65             voices.length = 0; 
    66             tracks.length = 0; 
     69            globalEvents.length = 0; 
     70            for (i=0; i<16; i++) tracks[i] = null; 
     71            for (i=0; i<256; i++) voices[i] = null; 
    6772            return this; 
     73        } 
     74         
     75         
     76        /** convert to SiONData  
     77         *  @param data SiONData to convert to, pass null to create new SiONData inside. 
     78         *  @return converted SiONData 
     79         */ 
     80        public function convertToSiONData(data:SiONData=null, pdxData:PDXData=null) : SiONData 
     81        { 
     82            var i:int, imax:int, prevClock:uint, currentClock:uint; 
     83             
     84            if (data == null) data = new SiONData(); 
     85            data.clear(); 
     86             
     87            data.bpm = bpm; 
     88            data.globalSequence.initialize(); 
     89            imax = globalEvents.length; 
     90            currentClock = prevClock = 0; 
     91            for (i=0; i<imax; i++) { 
     92                switch(globalEvents[i].type) { 
     93                case MDXEvent.TIMERB: 
     94                    currentClock = globalEvents[i].clock; 
     95                    if (prevClock < currentClock) data.globalSequence.appendNewEvent(MMLEvent.WAIT, (currentClock-prevClock)*10); 
     96                    data.globalSequence.appendNewEvent(MMLEvent.TEMPO, 4883/(256-globalEvents[i].data)); 
     97                    prevClock = currentClock; 
     98                    break; 
     99                } 
     100            } 
     101 
     102            imax = (isPCM8) ? 16 : 9; 
     103            for (i=0; i<imax; i++) { 
     104                tracks[i]._constructMMLSequence(data.appendNewSequence()); 
     105            } 
     106             
     107            imax = voices.length; 
     108            for (i=0; i<imax; i++) { 
     109                data.voices[i] = voices[i] 
     110            } 
     111             
     112            if (pdxData) { 
     113                imax = 96; 
     114                for (i=0; i<imax; i++) data.setPCMData(i, pdxData.pcmData[i]); 
     115            } 
     116             
     117            return data; 
    68118        } 
    69119         
     
    117167        { 
    118168            var i:int, opi:int, v:int, voice:SiONVoice, voiceNumber:int, fbalg:int, mask:int,  
    119                 opp:SiOPMOperatorParam, reg:Array = [], opia:Array = [0,2,1,3], dt2Table:Array = [0, 384, 500, 608]; 
     169                opp:SiOPMOperatorParam, reg:Array = [], opia:Array = [3,1,2,0], dt2Table:Array = [0, 384, 500, 608]; 
    120170             
    121171            for (i=0; i<voiceLength; i+=27) { 
     
    161211        private function _loadTracks(bytes:ByteArray, mmlOffsets:Array) : void 
    162212        { 
    163             var i:int, trackCount:int = (isPCM8) ? 16 : 9; 
    164             bpm = 0; 
    165             for (i=0; i<trackCount; i++) { 
     213            var i:int, imax:int = (isPCM8) ? 16 : 9; 
     214            // load tracks 
     215            for (i=0; i<imax; i++) { 
    166216                bytes.position = mmlOffsets[i]; 
    167                 tracks[i] = new MDXTrack(i); 
     217                tracks[i] = new MDXTrack(this, i); 
    168218                tracks[i].loadBytes(bytes); 
    169                 if (bpm == 0 && tracks[i].timerB != 0) bpm = 4883/(256 - tracks[i].timerB); 
     219            } 
     220             
     221            // sort all global events 
     222            globalEvents = globalEvents.sort(function(a:MDXEvent, b:MDXEvent) : Number { return (a.clock - b.clock); }); 
     223             
     224            // load bpm 
     225            bpm = 87.19642857142857; // 4883/(256-200) 
     226            imax = globalEvents.length; 
     227            for (i=0; i<imax; i++) { 
     228                if (globalEvents[i].clock > 0) break; 
     229                if (globalEvents[i].type == MDXEvent.TIMERB) { 
     230                    bpm = 4883/(256-globalEvents[i].data);//4370.285//4883 
     231                    break; 
     232                } 
    170233            } 
    171234        } 
  • as3/SiOPM/trunk/src/org/si/sound/mdx/MDXEvent.as

    r3516 r3530  
    1717        static public const REST:int = 0x00; 
    1818        static public const NOTE:int = 0x80; 
    19         static public const TEMPO:int = 0xff; 
     19        static public const TIMERB:int = 0xff; 
    2020        static public const REGISTER:int = 0xfe; 
    2121        static public const VOICE:int = 0xfd; 
     
    5252    //-------------------------------------------------------------------------------- 
    5353        public var type:int = 0; 
    54         public var value:int = 0; 
    55         public var value2:int = 0; 
     54        public var data:int = 0; 
     55        public var data2:int = 0; 
    5656        public var clock:uint = 0; 
    5757        public var deltaClock:uint = 0; 
     
    7474    // constructor 
    7575    //-------------------------------------------------------------------------------- 
    76         function MDXEvent(type:int, value:int, value2:int, clock:int, deltaClock:int)  
     76        function MDXEvent(type:int, data:int, data2:int, clock:int, deltaClock:int)  
    7777        { 
    7878            this.type = type; 
    79             this.value = value
    80             this.value2 = value2; 
     79            this.data = data
     80            this.data2 = data2; 
    8181            this.clock = clock; 
    8282            this.deltaClock = deltaClock; 
  • as3/SiOPM/trunk/src/org/si/sound/mdx/MDXTrack.as

    r3516 r3530  
    2323        /** Return pointer of segno */ 
    2424        public var segnoPointer:MDXEvent; 
    25         /** TIMER B value */ 
    26         public var timerB:int; 
    2725        /** channel number */ 
    2826        public var channelNumber:int; 
     27        /** owner MDXData */ 
     28        public var owner:MDXData; 
     29         
    2930         
    3031         
     
    4344    // constructor 
    4445    //-------------------------------------------------------------------------------- 
    45         function MDXTrack(channelNumber:int) 
    46         { 
     46        function MDXTrack(owner:MDXData, channelNumber:int) 
     47        { 
     48            this.owner = owner; 
    4749            this.channelNumber = channelNumber; 
    4850            sequence = new Vector.<MDXEvent>(); 
    4951            segnoPointer = null; 
    50             timerB = 0; 
    5152        } 
    5253         
     
    6162            sequence.length = 0; 
    6263            segnoPointer = null; 
    63             timerB = 0; 
    6464            return this; 
    6565        } 
     
    7474            clock = 0; 
    7575             
    76             while (!exitLoop) { 
     76            while (!exitLoop && bytes.bytesAvailable>0) { 
    7777                pos = bytes.position; 
    7878                code = bytes.readUnsignedByte(); 
     
    8989                    //----- 2 operands 
    9090                    case MDXEvent.REGISTER: 
    91                     case MDXEvent.REPEAT_BEGIN: 
    9291                    case MDXEvent.FADEOUT: 
    9392                        newEvent(code, bytes.readUnsignedByte(), bytes.readUnsignedByte()); 
     
    9998                    case MDXEvent.GATE: 
    10099                    case MDXEvent.KEY_ON_DELAY: 
    101                     case MDXEvent.SYNC_SEND: 
    102100                    case MDXEvent.FREQUENCY: 
    103101                    case MDXEvent.LFO_DELAY: 
     
    108106                    case MDXEvent.VOLUME_INC: 
    109107                    case MDXEvent.SLUR: 
    110                     case MDXEvent.SYNC_WAIT: 
    111108                    case MDXEvent.SET_PCM8: 
    112109                        newEvent(code); 
    113110                        break; 
    114                     //----- 1 WORD operand 
    115                     case MDXEvent.REPEAT_END: 
    116                     case MDXEvent.REPEAT_BREAK: 
    117                         newEvent(code, bytes.readUnsignedShort()); 
    118                         break; 
     111                    //----- 1 WORD 
    119112                    case MDXEvent.DETUNE: 
    120113                    case MDXEvent.PORTAMENT: 
    121                         newEvent(code, bytes.readShort()); //...? 
     114                        newEvent(code, bytes.readShort()); //...short? 
     115                        break; 
     116                    //----- REPEAT 
     117                    case MDXEvent.REPEAT_BEGIN: 
     118                        newEvent(code, bytes.readUnsignedByte(), bytes.readUnsignedByte()); 
     119                        break; 
     120                    case MDXEvent.REPEAT_END: 
     121                        v = pos+(bytes.readShort()); // REPEAT_BEGIN 
     122                        newEvent(code, v); 
     123                        break; 
     124                    case MDXEvent.REPEAT_BREAK: 
     125                        v = pos+(bytes.readShort()+2); // REPEAT_END 
     126                        newEvent(code, v); 
    122127                        break; 
    123128                    //----- others 
    124                     case MDXEvent.TEMPO: 
     129                    case MDXEvent.TIMERB: 
     130                    case MDXEvent.SYNC_SEND: 
    125131                        v = bytes.readUnsignedByte(); 
    126                         newEvent(code, v); 
    127                         if (timerB == 0) timerB = v; 
     132                        owner.globalEvents.push(newEvent(code, v)); 
     133                        break; 
     134                    case MDXEvent.SYNC_WAIT: 
     135                        owner.globalEvents.push(newEvent(code)); 
    128136                        break; 
    129137                    case MDXEvent.PITCH_LFO: 
    130138                    case MDXEvent.VOLUME_LFO: 
    131                         v = (bytes.readUnsignedByte() << 16) | bytes.readUnsignedShort(); 
    132                         newEvent(code, v, bytes.readUnsignedShort()); 
     139                        v = bytes.readUnsignedByte(); 
     140                        if (v == 0x80 || v == 0x81) newEvent(code, v<<24); 
     141                        else newEvent(code, (v<<16) | bytes.readUnsignedShort(), bytes.readUnsignedShort()); 
    133142                        break; 
    134143                    case MDXEvent.OPM_LFO: 
     
    155164             
    156165             
    157             function newEvent(type:int, value:int=0, value2:int=0, deltaClock:int=0) : void
    158                 var inst:MDXEvent = new MDXEvent(type, value, value2, clock, deltaClock); 
     166            function newEvent(type:int, data:int=0, data2:int=0, deltaClock:int=0) : MDXEvent
     167                var inst:MDXEvent = new MDXEvent(type, data, data2, clock, deltaClock); 
    159168                sequence.push(inst); 
    160169                mem[pos] = inst; 
     170                return inst; 
    161171            } 
    162172             
     
    166176         
    167177        /** @private [internal] construct MMLSequence */ 
    168         internal function _constructMMLSequence(simml:MMLSequence, tempo:Number) : void 
     178        internal function _constructMMLSequence(mmlseq:MMLSequence) : void 
    169179        { 
    170180            if (SiONDriver.mutex == null) return; 
    171181             
    172182            var i:int, v:int, imax:int, e:MDXEvent, me:MMLEvent, sequencer:SiMMLSequencer = SiONDriver.mutex.sequencer,   
    173                 panTable:Array = [4,0,8,4], freqTable:Array = [18,23,30,35,42],  
    174                 repeatStac:Array = [], lastNote:MMLEvent, lfoDelay:int=0, 
     183                panTable:Array = [4,0,8,4], freqTable:Array = [18,23,30,35,42], adpcmFreq:int = 4, adpcmID:int = -1, 
     184                repeatStac:Array = [], lastNoteMDX:MDXEvent, lastNoteMML:MMLEvent,  
     185                lfoDelay:int=0, lfofq:int=0, lfows:int=2, mp:int=0, ma:int=0,  
    175186                eventIDFadeOut:int = sequencer.getEventID("@fadeout"), 
    176187                eventIDPan:int     = sequencer.getEventID("p"), 
     
    182193             
    183194                 
    184             simml.initialize(); 
    185             simml.appendNewEvent(MMLEvent.MOD_TYPE, 6); // use FM voice 
     195            mmlseq.initialize(); 
     196            if (channelNumber < 8) mmlseq.appendNewEvent(MMLEvent.MOD_TYPE, 6); // use FM voice 
     197            else                   mmlseq.appendNewEvent(MMLEvent.MOD_TYPE, 7); // use PCM voice 
    186198             
    187199            imax = sequence.length; 
    188200            for (i=0; i<imax; i++) { 
    189201                e = sequence[i]; 
    190                 if (segnoPointer === e) simml.appendNewEvent(MMLEvent.REPEAT_ALL, 0); 
    191                      if (e.type < 0x80) simml.appendNewEvent(MMLEvent.REST, 0, e.deltaClock*10); 
    192                 else if (e.type < 0xe0) lastNote = simml.appendNewEvent(MMLEvent.NOTE, e.value+12, e.deltaClock*10); 
    193                 else { 
     202                if (segnoPointer === e) mmlseq.appendNewEvent(MMLEvent.REPEAT_ALL, 0); 
     203                if (e.type < 0x80) { 
     204                    mmlseq.appendNewEvent(MMLEvent.REST, 0, e.deltaClock*10); 
     205                } else if (e.type < 0xe0) { 
     206                     lastNoteMDX = e; 
     207                    if (channelNumber < 8) { 
     208                        lastNoteMML = mmlseq.appendNewEvent(MMLEvent.NOTE, e.data+12, e.deltaClock*10); // use FM voice 
     209                    } else { 
     210                        // use PCM voice 
     211                        if (adpcmID != e.data) { 
     212                            adpcmID = e.data; 
     213                            mmlseq.appendNewEvent(MMLEvent.MOD_PARAM, adpcmID); 
     214                        } 
     215                        lastNoteMML = mmlseq.appendNewEvent(MMLEvent.NOTE, freqTable[adpcmFreq], e.deltaClock*10);  
     216                    } 
     217                } else { 
    194218                    switch(e.type) { 
    195219                    case MDXEvent.REGISTER: 
    196                         simml.appendNewEvent(MMLEvent.REGISTER, (e.value << 8) | e.value2); 
     220                        mmlseq.appendNewEvent(MMLEvent.REGISTER, (e.data << 8) | e.data2); 
     221                        break; 
     222                    case MDXEvent.FADEOUT: 
     223                        mmlseq.appendNewEvent(eventIDFadeOut, e.data2); 
     224                        break; 
     225                    case MDXEvent.VOICE: 
     226                        mmlseq.appendNewEvent(MMLEvent.MOD_PARAM, e.data); 
     227                        break; 
     228                    case MDXEvent.PAN: 
     229                        if (e.data == 0) mmlseq.appendNewEvent(MMLEvent.VOLUME, 0); 
     230                        else { 
     231                            mmlseq.appendNewEvent(MMLEvent.VOLUME, 16); 
     232                            mmlseq.appendNewEvent(eventIDPan, panTable[e.data]); 
     233                        } 
     234                        break; 
     235                    case MDXEvent.VOLUME: 
     236                        if (e.data < 16) mmlseq.appendNewEvent(MMLEvent.FINE_VOLUME, e.data<<3); 
     237                        else mmlseq.appendNewEvent(MMLEvent.FINE_VOLUME, e.data & 127); 
     238                        break; 
     239                    case MDXEvent.GATE: 
     240                        if (e.data < 9) { 
     241                            mmlseq.appendNewEvent(MMLEvent.QUANT_RATIO, e.data); 
     242                            mmlseq.appendNewEvent(MMLEvent.QUANT_COUNT, 0); 
     243                        } else { 
     244                            mmlseq.appendNewEvent(MMLEvent.QUANT_RATIO, 8); 
     245                            mmlseq.appendNewEvent(MMLEvent.QUANT_COUNT, (256-e.data)*10); 
     246                        } 
     247                        break; 
     248                    case MDXEvent.KEY_ON_DELAY: 
     249                        mmlseq.appendNewEvent(MMLEvent.KEY_ON_DELAY, e.data*10); 
     250                        break; 
     251                    case MDXEvent.VOLUME_DEC: 
     252                        mmlseq.appendNewEvent(MMLEvent.VOLUME_SHIFT, -1); 
     253                        break; 
     254                    case MDXEvent.VOLUME_INC: 
     255                        mmlseq.appendNewEvent(MMLEvent.VOLUME_SHIFT, 1); 
     256                        break; 
     257                    case MDXEvent.SLUR: 
     258                        if (lastNoteMML) { 
     259                            mmlseq.appendNewEvent(MMLEvent.SLUR_WEAK, 0, lastNoteMML.length); 
     260                            lastNoteMML.length = 0; 
     261                        } 
    197262                        break; 
    198263                    case MDXEvent.REPEAT_BEGIN: 
    199                         repeatStac.unshift(simml.appendNewEvent(MMLEvent.REPEAT_BEGIN, e.value)); 
    200                         break; 
    201                     case MDXEvent.FADEOUT: 
    202                         simml.appendNewEvent(eventIDFadeOut, e.value2); 
    203                         break; 
    204                     case MDXEvent.TEMPO: 
    205                         simml.appendNewEvent(MMLEvent.TEMPO, e.value); 
    206                         break; 
    207                     case MDXEvent.VOICE: 
    208                         simml.appendNewEvent(MMLEvent.MOD_PARAM, e.value); 
    209                         break; 
    210                     case MDXEvent.PAN: 
    211                         if (e.value == 0) simml.appendNewEvent(MMLEvent.VOLUME, 0); 
    212                         else { 
    213                             simml.appendNewEvent(MMLEvent.VOLUME, 16); 
    214                             simml.appendNewEvent(eventIDPan, panTable[e.value]); 
    215                         } 
    216                         break; 
    217                     case MDXEvent.VOLUME: 
    218                         if (e.value < 16) simml.appendNewEvent(MMLEvent.FINE_VOLUME, e.value<<4); 
    219                         else simml.appendNewEvent(MMLEvent.FINE_VOLUME, e.value & 127); 
    220                         break; 
    221                     case MDXEvent.GATE: 
    222                         if (e.value < 9) { 
    223                             simml.appendNewEvent(MMLEvent.QUANT_RATIO, e.value); 
    224                             simml.appendNewEvent(MMLEvent.QUANT_COUNT, 0); 
    225                         } else { 
    226                             simml.appendNewEvent(MMLEvent.QUANT_RATIO, 8); 
    227                             simml.appendNewEvent(MMLEvent.QUANT_COUNT, (256-e.value)*10); 
    228                         } 
    229                         break; 
    230                     case MDXEvent.KEY_ON_DELAY: 
    231                         simml.appendNewEvent(MMLEvent.KEY_ON_DELAY, e.value*10); 
    232                         break; 
    233                     case MDXEvent.VOLUME_DEC: 
    234                         simml.appendNewEvent(MMLEvent.VOLUME_SHIFT, -1); 
    235                         break; 
    236                     case MDXEvent.VOLUME_INC: 
    237                         simml.appendNewEvent(MMLEvent.VOLUME_SHIFT, 1); 
    238                         break; 
    239                     case MDXEvent.SLUR: 
    240                         if (lastNote) { 
    241                             simml.appendNewEvent(MMLEvent.SLUR_WEAK, 0, lastNote.length); 
    242                             lastNote.length = 0; 
    243                         } 
     264                        repeatStac.unshift(mmlseq.appendNewEvent(MMLEvent.REPEAT_BEGIN, e.data)); 
    244265                        break; 
    245266                    case MDXEvent.REPEAT_BREAK: 
    246                         me = simml.appendNewEvent(MMLEvent.REPEAT_BREAK, 0); 
     267                        me = mmlseq.appendNewEvent(MMLEvent.REPEAT_BREAK, 0); 
    247268                        me.jump = repeatStac[0]; 
    248269                        break; 
    249270                    case MDXEvent.REPEAT_END: 
    250                         me = simml.appendNewEvent(MMLEvent.REPEAT_END, 0); 
     271                        me = mmlseq.appendNewEvent(MMLEvent.REPEAT_END, 0); 
    251272                        me.jump = repeatStac.shift(); 
    252273                        me.jump.jump = me; 
    253274                        break; 
    254275                    case MDXEvent.DETUNE: 
    255                         simml.appendNewEvent(eventIDPShift, e.value); 
     276                        mmlseq.appendNewEvent(eventIDPShift, e.data); 
    256277                        break; 
    257278                    case MDXEvent.PORTAMENT: 
    258                         if (lastNote) { 
    259                             v = lastNote.data + (e.value * lastNote.length + 81920)/163840
     279                        if (lastNoteMML) { 
     280                            v = lastNoteMML.data + (e.data * (e.clock - lastNoteMDX.clock) + 8192)/16384
    260281                            if (v<0) v=0; 
    261282                            else if (v>127) v=127; 
    262                             simml.appendNewEvent(MMLEvent.PITCHBEND, 0, lastNote.length); 
    263                             lastNote.length = 0; 
    264                             simml.appendNewEvent(MMLEvent.NOTE, v, 0); 
     283                            mmlseq.appendNewEvent(MMLEvent.PITCHBEND, 0, lastNoteMML.length); 
     284                            lastNoteMML.length = 0; 
     285                            mmlseq.appendNewEvent(MMLEvent.NOTE, v, 0); 
    265286                        } 
    266287                        break; 
    267288                    case MDXEvent.LFO_DELAY: 
    268                         lfoDelay = e.value*75/tempo
     289                        lfoDelay = e.data*75/owner.bpm
    269290                        break; 
    270291                    case MDXEvent.PITCH_LFO: 
    271                         v = e.value>>16; 
    272                         simml.appendNewEvent(eventIDLFO, (e.value&0xffff)*75/tempo * ((v&3)?2:1)); 
    273                         simml.appendNewEvent(MMLEvent.PARAMETER, v&3); 
    274                         if (lfoDelay) { 
    275                             simml.appendNewEvent(eventIDPMod, e.value2>>((v&4)?0:8)); 
    276                             simml.appendNewEvent(MMLEvent.PARAMETER, e.value2); 
    277                             simml.appendNewEvent(MMLEvent.PARAMETER, lfoDelay); 
     292                        if (e.data>>24) { 
     293                            if ((e.data>>24) == 0x80) mmlseq.appendNewEvent(eventIDPMod, 0); 
     294                            else _mod(eventIDPMod, mp); 
    278295                        } else { 
    279                             simml.appendNewEvent(eventIDPMod, e.value2>>((v&4)?0:8)); 
     296                            lfows = (e.data>>16)&3; 
     297                            lfofq = (e.data&0xffff)*75/owner.bpm * ((lfows)?2:1); 
     298                            mp = e.data2>>((e.data&0x40000)?0:8); 
     299                            _mod(eventIDPMod, mp); 
    280300                        } 
    281301                        break; 
    282302                    case MDXEvent.VOLUME_LFO: 
    283                         v = e.value>>16; 
    284                         simml.appendNewEvent(eventIDLFO, (e.value&0xffff)*75/tempo * ((v&3)?2:1)); 
    285                         simml.appendNewEvent(MMLEvent.PARAMETER, v&3); 
    286                         if (lfoDelay) { 
    287                             simml.appendNewEvent(eventIDAMod, 0); 
    288                             simml.appendNewEvent(MMLEvent.PARAMETER, e.value2>>8); 
    289                             simml.appendNewEvent(MMLEvent.PARAMETER, lfoDelay); 
     303                        if (e.data>>24) { 
     304                            if ((e.data>>24) == 0x80) mmlseq.appendNewEvent(eventIDAMod, 0); 
     305                            else _mod(eventIDPMod, ma); 
    290306                        } else { 
    291                             simml.appendNewEvent(eventIDAMod, e.value2>>8); 
     307                            lfows = (e.data>>16)&3; 
     308                            lfofq = (e.data&0xffff)*75/owner.bpm * ((lfows)?2:1); 
     309                            ma = e.data2>>8; 
     310                            _mod(eventIDAMod, ma); 
    292311                        } 
    293312                        break; 
     
    297316                        } else  
    298317                        if (channelNumber >= 8) { 
    299                             simml.appendNewEvent(MMLEvent.NOTE, freqTable[e.value], 0)
     318                            adpcmFreq = e.data
    300319                        } 
    301320                        break; 
    302321                    case MDXEvent.DATA_END: 
    303322                    case MDXEvent.SET_PCM8: 
     323                    case MDXEvent.TIMERB: 
    304324                        break; 
    305325                    case MDXEvent.SYNC_SEND: 
     
    310330                        break; 
    311331                    } 
    312                      
    313                     lastNote = null; 
     332                } 
     333            } 
     334             
     335             
     336            function _mod(eventID:int, data:int) : void { 
     337                mmlseq.appendNewEvent(eventID, lfofq); 
     338                mmlseq.appendNewEvent(MMLEvent.PARAMETER, lfows); 
     339                if (lfoDelay) { 
     340                    mmlseq.appendNewEvent(eventID, 0); 
     341                    mmlseq.appendNewEvent(MMLEvent.PARAMETER, data); 
     342                    mmlseq.appendNewEvent(MMLEvent.PARAMETER, lfoDelay); 
     343                } else { 
     344                    mmlseq.appendNewEvent(eventID, data); 
    314345                } 
    315346            } 
  • as3/SiOPM/trunk/src/org/si/sound/mdx/PDXData.as

    r3516 r3530  
    3232        { 
    3333            adpcmData = new Vector.<ByteArray>(96, true); 
    34             pcmData = Vector.<Vector.<Number>>(96, true); 
     34            pcmData = new Vector.<Vector.<Number>>(96, true); 
    3535        } 
    3636         
     
    7171                    bytes.position = offset; 
    7272                    bytes.readBytes(adpcmData[i], 0, length); 
     73                    if (extractAll) pcmData[i] = SiONUtil.extractADPCM(adpcmData[i]); 
    7374                } 
    74                 if (extractAll) pcmData[i] = SiONUtil.extractADPCM(adpcmData[i]); 
    7575            } 
    7676