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

   1 #ifndef foodefhfoo
   2 #define foodefhfoo
   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
  12   published by the Free Software Foundation; either version 2.1 of the
  13   License, 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   Lesser General Public License for more details.
  19
  20   You should have received a copy of the GNU Lesser General Public
  21   License 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 <inttypes.h>
  27 #include <sys/time.h>
  28 #include <time.h>
  29
  30 #include <pulse/cdecl.h>
  31 #include <pulse/sample.h>
  32
  33 /** \file
  34  * Global definitions */
  35
  36 PA_C_DECL_BEGIN
  37
  38 /** The state of a connection context */
  39 typedef enum pa_context_state {
  40     PA_CONTEXT_UNCONNECTED,    /**< The context hasn't been connected yet */
  41     PA_CONTEXT_CONNECTING,     /**< A connection is being established */
  42     PA_CONTEXT_AUTHORIZING,    /**< The client is authorizing itself to the daemon */
  43     PA_CONTEXT_SETTING_NAME,   /**< The client is passing its application name to the daemon */
  44     PA_CONTEXT_READY,          /**< The connection is established, the context is ready to execute operations */
  45     PA_CONTEXT_FAILED,         /**< The connection failed or was disconnected */
  46     PA_CONTEXT_TERMINATED      /**< The connection was terminated cleanly */
  47 } pa_context_state_t;
  48
  49 /** Return non-zero if the passed state is one of the connected states */
  50 static inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x) {
  51     return
  52         x == PA_CONTEXT_CONNECTING ||
  53         x == PA_CONTEXT_AUTHORIZING ||
  54         x == PA_CONTEXT_SETTING_NAME ||
  55         x == PA_CONTEXT_READY;
  56 }
  57
  58 /** The state of a stream */
  59 typedef enum pa_stream_state {
  60     PA_STREAM_UNCONNECTED, /**< The stream is not yet connected to any sink or source */
  61     PA_STREAM_CREATING,     /**< The stream is being created */
  62     PA_STREAM_READY,        /**< The stream is established, you may pass audio data to it now */
  63     PA_STREAM_FAILED,       /**< An error occured that made the stream invalid */
  64     PA_STREAM_TERMINATED    /**< The stream has been terminated cleanly */
  65 } pa_stream_state_t;
  66
  67 /** Return non-zero if the passed state is one of the connected states */
  68 static inline int PA_STREAM_IS_GOOD(pa_stream_state_t x) {
  69     return
  70         x == PA_STREAM_CREATING ||
  71         x == PA_STREAM_READY;
  72 }
  73
  74 /** The state of an operation */
  75 typedef enum pa_operation_state {
  76     PA_OPERATION_RUNNING,      /**< The operation is still running */
  77     PA_OPERATION_DONE,         /**< The operation has been completed */
  78     PA_OPERATION_CANCELED      /**< The operation has been canceled */
  79 } pa_operation_state_t;
  80
  81 /** An invalid index */
  82 #define PA_INVALID_INDEX ((uint32_t) -1)
  83
  84 /** Some special flags for contexts. */
  85 typedef enum pa_context_flags {
  86     PA_CONTEXT_NOAUTOSPAWN = 1 /**< Disabled autospawning of the PulseAudio daemon if required */
  87 } pa_context_flags_t;
  88
  89 /** The direction of a pa_stream object */
  90 typedef enum pa_stream_direction {
  91     PA_STREAM_NODIRECTION,   /**< Invalid direction */
  92     PA_STREAM_PLAYBACK,      /**< Playback stream */
  93     PA_STREAM_RECORD,        /**< Record stream */
  94     PA_STREAM_UPLOAD         /**< Sample upload stream */
  95 } pa_stream_direction_t;
  96
  97 /** Some special flags for stream connections. */
  98 typedef enum pa_stream_flags {
  99     PA_STREAM_START_CORKED = 1,       /**< Create the stream corked, requiring an explicit pa_stream_cork() call to uncork it. */
 100     PA_STREAM_INTERPOLATE_TIMING = 2, /**< Interpolate the latency for
 101                                        * this stream. When enabled,
 102                                        * pa_stream_get_latency() and
 103                                        * pa_stream_get_time() will try
 104                                        * to estimate the current
 105                                        * record/playback time based on
 106                                        * the local time that passed
 107                                        * since the last timing info
 108                                        * update.  Using this option
 109                                        * has the advantage of not
 110                                        * requiring a whole roundtrip
 111                                        * when the current
 112                                        * playback/recording time is
 113                                        * needed. Consider using this
 114                                        * option when requesting
 115                                        * latency information
 116                                        * frequently. This is
 117                                        * especially useful on long
 118                                        * latency network
 119                                        * connections. It makes a lot
 120                                        * of sense to combine this
 121                                        * option with
 122                                        * PA_STREAM_AUTO_TIMING_UPDATE. */
 123     PA_STREAM_NOT_MONOTONOUS = 4,    /**< Don't force the time to
 124                                       * increase monotonically. If
 125                                       * this option is enabled,
 126                                       * pa_stream_get_time() will not
 127                                       * necessarily return always
 128                                       * monotonically increasing time
 129                                       * values on each call. This may
 130                                       * confuse applications which
 131                                       * cannot deal with time going
 132                                       * 'backwards', but has the
 133                                       * advantage that bad transport
 134                                       * latency estimations that
 135                                       * caused the time to to jump
 136                                       * ahead can be corrected
 137                                       * quickly, without the need to
 138                                       * wait. */
 139     PA_STREAM_AUTO_TIMING_UPDATE = 8, /**< If set timing update requests
 140                                        * are issued periodically
 141                                        * automatically. Combined with
 142                                        * PA_STREAM_INTERPOLATE_TIMING
 143                                        * you will be able to query the
 144                                        * current time and latency with
 145                                        * pa_stream_get_time() and
 146                                        * pa_stream_get_latency() at
 147                                        * all times without a packet
 148                                        * round trip.*/
 149     PA_STREAM_NO_REMAP_CHANNELS = 16, /**< Don't remap channels by
 150                                        * their name, instead map them
 151                                        * simply by their
 152                                        * index. Implies
 153                                        * PA_STREAM_NO_REMIX_CHANNELS. Only
 154                                        * supported when the server is
 155                                        * at least PA 0.9.8. It is
 156                                        * ignored on older
 157                                        * servers.\since 0.9.8 */
 158     PA_STREAM_NO_REMIX_CHANNELS = 32, /**< When remapping channels by
 159                                        * name, don't upmix or downmix
 160                                        * them to related
 161                                        * channels. Copy them into
 162                                        * matching channels of the
 163                                        * device 1:1. Only supported
 164                                        * when the server is at least
 165                                        * PA 0.9.8. It is ignored on
 166                                        * older servers. \since
 167                                        * 0.9.8 */
 168     PA_STREAM_FIX_FORMAT = 64, /**< Use the sample format of the
 169                                 * sink/device this stream is being
 170                                 * connected to, and possibly ignore
 171                                 * the format the sample spec contains
 172                                 * -- but you still have to pass a
 173                                 * valid value in it as a hint to
 174                                 * PulseAudio what would suit your
 175                                 * stream best. If this is used you
 176                                 * should query the used sample format
 177                                 * after creating the stream by using
 178                                 * pa_stream_get_sample_spec(). Also,
 179                                 * if you specified manual buffer
 180                                 * metrics it is recommended to update
 181                                 * them with
 182                                 * pa_stream_set_buffer_attr() to
 183                                 * compensate for the changed frame
 184                                 * sizes. Only supported when the
 185                                 * server is at least PA 0.9.8. It is
 186                                 * ignored on older servers. \since
 187                                 * 0.9.8 */
 188
 189     PA_STREAM_FIX_RATE = 128, /**< Use the sample rate of the sink,
 190                                * and possibly ignore the rate the
 191                                * sample spec contains. Usage similar
 192                                * to PA_STREAM_FIX_FORMAT.Only
 193                                * supported when the server is at least
 194                                * PA 0.9.8. It is ignored on older
 195                                * servers. \since 0.9.8 */
 196
 197     PA_STREAM_FIX_CHANNELS = 256, /**< Use the number of channels and
 198                                * the channel map of the sink, and
 199                                * possibly ignore the number of
 200                                * channels and the map the sample spec
 201                                * and the passed channel map
 202                                * contains. Usage similar to
 203                                * PA_STREAM_FIX_FORMAT. Only supported
 204                                * when the server is at least PA
 205                                * 0.9.8. It is ignored on older
 206                                * servers. \since 0.9.8 */
 207     PA_STREAM_DONT_MOVE = 512, /**< Don't allow moving of this stream to
 208                               * another sink/device. Useful if you use
 209                               * any of the PA_STREAM_FIX_ flags and
 210                               * want to make sure that resampling
 211                               * never takes place -- which might
 212                               * happen if the stream is moved to
 213                               * another sink/source whith a different
 214                               * sample spec/channel map. Only
 215                               * supported when the server is at least
 216                               * PA 0.9.8. It is ignored on older
 217                               * servers. \since 0.9.8 */
 218     PA_STREAM_VARIABLE_RATE = 1024, /**< Allow dynamic changing of the
 219                                      * sampling rate during playback
 220                                      * with
 221                                      * pa_stream_update_sample_rate(). Only
 222                                      * supported when the server is at
 223                                      * least PA 0.9.8. It is ignored
 224                                      * on older servers. \since
 225                                      * 0.9.8 */
 226     PA_STREAM_PEAK_DETECT = 2048, /**< Find peaks instead of
 227                                    * resampling. \since 0.9.11 */
 228
 229     PA_STREAM_START_MUTED = 4096,  /**< Create in muted state. \since 0.9.11 */
 230
 231
 232     PA_STREAM_ADJUST_LATENCY = 8192, /**< Try to adjust the latency of
 233                                       * the sink/source based on the
 234                                       * requested buffer metrics and
 235                                       * adjust buffer metrics
 236                                       * accordingly. \since 0.9.11 */
 237 } pa_stream_flags_t;
 238
 239
 240 /** English is an evil language \since 0.9.11 */
 241 #define PA_STREAM_NOT_MONOTONIC PA_STREAM_NOT_MONOTONOUS
 242
 243 /** Playback and record buffer metrics */
 244 typedef struct pa_buffer_attr {
 245     uint32_t maxlength;      /**< Maximum length of the
 246                               * buffer. Setting this to 0 will
 247                               * initialize this to the maximum value
 248                               * supported by server, which is
 249                               * recommended. */
 250     uint32_t tlength;        /**< Playback only: target length of the
 251                               * buffer. The server tries to assure
 252                               * that at least tlength bytes are always
 253                               * available in the buffer. It is
 254                               * recommended to set this to 0, which
 255                               * will initialize this to a value that
 256                               * is deemed sensible by the
 257                               * server. However, this value will
 258                               * default to something like 2s, i.e. for
 259                               * applications that have specific
 260                               * latency requirements this value should
 261                               * be set to the maximum latency that the
 262                               * application can deal with.  */
 263     uint32_t prebuf;         /**< Playback only: pre-buffering. The
 264                               * server does not start with playback
 265                               * before at least prebug bytes are
 266                               * available in the buffer. It is
 267                               * recommended to set this to 0, which
 268                               * will initialize this to the same value
 269                               * as tlength, whatever that may be. */
 270     uint32_t minreq;         /**< Playback only: minimum request. The
 271                               * server does not request less than
 272                               * minreq bytes from the client, instead
 273                               * waits until the buffer is free enough
 274                               * to request more bytes at once. It is
 275                               * recommended to set this to 0, which
 276                               * will initialize this to a value that
 277                               * is deemed sensible by the server. */
 278     uint32_t fragsize;       /**< Recording only: fragment size. The
 279                               * server sends data in blocks of
 280                               * fragsize bytes size. Large values
 281                               * deminish interactivity with other
 282                               * operations on the connection context
 283                               * but decrease control overhead. It is
 284                               * recommended to set this to 0, which
 285                               * will initialize this to a value that
 286                               * is deemed sensible by the
 287                               * server. However, this value will
 288                               * default to something like 2s, i.e. for
 289                               * applications that have specific
 290                               * latency requirements this value should
 291                               * be set to the maximum latency that the
 292                               * application can deal with. */
 293 } pa_buffer_attr;
 294
 295 /** Error values as used by pa_context_errno(). Use pa_strerror() to convert these values to human readable strings */
 296 enum {
 297     PA_OK = 0,                     /**< No error */
 298     PA_ERR_ACCESS,                 /**< Access failure */
 299     PA_ERR_COMMAND,                /**< Unknown command */
 300     PA_ERR_INVALID,                /**< Invalid argument */
 301     PA_ERR_EXIST,                  /**< Entity exists */
 302     PA_ERR_NOENTITY,               /**< No such entity */
 303     PA_ERR_CONNECTIONREFUSED,      /**< Connection refused */
 304     PA_ERR_PROTOCOL,               /**< Protocol error */
 305     PA_ERR_TIMEOUT,                /**< Timeout */
 306     PA_ERR_AUTHKEY,                /**< No authorization key */
 307     PA_ERR_INTERNAL,               /**< Internal error */
 308     PA_ERR_CONNECTIONTERMINATED,   /**< Connection terminated */
 309     PA_ERR_KILLED,                 /**< Entity killed */
 310     PA_ERR_INVALIDSERVER,          /**< Invalid server */
 311     PA_ERR_MODINITFAILED,          /**< Module initialization failed */
 312     PA_ERR_BADSTATE,               /**< Bad state */
 313     PA_ERR_NODATA,                 /**< No data */
 314     PA_ERR_VERSION,                /**< Incompatible protocol version */
 315     PA_ERR_TOOLARGE,               /**< Data too large */
 316     PA_ERR_NOTSUPPORTED,           /**< Operation not supported \since 0.9.5 */
 317     PA_ERR_UNKNOWN,                /**< The error code was unknown to the client */
 318     PA_ERR_MAX                     /**< Not really an error but the first invalid error code */
 319 };
 320
 321 /** Subscription event mask, as used by pa_context_subscribe() */
 322 typedef enum pa_subscription_mask {
 323     PA_SUBSCRIPTION_MASK_NULL = 0,               /**< No events */
 324     PA_SUBSCRIPTION_MASK_SINK = 1,               /**< Sink events */
 325     PA_SUBSCRIPTION_MASK_SOURCE = 2,             /**< Source events */
 326     PA_SUBSCRIPTION_MASK_SINK_INPUT = 4,         /**< Sink input events */
 327     PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT = 8,      /**< Source output events */
 328     PA_SUBSCRIPTION_MASK_MODULE = 16,            /**< Module events */
 329     PA_SUBSCRIPTION_MASK_CLIENT = 32,            /**< Client events */
 330     PA_SUBSCRIPTION_MASK_SAMPLE_CACHE = 64,      /**< Sample cache events */
 331     PA_SUBSCRIPTION_MASK_SERVER = 128,           /**< Other global server changes. */
 332     PA_SUBSCRIPTION_MASK_AUTOLOAD = 256,         /**< Autoload table events. */
 333     PA_SUBSCRIPTION_MASK_ALL = 511               /**< Catch all events */
 334 } pa_subscription_mask_t;
 335
 336 /** Subscription event types, as used by pa_context_subscribe() */
 337 typedef enum pa_subscription_event_type {
 338     PA_SUBSCRIPTION_EVENT_SINK = 0,           /**< Event type: Sink */
 339     PA_SUBSCRIPTION_EVENT_SOURCE = 1,         /**< Event type: Source */
 340     PA_SUBSCRIPTION_EVENT_SINK_INPUT = 2,     /**< Event type: Sink input */
 341     PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT = 3,  /**< Event type: Source output */
 342     PA_SUBSCRIPTION_EVENT_MODULE = 4,         /**< Event type: Module */
 343     PA_SUBSCRIPTION_EVENT_CLIENT = 5,         /**< Event type: Client */
 344     PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE = 6,   /**< Event type: Sample cache item */
 345     PA_SUBSCRIPTION_EVENT_SERVER = 7,         /**< Event type: Global server change, only occuring with PA_SUBSCRIPTION_EVENT_CHANGE. */
 346     PA_SUBSCRIPTION_EVENT_AUTOLOAD = 8,       /**< Event type: Autoload table changes. */
 347     PA_SUBSCRIPTION_EVENT_FACILITY_MASK = 15, /**< A mask to extract the event type from an event value */
 348
 349     PA_SUBSCRIPTION_EVENT_NEW = 0,            /**< A new object was created */
 350     PA_SUBSCRIPTION_EVENT_CHANGE = 16,        /**< A property of the object was modified */
 351     PA_SUBSCRIPTION_EVENT_REMOVE = 32,        /**< An object was removed */
 352     PA_SUBSCRIPTION_EVENT_TYPE_MASK = 16+32   /**< A mask to extract the event operation from an event value */
 353 } pa_subscription_event_type_t;
 354
 355 /** Return one if an event type t matches an event mask bitfield */
 356 #define pa_subscription_match_flags(m, t) (!!((m) & (1 << ((t) & PA_SUBSCRIPTION_EVENT_FACILITY_MASK))))
 357
 358 /** A structure for all kinds of timing information of a stream. See
 359  * pa_stream_update_timing_info() and pa_stream_get_timing_info(). The
 360  * total output latency a sample that is written with
 361  * pa_stream_write() takes to be played may be estimated by
 362  * sink_usec+buffer_usec+transport_usec. (where buffer_usec is defined
 363  * as pa_bytes_to_usec(write_index-read_index)) The output buffer
 364  * which buffer_usec relates to may be manipulated freely (with
 365  * pa_stream_write()'s seek argument, pa_stream_flush() and friends),
 366  * the buffers sink_usec and source_usec relate to are first-in
 367  * first-out (FIFO) buffers which cannot be flushed or manipulated in
 368  * any way. The total input latency a sample that is recorded takes to
 369  * be delivered to the application is:
 370  * source_usec+buffer_usec+transport_usec-sink_usec. (Take care of
 371  * sign issues!) When connected to a monitor source sink_usec contains
 372  * the latency of the owning sink. The two latency estimations
 373  * described here are implemented in pa_stream_get_latency(). Please
 374  * note that this structure can be extended as part of evolutionary
 375  * API updates at any time in any new release.*/
 376 typedef struct pa_timing_info {
 377     struct timeval timestamp; /**< The time when this timing info structure was current */
 378     int synchronized_clocks;  /**< Non-zero if the local and the
 379                                * remote machine have synchronized
 380                                * clocks. If synchronized clocks are
 381                                * detected transport_usec becomes much
 382                                * more reliable. However, the code that
 383                                * detects synchronized clocks is very
 384                                * limited und unreliable itself. */
 385
 386     pa_usec_t sink_usec;      /**< Time in usecs a sample takes to be played on the sink. For playback streams and record streams connected to a monitor source. */
 387     pa_usec_t source_usec;    /**< Time in usecs a sample takes from being recorded to being delivered to the application. Only for record streams. */
 388     pa_usec_t transport_usec; /**< Estimated time in usecs a sample takes to be transferred to/from the daemon. For both playback and record streams. */
 389
 390     int playing;              /**< Non-zero when the stream is
 391                                * currently not underrun and data is
 392                                * being passed on to the device. Only
 393                                * for playback streams. This field does
 394                                * not say whether the data is actually
 395                                * already being played. To determine
 396                                * this check whether since_underrun
 397                                * (converted to usec) is larger than
 398                                * sink_usec.*/
 399
 400     int write_index_corrupt;  /**< Non-zero if write_index is not
 401                                * up-to-date because a local write
 402                                * command that corrupted it has been
 403                                * issued in the time since this latency
 404                                * info was current . Only write
 405                                * commands with SEEK_RELATIVE_ON_READ
 406                                * and SEEK_RELATIVE_END can corrupt
 407                                * write_index. */
 408     int64_t write_index;      /**< Current write index into the
 409                                * playback buffer in bytes. Think twice before
 410                                * using this for seeking purposes: it
 411                                * might be out of date a the time you
 412                                * want to use it. Consider using
 413                                * PA_SEEK_RELATIVE instead.  */
 414
 415     int read_index_corrupt;   /**< Non-zero if read_index is not
 416                                * up-to-date because a local pause or
 417                                * flush request that corrupted it has
 418                                * been issued in the time since this
 419                                * latency info was current. */
 420
 421     int64_t read_index;       /**< Current read index into the
 422                                * playback buffer in bytes. Think twice before
 423                                * using this for seeking purposes: it
 424                                * might be out of date a the time you
 425                                * want to use it. Consider using
 426                                * PA_SEEK_RELATIVE_ON_READ
 427                                * instead. */
 428
 429     pa_usec_t configured_sink_usec;   /**< The static configured latency for
 430                                 * the sink. \since 0.9.11 */
 431     pa_usec_t configured_source_usec; /**< The static configured latency for
 432                                 * the source. \since 0.9.11 */
 433
 434     int64_t since_underrun;    /**< Bytes that were handed to the sink
 435                                   since the last underrun happened, or
 436                                   since playback started again after
 437                                   the last underrun. playing will tell
 438                                   you which case it is. \since
 439                                   0.9.11 */
 440
 441 } pa_timing_info;
 442
 443 /** A structure for the spawn api. This may be used to integrate auto
 444  * spawned daemons into your application. For more information see
 445  * pa_context_connect(). When spawning a new child process the
 446  * waitpid() is used on the child's PID. The spawn routine will not
 447  * block or ignore SIGCHLD signals, since this cannot be done in a
 448  * thread compatible way. You might have to do this in
 449  * prefork/postfork. */
 450 typedef struct pa_spawn_api {
 451     void (*prefork)(void);     /**< Is called just before the fork in the parent process. May be NULL. */
 452     void (*postfork)(void);    /**< Is called immediately after the fork in the parent process. May be NULL.*/
 453     void (*atfork)(void);      /**< Is called immediately after the
 454                                 * fork in the child process. May be
 455                                 * NULL. It is not safe to close all
 456                                 * file descriptors in this function
 457                                 * unconditionally, since a UNIX socket
 458                                 * (created using socketpair()) is
 459                                 * passed to the new process. */
 460 } pa_spawn_api;
 461
 462 /** Seek type for pa_stream_write(). */
 463 typedef enum pa_seek_mode {
 464     PA_SEEK_RELATIVE = 0,           /**< Seek relatively to the write index */
 465     PA_SEEK_ABSOLUTE = 1,           /**< Seek relatively to the start of the buffer queue */
 466     PA_SEEK_RELATIVE_ON_READ = 2,   /**< Seek relatively to the read index.  */
 467     PA_SEEK_RELATIVE_END = 3        /**< Seek relatively to the current end of the buffer queue. */
 468 } pa_seek_mode_t;
 469
 470 /** Special sink flags. */
 471 typedef enum pa_sink_flags {
 472     PA_SINK_HW_VOLUME_CTRL = 1,   /**< Supports hardware volume control */
 473     PA_SINK_LATENCY = 2,          /**< Supports latency querying */
 474     PA_SINK_HARDWARE = 4,         /**< Is a hardware sink of some kind, in contrast to "virtual"/software sinks \since 0.9.3 */
 475     PA_SINK_NETWORK = 8,          /**< Is a networked sink of some kind. \since 0.9.7 */
 476     PA_SINK_HW_MUTE_CTRL = 16,    /**< Supports hardware mute control \since 0.9.11 */
 477     PA_SINK_DECIBEL_VOLUME = 32   /**< Volume can be translated to dB with pa_sw_volume_to_dB() \since 0.9.11 */
 478 } pa_sink_flags_t;
 479
 480 /** Special source flags.  */
 481 typedef enum pa_source_flags {
 482     PA_SOURCE_HW_VOLUME_CTRL = 1,  /**< Supports hardware volume control */
 483     PA_SOURCE_LATENCY = 2,         /**< Supports latency querying */
 484     PA_SOURCE_HARDWARE = 4,        /**< Is a hardware source of some kind, in contrast to "virtual"/software source \since 0.9.3 */
 485     PA_SOURCE_NETWORK = 8,         /**< Is a networked sink of some kind. \since 0.9.7 */
 486     PA_SOURCE_HW_MUTE_CTRL = 16,   /**< Supports hardware mute control \since 0.9.11 */
 487     PA_SOURCE_DECIBEL_VOLUME = 32  /**< Volume can be translated to dB with pa_sw_volume_to_dB() \since 0.9.11 */
 488 } pa_source_flags_t;
 489
 490 /** A generic free() like callback prototype */
 491 typedef void (*pa_free_cb_t)(void *p);
 492
 493 PA_C_DECL_END
 494
 495 #endif