source: svn/newcon3bcm2_21bu/BSEAV/api/build/proxy/bsettop_autogen_thunks.c

/*********************************
*
* This file is autogenerated. Rebuild with BSEAV/api/build/proxy/autogen.
*
* This file acquires b_lock for every function call into the Settop API. The actual impl of each function is remapped to _impl.
*
*********************************/
#define BSETTOP_NO_API_THUNKS
#include "bsettop_impl.h"

bdisplay_t bdisplay_open_impl(
    bobject_t display_id 
    );
void bdisplay_close_impl(
    bdisplay_t display 
    );
bresult boutput_rf_set_impl(boutput_rf_t rf,
    const boutput_rf_settings *settings);
void boutput_rf_get_impl(boutput_rf_t rf,
    boutput_rf_settings *settings 
    );
bresult boutput_hdmi_set_impl(boutput_hdmi_t dvi,
    const boutput_hdmi_settings *settings);
void boutput_hdmi_get_impl(boutput_hdmi_t dvi,
    boutput_hdmi_settings *settings 
    );
bresult boutput_hdmi_get_capabilities_impl(boutput_hdmi_t dvi,
                                     boutput_hdmi_capabilities *caps 
                                     );
bresult boutput_hdmi_get_status_impl(boutput_hdmi_t dvi,
                                boutput_hdmi_status *status 
                                     );
bresult boutput_hdmi_cec_get_message_impl(boutput_hdmi_t dvi,
                                boutput_hdmi_cec_message_data *cec_message_data 
                                );
bresult boutput_hdmi_cec_send_message_impl(boutput_hdmi_t dvi,
                                const boutput_hdmi_cec_message_data *cec_message_data
                                );
bresult boutput_hdmi_cec_get_configuration_impl(boutput_hdmi_t dvi,
                                boutput_hdmi_cec_configuration *cec_configuration   
                                );
bool boutput_hdmi_cec_is_device_ready_impl(boutput_hdmi_t dvi);
bresult boutput_hdmi_cec_enable_receive_impl(boutput_hdmi_t dvi);
bresult boutput_component_set_impl(boutput_component_t component,
    const boutput_component_settings *settings);
void boutput_component_get_impl(boutput_component_t component,
    boutput_component_settings *settings 
    );
bresult boutput_spdif_set_impl(boutput_spdif_t spdif,
    const boutput_spdif_settings *settings);
void boutput_spdif_get_impl(boutput_spdif_t spdif,
    boutput_spdif_settings *settings 
    );
boutput_spdif_t
boutput_spdif_open_impl(bobject_t spdif_id);
boutput_rf_t
boutput_rf_open_impl(bobject_t rfmod_id);
boutput_composite_t
boutput_composite_open_impl(bobject_t composite_id);
boutput_svideo_t
boutput_svideo_open_impl(bobject_t svideo_id);
boutput_hdmi_t
boutput_hdmi_open_impl(bobject_t dvi_id);
boutput_component_t
boutput_component_open_impl(bobject_t component_id);
void bdisplay_get_video_format_settings_impl(
    const bdisplay_settings *settings,
    bvideo_format_settings *format_settings 
    );
void bvideo_get_format_settings_impl(
    bvideo_format format,           
    bvideo_format_settings *settings    
    );
bresult
bdisplay_set_impl(
    bdisplay_t display, 
    const bdisplay_settings *settings   
    );
void
bdisplay_get_impl(
    bdisplay_t display, 
    bdisplay_settings *settings 
    );
bdecode_window_t bdecode_window_open_impl(
    bobject_t window_id, 
    bdisplay_t display 
    );
bdecode_window_t bdecode_window_open_mosaic_impl(
    bdecode_window_t parent_window, 
    bobject_t mosaic_id 
    );
void
bdecode_window_close_impl(
    bdecode_window_t window
    );
bdecode_window_t bdecode_window_clone_impl(
            bdecode_window_t window, 
            bobject_t clone_window_id, 
            bdisplay_t display 
        );
bresult bdisplay_set_dac_audio_volume_impl(
    bdisplay_t display,     
    const baudio_volume *volume 
    );
bresult bdisplay_get_dac_audio_volume_impl(
    bdisplay_t display,     
    baudio_volume *volume   
    );
bresult boutput_rf_set_audio_volume_impl(
    boutput_rf_t rf,
    const baudio_volume *volume 
    );
bresult boutput_spdif_set_audio_volume_impl(
    boutput_spdif_t spdif,
    const baudio_volume *volume 
    );
bresult boutput_spdif_get_audio_volume_impl(
    boutput_spdif_t spdif,
    baudio_volume *volume 
    );
bresult boutput_rf_get_audio_volume_impl(
    boutput_rf_t rf,
    baudio_volume *volume   
    );
bresult bdecode_window_get_impl(
    bdecode_window_t window,
    bdecode_window_settings *settings   
    );
bresult bdecode_window_set_impl(
    bdecode_window_t window,
    const bdecode_window_settings *settings
    );
bmessage_stream_t bmessage_open_impl(
        bmessage_format format
        );
void bmessage_stream_params_init_impl(
        bmessage_stream_params *params,
        bmessage_stream_t stream);
bresult bmessage_start_impl(
        bmessage_stream_t message_stream,
        const bmessage_stream_params *params
        );
bresult bmessage_get_buffer_impl(
        bmessage_stream_t message_stream, 
        const void ** p_bfr,                    
        size_t *length
        );
bresult bmessage_read_complete_impl(
        bmessage_stream_t message_stream, 
        size_t amount_consumed
        );
void bmessage_stop_impl(
        bmessage_stream_t message_stream 
        );
void bmessage_close_impl(
        bmessage_stream_t message_stream 
        );
void brecpump_get_open_params_impl(
                bobject_t id, 
                brecpump_open_params *open_params 
                );
brecpump_t brecpump_open_impl(
                bobject_t id, 
                const brecpump_open_params *open_params 
                );
void brecpump_close_impl(brecpump_t recpump);
void brecpump_params_init_impl(
        brecpump_params *params, 
        brecpump_t recpump
        );
bresult brecpump_start_impl(
        brecpump_t recpump,
        bstream_t stream,
        const brecpump_params *params
        );
bresult brecpump_stop_impl(
        brecpump_t recpump
        );
void brecpump_immediate_stop_impl(
        brecpump_t recpump
        );
bresult brecpump_data_get_buffer_impl(
        brecpump_t recpump,
        const void **buffer, 
        size_t *buffer_size 
        );
bresult brecpump_index_get_buffer_impl(
        brecpump_t recpump,
        const void **buffer, 
        size_t *buffer_size 
        );
bresult brecpump_data_write_complete_impl(
        brecpump_t recpump,
        size_t amount_written
        );
bresult brecpump_index_write_complete_impl(
        brecpump_t recpump,
        size_t amount_written
        );
void brecpump_get_status_impl(
        brecpump_t recpump,
        brecpump_status *status 
        );
bcipher_t bcipher_open_impl(
        bobject_t id
        );
void bcipher_close_impl(bcipher_t encrypt);
void bcipher_settings_init_impl(
        bcipher_settings *settings,     
        bcipher_t cipher                        
        );
bresult
bcipher_convert_data_impl(
        bcipher_t handle,               
        void *dest ,
        const void *source ,
        size_t datalen,                 
        const bcipher_settings *settings 
        );
bencode_t bencode_open_impl(
                bobject_t id 
                );
void bencode_close_impl(
                bencode_t encode 
                );
void bencode_extended_settings_init_impl(
        bencode_settings *settings,     
        bencode_quality quality,        
        bencode_t encode,               
        bencode_vpp_mode vpp_mode       
        );
void bencode_settings_init_impl(
        bencode_settings *settings, 
        bencode_quality quality,        
        bencode_t encode                        
        );
bstream_t bencode_start_impl(
        bencode_t encode, 
        bstream_t stream, 
        const bencode_settings *settings 
        );
void bencode_stop_impl(
        bencode_t encode,       
        bstream_t stream        
        );
void bpcm_play_settings_init_impl(
        bpcm_play_settings *settings,   
        bpcm_play_t pcmplay             
        );
bpcm_play_t bpcm_play_open_impl(
        bobject_t id                            
        );
void bpcm_play_close_impl(
        bpcm_play_t pcmplay
        );
bresult bpcm_play_start_impl(
        bpcm_play_t pcmplay,
        bdisplay_t display,                                     
        const bpcm_play_settings *settings
        );
bresult bpcm_play_get_status_impl(
        bpcm_play_t pcmplay,
        bpcm_play_status *status 
        );
bresult bpcm_play_get_buffer_impl(
        bpcm_play_t pcmplay,
        void **data,
        size_t *length
        );
bresult bpcm_play_write_complete_impl(
        bpcm_play_t pcmplay,
        size_t amount_written
        );
bresult bpcm_play_stop_impl(
        bpcm_play_t pcmplay
        );
void bpcm_play_get_output_settings_impl(
    bpcm_play_t pcmplay,
    bpcm_play_output_settings *settings 
    );
bresult bpcm_play_set_output_settings_impl(
    bpcm_play_t pcmplay,
    const bpcm_play_output_settings *settings
    );
void bpcm_capture_settings_init_impl(
    bpcm_capture_settings *settings,    
    bpcm_capture_t pcmcapture           
);
bpcm_capture_t bpcm_capture_open_impl(
    bobject_t id                                
);
void bpcm_capture_close_impl(
    bpcm_capture_t pcmcapture
);
bresult bpcm_capture_start_impl(
    bpcm_capture_t pcmcapture,
    bdisplay_t display,                                 
    const bpcm_capture_settings *settings
);
bresult bpcm_capture_get_buffer_impl(
    bpcm_capture_t pcmcapture,
    void **data,
    size_t *length
);
bresult bpcm_capture_read_complete_impl(
    bpcm_capture_t pcmcapture,
    size_t amount_read
);
bresult bpcm_capture_stop_impl(
    bpcm_capture_t pcmcapture
);
void bsmartcard_settings_init_impl(
        bsmartcard_settings_t *settings
);
bsmartcard_t bsmartcard_open_impl(
        bobject_t smartcard_id, 
        const bsmartcard_settings_t *settings 
);
void bsmartcard_close_impl(
        bsmartcard_t smartcard 
);
void bsmartcard_get_settings_impl(
    bsmartcard_t smartcard,
    bsmartcard_settings_t *settings
);
bresult bsmartcard_set_settings_impl(
    bsmartcard_t smartcard,
    const bsmartcard_settings_t *settings
);
bresult bsmartcard_read_impl(
        bsmartcard_t smartcard, 
        void *data ,
        size_t length,                  
        size_t *length_read             
);
bresult bsmartcard_write_impl(
        bsmartcard_t smartcard, 
        const void *data ,
        size_t length,                  
        size_t *length_written  
);
bresult bsmartcard_get_status_impl(
        bsmartcard_t smartcard,
        bsmartcard_status *status               
);
bresult bsmartcard_reset_card_impl(
        bsmartcard_t smartcard, 
        void *data ,
        size_t length,                  
        size_t *length_read             
);
bresult bsmartcard_reset_impl(
        bsmartcard_t smartcard, 
        bool warm_reset 
);
bresult bsmartcard_detect_card_impl( 
                bsmartcard_t smartcard
);
bresult bsmartcard_init_impl(void);
void bsmartcard_shutdown_impl(void);
buser_input_t buser_input_open_impl(
                     bobject_t user_input_id 
                    );
