← Back to branch summary

~diwic/ubuntu/lucid/pulseaudio/bugfixes

« back to all changes in this revision

Viewing changes to src/pulsecore/sink.h

  • Committer: Bazaar Package Importer
  • Author(s): Luke Yelavich
  • Date: 2009-05-05 14:18:20 UTC
  • mfrom: (1.2.4 upstream) (1.1.8 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090505141820-rrr2mtdd1jkllvr8
Tags: 1:0.9.15-1ubuntu1
* Merge from unreleased Debian pulseaudio git, remaining changes:
  - epoch (my stupid fault :S)
  - Don't build against, and create jack package. Jack is not in main
  - use linear resampler to work better with lack of PREEMPT in jaunty's
    -generic kernel config, also change buffer size
  - Add alsa configuration files to route alsa applications via pulseaudio
  - Move libasound2-plugins from Recommends to Depends
  - Add pm-utils sleep hook to suspend (and resume) users' pulseaudio
    daemons
  - patch to fix source/sink and suspend-on-idle race
  - Make initscript more informative in the default case of per-user
    sessions
  - create /var/run/pulse, and make restart more robust
  - add status check for system wide pulseaudio instance
  - LSB {Required-*,Should-*} should specify hal instead of dbus,
    since hal is required (and already requires dbus)
  - indicate that the system pulseaudio instance is being started from the init
    script
  - Install more upstream man pages
  - Link to pacat for parec man page
  - check whether pulseaudio is running before preloading the padsp library
  - Add DEB_OPT_FLAG = -O3 as per recommendation from
    pulseaudio-discuss/2007-December/001017.html
  - cache /usr/share/sounds/ubuntu/stereo/ wav files on pulseaudio load
  - disable glitch free (use tsched=0)
  - Generate a PO template on build
  - add special case to disable pulseaudio loading if accessibility/speech
    is being used
  - the sd wrapper script should not load pulseaudio if pulseaudio is being
    used as a system service
  - add a pulseaudio apport hook
  - fix some typos in README.Debian
  - demote paprefs to suggests
  - drop padevchooser(Recommends) and pavucontrol (Suggests)
  - drop libasyncns-dev build dependency, its in universe
* add libudev-dev as a build-dependency

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pulsecore/sink.h
9
9
 
10
10
  PulseAudio is free software; you can redistribute it and/or modify
11
11
  it under the terms of the GNU Lesser General Public License as published
12
 
  by the Free Software Foundation; either version 2 of the License,
 
12
  by the Free Software Foundation; either version 2.1 of the License,
13
13
  or (at your option) any later version.
14
14
 
15
15
  PulseAudio is distributed in the hope that it will be useful, but
27
27
 
28
28
#include <inttypes.h>
29
29
 
 
30
#include <pulse/def.h>
30
31
#include <pulse/sample.h>
31
32
#include <pulse/channelmap.h>
32
33
#include <pulse/volume.h>
38
39
#include <pulsecore/refcnt.h>
39
40
#include <pulsecore/msgobject.h>
40
41
#include <pulsecore/rtpoll.h>
 
42
#include <pulsecore/card.h>
 
43
#include <pulsecore/queue.h>
41
44
 
42
45
#define PA_MAX_INPUTS_PER_SINK 32
43
46
 
44
 
typedef enum pa_sink_state {
45
 
    PA_SINK_INIT,
46
 
    PA_SINK_RUNNING,
47
 
    PA_SINK_SUSPENDED,
48
 
    PA_SINK_IDLE,
49
 
    PA_SINK_UNLINKED
50
 
} pa_sink_state_t;
51
 
 
52
 
static inline pa_bool_t PA_SINK_IS_OPENED(pa_sink_state_t x) {
53
 
    return x == PA_SINK_RUNNING || x == PA_SINK_IDLE;
54
 
}
55
 
 
 
47
/* Returns true if sink is linked: registered and accessible from client side. */
56
48
static inline pa_bool_t PA_SINK_IS_LINKED(pa_sink_state_t x) {
57
49
    return x == PA_SINK_RUNNING || x == PA_SINK_IDLE || x == PA_SINK_SUSPENDED;
58
50
}
70
62
    pa_proplist *proplist;
71
63
 
72
64
    pa_module *module;                      /* may be NULL */
 
65
    pa_card *card;                          /* may be NULL */
73
66
 
74
67
    pa_sample_spec sample_spec;
75
68
    pa_channel_map channel_map;
78
71
    unsigned n_corked;
79
72
    pa_source *monitor_source;
80
73
 
81
 
    pa_cvolume volume;
82
 
    pa_bool_t muted;
 
74
    pa_volume_t base_volume; /* shall be constant */
 
75
    unsigned n_volume_steps; /* shall be constant */
 
76
 
 
77
    /* Also see http://pulseaudio.org/wiki/InternalVolumes */
 
78
    pa_cvolume virtual_volume;   /* The volume clients are informed about */
 
79
    pa_cvolume reference_volume; /* The volume taken as refernce base for relative sink input volumes */
 
80
    pa_cvolume soft_volume;      /* The internal software volume we apply to all PCM data while it passes through */
 
81
    pa_bool_t muted:1;
83
82
 
84
83
    pa_bool_t refresh_volume:1;
85
84
    pa_bool_t refresh_muted:1;
89
88
 
90
89
    pa_memchunk silence;
91
90
 
 
91
    pa_usec_t fixed_latency; /* for sinks with PA_SINK_DYNAMIC_LATENCY this is 0 */
 
92
 
92
93
    /* Called when the main loop requests a state change. Called from
93
94
     * main loop context. If returns -1 the state change will be
94
95
     * inhibited */
98
99
     * context. If this is NULL a PA_SINK_MESSAGE_GET_VOLUME message
99
100
     * will be sent to the IO thread instead. If refresh_volume is
100
101
     * FALSE neither this function is called nor a message is sent. */
101
 
    int (*get_volume)(pa_sink *s);             /* may be NULL */
 
102
    void (*get_volume)(pa_sink *s);             /* may be NULL */
102
103
 
103
104
    /* Called when the volume shall be changed. Called from main loop
104
105
     * context. If this is NULL a PA_SINK_MESSAGE_SET_VOLUME message
105
106
     * will be sent to the IO thread instead. */
106
 
    int (*set_volume)(pa_sink *s);             /* dito */
 
107
    void (*set_volume)(pa_sink *s);             /* dito */
107
108
 
108
109
    /* Called when the mute setting is queried. Called from main loop
109
110
     * context. If this is NULL a PA_SINK_MESSAGE_GET_MUTE message
110
111
     * will be sent to the IO thread instead. If refresh_mute is
111
112
     * FALSE neither this function is called nor a message is sent.*/
112
 
    int (*get_mute)(pa_sink *s);               /* dito */
 
113
    void (*get_mute)(pa_sink *s);               /* dito */
113
114
 
114
115
    /* Called when the mute setting shall be changed. Called from main
115
116
     * loop context. If this is NULL a PA_SINK_MESSAGE_SET_MUTE
116
117
     * message will be sent to the IO thread instead. */
117
 
    int (*set_mute)(pa_sink *s);               /* dito */
 
118
    void (*set_mute)(pa_sink *s);               /* dito */
118
119
 
119
120
    /* Called when a rewind request is issued. Called from IO thread
120
121
     * context. */
129
130
    struct {
130
131
        pa_sink_state_t state;
131
132
        pa_hashmap *inputs;
 
133
 
132
134
        pa_cvolume soft_volume;
133
135
        pa_bool_t soft_muted:1;
134
136
 
162
164
    PA_SINK_MESSAGE_REMOVE_INPUT,
163
165
    PA_SINK_MESSAGE_GET_VOLUME,
164
166
    PA_SINK_MESSAGE_SET_VOLUME,
 
167
    PA_SINK_MESSAGE_SYNC_VOLUMES,
165
168
    PA_SINK_MESSAGE_GET_MUTE,
166
169
    PA_SINK_MESSAGE_SET_MUTE,
167
170
    PA_SINK_MESSAGE_GET_LATENCY,
175
178
    PA_SINK_MESSAGE_GET_LATENCY_RANGE,
176
179
    PA_SINK_MESSAGE_GET_MAX_REWIND,
177
180
    PA_SINK_MESSAGE_GET_MAX_REQUEST,
 
181
    PA_SINK_MESSAGE_SET_MAX_REWIND,
 
182
    PA_SINK_MESSAGE_SET_MAX_REQUEST,
178
183
    PA_SINK_MESSAGE_MAX
179
184
} pa_sink_message_t;
180
185
 
184
189
 
185
190
    const char *driver;
186
191
    pa_module *module;
 
192
    pa_card *card;
187
193
 
188
194
    pa_sample_spec sample_spec;
189
195
    pa_channel_map channel_map;
206
212
void pa_sink_new_data_set_muted(pa_sink_new_data *data, pa_bool_t mute);
207
213
void pa_sink_new_data_done(pa_sink_new_data *data);
208
214
 
209
 
/* To be called exclusively by the sink driver, from main context */
 
215
/*** To be called exclusively by the sink driver, from main context */
210
216
 
211
217
pa_sink* pa_sink_new(
212
218
        pa_core *core,
220
226
void pa_sink_set_asyncmsgq(pa_sink *s, pa_asyncmsgq *q);
221
227
void pa_sink_set_rtpoll(pa_sink *s, pa_rtpoll *p);
222
228
 
 
229
void pa_sink_set_max_rewind(pa_sink *s, size_t max_rewind);
 
230
void pa_sink_set_max_request(pa_sink *s, size_t max_request);
223
231
void pa_sink_set_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency);
224
232
 
225
233
void pa_sink_detach(pa_sink *s);
226
234
void pa_sink_attach(pa_sink *s);
227
235
 
228
 
/* May be called by everyone, from main context */
 
236
void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume);
 
