Branch data Line data Source code
1 : : #ifndef foopulsesourcehfoo
2 : : #define foopulsesourcehfoo
3 : :
4 : : /***
5 : : This file is part of PulseAudio.
6 : :
7 : : Copyright 2004-2006 Lennart Poettering
8 : : Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
9 : :
10 : : PulseAudio is free software; you can redistribute it and/or modify
11 : : it under the terms of the GNU Lesser General Public License as published
12 : : by the Free Software Foundation; either version 2.1 of the License,
13 : : or (at your option) any later version.
14 : :
15 : : PulseAudio is distributed in the hope that it will be useful, but
16 : : WITHOUT ANY WARRANTY; without even the implied warranty of
17 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 : : General Public License for more details.
19 : :
20 : : You should have received a copy of the GNU Lesser General Public License
21 : : along with PulseAudio; if not, write to the Free Software
22 : : Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
23 : : USA.
24 : : ***/
25 : :
26 : : typedef struct pa_source pa_source;
27 : : typedef struct pa_source_volume_change pa_source_volume_change;
28 : :
29 : : #include <inttypes.h>
30 : :
31 : : #include <pulse/def.h>
32 : : #include <pulse/format.h>
33 : : #include <pulse/sample.h>
34 : : #include <pulse/channelmap.h>
35 : : #include <pulse/volume.h>
36 : :
37 : : #include <pulsecore/core.h>
38 : : #include <pulsecore/idxset.h>
39 : : #include <pulsecore/memchunk.h>
40 : : #include <pulsecore/sink.h>
41 : : #include <pulsecore/module.h>
42 : : #include <pulsecore/asyncmsgq.h>
43 : : #include <pulsecore/msgobject.h>
44 : : #include <pulsecore/rtpoll.h>
45 : : #include <pulsecore/card.h>
46 : : #include <pulsecore/device-port.h>
47 : : #include <pulsecore/queue.h>
48 : : #include <pulsecore/thread-mq.h>
49 : : #include <pulsecore/source-output.h>
50 : :
51 : : #define PA_MAX_OUTPUTS_PER_SOURCE 32
52 : :
53 : : /* Returns true if source is linked: registered and accessible from client side. */
54 : : static inline pa_bool_t PA_SOURCE_IS_LINKED(pa_source_state_t x) {
55 : 0 : return x == PA_SOURCE_RUNNING || x == PA_SOURCE_IDLE || x == PA_SOURCE_SUSPENDED;
56 : : }
57 : :
58 : : /* A generic definition for void callback functions */
59 : : typedef void(*pa_source_cb_t)(pa_source *s);
60 : :
61 : : struct pa_source {
62 : : pa_msgobject parent;
63 : :
64 : : uint32_t index;
65 : : pa_core *core;
66 : :
67 : : pa_source_state_t state;
68 : : pa_source_flags_t flags;
69 : : pa_suspend_cause_t suspend_cause;
70 : :
71 : : char *name;
72 : : char *driver; /* may be NULL */
73 : : pa_proplist *proplist;
74 : :
75 : : pa_module *module; /* may be NULL */
76 : : pa_card *card; /* may be NULL */
77 : :
78 : : pa_sample_spec sample_spec;
79 : : pa_channel_map channel_map;
80 : : uint32_t default_sample_rate;
81 : : uint32_t alternate_sample_rate;
82 : :
83 : : pa_idxset *outputs;
84 : : unsigned n_corked;
85 : : pa_sink *monitor_of; /* may be NULL */
86 : : pa_source_output *output_from_master; /* non-NULL only for filter sources */
87 : :
88 : : pa_volume_t base_volume; /* shall be constant */
89 : : unsigned n_volume_steps; /* shall be constant */
90 : :
91 : : /* Also see http://pulseaudio.org/wiki/InternalVolumes */
92 : : pa_cvolume reference_volume; /* The volume exported and taken as reference base for relative source output volumes */
93 : : pa_cvolume real_volume; /* The volume that the hardware is configured to */
94 : : pa_cvolume soft_volume; /* The internal software volume we apply to all PCM data while it passes through */
95 : :
96 : : pa_bool_t muted:1;
97 : :
98 : : pa_bool_t refresh_volume:1;
99 : : pa_bool_t refresh_muted:1;
100 : : pa_bool_t save_port:1;
101 : : pa_bool_t save_volume:1;
102 : : pa_bool_t save_muted:1;
103 : :
104 : : /* Saved volume state while we're in passthrough mode */
105 : : pa_cvolume saved_volume;
106 : : pa_bool_t saved_save_volume:1;
107 : :
108 : : pa_asyncmsgq *asyncmsgq;
109 : :
110 : : pa_memchunk silence;
111 : :
112 : : pa_hashmap *ports;
113 : : pa_device_port *active_port;
114 : : pa_atomic_t mixer_dirty;
115 : :
116 : : /* The latency offset is inherited from the currently active port */
117 : : int64_t latency_offset;
118 : :
119 : : unsigned priority;
120 : :
121 : : /* Called when the main loop requests a state change. Called from
122 : : * main loop context. If returns -1 the state change will be
123 : : * inhibited */
124 : : int (*set_state)(pa_source*source, pa_source_state_t state); /* may be NULL */
125 : :
126 : : /* Called when the volume is queried. Called from main loop
127 : : * context. If this is NULL a PA_SOURCE_MESSAGE_GET_VOLUME message
128 : : * will be sent to the IO thread instead. If refresh_volume is
129 : : * FALSE neither this function is called nor a message is sent.
130 : : *
131 : : * You must use the function pa_source_set_get_volume_callback() to
132 : : * set this callback. */
133 : : pa_source_cb_t get_volume; /* may be NULL */
134 : :
135 : : /* Called when the volume shall be changed. Called from main loop
136 : : * context. If this is NULL a PA_SOURCE_MESSAGE_SET_VOLUME message
137 : : * will be sent to the IO thread instead.
138 : : *
139 : : * You must use the function pa_source_set_set_volume_callback() to
140 : : * set this callback. */
141 : : pa_source_cb_t set_volume; /* may be NULL */
142 : :
143 : : /* Source drivers that set PA_SOURCE_DEFERRED_VOLUME must provide this
144 : : * callback. This callback is not used with source that do not set
145 : : * PA_SOURCE_DEFERRED_VOLUME. This is called from the IO thread when a
146 : : * pending hardware volume change has to be written to the
147 : : * hardware. The requested volume is passed to the callback
148 : : * implementation in s->thread_info.current_hw_volume.
149 : : *
150 : : * The call is done inside pa_source_volume_change_apply(), which is
151 : : * not called automatically - it is the driver's responsibility to
152 : : * schedule that function to be called at the right times in the
153 : : * IO thread.
154 : : *
155 : : * You must use the function pa_source_set_write_volume_callback() to
156 : : * set this callback. */
157 : : pa_source_cb_t write_volume; /* may be NULL */
158 : :
159 : : /* Called when the mute setting is queried. Called from main loop
160 : : * context. If this is NULL a PA_SOURCE_MESSAGE_GET_MUTE message
161 : : * will be sent to the IO thread instead. If refresh_mute is
162 : : * FALSE neither this function is called nor a message is sent.
163 : : *
164 : : * You must use the function pa_source_set_get_mute_callback() to
165 : : * set this callback. */
166 : : pa_source_cb_t get_mute; /* may be NULL */
167 : :
168 : : /* Called when the mute setting shall be changed. Called from main
169 : : * loop context. If this is NULL a PA_SOURCE_MESSAGE_SET_MUTE
170 : : * message will be sent to the IO thread instead.
171 : : *
172 : : * You must use the function pa_source_set_set_mute_callback() to
173 : : * set this callback. */
174 : : pa_source_cb_t set_mute; /* may be NULL */
175 : :
176 : : /* Called when a the requested latency is changed. Called from IO
177 : : * thread context. */
178 : : pa_source_cb_t update_requested_latency; /* may be NULL */
179 : :
180 : : /* Called whenever the port shall be changed. Called from IO
181 : : * thread if deferred volumes are enabled, and main thread otherwise. */
182 : : int (*set_port)(pa_source *s, pa_device_port *port); /*ditto */
183 : :
184 : : /* Called to get the list of formats supported by the source, sorted
185 : : * in descending order of preference. */
186 : : pa_idxset* (*get_formats)(pa_source *s); /* ditto */
187 : :
188 : : /* Called whenever the sampling frequency shall be changed. Called from
189 : : * main thread. */
190 : : pa_bool_t (*update_rate)(pa_source *s, uint32_t rate);
191 : :
192 : : /* Contains copies of the above data so that the real-time worker
193 : : * thread can work without access locking */
194 : : struct {
195 : : pa_source_state_t state;
196 : : pa_hashmap *outputs;
197 : :
198 : : pa_rtpoll *rtpoll;
199 : :
200 : : pa_cvolume soft_volume;
201 : : pa_bool_t soft_muted:1;
202 : :
203 : : pa_bool_t requested_latency_valid:1;
204 : : pa_usec_t requested_latency;
205 : :
206 : : /* Then number of bytes this source will be rewound for at
207 : : * max. (Only used on monitor sources) */
208 : : size_t max_rewind;
209 : :
210 : : pa_usec_t min_latency; /* we won't go below this latency */
211 : : pa_usec_t max_latency; /* An upper limit for the latencies */
212 : :
213 : : pa_usec_t fixed_latency; /* for sources with PA_SOURCE_DYNAMIC_LATENCY this is 0 */
214 : :
215 : : /* This latency offset is a direct copy from s->latency_offset */
216 : : int64_t latency_offset;
217 : :
218 : : /* Delayed volume change events are queued here. The events
219 : : * are stored in expiration order. The one expiring next is in
220 : : * the head of the list. */
221 : : PA_LLIST_HEAD(pa_source_volume_change, volume_changes);
222 : : pa_source_volume_change *volume_changes_tail;
223 : : /* This value is updated in pa_source_volume_change_apply() and
224 : : * used only by sources with PA_SOURCE_DEFERRED_VOLUME. */
225 : : pa_cvolume current_hw_volume;
226 : :
227 : : /* The amount of usec volume up events are delayed and volume
228 : : * down events are made earlier. */
229 : : uint32_t volume_change_safety_margin;
230 : : /* Usec delay added to all volume change events, may be negative. */
231 : : int32_t volume_change_extra_delay;
232 : : } thread_info;
233 : :
234 : : void *userdata;
235 : : };
236 : :
237 [ # # ][ # # ]: 0 : PA_DECLARE_PUBLIC_CLASS(pa_source);
[ # # ][ # # ]
[ # # ]
238 : : #define PA_SOURCE(s) pa_source_cast(s)
239 : :
240 : : typedef enum pa_source_message {
241 : : PA_SOURCE_MESSAGE_ADD_OUTPUT,
242 : : PA_SOURCE_MESSAGE_REMOVE_OUTPUT,
243 : : PA_SOURCE_MESSAGE_GET_VOLUME,
244 : : PA_SOURCE_MESSAGE_SET_SHARED_VOLUME,
245 : : PA_SOURCE_MESSAGE_SET_VOLUME_SYNCED,
246 : : PA_SOURCE_MESSAGE_SET_VOLUME,
247 : : PA_SOURCE_MESSAGE_SYNC_VOLUMES,
248 : : PA_SOURCE_MESSAGE_GET_MUTE,
249 : : PA_SOURCE_MESSAGE_SET_MUTE,
250 : : PA_SOURCE_MESSAGE_GET_LATENCY,
251 : : PA_SOURCE_MESSAGE_GET_REQUESTED_LATENCY,
252 : : PA_SOURCE_MESSAGE_SET_STATE,
253 : : PA_SOURCE_MESSAGE_ATTACH,
254 : : PA_SOURCE_MESSAGE_DETACH,
255 : : PA_SOURCE_MESSAGE_SET_LATENCY_RANGE,
256 : : PA_SOURCE_MESSAGE_GET_LATENCY_RANGE,
257 : : PA_SOURCE_MESSAGE_SET_FIXED_LATENCY,
258 : : PA_SOURCE_MESSAGE_GET_FIXED_LATENCY,
259 : : PA_SOURCE_MESSAGE_GET_MAX_REWIND,
260 : : PA_SOURCE_MESSAGE_SET_MAX_REWIND,
261 : : PA_SOURCE_MESSAGE_SET_PORT,
262 : : PA_SOURCE_MESSAGE_UPDATE_VOLUME_AND_MUTE,
263 : : PA_SOURCE_MESSAGE_SET_LATENCY_OFFSET,
264 : : PA_SOURCE_MESSAGE_MAX
265 : : } pa_source_message_t;
266 : :
267 : : typedef struct pa_source_new_data {
268 : : char *name;
269 : : pa_proplist *proplist;
270 : :
271 : : const char *driver;
272 : : pa_module *module;
273 : : pa_card *card;
274 : :
275 : : pa_hashmap *ports;
276 : : char *active_port;
277 : :
278 : : pa_sample_spec sample_spec;
279 : : pa_channel_map channel_map;
280 : : uint32_t alternate_sample_rate;
281 : : pa_cvolume volume;
282 : : pa_bool_t muted:1;
283 : :
284 : : pa_bool_t volume_is_set:1;
285 : : pa_bool_t muted_is_set:1;
286 : : pa_bool_t sample_spec_is_set:1;
287 : : pa_bool_t channel_map_is_set:1;
288 : : pa_bool_t alternate_sample_rate_is_set:1;
289 : :
290 : : pa_bool_t namereg_fail:1;
291 : :
292 : : pa_bool_t save_port:1;
293 : : pa_bool_t save_volume:1;
294 : : pa_bool_t save_muted:1;
295 : : } pa_source_new_data;
296 : :
297 : : pa_source_new_data* pa_source_new_data_init(pa_source_new_data *data);
298 : : void pa_source_new_data_set_name(pa_source_new_data *data, const char *name);
299 : : void pa_source_new_data_set_sample_spec(pa_source_new_data *data, const pa_sample_spec *spec);
300 : : void pa_source_new_data_set_channel_map(pa_source_new_data *data, const pa_channel_map *map);
301 : : void pa_source_new_data_set_alternate_sample_rate(pa_source_new_data *data, const uint32_t alternate_sample_rate);
302 : : void pa_source_new_data_set_volume(pa_source_new_data *data, const pa_cvolume *volume);
303 : : void pa_source_new_data_set_muted(pa_source_new_data *data, pa_bool_t mute);
304 : : void pa_source_new_data_set_port(pa_source_new_data *data, const char *port);
305 : : void pa_source_new_data_done(pa_source_new_data *data);
306 : :
307 : : /*** To be called exclusively by the source driver, from main context */
308 : :
309 : : pa_source* pa_source_new(
310 : : pa_core *core,
311 : : pa_source_new_data *data,
312 : : pa_source_flags_t flags);
313 : :
314 : : void pa_source_set_get_volume_callback(pa_source *s, pa_source_cb_t cb);
315 : : void pa_source_set_set_volume_callback(pa_source *s, pa_source_cb_t cb);
316 : : void pa_source_set_write_volume_callback(pa_source *s, pa_source_cb_t cb);
317 : : void pa_source_set_get_mute_callback(pa_source *s, pa_source_cb_t cb);
318 : : void pa_source_set_set_mute_callback(pa_source *s, pa_source_cb_t cb);
319 : : void pa_source_enable_decibel_volume(pa_source *s, pa_bool_t enable);
320 : :
321 : : void pa_source_put(pa_source *s);
322 : : void pa_source_unlink(pa_source *s);
323 : :
324 : : void pa_source_set_description(pa_source *s, const char *description);
325 : : void pa_source_set_asyncmsgq(pa_source *s, pa_asyncmsgq *q);
326 : : void pa_source_set_rtpoll(pa_source *s, pa_rtpoll *p);
327 : :
328 : : void pa_source_set_max_rewind(pa_source *s, size_t max_rewind);
329 : : void pa_source_set_latency_range(pa_source *s, pa_usec_t min_latency, pa_usec_t max_latency);
330 : : void pa_source_set_fixed_latency(pa_source *s, pa_usec_t latency);
331 : :
332 : : void pa_source_detach(pa_source *s);
333 : : void pa_source_attach(pa_source *s);
334 : :
335 : : void pa_source_set_soft_volume(pa_source *s, const pa_cvolume *volume);
336 : : void pa_source_volume_changed(pa_source *s, const pa_cvolume *new_volume);
337 : : void pa_source_mute_changed(pa_source *s, pa_bool_t new_muted);
338 : :
339 : : int pa_source_sync_suspend(pa_source *s);
340 : :
341 : : void pa_source_update_flags(pa_source *s, pa_source_flags_t mask, pa_source_flags_t value);
342 : :
343 : : /*** May be called by everyone, from main context */
344 : :
345 : : void pa_source_set_latency_offset(pa_source *s, int64_t offset);
346 : :
347 : : /* The returned value is supposed to be in the time domain of the sound card! */
348 : : pa_usec_t pa_source_get_latency(pa_source *s);
349 : : pa_usec_t pa_source_get_requested_latency(pa_source *s);
350 : : void pa_source_get_latency_range(pa_source *s, pa_usec_t *min_latency, pa_usec_t *max_latency);
351 : : pa_usec_t pa_source_get_fixed_latency(pa_source *s);
352 : :
353 : : size_t pa_source_get_max_rewind(pa_source *s);
354 : :
355 : : int pa_source_update_status(pa_source*s);
356 : : int pa_source_suspend(pa_source *s, pa_bool_t suspend, pa_suspend_cause_t cause);
357 : : int pa_source_suspend_all(pa_core *c, pa_bool_t suspend, pa_suspend_cause_t cause);
358 : :
359 : : /* Use this instead of checking s->flags & PA_SOURCE_FLAT_VOLUME directly. */
360 : : pa_bool_t pa_source_flat_volume_enabled(pa_source *s);
361 : :
362 : : /* Get the master source when sharing volumes */
363 : : pa_source *pa_source_get_master(pa_source *s);
364 : :
365 : : /* Is the source in passthrough mode? (that is, is this a monitor source for a sink
366 : : * that has a passthrough sink input connected to it. */
367 : : pa_bool_t pa_source_is_passthrough(pa_source *s);
368 : : /* These should be called when a source enters/leaves passthrough mode */
369 : : void pa_source_enter_passthrough(pa_source *s);
370 : : void pa_source_leave_passthrough(pa_source *s);
371 : :
372 : : void pa_source_set_volume(pa_source *source, const pa_cvolume *volume, pa_bool_t sendmsg, pa_bool_t save);
373 : : const pa_cvolume *pa_source_get_volume(pa_source *source, pa_bool_t force_refresh);
374 : :
375 : : void pa_source_set_mute(pa_source *source, pa_bool_t mute, pa_bool_t save);
376 : : pa_bool_t pa_source_get_mute(pa_source *source, pa_bool_t force_refresh);
377 : :
378 : : pa_bool_t pa_source_update_proplist(pa_source *s, pa_update_mode_t mode, pa_proplist *p);
379 : :
380 : : int pa_source_set_port(pa_source *s, const char *name, pa_bool_t save);
381 : : void pa_source_set_mixer_dirty(pa_source *s, pa_bool_t is_dirty);
382 : :
383 : : pa_bool_t pa_source_update_rate(pa_source *s, uint32_t rate, pa_bool_t passthrough);
384 : :
385 : : unsigned pa_source_linked_by(pa_source *s); /* Number of connected streams */
386 : : unsigned pa_source_used_by(pa_source *s); /* Number of connected streams that are not corked */
387 : : unsigned pa_source_check_suspend(pa_source *s); /* Returns how many streams are active that don't allow suspensions */
388 : : #define pa_source_get_state(s) ((pa_source_state_t) (s)->state)
389 : :
390 : : /* Moves all inputs away, and stores them in pa_queue */
391 : : pa_queue *pa_source_move_all_start(pa_source *s, pa_queue *q);
392 : : void pa_source_move_all_finish(pa_source *s, pa_queue *q, pa_bool_t save);
393 : : void pa_source_move_all_fail(pa_queue *q);
394 : :
395 : : pa_idxset* pa_source_get_formats(pa_source *s);
396 : : pa_bool_t pa_source_check_format(pa_source *s, pa_format_info *f);
397 : : pa_idxset* pa_source_check_formats(pa_source *s, pa_idxset *in_formats);
398 : :
399 : : /*** To be called exclusively by the source driver, from IO context */
400 : :
401 : : void pa_source_post(pa_source*s, const pa_memchunk *chunk);
402 : : void pa_source_post_direct(pa_source*s, pa_source_output *o, const pa_memchunk *chunk);
403 : : void pa_source_process_rewind(pa_source *s, size_t nbytes);
404 : :
405 : : int pa_source_process_msg(pa_msgobject *o, int code, void *userdata, int64_t, pa_memchunk *chunk);
406 : :
407 : : void pa_source_attach_within_thread(pa_source *s);
408 : : void pa_source_detach_within_thread(pa_source *s);
409 : :
410 : : pa_usec_t pa_source_get_requested_latency_within_thread(pa_source *s);
411 : :
412 : : void pa_source_set_max_rewind_within_thread(pa_source *s, size_t max_rewind);
413 : :
414 : : void pa_source_set_latency_range_within_thread(pa_source *s, pa_usec_t min_latency, pa_usec_t max_latency);
415 : : void pa_source_set_fixed_latency_within_thread(pa_source *s, pa_usec_t latency);
416 : :
417 : : void pa_source_update_volume_and_mute(pa_source *s);
418 : :
419 : : pa_bool_t pa_source_volume_change_apply(pa_source *s, pa_usec_t *usec_to_next);
420 : :
421 : : /*** To be called exclusively by source output drivers, from IO context */
422 : :
423 : : void pa_source_invalidate_requested_latency(pa_source *s, pa_bool_t dynamic);
424 : : pa_usec_t pa_source_get_latency_within_thread(pa_source *s);
425 : :
426 : : #define pa_source_assert_io_context(s) \
427 : : pa_assert(pa_thread_mq_get() || !PA_SOURCE_IS_LINKED((s)->state))
428 : :
429 : : #endif
|