void buser_input_close_impl(
        buser_input_t ui 
    );
void buser_input_get_settings_impl(
        buser_input_t ui,
        buser_input_settings *settings);
void buser_input_set_settings_impl(
        buser_input_t ui,
        const buser_input_settings *settings);
bresult buser_input_get_event_impl(
        buser_input_t ui, 
        buser_input_event *event ,
        unsigned nevents, 
        unsigned *result_nevents 
        );
buser_output_t buser_output_open_impl(
        bobject_t user_output_id 
        );
void buser_output_close_impl(
        buser_output_t uo 
        );
bresult buser_output_set_led_impl(
        buser_output_t ui, 
        unsigned led, 
        bool on                 
        );
bresult buser_output_display_message_impl(
        buser_output_t ui, 
        const char *message     
        );
void buser_input_set_xmp_settings_impl(
        buser_input_t ui,
        const buser_input_xmp_settings *settings);
void buser_input_get_xmp_settings_impl(
        buser_input_t ui,
        buser_input_xmp_settings *settings);
bresult buser_input_send_xmp_impl(
        buser_input_t remote, 
        const uint8_t *input_buffer ,
        size_t length 
        );
bresult buser_input_receive_xmp_impl(
        buser_input_t remote, 
        uint8_t *output_data ,
        size_t length,
        unsigned *output_size,
        uint32_t *data_packet
        );
bgraphics_t bgraphics_open_impl(
        bobject_t id,
        bdisplay_t display      
        );
void bgraphics_close_impl(
        bgraphics_t graphics    
        );
void bgraphics_get_impl(
        bgraphics_t graphics,   
        bgraphics_settings *settings 
        );
bresult bgraphics_set_impl(
        bgraphics_t graphics,   
        const bgraphics_settings *settings
        );
bresult bgraphics_sync_impl(
        bgraphics_t graphics    
        );
bresult bsurface_sync_impl(
        bsurface_t surface      
        );
bresult bgraphics_flip_impl(
        bgraphics_t graphics    
        );
bresult bgraphics_flip_sync_impl(
        bgraphics_t graphics    
        );
void bsurface_create_settings_init_impl(
        bsurface_create_settings *create_settings,      
        bgraphics_t graphics            
        );
bsurface_t bgraphics_create_framebuffer_impl(
        bgraphics_t graphics,   
        const bsurface_create_settings *create_settings,
        unsigned int back_buffer_count 
        );
bsurface_t bsurface_create_impl(
        bgraphics_t graphics,   
        const bsurface_create_settings *create_settings
        );
bsurface_t bsurface_get_display_impl(
        bgraphics_t graphics,   
        const bsurface_create_settings *create_settings
        );
void bsurface_destroy_impl(
        bsurface_t surface      
        );
bresult bsurface_get_memory_impl(
        bsurface_t s,
        bsurface_memory *memory 
        );
bresult bsurface_set_impl(
        bsurface_t s,
        const bsurface_settings *settings
        );
void bsurface_get_impl(
        bsurface_t s,
        bsurface_settings *settings 
        );
bresult bsurface_fill_impl(
        bsurface_t surface,             
        const bsettop_rect *rect,       
        bgraphics_pixel pixel 
        );
bresult bsurface_copy_impl(
        bsurface_t destsurface,         
        const bsettop_rect *destrect,    
        bsurface_t srcsurface,          
        const bsettop_rect *srcrect      
        );
bresult bsurface_blit_impl(
        bsurface_t destsurface,                 
        const bsettop_rect *destrect,   
        uint32_t operation,                             
        bsurface_t src1,                                
        const bsettop_rect *src1_rect,  
        bsurface_t src2,                                
        const bsettop_rect *src2_rect,  
        bgraphics_pixel pixel1,                 
        bgraphics_pixel pixel2                  
        );
void bsurface_blit_params_init_impl(bsurface_blit_params *params);
bresult bsurface_extended_blit_impl(
        bsurface_t destsurface,
        const bsettop_rect *destrect,
        const bsurface_blit_params *params
        );
bresult
bsurface_blended_fill_impl(
        bsurface_t surface,         
        const bsettop_rect *rect,   
        bgraphics_pixel pixel,      
        uint32_t operation         

        );
bresult bsurface_load_clut_impl(
        bsurface_t s,
        bgraphics_palette palette);
void bplaypump_get_open_params_impl(
                bobject_t id, 
                bplaypump_open_params *open_params 
                );
bplaypump_t bplaypump_open_impl(
                bobject_t id,
                const bplaypump_open_params *open_params 
                );
void bplaypump_close_impl(bplaypump_t playpump);
void bplaypump_params_init_impl(
        bplaypump_params *params, 
        bplaypump_t playpump
        );
bstream_t bplaypump_start_impl(
        bplaypump_t playpump,
        const bstream_mpeg *mpeg, 
        const bplaypump_params *params
        );
bresult bplaypump_stop_impl(
        bplaypump_t playpump
        );
bresult bplaypump_get_buffer_impl(
        bplaypump_t playpump,
        void **buffer, 
        size_t *size 
        );
bresult bplaypump_read_complete_impl(
        bplaypump_t playpump,
        size_t skip, 
        size_t amount 
        );
bresult bplaypump_set_impl(
        bplaypump_t playpump,
        const bplaypump_settings *settings
        );
void bplaypump_get_impl(
        bplaypump_t playpump,
        bplaypump_settings *settings
        );
bresult bplaypump_set_state_impl(
        bplaypump_t playpump,
        bplaypump_state state,
        bool forward
        );
bresult bplaypump_set_decoder_rate_impl(
        bplaypump_t playpump,
        unsigned rate
        );
bresult bplaypump_frame_advance_impl(
        bplaypump_t playpump
        );
bresult bplaypump_flush_impl(
        bplaypump_t playpump
        );
bresult bplaypump_get_status_impl(
        bplaypump_t p,
        bplaypump_status *status 
        );
bresult bplaypump_p_set_pwm_value_impl(
        bplaypump_t p, 
        int pwm_value);
void bplaypump_get_source_impl(bplaypump_t playpump, bplaypump_source *source);
bresult bplaypump_set_source_impl(bplaypump_t playpump, const bplaypump_source *source);
bresult bplaypump_get_rtp_hdr_data_impl(bplaypump_t p, const bplaypump_rtp_hdr_data_t *rtp_header_data, unsigned *entry_cnt);
void bencryption_params_init_impl(
        bencryption_params *encryption  
);
void bstream_mpeg_init_impl(
        bstream_mpeg *mpeg              
        );
bband_t bstreamer_attach_impl(
        bobject_t id,
        bstream_mpeg_type mpeg_type     
        );
bstream_t bstream_open_impl(
        bband_t band,   
        const bstream_mpeg *mpegparams  
        );
bresult bstream_set_encryption_impl(
        bstream_t stream,
        const bencryption_params *encryption
        );
void bstream_join_impl(bstream_t video_source, bstream_t audio_source);
bstream_t bstream_open_child_impl(bstream_t parent, const bstream_mpeg *mpegparams);
void bstream_close_impl(
        bstream_t stream        
        );
bresult
bstream_get_mpeg_parameters_impl(
        bstream_t stream,
        bstream_status *status  
        );
bresult
bstream_set_mpeg_parameters_impl(
        bstream_t stream,
        const bstream_mpeg *mpeg
        );
void bband_get_impl(
        bband_t band,
        bband_settings *settings 
        );
bresult bstream_start_pcr_monitor_impl(bstream_t stream);
void bstream_stop_pcr_monitor_impl(bstream_t stream);
bresult bstream_get_pcr_status_impl(bstream_t stream, bstream_pcr_status *status);
void bstream_vbi_get_settings_impl(
        bstream_t stream,                                       
        bstream_vbi_settings *settings  
        );
bresult bstream_vbi_set_settings_impl(
        bstream_t stream,                                       
        const bstream_vbi_settings *settings    
        );
bresult bstream_vbi_cc_read_impl(
        bstream_t stream,                       
        bstream_vbi_cc *data ,
        size_t length,                          
        size_t *length_read                     
        );
bresult bstream_vbi_cc708_read_impl(
        bstream_t stream,                       
        bstream_cc_708 *data ,
        size_t length,                          
        size_t *length_read                     
        );
bresult bdisplay_vbi_cc_write_impl(
        bdisplay_t display,                     
        const bstream_vbi_cc *data ,
        size_t length,                          
        size_t *length_written          
        );
bresult bstream_vbi_tt_read_impl(
        bstream_t stream,                       
        bstream_vbi_tt *data ,
        size_t length,                          
        size_t *length_read                     
        );
bresult bdisplay_vbi_tt_write_impl(
        bdisplay_t display,                     
        const bstream_vbi_tt *data ,
        size_t length,                          
    uint8_t polarity             
        );
bresult bdisplay_vbi_set_cgms_impl(
        bdisplay_t display,                     
        uint32_t cgms_value                     
        );
bresult bdisplay_vbi_set_wss_impl(
        bdisplay_t display,                     
        uint16_t wss_value                      
        );
bresult bdisplay_vbi_get_cgms_impl(
        bdisplay_t display,                     
        bool *enabled
        );
bresult bdisplay_vbi_get_wss_impl(
        bdisplay_t display,                     
        bool *enabled
        );
bdecode_t bdecode_open_impl(
    bobject_t decode_id 
    );
void bdecode_mosaic_settings_init_impl(
    bdecode_t parent,                 
    bdecode_mosaic_settings *settings 
    );
bdecode_t bdecode_open_mosaic_impl(
    bdecode_t parent,                       
    bobject_t decode_id,                    
    const bdecode_mosaic_settings *settings 
    );
void bdecode_close_impl(
    bdecode_t decode 
    );
void bdecode_get_impl(
    bdecode_t decode, 
    bdecode_settings *settings 
    );
bresult bdecode_set_impl(
    bdecode_t decode, 
    const bdecode_settings *settings
    );
