/**
* Initializes an audio encoder resource. The plugin should call Initialize()
* successfully before calling any of the functions below.
*
* @param[in] audio_encoder A <code>PP_Resource</code> identifying the audio
* encoder.
* @param[in] channels The number of audio channels to encode.
* @param[in] input_sampling_rate The sampling rate of the input audio buffer.
* @param[in] input_sample_size The sample size of the input audio buffer.
* @param[in] output_profile A <code>PP_AudioProfile</code> specifying the
* codec profile of the encoded output stream.
* @param[in] initial_bitrate The initial bitrate for the encoder.
* @param[in] acceleration A <code>PP_HardwareAcceleration</code> specifying
* whether to use a hardware accelerated or a software implementation.
* @param[in] callback A <code>PP_CompletionCallback</code> to be called upon
* completion.
*
* @return An int32_t containing an error code from <code>pp_errors.h</code>.
* Returns PP_ERROR_NOTSUPPORTED if audio encoding is not available, or the
* requested codec profile is not supported.
*/
public static int Initialize(PPResource audio_encoder,
uint channels,
PPAudioBufferSampleRate input_sample_rate,
PPAudioBufferSampleSize input_sample_size,
PPAudioProfile output_profile,
uint initial_bitrate,
PPHardwareAcceleration acceleration,
PPCompletionCallback callback)
{
return(_Initialize(audio_encoder,
channels,
input_sample_rate,
input_sample_size,
output_profile,
initial_bitrate,
acceleration,
callback));
}
/**
* Reads data from the socket. The socket must be connected. It may perform a
* partial read.
*
* @param[in] tcp_socket A <code>PP_Resource</code> corresponding to a TCP
* socket.
* @param[out] buffer The buffer to store the received data on success. It
* must be at least as large as <code>bytes_to_read</code>.
* @param[in] bytes_to_read The number of bytes to read.
* @param[in] callback A <code>PP_CompletionCallback</code> to be called upon
* completion.
*
* @return A non-negative number on success to indicate how many bytes have
* been read, 0 means that end-of-file was reached; otherwise, an error code
* from <code>pp_errors.h</code>.
*/
public static int Read(PPResource tcp_socket,
byte[] buffer,
int bytes_to_read,
PPCompletionCallback callback)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
unsafe
{
fixed(byte *buffer_ = &buffer[0])
{
return(_Read(tcp_socket, (IntPtr)buffer_, bytes_to_read, callback));
}
}
}
/**
* Sends data to a specific destination. The socket must be bound.
*
* @param[in] udp_socket A <code>PP_Resource</code> corresponding to a UDP
* socket.
* @param[in] buffer The buffer containing the data to send.
* @param[in] num_bytes The number of bytes to send.
* @param[in] addr A <code>PPB_NetAddress</code> resource holding the
* destination address.
* @param[in] callback A <code>PP_CompletionCallback</code> to be called upon
* completion.
*
* @return A non-negative number on success to indicate how many bytes have
* been sent; otherwise, an error code from <code>pp_errors.h</code>.
* <code>PP_ERROR_NOACCESS</code> will be returned if the caller doesn't have
* required permissions.
* <code>PP_ERROR_INPROGRESS</code> will be returned if the socket is busy
* sending. The caller should wait until a pending send completes before
* retrying.
*/
public static int SendTo(PPResource udp_socket,
byte[] buffer,
int num_bytes,
PPResource addr,
PPCompletionCallback callback)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
unsafe
{
fixed(byte *buffer_ = &buffer[0])
{
return(_SendTo(udp_socket, (IntPtr)buffer_, num_bytes, addr, callback));
}
}
}
/**
* Requests resolution of a host name. If the call completes successfully, the
* results can be retrieved by <code>GetCanonicalName()</code>,
* <code>GetNetAddressCount()</code> and <code>GetNetAddress()</code>.
*
* @param[in] host_resolver A <code>PP_Resource</code> corresponding to a host
* resolver.
* @param[in] host The host name (or IP address literal) to resolve.
* @param[in] port The port number to be set in the resulting network
* addresses.
* @param[in] hint A <code>PP_HostResolver_Hint</code> structure providing
* hints for host resolution.
* @param[in] callback A <code>PP_CompletionCallback</code> to be called upon
* completion.
*
* @return An int32_t containing an error code from <code>pp_errors.h</code>.
* <code>PP_ERROR_NOACCESS</code> will be returned if the caller doesn't have
* required permissions. <code>PP_ERROR_NAME_NOT_RESOLVED</code> will be
* returned if the host name couldn't be resolved.
*/
public static int Resolve(PPResource host_resolver,
byte[] host,
ushort port,
PPHostResolverHint hint,
PPCompletionCallback callback)
{
if (host == null)
{
throw new ArgumentNullException("host");
}
unsafe
{
fixed(byte *host_ = &host[0])
{
return(_Resolve(host_resolver, (IntPtr)host_, port, hint, callback));
}
}
}
/**
* Decodes a bitstream buffer. Copies |size| bytes of data from the plugin's
* |buffer|. The plugin should wait until the decoder signals completion by
* returning PP_OK or by running |callback| before calling Decode() again.
*
* In general, each bitstream buffer should contain a demuxed bitstream frame
* for the selected video codec. For example, H264 decoders expect to receive
* one AnnexB NAL unit, including the 4 byte start code prefix, while VP8
* decoders expect to receive a bitstream frame without the IVF frame header.
*
* If the call to Decode() eventually results in a picture, the |decode_id|
* parameter is copied into the returned picture. The plugin can use this to
* associate decoded pictures with Decode() calls (e.g. to assign timestamps
* or frame numbers to pictures.) This value is opaque to the API so the
* plugin is free to pass any value.
*
* @param[in] video_decoder A <code>PP_Resource</code> identifying the video
* decoder.
* @param[in] decode_id An optional value, chosen by the plugin, that can be
* used to associate calls to Decode() with decoded pictures returned by
* GetPicture().
* @param[in] size Buffer size in bytes.
* @param[in] buffer Starting address of buffer.
* @param[in] callback A <code>PP_CompletionCallback</code> to be called on
* completion.
*
* @return An int32_t containing an error code from <code>pp_errors.h</code>.
* Returns PP_ERROR_FAILED if the decoder isn't initialized or if a Flush()
* or Reset() call is pending.
* Returns PP_ERROR_INPROGRESS if there is another Decode() call pending.
* Returns PP_ERROR_NOMEMORY if a bitstream buffer can't be created.
* Returns PP_ERROR_ABORTED when Reset() is called while Decode() is pending.
*/
public static int Decode(PPResource video_decoder,
uint decode_id,
uint size,
byte[] buffer,
PPCompletionCallback callback)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
unsafe
{
fixed(byte *buffer_ = &buffer[0])
{
return(_Decode(video_decoder, decode_id, size, (IntPtr)buffer_,
callback));
}
}
}
/**
* Write() writes to an offset in the file. This function might perform a
* partial write. The FileIO object must have been opened with write access.
*
* @param[in] file_io A <code>PP_Resource</code> corresponding to a file
* FileIO.
* @param[in] offset The offset into the file.
* @param[in] buffer The buffer to hold the specified number of bytes read.
* @param[in] bytes_to_write The number of bytes to write to
* <code>offset</code>.
* @param[in] callback A <code>PP_CompletionCallback</code> to be called upon
* completion of Write().
*
* @return The number of bytes written or an error code from
* <code>pp_errors.h</code>. If the return value is 0, then end-of-file was
* reached. It is valid to call Write() multiple times with a completion
* callback to queue up parallel writes to the file, but pending writes
* cannot be interleaved with other operations.
*/
public static int Write(PPResource file_io,
long offset,
byte[] buffer,
int bytes_to_write,
PPCompletionCallback callback)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
unsafe
{
fixed(byte *buffer_ = &buffer[0])
{
return(_Write(file_io, offset, (IntPtr)buffer_,
bytes_to_write,
callback));
}
}
}
internal CompletionCallback(PPCompletionCallbackFunc callbackFunc, object userData = null, PPCompletionCallbackFlag flags = PPCompletionCallbackFlag.None)
{
this.callbackFunc = callbackFunc;
// if no callbackfunc is specified then
if (callbackFunc != null)
{
if (userData == null)
{
this.userData = IntPtr.Zero;
}
else
{
GCHandle userDataHandle = GCHandle.Alloc(userData, GCHandleType.Normal);
this.userData = (IntPtr)userDataHandle;
}
var ourCallback = new PPCompletionCallback();
ourCallback.func = OnCallBack;
ourCallback.flags = (int)PPCompletionCallbackFlag.None;
GCHandle userHandle = GCHandle.Alloc(this, GCHandleType.Normal);
ourCallback.user_data = (IntPtr)userHandle;
Callback = ourCallback;
}
}
/**
* Binds the socket to the given address. The socket must not be bound.
*
* @param[in] tcp_socket A <code>PP_Resource</code> corresponding to a TCP
* socket.
* @param[in] addr A <code>PPB_NetAddress</code> resource.
* @param[in] callback A <code>PP_CompletionCallback</code> to be called upon
* completion.
*
* @return An int32_t containing an error code from <code>pp_errors.h</code>,
* including (but not limited to):
* - <code>PP_ERROR_ADDRESS_IN_USE</code>: the address is already in use.
* - <code>PP_ERROR_ADDRESS_INVALID</code>: the address is invalid.
*/
public static int Bind(PPResource tcp_socket,
PPResource addr,
PPCompletionCallback callback)
{
return(_Bind(tcp_socket, addr, callback));
}
extern static void _CallOnMainThread(int delay_in_milliseconds,
PPCompletionCallback callback,
int result);
/**
* CallOnMainThread() schedules work to be executed on the main module thread
* after the specified delay. The delay may be 0 to specify a call back as
* soon as possible.
*
* The <code>result</code> parameter will just be passed as the second
* argument to the callback. Many applications won't need this, but it allows
* a module to emulate calls of some callbacks which do use this value.
*
* <strong>Note:</strong> CallOnMainThread, even when used from the main
* thread with a delay of 0 milliseconds, will never directly invoke the
* callback. Even in this case, the callback will be scheduled
* asynchronously.
*
* <strong>Note:</strong> If the browser is shutting down or if the module
* has no instances, then the callback function may not be called.
*
* @param[in] delay_in_milliseconds An int32_t delay in milliseconds.
* @param[in] callback A <code>PP_CompletionCallback</code> callback function
* that the browser will call after the specified delay.
* @param[in] result An int32_t that the browser will pass to the given
* <code>PP_CompletionCallback</code>.
*/
public static void CallOnMainThread(int delay_in_milliseconds,
PPCompletionCallback callback,
int result)
{
_CallOnMainThread(delay_in_milliseconds, callback, result);
}
extern static int _Configure(PPResource audio_track,
int[] attrib_list,
PPCompletionCallback callback);
extern static int _Read(PPResource tcp_socket,
IntPtr buffer,
int bytes_to_read,
PPCompletionCallback callback);
extern static int _Write(PPResource tcp_socket,
IntPtr buffer,
int bytes_to_write,
PPCompletionCallback callback);
extern static int _Open(PPResource file_system,
long expected_size,
PPCompletionCallback callback);
/**
* ReadDirectoryEntries() reads all entries in a directory.
*
* @param[in] file_ref A <code>PP_Resource</code> corresponding to a directory
* reference.
* @param[in] output An output array which will receive
* <code>PP_DirectoryEntry</code> objects on success.
* @param[in] callback A <code>PP_CompletionCallback</code> to run on
* completion.
*
* @return An int32_t containing an error code from <code>pp_errors.h</code>.
*/
public static int ReadDirectoryEntries(PPResource file_ref,
PPArrayOutput output,
PPCompletionCallback callback)
{
return(_ReadDirectoryEntries(file_ref, output, callback));
}
extern static int _ReadDirectoryEntries(PPResource file_ref,
PPArrayOutput output,
PPCompletionCallback callback);
/**
* Query() queries info about a file or directory. You must have access to
* read this file or directory if it exists in the external filesystem.
*
* @param[in] file_ref A <code>PP_Resource</code> corresponding to a file
* reference.
* @param[out] info A pointer to a <code>PP_FileInfo</code> which will be
* populated with information about the file or directory.
* @param[in] callback A <code>PP_CompletionCallback</code> to be called upon
* completion of Query().
*
* @return An int32_t containing an error code from <code>pp_errors.h</code>.
*/
public static int Query(PPResource file_ref,
out PPFileInfo info,
PPCompletionCallback callback)
{
return(_Query(file_ref, out info, callback));
}
extern static int _Query(PPResource file_ref,
out PPFileInfo info,
PPCompletionCallback callback);
/**
* Rename() renames a file or directory. Arguments <code>file_ref</code> and
* <code>new_file_ref</code> must both refer to files in the same file
* system. It is an error to rename a file or directory that is in use. It
* is not valid to rename a file in the external file system.
*
* @param[in] file_ref A <code>PP_Resource</code> corresponding to a file
* reference.
* @param[in] new_file_ref A <code>PP_Resource</code> corresponding to a new
* file reference.
* @param[in] callback A <code>PP_CompletionCallback</code> to be called upon
* completion of Rename().
*
* @return An int32_t containing an error code from <code>pp_errors.h</code>.
*/
public static int Rename(PPResource file_ref,
PPResource new_file_ref,
PPCompletionCallback callback)
{
return(_Rename(file_ref, new_file_ref, callback));
}
extern static int _Connect(PPResource tcp_socket,
PPResource addr,
PPCompletionCallback callback);
/**
* Connects the socket to the given address. The socket must not be listening.
* Binding the socket beforehand is optional.
*
* @param[in] tcp_socket A <code>PP_Resource</code> corresponding to a TCP
* socket.
* @param[in] addr A <code>PPB_NetAddress</code> resource.
* @param[in] callback A <code>PP_CompletionCallback</code> to be called upon
* completion.
*
* @return An int32_t containing an error code from <code>pp_errors.h</code>,
* including (but not limited to):
* - <code>PP_ERROR_NOACCESS</code>: the caller doesn't have required
* permissions.
* - <code>PP_ERROR_ADDRESS_UNREACHABLE</code>: <code>addr</code> is
* unreachable.
* - <code>PP_ERROR_CONNECTION_REFUSED</code>: the connection attempt was
* refused.
* - <code>PP_ERROR_CONNECTION_FAILED</code>: the connection attempt failed.
* - <code>PP_ERROR_CONNECTION_TIMEDOUT</code>: the connection attempt timed
* out.
*
* Since version 1.1, if the socket is listening/connected or has a pending
* listen/connect request, <code>Connect()</code> will fail without starting a
* connection attempt; otherwise, any failure during the connection attempt
* will cause the socket to be closed.
*/
public static int Connect(PPResource tcp_socket,
PPResource addr,
PPCompletionCallback callback)
{
return(_Connect(tcp_socket, addr, callback));
}
/**
* Starts listening. The socket must be bound and not connected.
*
* @param[in] tcp_socket A <code>PP_Resource</code> corresponding to a TCP
* socket.
* @param[in] backlog A hint to determine the maximum length to which the
* queue of pending connections may grow.
* @param[in] callback A <code>PP_CompletionCallback</code> to be called upon
* completion.
*
* @return An int32_t containing an error code from <code>pp_errors.h</code>,
* including (but not limited to):
* - <code>PP_ERROR_NOACCESS</code>: the caller doesn't have required
* permissions.
* - <code>PP_ERROR_ADDRESS_IN_USE</code>: Another socket is already listening
* on the same port.
*/
public static int Listen(PPResource tcp_socket,
int backlog,
PPCompletionCallback callback)
{
return(_Listen(tcp_socket, backlog, callback));
}
/**
* Open() opens the file system. A file system must be opened before running
* any other operation on it.
*
* @param[in] file_system A <code>PP_Resource</code> corresponding to a file
* system.
*
* @param[in] expected_size The expected size of the file system. Note that
* this does not request quota; to do that, you must either invoke
* requestQuota from JavaScript:
* http://www.html5rocks.com/en/tutorials/file/filesystem/#toc-requesting-quota
* or set the unlimitedStorage permission for Chrome Web Store apps:
* http://code.google.com/chrome/extensions/manifest.html#permissions
*
* @param[in] callback A <code>PP_CompletionCallback</code> to be called upon
* completion of Open().
*
* @return An int32_t containing an error code from <code>pp_errors.h</code>.
*/
public static int Open(PPResource file_system,
long expected_size,
PPCompletionCallback callback)
{
return(_Open(file_system, expected_size, callback));
}
/**
* Accepts a connection. The socket must be listening.
*
* @param[in] tcp_socket A <code>PP_Resource</code> corresponding to a TCP
* socket.
* @param[out] accepted_tcp_socket Stores the accepted TCP socket on success.
* @param[in] callback A <code>PP_CompletionCallback</code> to be called upon
* completion.
*
* @return An int32_t containing an error code from <code>pp_errors.h</code>,
* including (but not limited to):
* - <code>PP_ERROR_CONNECTION_ABORTED</code>: A connection has been aborted.
*/
public static int Accept(PPResource tcp_socket,
out PPResource accepted_tcp_socket,
PPCompletionCallback callback)
{
return(_Accept(tcp_socket, out accepted_tcp_socket, callback));
}
extern static int _Listen(PPResource tcp_socket,
int backlog,
PPCompletionCallback callback);
/**
* Configures underlying buffers for incoming audio samples.
* If the application doesn't want to drop samples, then the
* <code>PP_MEDIASTREAMAUDIOTRACK_ATTRIB_BUFFERS</code> should be
* chosen such that inter-buffer processing time variability won't overrun all
* the input buffers. If all buffers are filled, then samples will be
* dropped. The application can detect this by examining the timestamp on
* returned buffers. If <code>Configure()</code> is not called, default
* settings will be used. Calls to Configure while the plugin holds
* buffers will fail.
* Example usage from plugin code:
* @code
* int32_t attribs[] = {
* PP_MEDIASTREAMAUDIOTRACK_ATTRIB_BUFFERS, 4,
* PP_MEDIASTREAMAUDIOTRACK_ATTRIB_DURATION, 10,
* PP_MEDIASTREAMAUDIOTRACK_ATTRIB_NONE};
* track_if->Configure(track, attribs, callback);
* @endcode
*
* @param[in] audio_track A <code>PP_Resource</code> corresponding to an audio
* resource.
* @param[in] attrib_list A list of attribute name-value pairs in which each
* attribute is immediately followed by the corresponding desired value.
* The list is terminated by
* <code>PP_MEDIASTREAMAUDIOTRACK_ATTRIB_NONE</code>.
* @param[in] callback A <code>PP_CompletionCallback</code> to be called upon
* completion of <code>Configure()</code>.
*
* @return An int32_t containing a result code from <code>pp_errors.h</code>.
*/
public static int Configure(PPResource audio_track,
int[] attrib_list,
PPCompletionCallback callback)
{
return(_Configure(audio_track, attrib_list, callback));
}
extern static int _Accept(PPResource tcp_socket,
out PPResource accepted_tcp_socket,
PPCompletionCallback callback);
extern static int _GetBuffer(PPResource audio_track,
out PPResource buffer,
PPCompletionCallback callback);
extern static int _SetOption(PPResource tcp_socket,
PPTCPSocketOption name,
PPVar value,
PPCompletionCallback callback);
/**
* Gets the next audio buffer from the MediaStream track.
* If internal processing is slower than the incoming buffer rate, new buffers
* will be dropped from the incoming stream. Once all buffers are full,
* audio samples will be dropped until <code>RecycleBuffer()</code> is called
* to free a slot for another buffer.
* If there are no audio data in the input buffer,
* <code>PP_OK_COMPLETIONPENDING</code> will be returned immediately and the
* <code>callback</code> will be called, when a new buffer of audio samples
* is received or an error happens.
*
* @param[in] audio_track A <code>PP_Resource</code> corresponding to an audio
* resource.
* @param[out] buffer A <code>PP_Resource</code> corresponding to
* an AudioBuffer resource.
* @param[in] callback A <code>PP_CompletionCallback</code> to be called upon
* completion of GetBuffer().
*
* @return An int32_t containing a result code from <code>pp_errors.h</code>.
*/
public static int GetBuffer(PPResource audio_track,
out PPResource buffer,
PPCompletionCallback callback)
{
return(_GetBuffer(audio_track, out buffer, callback));
}
