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