bresult bdecode_display_surface_impl(
    bdecode_t decode, 
    bsurface_t surface,
    bdecode_window_t window
    );
bresult bdecode_start_impl(
    bdecode_t decode, 
    bstream_t source, 
    bdecode_window_t window 
    );
void bdecode_stop_impl(
    bdecode_t decode 
    );
baudio_decode_t bdecode_detach_audio_impl(
    bdecode_t decode 
    );
bresult bdecode_attach_audio_impl(
    bdecode_t decode, 
    baudio_decode_t audio 
    );
bresult bdecode_set_audio_program_impl(
    bdecode_t decode, 
    unsigned index 
    );
baudio_decode_t bdecode_get_audio_impl(
    bdecode_t decode, 
    bobject_t audio_id 
    );
bvideo_decode_t bdecode_detach_video_impl(
        bdecode_t decode 
    );
bresult bdecode_attach_video_impl(
        bdecode_t decode, 
        bvideo_decode_t video 
    );
bresult bdecode_set_video_program_impl(
        bdecode_t decode, 
        unsigned index 
    );
bvideo_decode_t bdecode_get_video_impl(
    bdecode_t decode, 
    bobject_t video_id 
    );
void baudio_decode_get_status_impl(
    baudio_decode_t audio, 
    baudio_decode_status *status 
    );
void bvideo_decode_get_status_impl(
    bvideo_decode_t video, 
    bvideo_decode_status *status
    );
bresult bdecode_get_status_impl(
    bdecode_t decode,  
    bdecode_status *status  
    );
bresult bdecode_set_audio_volume_impl(
    bdecode_t decode,
    const baudio_volume *volume
    );
bresult bdecode_get_audio_volume_impl(
    bdecode_t decode,
    baudio_volume *volume   
    );
bresult bdecode_get_stc_impl(bdecode_t decode, uint32_t *stc);
bresult bdecode_set_stc_impl(bdecode_t decode, uint32_t stc);
void bdecode_slow_clock_impl(
    bdecode_t decode,
    bool slow
    );
bresult bdecode_read_metadata_impl(
    bdecode_t decode,
    void *buffer ,
    unsigned size, 
    unsigned *amount_read 
    );
bresult bdecode_allocate_capture_buffers_impl(
    bdecode_t decode, 
    unsigned count 
    );
bsurface_t bdecode_acquire_capture_buffer_impl(
    bdecode_t decode,
    bgraphics_t graphics,
    bool *top_field 
    );
bresult bdecode_release_capture_buffer_impl(
    bdecode_t decode, 
    bsurface_t surface
    );
void bsettop_get_power_state_impl(bsettop_power_state *state);
bresult bsettop_set_power_state_impl(const bsettop_power_state *state);
int bsettop_init_frontend_impl(void);
btuner_t btuner_open_impl(
                     bobject_t tuner_id 
                    );
void btuner_close_impl(
                  btuner_t tuner 
                 );
void btuner_qam_params_init_impl(
    btuner_qam_params *qam,     
    btuner_t tuner              
    );
void btuner_ofdm_params_init_impl(
    btuner_ofdm_params *ofdm,    
    btuner_t tuner              
    );
void btuner_analog_params_init_impl(
    btuner_analog_params *analog,   
    btuner_t tuner                  
    );
void btuner_qam_us_params_init_impl(
    btuner_qam_us_params *us_param,     
    btuner_t tuner              
    );
void btuner_sds_params_init_impl(
    btuner_sds_params *sds,     
    btuner_t tuner              
    );
void btuner_vsb_params_init_impl(
    btuner_vsb_params *vsb,     
    btuner_t tuner              
    );
btuner_linein_t btuner_linein_open_impl(bobject_t linein_id);
bband_t btuner_tune_qam_impl(
    btuner_t tuner,
    unsigned freq, 
    const btuner_qam_params *params 
    );
bresult
btuner_tune_oob_impl(
    btuner_t tuner,
    unsigned freq, 
    const btuner_qam_params *params 
    );
bresult
btuner_tune_qam_us_impl(
    btuner_t tuner,
    unsigned freq, 
    const btuner_qam_us_params *params  
    );
bband_t btuner_tune_sds_impl(
    btuner_t tuner,
    unsigned freq, 
    const btuner_sds_params *params 
    );
bband_t btuner_tune_vsb_impl(
    btuner_t tuner,
    unsigned freq, 
    const btuner_vsb_params *params 
    );
bband_t
btuner_tune_ofdm_impl(
    btuner_t tuner, 
    unsigned freq,   
    const btuner_ofdm_params* params 
    );
bstream_t btuner_tune_rf_impl(
    btuner_t tuner,
    unsigned carrierfreq,   
    const btuner_analog_params *params  
    );
bstream_t btuner_tune_linein_impl(
    btuner_t tuner,
    btuner_linein_t linein, 
    const btuner_analog_params *params  
    );
bresult btuner_get_analog_status_impl(
    btuner_t tuner, 
    btuner_analog_status *status    
    );
bresult btuner_get_qam_status_impl(
    btuner_t tuner,
    btuner_qam_status *status   
    );
bresult btuner_get_qam_us_status_impl(
    btuner_t tuner,
    btuner_qam_us_status *status    
    );
bresult btuner_get_sds_status_impl(
    btuner_t tuner,
    btuner_sds_status *status   
    );
bresult btuner_get_vsb_status_impl(
    btuner_t tuner,
    btuner_vsb_status *status   
    );
bresult btuner_get_ofdm_status_impl(
    btuner_t tuner,
    btuner_ofdm_status *status   
    );
bresult btuner_get_soft_decisions_impl(
    btuner_t tuner,
    btuner_soft_decision *data ,
    size_t length 
    );
bmem_ptr bmem_alloc_impl(
        size_t buffer_length
);
void bmem_free_impl(
        void *buffer
);
bcablecard_t bcablecard_open_impl(
        bobject_t cablecard_id 
        );
void bcablecard_close_impl(
        bcablecard_t cablecard 
        );
void bcablecard_get_impl(
        bcablecard_t cablecard,
        bcablecard_settings *settings 
        );
bresult bcablecard_set_impl(
        bcablecard_t cablecard,
        const bcablecard_settings *settings
        );
bresult bcablecard_route_add_tuner_impl(
   bcablecard_t cablecard,
   btuner_t tuner 
   );
bresult bcablecard_route_remove_tuner_impl(
   bcablecard_t cablecard,
   btuner_t tuner 
   );
bresult bcablecard_route_get_impl(
        bcablecard_t cablecard,
        btuner_t tuner, 
        bcablecard_route_settings *settings 
        );
bdisplay_t bdisplay_open(
    bobject_t display_id 
    )
{
  bdisplay_t result;
  b_lock();
  result = bdisplay_open_impl(display_id);
  b_unlock();
  return result;
}

void bdisplay_close(
    bdisplay_t display 
    )
{
  b_lock();
  bdisplay_close_impl(display);
  b_unlock();
  return;
}

bresult boutput_rf_set(boutput_rf_t rf,
    const boutput_rf_settings *settings)
{
  bresult result;
  b_lock();
  result = boutput_rf_set_impl(rf, settings);
  b_unlock();
  return result;
}

void boutput_rf_get(boutput_rf_t rf,
    boutput_rf_settings *settings 
    )
{
  b_lock();
  boutput_rf_get_impl(rf, settings);
  b_unlock();
  return;
}

bresult boutput_hdmi_set(boutput_hdmi_t dvi,
    const boutput_hdmi_settings *settings)
{
  bresult result;
  b_lock();
  result = boutput_hdmi_set_impl(dvi, settings);
  b_unlock();
  return result;
}

void boutput_hdmi_get(boutput_hdmi_t dvi,
    boutput_hdmi_settings *settings 
    )
{
  b_lock();
  boutput_hdmi_get_impl(dvi, settings);
  b_unlock();
  return;
}

bresult boutput_hdmi_get_capabilities(boutput_hdmi_t dvi,
                                     boutput_hdmi_capabilities *caps 
                                     )
{
  bresult result;
  b_lock();
  result = boutput_hdmi_get_capabilities_impl(dvi, caps);
  b_unlock();
  return result;
}

bresult boutput_hdmi_get_status(boutput_hdmi_t dvi,
                                boutput_hdmi_status *status 
                                     )
{
  bresult result;
  b_lock();
  result = boutput_hdmi_get_status_impl(dvi, status);
  b_unlock();
  return result;
}

bresult boutput_hdmi_cec_get_message(boutput_hdmi_t dvi,
                                boutput_hdmi_cec_message_data *cec_message_data 
                                )
{
  bresult result;
  b_lock();
  result = boutput_hdmi_cec_get_message_impl(dvi, cec_message_data);
  b_unlock();
  return result;
}

bresult boutput_hdmi_cec_send_message(boutput_hdmi_t dvi,
                                const boutput_hdmi_cec_message_data *cec_message_data
                                )
{
  bresult result;
  b_lock();
  result = boutput_hdmi_cec_send_message_impl(dvi, cec_message_data);
  b_unlock();
  return result;
}

bresult boutput_hdmi_cec_get_configuration(boutput_hdmi_t dvi,
                                boutput_hdmi_cec_configuration *cec_configuration   
                                )
{
  bresult result;
  b_lock();
  result = boutput_hdmi_cec_get_configuration_impl(dvi, cec_configuration);
  b_unlock();
  return result;
}

bool boutput_hdmi_cec_is_device_ready(boutput_hdmi_t dvi)
{
  bool result;
  b_lock();
  result = boutput_hdmi_cec_is_device_ready_impl(dvi);
  b_unlock();
  return result;
}

bresult boutput_hdmi_cec_enable_receive(boutput_hdmi_t dvi)
{
  bresult result;
  b_lock();
  result = boutput_hdmi_cec_enable_receive_impl(dvi);
  b_unlock();
  return result;
}

bresult boutput_component_set(boutput_component_t component,
    const boutput_component_settings *settings)
{
  bresult result;
  b_lock();
  result = boutput_component_set_impl(component, settings);
  b_unlock();
  return result;
}

void boutput_component_get(boutput_component_t component,
    boutput_component_settings *settings 
    )
{
  b_lock();
  boutput_component_get_impl(component, settings);
  b_unlock();
  return;
}

bresult boutput_spdif_set(boutput_spdif_t spdif,
    const boutput_spdif_settings *settings)
{
  bresult result;
  b_lock();
  result = boutput_spdif_set_impl(spdif, settings);
  b_unlock();
  return result;
}

void boutput_spdif_get(boutput_spdif_t spdif,
    boutput_spdif_settings *settings 
    )
{
  b_lock();
  boutput_spdif_get_impl(spdif, settings);
  b_unlock();
  return;
}

