def.h

Go to the documentation of this file.

#ifndef foodefhfoo
#define foodefhfoo

/***
  This file is part of PulseAudio.

  Copyright 2004-2006 Lennart Poettering
  Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB

  PulseAudio is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as
  published by the Free Software Foundation; either version 2.1 of the
  License, or (at your option) any later version.

  PulseAudio is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
***/

#include <inttypes.h>
#include <sys/time.h>

#include <pulse/cdecl.h>
#include <pulse/sample.h>
#include <pulse/version.h>

PA_C_DECL_BEGIN

typedef enum pa_context_state {
    PA_CONTEXT_UNCONNECTED,    
    PA_CONTEXT_CONNECTING,     
    PA_CONTEXT_AUTHORIZING,    
    PA_CONTEXT_SETTING_NAME,   
    PA_CONTEXT_READY,          
    PA_CONTEXT_FAILED,         
    PA_CONTEXT_TERMINATED      
} pa_context_state_t;

static inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x) {
    return
        x == PA_CONTEXT_CONNECTING ||
        x == PA_CONTEXT_AUTHORIZING ||
        x == PA_CONTEXT_SETTING_NAME ||
        x == PA_CONTEXT_READY;
}

#define PA_CONTEXT_UNCONNECTED PA_CONTEXT_UNCONNECTED
#define PA_CONTEXT_CONNECTING PA_CONTEXT_CONNECTING
#define PA_CONTEXT_AUTHORIZING PA_CONTEXT_AUTHORIZING
#define PA_CONTEXT_SETTING_NAME PA_CONTEXT_SETTING_NAME
#define PA_CONTEXT_READY PA_CONTEXT_READY
#define PA_CONTEXT_FAILED PA_CONTEXT_FAILED
#define PA_CONTEXT_TERMINATED PA_CONTEXT_TERMINATED
#define PA_CONTEXT_IS_GOOD PA_CONTEXT_IS_GOOD

typedef enum pa_stream_state {
    PA_STREAM_UNCONNECTED,  
    PA_STREAM_CREATING,     
    PA_STREAM_READY,        
    PA_STREAM_FAILED,       
    PA_STREAM_TERMINATED    
} pa_stream_state_t;

static inline int PA_STREAM_IS_GOOD(pa_stream_state_t x) {
    return
        x == PA_STREAM_CREATING ||
        x == PA_STREAM_READY;
}

#define PA_STREAM_UNCONNECTED PA_STREAM_UNCONNECTED
#define PA_STREAM_CREATING PA_STREAM_CREATING
#define PA_STREAM_READY PA_STREAM_READY
#define PA_STREAM_FAILED PA_STREAM_FAILED
#define PA_STREAM_TERMINATED PA_STREAM_TERMINATED
#define PA_STREAM_IS_GOOD PA_STREAM_IS_GOOD

typedef enum pa_operation_state {
    PA_OPERATION_RUNNING,
    PA_OPERATION_DONE,
    PA_OPERATION_CANCELLED
} pa_operation_state_t;

#define PA_OPERATION_RUNNING PA_OPERATION_RUNNING
#define PA_OPERATION_DONE PA_OPERATION_DONE
#define PA_OPERATION_CANCELED PA_OPERATION_CANCELLED
#define PA_OPERATION_CANCELLED PA_OPERATION_CANCELLED

#define PA_INVALID_INDEX ((uint32_t) -1)

typedef enum pa_context_flags {
    PA_CONTEXT_NOFLAGS = 0x0000U,
    PA_CONTEXT_NOAUTOSPAWN = 0x0001U,
    PA_CONTEXT_NOFAIL = 0x0002U
} pa_context_flags_t;

/* Allow clients to check with #ifdef for those flags */
#define PA_CONTEXT_NOAUTOSPAWN PA_CONTEXT_NOAUTOSPAWN
#define PA_CONTEXT_NOFAIL PA_CONTEXT_NOFAIL

