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