@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/media/ID3Info.ts

@@ -0,0 +1,69 @@
+/**
+ * The ID3Info class contains properties that reflect ID3 metadata. You can get additional
+ * metadata for MP3 files by accessing the <codeph class="+ topic/ph pr-d/codeph ">id3</codeph>
+ * property of the Sound class; for example, <codeph class="+ topic/ph pr-d/codeph ">mySound.id3.TIME</codeph>.
+ * For more information, see the entry for <codeph class="+ topic/ph pr-d/codeph ">Sound.id3</codeph> and
+ * the ID3 tag definitions at <xref href="http://www.id3.org" class="- topic/xref ">http://www.id3.org</xref>.
+ */
+export class ID3Info {
+	constructor () {
+
+	}
+
+	/**
+	 * The name of the album; corresponds to the ID3 2.0 tag TALB.
+	 * @langversion	AS3
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 */
+	public album: string;
+
+	/**
+	 * The name of the artist; corresponds to the ID3 2.0 tag TPE1.
+	 * @langversion	AS3
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 */
+	public artist: string;
+
+	/**
+	 * A comment about the recording; corresponds to the ID3 2.0 tag COMM.
+	 * @langversion	AS3
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 */
+	public comment: string;
+
+	/**
+	 * The genre of the song; corresponds to the ID3 2.0 tag TCON.
+	 * @langversion	AS3
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 */
+	public genre: string;
+
+	/**
+	 * The name of the song; corresponds to the ID3 2.0 tag TIT2.
+	 * @langversion	AS3
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 */
+	public songName: string;
+
+	/**
+	 * The track number; corresponds to the ID3 2.0 tag TRCK.
+	 * @langversion	AS3
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 */
+	public track: string;
+
+	/**
+	 * The year of the recording; corresponds to the ID3 2.0 tag TYER.
+	 * @langversion	AS3
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 */
+	public year: string;
+
+}

package/lib/media/Sound.ts

