onebyoneblog

<?php
 
class Wave {
 
    /**
     * save wav files to server
     */
    function saveWav($wavByteArray) {
		// create a writable 'wavs' directory in the same directory as this service - probably want to use a different path
		$dir = "wavs";
 
		$fileName = "/sound" . time() . ".wav";
 
		$data = $wavByteArray->data;
		$result = file_put_contents($dir . $fileName, $data);
 
		return $result;
    }
}
 
?>

package {
 
	import com.bit101.components.PushButton;
	import com.bit101.components.Style;
	import flash.display.Sprite;
	import flash.events.Event;
	import com.adobe.audio.format.WAVWriter;
	import flash.events.MouseEvent;
	import flash.events.StatusEvent;
	import flash.events.TimerEvent;
	import flash.net.FileReference;
	import flash.net.NetConnection;
	import flash.net.Responder;
	import flash.text.AntiAliasType;
	import flash.text.TextField;
	import flash.text.TextFieldAutoSize;
	import flash.text.TextFormat;
	import flash.utils.Timer;
 
	import flash.events.SampleDataEvent;
	import flash.media.Microphone;
	import flash.utils.ByteArray;
 
	/**
	 * Record .wav file through mic then send it to users machine or server
	 * @author Devon O.
	 */
	[SWF(width='400', height='200', backgroundColor='#FFFFFF', frameRate='31')]
	public class Main extends Sprite {
 
		public static const GATEWAY_URL:String = "path/to/gateway.php";
 
		private var _startButton:PushButton;
		private var _stopButton:PushButton;
		private var _saveButton:PushButton;
 
		private var _recordingMessage:TextField;
 
		private var _timer:Timer;
		private var _mic:Microphone;
		private var _recordingComplete:Boolean = false;
		private var _soundRecording:ByteArray;
 
		private var _fileRef:FileReference = new FileReference();
 
		public function Main():void {
			if (stage) init();
			else addEventListener(Event.ADDED_TO_STAGE, init);
		}
 
		private function init(e:Event = null):void {
			removeEventListener(Event.ADDED_TO_STAGE, init);
			// entry point
 
			initMicrophone();
			initMessage();
			initUI();
		}
 
		private function initMicrophone():void {
			_mic = Microphone.getMicrophone();
			_mic.rate = 44;
			_mic.gain = 60;
			_mic.addEventListener(StatusEvent.STATUS, onmicStatus);
		}
 
		private function onmicStatus(event:StatusEvent):void {
			_mic.removeEventListener(StatusEvent.STATUS, onmicStatus);
 
			if (event.code == "Microphone.Muted") {
				_recordingMessage.text = "You must allow access\nto Mic to record.";
				_mic.removeEventListener(SampleDataEvent.SAMPLE_DATA, gotMicData);
			} else {
				_recordingMessage.text = "Recording...";
				_timer = new Timer(3000, 1);
				_timer.addEventListener(TimerEvent.TIMER_COMPLETE, timesUp);
				_timer.start();
			}
		}
 
		private function timesUp(event:TimerEvent):void {
			_timer.removeEventListener(TimerEvent.TIMER_COMPLETE, timesUp);
			stopRecording();
		}
 
		private function startRecording(event:MouseEvent):void {			
			_startButton.enabled = false;
			_recordingComplete = true;
			_soundRecording = new ByteArray();
			_mic.addEventListener(SampleDataEvent.SAMPLE_DATA, gotMicData);
		}
 
		private function stopRecording():void{
			_recordingMessage.text = "Recording complete.\nClick 'Save' to export .wav.";
			_saveButton.enabled = true;
			_mic.removeEventListener(SampleDataEvent.SAMPLE_DATA, gotMicData);
		}
 
		private function gotMicData(micData:SampleDataEvent):void {
			_soundRecording.writeBytes(micData.data);
		}
 
		private function saveRecording(event:MouseEvent):void {
			if (_soundRecording == null || _soundRecording.length <= 0) return;
 
			_saveButton.enabled = false;
 
			var wavWriter:WAVWriter = new WAVWriter();
 
			_soundRecording.position = 0;
 
			wavWriter.numOfChannels = 1;
			wavWriter.sampleBitRate = 16;
			wavWriter.samplingRate = 44100;
 
			var wavBytes:ByteArray = new ByteArray();
 
			wavWriter.processSamples(wavBytes, _soundRecording, 44100, 1); // convert our ByteArray to a WAV file.
 
			/* Use something like this to send the .wav to the server rather than the local machine:
 
			var resp:Responder = new Responder(successHandler, errorHandler);
			var gateway:NetConnection = new NetConnection();
			gateway.connect(GATEWAY_URL);
			gateway.call("Wave.saveWav", resp, wavBytes);
 
			*/
 
			// or use this to save it locally
			_fileRef.save(wavBytes, "sound.wav");
		}
 
		private function successHandler(o:Object):void {
			trace(o);
			if (!o) trace("wav file not saved");
		}
 
		private function errorHandler(o:Object):void {
			for (var prop:String in o) trace(prop + " = " + o[prop]);
		}
 
		private function initMessage():void {
			_recordingMessage = new TextField();
			_recordingMessage.selectable = false;
			_recordingMessage.mouseEnabled = false;
			_recordingMessage.autoSize = TextFieldAutoSize.LEFT;
			_recordingMessage.antiAliasType = AntiAliasType.ADVANCED;
			_recordingMessage.defaultTextFormat = new TextFormat("_sans", 24, 0x660000);
			_recordingMessage.text = "Click 'Record' to begin...";
			_recordingMessage.x = 10;
			_recordingMessage.y = 100;
			_recordingMessage.multiline = true;
			addChild(_recordingMessage);
		}
 
		private function initUI():void {
			Style.BUTTON_FACE = 0x000000;
			_startButton = new PushButton(this, 10, 10, "Record", startRecording);
			_saveButton = new PushButton(this, _startButton.x + _startButton.width + 5, 10, "Save", saveRecording);
			_saveButton.enabled = false;
		}
	}
}

wp = new WavPlayer();
wp.addEventListener(ProgressEvent.PROGRESS, onProgress);
wp.addEventListener(Event.COMPLETE, onComplete);
wp.Load("mysound.wav");
 
private function onProgress(event:ProgressEvent):void {
	trace((event.bytesLoaded / event.bytesTotal) * 100);
}
 
private function onComplete(event:Event):void {
	wp.playWav();
}