stream.h

Go to the documentation of this file.

#ifndef foostreamhfoo
#define foostreamhfoo

/***
  This file is part of PulseAudio.

  Copyright 2004-2006 Lennart Poettering
  Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB

  PulseAudio is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published
  by the Free Software Foundation; either version 2.1 of the License,
  or (at your option) any later version.

  PulseAudio is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with PulseAudio; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  USA.
***/

#include <sys/types.h>

#include <pulse/sample.h>
#include <pulse/channelmap.h>
#include <pulse/volume.h>
#include <pulse/def.h>
#include <pulse/cdecl.h>
#include <pulse/operation.h>
#include <pulse/context.h>
#include <pulse/proplist.h>

PA_C_DECL_BEGIN

typedef struct pa_stream pa_stream;

typedef void (*pa_stream_success_cb_t) (pa_stream*s, int success, void *userdata);

typedef void (*pa_stream_request_cb_t)(pa_stream *p, size_t nbytes, void *userdata);

typedef void (*pa_stream_notify_cb_t)(pa_stream *p, void *userdata);

typedef void (*pa_stream_event_cb_t)(pa_stream *p, const char *name, pa_proplist *pl, void *userdata);

pa_stream* pa_stream_new(
        pa_context *c                     ,
        const char *name                  ,
        const pa_sample_spec *ss          ,
        const pa_channel_map *map         );

pa_stream* pa_stream_new_with_proplist(
        pa_context *c                     ,
        const char *name                  ,
        const pa_sample_spec *ss          ,
        const pa_channel_map *map         ,
        pa_proplist *p                    );

void pa_stream_unref(pa_stream *s);

pa_stream *pa_stream_ref(pa_stream *s);

pa_stream_state_t pa_stream_get_state(pa_stream *p);

pa_context* pa_stream_get_context(pa_stream *p);

uint32_t pa_stream_get_index(pa_stream *s);

uint32_t pa_stream_get_device_index(pa_stream *s);

const char *pa_stream_get_device_name(pa_stream *s);

int pa_stream_is_suspended(pa_stream *s);

int pa_stream_is_corked(pa_stream *s);

int pa_stream_connect_playback(
        pa_stream *s                  ,
        const char *dev                ,
        const pa_buffer_attr *attr    ,
        pa_stream_flags_t flags       ,
        const pa_cvolume *volume      ,
        pa_stream *sync_stream        );

int pa_stream_connect_record(
        pa_stream *s                   ,
        const char *dev               ,
        const pa_buffer_attr *attr    ,
        pa_stream_flags_t flags       );

int pa_stream_disconnect(pa_stream *s);

int pa_stream_begin_write(
        pa_stream *p,
        void **data,
        size_t *nbytes);

int pa_stream_cancel_write(
        pa_stream *p);

int pa_stream_write(
        pa_stream *p             ,
        const void *data         ,
        size_t nbytes            ,
        pa_free_cb_t free_cb     ,
        int64_t offset,          
        pa_seek_mode_t seek      );

int pa_stream_peek(
        pa_stream *p                 ,
        const void **data            ,
        size_t *nbytes               );

int pa_stream_drop(pa_stream *p);

size_t pa_stream_writable_size(pa_stream *p);

size_t pa_stream_readable_size(pa_stream *p);

pa_operation* pa_stream_drain(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);

pa_operation* pa_stream_update_timing_info(pa_stream *p, pa_stream_success_cb_t cb, void *userdata);

void pa_stream_set_state_callback(pa_stream *s, pa_stream_notify_cb_t cb, void *userdata);

void pa_stream_set_write_callback(pa_stream *p, pa_stream_request_cb_t cb, void *userdata);

void pa_stream_set_read_callback(pa_stream *p, pa_stream_request_cb_t cb, void *userdata);

void pa_stream_set_overflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);

void pa_stream_set_underflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);

void pa_stream_set_started_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);

void pa_stream_set_latency_update_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);

void pa_stream_set_moved_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);

void pa_stream_set_suspended_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);

void pa_stream_set_event_callback(pa_stream *p, pa_stream_event_cb_t cb, void *userdata);

void pa_stream_set_buffer_attr_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);

pa_operation* pa_stream_cork(pa_stream *s, int b, pa_stream_success_cb_t cb, void *userdata);

pa_operation* pa_stream_flush(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);

pa_operation* pa_stream_prebuf(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);

pa_operation* pa_stream_trigger(pa_stream *s, pa_stream_success_cb_t cb, void *userdata);

pa_operation* pa_stream_set_name(pa_stream *s, const char *name, pa_stream_success_cb_t cb, void *userdata);

int pa_stream_get_time(pa_stream *s, pa_usec_t *r_usec);

int pa_stream_get_latency(pa_stream *s, pa_usec_t *r_usec, int *negative);

const pa_timing_info* pa_stream_get_timing_info(pa_stream *s);

const pa_sample_spec* pa_stream_get_sample_spec(pa_stream *s);

const pa_channel_map* pa_stream_get_channel_map(pa_stream *s);

const pa_buffer_attr* pa_stream_get_buffer_attr(pa_stream *s);

pa_operation *pa_stream_set_buffer_attr(pa_stream *s, const pa_buffer_attr *attr, pa_stream_success_cb_t cb, void *userdata);

pa_operation *pa_stream_update_sample_rate(pa_stream *s, uint32_t rate, pa_stream_success_cb_t cb, void *userdata);

pa_operation *pa_stream_proplist_update(pa_stream *s, pa_update_mode_t mode, pa_proplist *p, pa_stream_success_cb_t cb, void *userdata);

pa_operation *pa_stream_proplist_remove(pa_stream *s, const char *const keys[], pa_stream_success_cb_t cb, void *userdata);

int pa_stream_set_monitor_stream(pa_stream *s, uint32_t sink_input_idx);

uint32_t pa_stream_get_monitor_stream(pa_stream *s);

PA_C_DECL_END

#endif