typedef enum pa_direction {
    PA_DIRECTION_OUTPUT = 0x0001U,  
    PA_DIRECTION_INPUT = 0x0002U    
} pa_direction_t;

#define PA_DIRECTION_OUTPUT PA_DIRECTION_OUTPUT
#define PA_DIRECTION_INPUT PA_DIRECTION_INPUT

typedef enum pa_device_type {
    PA_DEVICE_TYPE_SINK,     
    PA_DEVICE_TYPE_SOURCE    
} pa_device_type_t;

#define PA_DEVICE_TYPE_SINK PA_DEVICE_TYPE_SINK
#define PA_DEVICE_TYPE_SOURCE PA_DEVICE_TYPE_SOURCE

typedef enum pa_stream_direction {
    PA_STREAM_NODIRECTION,   
    PA_STREAM_PLAYBACK,      
    PA_STREAM_RECORD,        
    PA_STREAM_UPLOAD         
} pa_stream_direction_t;

#define PA_STREAM_NODIRECTION PA_STREAM_NODIRECTION
#define PA_STREAM_PLAYBACK PA_STREAM_PLAYBACK
#define PA_STREAM_RECORD PA_STREAM_RECORD
#define PA_STREAM_UPLOAD PA_STREAM_UPLOAD

typedef enum pa_stream_flags {

    PA_STREAM_NOFLAGS = 0x0000U,
    PA_STREAM_START_CORKED = 0x0001U,
    PA_STREAM_INTERPOLATE_TIMING = 0x0002U,
    PA_STREAM_NOT_MONOTONIC = 0x0004U,
    PA_STREAM_AUTO_TIMING_UPDATE = 0x0008U,
    PA_STREAM_NO_REMAP_CHANNELS = 0x0010U,
    PA_STREAM_NO_REMIX_CHANNELS = 0x0020U,
    PA_STREAM_FIX_FORMAT = 0x0040U,
    PA_STREAM_FIX_RATE = 0x0080U,
    PA_STREAM_FIX_CHANNELS = 0x0100,
    PA_STREAM_DONT_MOVE = 0x0200U,
    PA_STREAM_VARIABLE_RATE = 0x0400U,
    PA_STREAM_PEAK_DETECT = 0x0800U,
    PA_STREAM_START_MUTED = 0x1000U,
    PA_STREAM_ADJUST_LATENCY = 0x2000U,
    PA_STREAM_EARLY_REQUESTS = 0x4000U,
    PA_STREAM_DONT_INHIBIT_AUTO_SUSPEND = 0x8000U,
    PA_STREAM_START_UNMUTED = 0x10000U,
    PA_STREAM_FAIL_ON_SUSPEND = 0x20000U,
    PA_STREAM_RELATIVE_VOLUME = 0x40000U,
    PA_STREAM_PASSTHROUGH = 0x80000U
} pa_stream_flags_t;

/* English is an evil language */
#define PA_STREAM_NOT_MONOTONOUS PA_STREAM_NOT_MONOTONIC

