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-device-restore.h>
  33 #include <pulse/ext-stream-restore.h>
  34 #include <pulse/ext-node-manager.h>
  35
  36 #include <pulsecore/socket-client.h>
  37 #include <pulsecore/pstream.h>
  38 #include <pulsecore/pdispatch.h>
  39 #include <pulsecore/llist.h>
  40 #include <pulsecore/native-common.h>
  41 #include <pulsecore/strlist.h>
  42 #include <pulsecore/mcalign.h>
  43 #include <pulsecore/memblockq.h>
  44 #include <pulsecore/hashmap.h>
  45 #include <pulsecore/refcnt.h>
  46 #include <pulsecore/time-smoother.h>
  47 #ifdef HAVE_DBUS
  48 #include <pulsecore/dbus-util.h>
  49 #endif
  50
  51 #include "client-conf.h"
  52
  53 #define DEFAULT_TIMEOUT (30)
  54
  55 struct pa_context {
  56     PA_REFCNT_DECLARE;
  57
  58 #ifdef HAVE_DBUS
  59     pa_dbus_wrap_connection *system_bus;
  60     pa_dbus_wrap_connection *session_bus;
  61 #endif
  62
  63     pa_proplist *proplist;
  64     pa_mainloop_api* mainloop;
  65
  66     pa_socket_client *client;
  67     pa_pstream *pstream;
  68     pa_pdispatch *pdispatch;
  69
  70     pa_hashmap *record_streams, *playback_streams;
  71     PA_LLIST_HEAD(pa_stream, streams);
  72     PA_LLIST_HEAD(pa_operation, operations);
  73
  74     uint32_t version;
  75     uint32_t ctag;
  76     uint32_t csyncid;
  77     int error;
  78     pa_context_state_t state;
  79
  80     pa_context_notify_cb_t state_callback;
  81     void *state_userdata;
  82     pa_context_subscribe_cb_t subscribe_callback;
  83     void *subscribe_userdata;
  84     pa_context_event_cb_t event_callback;
  85     void *event_userdata;
  86
  87     pa_mempool *mempool;
  88
  89     pa_bool_t is_local:1;
  90     pa_bool_t do_shm:1;
  91     pa_bool_t server_specified:1;
  92     pa_bool_t no_fail:1;
  93     pa_bool_t do_autospawn:1;
  94     pa_bool_t use_rtclock:1;
  95     pa_bool_t filter_added:1;
  96     pa_spawn_api spawn_api;
  97
  98     pa_strlist *server_list;
  99
 100     char *server;
 101
 102     pa_client_conf *conf;
 103
 104     uint32_t client_index;
 105
 106     /* Extension specific data */
 107     struct {
 108         pa_ext_device_manager_subscribe_cb_t callback;
 109         void *userdata;
 110     } ext_device_manager;
 111     struct {
 112         pa_ext_device_restore_subscribe_cb_t callback;
 113         void *userdata;
 114     } ext_device_restore;
 115     struct {
 116         pa_ext_stream_restore_subscribe_cb_t callback;
 117         void *userdata;
 118     } ext_stream_restore;
 119     struct {
 120         pa_ext_node_manager_subscribe_cb_t callback;
 121         void *userdata;
 122     } ext_node_manager;
 123 };
 124
 125 #define PA_MAX_WRITE_INDEX_CORRECTIONS 32
 126
 127 typedef struct pa_index_correction {
 128     uint32_t tag;
 129     int64_t value;
 130     pa_bool_t valid:1;
 131     pa_bool_t absolute:1;
 132     pa_bool_t corrupt:1;
 133 } pa_index_correction;
 134
 135 #define PA_MAX_FORMATS (PA_ENCODING_MAX)
 136
 137 struct pa_stream {
 138     PA_REFCNT_DECLARE;
 139     PA_LLIST_FIELDS(pa_stream);
 140
 141     pa_context *context;
 142     pa_mainloop_api *mainloop;
 143
 144     uint32_t direct_on_input;
 145
 146     pa_stream_direction_t direction;
 147     pa_stream_state_t state;
 148     pa_stream_flags_t flags;
 149
 150     pa_sample_spec sample_spec;
 151     pa_channel_map channel_map;
 152     uint8_t n_formats;
 153     pa_format_info *req_formats[PA_MAX_FORMATS];
 154     pa_format_info *format;
 155
 156     pa_proplist *proplist;
 157
 158     pa_bool_t channel_valid:1;
 159     pa_bool_t suspended:1;
 160     pa_bool_t corked:1;
 161     pa_bool_t timing_info_valid:1;
 162     pa_bool_t auto_timing_update_requested:1;
 163
 164     uint32_t channel;
 165     uint32_t syncid;
 166     uint32_t stream_index;
 167
 168     int64_t requested_bytes;
 169     pa_buffer_attr buffer_attr;
 170
 171     uint32_t device_index;
 172     char *device_name;
 173
 174     /* playback */
 175     pa_memblock *write_memblock;
 176     void *write_data;
 177     int64_t latest_underrun_at_index;
 178
 179     /* recording */
 180     pa_memchunk peek_memchunk;
 181     void *peek_data;
 182     pa_memblockq *record_memblockq;
 183
 184     /* Store latest latency info */
 185     pa_timing_info timing_info;
 186
 187     /* Use to make sure that time advances monotonically */
 188     pa_usec_t previous_time;
 189
 190     /* time updates with tags older than these are invalid */
 191     uint32_t write_index_not_before;
 192     uint32_t read_index_not_before;
 193
 194     /* Data about individual timing update corrections */
 195     pa_index_correction write_index_corrections[PA_MAX_WRITE_INDEX_CORRECTIONS];
 196     int current_write_index_correction;
 197
 198     /* Latency interpolation stuff */
 199     pa_time_event *auto_timing_update_event;
 200     pa_usec_t auto_timing_interval_usec;
 201
 202     pa_smoother *smoother;
 203
 204     /* Callbacks */
 205     pa_stream_notify_cb_t state_callback;
 206     void *state_userdata;
 207     pa_stream_request_cb_t read_callback;
 208     void *read_userdata;
 209     pa_stream_request_cb_t write_callback;
 210     void *write_userdata;
 211     pa_stream_notify_cb_t overflow_callback;
 212     void *overflow_userdata;
 213     pa_stream_notify_cb_t underflow_callback;
 214     void *underflow_userdata;
 215     pa_stream_notify_cb_t latency_update_callback;
 216     void *latency_update_userdata;
 217     pa_stream_notify_cb_t moved_callback;
 218     void *moved_userdata;
 219     pa_stream_notify_cb_t suspended_callback;
 220     void *suspended_userdata;
 221     pa_stream_notify_cb_t started_callback;
 222     void *started_userdata;
 223     pa_stream_event_cb_t event_callback;
 224     void *event_userdata;
 225     pa_stream_notify_cb_t buffer_attr_callback;
 226     void *buffer_attr_userdata;
 227 };
 228
 229 typedef void (*pa_operation_cb_t)(void);
 230
 231 struct pa_operation {
 232     PA_REFCNT_DECLARE;
 233
 234     pa_context *context;
 235     pa_stream *stream;
 236
 237     PA_LLIST_FIELDS(pa_operation);
 238
 239     pa_operation_state_t state;
 240     void *userdata;
 241     pa_operation_cb_t callback;
 242
 243     void *private; /* some operations might need this */
 244 };
 245
 246 void pa_command_request(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 247 void pa_command_stream_killed(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 248 void pa_command_subscribe_event(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 249 void pa_command_overflow_or_underflow(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 250 void pa_command_stream_suspended(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 251 void pa_command_stream_moved(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 252 void pa_command_stream_started(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 253 void pa_command_stream_event(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 254 void pa_command_client_event(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 255 void pa_command_stream_buffer_attr(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 256
 257 pa_operation *pa_operation_new(pa_context *c, pa_stream *s, pa_operation_cb_t callback, void *userdata);
 258 void pa_operation_done(pa_operation *o);
 259
 260 void pa_create_stream_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 261 void pa_stream_disconnect_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 262 void pa_context_simple_ack_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 263 void pa_stream_simple_ack_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 264
 265 void pa_context_fail(pa_context *c, int error);
 266 int pa_context_set_error(pa_context *c, int error);
 267 void pa_context_set_state(pa_context *c, pa_context_state_t st);
 268 int pa_context_handle_error(pa_context *c, uint32_t command, pa_tagstruct *t, pa_bool_t fail);
 269 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);
 270
 271 void pa_stream_set_state(pa_stream *s, pa_stream_state_t st);
 272
 273 pa_tagstruct *pa_tagstruct_command(pa_context *c, uint32_t command, uint32_t *tag);
 274
 275 #define PA_CHECK_VALIDITY(context, expression, error)         \
 276     do {                                                      \
 277         if (!(expression))                                    \
 278             return -pa_context_set_error((context), (error)); \
 279     } while(FALSE)
 280
 281
 282 #define PA_CHECK_VALIDITY_RETURN_ANY(context, expression, error, value) \
 283     do {                                                                \
 284         if (!(expression)) {                                            \
 285             pa_context_set_error((context), (error));                   \
 286             return value;                                               \
 287         }                                                               \
 288     } while(FALSE)
 289
 290 #define PA_CHECK_VALIDITY_RETURN_NULL(context, expression, error)       \
 291     PA_CHECK_VALIDITY_RETURN_ANY(context, expression, error, NULL)
 292
 293 #define PA_FAIL(context, error)                                 \
 294     do {                                                        \
 295         return -pa_context_set_error((context), (error));       \
 296     } while(FALSE)
 297
 298 #define PA_FAIL_RETURN_ANY(context, error, value)      \
 299     do {                                               \
 300         pa_context_set_error((context), (error));      \
 301         return value;                                  \
 302     } while(FALSE)
 303
 304 #define PA_FAIL_RETURN_NULL(context, error)     \
 305     PA_FAIL_RETURN_ANY(context, error, NULL)
 306
 307 void pa_ext_device_manager_command(pa_context *c, uint32_t tag, pa_tagstruct *t);
 308 void pa_ext_device_restore_command(pa_context *c, uint32_t tag, pa_tagstruct *t);
 309 void pa_ext_stream_restore_command(pa_context *c, uint32_t tag, pa_tagstruct *t);
 310 void pa_ext_node_manager_command(pa_context *c, uint32_t tag, pa_tagstruct *t);
 311
 312 void pa_format_info_free2(pa_format_info *f, void *userdata);
 313
 314 pa_bool_t pa_mainloop_is_our_api(pa_mainloop_api*m);
 315
 316 #endif