1 #ifndef foopulsesinkinputhfoo
2 #define foopulsesinkinputhfoo
7 This file is part of PulseAudio.
9 Copyright 2004-2006 Lennart Poettering
10 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
12 PulseAudio is free software; you can redistribute it and/or modify
13 it under the terms of the GNU Lesser General Public License as published
14 by the Free Software Foundation; either version 2 of the License,
15 or (at your option) any later version.
17 PulseAudio is distributed in the hope that it will be useful, but
18 WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 General Public License for more details.
22 You should have received a copy of the GNU Lesser General Public License
23 along with PulseAudio; if not, write to the Free Software
24 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
30 typedef struct pa_sink_input pa_sink_input
;
32 #include <pulse/sample.h>
33 #include <pulsecore/hook-list.h>
34 #include <pulsecore/memblockq.h>
35 #include <pulsecore/resampler.h>
36 #include <pulsecore/module.h>
37 #include <pulsecore/client.h>
38 #include <pulsecore/sink.h>
39 #include <pulsecore/core.h>
41 typedef enum pa_sink_input_state
{
42 PA_SINK_INPUT_INIT
, /*< The stream is not active yet, because pa_sink_put() has not been called yet */
43 PA_SINK_INPUT_DRAINED
, /*< The stream stopped playing because there was no data to play */
44 PA_SINK_INPUT_RUNNING
, /*< The stream is alive and kicking */
45 PA_SINK_INPUT_CORKED
, /*< The stream was corked on user request */
46 PA_SINK_INPUT_UNLINKED
/*< The stream is dead */
47 } pa_sink_input_state_t
;
49 static inline pa_bool_t
PA_SINK_INPUT_LINKED(pa_sink_input_state_t x
) {
50 return x
== PA_SINK_INPUT_DRAINED
|| x
== PA_SINK_INPUT_RUNNING
|| x
== PA_SINK_INPUT_CORKED
;
53 typedef enum pa_sink_input_flags
{
54 PA_SINK_INPUT_VARIABLE_RATE
= 1,
55 PA_SINK_INPUT_DONT_MOVE
= 2,
56 PA_SINK_INPUT_START_CORKED
= 4,
57 PA_SINK_INPUT_NO_REMAP
= 8,
58 PA_SINK_INPUT_NO_REMIX
= 16,
59 PA_SINK_INPUT_FIX_FORMAT
= 32,
60 PA_SINK_INPUT_FIX_RATE
= 64,
61 PA_SINK_INPUT_FIX_CHANNELS
= 128
62 } pa_sink_input_flags_t
;
64 struct pa_sink_input
{
70 /* Please note that this state should only be read with
71 * pa_sink_input_get_state(). That function will transparently
72 * merge the thread_info.drained value in. */
73 pa_sink_input_state_t state
;
74 pa_sink_input_flags_t flags
;
76 pa_proplist
*proplist
;
77 char *driver
; /* may be NULL */
78 pa_module
*module
; /* may be NULL */
79 pa_client
*client
; /* may be NULL */
83 pa_sample_spec sample_spec
;
84 pa_channel_map channel_map
;
86 pa_sink_input
*sync_prev
, *sync_next
;
91 pa_resample_method_t resample_method
;
93 /* Returns the chunk of audio data and drops it from the
94 * queue. Returns -1 on failure. Called from IO thread context. If
95 * data needs to be generated from scratch then please in the
96 * specified length request_nbytes. This is an optimization
97 * only. If less data is available, it's fine to return a smaller
98 * block. If more data is already ready, it is better to return
100 int (*pop
) (pa_sink_input
*i
, size_t request_nbytes
, pa_memchunk
*chunk
); /* may NOT be NULL */
102 /* Rewind the queue by the specified number of bytes. Called just
103 * before peek() if it is called at all. Only called if the sink
104 * input driver ever plans to call
105 * pa_sink_input_request_rewind(). Called from IO context. */
106 void (*rewind
) (pa_sink_input
*i
, size_t nbytes
); /* may NOT be NULL */
108 /* Called whenever the maximum rewindable size of the sink
109 * changes. Called from RT context. */
110 void (*set_max_rewind
) (pa_sink_input
*i
, size_t nbytes
); /* may be NULL */
112 /* If non-NULL this function is called when the input is first
113 * connected to a sink or when the rtpoll/asyncmsgq fields
114 * change. You usually don't need to implement this function
115 * unless you rewrite a sink that is piggy-backed onto
116 * another. Called from IO thread context */
117 void (*attach
) (pa_sink_input
*i
); /* may be NULL */
119 /* If non-NULL this function is called when the output is
120 * disconnected from its sink. Called from IO thread context */
121 void (*detach
) (pa_sink_input
*i
); /* may be NULL */
123 /* If non-NULL called whenever the the sink this input is attached
124 * to suspends or resumes. Called from main context */
125 void (*suspend
) (pa_sink_input
*i
, pa_bool_t b
); /* may be NULL */
127 /* If non-NULL called whenever the the sink this input is attached
128 * to changes. Called from main context */
129 void (*moved
) (pa_sink_input
*i
); /* may be NULL */
131 /* Supposed to unlink and destroy this stream. Called from main
133 void (*kill
) (pa_sink_input
*i
); /* may be NULL */
135 /* Return the current latency (i.e. length of bufferd audio) of
136 this stream. Called from main context. If NULL a
137 PA_SINK_INPUT_MESSAGE_GET_LATENCY message is sent to the IO thread
139 pa_usec_t (*get_latency
) (pa_sink_input
*i
); /* may be NULL */
142 pa_sink_input_state_t state
;
143 pa_atomic_t drained
, render_memblockq_is_empty
;
145 pa_bool_t attached
; /* True only between ->attach() and ->detach() calls */
147 pa_sample_spec sample_spec
;
149 pa_resampler
*resampler
; /* may be NULL */
151 /* We maintain a history of resampled audio data here. */
152 pa_memblockq
*render_memblockq
;
154 size_t rewrite_nbytes
;
155 int64_t since_underrun
;
156 pa_bool_t ignore_rewind
;
158 pa_sink_input
*sync_prev
, *sync_next
;
163 /* The requested latency for the sink */
164 pa_usec_t requested_sink_latency
;
170 PA_DECLARE_CLASS(pa_sink_input
);
171 #define PA_SINK_INPUT(o) pa_sink_input_cast(o)
174 PA_SINK_INPUT_MESSAGE_SET_VOLUME
,
175 PA_SINK_INPUT_MESSAGE_SET_MUTE
,
176 PA_SINK_INPUT_MESSAGE_GET_LATENCY
,
177 PA_SINK_INPUT_MESSAGE_SET_RATE
,
178 PA_SINK_INPUT_MESSAGE_SET_STATE
,
179 PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY
,
180 PA_SINK_INPUT_MESSAGE_MAX
183 typedef struct pa_sink_input_new_data
{
184 pa_proplist
*proplist
;
192 pa_sample_spec sample_spec
;
193 pa_bool_t sample_spec_is_set
;
194 pa_channel_map channel_map
;
195 pa_bool_t channel_map_is_set
;
198 pa_bool_t volume_is_set
;
200 pa_bool_t muted_is_set
;
202 pa_resample_method_t resample_method
;
204 pa_sink_input
*sync_base
;
205 } pa_sink_input_new_data
;
207 pa_sink_input_new_data
* pa_sink_input_new_data_init(pa_sink_input_new_data
*data
);
208 void pa_sink_input_new_data_set_sample_spec(pa_sink_input_new_data
*data
, const pa_sample_spec
*spec
);
209 void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data
*data
, const pa_channel_map
*map
);
210 void pa_sink_input_new_data_set_volume(pa_sink_input_new_data
*data
, const pa_cvolume
*volume
);
211 void pa_sink_input_new_data_set_muted(pa_sink_input_new_data
*data
, pa_bool_t mute
);
212 void pa_sink_input_new_data_done(pa_sink_input_new_data
*data
);
214 typedef struct pa_sink_input_move_hook_data
{
215 pa_sink_input
*sink_input
;
216 pa_sink
*destination
;
217 } pa_sink_input_move_hook_data
;
219 /* To be called by the implementing module only */
221 pa_sink_input
* pa_sink_input_new(
223 pa_sink_input_new_data
*data
,
224 pa_sink_input_flags_t flags
);
226 void pa_sink_input_put(pa_sink_input
*i
);
227 void pa_sink_input_unlink(pa_sink_input
* i
);
229 void pa_sink_input_set_name(pa_sink_input
*i
, const char *name
);
231 pa_usec_t
pa_sink_input_set_requested_latency(pa_sink_input
*i
, pa_usec_t usec
);
233 /* Request that the specified number of bytes already written out to
234 the hw device is rewritten, if possible. Please note that this is
235 only a kind request. The sink driver may not be able to fulfill it
236 fully -- or at all. If the request for a rewrite was successful, the
237 sink driver will call ->rewind() and pass the number of bytes that
238 could be rewound in the HW device. This functionality is required for
239 implementing the "zero latency" write-through functionality. */
240 void pa_sink_input_request_rewind(pa_sink_input
*i
, size_t nbytes
, pa_bool_t ignore_rewind
);
242 /* Callable by everyone from main thread*/
244 /* External code may request disconnection with this function */
245 void pa_sink_input_kill(pa_sink_input
*i
);
247 pa_usec_t
pa_sink_input_get_latency(pa_sink_input
*i
);
249 void pa_sink_input_set_volume(pa_sink_input
*i
, const pa_cvolume
*volume
);
250 const pa_cvolume
*pa_sink_input_get_volume(pa_sink_input
*i
);
251 void pa_sink_input_set_mute(pa_sink_input
*i
, pa_bool_t mute
);
252 int pa_sink_input_get_mute(pa_sink_input
*i
);
254 void pa_sink_input_cork(pa_sink_input
*i
, pa_bool_t b
);
256 int pa_sink_input_set_rate(pa_sink_input
*i
, uint32_t rate
);
258 pa_resample_method_t
pa_sink_input_get_resample_method(pa_sink_input
*i
);
260 int pa_sink_input_move_to(pa_sink_input
*i
, pa_sink
*dest
, int immediately
);
262 pa_sink_input_state_t
pa_sink_input_get_state(pa_sink_input
*i
);
264 pa_bool_t
pa_sink_input_safe_to_remove(pa_sink_input
*i
);
265 /* To be used exclusively by the sink driver IO thread */
267 int pa_sink_input_peek(pa_sink_input
*i
, size_t length
, pa_memchunk
*chunk
, pa_cvolume
*volume
);
268 void pa_sink_input_drop(pa_sink_input
*i
, size_t length
);
269 void pa_sink_input_process_rewind(pa_sink_input
*i
, size_t nbytes
/* in the sink's sample spec */);
270 void pa_sink_input_set_max_rewind(pa_sink_input
*i
, size_t nbytes
/* in the sink's sample spec */);
272 int pa_sink_input_process_msg(pa_msgobject
*o
, int code
, void *userdata
, int64_t offset
, pa_memchunk
*chunk
);
274 typedef struct pa_sink_input_move_info
{
275 pa_sink_input
*sink_input
;
276 pa_sink_input
*ghost_sink_input
;
277 pa_memblockq
*buffer
;
279 } pa_sink_input_move_info
;
281 pa_memchunk
* pa_sink_input_get_silence(pa_sink_input
*i
, pa_memchunk
*ret
);