root/lang/actionscript/flmml/trunk/src/com/txt_nifty/sketch/flmml/MChannel.as @ 38696

Revision 38696, 47.7 kB (checked in by tekisuke, 3 years ago)

ゆみさんの代理コミット。バッファの切れ目でポルタメントが正常に動作しない場合があったのを修正しました。

Line 
1package com.txt_nifty.sketch.flmml {
2    import __AS3__.vec.Vector;
3
4    public class MChannel {
5        private static const LFO_TARGET_PITCH:int     = 0;
6        private static const LFO_TARGET_AMPLITUDE:int = 1;
7        private static const LFO_TARGET_CUTOFF:int    = 2;
8        private static const LFO_TARGET_PWM:int       = 3;
9        private static const LFO_TARGET_FM:int        = 4;
10        private static const LFO_TARGET_PANPOT:int    = 5;
11       
12        private var m_noteNo:int;
13        private var m_detune:int;
14        private var m_freqNo:int;
15        private var m_envelope1:MEnvelope;     // for VCO
16        private var m_envelope2:MEnvelope;     // for VCF
17        private var m_oscSet1:MOscillator;     // for original wave
18        private var m_oscMod1:MOscMod;
19        private var m_oscSet2:MOscillator;     // for Pitch LFO
20        private var m_oscMod2:MOscMod;
21        private var m_osc2Connect:int;
22        private var m_osc2Sign:Number;
23        private var m_filter:MFilter;
24        private var m_filterConnect:int;
25        private var m_formant:MFormant;
26        private var m_expression:Number;       // expression (max:1.0)
27        private var m_velocity:Number;         // velocity (max:1.0)
28        private var m_ampLevel:Number;         // amplifier level (max:1.0)
29        private var m_pan:Number;                               // left 0.0 - 1.0 right
30        private var m_onCounter:int;
31        private var m_lfoDelay:int;
32        private var m_lfoDepth:Number;
33        private var m_lfoEnd:int;
34        private var m_lfoTarget:int;
35        private var m_lpfAmt:Number;
36        private var m_lpfFrq:Number;
37        private var m_lpfRes:Number;
38        private var m_pulseWidth:Number;
39        private var m_volMode:int;
40        private var m_inSens:Number;
41        private var m_inPipe:int;
42        private var m_outMode:int;
43        private var m_outPipe:int;
44        private var m_ringSens:Number;
45        private var m_ringPipe:int;
46        private var m_syncMode:int;
47        private var m_syncPipe:int;
48
49                private var m_portDepth:Number;
50                private var m_portDepthAdd:Number;
51                private var m_portamento:int;
52                private var m_portRate:Number;
53                private var m_lastFreqNo:int;
54
55        public    static var PITCH_RESOLUTION:int = 100;
56        protected static var s_init:int = 0;
57        protected static var s_frequencyMap:Vector.<Number> = new Vector.<Number>(128 * PITCH_RESOLUTION);
58        protected static var s_frequencyLen:int;
59        protected static var s_volumeMap:Vector.<Number> = new Vector.<Number>(128);
60        protected static var s_volumeLen:int;
61        protected static var s_samples:Vector.<Number>;            // mono
62        protected static var s_pipeArr:Vector.<Vector.<Number>>;
63        protected static var s_syncSources:Vector.<Vector.<Boolean>>;
64        protected static var s_lfoDelta:int = 245;
65
66        public function MChannel() {
67            m_noteNo = 0;
68            m_detune = 0;
69            m_freqNo = 0;
70            m_envelope1 = new MEnvelope(0.0, 60.0/127.0, 30.0/127.0, 1.0/127.0);
71            m_envelope2 = new MEnvelope(0.0, 30.0/127.0, 0.0, 1.0);
72            m_oscSet1 = new MOscillator();
73            m_oscMod1 = m_oscSet1.getCurrent();
74            m_oscSet2 = new MOscillator();
75            m_oscSet2.asLFO();
76            m_oscSet2.setForm(MOscillator.SINE);
77            m_oscMod2 = m_oscSet2.getCurrent();
78            m_osc2Connect = 0;
79            m_filter = new MFilter();
80            m_filterConnect = 0;
81            m_formant = new MFormant();
82            m_volMode  = 0;
83            setExpression(127);
84            setVelocity(100);
85            setPan(64);
86            m_onCounter = 0;
87            m_lfoDelay = 0;
88            m_lfoDepth = 0.0;
89            m_lfoEnd   = 0;
90            m_lpfAmt   = 0;
91            m_lpfFrq   = 0;
92            m_lpfRes   = 0;
93            m_pulseWidth = 0.5;
94            setInput(0, 0);
95            setOutput(0, 0);
96            setRing(0, 0);
97            setSync(0, 0);
98                        m_portDepth = 0;
99                        m_portDepthAdd = 0;
100                        m_lastFreqNo = 4800;
101                        m_portamento = 0;
102                        m_portRate = 0;
103        }
104        public static function boot(numSamples:int):void {
105            if (!s_init) {
106                var i:int;
107                s_frequencyLen = s_frequencyMap.length;
108                for(i = 0; i < s_frequencyLen; i++) {
109                    s_frequencyMap[i] = 440.0 * Math.pow(2.0, (i-69*PITCH_RESOLUTION)/(12*PITCH_RESOLUTION));
110                }
111                s_volumeLen = s_volumeMap.length;
112                s_volumeMap[0] = 0.0;
113                for(i = 1; i < s_volumeLen; i++) {
114                    s_volumeMap[i] = Math.pow(10.0, (i-127.0)*(48.0/(127.0*20.0))); // min:-48db
115                    //trace(i+","+s_volumeMap[i]);
116                }
117                s_init = 1;
118            }
119            s_samples = new Vector.<Number>(numSamples);
120            s_samples.fixed = true;
121        }
122        public static function createPipes(num:int):void {
123            s_pipeArr = new Vector.<Vector.<Number>>(num);
124            for (var i:int = 0; i < num; i++) {
125                s_pipeArr[i] = new Vector.<Number>(s_samples.length);
126                for (var j:int = 0; j < s_samples.length; j++) {
127                    s_pipeArr[i][j] = 0;
128                }
129            }
130        }
131        public static function createSyncSources(num:int):void {
132                s_syncSources = new Vector.<Vector.<Boolean>>(num);
133                for (var i:int = 0; i < num; i++) {
134                        s_syncSources[i] = new Vector.<Boolean>(s_samples.length);
135                        for (var j:int = 0; j < s_samples.length; j++) {
136                                s_syncSources[i][j] = false;
137                        }
138                }
139        }
140        public static function getFrequency(freqNo:int):Number {
141            freqNo = (freqNo < 0) ? 0 : (freqNo >= s_frequencyLen) ? s_frequencyLen-1 : freqNo;
142            return s_frequencyMap[freqNo];
143        }
144        public function setExpression(ex:int):void {
145            m_expression = (m_volMode) ? s_volumeMap[ex] : ex / 127.0;
146            m_ampLevel = m_velocity * m_expression;
147        }
148        public function setVelocity(velocity:int):void {
149            m_velocity = (m_volMode) ? s_volumeMap[velocity] : velocity / 127.0;
150            m_ampLevel = m_velocity * m_expression;
151        }
152        public function setNoteNo(noteNo:int, tie:Boolean = true):void {
153            m_noteNo = noteNo;
154            m_freqNo = m_noteNo * PITCH_RESOLUTION + m_detune;
155            m_oscMod1.setFrequency(getFrequency(m_freqNo));
156
157                        if (m_portamento == 1) {
158                                if (!tie) {
159                                        m_portDepth = m_lastFreqNo - m_freqNo;
160                                }
161                                else {
162                                        m_portDepth += (m_lastFreqNo - m_freqNo);
163                                }
164                                m_portDepthAdd = (m_portDepth < 0) ? m_portRate : m_portRate * -1;
165                        }
166                        m_lastFreqNo = m_freqNo;
167                }
168        public function setDetune(detune:int):void {
169            m_detune = detune;
170            m_freqNo = m_noteNo * PITCH_RESOLUTION + m_detune;
171            m_oscMod1.setFrequency(getFrequency(m_freqNo));
172        }
173        public function noteOn(noteNo:int, velocity:int):void {
174            setNoteNo(noteNo, false);
175            m_envelope1.triggerEnvelope();
176            m_envelope2.triggerEnvelope(1);
177            m_oscMod1.resetPhase();
178            m_oscMod2.resetPhase();
179            m_filter.reset();
180            setVelocity(velocity);
181            m_onCounter = 0;
182
183                var modPulse:MOscPulse = (MOscPulse)(m_oscSet1.getMod(MOscillator.PULSE));
184                modPulse.setPWM(m_pulseWidth);
185
186            var modFcNoise:MOscFcNoise = (MOscFcNoise)(m_oscSet1.getMod(MOscillator.FC_NOISE));
187            modFcNoise.setNoiseFreq(noteNo);
188            var modGbLNoise:MOscGbLNoise = (MOscGbLNoise)(m_oscSet1.getMod(MOscillator.GB_NOISE));
189            modGbLNoise.setNoiseFreq(noteNo);
190            var modGbSNoise:MOscGbSNoise = (MOscGbSNoise)(m_oscSet1.getMod(MOscillator.GB_S_NOISE));
191            modGbSNoise.setNoiseFreq(noteNo);
192                        //2009.05.10 OffGao ADD 2L addDPCM
193            var modFcDpcm:MOscFcDpcm = (MOscFcDpcm)(m_oscSet1.getMod(MOscillator.FC_DPCM));
194            modFcDpcm.setDpcmFreq(noteNo);
195                       
196        }
197        public function noteOff():void {
198            m_envelope1.releaseEnvelope();
199            m_envelope2.releaseEnvelope();
200        }
201        public function close():void {
202            noteOff();
203            m_filter.setSwitch(0);
204        }
205        public function setNoiseFreq(frequency:Number):void {
206            var modNoise:MOscNoise = (MOscNoise)(m_oscSet1.getMod(MOscillator.NOISE));
207            modNoise.setNoiseFreq(1.0 - frequency * (1.0 / 128.0));
208        }
209        public function setForm(form:int, subform:int):void {
210            m_oscMod1 = m_oscSet1.setForm(form);
211            if (form == MOscillator.GB_WAVE) (MOscGbWave)(m_oscSet1.getMod(MOscillator.GB_WAVE)).setWaveNo(subform);
212                        //2009.05.10 OffGao ADD 1L addDPCM
213            if (form == MOscillator.FC_DPCM) (MOscFcDpcm)(m_oscSet1.getMod(MOscillator.FC_DPCM)).setWaveNo(subform);
214            if (form == MOscillator.WAVE   ) (MOscWave)(m_oscSet1.getMod(MOscillator.WAVE   )).setWaveNo(subform);
215            if (form == MOscillator.SINE   ) (MOscSine)(m_oscSet1.getMod(MOscillator.SINE)).setWaveNo(subform);
216        }
217        public function setEnvelope1Atk(attack:int):void {
218                m_envelope1.setAttack(attack * (1.0 / 127.0));
219        }
220        public function setEnvelope1Point(time:int, level:int):void {
221                m_envelope1.addPoint(time * (1.0 / 127.0), level * (1.0 / 127.0));
222        }
223        public function setEnvelope1Rel(release:int):void {
224                m_envelope1.setRelease(release * (1.0 / 127.0));
225        }
226        public function setEnvelope2Atk(attack:int):void {
227                m_envelope2.setAttack(attack * (1.0 / 127.0));
228        }
229        public function setEnvelope2Point(time:int, level:int):void {
230                m_envelope2.addPoint(time * (1.0 / 127.0), level * (1.0 / 127.0));
231        }
232        public function setEnvelope2Rel(release:int):void {
233                m_envelope2.setRelease(release * (1.0 / 127.0));
234        }
235        public function setPWM(pwm:int):void {
236            if (m_oscSet1.getForm() != MOscillator.FC_PULSE) {
237                var modPulse:MOscPulse = (MOscPulse)(m_oscSet1.getMod(MOscillator.PULSE));
238                                if (pwm < 0) {
239                                        modPulse.setMIX(1);
240                                        pwm *= -1;
241                                }
242                                else {
243                                        modPulse.setMIX(0);
244                                }
245                m_pulseWidth = pwm * 0.01;
246                modPulse.setPWM(m_pulseWidth);
247            }
248            else {
249                var modFcPulse:MOscPulse = (MOscPulse)(m_oscSet1.getMod(MOscillator.FC_PULSE));
250                                if (pwm < 0) pwm *= -1;         // 以前との互換のため
251                modFcPulse.setPWM(0.125 * Number(pwm));
252            }
253        }
254        public function setPan(pan:int):void {
255            // left 1 - 64 - 127 right
256            // master_vol = (0.25 * 2)
257            m_pan = (pan - 1) * (0.5 / 63.0);
258            if (m_pan < 0) m_pan = 0;
259        }
260        public function setFormant(vowel:int):void {
261            if (vowel >= 0) m_formant.setVowel(vowel);
262            else m_formant.disable();
263        }
264        public function setLFOFMSF(form:int, subform:int):void {
265            m_oscMod2 = m_oscSet2.setForm((form >= 0) ? form-1 : -form-1);
266            m_osc2Sign = (form >= 0) ? 1.0 : -1.0;
267            if (form < 0) form = -form;
268            form--;
269            if (form >= MOscillator.MAX) m_osc2Connect = 0;
270            if (form == MOscillator.GB_WAVE)
271                (MOscGbWave)(m_oscSet2.getMod(MOscillator.GB_WAVE)).setWaveNo(subform);
272            if (form == MOscillator.FC_DPCM)
273                (MOscFcDpcm)(m_oscSet2.getMod(MOscillator.FC_DPCM)).setWaveNo(subform);
274            if (form == MOscillator.WAVE)
275                (MOscWave)(m_oscSet2.getMod(MOscillator.WAVE)).setWaveNo(subform);
276            if (form == MOscillator.SINE)
277                (MOscSine)(m_oscSet2.getMod(MOscillator.SINE)).setWaveNo(subform);
278        }
279        public function setLFODPWD(depth:int, freq:Number):void {
280            m_lfoDepth = depth;
281            m_osc2Connect = (depth == 0) ? 0 : 1;
282            m_oscMod2.setFrequency(freq);
283            m_oscMod2.resetPhase();
284            (MOscNoise)(m_oscSet2.getMod(MOscillator.NOISE)).setNoiseFreq(freq/MSequencer.RATE44100);
285        }
286        public function setLFODLTM(delay:int, time:int):void {
287            m_lfoDelay = delay;
288            m_lfoEnd = (time > 0) ? m_lfoDelay + time : 0;
289        }
290        public function setLFOTarget(target:int):void {
291                m_lfoTarget = target;
292        }
293        public function setLpfSwtAmt(swt:int, amt:int):void {
294            if (-3 < swt && swt < 3 && swt != m_filterConnect) {
295                m_filterConnect = swt;
296                m_filter.setSwitch(swt);
297            }
298            m_lpfAmt = ((amt < -127) ? -127 : (amt < 127) ? amt : 127) * PITCH_RESOLUTION;
299        }
300        public function setLpfFrqRes(frq:int, res:int):void {
301            if (frq < 0) frq = 0;
302            if (frq > 127) frq = 127;
303            m_lpfFrq = frq * PITCH_RESOLUTION;
304            m_lpfRes = res * (1.0 / 127.0);
305            if (m_lpfRes < 0.0) m_lpfRes = 0.0;
306            if (m_lpfRes > 1.0) m_lpfRes = 1.0;
307        }
308        public function setVolMode(m:int):void {
309            m_volMode = m;
310        }
311        public function setInput(i:int, p:int):void {
312            m_inSens = (1<<(i-1)) * (1.0 / 8.0) * MOscMod.PHASE_LEN;
313            m_inPipe = p;
314        }
315        public function setOutput(o:int, p:int):void {
316            m_outMode = o;
317            m_outPipe = p;
318        }
319        public function setRing(s:int, p:int):void {
320                m_ringSens = (1 << (s - 1)) / 8.0;
321                m_ringPipe = p;
322        }
323        public function setSync(m:int, p:int):void {
324                m_syncMode = m;
325                m_syncPipe = p;
326        }
327                public function setPortamento(depth:int, len:Number):void {
328                        m_portamento = 0;
329                        m_portDepth = depth;
330                        m_portDepthAdd = (Number(m_portDepth) / len) * -1;
331                }
332                public function setMidiPort(mode:int):void {
333                        m_portamento = mode;
334                        m_portDepth = 0;
335                }
336                public function setMidiPortRate(rate:Number):void {
337                        m_portRate = rate;
338                }
339                public function setPortBase(base:int):void {
340                        m_lastFreqNo = base;
341                }
342        protected function getNextCutoff():Number {
343            var cut:Number = m_lpfFrq + m_lpfAmt * m_envelope2.getNextAmplitudeLinear();
344            cut = getFrequency(cut) * m_oscMod1.getFrequency() * (2.0 * Math.PI / (MSequencer.RATE44100 * 440.0));
345            if (cut < (1.0/127.0)) cut = 0.0;
346            return cut;
347        }
348        public function getSamples(samples:Vector.<Number>, max:int, start:int, delta:int):void {
349            var end:int = start + delta;
350            var trackBuffer:Vector.<Number> = s_samples, sens:Number, pipe:Vector.<Number>;
351            var amplitude:Number, rightAmplitude:Number;
352            var playing:Boolean = m_envelope1.isPlaying(), tmpFlag:Boolean;
353            var vol:Number, lpffrq:int, pan:Number, depth:Number;
354            var i:int, j:int, s:int, e:int;
355            if (end >= max) end = max;
356            var key:Number = getFrequency(m_freqNo);
357            if(m_outMode == 1){
358                // @o1 が指定されていれば直接パイプに音声を書き込む
359                trackBuffer = s_pipeArr[m_outPipe];
360            }
361            if (playing) {
362                                if (m_portDepth == 0) {
363                                        if(m_inSens >= 0.000001){
364                                                if(m_osc2Connect == 0){
365                                                        getSamplesF__(trackBuffer, start, end);
366                                                }else if(m_lfoTarget == LFO_TARGET_PITCH){
367                                                        getSamplesFP_(trackBuffer, start, end);
368                                                }else if(m_lfoTarget == LFO_TARGET_PWM){
369                                                        getSamplesFW_(trackBuffer, start, end);
370                                                }else if(m_lfoTarget == LFO_TARGET_FM){
371                                                        getSamplesFF_(trackBuffer, start, end);
372                                                }else{
373                                                        getSamplesF__(trackBuffer, start, end);
374                                                }
375                                        }else if(m_syncMode == 2){
376                                                if(m_osc2Connect == 0){
377                                                        getSamplesI__(trackBuffer, start, end);
378                                                }else if(m_lfoTarget == LFO_TARGET_PITCH){
379                                                        getSamplesIP_(trackBuffer, start, end);
380                                                }else if(m_lfoTarget == LFO_TARGET_PWM){
381                                                        getSamplesIW_(trackBuffer, start, end);
382                                                }else{
383                                                        getSamplesI__(trackBuffer, start, end);
384                                                }
385                                        }else if(m_syncMode == 1){
386                                                if(m_osc2Connect == 0){
387                                                        getSamplesO__(trackBuffer, start, end);
388                                                }else if(m_lfoTarget == LFO_TARGET_PITCH){
389                                                        getSamplesOP_(trackBuffer, start, end);
390                                                }else if(m_lfoTarget == LFO_TARGET_PWM){
391                                                        getSamplesOW_(trackBuffer, start, end);
392                                                }else{
393                                                        getSamplesO__(trackBuffer, start, end);
394                                                }
395                                        }else{
396                                                if(m_osc2Connect == 0){
397                                                        getSamples___(trackBuffer, start, end);
398                                                }else if(m_lfoTarget == LFO_TARGET_PITCH){
399                                                        getSamples_P_(trackBuffer, start, end);
400                                                }else if(m_lfoTarget == LFO_TARGET_PWM){
401                                                        getSamples_W_(trackBuffer, start, end);
402                                                }else{
403                                                        getSamples___(trackBuffer, start, end);
404                                                }
405                                        }
406                                }
407                                else {
408                                        if(m_inSens >= 0.000001){
409                                                if(m_osc2Connect == 0){
410                                                        getSamplesF_P(trackBuffer, start, end);
411                                                }else if(m_lfoTarget == LFO_TARGET_PITCH){
412                                                        getSamplesFPP(trackBuffer, start, end);
413                                                }else if(m_lfoTarget == LFO_TARGET_PWM){
414                                                        getSamplesFWP(trackBuffer, start, end);
415                                                }else if(m_lfoTarget == LFO_TARGET_FM){
416                                                        getSamplesFFP(trackBuffer, start, end);
417                                                }else{
418                                                        getSamplesF_P(trackBuffer, start, end);
419                                                }
420                                        }else if(m_syncMode == 2){
421                                                if(m_osc2Connect == 0){
422                                                        getSamplesI_P(trackBuffer, start, end);
423                                                }else if(m_lfoTarget == LFO_TARGET_PITCH){
424                                                        getSamplesIPP(trackBuffer, start, end);
425                                                }else if(m_lfoTarget == LFO_TARGET_PWM){
426                                                        getSamplesIWP(trackBuffer, start, end);
427                                                }else{
428                                                        getSamplesI_P(trackBuffer, start, end);
429                                                }
430                                        }else if(m_syncMode == 1){
431                                                if(m_osc2Connect == 0){
432                                                        getSamplesO_P(trackBuffer, start, end);
433                                                }else if(m_lfoTarget == LFO_TARGET_PITCH){
434                                                        getSamplesOPP(trackBuffer, start, end);
435                                                }else if(m_lfoTarget == LFO_TARGET_PWM){
436                                                        getSamplesOWP(trackBuffer, start, end);
437                                                }else{
438                                                        getSamplesO_P(trackBuffer, start, end);
439                                                }
440                                        }else{
441                                                if(m_osc2Connect == 0){
442                                                        getSamples__P(trackBuffer, start, end);
443                                                }else if(m_lfoTarget == LFO_TARGET_PITCH){
444                                                        getSamples_PP(trackBuffer, start, end);
445                                                }else if(m_lfoTarget == LFO_TARGET_PWM){
446                                                        getSamples_WP(trackBuffer, start, end);
447                                                }else{
448                                                        getSamples__P(trackBuffer, start, end);
449                                                }
450                                        }
451                                }
452            }
453            if(m_volMode == 0){
454                m_envelope1.ampSamplesLinear(trackBuffer, start, end, m_ampLevel);
455            }else{
456                m_envelope1.ampSamplesNonLinear(trackBuffer, start, end, m_ampLevel);
457            }
458           
459            if(m_lfoTarget == LFO_TARGET_AMPLITUDE && m_osc2Connect != 0){      // with Amplitude LFO
460                depth = m_osc2Sign * m_lfoDepth / 127.0;
461                s = start;
462                for(i = start; i < end; i++) {
463                    vol = 1.0;
464                    if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
465                        vol += m_oscMod2.getNextSample() * depth;
466                    }
467                    if(vol < 0){
468                        vol = 0;
469                    }
470                                        trackBuffer[i] *= vol;
471                    m_onCounter++;
472                }
473            }
474            if(playing && (m_ringSens >= 0.000001)){ // with ring
475                pipe = s_pipeArr[m_ringPipe];
476                sens = m_ringSens;
477                for(i = start; i < end; i++){
478                                        trackBuffer[i] *= pipe[i] * sens;
479                                }
480            }
481           
482            // フォルマントフィルタを経由した後の音声が無音であればスキップ
483            tmpFlag = playing;
484            playing = playing || m_formant.checkToSilence();
485            if(playing != tmpFlag){
486                for(i = start; i < end; i++) trackBuffer[i] = 0;
487            }
488            if(playing){
489                m_formant.run(trackBuffer, start, end);
490            }
491
492            // フィルタを経由した後の音声が無音であればスキップ
493            tmpFlag = playing;
494            playing = playing || m_filter.checkToSilence();
495            if(playing != tmpFlag){
496                for(i = start; i < end; i++) trackBuffer[i] = 0;
497            }
498            if(playing){
499                if(m_lfoTarget == LFO_TARGET_CUTOFF && m_osc2Connect != 0){     // with Filter LFO
500                    depth = m_osc2Sign * m_lfoDepth;
501                        s = start;
502                        do {
503                            e = s + s_lfoDelta;
504                            if (e > end) e = end;
505                            lpffrq = m_lpfFrq;
506                            if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
507                                lpffrq += m_oscMod2.getNextSample() * depth;
508                                m_oscMod2.addPhase(e - s - 1);
509                            }
510                            if(lpffrq < 0.0){
511                                lpffrq = 0.0;
512                            }else if(lpffrq > 127.0 * PITCH_RESOLUTION){
513                                lpffrq = 127.0 * PITCH_RESOLUTION;
514                            }
515                                m_filter.run(s_samples, s, e, m_envelope2, lpffrq, m_lpfAmt, m_lpfRes, key);
516                            m_onCounter += e - s;
517                            s = e;
518                        } while(s < end);
519                }else{
520                    m_filter.run(trackBuffer, start, end, m_envelope2, m_lpfFrq, m_lpfAmt, m_lpfRes, key);
521                }
522            }
523           
524            if(playing){
525                switch(m_outMode) {
526                case 0:
527                    //trace("output audio");
528                    if(m_lfoTarget == LFO_TARGET_PANPOT && m_osc2Connect != 0){ // with Panpot LFO
529                        depth = m_osc2Sign * m_lfoDepth * (1.0 / 127.0);
530                        for(i = start; i < end; i++) {
531                            j = i + i;
532                            pan = m_pan + m_oscMod2.getNextSample() * depth;
533                            if(pan < 0){
534                                pan = 0;
535                            }else if(pan > 1.0){
536                                pan = 1.0;
537                            }
538                            amplitude = trackBuffer[i] * 0.5;
539                            rightAmplitude = amplitude * pan;
540                            samples[j] += amplitude - rightAmplitude;
541                            j++;
542                            samples[j] += rightAmplitude;
543                        }
544                    }else{
545                        for(i = start; i < end; i++) {
546                            j = i + i;
547                            amplitude = trackBuffer[i] * 0.5;
548                            rightAmplitude = amplitude * m_pan;
549                            samples[j] += amplitude - rightAmplitude;
550                            j++;
551                            samples[j] += rightAmplitude;
552                        }
553                    }
554                    break;
555                case 1: // overwrite
556                /* リングモジュレータと音量LFOの同時使用時に問題が出てたようなので
557                   一旦戻します。 2010.09.22 tekisuke */
558                    //trace("output "+m_outPipe);
559                    pipe = s_pipeArr[m_outPipe];
560                    for(i = start; i < end; i++) {
561                        pipe[i] = trackBuffer[i];
562                    }
563                    break;
564                case 2: // add
565                    pipe = s_pipeArr[m_outPipe];
566                    for(i = start; i < end; i++) {
567                        pipe[i] += trackBuffer[i];
568                    }
569                    break;
570                }
571            }else if(m_outMode == 1){
572                pipe = s_pipeArr[m_outPipe];
573                for(i = start; i < end; i++) {
574                    pipe[i] = 0.0;
575                }
576            }
577        }
578       
579        // 波形生成部の関数群
580        // [pipe] := [_:なし], [F:FM入力], [I:Sync入力], [O:Sync出力]
581        // [lfo]  := [_:なし], [P:音程], [W:パルス幅], [F:FM入力レベル]
582                // [pro.] := [_:なし], [p:ポルタメント]
583        // private function getSamples[pipe][lfo](samples:Vector.<Number>, start:int, end:int):void
584       
585        // パイプ処理なし, LFOなし, ポルタメントなし
586        private function getSamples___(samples:Vector.<Number>, start:int, end:int):void {
587                        m_oscMod1.getSamples(samples, start, end);
588        }
589        // パイプ処理なし, 音程LFO, ポルタメントなし
590        private function getSamples_P_(samples:Vector.<Number>, start:int, end:int):void {
591            var s:int = start, e:int, freqNo:int, depth:Number = m_osc2Sign * m_lfoDepth;
592            do {
593                e = s + s_lfoDelta;
594                if (e > end) e = end;
595                freqNo = m_freqNo;
596                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
597                    freqNo += m_oscMod2.getNextSample() * depth;
598                    m_oscMod2.addPhase(e - s - 1);
599                }
600                m_oscMod1.setFrequency(getFrequency(freqNo));
601                m_oscMod1.getSamples(samples, s, e);
602                m_onCounter += e - s;
603                s = e;
604            } while(s < end)
605        }
606        // パイプ処理なし, パルス幅(@3)LFO, ポルタメントなし
607        private function getSamples_W_(samples:Vector.<Number>, start:int, end:int):void {
608            var s:int = start, e:int, pwm:Number, depth:Number = m_osc2Sign * m_lfoDepth * 0.01,
609                modPulse:MOscPulse = (MOscPulse)(m_oscSet1.getMod(MOscillator.PULSE));
610            do {
611                e = s + s_lfoDelta;
612                if (e > end) e = end;
613                pwm = m_pulseWidth;
614                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
615                    pwm += m_oscMod2.getNextSample() * depth;
616                    m_oscMod2.addPhase(e - s - 1);
617                }
618                if(pwm < 0){
619                        pwm = 0;
620                }else if(pwm > 100.0){
621                        pwm = 100.0;
622                }
623                modPulse.setPWM(pwm);
624                m_oscMod1.getSamples(samples, s, e);
625                m_onCounter += e - s;
626                s = e;
627            } while(s < end)
628        }
629        // FM入力, LFOなし, ポルタメントなし
630        private function getSamplesF__(samples:Vector.<Number>, start:int, end:int):void {
631            var i:int, sens:Number = m_inSens, pipe:Vector.<Number> = s_pipeArr[m_inPipe];
632            // rev.35879 以前の挙動にあわせるため
633            m_oscMod1.setFrequency(getFrequency(m_freqNo) >> 0);
634            for(i = start; i < end; i++) {
635                samples[i] = m_oscMod1.getNextSampleOfs(pipe[i] * sens);
636            }
637        }
638        // FM入力, 音程LFO, ポルタメントなし
639        private function getSamplesFP_(samples:Vector.<Number>, start:int, end:int):void {
640            var i:int, freqNo:int, sens:Number = m_inSens, depth:Number = m_osc2Sign * m_lfoDepth,
641                pipe:Vector.<Number> = s_pipeArr[m_inPipe];
642            for(i = start; i < end; i++) {
643                freqNo = m_freqNo;
644                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
645                    freqNo += m_oscMod2.getNextSample() * depth;
646                }
647                m_oscMod1.setFrequency(getFrequency(freqNo));
648                samples[i] = m_oscMod1.getNextSampleOfs(pipe[i] * sens);
649                m_onCounter++;
650            }
651        }
652        // FM入力, パルス幅(@3)LFO, ポルタメントなし
653        private function getSamplesFW_(samples:Vector.<Number>, start:int, end:int):void {
654            var i:int, pwm:Number, depth:Number = m_osc2Sign * m_lfoDepth * 0.01,
655                modPulse:MOscPulse = (MOscPulse)(m_oscSet1.getMod(MOscillator.PULSE)),
656                sens:Number = m_inSens, pipe:Vector.<Number> = s_pipeArr[m_inPipe];
657            // rev.35879 以前の挙動にあわせるため
658            m_oscMod1.setFrequency(getFrequency(m_freqNo) >> 0);
659            for(i = start; i < end; i++) {
660                pwm = m_pulseWidth;
661                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
662                    pwm += m_oscMod2.getNextSample() * depth;
663                }
664                if(pwm < 0){
665                    pwm = 0;
666                }else if(pwm > 100.0){
667                    pwm = 100.0;
668                }
669                modPulse.setPWM(pwm);
670                samples[i] = m_oscMod1.getNextSampleOfs(pipe[i] * sens);
671                m_onCounter++;
672            }
673        }
674        // FM入力, FM入力レベル, ポルタメントなし
675        private function getSamplesFF_(samples:Vector.<Number>, start:int, end:int):void {
676            var i:int, freqNo:int, sens:Number, depth:Number = m_osc2Sign * m_lfoDepth * (1.0 / 127.0),
677                pipe:Vector.<Number> = s_pipeArr[m_inPipe];
678            // rev.35879 以前の挙動にあわせるため
679            m_oscMod1.setFrequency(getFrequency(m_freqNo) >> 0);
680            for(i = start; i < end; i++) {
681                sens = m_inSens;
682                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
683                    sens *= m_oscMod2.getNextSample() * depth;
684                }
685                samples[i] = m_oscMod1.getNextSampleOfs(pipe[i] * sens);
686                m_onCounter++;
687            }
688        }
689        // Sync入力, LFOなし, ポルタメントなし
690        private function getSamplesI__(samples:Vector.<Number>, start:int, end:int):void {
691            m_oscMod1.getSamplesWithSyncIn(samples, s_syncSources[m_syncPipe], start, end);
692        }
693        // Sync入力, 音程LFO, ポルタメントなし
694        private function getSamplesIP_(samples:Vector.<Number>, start:int, end:int):void {
695            var s:int = start, e:int, freqNo:int, depth:Number = m_osc2Sign * m_lfoDepth,
696                syncLine:Vector.<Boolean> = s_syncSources[m_syncPipe];
697            do {
698                e = s + s_lfoDelta;
699                if (e > end) e = end;
700                freqNo = m_freqNo;
701                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
702                    freqNo += m_oscMod2.getNextSample() * depth;
703                    m_oscMod2.addPhase(e - s - 1);
704                }
705                m_oscMod1.setFrequency(getFrequency(freqNo));
706                m_oscMod1.getSamplesWithSyncIn(samples, syncLine, s, e);
707                m_onCounter += e - s;
708                s = e;
709            } while(s < end)
710        }
711        // Sync入力, パルス幅(@3)LFO, ポルタメントなし
712        private function getSamplesIW_(samples:Vector.<Number>, start:int, end:int):void {
713            var s:int = start, e:int, pwm:Number, depth:Number = m_osc2Sign * m_lfoDepth * 0.01,
714                modPulse:MOscPulse = (MOscPulse)(m_oscSet1.getMod(MOscillator.PULSE)),
715                syncLine:Vector.<Boolean> = s_syncSources[m_syncPipe];
716            do {
717                e = s + s_lfoDelta;
718                if (e > end) e = end;
719                pwm = m_pulseWidth;
720                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
721                    pwm += m_oscMod2.getNextSample() * depth;
722                    m_oscMod2.addPhase(e - s - 1);
723                }
724                if(pwm < 0){
725                    pwm = 0;
726                }else if(pwm > 100.0){
727                    pwm = 100.0;
728                }
729                modPulse.setPWM(pwm);
730                m_oscMod1.getSamplesWithSyncIn(samples, syncLine, s, e);
731                m_onCounter += e - s;
732                s = e;
733            } while(s < end)
734        }
735        // Sync出力, LFOなし, ポルタメントなし
736        private function getSamplesO__(samples:Vector.<Number>, start:int, end:int):void {
737            m_oscMod1.getSamplesWithSyncOut(samples, s_syncSources[m_syncPipe], start, end);
738        }
739        // Sync出力, 音程LFO, ポルタメントなし
740        private function getSamplesOP_(samples:Vector.<Number>, start:int, end:int):void {
741            var s:int = start, e:int, freqNo:int, depth:Number = m_osc2Sign * m_lfoDepth,
742                syncLine:Vector.<Boolean> = s_syncSources[m_syncPipe];
743            do {
744                e = s + s_lfoDelta;
745                if (e > end) e = end;
746                freqNo = m_freqNo;
747                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
748                    freqNo += m_oscMod2.getNextSample() * depth;
749                    m_oscMod2.addPhase(e - s - 1);
750                }
751                m_oscMod1.setFrequency(getFrequency(freqNo));
752                m_oscMod1.getSamplesWithSyncOut(samples, syncLine, s, e);
753                m_onCounter += e - s;
754                s = e;
755            } while(s < end)
756        }
757        // Sync出力, パルス幅(@3)LFO, ポルタメントなし
758        private function getSamplesOW_(samples:Vector.<Number>, start:int, end:int):void {
759            var s:int = start, e:int, pwm:Number, depth:Number = m_osc2Sign * m_lfoDepth * 0.01,
760                modPulse:MOscPulse = (MOscPulse)(m_oscSet1.getMod(MOscillator.PULSE)),
761                syncLine:Vector.<Boolean> = s_syncSources[m_syncPipe];
762            do {
763                e = s + s_lfoDelta;
764                if (e > end) e = end;
765                pwm = m_pulseWidth;
766                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
767                    pwm += m_oscMod2.getNextSample() * depth;
768                    m_oscMod2.addPhase(e - s - 1);
769                }
770                if(pwm < 0){
771                    pwm = 0;
772                }else if(pwm > 100.0){
773                    pwm = 100.0;
774                }
775                modPulse.setPWM(pwm);
776                m_oscMod1.getSamplesWithSyncOut(samples, syncLine, s, e);
777                m_onCounter += e - s;
778                s = e;
779            } while(s < end)
780        }
781
782                /*** ここから下がポルタメントありの場合 ***/
783               
784        // パイプ処理なし, LFOなし, ポルタメントあり
785        private function getSamples__P(samples:Vector.<Number>, start:int, end:int):void {
786            var s:int = start, e:int, freqNo:int;
787                        do {
788                                e = s + s_lfoDelta;
789                                if (e > end) e = end;
790                                freqNo = m_freqNo
791                                if (m_portDepth != 0) {
792                                        freqNo += m_portDepth;
793                                        m_portDepth += (m_portDepthAdd * (e - s - 1));
794                                        if (m_portDepth * m_portDepthAdd > 0) m_portDepth = 0;
795                                }
796                m_oscMod1.setFrequency(getFrequency(freqNo));
797                m_oscMod1.getSamples(samples, s, e);
798                s = e;
799                        } while (s < end)
800                        if (m_portDepth == 0) {
801                m_oscMod1.setFrequency(getFrequency(m_freqNo));
802                        }
803        }
804        // パイプ処理なし, 音程LFO, ポルタメントあり
805        private function getSamples_PP(samples:Vector.<Number>, start:int, end:int):void {
806            var s:int = start, e:int, freqNo:int, depth:Number = m_osc2Sign * m_lfoDepth;
807            do {
808                e = s + s_lfoDelta;
809                if (e > end) e = end;
810                                freqNo = m_freqNo;
811                                if (m_portDepth != 0) {
812                                        freqNo += m_portDepth;
813                                        m_portDepth += (m_portDepthAdd * (e - s - 1));
814                                        if (m_portDepth * m_portDepthAdd > 0) m_portDepth = 0;
815                                }
816                                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
817                                        freqNo += m_oscMod2.getNextSample() * depth;
818                                        m_oscMod2.addPhase(e - s - 1);
819                                        if (m_portDepth * m_portDepthAdd > 0) m_portDepth = 0;
820                                }
821                m_oscMod1.setFrequency(getFrequency(freqNo));
822                m_oscMod1.getSamples(samples, s, e);
823                m_onCounter += e - s;
824                s = e;
825            } while(s < end)
826        }
827        // パイプ処理なし, パルス幅(@3)LFO, ポルタメントあり
828        private function getSamples_WP(samples:Vector.<Number>, start:int, end:int):void {
829            var s:int = start, e:int, pwm:Number, depth:Number = m_osc2Sign * m_lfoDepth * 0.01, freqNo:Number,
830                modPulse:MOscPulse = (MOscPulse)(m_oscSet1.getMod(MOscillator.PULSE));
831            do {
832                e = s + s_lfoDelta;
833                if (e > end) e = end;
834
835                                freqNo = m_freqNo;
836                                if (m_portDepth != 0) {
837                                        freqNo += m_portDepth;
838                                        m_portDepth += (m_portDepthAdd * (e - s - 1));
839                                        if (m_portDepth * m_portDepthAdd > 0) m_portDepth = 0;
840                                }
841                                m_oscMod1.setFrequency(getFrequency(freqNo));
842
843                pwm = m_pulseWidth;
844                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
845                    pwm += m_oscMod2.getNextSample() * depth;
846                    m_oscMod2.addPhase(e - s - 1);
847                }
848                if(pwm < 0){
849                        pwm = 0;
850                }else if(pwm > 100.0){
851                        pwm = 100.0;
852                }
853                modPulse.setPWM(pwm);
854                m_oscMod1.getSamples(samples, s, e);
855                m_onCounter += e - s;
856                s = e;
857            } while(s < end)
858                        if (m_portDepth == 0) {
859                m_oscMod1.setFrequency(getFrequency(m_freqNo));
860                        }
861        }
862        // FM入力, LFOなし, ポルタメントあり
863        private function getSamplesF_P(samples:Vector.<Number>, start:int, end:int):void {
864            var freqNo:int, i:int, sens:Number = m_inSens, pipe:Vector.<Number> = s_pipeArr[m_inPipe];
865            for (i = start; i < end; i++) {
866                                freqNo = m_freqNo;
867                                if (m_portDepth != 0) {
868                                        freqNo += m_portDepth;
869                                        m_portDepth += m_portDepthAdd;
870                                        if (m_portDepth * m_portDepthAdd > 0) m_portDepth = 0;
871                                }
872                                m_oscMod1.setFrequency(getFrequency(freqNo));
873                                samples[i] = m_oscMod1.getNextSampleOfs(pipe[i] * sens);
874                        }
875        }
876        // FM入力, 音程LFO, ポルタメントあり
877        private function getSamplesFPP(samples:Vector.<Number>, start:int, end:int):void {
878            var i:int, freqNo:int, sens:Number = m_inSens, depth:Number = m_osc2Sign * m_lfoDepth,
879                pipe:Vector.<Number> = s_pipeArr[m_inPipe];
880            for(i = start; i < end; i++) {
881                                freqNo = m_freqNo;
882                                if (m_portDepth != 0) {
883                                        freqNo += m_portDepth;
884                                        m_portDepth += m_portDepthAdd;
885                                        if (m_portDepth * m_portDepthAdd > 0) m_portDepth = 0;
886                                }
887                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
888                    freqNo += m_oscMod2.getNextSample() * depth;
889                }
890                m_oscMod1.setFrequency(getFrequency(freqNo));
891                samples[i] = m_oscMod1.getNextSampleOfs(pipe[i] * sens);
892                m_onCounter++;
893            }
894        }
895        // FM入力, パルス幅(@3)LFO, ポルタメントあり
896        private function getSamplesFWP(samples:Vector.<Number>, start:int, end:int):void {
897            var i:int, freqNo:int, pwm:Number, depth:Number = m_osc2Sign * m_lfoDepth * 0.01,
898                modPulse:MOscPulse = (MOscPulse)(m_oscSet1.getMod(MOscillator.PULSE)),
899                sens:Number = m_inSens, pipe:Vector.<Number> = s_pipeArr[m_inPipe];
900            for (i = start; i < end; i++) {
901                                freqNo = m_freqNo;
902                                if (m_portDepth != 0) {
903                                        freqNo += m_portDepth;
904                                        m_portDepth += m_portDepthAdd;
905                                        if (m_portDepth * m_portDepthAdd > 0) m_portDepth = 0;
906                                }
907                                m_oscMod1.setFrequency(getFrequency(freqNo));
908                                pwm = m_pulseWidth;
909                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
910                    pwm += m_oscMod2.getNextSample() * depth;
911                }
912                if(pwm < 0){
913                    pwm = 0;
914                }else if(pwm > 100.0){
915                    pwm = 100.0;
916                }
917                modPulse.setPWM(pwm);
918                samples[i] = m_oscMod1.getNextSampleOfs(pipe[i] * sens);
919                m_onCounter++;
920            }
921        }
922        // FM入力, FM入力レベル, ポルタメントあり
923        private function getSamplesFFP(samples:Vector.<Number>, start:int, end:int):void {
924            var i:int, freqNo:int, sens:Number, depth:Number = m_osc2Sign * m_lfoDepth * (1.0 / 127.0),
925                pipe:Vector.<Number> = s_pipeArr[m_inPipe];
926            for (i = start; i < end; i++) {
927                                freqNo = m_freqNo;
928                                if (m_portDepth != 0) {
929                                        freqNo += m_portDepth;
930                                        m_portDepth += m_portDepthAdd;
931                                        if (m_portDepth * m_portDepthAdd > 0) m_portDepth = 0;
932                                }
933                                m_oscMod1.setFrequency(getFrequency(freqNo));
934                sens = m_inSens;
935                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
936                    sens *= m_oscMod2.getNextSample() * depth;
937                }
938                samples[i] = m_oscMod1.getNextSampleOfs(pipe[i] * sens);
939                m_onCounter++;
940            }
941        }
942        // Sync入力, LFOなし, ポルタメントあり
943        private function getSamplesI_P(samples:Vector.<Number>, start:int, end:int):void {
944            var s:int = start, e:int, freqNo:int,
945                syncLine:Vector.<Boolean> = s_syncSources[m_syncPipe];
946            do {
947                e = s + s_lfoDelta;
948                if (e > end) e = end;
949                freqNo = m_freqNo;
950                                if (m_portDepth != 0) {
951                                        freqNo += m_portDepth;
952                                        m_portDepth += (m_portDepthAdd * (e - s - 1));
953                                        if (m_portDepth * m_portDepthAdd > 0) m_portDepth = 0;
954                                }
955                m_oscMod1.setFrequency(getFrequency(freqNo));
956                m_oscMod1.getSamplesWithSyncIn(samples, syncLine, s, e);
957                m_onCounter += e - s;
958                s = e;
959            } while (s < end)
960                        if (m_portDepth == 0) {
961                m_oscMod1.setFrequency(getFrequency(m_freqNo));
962                        }
963                }
964        // Sync入力, 音程LFO, ポルタメントあり
965        private function getSamplesIPP(samples:Vector.<Number>, start:int, end:int):void {
966            var s:int = start, e:int, freqNo:int, depth:Number = m_osc2Sign * m_lfoDepth,
967                syncLine:Vector.<Boolean> = s_syncSources[m_syncPipe];
968            do {
969                e = s + s_lfoDelta;
970                if (e > end) e = end;
971                freqNo = m_freqNo;
972                                if (m_portDepth != 0) {
973                                        freqNo += m_portDepth;
974                                        m_portDepth += (m_portDepthAdd * (e - s - 1));
975                                        if (m_portDepth * m_portDepthAdd > 0) m_portDepth = 0;
976                                }
977                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
978                    freqNo += m_oscMod2.getNextSample() * depth;
979                    m_oscMod2.addPhase(e - s - 1);
980                }
981                m_oscMod1.setFrequency(getFrequency(freqNo));
982                m_oscMod1.getSamplesWithSyncIn(samples, syncLine, s, e);
983                m_onCounter += e - s;
984                s = e;
985            } while(s < end)
986        }
987        // Sync入力, パルス幅(@3)LFO, ポルタメントあり
988        private function getSamplesIWP(samples:Vector.<Number>, start:int, end:int):void {
989            var s:int = start, e:int, freqNo:int, pwm:Number, depth:Number = m_osc2Sign * m_lfoDepth * 0.01,
990                modPulse:MOscPulse = (MOscPulse)(m_oscSet1.getMod(MOscillator.PULSE)),
991                syncLine:Vector.<Boolean> = s_syncSources[m_syncPipe];
992            do {
993                e = s + s_lfoDelta;
994                if (e > end) e = end;
995                freqNo = m_freqNo;
996                                if (m_portDepth != 0) {
997                                        freqNo += m_portDepth;
998                                        m_portDepth += (m_portDepthAdd * (e - s - 1));
999                                        if (m_portDepth * m_portDepthAdd > 0) m_portDepth = 0;
1000                                }
1001                m_oscMod1.setFrequency(getFrequency(freqNo));
1002                pwm = m_pulseWidth;
1003                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
1004                    pwm += m_oscMod2.getNextSample() * depth;
1005                    m_oscMod2.addPhase(e - s - 1);
1006                }
1007                if(pwm < 0){
1008                    pwm = 0;
1009                }else if(pwm > 100.0){
1010                    pwm = 100.0;
1011                }
1012                modPulse.setPWM(pwm);
1013                m_oscMod1.getSamplesWithSyncIn(samples, syncLine, s, e);
1014                m_onCounter += e - s;
1015                s = e;
1016            } while(s < end)
1017                        if (m_portDepth == 0) {
1018                m_oscMod1.setFrequency(getFrequency(m_freqNo));
1019                        }
1020        }
1021        // Sync出力, LFOなし, ポルタメントあり
1022        private function getSamplesO_P(samples:Vector.<Number>, start:int, end:int):void {
1023            var s:int = start, e:int, freqNo:int,
1024                syncLine:Vector.<Boolean> = s_syncSources[m_syncPipe];
1025            do {
1026                e = s + s_lfoDelta;
1027                if (e > end) e = end;
1028                freqNo = m_freqNo;
1029                                if (m_portDepth != 0) {
1030                                        freqNo += m_portDepth;
1031                                        m_portDepth += (m_portDepthAdd * (e - s - 1));
1032                                        if (m_portDepth * m_portDepthAdd > 0) m_portDepth = 0;
1033                                }
1034                m_oscMod1.setFrequency(getFrequency(freqNo));
1035                m_oscMod1.getSamplesWithSyncOut(samples, syncLine, s, e);
1036                m_onCounter += e - s;
1037                s = e;
1038            } while(s < end)
1039                        if (m_portDepth == 0) {
1040                m_oscMod1.setFrequency(getFrequency(m_freqNo));
1041                        }
1042        }
1043        // Sync出力, 音程LFO, ポルタメントあり
1044        private function getSamplesOPP(samples:Vector.<Number>, start:int, end:int):void {
1045            var s:int = start, e:int, freqNo:int, depth:Number = m_osc2Sign * m_lfoDepth,
1046                syncLine:Vector.<Boolean> = s_syncSources[m_syncPipe];
1047            do {
1048                e = s + s_lfoDelta;
1049                if (e > end) e = end;
1050                freqNo = m_freqNo;
1051                                if (m_portDepth != 0) {
1052                                        freqNo += m_portDepth;
1053                                        m_portDepth += (m_portDepthAdd * (e - s - 1));
1054                                        if (m_portDepth * m_portDepthAdd > 0) m_portDepth = 0;
1055                                }
1056                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
1057                    freqNo += m_oscMod2.getNextSample() * depth;
1058                    m_oscMod2.addPhase(e - s - 1);
1059                }
1060                m_oscMod1.setFrequency(getFrequency(freqNo));
1061                m_oscMod1.getSamplesWithSyncOut(samples, syncLine, s, e);
1062                m_onCounter += e - s;
1063                s = e;
1064            } while(s < end)
1065        }
1066        // Sync出力, パルス幅(@3)LFO, ポルタメントあり
1067        private function getSamplesOWP(samples:Vector.<Number>, start:int, end:int):void {
1068            var s:int = start, e:int, freqNo:int, pwm:Number, depth:Number = m_osc2Sign * m_lfoDepth * 0.01,
1069                modPulse:MOscPulse = (MOscPulse)(m_oscSet1.getMod(MOscillator.PULSE)),
1070                syncLine:Vector.<Boolean> = s_syncSources[m_syncPipe];
1071            do {
1072                e = s + s_lfoDelta;
1073                if (e > end) e = end;
1074                freqNo = m_freqNo;
1075                                if (m_portDepth != 0) {
1076                                        freqNo += m_portDepth;
1077                                        m_portDepth += (m_portDepthAdd * (e - s - 1));
1078                                        if (m_portDepth * m_portDepthAdd > 0) m_portDepth = 0;
1079                                }
1080                m_oscMod1.setFrequency(getFrequency(freqNo));
1081                pwm = m_pulseWidth;
1082                if (m_onCounter >= m_lfoDelay && (m_lfoEnd == 0 || m_onCounter < m_lfoEnd)) {
1083                    pwm += m_oscMod2.getNextSample() * depth;
1084                    m_oscMod2.addPhase(e - s - 1);
1085                }
1086                if(pwm < 0){
1087                    pwm = 0;
1088                }else if(pwm > 100.0){
1089                    pwm = 100.0;
1090                }
1091                modPulse.setPWM(pwm);
1092                m_oscMod1.getSamplesWithSyncOut(samples, syncLine, s, e);
1093                m_onCounter += e - s;
1094                s = e;
1095            } while(s < end)
1096                        if (m_portDepth == 0) {
1097                m_oscMod1.setFrequency(getFrequency(m_freqNo));
1098                        }
1099        }
1100        }
1101}
Note: See TracBrowser for help on using the browser.