boutput_spdif_t
boutput_spdif_open(bobject_t spdif_id)
{
  boutput_spdif_t result;
  b_lock();
  result = boutput_spdif_open_impl(spdif_id);
  b_unlock();
  return result;
}

boutput_rf_t
boutput_rf_open(bobject_t rfmod_id)
{
  boutput_rf_t result;
  b_lock();
  result = boutput_rf_open_impl(rfmod_id);
  b_unlock();
  return result;
}

boutput_composite_t
boutput_composite_open(bobject_t composite_id)
{
  boutput_composite_t result;
  b_lock();
  result = boutput_composite_open_impl(composite_id);
  b_unlock();
  return result;
}

boutput_svideo_t
boutput_svideo_open(bobject_t svideo_id)
{
  boutput_svideo_t result;
  b_lock();
  result = boutput_svideo_open_impl(svideo_id);
  b_unlock();
  return result;
}

boutput_hdmi_t
boutput_hdmi_open(bobject_t dvi_id)
{
  boutput_hdmi_t result;
  b_lock();
  result = boutput_hdmi_open_impl(dvi_id);
  b_unlock();
  return result;
}

boutput_component_t
boutput_component_open(bobject_t component_id)
{
  boutput_component_t result;
  b_lock();
  result = boutput_component_open_impl(component_id);
  b_unlock();
  return result;
}

void bdisplay_get_video_format_settings(
    const bdisplay_settings *settings,
    bvideo_format_settings *format_settings 
    )
{
  b_lock();
  bdisplay_get_video_format_settings_impl(settings, format_settings);
  b_unlock();
  return;
}

void bvideo_get_format_settings(
    bvideo_format format,           
    bvideo_format_settings *settings    
    )
{
  b_lock();
  bvideo_get_format_settings_impl(format, settings);
  b_unlock();
  return;
}

bresult
bdisplay_set(
    bdisplay_t display, 
    const bdisplay_settings *settings   
    )
{
  bresult result;
  b_lock();
  result = bdisplay_set_impl(display, settings);
  b_unlock();
  return result;
}

void
bdisplay_get(
    bdisplay_t display, 
    bdisplay_settings *settings 
    )
{
  b_lock();
  bdisplay_get_impl(display, settings);
  b_unlock();
  return;
}

bdecode_window_t bdecode_window_open(
    bobject_t window_id, 
    bdisplay_t display 
    )
{
  bdecode_window_t result;
  b_lock();
  result = bdecode_window_open_impl(window_id, display);
  b_unlock();
  return result;
}

bdecode_window_t bdecode_window_open_mosaic(
    bdecode_window_t parent_window, 
    bobject_t mosaic_id 
    )
{
  bdecode_window_t result;
  b_lock();
  result = bdecode_window_open_mosaic_impl(parent_window, mosaic_id);
  b_unlock();
  return result;
}

void
bdecode_window_close(
    bdecode_window_t window
    )
{
  b_lock();
  bdecode_window_close_impl(window);
  b_unlock();
  return;
}

bdecode_window_t bdecode_window_clone(
            bdecode_window_t window, 
            bobject_t clone_window_id, 
            bdisplay_t display 
        )
{
  bdecode_window_t result;
  b_lock();
  result = bdecode_window_clone_impl(window, clone_window_id, display);
  b_unlock();
  return result;
}

bresult bdisplay_set_dac_audio_volume(
    bdisplay_t display,     
    const baudio_volume *volume 
    )
{
  bresult result;
  b_lock();
  result = bdisplay_set_dac_audio_volume_impl(display, volume);
  b_unlock();
  return result;
}

bresult bdisplay_get_dac_audio_volume(
    bdisplay_t display,     
    baudio_volume *volume   
    )
{
  bresult result;
  b_lock();
  result = bdisplay_get_dac_audio_volume_impl(display, volume);
  b_unlock();
  return result;
}

bresult boutput_rf_set_audio_volume(
    boutput_rf_t rf,
    const baudio_volume *volume 
    )
{
  bresult result;
  b_lock();
  result = boutput_rf_set_audio_volume_impl(rf, volume);
  b_unlock();
  return result;
}

bresult boutput_spdif_set_audio_volume(
    boutput_spdif_t spdif,
    const baudio_volume *volume 
    )
{
  bresult result;
  b_lock();
  result = boutput_spdif_set_audio_volume_impl(spdif, volume);
  b_unlock();
  return result;
}

bresult boutput_spdif_get_audio_volume(
    boutput_spdif_t spdif,
    baudio_volume *volume 
    )
{
  bresult result;
  b_lock();
  result = boutput_spdif_get_audio_volume_impl(spdif, volume);
  b_unlock();
  return result;
}

bresult boutput_rf_get_audio_volume(
    boutput_rf_t rf,
    baudio_volume *volume   
    )
{
  bresult result;
  b_lock();
  result = boutput_rf_get_audio_volume_impl(rf, volume);
  b_unlock();
  return result;
}

bresult bdecode_window_get(
    bdecode_window_t window,
    bdecode_window_settings *settings   
    )
{
  bresult result;
  b_lock();
  result = bdecode_window_get_impl(window, settings);
  b_unlock();
  return result;
}

bresult bdecode_window_set(
    bdecode_window_t window,
    const bdecode_window_settings *settings
    )
{
  bresult result;
  b_lock();
  result = bdecode_window_set_impl(window, settings);
  b_unlock();
  return result;
}

bmessage_stream_t bmessage_open(
        bmessage_format format
        )
{
  bmessage_stream_t result;
  b_lock();
  result = bmessage_open_impl(format);
  b_unlock();
  return result;
}

void bmessage_stream_params_init(
        bmessage_stream_params *params,
        bmessage_stream_t stream)
{
  b_lock();
  bmessage_stream_params_init_impl(params, stream);
  b_unlock();
  return;
}

bresult bmessage_start(
        bmessage_stream_t message_stream,
        const bmessage_stream_params *params
        )
{
  bresult result;
  b_lock();
  result = bmessage_start_impl(message_stream, params);
  b_unlock();
  return result;
}

bresult bmessage_get_buffer(
        bmessage_stream_t message_stream, 
        const void ** p_bfr,                    
        size_t *length
        )
{
  bresult result;
  b_lock();
  result = bmessage_get_buffer_impl(message_stream, p_bfr, length);
  b_unlock();
  return result;
}

bresult bmessage_read_complete(
        bmessage_stream_t message_stream, 
        size_t amount_consumed
        )
{
  bresult result;
  b_lock();
  result = bmessage_read_complete_impl(message_stream, amount_consumed);
  b_unlock();
  return result;
}

void bmessage_stop(
        bmessage_stream_t message_stream 
        )
{
  b_lock();
  bmessage_stop_impl(message_stream);
  b_unlock();
  return;
}

void bmessage_close(
        bmessage_stream_t message_stream 
        )
{
  b_lock();
  bmessage_close_impl(message_stream);
  b_unlock();
  return;
}

void brecpump_get_open_params(
                bobject_t id, 
                brecpump_open_params *open_params 
                )
{
  b_lock();
  brecpump_get_open_params_impl(id, open_params);
  b_unlock();
  return;
}

brecpump_t brecpump_open(
                bobject_t id, 
                const brecpump_open_params *open_params 
                )
{
  brecpump_t result;
  b_lock();
  result = brecpump_open_impl(id, open_params);
  b_unlock();
  return result;
}

void brecpump_close(brecpump_t recpump)
{
  b_lock();
  brecpump_close_impl(recpump);
  b_unlock();
  return;
}

void brecpump_params_init(
        brecpump_params *params, 
        brecpump_t recpump
        )
{
  b_lock();
  brecpump_params_init_impl(params, recpump);
  b_unlock();
  return;
}

bresult brecpump_start(
        brecpump_t recpump,
        bstream_t stream,
        const brecpump_params *params
        )
{
  bresult result;
  b_lock();
  result = brecpump_start_impl(recpump, stream, params);
  b_unlock();
  return result;
}

bresult brecpump_stop(
        brecpump_t recpump
        )
{
  bresult result;
  b_lock();
  result = brecpump_stop_impl(recpump);
  b_unlock();
  return result;
}

void brecpump_immediate_stop(
        brecpump_t recpump
        )
{
  b_lock();
  brecpump_immediate_stop_impl(recpump);
  b_unlock();
  return;
}

bresult brecpump_data_get_buffer(
        brecpump_t recpump,
        const void **buffer, 
        size_t *buffer_size 
        )
{
  bresult result;
  b_lock();
  result = brecpump_data_get_buffer_impl(recpump, buffer, buffer_size);
  b_unlock();
  return result;
}

bresult brecpump_index_get_buffer(
        brecpump_t recpump,
        const void **buffer, 
        size_t *buffer_size 
        )
{
  bresult result;
  b_lock();
  result = brecpump_index_get_buffer_impl(recpump, buffer, buffer_size);
  b_unlock();
  return result;
}

bresult brecpump_data_write_complete(
        brecpump_t recpump,
        size_t amount_written
        )
{
  bresult result;
  b_lock();
  result = brecpump_data_write_complete_impl(recpump, amount_written);
  b_unlock();
  return result;
}

bresult brecpump_index_write_complete(
        brecpump_t recpump,
        size_t amount_written
        )
{
  bresult result;
  b_lock();
  result = brecpump_index_write_complete_impl(recpump, amount_written);
  b_unlock();
  return result;
}

void brecpump_get_status(
        brecpump_t recpump,
        brecpump_status *status 
        )
{
  b_lock();
  brecpump_get_status_impl(recpump, status);
  b_unlock();
  return;
}

bcipher_t bcipher_open(
        bobject_t id
        )
{
  bcipher_t result;
  b_lock();
  result = bcipher_open_impl(id);
  b_unlock();
  return result;
}

void bcipher_close(bcipher_t encrypt)
{
  b_lock();
  bcipher_close_impl(encrypt);
  b_unlock();
  return;
}

void bcipher_settings_init(
        bcipher_settings *settings,     
        bcipher_t cipher                        
        )
{
  b_lock();
  bcipher_settings_init_impl(settings, cipher);
  b_unlock();
  return;
}

bresult
bcipher_convert_data(
        bcipher_t handle,               
        void *dest ,
        const void *source ,
        size_t datalen,                 
        const bcipher_settings *settings 
        )
{
  bresult result;
  b_lock();
  result = bcipher_convert_data_impl(handle, dest, source, datalen, settings);
  b_unlock();
  return result;
}

bencode_t bencode_open(
                bobject_t id 
                )
{
  bencode_t result;
  b_lock();
  result = bencode_open_impl(id);
  b_unlock();
  return result;
}

void bencode_close(
                bencode_t encode 
                )
{
  b_lock();
  bencode_close_impl(encode);
  b_unlock();
  return;
}

