introspect.h

Go to the documentation of this file.

#ifndef foointrospecthfoo
#define foointrospecthfoo
 
/***
  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
  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 <pulse/operation.h>
#include <pulse/context.h>
#include <pulse/cdecl.h>
#include <pulse/gccmacro.h>
#include <pulse/channelmap.h>
#include <pulse/volume.h>
#include <pulse/proplist.h>
#include <pulse/format.h>
#include <pulse/version.h>


 
PA_C_DECL_BEGIN


typedef struct pa_sink_port_info {
    const char *name;                   
    const char *description;            
    uint32_t priority;                  
    int available;                      
} pa_sink_port_info;

typedef struct pa_sink_info {
    const char *name;                  
    uint32_t index;                    
    const char *description;           
    pa_sample_spec sample_spec;        
    pa_channel_map channel_map;        
    uint32_t owner_module;             
    pa_cvolume volume;                 
    int mute;                          
    uint32_t monitor_source;           
    const char *monitor_source_name;   
    pa_usec_t latency;                 
    const char *driver;                
    pa_sink_flags_t flags;             
    pa_proplist *proplist;             
    pa_usec_t configured_latency;      
    pa_volume_t base_volume;           
    pa_sink_state_t state;             
    uint32_t n_volume_steps;           
    uint32_t card;                     
    uint32_t n_ports;                  
    pa_sink_port_info** ports;         
    pa_sink_port_info* active_port;    
    uint8_t n_formats;                 
    pa_format_info **formats;          
} pa_sink_info;

typedef void (*pa_sink_info_cb_t)(pa_context *c, const pa_sink_info *i, int eol, void *userdata);

pa_operation* pa_context_get_sink_info_by_name(pa_context *c, const char *name, pa_sink_info_cb_t cb, void *userdata);

pa_operation* pa_context_get_sink_info_by_index(pa_context *c, uint32_t idx, pa_sink_info_cb_t cb, void *userdata);

pa_operation* pa_context_get_sink_info_list(pa_context *c, pa_sink_info_cb_t cb, void *userdata);

pa_operation* pa_context_set_sink_volume_by_index(pa_context *c, uint32_t idx, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_set_sink_volume_by_name(pa_context *c, const char *name, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_set_sink_mute_by_index(pa_context *c, uint32_t idx, int mute, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_set_sink_mute_by_name(pa_context *c, const char *name, int mute, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_suspend_sink_by_name(pa_context *c, const char *sink_name, int suspend, pa_context_success_cb_t cb, void* userdata);

pa_operation* pa_context_suspend_sink_by_index(pa_context *c, uint32_t idx, int suspend,  pa_context_success_cb_t cb, void* userdata);

pa_operation* pa_context_set_sink_port_by_index(pa_context *c, uint32_t idx, const char*port, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_set_sink_port_by_name(pa_context *c, const char*name, const char*port, pa_context_success_cb_t cb, void *userdata);



typedef struct pa_source_port_info {
    const char *name;                   
    const char *description;            
    uint32_t priority;                  
    int available;                      
} pa_source_port_info;

typedef struct pa_source_info {
    const char *name;                   
    uint32_t index;                     
    const char *description;            
    pa_sample_spec sample_spec;         
    pa_channel_map channel_map;         
    uint32_t owner_module;              
    pa_cvolume volume;                  
    int mute;                           
    uint32_t monitor_of_sink;           
    const char *monitor_of_sink_name;   
    pa_usec_t latency;                  
    const char *driver;                 
    pa_source_flags_t flags;            
    pa_proplist *proplist;              
    pa_usec_t configured_latency;       
    pa_volume_t base_volume;            
    pa_source_state_t state;            
    uint32_t n_volume_steps;            
    uint32_t card;                      
    uint32_t n_ports;                   
    pa_source_port_info** ports;        
    pa_source_port_info* active_port;   
    uint8_t n_formats;                  
    pa_format_info **formats;           
} pa_source_info;

typedef void (*pa_source_info_cb_t)(pa_context *c, const pa_source_info *i, int eol, void *userdata);

pa_operation* pa_context_get_source_info_by_name(pa_context *c, const char *name, pa_source_info_cb_t cb, void *userdata);

pa_operation* pa_context_get_source_info_by_index(pa_context *c, uint32_t idx, pa_source_info_cb_t cb, void *userdata);

pa_operation* pa_context_get_source_info_list(pa_context *c, pa_source_info_cb_t cb, void *userdata);

pa_operation* pa_context_set_source_volume_by_index(pa_context *c, uint32_t idx, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_set_source_volume_by_name(pa_context *c, const char *name, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_set_source_mute_by_index(pa_context *c, uint32_t idx, int mute, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_set_source_mute_by_name(pa_context *c, const char *name, int mute, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_suspend_source_by_name(pa_context *c, const char *source_name, int suspend, pa_context_success_cb_t cb, void* userdata);

pa_operation* pa_context_suspend_source_by_index(pa_context *c, uint32_t idx, int suspend, pa_context_success_cb_t cb, void* userdata);

pa_operation* pa_context_set_source_port_by_index(pa_context *c, uint32_t idx, const char*port, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_set_source_port_by_name(pa_context *c, const char*name, const char*port, pa_context_success_cb_t cb, void *userdata);



typedef struct pa_server_info {
    const char *user_name;              
    const char *host_name;              
    const char *server_version;         
    const char *server_name;            
    pa_sample_spec sample_spec;         
    const char *default_sink_name;      
    const char *default_source_name;    
    uint32_t cookie;                    
    pa_channel_map channel_map;         
} pa_server_info;

typedef void (*pa_server_info_cb_t) (pa_context *c, const pa_server_info*i, void *userdata);

pa_operation* pa_context_get_server_info(pa_context *c, pa_server_info_cb_t cb, void *userdata);



typedef struct pa_module_info {
    uint32_t index;                     
    const char*name,                    
        *argument;                      
    uint32_t n_used;                    
    int auto_unload;                    
    pa_proplist *proplist;              
} pa_module_info;

typedef void (*pa_module_info_cb_t) (pa_context *c, const pa_module_info*i, int eol, void *userdata);

pa_operation* pa_context_get_module_info(pa_context *c, uint32_t idx, pa_module_info_cb_t cb, void *userdata);

pa_operation* pa_context_get_module_info_list(pa_context *c, pa_module_info_cb_t cb, void *userdata);

typedef void (*pa_context_index_cb_t)(pa_context *c, uint32_t idx, void *userdata);

pa_operation* pa_context_load_module(pa_context *c, const char*name, const char *argument, pa_context_index_cb_t cb, void *userdata);

pa_operation* pa_context_unload_module(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata);



typedef struct pa_client_info {
    uint32_t index;                      
    const char *name;                    
    uint32_t owner_module;               
    const char *driver;                  
    pa_proplist *proplist;               
} pa_client_info;

typedef void (*pa_client_info_cb_t) (pa_context *c, const pa_client_info*i, int eol, void *userdata);

pa_operation* pa_context_get_client_info(pa_context *c, uint32_t idx, pa_client_info_cb_t cb, void *userdata);

pa_operation* pa_context_get_client_info_list(pa_context *c, pa_client_info_cb_t cb, void *userdata);

pa_operation* pa_context_kill_client(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata);



typedef struct pa_card_profile_info {
    const char *name;                   
    const char *description;            
    uint32_t n_sinks;                   
    uint32_t n_sources;                 
    uint32_t priority;                  
} pa_card_profile_info;

typedef struct pa_card_profile_info2 {
    const char *name;                   
    const char *description;            
    uint32_t n_sinks;                   
    uint32_t n_sources;                 
    uint32_t priority;                  
    int available;
} pa_card_profile_info2;

typedef struct pa_card_port_info {
    const char *name;                   
    const char *description;            
    uint32_t priority;                  
    int available;                      
    int direction;                      
    uint32_t n_profiles;                
    pa_card_profile_info** profiles;    
    pa_proplist *proplist;              
    int64_t latency_offset;             
    pa_card_profile_info2** profiles2;  
} pa_card_port_info;

typedef struct pa_card_info {
    uint32_t index;                      
    const char *name;                    
    uint32_t owner_module;               
    const char *driver;                  
    uint32_t n_profiles;                 
    pa_card_profile_info* profiles;      
    pa_card_profile_info* active_profile; 
    pa_proplist *proplist;               
    uint32_t n_ports;                    
    pa_card_port_info **ports;           
    pa_card_profile_info2** profiles2;    
    pa_card_profile_info2* active_profile2; 
} pa_card_info;

typedef void (*pa_card_info_cb_t) (pa_context *c, const pa_card_info*i, int eol, void *userdata);

pa_operation* pa_context_get_card_info_by_index(pa_context *c, uint32_t idx, pa_card_info_cb_t cb, void *userdata);

pa_operation* pa_context_get_card_info_by_name(pa_context *c, const char *name, pa_card_info_cb_t cb, void *userdata);

pa_operation* pa_context_get_card_info_list(pa_context *c, pa_card_info_cb_t cb, void *userdata);

pa_operation* pa_context_set_card_profile_by_index(pa_context *c, uint32_t idx, const char*profile, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_set_card_profile_by_name(pa_context *c, const char*name, const char*profile, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_set_port_latency_offset(pa_context *c, const char *card_name, const char *port_name, int64_t offset, pa_context_success_cb_t cb, void *userdata);



typedef struct pa_sink_input_info {
    uint32_t index;                      
    const char *name;                    
    uint32_t owner_module;               
    uint32_t client;                     
    uint32_t sink;                       
    pa_sample_spec sample_spec;          
    pa_channel_map channel_map;          
    pa_cvolume volume;                   
    pa_usec_t buffer_usec;               
    pa_usec_t sink_usec;                 
    const char *resample_method;         
    const char *driver;                  
    int mute;                            
    pa_proplist *proplist;               
    int corked;                          
    int has_volume;                      
    int volume_writable;                 
    pa_format_info *format;              
} pa_sink_input_info;

typedef void (*pa_sink_input_info_cb_t) (pa_context *c, const pa_sink_input_info *i, int eol, void *userdata);

pa_operation* pa_context_get_sink_input_info(pa_context *c, uint32_t idx, pa_sink_input_info_cb_t cb, void *userdata);

pa_operation* pa_context_get_sink_input_info_list(pa_context *c, pa_sink_input_info_cb_t cb, void *userdata);

pa_operation* pa_context_move_sink_input_by_name(pa_context *c, uint32_t idx, const char *sink_name, pa_context_success_cb_t cb, void* userdata);

pa_operation* pa_context_move_sink_input_by_index(pa_context *c, uint32_t idx, uint32_t sink_idx, pa_context_success_cb_t cb, void* userdata);

pa_operation* pa_context_set_sink_input_volume(pa_context *c, uint32_t idx, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_set_sink_input_mute(pa_context *c, uint32_t idx, int mute, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_kill_sink_input(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata);



typedef struct pa_source_output_info {
    uint32_t index;                      
    const char *name;                    
    uint32_t owner_module;               
    uint32_t client;                     
    uint32_t source;                     
    pa_sample_spec sample_spec;          
    pa_channel_map channel_map;          
    pa_usec_t buffer_usec;               
    pa_usec_t source_usec;               
    const char *resample_method;         
    const char *driver;                  
    pa_proplist *proplist;               
    int corked;                          
    pa_cvolume volume;                   
    int mute;                            
    int has_volume;                      
    int volume_writable;                 
    pa_format_info *format;              
} pa_source_output_info;

typedef void (*pa_source_output_info_cb_t) (pa_context *c, const pa_source_output_info *i, int eol, void *userdata);

pa_operation* pa_context_get_source_output_info(pa_context *c, uint32_t idx, pa_source_output_info_cb_t cb, void *userdata);

pa_operation* pa_context_get_source_output_info_list(pa_context *c, pa_source_output_info_cb_t cb, void *userdata);

pa_operation* pa_context_move_source_output_by_name(pa_context *c, uint32_t idx, const char *source_name, pa_context_success_cb_t cb, void* userdata);

pa_operation* pa_context_move_source_output_by_index(pa_context *c, uint32_t idx, uint32_t source_idx, pa_context_success_cb_t cb, void* userdata);

pa_operation* pa_context_set_source_output_volume(pa_context *c, uint32_t idx, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_set_source_output_mute(pa_context *c, uint32_t idx, int mute, pa_context_success_cb_t cb, void *userdata);

pa_operation* pa_context_kill_source_output(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata);



typedef struct pa_stat_info {
    uint32_t memblock_total;           
    uint32_t memblock_total_size;      
    uint32_t memblock_allocated;       
    uint32_t memblock_allocated_size;  
    uint32_t scache_size;              
} pa_stat_info;

typedef void (*pa_stat_info_cb_t) (pa_context *c, const pa_stat_info *i, void *userdata);

pa_operation* pa_context_stat(pa_context *c, pa_stat_info_cb_t cb, void *userdata);



typedef struct pa_sample_info {
    uint32_t index;                       
    const char *name;                     
    pa_cvolume volume;                    
    pa_sample_spec sample_spec;           
    pa_channel_map channel_map;           
    pa_usec_t duration;                   
    uint32_t bytes;                       
    int lazy;                             
    const char *filename;                 
    pa_proplist *proplist;                
} pa_sample_info;

typedef void (*pa_sample_info_cb_t)(pa_context *c, const pa_sample_info *i, int eol, void *userdata);

pa_operation* pa_context_get_sample_info_by_name(pa_context *c, const char *name, pa_sample_info_cb_t cb, void *userdata);

pa_operation* pa_context_get_sample_info_by_index(pa_context *c, uint32_t idx, pa_sample_info_cb_t cb, void *userdata);

pa_operation* pa_context_get_sample_info_list(pa_context *c, pa_sample_info_cb_t cb, void *userdata);




typedef enum pa_autoload_type {
    PA_AUTOLOAD_SINK = 0,
    PA_AUTOLOAD_SOURCE = 1
} pa_autoload_type_t;

typedef struct pa_autoload_info {
    uint32_t index;               
    const char *name;             
    pa_autoload_type_t type;      
    const char *module;           
    const char *argument;         
} pa_autoload_info;

typedef void (*pa_autoload_info_cb_t)(pa_context *c, const pa_autoload_info *i, int eol, void *userdata);

pa_operation* pa_context_get_autoload_info_by_name(pa_context *c, const char *name, pa_autoload_type_t type, pa_autoload_info_cb_t cb, void *userdata) PA_GCC_DEPRECATED;

pa_operation* pa_context_get_autoload_info_by_index(pa_context *c, uint32_t idx, pa_autoload_info_cb_t cb, void *userdata) PA_GCC_DEPRECATED;

pa_operation* pa_context_get_autoload_info_list(pa_context *c, pa_autoload_info_cb_t cb, void *userdata) PA_GCC_DEPRECATED;

pa_operation* pa_context_add_autoload(pa_context *c, const char *name, pa_autoload_type_t type, const char *module, const char*argument, pa_context_index_cb_t, void* userdata) PA_GCC_DEPRECATED;

pa_operation* pa_context_remove_autoload_by_name(pa_context *c, const char *name, pa_autoload_type_t type, pa_context_success_cb_t cb, void* userdata) PA_GCC_DEPRECATED;

pa_operation* pa_context_remove_autoload_by_index(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void* userdata) PA_GCC_DEPRECATED;


 
PA_C_DECL_END
 
#endif