# Module Alsa.Pcm

    module Pcm: sig .. end

    type handle

Handle to a device.

    type params

Parameters of a device.
`type ``stream =`

`|` | `Playback` | `(*` | Playback stream. | `*)`
`|` | `Capture` | `(*` | Capture stream. | `*)`

Wanted stream.
`type ``mode =`

`|` | `Async` | `(*` | Asynchronous notification (not supported yet). | `*)`
`|` | `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 -> string -> 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 -> string -> int -> int -> int

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

    val readn : handle -> string array -> int -> int -> int

    val writen : handle -> string 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_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 =`

`|` | `St_open` | `(*` | open | `*)`
`|` | `St_setup` | `(*` | setup installed | `*)`
`|` | `St_prepared` | `(*` | ready to start | `*)`
`|` | `St_running` | `(*` | running | `*)`
`|` | `St_xrun` | `(*` | stopped: underrun (playback) or overrun (capture) detected | `*)`
`|` | `St_draining` | `(*` | draining: running (playback) or stopped (capture) | `*)`
`|` | `St_paused` | `(*` | paused | `*)`
`|` | `St_suspended` | `(*` | hardware is suspended | `*)`
`|` | `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 =`

`|` | `Access_rw_interleaved`
`|` | `Access_rw_noninterleaved`

Access mode.

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

Set the access mode.
`type ``fmt =`

`|` | `Format_s16_le` | `(*` | 16 bits, little endian | `*)`
`|` | `Format_s24_3le`
`|` | `Format_float` | `(*` | float 32 bit CPU endian | `*)`
`|` | `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 -> Alsa.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 -> Alsa.direction -> unit

Set the number of periods.

    val get_periods_min : params -> int * Alsa.direction

Get the number of periods.

    val get_periods_max : params -> int * Alsa.direction

    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_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.