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