code.delx.au - pulseaudio/blob - src/pulse/internal.h

   1 #ifndef foointernalhfoo
   2 #define foointernalhfoo
   3
   4 /***
   5   This file is part of PulseAudio.
   6
   7   Copyright 2004-2006 Lennart Poettering
   8   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   9
  10   PulseAudio is free software; you can redistribute it and/or modify
  11   it under the terms of the GNU Lesser General Public License as published
  12   by the Free Software Foundation; either version 2.1 of the License,
  13   or (at your option) any later version.
  14
  15   PulseAudio is distributed in the hope that it will be useful, but
  16   WITHOUT ANY WARRANTY; without even the implied warranty of
  17   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18   General Public License for more details.
  19
  20   You should have received a copy of the GNU Lesser General Public License
  21   along with PulseAudio; if not, write to the Free Software
  22   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  23   USA.
  24 ***/
  25
  26 #include <pulse/mainloop-api.h>
  27 #include <pulse/context.h>
  28 #include <pulse/stream.h>
  29 #include <pulse/operation.h>
  30 #include <pulse/subscribe.h>
  31 #include <pulse/ext-device-manager.h>
  32 #include <pulse/ext-stream-restore.h>
  33
  34 #include <pulsecore/socket-client.h>
  35 #include <pulsecore/pstream.h>
  36 #include <pulsecore/pdispatch.h>
  37 #include <pulsecore/llist.h>
  38 #include <pulsecore/native-common.h>
  39 #include <pulsecore/strlist.h>
  40 #include <pulsecore/mcalign.h>
  41 #include <pulsecore/memblockq.h>
  42 #include <pulsecore/hashmap.h>
  43 #include <pulsecore/refcnt.h>
  44 #include <pulsecore/time-smoother.h>
  45 #ifdef HAVE_DBUS
  46 #include <pulsecore/dbus-util.h>
  47 #endif
  48
  49 #include "client-conf.h"
  50
  51 #define DEFAULT_TIMEOUT (30)
  52
  53 struct pa_context {
  54     PA_REFCNT_DECLARE;
  55
  56 #ifdef HAVE_DBUS
  57     pa_dbus_wrap_connection *system_bus;
  58     pa_dbus_wrap_connection *session_bus;
  59 #endif
  60
  61     pa_proplist *proplist;
  62     pa_mainloop_api* mainloop;
  63
  64     pa_socket_client *client;
  65     pa_pstream *pstream;
  66     pa_pdispatch *pdispatch;
  67
  68     pa_hashmap *record_streams, *playback_streams;
  69     PA_LLIST_HEAD(pa_stream, streams);
  70     PA_LLIST_HEAD(pa_operation, operations);
  71
  72     uint32_t version;
  73     uint32_t ctag;
  74     uint32_t csyncid;
  75     int error;
  76     pa_context_state_t state;
  77
  78     pa_context_notify_cb_t state_callback;
  79     void *state_userdata;
  80     pa_context_subscribe_cb_t subscribe_callback;
  81     void *subscribe_userdata;
  82     pa_context_event_cb_t event_callback;
  83     void *event_userdata;
  84
  85     pa_mempool *mempool;
  86
  87     pa_bool_t is_local:1;
  88     pa_bool_t do_shm:1;
  89     pa_bool_t server_specified:1;
  90     pa_bool_t no_fail:1;
  91     pa_bool_t do_autospawn:1;
  92     pa_bool_t use_rtclock:1;
  93     pa_bool_t filter_added:1;
  94     pa_spawn_api spawn_api;
  95
  96     pa_strlist *server_list;
  97
  98     char *server;
  99
 100     pa_client_conf *conf;
 101
 102     uint32_t client_index;
 103
 104     /* Extension specific data */
 105     struct {
 106         pa_ext_device_manager_subscribe_cb_t callback;
 107         void *userdata;
 108     } ext_device_manager;
 109     struct {
 110         pa_ext_stream_restore_subscribe_cb_t callback;
 111         void *userdata;
 112     } ext_stream_restore;
 113 };
 114
 115 #define PA_MAX_WRITE_INDEX_CORRECTIONS 32
 116
 117 typedef struct pa_index_correction {
 118     uint32_t tag;
 119     int64_t value;
 120     pa_bool_t valid:1;
 121     pa_bool_t absolute:1;
 122     pa_bool_t corrupt:1;
 123 } pa_index_correction;
 124
 125 #define PA_MAX_FORMATS (PA_ENCODING_MAX)
 126
 127 struct pa_stream {
 128     PA_REFCNT_DECLARE;
 129     PA_LLIST_FIELDS(pa_stream);
 130
 131     pa_context *context;
 132     pa_mainloop_api *mainloop;
 133
 134     uint32_t direct_on_input;
 135
 136     pa_stream_direction_t direction;
 137     pa_stream_state_t state;
 138     pa_stream_flags_t flags;
 139
 140     pa_sample_spec sample_spec;
 141     pa_channel_map channel_map;
 142     uint8_t n_formats;
 143     pa_format_info *req_formats[PA_MAX_FORMATS];
 144     pa_format_info *format;
 145
 146     pa_proplist *proplist;
 147
 148     pa_bool_t channel_valid:1;
 149     pa_bool_t suspended:1;
 150     pa_bool_t corked:1;
 151     pa_bool_t timing_info_valid:1;
 152     pa_bool_t auto_timing_update_requested:1;
 153
 154     uint32_t channel;
 155     uint32_t syncid;
 156     uint32_t stream_index;
 157
 158     int64_t requested_bytes;
 159     pa_buffer_attr buffer_attr;
 160
 161     uint32_t device_index;
 162     char *device_name;
 163
 164     /* playback */
 165     pa_memblock *write_memblock;
 166     void *write_data;
 167
 168     /* recording */
 169     pa_memchunk peek_memchunk;
 170     void *peek_data;
 171     pa_memblockq *record_memblockq;
 172
 173     /* Store latest latency info */
 174     pa_timing_info timing_info;
 175
 176     /* Use to make sure that time advances monotonically */
 177     pa_usec_t previous_time;
 178
 179     /* time updates with tags older than these are invalid */
 180     uint32_t write_index_not_before;
 181     uint32_t read_index_not_before;
 182
 183     /* Data about individual timing update corrections */
 184     pa_index_correction write_index_corrections[PA_MAX_WRITE_INDEX_CORRECTIONS];
 185     int current_write_index_correction;
 186
 187     /* Latency interpolation stuff */
 188     pa_time_event *auto_timing_update_event;
 189     pa_usec_t auto_timing_interval_usec;
 190
 191     pa_smoother *smoother;
 192
 193     /* Callbacks */
 194     pa_stream_notify_cb_t state_callback;
 195     void *state_userdata;
 196     pa_stream_request_cb_t read_callback;
 197     void *read_userdata;
 198     pa_stream_request_cb_t write_callback;
 199     void *write_userdata;
 200     pa_stream_notify_cb_t overflow_callback;
 201     void *overflow_userdata;
 202     pa_stream_notify_cb_t underflow_callback;
 203     void *underflow_userdata;
 204     pa_stream_notify_cb_t latency_update_callback;
 205     void *latency_update_userdata;
 206     pa_stream_notify_cb_t moved_callback;
 207     void *moved_userdata;
 208     pa_stream_notify_cb_t suspended_callback;
 209     void *suspended_userdata;
 210     pa_stream_notify_cb_t started_callback;
 211     void *started_userdata;
 212     pa_stream_event_cb_t event_callback;
 213     void *event_userdata;
 214     pa_stream_notify_cb_t buffer_attr_callback;
 215     void *buffer_attr_userdata;
 216 };
 217
 218 typedef void (*pa_operation_cb_t)(void);
 219
 220 struct pa_operation {
 221     PA_REFCNT_DECLARE;
 222
 223     pa_context *context;
 224     pa_stream *stream;
 225
 226     PA_LLIST_FIELDS(pa_operation);
 227
 228     pa_operation_state_t state;
 229     void *userdata;
 230     pa_operation_cb_t callback;
 231
 232     void *private; /* some operations might need this */
 233 };
 234
 235 void pa_command_request(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 236 void pa_command_stream_killed(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 237 void pa_command_subscribe_event(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 238 void pa_command_overflow_or_underflow(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 239 void pa_command_stream_suspended(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 240 void pa_command_stream_moved(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 241 void pa_command_stream_started(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 242 void pa_command_stream_event(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 243 void pa_command_client_event(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 244 void pa_command_stream_buffer_attr(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 245
 246 pa_operation *pa_operation_new(pa_context *c, pa_stream *s, pa_operation_cb_t callback, void *userdata);
 247 void pa_operation_done(pa_operation *o);
 248
 249 void pa_create_stream_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 250 void pa_stream_disconnect_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 251 void pa_context_simple_ack_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 252 void pa_stream_simple_ack_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 253
 254 void pa_context_fail(pa_context *c, int error);
 255 int pa_context_set_error(pa_context *c, int error);
 256 void pa_context_set_state(pa_context *c, pa_context_state_t st);
 257 int pa_context_handle_error(pa_context *c, uint32_t command, pa_tagstruct *t, pa_bool_t fail);
 258 pa_operation* pa_context_send_simple_command(pa_context *c, uint32_t command, void (*internal_callback)(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata), void (*cb)(void), void *userdata);
 259
 260 void pa_stream_set_state(pa_stream *s, pa_stream_state_t st);
 261
 262 pa_tagstruct *pa_tagstruct_command(pa_context *c, uint32_t command, uint32_t *tag);
 263
 264 #define PA_CHECK_VALIDITY(context, expression, error)         \
 265     do {                                                      \
 266         if (!(expression))                                    \
 267             return -pa_context_set_error((context), (error)); \
 268     } while(FALSE)
 269
 270
 271 #define PA_CHECK_VALIDITY_RETURN_ANY(context, expression, error, value) \
 272     do {                                                                \
 273         if (!(expression)) {                                            \
 274             pa_context_set_error((context), (error));                   \
 275             return value;                                               \
 276         }                                                               \
 277     } while(FALSE)
 278
 279 #define PA_CHECK_VALIDITY_RETURN_NULL(context, expression, error)       \
 280     PA_CHECK_VALIDITY_RETURN_ANY(context, expression, error, NULL)
 281
 282 #define PA_FAIL(context, error)                                 \
 283     do {                                                        \
 284         return -pa_context_set_error((context), (error));       \
 285     } while(FALSE)
 286
 287 #define PA_FAIL_RETURN_ANY(context, error, value)      \
 288     do {                                               \
 289         pa_context_set_error((context), (error));      \
 290         return value;                                  \
 291     } while(FALSE)
 292
 293 #define PA_FAIL_RETURN_NULL(context, error)     \
 294     PA_FAIL_RETURN_ANY(context, error, NULL)
 295
 296 void pa_ext_device_manager_command(pa_context *c, uint32_t tag, pa_tagstruct *t);
 297 void pa_ext_stream_restore_command(pa_context *c, uint32_t tag, pa_tagstruct *t);
 298
 299 pa_bool_t pa_format_info_is_compatible(pa_format_info *first, pa_format_info *second);
 300 pa_format_info* pa_format_info_from_sample_spec(pa_sample_spec *ss, pa_channel_map *map);
 301 void pa_format_info_to_sample_spec(pa_format_info *f, pa_sample_spec *ss, pa_channel_map *map);
 302 void pa_format_info_to_sample_spec_fake(pa_format_info *f, pa_sample_spec *ss);
 303
 304 pa_bool_t pa_mainloop_is_our_api(pa_mainloop_api*m);
 305
 306 #endif