enum MixStreamState

typedef enum {
  MIX_STREAM_NULL=0,
  MIX_STREAM_STOPPED,
  MIX_STREAM_PLAYING,
  MIX_STREAM_PAUSED,
  MIX_STREAM_DRAINING,
  MIX_STREAM_LAST
} MixStreamState;

Stream State during Decode and Render or Encode mode. These states do not apply to Decode and Return mode.

enum MixState

typedef enum {
  MIX_STATE_NULL=0,
  MIX_STATE_UNINITIALIZED,
  MIX_STATE_INITIALIZED,
  MIX_STATE_CONFIGURED,
  MIX_STATE_LAST
} MixState;

The varies states the device is in.

enum MixCodecMode

typedef enum {
  MIX_CODING_INVALID=0,
  MIX_CODING_ENCODE,
  MIX_CODING_DECODE,
  MIX_CODING_LAST
} MixCodecMode;

Mode where device is operating on. See mix_audio_initialize().

enum MixVolType

typedef enum {
  MIX_VOL_PERCENT=0,
  MIX_VOL_DECIBELS,
  MIX_VOL_LAST
} MixVolType;

See mix_audio_getvolume() and mix_audio_setvolume().

enum MixVolRamp

typedef enum 
{
  MIX_RAMP_LINEAR = 0,
  MIX_RAMP_EXPONENTIAL,
  MIX_RAMP_LAST
} MixVolRamp;

See mix_audio_getvolume() and mix_audio_setvolume().

MixIOVec

typedef struct {
  guchar *data;
  gint size;
} MixIOVec;

Scatter-gather style structure. To be used by mix_audio_decode() method for input and output buffer.

enum MixDeviceState

typedef enum {
  MIX_AUDIO_DEV_CLOSED=0,
  MIX_AUDIO_DEV_OPENED,
  MIX_AUDIO_DEV_ALLOCATED
} MixDeviceState;

Device state.

MixAudio

typedef struct {
  GObject parent;
} MixAudio;

MI-X Audio object

mix_audio_new ()

MixAudio *          mix_audio_new                       (void);

Use this method to create new instance of MixAudio

mix_audio_ref ()

MixAudio *          mix_audio_ref                       (MixAudio *mix);

Add reference count.

mix_audio_unref()

#define mix_audio_unref(obj) g_object_unref (G_OBJECT(obj))

Decrement reference count of the object.

mix_audio_get_version ()

MIX_RESULT          mix_audio_get_version               (guint *major,
                                                         guint *minor);

Returns the version of the MI-X library.

mix_audio_initialize ()

MIX_RESULT          mix_audio_initialize                (MixAudio *mix,
                                                         MixCodecMode mode,
                                                         MixAudioInitParams *aip,
                                                         MixDrmParams *drminitparams);

This function will initialize an encode or decode session with this MixAudio instance. During this call, the device will be opened. If the device is not available, an error is returned to the caller so that an alternative (e.g. software decoding) can be configured instead. Use mix_audio_deinitialize() to close the device.

A previous initialized session must be de-initialized using mix_audio_deinitialize() before it can be initialized again.

mix_audio_configure ()

MIX_RESULT          mix_audio_configure                 (MixAudio *mix,
                                                         MixAudioConfigParams *audioconfigparams,
                                                         MixDrmParams *drmparams);

This function can be used to configure a stream for the current session. The caller can use this function to do the following:

SST stream parameters will be set during this call, and stream resources allocated in SST.

If mode is specified to MIX_DECODE_DIRECTRENDER but direct-render mode is not available (due to end user use of alternative output device), an error indication will be returned to the caller so that an alternate pipeline configuration can be created (e.g. including a Pulse Audio sink, and support for output buffers). In this case, the caller will need to call mix_audio_configure() again to with mode specify as MIX_DECODE_DECODERETURN to request decode-return mode.

This method can be called multiple times if reconfiguration of the stream is needed. However, this method must be called when the stream is in MIX_STREAM_STOPPED state.

mix_audio_decode ()

MIX_RESULT          mix_audio_decode                    (MixAudio *mix,
                                                         const MixIOVec *iovin,
                                                         gint iovincnt,
                                                         guint64 *insize,
                                                         MixIOVec *iovout,
                                                         gint iovoutcnt,
                                                         guint64 *outsize);

