root/lang/actionscript/flmml/trunk/src/com/txt_nifty/sketch/flmml/MSequencer.as @ 24775

package com.txt_nifty.sketch.flmml {
    import flash.events.EventDispatcher;
    import flash.events.SampleDataEvent;
    import flash.media.Sound;
    import flash.media.SoundChannel;
    import flash.utils.*;
    import __AS3__.vec.Vector;

    public class MSequencer extends EventDispatcher {
        public var onSignal:Function = null;
        public static const BUFFER_SIZE:int         = 8192;
        public static const RATE44100:int           = 44100;

        protected static const STATUS_STOP:int      = 0;
        protected static const STATUS_PAUSE:int     = 1;
        protected static const STATUS_BUFFERING:int = 2;
        protected static const STATUS_PLAY:int      = 3;
        protected static const STATUS_LAST1:int     = 4;
        protected static const STATUS_LAST2:int     = 5;
        protected var m_sound:Sound;
        protected var m_soundChannel:SoundChannel;
        protected var m_buffer:Vector.<Number>;
        protected var m_trackArr:Array;
        protected var m_volume:int;              // master volume (max:127)
        protected var m_signalArr:Array;
        protected var m_signalPtr:int;
        protected var m_globalTick:uint;
        protected var m_status:int;
        protected var m_signalInterval:int;

        public function MSequencer() {
            MChannel.boot(MSequencer.BUFFER_SIZE);
            MOscillator.boot();
            MEnvelope.boot();
            m_trackArr = new Array();
            m_volume = 100;
            m_signalArr = new Array(3);
            for(var i:int = 0; i < m_signalArr.length; i++) {
                m_signalArr[i] = new MSignal(i);
                m_signalArr[i].setFunction(onSignalHandler);
            }
            m_signalPtr = 0;
            m_buffer = new Vector.<Number>(MSequencer.BUFFER_SIZE*2);
            m_buffer.fixed = true;
            m_sound = new Sound();
            m_soundChannel = new SoundChannel();
            m_status = STATUS_STOP;
            m_signalInterval = 96;
            m_sound.addEventListener(SampleDataEvent.SAMPLE_DATA, onSampleData);
        }

        public function play():void {
            if (m_status != STATUS_PAUSE) {
                stop();
                m_globalTick = 0;
                for (var i:int = 0; i < m_trackArr.length; i++) {
                    m_trackArr[i].seekTop();
                }
            }
            m_status = STATUS_PLAY;
            m_soundChannel = m_sound.play();
        }

        public function stop():void {
            if (m_soundChannel) m_soundChannel.stop();
            m_status = STATUS_STOP;
        }

        public function pause():void {
            if (m_soundChannel) m_soundChannel.stop();
            m_status = STATUS_PAUSE;
        }

        public function setMasterVolume(vol:int):void {
            m_volume = vol;
        }

        public function isPlaying():Boolean {
            return (m_status == STATUS_PLAY);
        }

        public function isPaused():Boolean {
            return (m_status == STATUS_PAUSE);
        }

        public function disconnectAll():void {
            while(m_trackArr.pop());
            m_status = STATUS_STOP;
        }

        public function connect(track:MTrack):void {
            track.m_signalInterval = m_signalInterval;
            m_trackArr.push(track);
        }

        public function getGlobalTick():uint {
            return m_globalTick;
        }

        public function setSignalInterval(interval:int):void {
            m_signalInterval = interval;
        }

        protected function onSignalHandler(globalTick:uint, event:int):void {
            m_globalTick = globalTick;
            if (onSignal != null) onSignal(globalTick, event);
        }

        private function onSampleData(e:SampleDataEvent):void {
            try {
                if (m_status < STATUS_BUFFERING) return;
                if (m_status == STATUS_LAST2) {
                    stop();
                    dispatchEvent(new MMLEvent(MMLEvent.COMPLETE));
                    return;
                }
                if (m_status == STATUS_LAST1) m_status++;
                //var starttime:Date = new Date();
                var amplitude:Number;
                var i:int;
                var sLen:int = MSequencer.BUFFER_SIZE;
                for(i = 0; i < sLen; i++) {
                    m_buffer[i] = m_buffer[i+sLen] = 0.0;
                }
                var signal:MSignal = m_signalArr[m_signalPtr];
                var nt:int = m_trackArr.length;
                if (nt > 0) {
                    var track:MTrack = m_trackArr[MTrack.TEMPO_TRACK];
                    track.onSampleData(m_buffer, signal);
                    for(i = MTrack.FIRST_TRACK; i < nt; i++) {
                        track = m_trackArr[i];
                        track.onSampleData(m_buffer);
                    }
                }
                var mvol:Number = m_volume * (0.25 / 127.0);
                for(i = 0; i < sLen; i++) {
                    e.data.writeFloat(m_buffer[i]      * mvol);
                    e.data.writeFloat(m_buffer[i+sLen] * mvol);
                }

                m_signalArr[(m_signalPtr + m_signalArr.length-1) % m_signalArr.length].start();
                if (m_status < STATUS_PLAY) {
                    m_status++;
                }
                m_signalPtr = (++m_signalPtr) % m_signalArr.length;

                // end of sequence
                if (m_status == STATUS_PLAY) {
                    var n:int = 0;
                    for (i = 0; i < m_trackArr.length; i++) {
                        if (m_trackArr[i].isEnd()) n++;
                    }
                    if (n >= m_trackArr.length) {
                        m_status = STATUS_LAST1;
                    }
                }

                //var endtime:Date = new Date();
                //trace((endtime.getTime() - starttime.getTime()) + "msec.");
            }
            catch (e:Error) {
                stop();
                dispatchEvent(new MMLEvent(MMLEvent.COMPLETE));
            }
        }

        public function createPipes(num:int):void {
            MChannel.createPipes(num);
        }
    }
}