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, see <http://www.gnu.org/licenses/>.
***/
 
#include <sys/types.h>
 
#include <pulse/sample.h>
#include <pulse/format.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                    );
 
pa_stream *pa_stream_new_extended(
        pa_context *c                     ,
        const char *name                  ,
        pa_format_info * const * formats  ,
        unsigned int n_formats            ,
        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(const pa_stream *p);
 
pa_context* pa_stream_get_context(const pa_stream *p);
 
uint32_t pa_stream_get_index(const pa_stream *s);
 
uint32_t pa_stream_get_device_index(const pa_stream *s);
 
const char *pa_stream_get_device_name(const pa_stream *s);
 
int pa_stream_is_suspended(const pa_stream *s);
 
int pa_stream_is_corked(const 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_write_ext_free(
        pa_stream *p             ,
        const void *data         ,
        size_t nbytes            ,
        pa_free_cb_t free_cb     ,
        void *free_cb_data       ,
        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(const pa_stream *p);
 
size_t pa_stream_readable_size(const 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);
 
int64_t pa_stream_get_underflow_index(const pa_stream *p);
 
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_format_info* pa_stream_get_format_info(const 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(const pa_stream *s);
 
PA_C_DECL_END
 
#endif