This function is used to initiate HW accelerated decoding of encoded data buffers. This function may be used in two major modes, direct-render or decode-return.

With direct-render, input buffers are provided by the caller which hold encoded audio data, and no output buffers are provided. The encoded data is decoded, and the decoded data is sent directly to the output speaker. This allows very low power audio rendering and is the best choice of operation for longer battery life.

Input buffers in both modes are one or more user space buffers using a scatter/gather style vector interface.

Output buffers for the decode-return mode are one or more user space buffers in a scatter style vector interface. Buffers will be filled in order and lengths of data filled will be returned.

This call will block until data has been completely copied or queued to the driver. All user space buffers may be used or released when this call returns.

Note: If the stream is configured as MIX_DECODE_DIRECTRENDER, and whenever the stream in MIX_STREAM_STOPPED state, the call to mix_audio_decode() will not start the playback until mix_audio_start() is called. This behavior would allow application to queue up data but delay the playback until appropriate time.

mix_audio_capture_encode ()

MIX_RESULT          mix_audio_capture_encode            (MixAudio *mix,
                                                         MixIOVec *iovout,
                                                         gint iovoutcnt);

To read encoded data from device.

NOTE: May need to rename to "read_encoded" or other name. Since "encode" seems to mean taking raw audio and convert to compressed audio.

mix_audio_start ()

MIX_RESULT          mix_audio_start                     (MixAudio *mix);

If the stream is configured to MIX_DECODE_DIRECTRENDER, application use this call to change the stream out of the MIX_STREAM_STOPPED state. If mix_audio_decode() is called and blocking in a seperate thread prior to this call. This method causes the device to start rendering data.

In MIX_DECODE_DECODERETURN, this method is no op.

mix_audio_stop_drop ()

MIX_RESULT          mix_audio_stop_drop                 (MixAudio *mix);

If the stream is configured to MIX_DECODE_DIRECTRENDER, application uses this function to stop the processing and playback of audio.

All remaining frames to be decoded or rendered will be discarded and playback will stop immediately, unblocks any pending mix_audio_decode().

If MIX_STOP_DRAIN is requested, the call will block with stream state set to MIX_STREAM_DRAINING, and return only until all remaining frame in previously submitted buffers are decoded and rendered. When MIX_STOP_DRAIN returns successfully, the stream would have reached MIX_STREAM_STOPPED successfully.

After this call, timestamp retrived by mix_audio_gettimestamp() is reset to zero.

Note that this method returns MIX_RESULT_WRONG_STATE if the stream is in MIX_STREAM_DRAINING state.

mix_audio_stop_drain ()

MIX_RESULT          mix_audio_stop_drain                (MixAudio *mix);

If the stream is configured to MIX_DECODE_DIRECTRENDER, application uses this function to stop the processing and playback of audio.

The call will block with stream state set to MIX_STREAM_DRAINING, and return only until all remaining frame in previously submitted buffers are decoded and rendered.

Note that this method blocks until MIX_STREAM_STOPPED is reached if it is called when the stream is already in MIX_STREAM_DRAINING state.

mix_audio_pause ()

MIX_RESULT          mix_audio_pause                     (MixAudio *mix);

If the stream is configured to MIX_DECODE_DIRECTRENDER, application uses this call to change the stream state from MIX_STREAM_PLAYING to MIX_STREAM_PAUSED. Note that this method returns sucessful only when the resulting state reaches MIX_STREAM_PAUSED. Meaning it will return fail code if it is called in a state such as MIX_STREAM_STOPPED, where transitioning to MIX_STREAM_PAUSED is not possible.

In some situation, where there is potential race condition with the DRAINING operation, this method may return MIX_RESULT_NEED_RETRY to indicate last operation result is inclusive and request caller to call again.

mix_audio_resume ()

MIX_RESULT          mix_audio_resume                    (MixAudio *mix);

If the stream is configured to MIX_DECODE_DIRECTRENDER, application uses this call to change the stream state to MIX_STREAM_PLAYING. Note that this method returns sucessful only when the resulting state reaches MIX_STREAM_PAUSED. Meaning it will return fail code if it is called in a state such as MIX_STREAM_DRAINING, where transitioning to MIX_STREAM_PLAYING is not possible.

mix_audio_get_timestamp ()

MIX_RESULT          mix_audio_get_timestamp             (MixAudio *mix,
                                                         guint64 *msecs);

