flexPartyPlayer 0.0.1

data/src/com/automatastudios/audio/audiodecoder/decoders/WAVDecoder.as

@@ -0,0 +1,325 @@
+package com.automatastudios.audio.audiodecoder.decoders {
+	import com.automatastudios.audio.audiodecoder.events.AudioDecoderEvent;
+	import com.automatastudios.data.riff.RIFFChunkInfo;
+	import com.automatastudios.data.riff.RIFFParser;
+	
+	import flash.errors.EOFError;
+	import flash.events.EventDispatcher;
+	import flash.events.Event;
+	import flash.events.IOErrorEvent;
+	import flash.events.ProgressEvent;
+	import flash.errors.EOFError;
+	import flash.net.URLStream;
+	import flash.utils.ByteArray;
+	import flash.utils.Endian;
+	import flash.utils.IDataInput;		
+		
+	
+	public class WAVDecoder extends EventDispatcher implements IDecoder {
+		private var _data:IDataInput;
+		private var _riffParser:RIFFParser;
+		private var _audioInfo:AudioInfo;
+		private var _nextMethod:Function;
+		private var _convertMethod:Function;
+		private var _isBuffering:Boolean;
+		private var _bufferSize:uint;
+		
+		private var _dataSize:uint;
+		private var _position:uint;
+		private var _isSmallFile:Boolean;
+		
+		public function WAVDecoder():void {
+			// do nothing, wait for init
+		}
+		
+		public function init(data:IDataInput, bufferSize:uint, progressEventName:String):void {
+			_data = data;
+			_riffParser = new RIFFParser(data);
+			_bufferSize = bufferSize;
+			
+			_position = 0;
+			_dataSize = 0;
+			
+			_nextMethod = parseRIFFChunk;
+			
+			if (progressEventName != null) {
+				_isSmallFile = true;
+				(data as EventDispatcher).addEventListener(progressEventName, onDataProgress);
+				(data as EventDispatcher).addEventListener(Event.COMPLETE, onDataComplete);
+			} else {
+				_nextMethod();
+			}	
+		}
+		
+		public function getSamples(position:Number, numSamples:uint, sampleData:ByteArray):void {
+			var numBytes:uint = numSamples * _audioInfo.blockAlign / _audioInfo.sampleMultiplier;
+			var dataReadSize:int;
+			var sampleReadSize:int;
+			var rawSampleData:ByteArray = new ByteArray();
+			var i:uint;
+			
+			try {
+				dataReadSize = _riffParser.streamChunkData(numBytes, rawSampleData);
+				
+				sampleReadSize = dataReadSize / _audioInfo.blockAlign;
+				
+				_position += dataReadSize;
+				rawSampleData.endian = Endian.LITTLE_ENDIAN;
+				
+				_convertMethod(sampleReadSize, rawSampleData, sampleData);
+				
+				if (!_riffParser.isDataComplete) {
+					// padd with extra 0s as needed
+					for (i=sampleReadSize * _audioInfo.sampleMultiplier; i<numSamples; ++i) {
+						sampleData.writeFloat(0);
+						sampleData.writeFloat(0);
+					}
+				} else {
+					dispatchEvent(new Event(Event.COMPLETE));
+				}
+				
+			} catch (error:EOFError) {
+				// padd with extra 0s as needed
+				for (i=0; i<numSamples; ++i) {
+					sampleData.writeFloat(0);
+					sampleData.writeFloat(0);
+				}
+			}
+		}
+		
+		public function getAudioInfo():AudioInfo {
+			return _audioInfo;
+		}
+		
+		public function getTotalTime():Number {
+			return ((_dataSize / (_audioInfo.blockAlign * _audioInfo.sampleMultiplier)) / 44100);
+		}
+		
+		public function getPosition():Number {
+			return ((_position / (_audioInfo.blockAlign * _audioInfo.sampleMultiplier)) / 44100);
+		}
+
+		private function onDataProgress(event:Event):void {
+			if (_nextMethod != null) {
+				if (_data.bytesAvailable >= _bufferSize) {
+					_isSmallFile = false;
+					_nextMethod();
+				}
+			}
+		}
+		
+		private function onDataComplete(event:Event):void {
+			if (_isSmallFile) {
+				_bufferSize = _data.bytesAvailable;
+				
+				_nextMethod();
+			}
+		}
+		
+		private function parseRIFFChunk():void {
+			var headerInfo:RIFFChunkInfo;
+		
+			try {
+				headerInfo = _riffParser.readChunk();
+				
+				if (headerInfo.chunkId == "RIFF") {
+					
+					_nextMethod = parseRIFFSubChunk;
+					_nextMethod();
+				} else {
+					dispatchEvent(new IOErrorEvent(IOErrorEvent.IO_ERROR, false, false, "Bad audio format"));	
+				}
+			} catch (error:EOFError) {
+				// do nothing, wait for next attempt
+			}
+		}
+		
+		private function parseRIFFSubChunk():void {
+			var subChunkFormat:String;
+			
+			try {
+				subChunkFormat = _riffParser.readSubChunk();
+				
+				if (subChunkFormat == "WAVE") {
+					_nextMethod = locateFormatChunk;
+					_nextMethod();
+				} else {
+					dispatchEvent(new IOErrorEvent(IOErrorEvent.IO_ERROR, false, false, "Bad audio format"));
+				}
+			} catch (error:EOFError) {
+				// do nothing, wait for next attempt
+			}
+		}
+		
+		private function locateFormatChunk():void {
+			var chunkInfo:RIFFChunkInfo;
+
+			try {
+				chunkInfo = _riffParser.readChunk();
+				
+				while (chunkInfo.chunkId != "fmt " && chunkInfo != null) {
+					chunkInfo = _riffParser.readChunk();
+				}
+				
+				if (chunkInfo.chunkId == "fmt ") {
+					_nextMethod = parseFormatChunk; 
+					_nextMethod();
+				} else {
+					dispatchEvent(new IOErrorEvent(IOErrorEvent.IO_ERROR, false, false, "Bad audio format"));		
+				}
+			} catch (error:EOFError) {
+				// do nothing, wait for next attempt
+			}			
+		}
+		
+		private function parseFormatChunk():void {
+			var chunkData:ByteArray;
+			
+			try {
+				chunkData = _riffParser.readChunkData();
+				chunkData.endian = Endian.LITTLE_ENDIAN;
+
+
+				if (chunkData.length >= 16) {
+					_audioInfo = new AudioInfo();
+					_audioInfo.decoder = "com.automatastudios.audio.audiodecoder.decoders.WAVDecoder";
+					_audioInfo.format = (chunkData.readUnsignedShort() == 1 ? "PCM" : "Unknown");
+					_audioInfo.channels = chunkData.readUnsignedShort();
+					_audioInfo.sampleRate = chunkData.readUnsignedInt();
+					_audioInfo.bitRateUpper =
+					_audioInfo.bitRateLower = chunkData.readUnsignedInt()/8;
+					_audioInfo.blockAlign = chunkData.readUnsignedShort();
+					_audioInfo.bitsPerSample = chunkData.readUnsignedShort();
+					_audioInfo.sampleMultiplier =  44100 / _audioInfo.sampleRate;
+					
+					trace(_audioInfo.toString());
+
+					if (_audioInfo.channels == 1) {
+						if (_audioInfo.bitsPerSample == 8) {
+							_convertMethod = convert8BitMono;
+						} else if (_audioInfo.bitsPerSample == 16) {
+							_convertMethod = convert16BitMono;
+						}
+					} else if (_audioInfo.channels == 2) {
+						if (_audioInfo.bitsPerSample == 8) {
+							_convertMethod = convert8BitStereo;
+						} else if (_audioInfo.bitsPerSample == 16) {
+							_convertMethod = convert16BitStereo;
+						}						
+					}
+
+					if (_audioInfo.format != "PCM" || _convertMethod == null) {
+						dispatchEvent(new IOErrorEvent(IOErrorEvent.IO_ERROR, false, false, "Bad audio format"));
+						_nextMethod = null;	
+					} else if (_audioInfo.sampleRate != 44100 && _audioInfo.sampleRate != 22050 && _audioInfo.sampleRate != 11025) {
+						dispatchEvent(new IOErrorEvent(IOErrorEvent.IO_ERROR, false, false, "Bad sample rate"));
+						_nextMethod = null;	
+					} else {
+						_nextMethod = locateDataChunk;
+						_nextMethod();
+					}
+				
+				} else {
+					dispatchEvent(new IOErrorEvent(IOErrorEvent.IO_ERROR, false, false, "Bad audio format"));	
+				}
+
+			} catch (error:EOFError) {
+				// do nothing, wait for next attempt
+			}			
+		}
+		
+		private function locateDataChunk():void {
+			var chunkInfo:RIFFChunkInfo;
+
+			try {
+				_nextMethod = null;
+				chunkInfo = _riffParser.readChunk();
+				
+				while (chunkInfo.chunkId != "data" && chunkInfo != null) {
+					chunkInfo = _riffParser.readChunk();
+				}
+
+				if (chunkInfo.chunkId == "data") {
+					_dataSize = chunkInfo.size;
+					dispatchEvent(new Event(Event.INIT));
+					
+					_nextMethod = null;
+				} else {
+					dispatchEvent(new IOErrorEvent(IOErrorEvent.IO_ERROR, false, false, "Bad audio format"));		
+				}
+
+				
+			} catch (error:EOFError) {
+				// do nothing, wait for next attempt
+			}			
+		}
+		
+		private function convert8BitMono(numSamples:uint, inputData:ByteArray, outputData:ByteArray):void {
+			var i:uint;
+			var j:uint;
+			var sample:Number;
+			
+			for (i=0; i<numSamples; ++i) {
+				sample = (inputData.readUnsignedByte() - 128) / 128;
+				for (j=0; j< _audioInfo.sampleMultiplier; ++j) {
+					outputData.writeFloat(sample);
+					outputData.writeFloat(sample);
+				}
+			}
+		}
+		
+		private function convert16BitMono(numSamples:uint, inputData:ByteArray, outputData:ByteArray):void {
+			var i:uint;
+			var j:uint;
+			var sample:Number;
+			
+			for (i=0; i<numSamples; ++i) {
+				sample = inputData.readShort();
+				sample /= 32768;
+				
+				for (j=0; j< _audioInfo.sampleMultiplier; ++j) {
+					outputData.writeFloat(sample);
+					outputData.writeFloat(sample);
+				}
+			}			
+		}
+		
+		private function convert8BitStereo(numSamples:uint, inputData:ByteArray, outputData:ByteArray):void {
+			var i:uint;
+			var j:uint;
+			var sample:Number;
+			
+			for (i=0; i<numSamples; ++i) {
+				sample = (inputData.readUnsignedByte() - 128) / 128;
+				for (j=0; j< _audioInfo.sampleMultiplier; ++j) {
+					outputData.writeFloat(sample);
+				}
+				
+				sample = (inputData.readUnsignedByte() - 128) / 128;
+				for (j=0; j< _audioInfo.sampleMultiplier; ++j) {
+					outputData.writeFloat(sample);
+				}
+			}			
+		}
+		
+		private function convert16BitStereo(numSamples:uint, inputData:ByteArray, outputData:ByteArray):void {
+			var i:uint;
+			var j:uint;
+			var leftSample:Number;
+			var rightSample:Number;
+			var count:uint = 0;
+			
+			for (i=0; i<numSamples; ++i) {
+				leftSample = inputData.readShort() / 32767;
+				rightSample = inputData.readShort() / 32767;
+				
+				for (j=0; j< _audioInfo.sampleMultiplier; ++j) {
+					outputData.writeFloat(leftSample);
+					outputData.writeFloat(rightSample);
+					++count;
+					++count;
+				}
+			}
+		}				
+	}
+}