void bencode_extended_settings_init(
        bencode_settings *settings,     
        bencode_quality quality,        
        bencode_t encode,               
        bencode_vpp_mode vpp_mode       
        )
{
  b_lock();
  bencode_extended_settings_init_impl(settings, quality, encode, vpp_mode);
  b_unlock();
  return;
}

void bencode_settings_init(
        bencode_settings *settings, 
        bencode_quality quality,        
        bencode_t encode                        
        )
{
  b_lock();
  bencode_settings_init_impl(settings, quality, encode);
  b_unlock();
  return;
}

bstream_t bencode_start(
        bencode_t encode, 
        bstream_t stream, 
        const bencode_settings *settings 
        )
{
  bstream_t result;
  b_lock();
  result = bencode_start_impl(encode, stream, settings);
  b_unlock();
  return result;
}

void bencode_stop(
        bencode_t encode,       
        bstream_t stream        
        )
{
  b_lock();
  bencode_stop_impl(encode, stream);
  b_unlock();
  return;
}

void bpcm_play_settings_init(
        bpcm_play_settings *settings,   
        bpcm_play_t pcmplay             
        )
{
  b_lock();
  bpcm_play_settings_init_impl(settings, pcmplay);
  b_unlock();
  return;
}

bpcm_play_t bpcm_play_open(
        bobject_t id                            
        )
{
  bpcm_play_t result;
  b_lock();
  result = bpcm_play_open_impl(id);
  b_unlock();
  return result;
}

void bpcm_play_close(
        bpcm_play_t pcmplay
        )
{
  b_lock();
  bpcm_play_close_impl(pcmplay);
  b_unlock();
  return;
}

bresult bpcm_play_start(
        bpcm_play_t pcmplay,
        bdisplay_t display,                                     
        const bpcm_play_settings *settings
        )
{
  bresult result;
  b_lock();
  result = bpcm_play_start_impl(pcmplay, display, settings);
  b_unlock();
  return result;
}

bresult bpcm_play_get_status(
        bpcm_play_t pcmplay,
        bpcm_play_status *status 
        )
{
  bresult result;
  b_lock();
  result = bpcm_play_get_status_impl(pcmplay, status);
  b_unlock();
  return result;
}

bresult bpcm_play_get_buffer(
        bpcm_play_t pcmplay,
        void **data,
        size_t *length
        )
{
  bresult result;
  b_lock();
  result = bpcm_play_get_buffer_impl(pcmplay, data, length);
  b_unlock();
  return result;
}

bresult bpcm_play_write_complete(
        bpcm_play_t pcmplay,
        size_t amount_written
        )
{
  bresult result;
  b_lock();
  result = bpcm_play_write_complete_impl(pcmplay, amount_written);
  b_unlock();
  return result;
}

bresult bpcm_play_stop(
        bpcm_play_t pcmplay
        )
{
  bresult result;
  b_lock();
  result = bpcm_play_stop_impl(pcmplay);
  b_unlock();
  return result;
}

void bpcm_play_get_output_settings(
    bpcm_play_t pcmplay,
    bpcm_play_output_settings *settings 
    )
{
  b_lock();
  bpcm_play_get_output_settings_impl(pcmplay, settings);
  b_unlock();
  return;
}

bresult bpcm_play_set_output_settings(
    bpcm_play_t pcmplay,
    const bpcm_play_output_settings *settings
    )
{
  bresult result;
  b_lock();
  result = bpcm_play_set_output_settings_impl(pcmplay, settings);
  b_unlock();
  return result;
}

void bpcm_capture_settings_init(
    bpcm_capture_settings *settings,    
    bpcm_capture_t pcmcapture           
)
{
  b_lock();
  bpcm_capture_settings_init_impl(settings, pcmcapture);
  b_unlock();
  return;
}

bpcm_capture_t bpcm_capture_open(
    bobject_t id                                
)
{
  bpcm_capture_t result;
  b_lock();
  result = bpcm_capture_open_impl(id);
  b_unlock();
  return result;
}

void bpcm_capture_close(
    bpcm_capture_t pcmcapture
)
{
  b_lock();
  bpcm_capture_close_impl(pcmcapture);
  b_unlock();
  return;
}

bresult bpcm_capture_start(
    bpcm_capture_t pcmcapture,
    bdisplay_t display,                                 
    const bpcm_capture_settings *settings
)
{
  bresult result;
  b_lock();
  result = bpcm_capture_start_impl(pcmcapture, display, settings);
  b_unlock();
  return result;
}

bresult bpcm_capture_get_buffer(
    bpcm_capture_t pcmcapture,
    void **data,
    size_t *length
)
{
  bresult result;
  b_lock();
  result = bpcm_capture_get_buffer_impl(pcmcapture, data, length);
  b_unlock();
  return result;
}

bresult bpcm_capture_read_complete(
    bpcm_capture_t pcmcapture,
    size_t amount_read
)
{
  bresult result;
  b_lock();
  result = bpcm_capture_read_complete_impl(pcmcapture, amount_read);
  b_unlock();
  return result;
}

bresult bpcm_capture_stop(
    bpcm_capture_t pcmcapture
)
{
  bresult result;
  b_lock();
  result = bpcm_capture_stop_impl(pcmcapture);
  b_unlock();
  return result;
}

void bsmartcard_settings_init(
        bsmartcard_settings_t *settings
)
{
  b_lock();
  bsmartcard_settings_init_impl(settings);
  b_unlock();
  return;
}

bsmartcard_t bsmartcard_open(
        bobject_t smartcard_id, 
        const bsmartcard_settings_t *settings 
)
{
  bsmartcard_t result;
  b_lock();
  result = bsmartcard_open_impl(smartcard_id, settings);
  b_unlock();
  return result;
}

void bsmartcard_close(
        bsmartcard_t smartcard 
)
{
  b_lock();
  bsmartcard_close_impl(smartcard);
  b_unlock();
  return;
}

void bsmartcard_get_settings(
    bsmartcard_t smartcard,
    bsmartcard_settings_t *settings
)
{
  b_lock();
  bsmartcard_get_settings_impl(smartcard, settings);
  b_unlock();
  return;
}

bresult bsmartcard_set_settings(
    bsmartcard_t smartcard,
    const bsmartcard_settings_t *settings
)
{
  bresult result;
  b_lock();
  result = bsmartcard_set_settings_impl(smartcard, settings);
  b_unlock();
  return result;
}

bresult bsmartcard_read(
        bsmartcard_t smartcard, 
        void *data ,
        size_t length,                  
        size_t *length_read             
)
{
  bresult result;
  b_lock();
  result = bsmartcard_read_impl(smartcard, data, length, length_read);
  b_unlock();
  return result;
}

bresult bsmartcard_write(
        bsmartcard_t smartcard, 
        const void *data ,
        size_t length,                  
        size_t *length_written  
)
{
  bresult result;
  b_lock();
  result = bsmartcard_write_impl(smartcard, data, length, length_written);
  b_unlock();
  return result;
}

bresult bsmartcard_get_status(
        bsmartcard_t smartcard,
        bsmartcard_status *status               
)
{
  bresult result;
  b_lock();
  result = bsmartcard_get_status_impl(smartcard, status);
  b_unlock();
  return result;
}

bresult bsmartcard_reset_card(
        bsmartcard_t smartcard, 
        void *data ,
        size_t length,                  
        size_t *length_read             
)
{
  bresult result;
  b_lock();
  result = bsmartcard_reset_card_impl(smartcard, data, length, length_read);
  b_unlock();
  return result;
}

bresult bsmartcard_reset(
        bsmartcard_t smartcard, 
        bool warm_reset 
)
{
  bresult result;
  b_lock();
  result = bsmartcard_reset_impl(smartcard, warm_reset);
  b_unlock();
  return result;
}

bresult bsmartcard_detect_card( 
                bsmartcard_t smartcard
)
{
  bresult result;
  b_lock();
  result = bsmartcard_detect_card_impl(smartcard);
  b_unlock();
  return result;
}

bresult bsmartcard_init(void)
{
  bresult result;
  b_lock();
  result = bsmartcard_init_impl();
  b_unlock();
  return result;
}

void bsmartcard_shutdown(void)
{
  b_lock();
  bsmartcard_shutdown_impl();
  b_unlock();
  return;
}

buser_input_t buser_input_open(
                     bobject_t user_input_id 
                    )
{
  buser_input_t result;
  b_lock();
  result = buser_input_open_impl(user_input_id);
  b_unlock();
  return result;
}

void buser_input_close(
        buser_input_t ui 
    )
{
  b_lock();
  buser_input_close_impl(ui);
  b_unlock();
  return;
}

void buser_input_get_settings(
        buser_input_t ui,
        buser_input_settings *settings)
{
  b_lock();
  buser_input_get_settings_impl(ui, settings);
  b_unlock();
  return;
}

void buser_input_set_settings(
        buser_input_t ui,
        const buser_input_settings *settings)
{
  b_lock();
  buser_input_set_settings_impl(ui, settings);
  b_unlock();
  return;
}

bresult buser_input_get_event(
        buser_input_t ui, 
        buser_input_event *event ,
        unsigned nevents, 
        unsigned *result_nevents 
        )
{
  bresult result;
  b_lock();
  result = buser_input_get_event_impl(ui, event, nevents, result_nevents);
  b_unlock();
  return result;
}

buser_output_t buser_output_open(
        bobject_t user_output_id 
        )
{
  buser_output_t result;
  b_lock();
  result = buser_output_open_impl(user_output_id);
  b_unlock();
  return result;
}

void buser_output_close(
        buser_output_t uo 
        )
{
  b_lock();
  buser_output_close_impl(uo);
  b_unlock();
  return;
}

bresult buser_output_set_led(
        buser_output_t ui, 
        unsigned led, 
        bool on                 
        )
{
  bresult result;
  b_lock();
  result = buser_output_set_led_impl(ui, led, on);
  b_unlock();
  return result;
}

bresult buser_output_display_message(
        buser_output_t ui, 
        const char *message     
        )
{
  bresult result;
  b_lock();
  result = buser_output_display_message_impl(ui, message);
  b_unlock();
  return result;
}

void buser_input_set_xmp_settings(
        buser_input_t ui,
        const buser_input_xmp_settings *settings)
{
  b_lock();
  buser_input_set_xmp_settings_impl(ui, settings);
  b_unlock();
  return;
}

void buser_input_get_xmp_settings(
        buser_input_t ui,
        buser_input_xmp_settings *settings)
{
  b_lock();
  buser_input_get_xmp_settings_impl(ui, settings);
  b_unlock();
  return;
}