237
void pa_sink_volume_changed(pa_sink *s, const pa_cvolume *new_volume);
 
238
void pa_sink_mute_changed(pa_sink *s, pa_bool_t new_muted);
 
239
 
 
240
pa_bool_t pa_device_init_description(pa_proplist *p);
 
241
pa_bool_t pa_device_init_icon(pa_proplist *p, pa_bool_t is_sink);
 
242
 
 
243
/**** May be called by everyone, from main context */
229
244
 
230
245
/* The returned value is supposed to be in the time domain of the sound card! */
231
246
pa_usec_t pa_sink_get_latency(pa_sink *s);
239
254
int pa_sink_suspend(pa_sink *s, pa_bool_t suspend);
240
255
int pa_sink_suspend_all(pa_core *c, pa_bool_t suspend);
241
256
 
242
 
void pa_sink_set_volume(pa_sink *sink, const pa_cvolume *volume);
243
 
void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume);
244
 
const pa_cvolume *pa_sink_get_volume(pa_sink *sink, pa_bool_t force_refresh);
 
257
void pa_sink_update_flat_volume(pa_sink *s, pa_cvolume *new_volume);
 
258
void pa_sink_propagate_flat_volume(pa_sink *s);
 
259
 
 
260
void pa_sink_set_volume(pa_sink *sink, const pa_cvolume *volume, pa_bool_t propagate, pa_bool_t sendmsg, pa_bool_t become_reference);
 