/* Allow clients to check with #ifdef for those flags */
#define PA_STREAM_START_CORKED PA_STREAM_START_CORKED
#define PA_STREAM_INTERPOLATE_TIMING PA_STREAM_INTERPOLATE_TIMING
#define PA_STREAM_NOT_MONOTONIC PA_STREAM_NOT_MONOTONIC
#define PA_STREAM_AUTO_TIMING_UPDATE PA_STREAM_AUTO_TIMING_UPDATE
#define PA_STREAM_NO_REMAP_CHANNELS PA_STREAM_NO_REMAP_CHANNELS
#define PA_STREAM_NO_REMIX_CHANNELS PA_STREAM_NO_REMIX_CHANNELS
#define PA_STREAM_FIX_FORMAT PA_STREAM_FIX_FORMAT
#define PA_STREAM_FIX_RATE PA_STREAM_FIX_RATE
#define PA_STREAM_FIX_CHANNELS PA_STREAM_FIX_CHANNELS
#define PA_STREAM_DONT_MOVE PA_STREAM_DONT_MOVE
#define PA_STREAM_VARIABLE_RATE PA_STREAM_VARIABLE_RATE
#define PA_STREAM_PEAK_DETECT PA_STREAM_PEAK_DETECT
#define PA_STREAM_START_MUTED PA_STREAM_START_MUTED
#define PA_STREAM_ADJUST_LATENCY PA_STREAM_ADJUST_LATENCY
#define PA_STREAM_EARLY_REQUESTS PA_STREAM_EARLY_REQUESTS
#define PA_STREAM_DONT_INHIBIT_AUTO_SUSPEND PA_STREAM_DONT_INHIBIT_AUTO_SUSPEND
#define PA_STREAM_START_UNMUTED PA_STREAM_START_UNMUTED
#define PA_STREAM_FAIL_ON_SUSPEND PA_STREAM_FAIL_ON_SUSPEND
#define PA_STREAM_RELATIVE_VOLUME PA_STREAM_RELATIVE_VOLUME
#define PA_STREAM_PASSTHROUGH PA_STREAM_PASSTHROUGH

typedef struct pa_buffer_attr {
    uint32_t maxlength;
    uint32_t tlength;
    uint32_t prebuf;
    uint32_t minreq;
    uint32_t fragsize;
} pa_buffer_attr;

typedef enum pa_error_code {
    PA_OK = 0,                     
    PA_ERR_ACCESS,                 
    PA_ERR_COMMAND,                
    PA_ERR_INVALID,                
    PA_ERR_EXIST,                  
    PA_ERR_NOENTITY,               
    PA_ERR_CONNECTIONREFUSED,      
    PA_ERR_PROTOCOL,               
    PA_ERR_TIMEOUT,                
    PA_ERR_AUTHKEY,                
    PA_ERR_INTERNAL,               
    PA_ERR_CONNECTIONTERMINATED,   
    PA_ERR_KILLED,                 
    PA_ERR_INVALIDSERVER,          
    PA_ERR_MODINITFAILED,          
    PA_ERR_BADSTATE,               
    PA_ERR_NODATA,                 
    PA_ERR_VERSION,                
    PA_ERR_TOOLARGE,               
    PA_ERR_NOTSUPPORTED,           
    PA_ERR_UNKNOWN,                
    PA_ERR_NOEXTENSION,            
    PA_ERR_OBSOLETE,               
    PA_ERR_NOTIMPLEMENTED,         
    PA_ERR_FORKED,                 
    PA_ERR_IO,                     
    PA_ERR_BUSY,                   
    PA_ERR_MAX                     
} pa_error_code_t;

#define PA_OK PA_OK
#define PA_ERR_ACCESS PA_ERR_ACCESS
#define PA_ERR_COMMAND PA_ERR_COMMAND
#define PA_ERR_INVALID PA_ERR_INVALID
#define PA_ERR_EXIST PA_ERR_EXIST
#define PA_ERR_NOENTITY PA_ERR_NOENTITY
#define PA_ERR_CONNECTIONREFUSED PA_ERR_CONNECTIONREFUSED
#define PA_ERR_PROTOCOL PA_ERR_PROTOCOL
#define PA_ERR_TIMEOUT PA_ERR_TIMEOUT
#define PA_ERR_AUTHKEY PA_ERR_AUTHKEY
#define PA_ERR_INTERNAL PA_ERR_INTERNAL
#define PA_ERR_CONNECTIONTERMINATED PA_ERR_CONNECTIONTERMINATED
#define PA_ERR_KILLED PA_ERR_KILLED
#define PA_ERR_INVALIDSERVER PA_ERR_INVALIDSERVER
#define PA_ERR_MODINITFAILED PA_ERR_MODINITFAILED
#define PA_ERR_BADSTATE PA_ERR_BADSTATE
#define PA_ERR_NODATA PA_ERR_NODATA
#define PA_ERR_VERSION PA_ERR_VERSION
#define PA_ERR_TOOLARGE PA_ERR_TOOLARGE
#define PA_ERR_NOTSUPPORTED PA_ERR_NOTSUPPORTED
#define PA_ERR_UNKNOWN PA_ERR_UNKNOWN
#define PA_ERR_NOEXTENSION PA_ERR_NOEXTENSION
#define PA_ERR_OBSOLETE PA_ERR_OBSOLETE
#define PA_ERR_NOTIMPLEMENTED PA_ERR_NOTIMPLEMENTED
#define PA_ERR_FORKED PA_ERR_FORKED
#define PA_ERR_MAX PA_ERR_MAX