bresult buser_input_send_xmp(
        buser_input_t remote, 
        const uint8_t *input_buffer ,
        size_t length 
        )
{
  bresult result;
  b_lock();
  result = buser_input_send_xmp_impl(remote, input_buffer, length);
  b_unlock();
  return result;
}

bresult buser_input_receive_xmp(
        buser_input_t remote, 
        uint8_t *output_data ,
        size_t length,
        unsigned *output_size,
        uint32_t *data_packet
        )
{
  bresult result;
  b_lock();
  result = buser_input_receive_xmp_impl(remote, output_data, length, output_size, data_packet);
  b_unlock();
  return result;
}

bgraphics_t bgraphics_open(
        bobject_t id,
        bdisplay_t display      
        )
{
  bgraphics_t result;
  b_lock();
  result = bgraphics_open_impl(id, display);
  b_unlock();
  return result;
}

void bgraphics_close(
        bgraphics_t graphics    
        )
{
  b_lock();
  bgraphics_close_impl(graphics);
  b_unlock();
  return;
}

void bgraphics_get(
        bgraphics_t graphics,   
        bgraphics_settings *settings 
        )
{
  b_lock();
  bgraphics_get_impl(graphics, settings);
  b_unlock();
  return;
}

bresult bgraphics_set(
        bgraphics_t graphics,   
        const bgraphics_settings *settings
        )
{
  bresult result;
  b_lock();
  result = bgraphics_set_impl(graphics, settings);
  b_unlock();
  return result;
}

bresult bgraphics_sync(
        bgraphics_t graphics    
        )
{
  bresult result;
  b_lock();
  result = bgraphics_sync_impl(graphics);
  b_unlock();
  return result;
}

bresult bsurface_sync(
        bsurface_t surface      
        )
{
  bresult result;
  b_lock();
  result = bsurface_sync_impl(surface);
  b_unlock();
  return result;
}

bresult bgraphics_flip(
        bgraphics_t graphics    
        )
{
  bresult result;
  b_lock();
  result = bgraphics_flip_impl(graphics);
  b_unlock();
  return result;
}

bresult bgraphics_flip_sync(
        bgraphics_t graphics    
        )
{
  bresult result;
  b_lock();
  result = bgraphics_flip_sync_impl(graphics);
  b_unlock();
  return result;
}

void bsurface_create_settings_init(
        bsurface_create_settings *create_settings,      
        bgraphics_t graphics            
        )
{
  b_lock();
  bsurface_create_settings_init_impl(create_settings, graphics);
  b_unlock();
  return;
}

bsurface_t bgraphics_create_framebuffer(
        bgraphics_t graphics,   
        const bsurface_create_settings *create_settings,
        unsigned int back_buffer_count 
        )
{
  bsurface_t result;
  b_lock();
  result = bgraphics_create_framebuffer_impl(graphics, create_settings, back_buffer_count);
  b_unlock();
  return result;
}

bsurface_t bsurface_create(
        bgraphics_t graphics,   
        const bsurface_create_settings *create_settings
        )
{
  bsurface_t result;
  b_lock();
  result = bsurface_create_impl(graphics, create_settings);
  b_unlock();
  return result;
}

bsurface_t bsurface_get_display(
        bgraphics_t graphics,   
        const bsurface_create_settings *create_settings
        )
{
  bsurface_t result;
  b_lock();
  result = bsurface_get_display_impl(graphics, create_settings);
  b_unlock();
  return result;
}

void bsurface_destroy(
        bsurface_t surface      
        )
{
  b_lock();
  bsurface_destroy_impl(surface);
  b_unlock();
  return;
}

bresult bsurface_get_memory(
        bsurface_t s,
        bsurface_memory *memory 
        )
{
  bresult result;
  b_lock();
  result = bsurface_get_memory_impl(s, memory);
  b_unlock();
  return result;
}

bresult bsurface_set(
        bsurface_t s,
        const bsurface_settings *settings
        )
{
  bresult result;
  b_lock();
  result = bsurface_set_impl(s, settings);
  b_unlock();
  return result;
}

void bsurface_get(
        bsurface_t s,
        bsurface_settings *settings 
        )
{
  b_lock();
  bsurface_get_impl(s, settings);
  b_unlock();
  return;
}

bresult bsurface_fill(
        bsurface_t surface,             
        const bsettop_rect *rect,       
        bgraphics_pixel pixel 
        )
{
  bresult result;
  b_lock();
  result = bsurface_fill_impl(surface, rect, pixel);
  b_unlock();
  return result;
}

bresult bsurface_copy(
        bsurface_t destsurface,         
        const bsettop_rect *destrect,    
        bsurface_t srcsurface,          
        const bsettop_rect *srcrect      
        )
{
  bresult result;
  b_lock();
  result = bsurface_copy_impl(destsurface, destrect, srcsurface, srcrect);
  b_unlock();
  return result;
}

bresult bsurface_blit(
        bsurface_t destsurface,                 
        const bsettop_rect *destrect,   
        uint32_t operation,                             
        bsurface_t src1,                                
        const bsettop_rect *src1_rect,  
        bsurface_t src2,                                
        const bsettop_rect *src2_rect,  
        bgraphics_pixel pixel1,                 
        bgraphics_pixel pixel2                  
        )
{
  bresult result;
  b_lock();
  result = bsurface_blit_impl(destsurface, destrect, operation, src1, src1_rect, src2, src2_rect, pixel1, pixel2);
  b_unlock();
  return result;
}

void bsurface_blit_params_init(bsurface_blit_params *params)
{
  b_lock();
  bsurface_blit_params_init_impl(params);
  b_unlock();
  return;
}

bresult bsurface_extended_blit(
        bsurface_t destsurface,
        const bsettop_rect *destrect,
        const bsurface_blit_params *params
        )
{
  bresult result;
  b_lock();
  result = bsurface_extended_blit_impl(destsurface, destrect, params);
  b_unlock();
  return result;
}

bresult
bsurface_blended_fill(
        bsurface_t surface,         
        const bsettop_rect *rect,   
        bgraphics_pixel pixel,      
        uint32_t operation         

        )
{
  bresult result;
  b_lock();
  result = bsurface_blended_fill_impl(surface, rect, pixel, operation);
  b_unlock();
  return result;
}

bresult bsurface_load_clut(
        bsurface_t s,
        bgraphics_palette palette)
{
  bresult result;
  b_lock();
  result = bsurface_load_clut_impl(s, palette);
  b_unlock();
  return result;
}

void bplaypump_get_open_params(
                bobject_t id, 
                bplaypump_open_params *open_params 
                )
{
  b_lock();
  bplaypump_get_open_params_impl(id, open_params);
  b_unlock();
  return;
}

bplaypump_t bplaypump_open(
                bobject_t id,
                const bplaypump_open_params *open_params 
                )
{
  bplaypump_t result;
  b_lock();
  result = bplaypump_open_impl(id, open_params);
  b_unlock();
  return result;
}

void bplaypump_close(bplaypump_t playpump)
{
  b_lock();
  bplaypump_close_impl(playpump);
  b_unlock();
  return;
}

void bplaypump_params_init(
        bplaypump_params *params, 
        bplaypump_t playpump
        )
{
  b_lock();
  bplaypump_params_init_impl(params, playpump);
  b_unlock();
  return;
}

bstream_t bplaypump_start(
        bplaypump_t playpump,
        const bstream_mpeg *mpeg, 
        const bplaypump_params *params
        )
{
  bstream_t result;
  b_lock();
  result = bplaypump_start_impl(playpump, mpeg, params);
  b_unlock();
  return result;
}

bresult bplaypump_stop(
        bplaypump_t playpump
        )
{
  bresult result;
  b_lock();
  result = bplaypump_stop_impl(playpump);
  b_unlock();
  return result;
}

bresult bplaypump_get_buffer(
        bplaypump_t playpump,
        void **buffer, 
        size_t *size 
        )
{
  bresult result;
  b_lock();
  result = bplaypump_get_buffer_impl(playpump, buffer, size);
  b_unlock();
  return result;
}

bresult bplaypump_read_complete(
        bplaypump_t playpump,
        size_t skip, 
        size_t amount 
        )
{
  bresult result;
  b_lock();
  result = bplaypump_read_complete_impl(playpump, skip, amount);
  b_unlock();
  return result;
}

bresult bplaypump_set(
        bplaypump_t playpump,
        const bplaypump_settings *settings
        )
{
  bresult result;
  b_lock();
  result = bplaypump_set_impl(playpump, settings);
  b_unlock();
  return result;
}

void bplaypump_get(
        bplaypump_t playpump,
        bplaypump_settings *settings
        )
{
  b_lock();
  bplaypump_get_impl(playpump, settings);
  b_unlock();
  return;
}

bresult bplaypump_set_state(
        bplaypump_t playpump,
        bplaypump_state state,
        bool forward
        )
{
  bresult result;
  b_lock();
  result = bplaypump_set_state_impl(playpump, state, forward);
  b_unlock();
  return result;
}

bresult bplaypump_set_decoder_rate(
        bplaypump_t playpump,
        unsigned rate
        )
{
  bresult result;
  b_lock();
  result = bplaypump_set_decoder_rate_impl(playpump, rate);
  b_unlock();
  return result;
}

bresult bplaypump_frame_advance(
        bplaypump_t playpump
        )
{
  bresult result;
  b_lock();
  result = bplaypump_frame_advance_impl(playpump);
  b_unlock();
  return result;
}

bresult bplaypump_flush(
        bplaypump_t playpump
        )
{
  bresult result;
  b_lock();
  result = bplaypump_flush_impl(playpump);
  b_unlock();
  return result;
}

bresult bplaypump_get_status(
        bplaypump_t p,
        bplaypump_status *status 
        )
{
  bresult result;
  b_lock();
  result = bplaypump_get_status_impl(p, status);
  b_unlock();
  return result;
}

bresult bplaypump_p_set_pwm_value(
        bplaypump_t p, 
        int pwm_value)
{
  bresult result;
  b_lock();
  result = bplaypump_p_set_pwm_value_impl(p, pwm_value);
  b_unlock();
  return result;
}

void bplaypump_get_source(bplaypump_t playpump, bplaypump_source *source)
{
  b_lock();
  bplaypump_get_source_impl(playpump, source);
  b_unlock();
  return;
}

bresult bplaypump_set_source(bplaypump_t playpump, const bplaypump_source *source)
{
  bresult result;
  b_lock();
  result = bplaypump_set_source_impl(playpump, source);
  b_unlock();
  return result;
}

bresult bplaypump_get_rtp_hdr_data(bplaypump_t p, const bplaypump_rtp_hdr_data_t *rtp_header_data, unsigned *entry_cnt)
{
  bresult result;
  b_lock();
  result = bplaypump_get_rtp_hdr_data_impl(p, rtp_header_data, entry_cnt);
  b_unlock();
  return result;
}

