package alsa

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type
type handle

Handle to a device.

type params

Parameters of a device.

type stream =
  1. | Playback
    (*

    Playback stream.

    *)
  2. | Capture
    (*

    Capture stream.

    *)

Wanted stream.

type mode =
  1. | Async
    (*

    Asynchronous notification (not supported yet).

    *)
  2. | Non_blocking
    (*

    Non blocking I/O.

    *)

Modes for opening a stream.

val open_pcm : string -> stream list -> mode list -> handle
val close : handle -> unit
val prepare : handle -> unit

Prepare PCM for use.

val resume : handle -> unit

Resume from suspend, no samples are lost.

val recover : ?verbose:bool -> handle -> exn -> unit

Recover the stream state from an error or suspend. * This a high-level helper function building on other functions. * This functions handles Interrupted, Buffer_xrun and Suspended * exceptions trying to prepare given stream for next I/O. * Raises the given exception when not recognized/used.

val start : handle -> unit
val drain : handle -> unit

Stop a PCM preserving pending frames.

val drop : handle -> unit

Stop a PCM dropping pending frames.

val pause : handle -> bool -> unit

pause hnd pause pauses (when pause is true) or resume (when pause * is false) a PCM.

val reset : handle -> unit
val wait : handle -> int -> bool

Wait for a PCM to become ready. The second argument is the timeout in * milliseconds (negative for infinite). Returns false if a timeout * occured.

val readi : handle -> bytes -> int -> int -> int

readi handle buf ofs len reads len interleaved frames in buf * starting at offset ofs (in bytes). It returns the actual number of * frames read.

val writei : handle -> bytes -> int -> int -> int

writei handle buf ofs len writes len interleaved frames of buf * starting at offset ofs (in bytes).

val readn : handle -> bytes array -> int -> int -> int
val writen : handle -> bytes array -> int -> int -> int
val readn_float : handle -> float array array -> int -> int -> int
val writen_float : handle -> float array array -> int -> int -> int
val readn_float_ba : handle -> (float, Stdlib.Bigarray.float32_elt, Stdlib.Bigarray.c_layout) Stdlib.Bigarray.Array1.t array -> int
val writen_float_ba : handle -> (float, Stdlib.Bigarray.float32_elt, Stdlib.Bigarray.c_layout) Stdlib.Bigarray.Array1.t array -> int
val writei_float_ba : handle -> int -> (float, Stdlib.Bigarray.float32_elt, Stdlib.Bigarray.c_layout) Stdlib.Bigarray.Array1.t -> int
val readn_float64 : handle -> float array array -> int -> int -> int
val writen_float64 : handle -> float array array -> int -> int -> int
val get_delay : handle -> int

Get the delay (in frames).

type state =
  1. | St_open
    (*

    open

    *)
  2. | St_setup
    (*

    setup installed

    *)
  3. | St_prepared
    (*

    ready to start

    *)
  4. | St_running
    (*

    running

    *)
  5. | St_xrun
    (*

    stopped: underrun (playback) or overrun (capture) detected

    *)
  6. | St_draining
    (*

    draining: running (playback) or stopped (capture)

    *)
  7. | St_paused
    (*

    paused

    *)
  8. | St_suspended
    (*

    hardware is suspended

    *)
  9. | St_disconnected
    (*

    hardward is disconnected

    *)

State.

val get_state : handle -> state

Get the current state.

val get_params : handle -> params
val set_params : handle -> params -> unit
type access =
  1. | Access_rw_interleaved
  2. | Access_rw_noninterleaved

Access mode.

val set_access : handle -> params -> access -> unit

Set the access mode.

type fmt =
  1. | Format_s16_le
    (*

    16 bits, little endian

    *)
  2. | Format_s24_3le
  3. | Format_float
    (*

    float 32 bit CPU endian

    *)
  4. | Format_float64
    (*

    float 64 bit CPU endian

    *)

Format of audio data.

val set_format : handle -> params -> fmt -> unit

Set the format of audio data.

val set_rate_near : handle -> params -> int -> direction -> int

set_rate_near handle params rate dir sets the sampling rate (in Hz). * If the rate is not avalaible, dir is used to determine the direction of * the nearest available sampling rate to use . The actual sampling rate used * is returned.

val set_channels : handle -> params -> int -> unit

Set the number of channels.

val set_periods : handle -> params -> int -> direction -> unit

Set the number of periods.

val get_periods_min : params -> int * direction

Get the number of periods.

val get_periods_max : params -> int * direction
val get_period_size : params -> int
val set_buffer_size : handle -> params -> int -> unit

Set the buffer size in frames.

val set_buffer_size_near : handle -> params -> int -> int

Set the buffer size near a value in frames.

val get_buffer_size : params -> int
val get_buffer_size_min : params -> int
val get_buffer_size_max : params -> int
val set_nonblock : handle -> bool -> unit

Set blocking mode (true means non-blocking).

val get_frame_size : params -> int

Get the size of a frame in bytes.

OCaml

Innovation. Community. Security.