typedef enum pa_subscription_mask {
    PA_SUBSCRIPTION_MASK_NULL = 0x0000U,
    PA_SUBSCRIPTION_MASK_SINK = 0x0001U,
    PA_SUBSCRIPTION_MASK_SOURCE = 0x0002U,
    PA_SUBSCRIPTION_MASK_SINK_INPUT = 0x0004U,
    PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT = 0x0008U,
    PA_SUBSCRIPTION_MASK_MODULE = 0x0010U,
    PA_SUBSCRIPTION_MASK_CLIENT = 0x0020U,
    PA_SUBSCRIPTION_MASK_SAMPLE_CACHE = 0x0040U,
    PA_SUBSCRIPTION_MASK_SERVER = 0x0080U,
    PA_SUBSCRIPTION_MASK_AUTOLOAD = 0x0100U,
    PA_SUBSCRIPTION_MASK_CARD = 0x0200U,
    PA_SUBSCRIPTION_MASK_ALL = 0x02ffU
} pa_subscription_mask_t;

typedef enum pa_subscription_event_type {
    PA_SUBSCRIPTION_EVENT_SINK = 0x0000U,
    PA_SUBSCRIPTION_EVENT_SOURCE = 0x0001U,
    PA_SUBSCRIPTION_EVENT_SINK_INPUT = 0x0002U,
    PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT = 0x0003U,
    PA_SUBSCRIPTION_EVENT_MODULE = 0x0004U,
    PA_SUBSCRIPTION_EVENT_CLIENT = 0x0005U,
    PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE = 0x0006U,
    PA_SUBSCRIPTION_EVENT_SERVER = 0x0007U,
    PA_SUBSCRIPTION_EVENT_AUTOLOAD = 0x0008U,
    PA_SUBSCRIPTION_EVENT_CARD = 0x0009U,
    PA_SUBSCRIPTION_EVENT_FACILITY_MASK = 0x000FU,
    PA_SUBSCRIPTION_EVENT_NEW = 0x0000U,
    PA_SUBSCRIPTION_EVENT_CHANGE = 0x0010U,
    PA_SUBSCRIPTION_EVENT_REMOVE = 0x0020U,
    PA_SUBSCRIPTION_EVENT_TYPE_MASK = 0x0030U
} pa_subscription_event_type_t;

#define pa_subscription_match_flags(m, t) (!!((m) & (1 << ((t) & PA_SUBSCRIPTION_EVENT_FACILITY_MASK))))