void bencryption_params_init(
        bencryption_params *encryption  
)
{
  b_lock();
  bencryption_params_init_impl(encryption);
  b_unlock();
  return;
}

void bstream_mpeg_init(
        bstream_mpeg *mpeg              
        )
{
  b_lock();
  bstream_mpeg_init_impl(mpeg);
  b_unlock();
  return;
}

bband_t bstreamer_attach(
        bobject_t id,
        bstream_mpeg_type mpeg_type     
        )
{
  bband_t result;
  b_lock();
  result = bstreamer_attach_impl(id, mpeg_type);
  b_unlock();
  return result;
}

bstream_t bstream_open(
        bband_t band,   
        const bstream_mpeg *mpegparams  
        )
{
  bstream_t result;
  b_lock();
  result = bstream_open_impl(band, mpegparams);
  b_unlock();
  return result;
}

bresult bstream_set_encryption(
        bstream_t stream,
        const bencryption_params *encryption
        )
{
  bresult result;
  b_lock();
  result = bstream_set_encryption_impl(stream, encryption);
  b_unlock();
  return result;
}

void bstream_join(bstream_t video_source, bstream_t audio_source)
{
  b_lock();
  bstream_join_impl(video_source, audio_source);
  b_unlock();
  return;
}

bstream_t bstream_open_child(bstream_t parent, const bstream_mpeg *mpegparams)
{
  bstream_t result;
  b_lock();
  result = bstream_open_child_impl(parent, mpegparams);
  b_unlock();
  return result;
}

void bstream_close(
        bstream_t stream        
        )
{
  b_lock();
  bstream_close_impl(stream);
  b_unlock();
  return;
}

bresult
bstream_get_mpeg_parameters(
        bstream_t stream,
        bstream_status *status  
        )
{
  bresult result;
  b_lock();
  result = bstream_get_mpeg_parameters_impl(stream, status);
  b_unlock();
  return result;
}

bresult
bstream_set_mpeg_parameters(
        bstream_t stream,
        const bstream_mpeg *mpeg
        )
{
  bresult result;
  b_lock();
  result = bstream_set_mpeg_parameters_impl(stream, mpeg);
  b_unlock();
  return result;
}

void bband_get(
        bband_t band,
        bband_settings *settings 
        )
{
  b_lock();
  bband_get_impl(band, settings);
  b_unlock();
  return;
}

bresult bstream_start_pcr_monitor(bstream_t stream)
{
  bresult result;
  b_lock();
  result = bstream_start_pcr_monitor_impl(stream);
  b_unlock();
  return result;
}

void bstream_stop_pcr_monitor(bstream_t stream)
{
  b_lock();
  bstream_stop_pcr_monitor_impl(stream);
  b_unlock();
  return;
}

bresult bstream_get_pcr_status(bstream_t stream, bstream_pcr_status *status)
{
  bresult result;
  b_lock();
  result = bstream_get_pcr_status_impl(stream, status);
  b_unlock();
  return result;
}

void bstream_vbi_get_settings(
        bstream_t stream,                                       
        bstream_vbi_settings *settings  
        )
{
  b_lock();
  bstream_vbi_get_settings_impl(stream, settings);
  b_unlock();
  return;
}

bresult bstream_vbi_set_settings(
        bstream_t stream,                                       
        const bstream_vbi_settings *settings    
        )
{
  bresult result;
  b_lock();
  result = bstream_vbi_set_settings_impl(stream, settings);
  b_unlock();
  return result;
}

bresult bstream_vbi_cc_read(
        bstream_t stream,                       
        bstream_vbi_cc *data ,
        size_t length,                          
        size_t *length_read                     
        )
{
  bresult result;
  b_lock();
  result = bstream_vbi_cc_read_impl(stream, data, length, length_read);
  b_unlock();
  return result;
}

bresult bstream_vbi_cc708_read(
        bstream_t stream,                       
        bstream_cc_708 *data ,
        size_t length,                          
        size_t *length_read                     
        )
{
  bresult result;
  b_lock();
  result = bstream_vbi_cc708_read_impl(stream, data, length, length_read);
  b_unlock();
  return result;
}

bresult bdisplay_vbi_cc_write(
        bdisplay_t display,                     
        const bstream_vbi_cc *data ,
        size_t length,                          
        size_t *length_written          
        )
{
  bresult result;
  b_lock();
  result = bdisplay_vbi_cc_write_impl(display, data, length, length_written);
  b_unlock();
  return result;
}

bresult bstream_vbi_tt_read(
        bstream_t stream,                       
        bstream_vbi_tt *data ,
        size_t length,                          
        size_t *length_read                     
        )
{
  bresult result;
  b_lock();
  result = bstream_vbi_tt_read_impl(stream, data, length, length_read);
  b_unlock();
  return result;
}

bresult bdisplay_vbi_tt_write(
        bdisplay_t display,                     
        const bstream_vbi_tt *data ,
        size_t length,                          
    uint8_t polarity             
        )
{
  bresult result;
  b_lock();
  result = bdisplay_vbi_tt_write_impl(display, data, length, polarity);
  b_unlock();
  return result;
}

bresult bdisplay_vbi_set_cgms(
        bdisplay_t display,                     
        uint32_t cgms_value                     
        )
{
  bresult result;
  b_lock();
  result = bdisplay_vbi_set_cgms_impl(display, cgms_value);
  b_unlock();
  return result;
}

bresult bdisplay_vbi_set_wss(
        bdisplay_t display,                     
        uint16_t wss_value                      
        )
{
  bresult result;
  b_lock();
  result = bdisplay_vbi_set_wss_impl(display, wss_value);
  b_unlock();
  return result;
}

bresult bdisplay_vbi_get_cgms(
        bdisplay_t display,                     
        bool *enabled
        )
{
  bresult result;
  b_lock();
  result = bdisplay_vbi_get_cgms_impl(display, enabled);
  b_unlock();
  return result;
}

bresult bdisplay_vbi_get_wss(
        bdisplay_t display,                     
        bool *enabled
        )
{
  bresult result;
  b_lock();
  result = bdisplay_vbi_get_wss_impl(display, enabled);
  b_unlock();
  return result;
}

bdecode_t bdecode_open(
    bobject_t decode_id 
    )
{
  bdecode_t result;
  b_lock();
  result = bdecode_open_impl(decode_id);
  b_unlock();
  return result;
}

void bdecode_mosaic_settings_init(
    bdecode_t parent,                 
    bdecode_mosaic_settings *settings 
    )
{
  b_lock();
  bdecode_mosaic_settings_init_impl(parent, settings);
  b_unlock();
  return;
}

bdecode_t bdecode_open_mosaic(
    bdecode_t parent,                       
    bobject_t decode_id,                    
    const bdecode_mosaic_settings *settings 
    )
{
  bdecode_t result;
  b_lock();
  result = bdecode_open_mosaic_impl(parent, decode_id, settings);
  b_unlock();
  return result;
}

void bdecode_close(
    bdecode_t decode 
    )
{
  b_lock();
  bdecode_close_impl(decode);
  b_unlock();
  return;
}

void bdecode_get(
    bdecode_t decode, 
    bdecode_settings *settings 
    )
{
  b_lock();
  bdecode_get_impl(decode, settings);
  b_unlock();
  return;
}

bresult bdecode_set(
    bdecode_t decode, 
    const bdecode_settings *settings
    )
{
  bresult result;
  b_lock();
  result = bdecode_set_impl(decode, settings);
  b_unlock();
  return result;
}

bresult bdecode_display_surface(
    bdecode_t decode, 
    bsurface_t surface,
    bdecode_window_t window
    )
{
  bresult result;
  b_lock();
  result = bdecode_display_surface_impl(decode, surface, window);
  b_unlock();
  return result;
}

bresult bdecode_start(
    bdecode_t decode, 
    bstream_t source, 
    bdecode_window_t window 
    )
{
  bresult result;
  b_lock();
  result = bdecode_start_impl(decode, source, window);
  b_unlock();
  return result;
}

void bdecode_stop(
    bdecode_t decode 
    )
{
  b_lock();
  bdecode_stop_impl(decode);
  b_unlock();
  return;
}

baudio_decode_t bdecode_detach_audio(
    bdecode_t decode 
    )
{
  baudio_decode_t result;
  b_lock();
  result = bdecode_detach_audio_impl(decode);
  b_unlock();
  return result;
}

bresult bdecode_attach_audio(
    bdecode_t decode, 
    baudio_decode_t audio 
    )
{
  bresult result;
  b_lock();
  result = bdecode_attach_audio_impl(decode, audio);
  b_unlock();
  return result;
}

bresult bdecode_set_audio_program(
    bdecode_t decode, 
    unsigned index 
    )
{
  bresult result;
  b_lock();
  result = bdecode_set_audio_program_impl(decode, index);
  b_unlock();
  return result;
}

baudio_decode_t bdecode_get_audio(
    bdecode_t decode, 
    bobject_t audio_id 
    )
{
  baudio_decode_t result;
  b_lock();
  result = bdecode_get_audio_impl(decode, audio_id);
  b_unlock();
  return result;
}

bvideo_decode_t bdecode_detach_video(
        bdecode_t decode 
    )
{
  bvideo_decode_t result;
  b_lock();
  result = bdecode_detach_video_impl(decode);
  b_unlock();
  return result;
}

bresult bdecode_attach_video(
        bdecode_t decode, 
        bvideo_decode_t video 
    )
{
  bresult result;
  b_lock();
  result = bdecode_attach_video_impl(decode, video);
  b_unlock();
  return result;
}

bresult bdecode_set_video_program(
        bdecode_t decode, 
        unsigned index 
    )
{
  bresult result;
  b_lock();
  result = bdecode_set_video_program_impl(decode, index);
  b_unlock();
  return result;
}

bvideo_decode_t bdecode_get_video(
    bdecode_t decode, 
    bobject_t video_id 
    )
{
  bvideo_decode_t result;
  b_lock();
  result = bdecode_get_video_impl(decode, video_id);
  b_unlock();
  return result;
}

void baudio_decode_get_status(
    baudio_decode_t audio, 
    baudio_decode_status *status 
    )
{
  b_lock();
  baudio_decode_get_status_impl(audio, status);
  b_unlock();
  return;
}

void bvideo_decode_get_status(
    bvideo_decode_t video, 
    bvideo_decode_status *status
    )
{
  b_lock();
  bvideo_decode_get_status_impl(video, status);
  b_unlock();
  return;
}

bresult bdecode_get_status(
    bdecode_t decode,  
    bdecode_status *status  
    )
{
  bresult result;
  b_lock();
  result = bdecode_get_status_impl(decode, status);
  b_unlock();
  return result;
}