@@ -0,0 +1,532 @@
+
+import { EventDispatcher } from '../events/EventDispatcher';
+import { Event } from '../events/Event';
+import { IOErrorEvent } from '../events/IOErrorEvent';
+import { URLRequest } from '../net/URLRequest';
+import { SoundLoaderContext } from './SoundLoaderContext';
+import { SoundChannel } from './SoundChannel';
+import { SoundTransform } from './SoundTransform';
+import { ByteArray } from '../utils/ByteArray';
+import { ID3Info } from './ID3Info';
+import {
+	AssetLibrary,
+	LoaderContext,
+	WaveAudio,
+	WaveAudioParser,
+	URLRequest as URLRequestAway,
+	AssetEvent,
+	LoaderEvent,
+	URLLoaderEvent,
+	IAsset,
+	IAudioChannel
+} from '@awayjs/core';
+
+import { SecurityDomain } from '../SecurityDomain';
+
+/**
+ * Dispatched when data is received as a load operation progresses.
+ * @eventType	flash.events.ProgressEvent.PROGRESS
+ [Event(name="progress", type="flash.events.Progress [EventEvent")]
+
+ * Dispatched when a load operation starts.
+ * @eventType	flash.events.Event.OPEN
+ [Event(name="open", type="flash.events. [EventEvent")]
+
+ * Dispatched when an input/output error occurs that causes a load operation to fail.
+ * @eventType	flash.events.IOErrorEvent.IO_ERROR
+ [Event(name="ioError", type="flash.events.IOError [EventEvent")]
+
+ * Dispatched by a Sound object when ID3 data is available for an MP3 sound.
+ * @eventType	flash.events.Event.ID3
+ [Event(name="id3", type="flash.events. [EventEvent")]
+
+ * Dispatched when data has loaded successfully.
+ * @eventType	flash.events.Event.COMPLETE
+ [Event(name="complete", type="flash.events. [EventEvent")]
+
+ * Dispatched when the runtime requests new audio data.
+ * @eventType	flash.events.SampleDataEvent.SAMPLE_DATA
+ [Event(name="sampleData", type="flash.events.SampleData [EventEvent")]
+
+ * The Sound class lets you work with sound in an application. The Sound class
+ * lets you create a Sound object, load and play an external MP3 file into that object,
+ * close the sound stream, and access
+ * data about the sound, such as information about the number of bytes in the stream and
+ * ID3 metadata. More detailed control of the sound is performed through the sound source —
+ * the SoundChannel or Microphone object for the sound — and through the properties
+ * in the SoundTransform class that control the output of the sound to the computer's speakers.
+ *
+ *   <p class="- topic/p ">In Flash Player 10 and later and AIR 1.5 and later, you can also use this
+ * class to work with sound that is generated dynamically.
+ * In this case, the Sound object uses the function you assign to a
+ * <codeph class="+ topic/ph pr-d/codeph ">sampleData</codeph> event handler to
+ * poll for sound data. The sound is played as it is retrieved from a ByteArray object that
+ * you populate with sound data. You can use
+ * <codeph class="+ topic/ph pr-d/codeph ">Sound.extract()</codeph> to extract sound data from a
+ * Sound object,
+ * after which you can manipulate it before writing it back to the stream for playback.
+ * </p><p class="- topic/p ">To control sounds that are embedded in a SWF file,
+ * use the properties in the SoundMixer class.</p><p class="- topic/p ">
+ * <b class="+ topic/ph hi-d/b ">Note</b>: The ActionScript 3.0 Sound API differs from ActionScript 2.0.
+ * In ActionScript 3.0, you cannot take sound objects and arrange them in a hierarchy
+ * to control their properties.</p><p class="- topic/p ">
+ * When you use this class, consider the following security model:
+ * </p><ul class="- topic/ul "><li class="- topic/li ">
+ * Loading and playing a sound is not allowed if the calling file is in a network sandbox
+ * and the sound file to be loaded is local.</li><li class="- topic/li ">
+ * By default, loading and playing a sound is not allowed if the calling file is local and
+ * tries to load and play a remote sound. A user must grant explicit permission to allow this type of access.
+ * </li><li class="- topic/li ">Certain operations dealing with sound are restricted. The data in a loaded sound cannot
+ * be accessed by a file in a different domain unless you implement a cross-domain policy file.
+ * Sound-related APIs that fall under this restriction are <codeph class="+ topic/ph pr-d/codeph ">Sound.id3</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">SoundMixer.computeSpectrum()</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">SoundMixer.bufferTime</codeph>,
+ * and the <codeph class="+ topic/ph pr-d/codeph ">SoundTransform</codeph> class.</li></ul>
+ * <p class="- topic/p ">However, in Adobe AIR, content in the
+ *  <codeph class="+ topic/ph pr-d/codeph ">application</codeph> security sandbox (content
+ * installed with the AIR application) are not restricted by these security limitations.</p>
+ * <p class="- topic/p ">For more information related to security, see the Flash Player Developer Center Topic:
+ * <xref href="http://www.adobe.com/go/devnet_security_en" scope="external" class="- topic/xref ">Security</xref>.</p>
+ */
+
+export class Sound extends EventDispatcher {
+	private _adaptee: WaveAudio;
+	private _url: string;
+	private _loading: boolean;
+	private _playAfterLoad: boolean;
+	private _pendingPlayCommand: IPendingPlayCommand;
+	private _bytesLoaded: number;
+
+	/**
+	 * Creates a new Sound object. If you pass a valid URLRequest object to the
+	 * Sound constructor, the constructor automatically calls the load() function
+	 * for the Sound object.
+	 * If you do not pass a valid URLRequest object to the Sound constructor,
+	 * you must call the load() function for the Sound object yourself,
+	 * or the stream will not load.
+	 *
+	 *   Once load() is called on a Sound object, you can't later load
+	 * a different sound file into that Sound object. To load a different sound file,
+	 * create a new Sound object.
+	 *
+	 *   In Flash Player 10 and later and AIR 1.5 and later, instead of using load(),
+	 * you can use the sampleData event handler to load sound dynamically into the Sound object.
+	 * @param	stream	The URL that points to an external MP3 file.
+	 * @param	context	An optional SoundLoader context object, which can define the buffer time
+	 *   (the minimum number of milliseconds of MP3 data to hold in the Sound object's
+	 *   buffer) and can specify whether the application should check for a cross-domain
+	 *   policy file prior to loading the sound.
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 * @refpath
+	 */
+	constructor (stream: URLRequest = null, context: SoundLoaderContext = null) {
+		super();
+		this._bytesLoaded = 0;
+		this._onAssetCompleteDelegate = (event: AssetEvent) => this.onAssetComplete(event);
+		this._onLoaderCompleteDelegate = (event: LoaderEvent) => this.onLoaderComplete(event);
+		this._onLoadErrorDelegate = (event: URLLoaderEvent) => this.onLoadError(event);
+		if (stream) {
+			this.loadWaveAudio(stream);
+		}
+	}
+
+	private loadWaveAudio(stream: URLRequest) {
+		this._url = stream.url;
+		this._loading = true;
+		AssetLibrary.removeEventListener(AssetEvent.ASSET_COMPLETE, this._onAssetCompleteDelegate);
+		AssetLibrary.removeEventListener(LoaderEvent.LOADER_COMPLETE, this._onLoaderCompleteDelegate);
+		AssetLibrary.removeEventListener(URLLoaderEvent.LOAD_ERROR, this._onLoadErrorDelegate);
+		AssetLibrary.addEventListener(AssetEvent.ASSET_COMPLETE, this._onAssetCompleteDelegate);
+		AssetLibrary.addEventListener(LoaderEvent.LOADER_COMPLETE, this._onLoaderCompleteDelegate);
+		AssetLibrary.addEventListener(URLLoaderEvent.LOAD_ERROR, this._onLoadErrorDelegate);
+		AssetLibrary.load(new URLRequestAway(this._url), new LoaderContext(), this._url, new WaveAudioParser());
+	}
+
+	private _onAssetCompleteDelegate: (event: AssetEvent) => void;
+
+	private onAssetComplete(event: AssetEvent): void {
+		const asset: IAsset = event.asset;
+		if (asset.isAsset(WaveAudio)) {
+			this._adaptee = <WaveAudio>asset;
+			this._loading = false;
+			if (this._pendingPlayCommand) {
+				this.play(this._pendingPlayCommand.startTime / 1000,
+					this._pendingPlayCommand.loops,
+					this._pendingPlayCommand.sndTransform);
+				this._playAfterLoad = false;
+			}
+			this._pendingPlayCommand = null;
+		}
+	}
+
+	private _onLoaderCompleteDelegate: (event: LoaderEvent) => void;
+
+	private onLoaderComplete(event: LoaderEvent): void {
+		if (event.url != this._url) {
+			return;
+		}
+		this._loading = false;
+		this._bytesLoaded = 1000;
+		AssetLibrary.removeEventListener(AssetEvent.ASSET_COMPLETE, this._onAssetCompleteDelegate);
+		AssetLibrary.removeEventListener(LoaderEvent.LOADER_COMPLETE, this._onLoaderCompleteDelegate);
+		AssetLibrary.removeEventListener(URLLoaderEvent.LOAD_ERROR, this._onLoadErrorDelegate);
+		this.dispatchEvent(new (<SecurityDomain> this.sec).flash.events.Event(Event.COMPLETE));
+	}
+
+	private _onLoadErrorDelegate: (event: URLLoaderEvent) => void;
+
+	private onLoadError(event: URLLoaderEvent): void {
+		AssetLibrary.removeEventListener(AssetEvent.ASSET_COMPLETE, this._onAssetCompleteDelegate);
+		AssetLibrary.removeEventListener(LoaderEvent.LOADER_COMPLETE, this._onLoaderCompleteDelegate);
+		AssetLibrary.removeEventListener(URLLoaderEvent.LOAD_ERROR, this._onLoadErrorDelegate);
+		console.log('load error in Sound', event);
+		this._loading = false;
+		this.dispatchEvent(new (<SecurityDomain> this.sec).flash.events.IOErrorEvent(IOErrorEvent.ERROR));
+	}
+
+	public get adaptee(): WaveAudio {
+		return (<WaveAudio> this._adaptee);
+	}
+
+	public set adaptee(adaptee: WaveAudio) {
+		this._adaptee = adaptee;
+	}
+
+	/**
+	 * Returns the currently available number of bytes in this sound object. This property is
+	 * usually useful only for externally loaded files.
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 * @refpath
+	 */
+	public get bytesLoaded (): number {
+		return this._bytesLoaded;
+	}
+
+	/**
+	 * Returns the total number of bytes in this sound object.
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 * @refpath
+	 */
+	public get bytesTotal (): number {
+		return 1000;
+	}
+
+	/**
+	 * Provides access to the metadata that is part of an MP3 file.
+	 *
+	 *   MP3 sound files can contain ID3 tags, which provide metadata about the
+	 * file. If an MP3 sound that you load using the Sound.load()
+	 * method contains ID3 tags, you can query these properties. Only ID3 tags
+	 * that use the UTF-8 character set are supported.Flash Player 9 and later and AIR support
+	 * ID3 2.0 tags,
+	 * specifically 2.3 and 2.4. The following tables list the standard ID3 2.0 tags
+	 * and the type of content the tags represent. The Sound.id3 property provides
+	 * access to these tags through the format
+	 * my_sound.id3.COMM, my_sound.id3.TIME, and so on. The first
+	 * table describes tags that can be accessed either through the ID3 2.0 property name or
+	 * the ActionScript property name. The second table describes ID3 tags that are supported but do not have
+	 * predefined properties in ActionScript. ID3 2.0 tagCorresponding
+	 * The following table describes ID3 tags that are supported but do not have
+	 * predefined properties in the Sound class. You access them by calling
+	 * mySound.id3.TFLT, mySound.id3.TIME, and so on. NOTE: None of
+	 * these tags are supported in Flash Lite 4.
+	 * that are in the same security sandbox as the sound file. For files in other sandboxes, there
+	 * are security checks.When you load the sound, using the load() method of the Sound class, you can
+	 * specify a context parameter, which is a SoundLoaderContext object. If you set the
+	 * checkPolicyFile  property of the SoundLoaderContext object to true, Flash Player
+	 * checks for a URL policy file on the server from which the sound is loaded. If a
+	 * policy file exists and permits access from the domain of the loading SWF file, then the file is allowed
+	 * to access the id3 property of the Sound object; otherwise it is not.However,
+	 * in Adobe AIR, content in the application security sandbox (content
+	 * installed with the AIR application) are not restricted by these security limitations.
+	 * For more information related to security, see the Flash Player Developer Center Topic:
+	 * Security.
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 */
+	public get id3 (): ID3Info {
+		console.log('id3 not implemented yet in flash/Sound');
+		return null;
+	}
+
+	/**
+	 * Returns the buffering state of external MP3 files. If the value is true,
+	 * any playback is
+	 * currently suspended while the object waits for more data.
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 * @refpath
+	 */
+	public get isBuffering (): boolean {
+		console.log('isBuffering not implemented yet in flash/Sound');
+		return false;
+	}
+
+	/**
+	 * Indicates if the Sound.url property has been
+	 * truncated. When the isURLInaccessible value is true the
+	 * Sound.url value is only the domain of the final URL from which the sound loaded.
+	 * For example, the property is truncated if the sound is loaded from http://www.adobe.com/assets/hello.mp3,
+	 * and the Sound.url property has the value http://www.adobe.com.
+	 * The isURLInaccessible value is true only when all of the following are also true:
+	 *
+	 *   An HTTP redirect occurred while loading the sound file.
+	 * The SWF file calling Sound.load() is from a different domain than
+	 * the sound file's final URL.The SWF file calling Sound.load() does not have permission to access
+	 * the sound file.  Permission is granted to access the sound file the same way permission is granted
+	 * for the Sound.id3 property: establish a policy file and use the SoundLoaderContext.checkPolicyFile
+	 * property.Note: The isURLInaccessible property was added for Flash Player 10.1 and AIR 2.0.
+	 * However, this property is made available to SWF files of all versions when the
+	 * Flash runtime supports it. So, using some authoring tools in "strict mode" causes a compilation error.
+	 * To work around the error use the indirect syntax mySound["isURLInaccessible"],
+	 * or disable strict mode. If you are using Flash Professional CS5
+	 * or Flex SDK 4.1, you can use and compile this API for runtimes released
+	 * before Flash Player 10.1 and AIR 2.For application
+	 * content in AIR, the value of this property is always false.
+	 * @langversion	3.0
+	 * @playerversion	Flash 10.1
+	 * @playerversion	AIR 2
+	 */
+	public get isURLInaccessible (): boolean {
+		console.log('isURLInaccessible not implemented yet in flash/Sound');
+		return false;
+	}
+
+	/**
+	 * The length of the current sound in milliseconds.
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 */
+	public get length (): number {
+		if (!this._adaptee)
+			return;
+		return this._adaptee.duration * 1000;
+	}
+
+	/**
+	 * The URL from which this sound was loaded. This property is applicable only to Sound
+	 * objects that were loaded using the Sound.load() method. For
+	 * Sound objects that are associated with a sound asset from a SWF file's library, the
+	 * value of the url property is null.
+	 *
+	 *   When you first call Sound.load(), the url property
+	 * initially has a value of null, because the final URL is not yet known.
+	 * The url property will have a non-null value as soon as an
+	 * open event is dispatched from the Sound object.The url property contains the final,
+	 * absolute URL from which a sound was
+	 * loaded. The value of url is usually the same as the value passed to the
+	 * stream parameter of Sound.load().
+	 * However, if you passed a relative URL to Sound.load()
+	 * the value of the url property represents the absolute URL.
+	 * Additionally, if the original URL request is redirected by an HTTP server, the value
+	 * of the url property reflects the final URL from which the sound file was actually
+	 * downloaded.  This reporting of an absolute, final URL is equivalent to the behavior of
+	 * LoaderInfo.url.In some cases, the value of the url property is truncated; see the
+	 * isURLInaccessible property for details.
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 */
+	public get url (): string {
+		return this._url;
+	}
+
+	/**
+	 * Closes the stream, causing any download of data to cease.
+	 * No data may be read from the stream after the close()
+	 * method is called.
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 * @refpath
+	 * @throws	IOError The stream could not be closed, or
+	 *   the stream was not open.
+	 */
+	public close () {
+		console.log('close not implemented yet in flash/Sound');
+	}
+
+	/**
+	 * Extracts raw sound data from a Sound object.
+	 *
+	 *   This method is designed to be used when you are working
+	 * with dynamically generated audio, using a function you assign
+	 * to the sampleData event for a different Sound object.
+	 * That is, you can use this method to extract sound data from a Sound object.
+	 * Then you can write the data to the byte array that another Sound object is using
+	 * to stream dynamic audio.The audio data is placed in the target byte
+	 * array starting from the current position of the byte array.
+	 * The audio data is always exposed as 44100 Hz Stereo. The sample type is a 32-bit floating-point value,
+	 * which can be converted to a Number using ByteArray.readFloat().
+	 * @param	target	A ByteArray object in which the extracted sound samples are placed.
+	 * @param	length	The number of sound samples to extract.
+	 *   A sample contains both the left and right channels — that is, two 32-bit floating-point values.
+	 * @param	startPosition	The sample at which extraction begins.
+	 *   If you don't specify a value, the first call to Sound.extract() starts at the beginning
+	 *   of the sound; subsequent calls without a value for startPosition
+	 *   progress sequentially through the file.
+	 * @return	The number of samples written to the ByteArray specified in the target parameter.
+	 * @langversion	3.0
+	 * @playerversion	Flash 10
+	 * @playerversion	AIR 1.5
+	 * @refpath
+	 */
+	public extract (target: ByteArray, length: number, startPosition: number = -1): number {
+		console.log('extract not implemented yet in flash/Sound');
+		return 0;
+	}
+
+	/**
+	 * Initiates loading of an external MP3 file from the specified URL. If you provide
+	 * a valid URLRequest object to the Sound constructor, the constructor calls
+	 * Sound.load() for you. You only need to call Sound.load()
+	 * yourself if you
+	 * don't pass a valid URLRequest object to the Sound constructor or you pass a null
+	 * value.
+	 *
+	 *   Once load() is called on a Sound object, you can't later load
+	 * a different sound file into that Sound object. To load a different sound file,
+	 * create a new Sound object.When using this method, consider the following security model:Calling Sound.load()
+	 * is not allowed if the calling file is in the
+	 * local-with-file-system sandbox and the sound is in a network sandbox.
+	 * Access from the local-trusted or local-with-networking sandbox requires permission
+	 * from a website through a URL policy file.You cannot connect to commonly reserved ports.
+	 * For a complete list of blocked ports, see "Restricting Networking APIs" in the
+	 * ActionScript 3.0 Developer's Guide.You can prevent a SWF file from using this method by setting the
+	 * allowNetworking parameter of the object and embed
+	 * tags in the HTML page that contains the SWF content. In Flash Player 10 and later,
+	 * if you use a multipart Content-Type (for example "multipart/form-data")
+	 * that contains an upload (indicated by a "filename" parameter
+	 * in a "content-disposition" header within the POST body),
+	 * the POST operation is subject to the security rules applied to uploads:
+	 * The POST operation must be performed in response to a user-initiated action
+	 * such as a mouse click or key press.If the POST operation is cross-domain
+	 * (the POST target is not on the same server as the SWF file
+	 * that is sending the POST request),
+	 * the target server must provide a URL policy file that permits cross-domain access.
+	 * Also, for any multipart Content-Type, the syntax must be valid (according to the RFC2046 standards).
+	 * If the syntax appears to be invalid, the POST operation is subject to the security rules applied to uploads.
+	 * In Adobe AIR, content in the application security sandbox (content
+	 * installed with the AIR application) are not restricted by these security limitations.For more
+	 * information related to security, see the Flash Player Developer Center Topic:
+	 * Security.
+	 * @param	stream	A URL that points to an external MP3 file.
+	 * @param	context	An optional SoundLoader context object, which can define the buffer time
+	 *   (the minimum number of milliseconds of MP3 data to hold in the Sound object's
+	 *   buffer) and can specify whether the application should check for a cross-domain
+	 *   policy file prior to loading the sound.
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 * @refpath
+	 * @throws	IOError A network error caused the load to fail.
+	 * @throws	SecurityError Local untrusted files may not communicate with
+	 *   the Internet. You can work around this by reclassifying this file
+	 *   as local-with-networking or trusted.
+	 * @throws	SecurityError You cannot connect to commonly reserved ports.
+	 *   For a complete list of blocked ports, see "Restricting Networking APIs" in the
+	 *   ActionScript 3.0 Developer's Guide.
+	 * @throws	IOError The digest property of the stream object is not
+	 *   null. You should only set the digest property of a URLRequest object
+	 *   when calling the URLLoader.load() method when loading a SWZ file (an Adobe
+	 *   platform component).
+	 */
+	public load (stream: URLRequest, context: SoundLoaderContext = null) {
+		this.loadWaveAudio(stream);
+	}
+
+	public loadCompressedDataFromByteArray (_bytes: ByteArray, _bytesLength: number) {
+		console.log('loadCompressedDataFromByteArray not implemented yet in flash/Sound');
+	}
+
+	public loadPCMFromByteArray (
+		_bytes: ByteArray,
+		_samples: number,
+		_format: string = 'float',
+		_stereo: boolean = true,
+		_sampleRate: number = 44100) {
+		console.log('loadPCMFromByteArray not implemented yet in flash/Sound');
+	}
+
+	/**
+	 * Generates a new SoundChannel object to play back the sound. This method
+	 * returns a SoundChannel object, which you access to stop the sound and to monitor volume.
+	 * (To control the volume, panning, and balance, access the SoundTransform object assigned
+	 * to the sound channel.)
+	 * @param	startTime	The initial position in milliseconds at which playback should
+	 *   start.
+	 * @param	loops	Defines the number of times a sound loops back to the startTime value
+	 *   before the sound channel stops playback.
+	 * @param	sndTransform	The initial SoundTransform object assigned to the sound channel.
+	 * @return	A SoundChannel object, which you use to control the sound.
+	 *   This method returns null if you have no sound card
+	 *   or if you run out of available sound channels. The maximum number of
+	 *   sound channels available at once is 32.
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 * @refpath
+	 */
+	public play (startTime: number = 0, loops: number = 0, sndTransform: SoundTransform = null): SoundChannel {
+		if (!this.adaptee && !this._loading) {
+			console.warn('[Sound#play]: no adaptee exists!');
+
+			// return empty SoundChannel to prevent crash when adaptee is not exist
+			return new (<SecurityDomain> this.sec).flash.media.SoundChannel();
+		}
+
+		if (!this.adaptee && this._loading) {
+			this._pendingPlayCommand = {
+				startTime: startTime,
+				loops: loops,
+				sndTransform: sndTransform,
+				sndChannel: new (<SecurityDomain> this.sec).flash.media.SoundChannel()
+			};
+
+			return this._pendingPlayCommand.sndChannel;
+		}
+
+		startTime = (isNaN(startTime) || startTime < 0) ? 0 : Math.floor(startTime);
+		loops = isNaN(loops) ? 0 : loops < 1 ? 1 : Math.floor(loops);
+
+		const channel: IAudioChannel =  <any> this._adaptee.play(startTime / 1000, loops);
+
+		if (!channel) {
+			console.debug('[Sound] Sound channel missed, channel pool overflow for:', this._adaptee.id);
+		}
+
+		const newSoundChannel: SoundChannel = this._pendingPlayCommand ?
+			this._pendingPlayCommand.sndChannel :
+			new (<SecurityDomain> this.sec).flash.media.SoundChannel();
+
+		sndTransform = sndTransform || new (<SecurityDomain> this.sec).flash.media.SoundTransform();
+
+		newSoundChannel.init(
+			channel,
+			sndTransform
+		);
+
+		return newSoundChannel;
+	}
+
+	/* internal */ stopAll (): void {
+		this._adaptee.stop();
+	}
+
+}
+
+interface IPendingPlayCommand {
+	startTime: number,
+	loops: number,
+	sndTransform: SoundTransform,
+	sndChannel: SoundChannel
+}