import { Event } from './Event';
import { ByteArray } from '../utils/ByteArray';
/**
/// @eventType flash.events.SampleDataEvent.SAMPLE_DATA
[Event(name="sampleData", type="flash.events.SampleDataEvent")]
* Dispatched when a Sound object requests new audio data or when a Microphone object
* has new audio data to provide.
*
* This event has two uses:
-
* To provide dynamically generated audio data for a Sound object
-
* To get audio data for a Microphone object
* Dynamically generating audio using the Sound object Use the
* sampleData event to play dynamically generated audio.
* In this environment,
* the Sound object doesn't actually contain sound data. Instead, it acts as a socket for
* sound data that is being streamed to it through the use of the function
* you assign as the handler for the sampleData event.
*
In your function, you use the
* ByteArray.writeFloat() method to write to
* the event's data) property, which contains the sampled data you
* want to play.
If a Sound object has not loaded an MP3 file,
* when you call its play() method
* the object starts dispatching sampleData events,
* requesting sound samples.
* The Sound object continues to send events as the sound plays back until you stop providing data,
* or until the stop() method of the SoundChannel object is called.
*
Thes latency of the event varies from platform to platform, and it could change in future
* versions of Flash Player or AIR. Don't depend on a specific latency.
* Instead calculate it using
* ((SampleDataEvent.position/44.1) - SoundChannelObject.position).
* Provide between 2048 and 8192 samples to the data property of
* the SampleDataEvent object. For best performance, provide as many samples as possible.
* The fewer samples you provide, the more likely it is
* that clicks and pops will occur during playback. This behavior can differ on various platforms
* and can occur in various situations - for example, when resizing the browser.
* You might write code that works on one platform when you provide only 2048 samples, but that same code
* might not work as well when run on a different platform. If you require the lowest latency possible,
* consider making the amount of data user-selectable.
* If you provide fewer than 2048 samples, tha Sound object plays the remaining samples
* and then stops the sound as if the end of a sound file was reached, generating
* a complete event.
* You can use the extract() method of a Sound object
* to extract its sound data,
* which you can then write to the dynamic stream for playback.
* When you use the sampleData event with a Sound object,
* the only Sound methods that
* are enabled are extract()
* and play(). Calling any other methods or properties
* results in an "invalid call" exception. All methods and properties of the SoundChannel object
* are still enabled.
* Capturing Microphone audio Use the sampleData event
* to capture audio data from a microphone. When you add an event listener for the
* sampleData event,
* the Microphone dispatches the event as audio samples
* become available.
In the event handler function,
* use the ByteArray.readFloat() method to read
* the event's data) property,
* which contains the sampled data. The event will contain
* multiple samples, so you should use a while
* loop to read the available data:
var soundBytes:ByteArray = new ByteArray();
* while(event.data.bytesAvailable)
* {
* var sample:Number = event.data.readFloat();
* soundBytes.writeFloat(sample);
* }
*/
export class SampleDataEvent extends Event {
/**
* Defines the value of the type property of a SampleDataEvent event object.
* This event has the following properties:PropertyValuebubblesfalsecancelablefalse;
* there is no default behavior to cancel.positionThe point from which audio data is provided.
*/
public static SAMPLE_DATA: string = 'sampleData';
/**
* The data in the audio stream.
*/
public get data (): ByteArray {
console.log('data not implemented yet in flash/SampleDataEvent');
return null;
}
public set data (thedata: ByteArray) {
console.log('data not implemented yet in flash/SampleDataEvent');
}
/**
* The position of the data in the audio stream.
*/
public get position (): number {
console.log('position not implemented yet in flash/SampleDataEvent');
return 0;
}
public set position (theposition: number) {
console.log('position not implemented yet in flash/SampleDataEvent');
}
/**
* Creates an event object that contains information about audio data events.
* Event objects are passed as parameters to event listeners.
* @param type The type of the event. This value is:Event.SAMPLE_DATA.
* @param bubbles Determines whether the Event object participates in the bubbling stage of the event flow.
* @param cancelable Determines whether the Event object can be canceled.
* @param theposition The position of the data in the audio stream.
* @param thedata A byte array of data.
*/
constructor (type: string, bubbles: boolean = false, cancelable: boolean = false,
theposition: number = 0, thedata: ByteArray = null) {
super(type, bubbles, cancelable);
}
/**
* Creates a copy of the SampleDataEvent object and sets each property's value to match that of the original.
* @return A new SampleDataEvent object with property values that match those of the original.
*/
public clone (): Event {
console.log('clone not implemented yet in flash/SampleDataEvent');
return null;
}
/**
* Returns a string that contains all the properties of the SampleDataEvent object.
* The string is in the following format:
* [SampleDataEvent type=value bubbles=value cancelable=value theposition=value thedata=value]
* @return A string that contains all the properties of the SampleDataEvent object.
*/
public toString (): string {
console.log('toString not implemented yet in flash/SampleDataEvent');
return '';
}
}