bresult bdecode_set_audio_volume(
    bdecode_t decode,
    const baudio_volume *volume
    )
{
  bresult result;
  b_lock();
  result = bdecode_set_audio_volume_impl(decode, volume);
  b_unlock();
  return result;
}

bresult bdecode_get_audio_volume(
    bdecode_t decode,
    baudio_volume *volume   
    )
{
  bresult result;
  b_lock();
  result = bdecode_get_audio_volume_impl(decode, volume);
  b_unlock();
  return result;
}

bresult bdecode_get_stc(bdecode_t decode, uint32_t *stc)
{
  bresult result;
  b_lock();
  result = bdecode_get_stc_impl(decode, stc);
  b_unlock();
  return result;
}

bresult bdecode_set_stc(bdecode_t decode, uint32_t stc)
{
  bresult result;
  b_lock();
  result = bdecode_set_stc_impl(decode, stc);
  b_unlock();
  return result;
}

void bdecode_slow_clock(
    bdecode_t decode,
    bool slow
    )
{
  b_lock();
  bdecode_slow_clock_impl(decode, slow);
  b_unlock();
  return;
}

bresult bdecode_read_metadata(
    bdecode_t decode,
    void *buffer ,
    unsigned size, 
    unsigned *amount_read 
    )
{
  bresult result;
  b_lock();
  result = bdecode_read_metadata_impl(decode, buffer, size, amount_read);
  b_unlock();
  return result;
}

bresult bdecode_allocate_capture_buffers(
    bdecode_t decode, 
    unsigned count 
    )
{
  bresult result;
  b_lock();
  result = bdecode_allocate_capture_buffers_impl(decode, count);
  b_unlock();
  return result;
}

bsurface_t bdecode_acquire_capture_buffer(
    bdecode_t decode,
    bgraphics_t graphics,
    bool *top_field 
    )
{
  bsurface_t result;
  b_lock();
  result = bdecode_acquire_capture_buffer_impl(decode, graphics, top_field);
  b_unlock();
  return result;
}

bresult bdecode_release_capture_buffer(
    bdecode_t decode, 
    bsurface_t surface
    )
{
  bresult result;
  b_lock();
  result = bdecode_release_capture_buffer_impl(decode, surface);
  b_unlock();
  return result;
}

void bsettop_get_power_state(bsettop_power_state *state)
{
  b_lock();
  bsettop_get_power_state_impl(state);
  b_unlock();
  return;
}

bresult bsettop_set_power_state(const bsettop_power_state *state)
{
  bresult result;
  b_lock();
  result = bsettop_set_power_state_impl(state);
  b_unlock();
  return result;
}

int bsettop_init_frontend(void)
{
  int result;
  b_lock();
  result = bsettop_init_frontend_impl();
  b_unlock();
  return result;
}

btuner_t btuner_open(
                     bobject_t tuner_id 
                    )
{
  btuner_t result;
  b_lock();
  result = btuner_open_impl(tuner_id);
  b_unlock();
  return result;
}

void btuner_close(
                  btuner_t tuner 
                 )
{
  b_lock();
  btuner_close_impl(tuner);
  b_unlock();
  return;
}

void btuner_qam_params_init(
    btuner_qam_params *qam,     
    btuner_t tuner              
    )
{
  b_lock();
  btuner_qam_params_init_impl(qam, tuner);
  b_unlock();
  return;
}

void btuner_ofdm_params_init(
    btuner_ofdm_params *ofdm,    
    btuner_t tuner              
    )
{
  b_lock();
  btuner_ofdm_params_init_impl(ofdm, tuner);
  b_unlock();
  return;
}

void btuner_analog_params_init(
    btuner_analog_params *analog,   
    btuner_t tuner                  
    )
{
  b_lock();
  btuner_analog_params_init_impl(analog, tuner);
  b_unlock();
  return;
}

void btuner_qam_us_params_init(
    btuner_qam_us_params *us_param,     
    btuner_t tuner              
    )
{
  b_lock();
  btuner_qam_us_params_init_impl(us_param, tuner);
  b_unlock();
  return;
}

void btuner_sds_params_init(
    btuner_sds_params *sds,     
    btuner_t tuner              
    )
{
  b_lock();
  btuner_sds_params_init_impl(sds, tuner);
  b_unlock();
  return;
}

void btuner_vsb_params_init(
    btuner_vsb_params *vsb,     
    btuner_t tuner              
    )
{
  b_lock();
  btuner_vsb_params_init_impl(vsb, tuner);
  b_unlock();
  return;
}

btuner_linein_t btuner_linein_open(bobject_t linein_id)
{
  btuner_linein_t result;
  b_lock();
  result = btuner_linein_open_impl(linein_id);
  b_unlock();
  return result;
}

bband_t btuner_tune_qam(
    btuner_t tuner,
    unsigned freq, 
    const btuner_qam_params *params 
    )
{
  bband_t result;
  b_lock();
  result = btuner_tune_qam_impl(tuner, freq, params);
  b_unlock();
  return result;
}

bresult
btuner_tune_oob(
    btuner_t tuner,
    unsigned freq, 
    const btuner_qam_params *params 
    )
{
  bresult result;
  b_lock();
  result = btuner_tune_oob_impl(tuner, freq, params);
  b_unlock();
  return result;
}

bresult
btuner_tune_qam_us(
    btuner_t tuner,
    unsigned freq, 
    const btuner_qam_us_params *params  
    )
{
  bresult result;
  b_lock();
  result = btuner_tune_qam_us_impl(tuner, freq, params);
  b_unlock();
  return result;
}

bband_t btuner_tune_sds(
    btuner_t tuner,
    unsigned freq, 
    const btuner_sds_params *params 
    )
{
  bband_t result;
  b_lock();
  result = btuner_tune_sds_impl(tuner, freq, params);
  b_unlock();
  return result;
}

bband_t btuner_tune_vsb(
    btuner_t tuner,
    unsigned freq, 
    const btuner_vsb_params *params 
    )
{
  bband_t result;
  b_lock();
  result = btuner_tune_vsb_impl(tuner, freq, params);
  b_unlock();
  return result;
}

bband_t
btuner_tune_ofdm(
    btuner_t tuner, 
    unsigned freq,   
    const btuner_ofdm_params* params 
    )
{
  bband_t result;
  b_lock();
  result = btuner_tune_ofdm_impl(tuner, freq, params);
  b_unlock();
  return result;
}

bstream_t btuner_tune_rf(
    btuner_t tuner,
    unsigned carrierfreq,   
    const btuner_analog_params *params  
    )
{
  bstream_t result;
  b_lock();
  result = btuner_tune_rf_impl(tuner, carrierfreq, params);
  b_unlock();
  return result;
}

bstream_t btuner_tune_linein(
    btuner_t tuner,
    btuner_linein_t linein, 
    const btuner_analog_params *params  
    )
{
  bstream_t result;
  b_lock();
  result = btuner_tune_linein_impl(tuner, linein, params);
  b_unlock();
  return result;
}

bresult btuner_get_analog_status(
    btuner_t tuner, 
    btuner_analog_status *status    
    )
{
  bresult result;
  b_lock();
  result = btuner_get_analog_status_impl(tuner, status);
  b_unlock();
  return result;
}

bresult btuner_get_qam_status(
    btuner_t tuner,
    btuner_qam_status *status   
    )
{
  bresult result;
  b_lock();
  result = btuner_get_qam_status_impl(tuner, status);
  b_unlock();
  return result;
}

bresult btuner_get_qam_us_status(
    btuner_t tuner,
    btuner_qam_us_status *status    
    )
{
  bresult result;
  b_lock();
  result = btuner_get_qam_us_status_impl(tuner, status);
  b_unlock();
  return result;
}

bresult btuner_get_sds_status(
    btuner_t tuner,
    btuner_sds_status *status   
    )
{
  bresult result;
  b_lock();
  result = btuner_get_sds_status_impl(tuner, status);
  b_unlock();
  return result;
}

bresult btuner_get_vsb_status(
    btuner_t tuner,
    btuner_vsb_status *status   
    )
{
  bresult result;
  b_lock();
  result = btuner_get_vsb_status_impl(tuner, status);
  b_unlock();
  return result;
}

bresult btuner_get_ofdm_status(
    btuner_t tuner,
    btuner_ofdm_status *status   
    )
{
  bresult result;
  b_lock();
  result = btuner_get_ofdm_status_impl(tuner, status);
  b_unlock();
  return result;
}

bresult btuner_get_soft_decisions(
    btuner_t tuner,
    btuner_soft_decision *data ,
    size_t length 
    )
{
  bresult result;
  b_lock();
  result = btuner_get_soft_decisions_impl(tuner, data, length);
  b_unlock();
  return result;
}

bmem_ptr bmem_alloc(
        size_t buffer_length
)
{
  bmem_ptr result;
  b_lock();
  result = bmem_alloc_impl(buffer_length);
  b_unlock();
  return result;
}

void bmem_free(
        void *buffer
)
{
  b_lock();
  bmem_free_impl(buffer);
  b_unlock();
  return;
}

bcablecard_t bcablecard_open(
        bobject_t cablecard_id 
        )
{
  bcablecard_t result;
  b_lock();
  result = bcablecard_open_impl(cablecard_id);
  b_unlock();
  return result;
}

void bcablecard_close(
        bcablecard_t cablecard 
        )
{
  b_lock();
  bcablecard_close_impl(cablecard);
  b_unlock();
  return;
}

void bcablecard_get(
        bcablecard_t cablecard,
        bcablecard_settings *settings 
        )
{
  b_lock();
  bcablecard_get_impl(cablecard, settings);
  b_unlock();
  return;
}

bresult bcablecard_set(
        bcablecard_t cablecard,
        const bcablecard_settings *settings
        )
{
  bresult result;
  b_lock();
  result = bcablecard_set_impl(cablecard, settings);
  b_unlock();
  return result;
}

bresult bcablecard_route_add_tuner(
   bcablecard_t cablecard,
   btuner_t tuner 
   )
{
  bresult result;
  b_lock();
  result = bcablecard_route_add_tuner_impl(cablecard, tuner);
  b_unlock();
  return result;
}

bresult bcablecard_route_remove_tuner(
   bcablecard_t cablecard,
   btuner_t tuner 
   )
{
  bresult result;
  b_lock();
  result = bcablecard_route_remove_tuner_impl(cablecard, tuner);
  b_unlock();
  return result;
}

bresult bcablecard_route_get(
        bcablecard_t cablecard,
        btuner_t tuner, 
        bcablecard_route_settings *settings 
        )
{
  bresult result;
  b_lock();
  result = bcablecard_route_get_impl(cablecard, tuner, settings);
  b_unlock();
  return result;
}