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_spawn_api spawn_api;
  94
  95     pa_strlist *server_list;
  96
  97     char *server;
  98
  99     pa_client_conf *conf;
 100
 101     uint32_t client_index;
 102
 103     /* Extension specific data */
 104     struct {
 105         pa_ext_device_manager_subscribe_cb_t callback;
 106         void *userdata;
 107     } ext_device_manager;
 108     struct {
 109         pa_ext_stream_restore_subscribe_cb_t callback;
 110         void *userdata;
 111     } ext_stream_restore;
 112 };
 113
 114 #define PA_MAX_WRITE_INDEX_CORRECTIONS 32
 115
 116 typedef struct pa_index_correction {
 117     uint32_t tag;
 118     int64_t value;
 119     pa_bool_t valid:1;
 120     pa_bool_t absolute:1;
 121     pa_bool_t corrupt:1;
 122 } pa_index_correction;
 123
 124 struct pa_stream {
 125     PA_REFCNT_DECLARE;
 126     PA_LLIST_FIELDS(pa_stream);
 127
 128     pa_context *context;
 129     pa_mainloop_api *mainloop;
 130
 131     uint32_t direct_on_input;
 132
 133     pa_stream_direction_t direction;
 134     pa_stream_state_t state;
 135     pa_stream_flags_t flags;
 136
 137     pa_sample_spec sample_spec;
 138     pa_channel_map channel_map;
 139
 140     pa_proplist *proplist;
 141
 142     pa_bool_t channel_valid:1;
 143     pa_bool_t suspended:1;
 144     pa_bool_t corked:1;
 145     pa_bool_t timing_info_valid:1;
 146     pa_bool_t auto_timing_update_requested:1;
 147
 148     uint32_t channel;
 149     uint32_t syncid;
 150     uint32_t stream_index;
 151
 152     int64_t requested_bytes;
 153     pa_buffer_attr buffer_attr;
 154
 155     uint32_t device_index;
 156     char *device_name;
 157
 158     /* playback */
 159     pa_memblock *write_memblock;
 160     void *write_data;
 161
 162     /* recording */
 163     pa_memchunk peek_memchunk;
 164     void *peek_data;
 165     pa_memblockq *record_memblockq;
 166
 167     /* Store latest latency info */
 168     pa_timing_info timing_info;
 169
 170     /* Use to make sure that time advances monotonically */
 171     pa_usec_t previous_time;
 172
 173     /* time updates with tags older than these are invalid */
 174     uint32_t write_index_not_before;
 175     uint32_t read_index_not_before;
 176
 177     /* Data about individual timing update corrections */
 178     pa_index_correction write_index_corrections[PA_MAX_WRITE_INDEX_CORRECTIONS];
 179     int current_write_index_correction;
 180
 181     /* Latency interpolation stuff */
 182     pa_time_event *auto_timing_update_event;
 183     pa_usec_t auto_timing_interval_usec;
 184
 185     pa_smoother *smoother;
 186
 187     /* Callbacks */
 188     pa_stream_notify_cb_t state_callback;
 189     void *state_userdata;
 190     pa_stream_request_cb_t read_callback;
 191     void *read_userdata;
 192     pa_stream_request_cb_t write_callback;
 193     void *write_userdata;
 194     pa_stream_notify_cb_t overflow_callback;
 195     void *overflow_userdata;
 196     pa_stream_notify_cb_t underflow_callback;
 197     void *underflow_userdata;
 198     pa_stream_notify_cb_t latency_update_callback;
 199     void *latency_update_userdata;
 200     pa_stream_notify_cb_t moved_callback;
 201     void *moved_userdata;
 202     pa_stream_notify_cb_t suspended_callback;
 203     void *suspended_userdata;
 204     pa_stream_notify_cb_t started_callback;
 205     void *started_userdata;
 206     pa_stream_event_cb_t event_callback;
 207     void *event_userdata;
 208     pa_stream_notify_cb_t buffer_attr_callback;
 209     void *buffer_attr_userdata;
 210 };
 211
 212 typedef void (*pa_operation_cb_t)(void);
 213
 214 struct pa_operation {
 215     PA_REFCNT_DECLARE;
 216
 217     pa_context *context;
 218     pa_stream *stream;
 219
 220     PA_LLIST_FIELDS(pa_operation);
 221
 222     pa_operation_state_t state;
 223     void *userdata;
 224     pa_operation_cb_t callback;
 225
 226     void *private; /* some operations might need this */
 227 };
 228
 229 void pa_command_request(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 230 void pa_command_stream_killed(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 231 void pa_command_subscribe_event(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 232 void pa_command_overflow_or_underflow(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 233 void pa_command_stream_suspended(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 234 void pa_command_stream_moved(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 235 void pa_command_stream_started(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 236 void pa_command_stream_event(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 237 void pa_command_client_event(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 238 void pa_command_stream_buffer_attr(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 239
 240 pa_operation *pa_operation_new(pa_context *c, pa_stream *s, pa_operation_cb_t callback, void *userdata);
 241 void pa_operation_done(pa_operation *o);
 242
 243 void pa_create_stream_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 244 void pa_stream_disconnect_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 245 void pa_context_simple_ack_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 246 void pa_stream_simple_ack_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 247
 248 void pa_context_fail(pa_context *c, int error);
 249 int pa_context_set_error(pa_context *c, int error);
 250 void pa_context_set_state(pa_context *c, pa_context_state_t st);
 251 int pa_context_handle_error(pa_context *c, uint32_t command, pa_tagstruct *t, pa_bool_t fail);
 252 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);
 253
 254 void pa_stream_set_state(pa_stream *s, pa_stream_state_t st);
 255
 256 pa_tagstruct *pa_tagstruct_command(pa_context *c, uint32_t command, uint32_t *tag);
 257
 258 #define PA_CHECK_VALIDITY(context, expression, error)         \
 259     do {                                                      \
 260         if (!(expression))                                    \
 261             return -pa_context_set_error((context), (error)); \
 262     } while(FALSE)
 263
 264
 265 #define PA_CHECK_VALIDITY_RETURN_ANY(context, expression, error, value) \
 266     do {                                                                \
 267         if (!(expression)) {                                            \
 268             pa_context_set_error((context), (error));                   \
 269             return value;                                               \
 270         }                                                               \
 271     } while(FALSE)
 272
 273 #define PA_CHECK_VALIDITY_RETURN_NULL(context, expression, error)       \
 274     PA_CHECK_VALIDITY_RETURN_ANY(context, expression, error, NULL)
 275
 276 #define PA_FAIL(context, error)                                 \
 277     do {                                                        \
 278         return -pa_context_set_error((context), (error));       \
 279     } while(FALSE)
 280
 281 #define PA_FAIL_RETURN_ANY(context, error, value)      \
 282     do {                                               \
 283         pa_context_set_error((context), (error));      \
 284         return value;                                  \
 285     } while(FALSE)
 286
 287 #define PA_FAIL_RETURN_NULL(context, error)     \
 288     PA_FAIL_RETURN_ANY(context, error, NULL)
 289
 290 void pa_ext_device_manager_command(pa_context *c, uint32_t tag, pa_tagstruct *t);
 291 void pa_ext_stream_restore_command(pa_context *c, uint32_t tag, pa_tagstruct *t);
 292
 293 pa_bool_t pa_mainloop_is_our_api(pa_mainloop_api*m);
 294
 295 #endif