1 #ifndef foopulsesourceoutputhfoo
2 #define foopulsesourceoutputhfoo
3
4 /***
5 This file is part of PulseAudio.
6
7 Copyright 2004-2006 Lennart Poettering
8
9 PulseAudio is free software; you can redistribute it and/or modify
10 it under the terms of the GNU Lesser General Public License as published
11 by the Free Software Foundation; either version 2.1 of the License,
12 or (at your option) any later version.
13
14 PulseAudio is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
18
19 You should have received a copy of the GNU Lesser General Public License
20 along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
21 ***/
22
23 #include <inttypes.h>
24
25 #include <pulsecore/typedefs.h>
26 #include <pulse/sample.h>
27 #include <pulse/format.h>
28 #include <pulsecore/memblockq.h>
29 #include <pulsecore/resampler.h>
30 #include <pulsecore/module.h>
31 #include <pulsecore/client.h>
32 #include <pulsecore/source.h>
33 #include <pulsecore/core.h>
34 #include <pulsecore/sink-input.h>
35
36 typedef enum pa_source_output_state {
37 PA_SOURCE_OUTPUT_INIT,
38 PA_SOURCE_OUTPUT_RUNNING,
39 PA_SOURCE_OUTPUT_CORKED,
40 PA_SOURCE_OUTPUT_UNLINKED
41 } pa_source_output_state_t;
42
PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_state_t x)43 static inline bool PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_state_t x) {
44 return x == PA_SOURCE_OUTPUT_RUNNING || x == PA_SOURCE_OUTPUT_CORKED;
45 }
46
47 typedef enum pa_source_output_flags {
48 PA_SOURCE_OUTPUT_VARIABLE_RATE = 1,
49 PA_SOURCE_OUTPUT_DONT_MOVE = 2,
50 PA_SOURCE_OUTPUT_START_CORKED = 4,
51 PA_SOURCE_OUTPUT_NO_REMAP = 8,
52 PA_SOURCE_OUTPUT_NO_REMIX = 16,
53 PA_SOURCE_OUTPUT_FIX_FORMAT = 32,
54 PA_SOURCE_OUTPUT_FIX_RATE = 64,
55 PA_SOURCE_OUTPUT_FIX_CHANNELS = 128,
56 PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND = 256,
57 PA_SOURCE_OUTPUT_NO_CREATE_ON_SUSPEND = 512,
58 PA_SOURCE_OUTPUT_KILL_ON_SUSPEND = 1024,
59 PA_SOURCE_OUTPUT_PASSTHROUGH = 2048
60 } pa_source_output_flags_t;
61
62 struct pa_source_output {
63 pa_msgobject parent;
64
65 uint32_t index;
66 pa_core *core;
67
68 pa_source_output_state_t state;
69 pa_source_output_flags_t flags;
70
71 char *driver; /* may be NULL */
72 pa_proplist *proplist;
73
74 pa_module *module; /* may be NULL */
75 pa_client *client; /* may be NULL */
76
77 pa_source *source; /* NULL while being moved */
78
79 /* This is set to true when creating the source output if the source was
80 * requested by the application that created the source output. This is
81 * sometimes useful for determining whether the source output should be
82 * moved by some automatic policy. If the source output is moved away from
83 * the source that the application requested, this flag is reset to
84 * false. */
85 bool source_requested_by_application;
86
87 pa_source *destination_source; /* only set by filter sources */
88
89 /* A source output can monitor just a single input of a sink, in which case we find it here */
90 pa_sink_input *direct_on_input; /* may be NULL */
91
92 pa_sample_spec sample_spec;
93 pa_channel_map channel_map;
94 pa_format_info *format;
95
96 /* Also see http://www.freedesktop.org/wiki/Software/PulseAudio/Documentation/Developer/Volumes/ */
97 pa_cvolume volume; /* The volume clients are informed about */
98 pa_cvolume reference_ratio; /* The ratio of the stream's volume to the source's reference volume */
99 pa_cvolume real_ratio; /* The ratio of the stream's volume to the source's real volume */
100 pa_cvolume volume_factor; /* An internally used volume factor that can be used by modules to apply effects and suchlike without having that visible to the outside */
101 pa_cvolume soft_volume; /* The internal software volume we apply to all PCM data while it passes through. Usually calculated as real_ratio * volume_factor */
102
103 pa_cvolume volume_factor_source; /* A second volume factor in format of the source this stream is connected to */
104
105 bool volume_writable:1;
106
107 bool muted:1;
108
109 /* if true then the volume and the mute state of this source-output
110 * are worth remembering, module-stream-restore looks for this. */
111 bool save_volume:1, save_muted:1;
112
113 /* if users move the source-output to a source, and the source is not
114 * default_source, the source->name will be saved in preferred_source. And
115 * later if source-output is moved to other sources for some reason, it
116 * still can be restored to the preferred_source at an appropriate time */
117 char *preferred_source;
118
119 pa_resample_method_t requested_resample_method, actual_resample_method;
120
121 /* Pushes a new memchunk into the output. Called from IO thread
122 * context. */
123 void (*push)(pa_source_output *o, const pa_memchunk *chunk); /* may NOT be NULL */
124
125 /* Only relevant for monitor sources right now: called when the
126 * recorded stream is rewound. Called from IO context */
127 void (*process_rewind)(pa_source_output *o, size_t nbytes); /* may be NULL */
128
129 /* Called whenever the maximum rewindable size of the source
130 * changes. Called from IO thread context. */
131 void (*update_max_rewind) (pa_source_output *o, size_t nbytes); /* may be NULL */
132
133 /* Called whenever the configured latency of the source
134 * changes. Called from IO context. */
135 void (*update_source_requested_latency) (pa_source_output *o); /* may be NULL */
136
137 /* Called whenever the latency range of the source changes. Called
138 * from IO context. */
139 void (*update_source_latency_range) (pa_source_output *o); /* may be NULL */
140
141 /* Called whenever the fixed latency of the source changes, if there
142 * is one. Called from IO context. */
143 void (*update_source_fixed_latency) (pa_source_output *i); /* may be NULL */
144
145 /* If non-NULL this function is called when the output is first
146 * connected to a source or when the rtpoll/asyncmsgq fields
147 * change. You usually don't need to implement this function
148 * unless you rewrite a source that is piggy-backed onto
149 * another. Called from IO thread context */
150 void (*attach) (pa_source_output *o); /* may be NULL */
151
152 /* If non-NULL this function is called when the output is
153 * disconnected from its source. Called from IO thread context */
154 void (*detach) (pa_source_output *o); /* may be NULL */
155
156 /* If non-NULL called whenever the source this output is attached
157 * to suspends or resumes or if the suspend cause changes.
158 * Called from main context */
159 void (*suspend) (pa_source_output *o, pa_source_state_t old_state, pa_suspend_cause_t old_suspend_cause); /* may be NULL */
160
161 /* If non-NULL called whenever the source this output is attached
162 * to suspends or resumes. Called from IO context */
163 void (*suspend_within_thread) (pa_source_output *o, bool b); /* may be NULL */
164
165 /* If non-NULL called whenever the source output is moved to a new
166 * source. Called from main context after the source output has been
167 * detached from the old source and before it has been attached to
168 * the new source. If dest is NULL the move was executed in two
169 * phases and the second one failed; the stream will be destroyed
170 * after this call. */
171 void (*moving) (pa_source_output *o, pa_source *dest); /* may be NULL */
172
173 /* Supposed to unlink and destroy this stream. Called from main
174 * context. */
175 void (*kill)(pa_source_output* o); /* may NOT be NULL */
176
177 /* Return the current latency (i.e. length of buffered audio) of
178 this stream. Called from main context. This is added to what the
179 PA_SOURCE_OUTPUT_MESSAGE_GET_LATENCY message sent to the IO thread
180 returns */
181 pa_usec_t (*get_latency) (pa_source_output *o); /* may be NULL */
182
183 /* If non-NULL this function is called from thread context if the
184 * state changes. The old state is found in thread_info.state. */
185 void (*state_change) (pa_source_output *o, pa_source_output_state_t state); /* may be NULL */
186
187 /* If non-NULL this function is called before this source output
188 * is moved to a source and if it returns false the move
189 * will not be allowed */
190 bool (*may_move_to) (pa_source_output *o, pa_source *s); /* may be NULL */
191
192 /* If non-NULL this function is used to dispatch asynchronous
193 * control events. */
194 void (*send_event)(pa_source_output *o, const char *event, pa_proplist* data);
195
196 /* If non-NULL this function is called whenever the source output
197 * volume changes. Called from main context */
198 void (*volume_changed)(pa_source_output *o); /* may be NULL */
199
200 /* If non-NULL this function is called whenever the source output
201 * mute status changes. Called from main context */
202 void (*mute_changed)(pa_source_output *o); /* may be NULL */
203
204 struct {
205 pa_source_output_state_t state;
206
207 pa_cvolume soft_volume;
208 bool muted:1;
209
210 bool attached:1; /* True only between ->attach() and ->detach() calls */
211
212 pa_sample_spec sample_spec;
213
214 pa_resampler* resampler; /* may be NULL */
215
216 /* We maintain a delay memblockq here for source outputs that
217 * don't implement rewind() */
218 pa_memblockq *delay_memblockq;
219
220 /* The requested latency for the source */
221 pa_usec_t requested_source_latency;
222
223 pa_sink_input *direct_on_input; /* may be NULL */
224 } thread_info;
225
226 void *userdata;
227 };
228
229 PA_DECLARE_PUBLIC_CLASS(pa_source_output);
230 #define PA_SOURCE_OUTPUT(o) pa_source_output_cast(o)
231
232 enum {
233 PA_SOURCE_OUTPUT_MESSAGE_GET_LATENCY,
234 PA_SOURCE_OUTPUT_MESSAGE_SET_RATE,
235 PA_SOURCE_OUTPUT_MESSAGE_SET_STATE,
236 PA_SOURCE_OUTPUT_MESSAGE_SET_REQUESTED_LATENCY,
237 PA_SOURCE_OUTPUT_MESSAGE_GET_REQUESTED_LATENCY,
238 PA_SOURCE_OUTPUT_MESSAGE_SET_SOFT_VOLUME,
239 PA_SOURCE_OUTPUT_MESSAGE_SET_SOFT_MUTE,
240 PA_SOURCE_OUTPUT_MESSAGE_MAX
241 };
242
243 typedef struct pa_source_output_send_event_hook_data {
244 pa_source_output *source_output;
245 const char *event;
246 pa_proplist *data;
247 } pa_source_output_send_event_hook_data;
248
249 typedef struct pa_source_output_new_data {
250 pa_source_output_flags_t flags;
251
252 pa_proplist *proplist;
253 pa_sink_input *direct_on_input;
254
255 const char *driver;
256 pa_module *module;
257 pa_client *client;
258
259 pa_source *source;
260 bool source_requested_by_application;
261 pa_source *destination_source;
262
263 pa_resample_method_t resample_method;
264
265 pa_sample_spec sample_spec;
266 pa_channel_map channel_map;
267 pa_format_info *format;
268 pa_idxset *req_formats;
269 pa_idxset *nego_formats;
270
271 pa_cvolume volume, volume_factor, volume_factor_source;
272 bool muted:1;
273
274 bool sample_spec_is_set:1;
275 bool channel_map_is_set:1;
276
277 bool volume_is_set:1, volume_factor_is_set:1, volume_factor_source_is_set:1;
278 bool muted_is_set:1;
279
280 bool volume_is_absolute:1;
281
282 bool volume_writable:1;
283
284 bool save_volume:1, save_muted:1;
285 char *preferred_source;
286 } pa_source_output_new_data;
287
288 pa_source_output_new_data* pa_source_output_new_data_init(pa_source_output_new_data *data);
289 void pa_source_output_new_data_set_sample_spec(pa_source_output_new_data *data, const pa_sample_spec *spec);
290 void pa_source_output_new_data_set_channel_map(pa_source_output_new_data *data, const pa_channel_map *map);
291 bool pa_source_output_new_data_is_passthrough(pa_source_output_new_data *data);
292 void pa_source_output_new_data_set_volume(pa_source_output_new_data *data, const pa_cvolume *volume);
293 void pa_source_output_new_data_apply_volume_factor(pa_source_output_new_data *data, const pa_cvolume *volume_factor);
294 void pa_source_output_new_data_apply_volume_factor_source(pa_source_output_new_data *data, const pa_cvolume *volume_factor);
295 void pa_source_output_new_data_set_muted(pa_source_output_new_data *data, bool mute);
296 bool pa_source_output_new_data_set_source(pa_source_output_new_data *data, pa_source *s, bool save,
297 bool requested_by_application);
298 bool pa_source_output_new_data_set_formats(pa_source_output_new_data *data, pa_idxset *formats);
299 void pa_source_output_new_data_done(pa_source_output_new_data *data);
300
301 /* To be called by the implementing module only */
302
303 int pa_source_output_new(
304 pa_source_output**o,
305 pa_core *core,
306 pa_source_output_new_data *data);
307
308 void pa_source_output_put(pa_source_output *o);
309 void pa_source_output_unlink(pa_source_output*o);
310
311 pa_usec_t pa_source_output_set_requested_latency(pa_source_output *o, pa_usec_t usec);
312
313 void pa_source_output_cork(pa_source_output *o, bool b);
314
315 int pa_source_output_set_rate(pa_source_output *o, uint32_t rate);
316 int pa_source_output_update_resampler(pa_source_output *o);
317
318 size_t pa_source_output_get_max_rewind(pa_source_output *o);
319
320 /* Callable by everyone */
321
322 /* External code may request disconnection with this function */
323 void pa_source_output_kill(pa_source_output*o);
324
325 pa_usec_t pa_source_output_get_latency(pa_source_output *o, pa_usec_t *source_latency);
326
327 bool pa_source_output_is_volume_readable(pa_source_output *o);
328 bool pa_source_output_is_passthrough(pa_source_output *o);
329 void pa_source_output_set_volume(pa_source_output *o, const pa_cvolume *volume, bool save, bool absolute);
330 pa_cvolume *pa_source_output_get_volume(pa_source_output *o, pa_cvolume *volume, bool absolute);
331
332 void pa_source_output_set_mute(pa_source_output *o, bool mute, bool save);
333
334 void pa_source_output_set_property(pa_source_output *o, const char *key, const char *value);
335 void pa_source_output_set_property_arbitrary(pa_source_output *o, const char *key, const uint8_t *value, size_t nbytes);
336 void pa_source_output_update_proplist(pa_source_output *o, pa_update_mode_t mode, pa_proplist *p);
337
338 pa_resample_method_t pa_source_output_get_resample_method(pa_source_output *o);
339
340 void pa_source_output_send_event(pa_source_output *o, const char *name, pa_proplist *data);
341
342 bool pa_source_output_may_move(pa_source_output *o);
343 bool pa_source_output_may_move_to(pa_source_output *o, pa_source *dest);
344 int pa_source_output_move_to(pa_source_output *o, pa_source *dest, bool save);
345
346 /* The same as pa_source_output_move_to() but in two separate steps,
347 * first the detaching from the old source, then the attaching to the
348 * new source */
349 int pa_source_output_start_move(pa_source_output *o);
350 int pa_source_output_finish_move(pa_source_output *o, pa_source *dest, bool save);
351 void pa_source_output_fail_move(pa_source_output *o);
352
353 pa_usec_t pa_source_output_get_requested_latency(pa_source_output *o);
354
355 /* To be used exclusively by the source driver thread */
356
357 void pa_source_output_push(pa_source_output *o, const pa_memchunk *chunk);
358 void pa_source_output_process_rewind(pa_source_output *o, size_t nbytes);
359 void pa_source_output_update_max_rewind(pa_source_output *o, size_t nbytes);
360
361 void pa_source_output_set_state_within_thread(pa_source_output *o, pa_source_output_state_t state);
362
363 int pa_source_output_process_msg(pa_msgobject *mo, int code, void *userdata, int64_t offset, pa_memchunk *chunk);
364
365 pa_usec_t pa_source_output_set_requested_latency_within_thread(pa_source_output *o, pa_usec_t usec);
366
367 /* Calls the attach() callback if it's set. The output must be in detached
368 * state. */
369 void pa_source_output_attach(pa_source_output *o);
370
371 /* Calls the detach() callback if it's set and the output is attached. The
372 * output is allowed to be already detached, in which case this does nothing.
373 *
374 * The reason why this can be called for already-detached outputs is that when
375 * a filter source's output is detached, it has to detach also all outputs
376 * connected to the filter source. In case the filter source's output was
377 * detached because the filter source is being removed, those other outputs
378 * will be moved to another source or removed, and moving and removing involve
379 * detaching the outputs, but the outputs at that point are already detached.
380 *
381 * XXX: Moving or removing an output also involves sending messages to the
382 * output's source. If the output's source is a detached filter source,
383 * shouldn't sending messages to it be prohibited? The messages are processed
384 * in the root source's IO thread, and when the filter source is detached, it
385 * would seem logical to prohibit any interaction with the IO thread that isn't
386 * any more associated with the filter source. Currently sending messages to
387 * detached filter sources mostly works, because the filter sources don't
388 * update their asyncmsgq pointer when detaching, so messages still find their
389 * way to the old IO thread. */
390 void pa_source_output_detach(pa_source_output *o);
391
392 /* Called from the main thread, from source.c only. The normal way to set the
393 * source output volume is to call pa_source_output_set_volume(), but the flat
394 * volume logic in source.c needs also a function that doesn't do all the extra
395 * stuff that pa_source_output_set_volume() does. This function simply sets
396 * o->volume and fires change notifications. */
397 void pa_source_output_set_volume_direct(pa_source_output *o, const pa_cvolume *volume);
398
399 /* Called from the main thread, from source.c only. This shouldn't be a public
400 * function, but the flat volume logic in source.c currently needs a way to
401 * directly set the source output reference ratio. This function simply sets
402 * o->reference_ratio and logs a message if the value changes. */
403 void pa_source_output_set_reference_ratio(pa_source_output *o, const pa_cvolume *ratio);
404
405 void pa_source_output_set_preferred_source(pa_source_output *o, pa_source *s);
406
407 #define pa_source_output_assert_io_context(s) \
408 pa_assert(pa_thread_mq_get() || !PA_SOURCE_OUTPUT_IS_LINKED((s)->state))
409
410 #endif
411