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