code.delx.au - pulseaudio/blob - src/pulsecore/source-output.h

   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, write to the Free Software
  21   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  22   USA.
  23 ***/
  24
  25 #include <inttypes.h>
  26
  27 typedef struct pa_source_output pa_source_output;
  28
  29 #include <pulse/sample.h>
  30 #include <pulse/format.h>
  31 #include <pulsecore/memblockq.h>
  32 #include <pulsecore/resampler.h>
  33 #include <pulsecore/module.h>
  34 #include <pulsecore/client.h>
  35 #include <pulsecore/source.h>
  36 #include <pulsecore/core.h>
  37 #include <pulsecore/sink-input.h>
  38
  39 typedef enum pa_source_output_state {
  40     PA_SOURCE_OUTPUT_INIT,
  41     PA_SOURCE_OUTPUT_RUNNING,
  42     PA_SOURCE_OUTPUT_CORKED,
  43     PA_SOURCE_OUTPUT_UNLINKED
  44 } pa_source_output_state_t;
  45
  46 static inline bool PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_state_t x) {
  47     return x == PA_SOURCE_OUTPUT_RUNNING || x == PA_SOURCE_OUTPUT_CORKED;
  48 }
  49
  50 typedef enum pa_source_output_flags {
  51     PA_SOURCE_OUTPUT_VARIABLE_RATE = 1,
  52     PA_SOURCE_OUTPUT_DONT_MOVE = 2,
  53     PA_SOURCE_OUTPUT_START_CORKED = 4,
  54     PA_SOURCE_OUTPUT_NO_REMAP = 8,
  55     PA_SOURCE_OUTPUT_NO_REMIX = 16,
  56     PA_SOURCE_OUTPUT_FIX_FORMAT = 32,
  57     PA_SOURCE_OUTPUT_FIX_RATE = 64,
  58     PA_SOURCE_OUTPUT_FIX_CHANNELS = 128,
  59     PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND = 256,
  60     PA_SOURCE_OUTPUT_NO_CREATE_ON_SUSPEND = 512,
  61     PA_SOURCE_OUTPUT_KILL_ON_SUSPEND = 1024,
  62     PA_SOURCE_OUTPUT_PASSTHROUGH = 2048
  63 } pa_source_output_flags_t;
  64
  65 struct pa_source_output {
  66     pa_msgobject parent;
  67
  68     uint32_t index;
  69     pa_core *core;
  70
  71     pa_source_output_state_t state;
  72     pa_source_output_flags_t flags;
  73
  74     char *driver;                         /* may be NULL */
  75     pa_proplist *proplist;
  76
  77     pa_module *module;                    /* may be NULL */
  78     pa_client *client;                    /* may be NULL */
  79
  80     pa_source *source;                    /* NULL while being moved */
  81     pa_source *destination_source;        /* only set by filter sources */
  82
  83     /* A source output can monitor just a single input of a sink, in which case we find it here */
  84     pa_sink_input *direct_on_input;       /* may be NULL */
  85
  86     pa_sample_spec sample_spec;
  87     pa_channel_map channel_map;
  88     pa_format_info *format;
  89
  90     /* Also see http://pulseaudio.org/wiki/InternalVolumes */
  91     pa_cvolume volume;             /* The volume clients are informed about */
  92     pa_cvolume reference_ratio;    /* The ratio of the stream's volume to the source's reference volume */
  93     pa_cvolume real_ratio;         /* The ratio of the stream's volume to the source's real volume */
  94     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 */
  95     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 */
  96
  97     pa_cvolume volume_factor_source; /* A second volume factor in format of the source this stream is connected to */
  98
  99     bool volume_writable:1;
 100
 101     bool muted:1;
 102
 103     /* if true then the source we are connected to and/or the volume
 104      * set is worth remembering, i.e. was explicitly chosen by the
 105      * user and not automatically. module-stream-restore looks for
 106      * this.*/
 107     bool save_source:1, save_volume:1, save_muted:1;
 108
 109     pa_resample_method_t requested_resample_method, actual_resample_method;
 110
 111     /* Pushes a new memchunk into the output. Called from IO thread
 112      * context. */
 113     void (*push)(pa_source_output *o, const pa_memchunk *chunk); /* may NOT be NULL */
 114
 115     /* Only relevant for monitor sources right now: called when the
 116      * recorded stream is rewound. Called from IO context */
 117     void (*process_rewind)(pa_source_output *o, size_t nbytes); /* may be NULL */
 118
 119     /* Called whenever the maximum rewindable size of the source
 120      * changes. Called from IO thread context. */
 121     void (*update_max_rewind) (pa_source_output *o, size_t nbytes); /* may be NULL */
 122
 123     /* Called whenever the configured latency of the source
 124      * changes. Called from IO context. */
 125     void (*update_source_requested_latency) (pa_source_output *o); /* may be NULL */
 126
 127     /* Called whenever the latency range of the source changes. Called
 128      * from IO context. */
 129     void (*update_source_latency_range) (pa_source_output *o); /* may be NULL */
 130
 131     /* Called whenever the fixed latency of the source changes, if there
 132      * is one. Called from IO context. */
 133     void (*update_source_fixed_latency) (pa_source_output *i); /* may be NULL */
 134
 135     /* If non-NULL this function is called when the output is first
 136      * connected to a source or when the rtpoll/asyncmsgq fields
 137      * change. You usually don't need to implement this function
 138      * unless you rewrite a source that is piggy-backed onto
 139      * another. Called from IO thread context */
 140     void (*attach) (pa_source_output *o);           /* may be NULL */
 141
 142     /* If non-NULL this function is called when the output is
 143      * disconnected from its source. Called from IO thread context */
 144     void (*detach) (pa_source_output *o);           /* may be NULL */
 145
 146     /* If non-NULL called whenever the source this output is attached
 147      * to suspends or resumes. Called from main context */
 148     void (*suspend) (pa_source_output *o, bool b);   /* may be NULL */
 149
 150     /* If non-NULL called whenever the source this output is attached
 151      * to suspends or resumes. Called from IO context */
 152     void (*suspend_within_thread) (pa_source_output *o, bool b);   /* may be NULL */
 153
 154     /* If non-NULL called whenever the source output is moved to a new
 155      * source. Called from main context after the source output has been
 156      * detached from the old source and before it has been attached to
 157      * the new source. If dest is NULL the move was executed in two
 158      * phases and the second one failed; the stream will be destroyed
 159      * after this call. */
 160     void (*moving) (pa_source_output *o, pa_source *dest);   /* may be NULL */
 161
 162     /* Supposed to unlink and destroy this stream. Called from main
 163      * context. */
 164     void (*kill)(pa_source_output* o);              /* may NOT be NULL */
 165
 166     /* Return the current latency (i.e. length of buffered audio) of
 167     this stream. Called from main context. This is added to what the
 168     PA_SOURCE_OUTPUT_MESSAGE_GET_LATENCY message sent to the IO thread
 169     returns */
 170     pa_usec_t (*get_latency) (pa_source_output *o); /* may be NULL */
 171
 172     /* If non-NULL this function is called from thread context if the
 173      * state changes. The old state is found in thread_info.state.  */
 174     void (*state_change) (pa_source_output *o, pa_source_output_state_t state); /* may be NULL */
 175
 176     /* If non-NULL this function is called before this source output
 177      * is moved to a source and if it returns false the move
 178      * will not be allowed */
 179     bool (*may_move_to) (pa_source_output *o, pa_source *s); /* may be NULL */
 180
 181     /* If non-NULL this function is used to dispatch asynchronous
 182      * control events. */
 183     void (*send_event)(pa_source_output *o, const char *event, pa_proplist* data);
 184
 185     /* If non-NULL this function is called whenever the source output
 186      * volume changes. Called from main context */
 187     void (*volume_changed)(pa_source_output *o); /* may be NULL */
 188
 189     /* If non-NULL this function is called whenever the source output
 190      * mute status changes. Called from main context */
 191     void (*mute_changed)(pa_source_output *o); /* may be NULL */
 192
 193     struct {
 194         pa_source_output_state_t state;
 195
 196         pa_cvolume soft_volume;
 197         bool muted:1;
 198
 199         bool attached:1; /* True only between ->attach() and ->detach() calls */
 200
 201         pa_sample_spec sample_spec;
 202
 203         pa_resampler* resampler;              /* may be NULL */
 204
 205         /* We maintain a delay memblockq here for source outputs that
 206          * don't implement rewind() */
 207         pa_memblockq *delay_memblockq;
 208
 209         /* The requested latency for the source */
 210         pa_usec_t requested_source_latency;
 211
 212         pa_sink_input *direct_on_input;       /* may be NULL */
 213     } thread_info;
 214
 215     void *userdata;
 216 };
 217
 218 PA_DECLARE_PUBLIC_CLASS(pa_source_output);
 219 #define PA_SOURCE_OUTPUT(o) pa_source_output_cast(o)
 220
 221 enum {
 222     PA_SOURCE_OUTPUT_MESSAGE_GET_LATENCY,
 223     PA_SOURCE_OUTPUT_MESSAGE_SET_RATE,
 224     PA_SOURCE_OUTPUT_MESSAGE_SET_STATE,
 225     PA_SOURCE_OUTPUT_MESSAGE_SET_REQUESTED_LATENCY,
 226     PA_SOURCE_OUTPUT_MESSAGE_GET_REQUESTED_LATENCY,
 227     PA_SOURCE_OUTPUT_MESSAGE_SET_SOFT_VOLUME,
 228     PA_SOURCE_OUTPUT_MESSAGE_SET_SOFT_MUTE,
 229     PA_SOURCE_OUTPUT_MESSAGE_MAX
 230 };
 231
 232 typedef struct pa_source_output_send_event_hook_data {
 233     pa_source_output *source_output;
 234     const char *event;
 235     pa_proplist *data;
 236 } pa_source_output_send_event_hook_data;
 237
 238 typedef struct pa_source_output_new_data {
 239     pa_source_output_flags_t flags;
 240
 241     pa_proplist *proplist;
 242     pa_sink_input *direct_on_input;
 243
 244     const char *driver;
 245     pa_module *module;
 246     pa_client *client;
 247
 248     pa_source *source;
 249     pa_source *destination_source;
 250
 251     pa_resample_method_t resample_method;
 252
 253     pa_sample_spec sample_spec;
 254     pa_channel_map channel_map;
 255     pa_format_info *format;
 256     pa_idxset *req_formats;
 257     pa_idxset *nego_formats;
 258
 259     pa_cvolume volume, volume_factor, volume_factor_source;
 260     bool muted:1;
 261
 262     bool sample_spec_is_set:1;
 263     bool channel_map_is_set:1;
 264
 265     bool volume_is_set:1, volume_factor_is_set:1, volume_factor_source_is_set:1;
 266     bool muted_is_set:1;
 267
 268     bool volume_is_absolute:1;
 269
 270     bool volume_writable:1;
 271
 272     bool save_source:1, save_volume:1, save_muted:1;
 273 } pa_source_output_new_data;
 274
 275 pa_source_output_new_data* pa_source_output_new_data_init(pa_source_output_new_data *data);
 276 void pa_source_output_new_data_set_sample_spec(pa_source_output_new_data *data, const pa_sample_spec *spec);
 277 void pa_source_output_new_data_set_channel_map(pa_source_output_new_data *data, const pa_channel_map *map);
 278 bool pa_source_output_new_data_is_passthrough(pa_source_output_new_data *data);
 279 void pa_source_output_new_data_set_volume(pa_source_output_new_data *data, const pa_cvolume *volume);
 280 void pa_source_output_new_data_apply_volume_factor(pa_source_output_new_data *data, const pa_cvolume *volume_factor);
 281 void pa_source_output_new_data_apply_volume_factor_source(pa_source_output_new_data *data, const pa_cvolume *volume_factor);
 282 void pa_source_output_new_data_set_muted(pa_source_output_new_data *data, bool mute);
 283 bool pa_source_output_new_data_set_source(pa_source_output_new_data *data, pa_source *s, bool save);
 284 bool pa_source_output_new_data_set_formats(pa_source_output_new_data *data, pa_idxset *formats);
 285 void pa_source_output_new_data_done(pa_source_output_new_data *data);
 286
 287 /* To be called by the implementing module only */
 288
 289 int pa_source_output_new(
 290         pa_source_output**o,
 291         pa_core *core,
 292         pa_source_output_new_data *data);
 293
 294 void pa_source_output_put(pa_source_output *o);
 295 void pa_source_output_unlink(pa_source_output*o);
 296
 297 void pa_source_output_set_name(pa_source_output *o, const char *name);
 298
 299 pa_usec_t pa_source_output_set_requested_latency(pa_source_output *o, pa_usec_t usec);
 300
 301 void pa_source_output_cork(pa_source_output *o, bool b);
 302
 303 int pa_source_output_set_rate(pa_source_output *o, uint32_t rate);
 304 int pa_source_output_update_rate(pa_source_output *o);
 305
 306 size_t pa_source_output_get_max_rewind(pa_source_output *o);
 307
 308 /* Callable by everyone */
 309
 310 /* External code may request disconnection with this function */
 311 void pa_source_output_kill(pa_source_output*o);
 312
 313 pa_usec_t pa_source_output_get_latency(pa_source_output *o, pa_usec_t *source_latency);
 314
 315 bool pa_source_output_is_volume_readable(pa_source_output *o);
 316 bool pa_source_output_is_passthrough(pa_source_output *o);
 317 void pa_source_output_set_volume(pa_source_output *o, const pa_cvolume *volume, bool save, bool absolute);
 318 pa_cvolume *pa_source_output_get_volume(pa_source_output *o, pa_cvolume *volume, bool absolute);
 319
 320 void pa_source_output_set_mute(pa_source_output *o, bool mute, bool save);
 321 bool pa_source_output_get_mute(pa_source_output *o);
 322
 323 void pa_source_output_update_proplist(pa_source_output *o, pa_update_mode_t mode, pa_proplist *p);
 324
 325 pa_resample_method_t pa_source_output_get_resample_method(pa_source_output *o);
 326
 327 void pa_source_output_send_event(pa_source_output *o, const char *name, pa_proplist *data);
 328
 329 bool pa_source_output_may_move(pa_source_output *o);
 330 bool pa_source_output_may_move_to(pa_source_output *o, pa_source *dest);
 331 int pa_source_output_move_to(pa_source_output *o, pa_source *dest, bool save);
 332
 333 /* The same as pa_source_output_move_to() but in two separate steps,
 334  * first the detaching from the old source, then the attaching to the
 335  * new source */
 336 int pa_source_output_start_move(pa_source_output *o);
 337 int pa_source_output_finish_move(pa_source_output *o, pa_source *dest, bool save);
 338 void pa_source_output_fail_move(pa_source_output *o);
 339
 340 #define pa_source_output_get_state(o) ((o)->state)
 341
 342 pa_usec_t pa_source_output_get_requested_latency(pa_source_output *o);
 343
 344 /* To be used exclusively by the source driver thread */
 345
 346 void pa_source_output_push(pa_source_output *o, const pa_memchunk *chunk);
 347 void pa_source_output_process_rewind(pa_source_output *o, size_t nbytes);
 348 void pa_source_output_update_max_rewind(pa_source_output *o, size_t nbytes);
 349
 350 void pa_source_output_set_state_within_thread(pa_source_output *o, pa_source_output_state_t state);
 351
 352 int pa_source_output_process_msg(pa_msgobject *mo, int code, void *userdata, int64_t offset, pa_memchunk *chunk);
 353
 354 pa_usec_t pa_source_output_set_requested_latency_within_thread(pa_source_output *o, pa_usec_t usec);
 355
 356 /* Called from the main thread, from source.c only. The normal way to set the
 357  * source output volume is to call pa_source_output_set_volume(), but the flat
 358  * volume logic in source.c needs also a function that doesn't do all the extra
 359  * stuff that pa_source_output_set_volume() does. This function simply sets
 360  * o->volume and fires change notifications. */
 361 void pa_source_output_set_volume_direct(pa_source_output *o, const pa_cvolume *volume);
 362
 363 #define pa_source_output_assert_io_context(s) \
 364     pa_assert(pa_thread_mq_get() || !PA_SOURCE_OUTPUT_IS_LINKED((s)->state))
 365
 366 #endif