mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-11-06 13:29:56 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

commit glitch-free work

Browse source 
git-svn-id: file:///home/lennart/svn/public/pulseaudio/branches/glitch-free@2122 fefdeb5f-60dc-0310-8127-8f9354f1896f
This commit is contained in:
Lennart Poettering 2008-03-15 15:19:40 +00:00
parent 347cfc356a
commit 12c01e942d
50 changed files with 2877 additions and 1194 deletions
Download patch file Download diff file Expand all files Collapse all files

86
src/pulsecore/sink-input.h
View file

@ -73,7 +73,8 @@ struct pa_sink_input {
pa_sink_input_state_t state;
pa_sink_input_flags_t flags;
char *name, *driver; /* may be NULL */
pa_proplist *proplist;
char *driver; /* may be NULL */
pa_module *module; /* may be NULL */
pa_client *client; /* may be NULL */
@ -87,17 +88,26 @@ struct pa_sink_input {
pa_cvolume volume;
pa_bool_t muted;
/* Returns the chunk of audio data (but doesn't drop it
* yet!). Returns -1 on failure. Called from IO thread context. If
* data needs to be generated from scratch then please in the
* specified length. This is an optimization only. If less data is
* available, it's fine to return a smaller block. If more data is
* already ready, it is better to return the full block.*/
int (*peek) (pa_sink_input *i, size_t length, pa_memchunk *chunk);
pa_resample_method_t resample_method;
/* Drops the specified number of bytes, usually called right after
* peek(), but not necessarily. Called from IO thread context. */
void (*drop) (pa_sink_input *i, size_t length);
/* Returns the chunk of audio data and drops it from the
* queue. Returns -1 on failure. Called from IO thread context. If
* data needs to be generated from scratch then please in the
* specified length request_nbytes. This is an optimization
* only. If less data is available, it's fine to return a smaller
* block. If more data is already ready, it is better to return
* the full block. */
int (*pop) (pa_sink_input *i, size_t request_nbytes, pa_memchunk *chunk);
/* Rewind the queue by the specified number of bytes. Called just
* before peek() if it is called at all. Only called if the sink
* input driver ever plans to call
* pa_sink_input_request_rewrite(). Called from IO context. */
void (*rewind) (pa_sink_input *i, size_t nbytes);
/* Called whenever the maximum rewindable size of the sink
* changes. Called from UI context. */
void (*set_max_rewind) (pa_sink_input *i, size_t nbytes); /* may be NULL */
/* If non-NULL this function is called when the input is first
* connected to a sink or when the rtpoll/asyncmsgq fields
@ -128,29 +138,28 @@ struct pa_sink_input {
instead. */
pa_usec_t (*get_latency) (pa_sink_input *i); /* may be NULL */
pa_resample_method_t resample_method;
struct {
pa_sink_input_state_t state;
pa_atomic_t drained;
pa_atomic_t drained, render_memblockq_is_empty;
pa_bool_t attached; /* True only between ->attach() and ->detach() calls */
pa_sample_spec sample_spec;
pa_memchunk resampled_chunk;
pa_resampler *resampler; /* may be NULL */
/* Some silence to play before the actual data. This is used to
* compensate for latency differences when moving a sink input
* "hot" between sinks. */
size_t move_silence;
pa_memblock *silence_memblock; /* may be NULL */
/* We maintain a history of resampled audio data here. */
pa_memblockq *render_memblockq;
size_t rewrite_nbytes;
pa_bool_t ignore_rewind;
pa_sink_input *sync_prev, *sync_next;
pa_cvolume volume;
pa_bool_t muted;
/* The requested latency for the sink */
pa_usec_t requested_sink_latency;
} thread_info;
void *userdata;
@ -165,11 +174,14 @@ enum {
PA_SINK_INPUT_MESSAGE_GET_LATENCY,
PA_SINK_INPUT_MESSAGE_SET_RATE,
PA_SINK_INPUT_MESSAGE_SET_STATE,
PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY,
PA_SINK_INPUT_MESSAGE_MAX
};
typedef struct pa_sink_input_new_data {
const char *name, *driver;
pa_proplist *proplist;
const char *driver;
pa_module *module;
pa_client *client;
@ -190,16 +202,17 @@ typedef struct pa_sink_input_new_data {
pa_sink_input *sync_base;
} pa_sink_input_new_data;
typedef struct pa_sink_input_move_hook_data {
pa_sink_input *sink_input;
pa_sink *destination;
} pa_sink_input_move_hook_data;
pa_sink_input_new_data* pa_sink_input_new_data_init(pa_sink_input_new_data *data);
void pa_sink_input_new_data_set_sample_spec(pa_sink_input_new_data *data, const pa_sample_spec *spec);
void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data *data, const pa_channel_map *map);
void pa_sink_input_new_data_set_volume(pa_sink_input_new_data *data, const pa_cvolume *volume);
void pa_sink_input_new_data_set_muted(pa_sink_input_new_data *data, pa_bool_t mute);
void pa_sink_input_new_data_done(pa_sink_input_new_data *data);
typedef struct pa_sink_input_move_hook_data {
pa_sink_input *sink_input;
pa_sink *destination;
} pa_sink_input_move_hook_data;
/* To be called by the implementing module only */
@ -213,7 +226,19 @@ void pa_sink_input_unlink(pa_sink_input* i);
void pa_sink_input_set_name(pa_sink_input *i, const char *name);
/* Callable by everyone */
void pa_sink_input_set_requested_latency(pa_sink_input *i, pa_usec_t usec);
/* Request that the specified number of bytes already written out to
the hw device is rewritten, if possible. If this function is used you
need to supply the ->rewind() function pointer. Please note that this
is only a kind request. The sink driver may not be able to fulfill it
fully -- or at all. If the request for a rewrite was successful, the
sink driver will call ->rewind() and pass the number of bytes that
could be rewound in the HW device. This functionality is required for
implementing the "zero latency" write-through functionality. */
void pa_sink_input_request_rewrite(pa_sink_input *i, size_t nbytes);
/* Callable by everyone from main thread*/
/* External code may request disconnection with this function */
void pa_sink_input_kill(pa_sink_input*i);
@ -235,10 +260,14 @@ int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, int immediately);
pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i);
/* To be used exclusively by the sink driver thread */
pa_bool_t pa_sink_input_safe_to_remove(pa_sink_input *i);
/* To be used exclusively by the sink driver IO thread */
int pa_sink_input_peek(pa_sink_input *i, size_t length, pa_memchunk *chunk, pa_cvolume *volume);
void pa_sink_input_drop(pa_sink_input *i, size_t length);
void pa_sink_input_rewind(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */);
void pa_sink_input_set_max_rewind(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */);
int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk);
typedef struct pa_sink_input_move_info {
@ -248,4 +277,5 @@ typedef struct pa_sink_input_move_info {
size_t buffer_bytes;
} pa_sink_input_move_info;
#endif