261
const pa_cvolume *pa_sink_get_volume(pa_sink *sink, pa_bool_t force_refresh, pa_bool_t reference);
 
262
 
245
263
void pa_sink_set_mute(pa_sink *sink, pa_bool_t mute);
246
 
pa_bool_t pa_sink_get_mute(pa_sink *sink, pa_bool_t force_refres);
 
264
pa_bool_t pa_sink_get_mute(pa_sink *sink, pa_bool_t force_refresh);
 
265
 
 
266
pa_bool_t pa_sink_update_proplist(pa_sink *s, pa_update_mode_t mode, pa_proplist *p);
247
267
 
248
268
unsigned pa_sink_linked_by(pa_sink *s); /* Number of connected streams */
249
269
unsigned pa_sink_used_by(pa_sink *s); /* Number of connected streams which are not corked */
 
270
unsigned pa_sink_check_suspend(pa_sink *s); /* Returns how many streams are active that don't allow suspensions */
250
271
#define pa_sink_get_state(s) ((s)->state)
251
272
 
252
 
/* To be called exclusively by the sink driver, from IO context */
 
273
/* Moves all inputs away, and stores them in pa_queue */
 
274
pa_queue *pa_sink_move_all_start(pa_sink *s);
 
275
void pa_sink_move_all_finish(pa_sink *s, pa_queue *q, pa_bool_t save);
 
276
void pa_sink_move_all_fail(pa_queue *q);
 
277
 
 
278
/*** To be called exclusively by the sink driver, from IO context */
253
279
 
254
280
void pa_sink_render(pa_sink*s, size_t length, pa_memchunk *result);
255
281
void pa_sink_render_full(pa_sink *s, size_t length, pa_memchunk *result);
265
291
 
266
292
pa_usec_t pa_sink_get_requested_latency_within_thread(pa_sink *s);
267
293
 
268
 
void pa_sink_set_max_rewind(pa_sink *s, size_t max_rewind);
269
 
void pa_sink_set_max_request(pa_sink *s, size_t max_request);
270
 
 
271
 
void pa_sink_update_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency);
272
 
 
273
 
/* To be called exclusively by sink input drivers, from IO context */
 
294
void pa_sink_set_max_rewind_within_thread(pa_sink *s, size_t max_rewind);
 
295
void pa_sink_set_max_request_within_thread(pa_sink *s, size_t max_request);
 
296
 
 
297
void pa_sink_set_latency_range_within_thread(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency);
 
298
 
 
299
/*** To be called exclusively by sink input drivers, from IO context */
274
300
 
275
301
void pa_sink_request_rewind(pa_sink*s, size_t nbytes);
276
302
 
277
303
void pa_sink_invalidate_requested_latency(pa_sink *s);
278
304
 
 
305
pa_usec_t pa_sink_get_latency_within_thread(pa_sink *s);
 
306
 
279
307
#endif