data/src/com/automatastudios/audio/audiodecoder/events/AudioDecoderEvent.as

@@ -0,0 +1,13 @@
+package com.automatastudios.audio.audiodecoder.events {
+	import flash.events.Event;
+
+	public class AudioDecoderEvent extends Event {
+		public static const INVALID_SAMPLE_RATE:String = "audioDecoderInvalidSampleRate";
+		public static const INVALID_FORMAT:String = "audioDecoderInvalidFormat";
+		
+		public function AudioDecoderEvent(type:String, bubbles:Boolean=false, cancelable:Boolean=false) {
+			super(type, bubbles, cancelable);
+		}
+		
+	}
+}

data/src/com/automatastudios/data/riff/RIFFChunkInfo.as

@@ -0,0 +1,6 @@
+package com.automatastudios.data.riff {
+	public class RIFFChunkInfo {
+		public var chunkId:String;
+		public var size:uint;
+	}
+}

data/src/com/automatastudios/data/riff/RIFFParser.as

@@ -0,0 +1,175 @@
+package com.automatastudios.data.riff {
+	import flash.errors.EOFError;
+	import com.automatastudios.audio.audiodecoder.events.AudioDecoderEvent;
+	import com.automatastudios.audio.audiodecoder.events.AudioDecoderEvent;
+	import flash.events.EventDispatcher;
+	import flash.events.Event;
+	import flash.events.ProgressEvent;
+	import flash.errors.EOFError;
+	import flash.net.URLStream;
+	import flash.utils.ByteArray;
+	import flash.utils.Endian;
+	import flash.utils.IDataInput;	
+		
+	public class RIFFParser {
+		private var _data:IDataInput;
+		private var _currentSize:uint;
+		private var _chunkSize:uint;
+		private var _currentPosition:uint;
+		private var _startPosition:uint;
+		private var _isDataComplete:Boolean;
+		private var _dataSize:uint;
+		
+		private var _positionStack:Array;
+		private var _sizeStack:Array;
+		
+		public function RIFFParser(data:IDataInput = null) {
+			_data = data;
+			_sizeStack = new Array();
+			_positionStack = new Array();
+			_currentPosition = 0;
+			_currentSize = 0;
+			_startPosition = 0;
+			_isDataComplete = false;			
+			
+			if (_data is ByteArray) {
+				_dataSize = (_data as ByteArray).length;
+			} else {	
+				(_data as EventDispatcher).addEventListener(ProgressEvent.PROGRESS, onDataProgress);
+			}
+		}
+		
+		public function get isDataComplete():Boolean {
+			return _isDataComplete;
+		}
+		
+		public function parse(data:IDataInput):void {
+			_data = data;
+			_sizeStack = new Array();
+			_positionStack = new Array();
+			_currentPosition = 0;
+			_currentSize = 0;
+			_startPosition = 0;
+			
+			if (_data is ByteArray) {
+				_isDataComplete = true;
+			} else {
+				_isDataComplete = false;
+			}
+		}
+		
+		public function readChunk():RIFFChunkInfo {
+			var chunkInfo:RIFFChunkInfo;
+			
+			_data.endian = Endian.BIG_ENDIAN;
+			
+			if (_data.bytesAvailable >= 8) {
+
+				// move on to next chunk
+				if (_currentSize > 0) {
+					_data.readBytes(new ByteArray(), 0, _currentSize - (_currentPosition - _startPosition));
+				}
+				
+				// check to see if we need to pop up the stack
+				while(_sizeStack.length > 0 && _sizeStack[_sizeStack.length - 1] - _currentPosition - _positionStack[_positionStack.length - 1] < 1) {
+					_sizeStack.pop();
+					_positionStack.pop();
+				}
+				
+				// if on an odd byte remove the padding byte
+				if (_currentPosition % 2 == 1) {
+					_data.readUnsignedByte();
+					++_currentPosition;
+				}
+	
+				chunkInfo = new RIFFChunkInfo();
+				chunkInfo.chunkId = String.fromCharCode(_data.readUnsignedByte(), 
+												_data.readUnsignedByte(), 
+												_data.readUnsignedByte(), 
+												_data.readUnsignedByte());
+				
+				_data.endian = Endian.LITTLE_ENDIAN;				
+				chunkInfo.size = 
+				_chunkSize = 
+				_currentSize = _data.readUnsignedInt();
+				
+				_currentPosition += 8;
+				_startPosition = _currentPosition;
+												
+				return chunkInfo;
+			} else {
+				throw new EOFError("Not enough data available to read chunk");
+			}
+		}
+		
+		public function readSubChunk():String {
+			var subChunkId:String = "";
+			
+			if (_data.bytesAvailable >= 4) {
+		
+				_sizeStack.push(_currentSize);
+				_positionStack.push(_startPosition);
+				
+				_currentSize = 0;
+				_startPosition = 0;
+				
+				_data.endian = Endian.BIG_ENDIAN;
+	
+				subChunkId = String.fromCharCode(_data.readUnsignedByte(), 
+												_data.readUnsignedByte(), 
+												_data.readUnsignedByte(), 
+												_data.readUnsignedByte());
+								
+				
+				_currentPosition += 4;
+	
+				return subChunkId;
+			} else {
+				throw new EOFError("Not enough data avilable to read sub chunk");
+			}
+		}
+		
+		public function readChunkData():ByteArray {
+			var chunkData:ByteArray;
+			
+			if (_data.bytesAvailable >= _currentSize) {
+				chunkData = new ByteArray();
+				_data.readBytes(chunkData, 0, _currentSize);
+				_currentPosition += _currentSize;
+				_currentSize = 0;
+
+				return chunkData;
+			} else {
+				throw new EOFError("Not enough data avilable to read chunk data");
+			}
+		}
+		
+		public function streamChunkData(bufferSize:uint, streamData:ByteArray):uint {
+			var readSize:int = Math.min(bufferSize, _currentSize);
+			var maxPosition:uint = Math.min(_chunkSize, _currentPosition + _data.bytesAvailable);
+			var movedPosition:uint;
+					
+			readSize = Math.max(readSize, 0);
+
+			if (_data.bytesAvailable >= readSize) {
+				if (readSize > 0) {
+					_data.readBytes(streamData, streamData.length, readSize);
+					_currentPosition += readSize;
+					_currentSize -= readSize;
+				}
+				
+				if (_currentSize == 0 && _dataSize > 0) {
+					_isDataComplete = true;
+				}
+				
+				return readSize;
+			} else {
+				throw new EOFError("Not enough data avilable to read " + readSize + " bytes from chunk data");
+			}	
+		}
+		
+		private function onDataProgress(event:ProgressEvent):void {
+			_dataSize = event.bytesTotal;
+		}
+	}
+}