#define PA_SUBSCRIPTION_MASK_NULL PA_SUBSCRIPTION_MASK_NULL
#define PA_SUBSCRIPTION_MASK_SINK PA_SUBSCRIPTION_MASK_SINK
#define PA_SUBSCRIPTION_MASK_SOURCE PA_SUBSCRIPTION_MASK_SOURCE
#define PA_SUBSCRIPTION_MASK_SINK_INPUT PA_SUBSCRIPTION_MASK_SINK_INPUT
#define PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT
#define PA_SUBSCRIPTION_MASK_MODULE PA_SUBSCRIPTION_MASK_MODULE
#define PA_SUBSCRIPTION_MASK_CLIENT PA_SUBSCRIPTION_MASK_CLIENT
#define PA_SUBSCRIPTION_MASK_SAMPLE_CACHE PA_SUBSCRIPTION_MASK_SAMPLE_CACHE
#define PA_SUBSCRIPTION_MASK_SERVER PA_SUBSCRIPTION_MASK_SERVER
#define PA_SUBSCRIPTION_MASK_AUTOLOAD PA_SUBSCRIPTION_MASK_AUTOLOAD
#define PA_SUBSCRIPTION_MASK_CARD PA_SUBSCRIPTION_MASK_CARD
#define PA_SUBSCRIPTION_MASK_ALL PA_SUBSCRIPTION_MASK_ALL
#define PA_SUBSCRIPTION_EVENT_SINK PA_SUBSCRIPTION_EVENT_SINK
#define PA_SUBSCRIPTION_EVENT_SOURCE PA_SUBSCRIPTION_EVENT_SOURCE
#define PA_SUBSCRIPTION_EVENT_SINK_INPUT PA_SUBSCRIPTION_EVENT_SINK_INPUT
#define PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT
#define PA_SUBSCRIPTION_EVENT_MODULE PA_SUBSCRIPTION_EVENT_MODULE
#define PA_SUBSCRIPTION_EVENT_CLIENT PA_SUBSCRIPTION_EVENT_CLIENT
#define PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE
#define PA_SUBSCRIPTION_EVENT_SERVER PA_SUBSCRIPTION_EVENT_SERVER
#define PA_SUBSCRIPTION_EVENT_AUTOLOAD PA_SUBSCRIPTION_EVENT_AUTOLOAD
#define PA_SUBSCRIPTION_EVENT_CARD PA_SUBSCRIPTION_EVENT_CARD
#define PA_SUBSCRIPTION_EVENT_FACILITY_MASK PA_SUBSCRIPTION_EVENT_FACILITY_MASK
#define PA_SUBSCRIPTION_EVENT_NEW PA_SUBSCRIPTION_EVENT_NEW
#define PA_SUBSCRIPTION_EVENT_CHANGE PA_SUBSCRIPTION_EVENT_CHANGE
#define PA_SUBSCRIPTION_EVENT_REMOVE PA_SUBSCRIPTION_EVENT_REMOVE
#define PA_SUBSCRIPTION_EVENT_TYPE_MASK PA_SUBSCRIPTION_EVENT_TYPE_MASK

typedef struct pa_timing_info {
    struct timeval timestamp;
    int synchronized_clocks;
    pa_usec_t sink_usec;
    pa_usec_t source_usec;
    pa_usec_t transport_usec;
    int playing;
    int write_index_corrupt;
    int64_t write_index;
    int read_index_corrupt;
    int64_t read_index;
    pa_usec_t configured_sink_usec;
    pa_usec_t configured_source_usec;
    int64_t since_underrun;
} pa_timing_info;

typedef struct pa_spawn_api {
    void (*prefork)(void);
    void (*postfork)(void);
    void (*atfork)(void);
} pa_spawn_api;

typedef enum pa_seek_mode {
    PA_SEEK_RELATIVE = 0,
    PA_SEEK_ABSOLUTE = 1,
    PA_SEEK_RELATIVE_ON_READ = 2,
    PA_SEEK_RELATIVE_END = 3
} pa_seek_mode_t;

#define PA_SEEK_RELATIVE PA_SEEK_RELATIVE
#define PA_SEEK_ABSOLUTE PA_SEEK_ABSOLUTE
#define PA_SEEK_RELATIVE_ON_READ PA_SEEK_RELATIVE_ON_READ
#define PA_SEEK_RELATIVE_END PA_SEEK_RELATIVE_END