This function can be used to retrieve the current timestamp for audio playback in milliseconds. The timestamp will reflect the amount of audio data rendered since the start of stream, or since the last stop. Note that the timestamp is always reset to zero when the stream enter MIX_STREAM_STOPPED state. The timestamp is an unsigned long value, so the value will wrap when the timestamp reaches ULONG_MAX. This function is only valid in direct-render mode.

mix_audio_set_mute ()

MIX_RESULT          mix_audio_set_mute                  (MixAudio *mix,
                                                         gboolean mute);

This function is used to mute and unmute audio playback. While muted, playback would continue but silently. This function is only valid when the session is configured to MIX_DECODE_DIRECTRENDER mode.

Note that playback volumn may change due to change of global settings while stream is muted.

mix_audio_get_mute ()

MIX_RESULT          mix_audio_get_mute                  (MixAudio *mix,
                                                         gboolean *muted);

Get Mute.

mix_audio_get_max_vol ()

MIX_RESULT          mix_audio_get_max_vol               (MixAudio *mix,
                                                         gint *maxvol);

This function can be used if the application will be setting the audio volume using decibels instead of percentage. The maximum volume in decibels supported by the driver will be returned. This value can be used to determine the upper bound of the decibel range in calculating volume levels. This value is a signed integer. This function is only valid if stream is configured to MIX_DECODE_DIRECTRENDER mode.

mix_audio_get_min_vol ()

MIX_RESULT          mix_audio_get_min_vol               (MixAudio *mix,
                                                         gint *minvol);

This function can be used if the application will be setting the audio volume using decibels instead of percentage. The minimum volume in decibels supported by the driver will be returned. This value can be used to determine the lower bound of the decibel range in calculating volume levels. This value is a signed integer. This function is only valid if stream is configured to MIX_DECODE_DIRECTRENDER mode.

mix_audio_get_volume ()

MIX_RESULT          mix_audio_get_volume                (MixAudio *mix,
                                                         gint *currvol,
                                                         MixVolType type);

This function returns the current volume setting in either decibels or percentage. This function is only valid if stream is configured to MIX_DECODE_DIRECTRENDER mode.

mix_audio_set_volume ()

MIX_RESULT          mix_audio_set_volume                (MixAudio *mix,
                                                         gint currvol,
                                                         MixVolType type,
                                                         gulong msecs,
                                                         MixVolRamp ramptype);

This function sets the current volume setting in either decibels or percentage. This function is only valid if the stream is configured to MIX_DECODE_DIRECTRENDER mode.

mix_audio_deinitialize ()

MIX_RESULT          mix_audio_deinitialize              (MixAudio *mix);

This function will uninitialize a session with this MI-X instance. During this call, the SST device will be closed and resources including mmapped buffers would be freed.This function should be called by the application once mix_audio_init() has been called.

Note that if this method should not fail normally. If it does return failure, the state of this object and the underlying mechanism is compromised and application should not attempt to reuse this object.

mix_audio_get_stream_state ()

MIX_RESULT          mix_audio_get_stream_state          (MixAudio *mix,
                                                         MixStreamState *streamState);

Get the stream state of the current stream.

mix_audio_get_state ()

MIX_RESULT          mix_audio_get_state                 (MixAudio *mix,
                                                         MixState *state);

Get the device state of the audio session.

mix_audio_am_is_enabled ()

gboolean            mix_audio_am_is_enabled             (MixAudio *mix);

This method checks if the current session is configure to use Intel Audio Manager. Note that Intel Audio Manager is considered disabled if the stream has not be initialized to use the service explicitly.

mix_audio_is_am_available ()

MIX_RESULT          mix_audio_is_am_available           (MixAudio *mix,
                                                         MixAudioManager am,
                                                         gboolean *avail);

Check if AM is available.

mix_audio_get_output_configuration ()

MIX_RESULT          mix_audio_get_output_configuration  (MixAudio *mix,
                                                         MixAudioConfigParams **audioconfigparams);

This method retrieve the current configuration. This can be called after initialization. If a stream has been configured, it returns the corresponding derive object of MixAudioConfigParams.

mix_audio_get_stream_byte_decoded ()

MIX_RESULT          mix_audio_get_stream_byte_decoded   (MixAudio *mix,
                                                         guint64 *byte);

Retrive the culmulative byte decoded.

Not Implemented.