Struct xpcom::interfaces::imgIEncoder

#[repr(C)]
pub struct imgIEncoder { /* fields omitted */ }

interface imgIEncoder : nsIAsyncInputStream

/**
 * imgIEncoder interface
 */

Methods

impl imgIEncoder

pub fn coerce<T: imgIEncoderCoerce>(&self) -> &T

Cast this imgIEncoder to one of its base interfaces.

impl imgIEncoder

pub const INPUT_FORMAT_RGB: i64

INPUT_FORMAT_RGB: i64 = 0

pub const INPUT_FORMAT_RGBA: i64

INPUT_FORMAT_RGBA: i64 = 1

pub const INPUT_FORMAT_HOSTARGB: i64

INPUT_FORMAT_HOSTARGB: i64 = 2

pub unsafe fn InitFromData(
    &self,
    data: *const uint8_t,
    length: uint32_t,
    width: uint32_t,
    height: uint32_t,
    stride: uint32_t,
    inputFormat: uint32_t,
    outputOptions: &nsAString
) -> nsresult

void initFromData ([array, size_is (length), const] in uint8_t data, in unsigned long length, in uint32_t width, in uint32_t height, in uint32_t stride, in uint32_t inputFormat, in AString outputOptions);

pub unsafe fn StartImageEncode(
    &self,
    width: uint32_t,
    height: uint32_t,
    inputFormat: uint32_t,
    outputOptions: &nsAString
) -> nsresult

void startImageEncode (in uint32_t width, in uint32_t height, in uint32_t inputFormat, in AString outputOptions);

pub unsafe fn AddImageFrame(
    &self,
    data: *const uint8_t,
    length: uint32_t,
    width: uint32_t,
    height: uint32_t,
    stride: uint32_t,
    frameFormat: uint32_t,
    frameOptions: &nsAString
) -> nsresult

void addImageFrame ([array, size_is (length), const] in uint8_t data, in unsigned long length, in uint32_t width, in uint32_t height, in uint32_t stride, in uint32_t frameFormat, in AString frameOptions);

pub unsafe fn EndImageEncode(&self) -> nsresult

void endImageEncode ();

pub unsafe fn GetImageBufferUsed(&self, _retval: *mut uint32_t) -> nsresult

[noscript] unsigned long getImageBufferUsed ();

pub unsafe fn GetImageBuffer(&self, _retval: *mut *mut u8) -> nsresult

[noscript] charPtr getImageBuffer ();

Methods from Deref<Target = nsIAsyncInputStream>

pub fn coerce<T: nsIAsyncInputStreamCoerce>(&self) -> &T

Cast this nsIAsyncInputStream to one of its base interfaces.

pub const WAIT_CLOSURE_ONLY: i64

pub unsafe fn CloseWithStatus(&self, aStatus: nsresult) -> nsresult

/**
     * This method closes the stream and sets its internal status.  If the
     * stream is already closed, then this method is ignored.  Once the stream
     * is closed, the stream's status cannot be changed.  Any successful status
     * code passed to this method is treated as NS_BASE_STREAM_CLOSED, which
     * has an effect equivalent to nsIInputStream::close.
     *
     * NOTE: this method exists in part to support pipes, which have both an
     * input end and an output end.  If the input end of a pipe is closed, then
     * writes to the output end of the pipe will fail.  The error code returned
     * when an attempt is made to write to a "broken" pipe corresponds to the
     * status code passed in when the input end of the pipe was closed, which
     * greatly simplifies working with pipes in some cases.
     *
     * @param aStatus
     *        The error that will be reported if this stream is accessed after
     *        it has been closed.
     */

void closeWithStatus (in nsresult aStatus);

pub unsafe fn AsyncWait(
    &self,
    aCallback: *const nsIInputStreamCallback,
    aFlags: uint32_t,
    aRequestedCount: uint32_t,
    aEventTarget: *const nsIEventTarget
) -> nsresult

/**
     * Asynchronously wait for the stream to be readable or closed.  The
     * notification is one-shot, meaning that each asyncWait call will result
     * in exactly one notification callback.  After the OnInputStreamReady event
     * is dispatched, the stream releases its reference to the
     * nsIInputStreamCallback object.  It is safe to call asyncWait again from the
     * notification handler.
     *
     * This method may be called at any time (even if read has not been called).
     * In other words, this method may be called when the stream already has
     * data to read.  It may also be called when the stream is closed.  If the
     * stream is already readable or closed when AsyncWait is called, then the
     * OnInputStreamReady event will be dispatched immediately.  Otherwise, the
     * event will be dispatched when the stream becomes readable or closed.
     *
     * @param aCallback
     *        This object is notified when the stream becomes ready.  This
     *        parameter may be null to clear an existing callback.
     * @param aFlags
     *        This parameter specifies optional flags passed in to configure
     *        the behavior of this method.  Pass zero to specify no flags.
     * @param aRequestedCount
     *        Wait until at least this many bytes can be read.  This is only
     *        a suggestion to the underlying stream; it may be ignored.  The
     *        caller may pass zero to indicate no preference.
     * @param aEventTarget
     *        Specify NULL to receive notification on ANY thread (possibly even
     *        recursively on the calling thread -- i.e., synchronously), or
     *        specify that the notification be delivered to a specific event
     *        target.
     */

void asyncWait (in nsIInputStreamCallback aCallback, in unsigned long aFlags, in unsigned long aRequestedCount, in nsIEventTarget aEventTarget);

Trait Implementations

impl XpCom for imgIEncoder

const IID: nsIID

IID: nsIID = nsID(1269443950, 65255, 17119, [174, 63, 95, 190, 188, 12, 38, 124])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for imgIEncoder

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for imgIEncoder

type Target = nsIAsyncInputStream

The resulting type after dereferencing.

fn deref(&self) -> &nsIAsyncInputStream

Dereferences the value.