typedef enum pa_sink_flags {
    PA_SINK_NOFLAGS = 0x0000U,
    PA_SINK_HW_VOLUME_CTRL = 0x0001U,
    PA_SINK_LATENCY = 0x0002U,
    PA_SINK_HARDWARE = 0x0004U,
    PA_SINK_NETWORK = 0x0008U,
    PA_SINK_HW_MUTE_CTRL = 0x0010U,
    PA_SINK_DECIBEL_VOLUME = 0x0020U,
    PA_SINK_FLAT_VOLUME = 0x0040U,
    PA_SINK_DYNAMIC_LATENCY = 0x0080U,
    PA_SINK_SET_FORMATS = 0x0100U,
#ifdef __INCLUDED_FROM_PULSE_AUDIO

    /* PRIVATE: Server-side values -- do not try to use these at client-side.
     * The server will filter out these flags anyway, so you should never see
     * these flags in sinks. */

    PA_SINK_SHARE_VOLUME_WITH_MASTER = 0x1000000U,
    PA_SINK_DEFERRED_VOLUME = 0x2000000U,
#endif

} pa_sink_flags_t;

#define PA_SINK_HW_VOLUME_CTRL PA_SINK_HW_VOLUME_CTRL
#define PA_SINK_LATENCY PA_SINK_LATENCY
#define PA_SINK_HARDWARE PA_SINK_HARDWARE
#define PA_SINK_NETWORK PA_SINK_NETWORK
#define PA_SINK_HW_MUTE_CTRL PA_SINK_HW_MUTE_CTRL
#define PA_SINK_DECIBEL_VOLUME PA_SINK_DECIBEL_VOLUME
#define PA_SINK_FLAT_VOLUME PA_SINK_FLAT_VOLUME
#define PA_SINK_DYNAMIC_LATENCY PA_SINK_DYNAMIC_LATENCY
#define PA_SINK_SET_FORMATS PA_SINK_SET_FORMATS
#ifdef __INCLUDED_FROM_PULSE_AUDIO
#define PA_SINK_CLIENT_FLAGS_MASK 0xFFFFFF
#endif

typedef enum pa_sink_state { /* enum serialized in u8 */
    PA_SINK_INVALID_STATE = -1,
    PA_SINK_RUNNING = 0,
    PA_SINK_IDLE = 1,
    PA_SINK_SUSPENDED = 2,
    /* PRIVATE: Server-side values -- DO NOT USE THIS ON THE CLIENT
     * SIDE! These values are *not* considered part of the official PA
     * API/ABI. If you use them your application might break when PA
     * is upgraded. Also, please note that these values are not useful
     * on the client side anyway. */

    PA_SINK_INIT = -2,
    PA_SINK_UNLINKED = -3
} pa_sink_state_t;

static inline int PA_SINK_IS_OPENED(pa_sink_state_t x) {
    return x == PA_SINK_RUNNING || x == PA_SINK_IDLE;
}

static inline int PA_SINK_IS_RUNNING(pa_sink_state_t x) {
    return x == PA_SINK_RUNNING;
}

#define PA_SINK_INVALID_STATE PA_SINK_INVALID_STATE
#define PA_SINK_RUNNING PA_SINK_RUNNING
#define PA_SINK_IDLE PA_SINK_IDLE
#define PA_SINK_SUSPENDED PA_SINK_SUSPENDED
#define PA_SINK_INIT PA_SINK_INIT
#define PA_SINK_UNLINKED PA_SINK_UNLINKED
#define PA_SINK_IS_OPENED PA_SINK_IS_OPENED

typedef enum pa_source_flags {
    PA_SOURCE_NOFLAGS = 0x0000U,
    PA_SOURCE_HW_VOLUME_CTRL = 0x0001U,
    PA_SOURCE_LATENCY = 0x0002U,
    PA_SOURCE_HARDWARE = 0x0004U,
    PA_SOURCE_NETWORK = 0x0008U,
    PA_SOURCE_HW_MUTE_CTRL = 0x0010U,
    PA_SOURCE_DECIBEL_VOLUME = 0x0020U,
    PA_SOURCE_DYNAMIC_LATENCY = 0x0040U,
    PA_SOURCE_FLAT_VOLUME = 0x0080U,
#ifdef __INCLUDED_FROM_PULSE_AUDIO

    /* PRIVATE: Server-side values -- do not try to use these at client-side.
     * The server will filter out these flags anyway, so you should never see
     * these flags in sources. */

    PA_SOURCE_SHARE_VOLUME_WITH_MASTER = 0x1000000U,
    PA_SOURCE_DEFERRED_VOLUME = 0x2000000U,
#endif
} pa_source_flags_t;

