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