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 <pulsecore/memblockq.h>
  32 #include <pulsecore/resampler.h>
  33 #include <pulsecore/module.h>
  34 #include <pulsecore/client.h>
  35 #include <pulsecore/sink-input.h>
  36
  37 typedef enum pa_source_output_state {
  38     PA_SOURCE_OUTPUT_INIT,
  39     PA_SOURCE_OUTPUT_RUNNING,
  40     PA_SOURCE_OUTPUT_CORKED,
  41     PA_SOURCE_OUTPUT_UNLINKED
  42 } pa_source_output_state_t;
  43
  44 static inline pa_bool_t PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_state_t x) {
  45     return x == PA_SOURCE_OUTPUT_RUNNING || x == PA_SOURCE_OUTPUT_CORKED;
  46 }
  47
  48 typedef enum pa_source_output_flags {
  49     PA_SOURCE_OUTPUT_VARIABLE_RATE = 1,
  50     PA_SOURCE_OUTPUT_DONT_MOVE = 2,
  51     PA_SOURCE_OUTPUT_START_CORKED = 4,
  52     PA_SOURCE_OUTPUT_NO_REMAP = 8,
  53     PA_SOURCE_OUTPUT_NO_REMIX = 16,
  54     PA_SOURCE_OUTPUT_FIX_FORMAT = 32,
  55     PA_SOURCE_OUTPUT_FIX_RATE = 64,
  56     PA_SOURCE_OUTPUT_FIX_CHANNELS = 128,
  57     PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND = 256,
  58     PA_SOURCE_OUTPUT_NO_CREATE_ON_SUSPEND = 512,
  59     PA_SOURCE_OUTPUT_KILL_ON_SUSPEND = 1024
  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     /* A source output can monitor just a single input of a sink, in which case we find it here */
  80     pa_sink_input *direct_on_input;       /* may be NULL */
  81
  82     pa_sample_spec sample_spec;
  83     pa_channel_map channel_map;
  84
  85     /* if TRUE then the source we are connected to is worth
  86      * remembering, i.e. was explicitly chosen by the user and not
  87      * automatically. module-stream-restore looks for this.*/
  88     pa_bool_t save_source:1;
  89
  90     pa_resample_method_t requested_resample_method, actual_resample_method;
  91
  92     /* Pushes a new memchunk into the output. Called from IO thread
  93      * context. */
  94     void (*push)(pa_source_output *o, const pa_memchunk *chunk); /* may NOT be NULL */
  95
  96     /* Only relevant for monitor sources right now: called when the
  97      * recorded stream is rewound. Called from IO context */
  98     void (*process_rewind)(pa_source_output *o, size_t nbytes); /* may be NULL */
  99
 100     /* Called whenever the maximum rewindable size of the source
 101      * changes. Called from IO thread context. */
 102     void (*update_max_rewind) (pa_source_output *o, size_t nbytes); /* may be NULL */
 103
 104     /* Called whenever the configured latency of the source
 105      * changes. Called from IO context. */
 106     void (*update_source_requested_latency) (pa_source_output *o); /* may be NULL */
 107
 108     /* Called whenver the latency range of the source changes. Called
 109      * from IO context. */
 110     void (*update_source_latency_range) (pa_source_output *o); /* may be NULL */
 111
 112     /* If non-NULL this function is called when the output is first
 113      * connected to a source. Called from IO thread context */
 114     void (*attach) (pa_source_output *o);           /* may be NULL */
 115
 116     /* If non-NULL this function is called when the output is
 117      * disconnected from its source. Called from IO thread context */
 118     void (*detach) (pa_source_output *o);           /* may be NULL */
 119
 120     /* If non-NULL called whenever the source this output is attached
 121      * to suspends or resumes. Called from main context */
 122     void (*suspend) (pa_source_output *o, pa_bool_t b);   /* may be NULL */
 123
 124     /* If non-NULL called whenever the source this output is attached
 125      * to suspends or resumes. Called from IO context */
 126     void (*suspend_within_thread) (pa_source_output *o, pa_bool_t b);   /* may be NULL */
 127
 128     /* If non-NULL called whenever the source output is moved to a new
 129      * source. Called from main context after the stream was detached
 130      * from the old source and before it is attached to the new
 131      * source. If dest is NULL the move was executed in two
 132      * phases and the second one failed; the stream will be destroyed
 133      * after this call. */
 134     void (*moving) (pa_source_output *o, pa_source *dest);   /* may be NULL */
 135
 136     /* Supposed to unlink and destroy this stream. Called from main
 137      * context. */
 138     void (*kill)(pa_source_output* o);              /* may NOT be NULL */
 139
 140     /* Return the current latency (i.e. length of bufferd audio) of
 141     this stream. Called from main context. This is added to what the
 142     PA_SOURCE_OUTPUT_MESSAGE_GET_LATENCY message sent to the IO thread
 143     returns */
 144     pa_usec_t (*get_latency) (pa_source_output *o); /* may be NULL */
 145
 146     /* If non-NULL this function is called from thread context if the
 147      * state changes. The old state is found in thread_info.state.  */
 148     void (*state_change) (pa_source_output *o, pa_source_output_state_t state); /* may be NULL */
 149
 150     /* If non-NULL this function is called before this source output
 151      * is moved to a source and if it returns FALSE the move
 152      * will not be allowed */
 153     pa_bool_t (*may_move_to) (pa_source_output *o, pa_source *s); /* may be NULL */
 154
 155     /* If non-NULL this function is used to dispatch asynchronous
 156      * control events. */
 157     void (*send_event)(pa_source_output *o, const char *event, pa_proplist* data);
 158
 159     struct {
 160         pa_source_output_state_t state;
 161
 162         pa_bool_t attached:1; /* True only between ->attach() and ->detach() calls */
 163
 164         pa_sample_spec sample_spec;
 165
 166         pa_resampler* resampler;              /* may be NULL */
 167
 168         /* We maintain a delay memblockq here for source outputs that
 169          * don't implement rewind() */
 170         pa_memblockq *delay_memblockq;
 171
 172         /* The requested latency for the source */
 173         pa_usec_t requested_source_latency;
 174
 175         pa_sink_input *direct_on_input;       /* may be NULL */
 176     } thread_info;
 177
 178     void *userdata;
 179 };
 180
 181 PA_DECLARE_CLASS(pa_source_output);
 182 #define PA_SOURCE_OUTPUT(o) pa_source_output_cast(o)
 183
 184 enum {
 185     PA_SOURCE_OUTPUT_MESSAGE_GET_LATENCY,
 186     PA_SOURCE_OUTPUT_MESSAGE_SET_RATE,
 187     PA_SOURCE_OUTPUT_MESSAGE_SET_STATE,
 188     PA_SOURCE_OUTPUT_MESSAGE_SET_REQUESTED_LATENCY,
 189     PA_SOURCE_OUTPUT_MESSAGE_GET_REQUESTED_LATENCY,
 190     PA_SOURCE_OUTPUT_MESSAGE_MAX
 191 };
 192
 193 typedef struct pa_source_output_send_event_hook_data {
 194     pa_source_output *source_output;
 195     const char *event;
 196     pa_proplist *data;
 197 } pa_source_output_send_event_hook_data;
 198
 199 typedef struct pa_source_output_new_data {
 200     pa_proplist *proplist;
 201     pa_sink_input *direct_on_input;
 202
 203     const char *driver;
 204     pa_module *module;
 205     pa_client *client;
 206
 207     pa_source *source;
 208
 209     pa_resample_method_t resample_method;
 210
 211     pa_sample_spec sample_spec;
 212     pa_channel_map channel_map;
 213
 214     pa_bool_t sample_spec_is_set:1;
 215     pa_bool_t channel_map_is_set:1;
 216
 217     pa_bool_t save_source:1;
 218 } pa_source_output_new_data;
 219
 220 pa_source_output_new_data* pa_source_output_new_data_init(pa_source_output_new_data *data);
 221 void pa_source_output_new_data_set_sample_spec(pa_source_output_new_data *data, const pa_sample_spec *spec);
 222 void pa_source_output_new_data_set_channel_map(pa_source_output_new_data *data, const pa_channel_map *map);
 223 void pa_source_output_new_data_done(pa_source_output_new_data *data);
 224
 225 /* To be called by the implementing module only */
 226
 227 int pa_source_output_new(
 228         pa_source_output**o,
 229         pa_core *core,
 230         pa_source_output_new_data *data,
 231         pa_source_output_flags_t flags);
 232
 233 void pa_source_output_put(pa_source_output *o);
 234 void pa_source_output_unlink(pa_source_output*o);
 235
 236 void pa_source_output_set_name(pa_source_output *o, const char *name);
 237
 238 pa_usec_t pa_source_output_set_requested_latency(pa_source_output *o, pa_usec_t usec);
 239
 240 void pa_source_output_cork(pa_source_output *o, pa_bool_t b);
 241
 242 int pa_source_output_set_rate(pa_source_output *o, uint32_t rate);
 243
 244 size_t pa_source_output_get_max_rewind(pa_source_output *o);
 245
 246 /* Callable by everyone */
 247
 248 /* External code may request disconnection with this funcion */
 249 void pa_source_output_kill(pa_source_output*o);
 250
 251 pa_usec_t pa_source_output_get_latency(pa_source_output *o, pa_usec_t *source_latency);
 252
 253 void pa_source_output_update_proplist(pa_source_output *o, pa_update_mode_t mode, pa_proplist *p);
 254
 255 pa_resample_method_t pa_source_output_get_resample_method(pa_source_output *o);
 256
 257 void pa_source_output_send_event(pa_source_output *o, const char *name, pa_proplist *data);
 258
 259 pa_bool_t pa_source_output_may_move(pa_source_output *o);
 260 pa_bool_t pa_source_output_may_move_to(pa_source_output *o, pa_source *dest);
 261 int pa_source_output_move_to(pa_source_output *o, pa_source *dest, pa_bool_t save);
 262
 263 /* The same as pa_source_output_move_to() but in two seperate steps,
 264  * first the detaching from the old source, then the attaching to the
 265  * new source */
 266 int pa_source_output_start_move(pa_source_output *o);
 267 int pa_source_output_finish_move(pa_source_output *o, pa_source *dest, pa_bool_t save);
 268 void pa_source_output_fail_move(pa_source_output *o);
 269
 270 #define pa_source_output_get_state(o) ((o)->state)
 271
 272 pa_usec_t pa_source_output_get_requested_latency(pa_source_output *o);
 273
 274 /* To be used exclusively by the source driver thread */
 275
 276 void pa_source_output_push(pa_source_output *o, const pa_memchunk *chunk);
 277 void pa_source_output_process_rewind(pa_source_output *o, size_t nbytes);
 278 void pa_source_output_update_max_rewind(pa_source_output *o, size_t nbytes);
 279
 280 void pa_source_output_set_state_within_thread(pa_source_output *o, pa_source_output_state_t state);
 281
 282 int pa_source_output_process_msg(pa_msgobject *mo, int code, void *userdata, int64_t offset, pa_memchunk *chunk);
 283
 284 pa_usec_t pa_source_output_set_requested_latency_within_thread(pa_source_output *o, pa_usec_t usec);
 285
 286 #define pa_source_output_assert_io_context(s) \
 287     pa_assert(pa_thread_mq_get() || !PA_SOURCE_OUTPUT_IS_LINKED((s)->state))
 288
 289 #endif