#define PA_SOURCE_HW_VOLUME_CTRL PA_SOURCE_HW_VOLUME_CTRL
#define PA_SOURCE_LATENCY PA_SOURCE_LATENCY
#define PA_SOURCE_HARDWARE PA_SOURCE_HARDWARE
#define PA_SOURCE_NETWORK PA_SOURCE_NETWORK
#define PA_SOURCE_HW_MUTE_CTRL PA_SOURCE_HW_MUTE_CTRL
#define PA_SOURCE_DECIBEL_VOLUME PA_SOURCE_DECIBEL_VOLUME
#define PA_SOURCE_DYNAMIC_LATENCY PA_SOURCE_DYNAMIC_LATENCY
#define PA_SOURCE_FLAT_VOLUME PA_SOURCE_FLAT_VOLUME
#ifdef __INCLUDED_FROM_PULSE_AUDIO
#define PA_SOURCE_CLIENT_FLAGS_MASK 0xFFFFFF
#endif

typedef enum pa_source_state {
    PA_SOURCE_INVALID_STATE = -1,
    PA_SOURCE_RUNNING = 0,
    PA_SOURCE_IDLE = 1,
    PA_SOURCE_SUSPENDED = 2,
    /* PRIVATE: Server-side values -- DO NOT USE THIS ON THE CLIENT
     * SIDE! These values are *not* considered part of the official PA
     * API/ABI. If you use them your application might break when PA
     * is upgraded. Also, please note that these values are not useful
     * on the client side anyway. */

    PA_SOURCE_INIT = -2,
    PA_SOURCE_UNLINKED = -3
} pa_source_state_t;

static inline int PA_SOURCE_IS_OPENED(pa_source_state_t x) {
    return x == PA_SOURCE_RUNNING || x == PA_SOURCE_IDLE;
}

static inline int PA_SOURCE_IS_RUNNING(pa_source_state_t x) {
    return x == PA_SOURCE_RUNNING;
}

#define PA_SOURCE_INVALID_STATE PA_SOURCE_INVALID_STATE
#define PA_SOURCE_RUNNING PA_SOURCE_RUNNING
#define PA_SOURCE_IDLE PA_SOURCE_IDLE
#define PA_SOURCE_SUSPENDED PA_SOURCE_SUSPENDED
#define PA_SOURCE_INIT PA_SOURCE_INIT
#define PA_SOURCE_UNLINKED PA_SOURCE_UNLINKED
#define PA_SOURCE_IS_OPENED PA_SOURCE_IS_OPENED

typedef void (*pa_free_cb_t)(void *p);

#define PA_STREAM_EVENT_REQUEST_CORK "request-cork"

#define PA_STREAM_EVENT_REQUEST_UNCORK "request-uncork"

#define PA_STREAM_EVENT_FORMAT_LOST "format-lost"

#ifndef __INCLUDED_FROM_PULSE_AUDIO

typedef enum pa_port_available {
    PA_PORT_AVAILABLE_UNKNOWN = 0, 
    PA_PORT_AVAILABLE_NO = 1,      
    PA_PORT_AVAILABLE_YES = 2,     
} pa_port_available_t;

#define PA_PORT_AVAILABLE_UNKNOWN PA_PORT_AVAILABLE_UNKNOWN
#define PA_PORT_AVAILABLE_NO PA_PORT_AVAILABLE_NO
#define PA_PORT_AVAILABLE_YES PA_PORT_AVAILABLE_YES

#endif

PA_C_DECL_END

#endif