source: svn/trunk/newcon3bcm2_21bu/BSEAV/api/build/proxy/bsettop_autogen_usercall.c

/*********************************
*
* This file is autogenerated. Do not modify.
*
*********************************/
bdisplay_t bdisplay_open(
    bobject_t display_id 
    )
{
  int rc;
  ioctl_settopapi_struct_bdisplay_open st;
  st.display_id = display_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdisplay_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bdisplay_close(
    bdisplay_t display 
    )
{
  int rc;
  ioctl_settopapi_struct_bdisplay_close st;
  st.display = display;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdisplay_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult boutput_rf_set(boutput_rf_t rf,
    const boutput_rf_settings *settings)
{
  int rc;
  ioctl_settopapi_struct_boutput_rf_set st;
  st.rf = rf;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_rf_set, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void boutput_rf_get(boutput_rf_t rf,
    boutput_rf_settings *settings 
    )
{
  int rc;
  ioctl_settopapi_struct_boutput_rf_get st;
  st.rf = rf;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_rf_get, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult boutput_hdmi_set(boutput_hdmi_t dvi,
    const boutput_hdmi_settings *settings)
{
  int rc;
  ioctl_settopapi_struct_boutput_hdmi_set st;
  st.dvi = dvi;
  st.settings = settings;
  b_register_callback(ioctl_settopapi_boutput_dvi_settings_hdmi_hotplug_callback, (void*)dvi, settings->hdmi_hotplug_callback, (void*)settings->callback_context);
  b_register_callback(ioctl_settopapi_boutput_dvi_settings_hdmi_disconnect_callback, (void*)dvi, settings->hdmi_disconnect_callback, (void*)settings->callback_context);
  b_register_callback(ioctl_settopapi_boutput_dvi_settings_hdmi_hdcp_status_callback, (void*)dvi, settings->hdmi_hdcp_status_callback, (void*)settings->callback_context);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_hdmi_set, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void boutput_hdmi_get(boutput_hdmi_t dvi,
    boutput_hdmi_settings *settings 
    )
{
  int rc;
  ioctl_settopapi_struct_boutput_hdmi_get st;
  st.dvi = dvi;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_hdmi_get, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  settings->hdmi_hotplug_callback = b_lookup_callback(ioctl_settopapi_boutput_dvi_settings_hdmi_hotplug_callback, (void*)dvi);
  settings->hdmi_disconnect_callback = b_lookup_callback(ioctl_settopapi_boutput_dvi_settings_hdmi_disconnect_callback, (void*)dvi);
  settings->hdmi_hdcp_status_callback = b_lookup_callback(ioctl_settopapi_boutput_dvi_settings_hdmi_hdcp_status_callback, (void*)dvi);
}

bresult boutput_hdmi_get_capabilities(boutput_hdmi_t dvi,
                                     boutput_hdmi_capabilities *caps 
                                     )
{
  int rc;
  ioctl_settopapi_struct_boutput_hdmi_get_capabilities st;
  st.dvi = dvi;
  st.caps = caps;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_hdmi_get_capabilities, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult boutput_hdmi_get_status(boutput_hdmi_t dvi,
                                boutput_hdmi_status *status 
                                     )
{
  int rc;
  ioctl_settopapi_struct_boutput_hdmi_get_status st;
  st.dvi = dvi;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_hdmi_get_status, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult boutput_hdmi_cec_get_message(boutput_hdmi_t dvi,
                                boutput_hdmi_cec_message_data *cec_message_data 
                                )
{
  int rc;
  ioctl_settopapi_struct_boutput_hdmi_cec_get_message st;
  st.dvi = dvi;
  st.cec_message_data = cec_message_data;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_hdmi_cec_get_message, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult boutput_hdmi_cec_send_message(boutput_hdmi_t dvi,
                                const boutput_hdmi_cec_message_data *cec_message_data
                                )
{
  int rc;
  ioctl_settopapi_struct_boutput_hdmi_cec_send_message st;
  st.dvi = dvi;
  st.cec_message_data = cec_message_data;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_hdmi_cec_send_message, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult boutput_hdmi_cec_get_configuration(boutput_hdmi_t dvi,
                                boutput_hdmi_cec_configuration *cec_configuration   
                                )
{
  int rc;
  ioctl_settopapi_struct_boutput_hdmi_cec_get_configuration st;
  st.dvi = dvi;
  st.cec_configuration = cec_configuration;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_hdmi_cec_get_configuration, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bool boutput_hdmi_cec_is_device_ready(boutput_hdmi_t dvi)
{
  int rc;
  ioctl_settopapi_struct_boutput_hdmi_cec_is_device_ready st;
  st.dvi = dvi;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_hdmi_cec_is_device_ready, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bresult boutput_hdmi_cec_enable_receive(boutput_hdmi_t dvi)
{
  int rc;
  ioctl_settopapi_struct_boutput_hdmi_cec_enable_receive st;
  st.dvi = dvi;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_hdmi_cec_enable_receive, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult boutput_component_set(boutput_component_t component,
    const boutput_component_settings *settings)
{
  int rc;
  ioctl_settopapi_struct_boutput_component_set st;
  st.component = component;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_component_set, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void boutput_component_get(boutput_component_t component,
    boutput_component_settings *settings 
    )
{
  int rc;
  ioctl_settopapi_struct_boutput_component_get st;
  st.component = component;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_component_get, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult boutput_spdif_set(boutput_spdif_t spdif,
    const boutput_spdif_settings *settings)
{
  int rc;
  ioctl_settopapi_struct_boutput_spdif_set st;
  st.spdif = spdif;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_spdif_set, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void boutput_spdif_get(boutput_spdif_t spdif,
    boutput_spdif_settings *settings 
    )
{
  int rc;
  ioctl_settopapi_struct_boutput_spdif_get st;
  st.spdif = spdif;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_spdif_get, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

boutput_spdif_t
boutput_spdif_open(bobject_t spdif_id)
{
  int rc;
  ioctl_settopapi_struct_boutput_spdif_open st;
  st.spdif_id = spdif_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_spdif_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

boutput_rf_t
boutput_rf_open(bobject_t rfmod_id)
{
  int rc;
  ioctl_settopapi_struct_boutput_rf_open st;
  st.rfmod_id = rfmod_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_rf_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

boutput_composite_t
boutput_composite_open(bobject_t composite_id)
{
  int rc;
  ioctl_settopapi_struct_boutput_composite_open st;
  st.composite_id = composite_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_composite_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

boutput_svideo_t
boutput_svideo_open(bobject_t svideo_id)
{
  int rc;
  ioctl_settopapi_struct_boutput_svideo_open st;
  st.svideo_id = svideo_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_svideo_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

boutput_hdmi_t
boutput_hdmi_open(bobject_t dvi_id)
{
  int rc;
  ioctl_settopapi_struct_boutput_hdmi_open st;
  st.dvi_id = dvi_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_hdmi_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

boutput_component_t
boutput_component_open(bobject_t component_id)
{
  int rc;
  ioctl_settopapi_struct_boutput_component_open st;
  st.component_id = component_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_component_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bdisplay_get_video_format_settings(
    const bdisplay_settings *settings,
    bvideo_format_settings *format_settings 
    )
{
  int rc;
  ioctl_settopapi_struct_bdisplay_get_video_format_settings st;
  st.settings = settings;
  st.format_settings = format_settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdisplay_get_video_format_settings, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void bvideo_get_format_settings(
    bvideo_format format,           
    bvideo_format_settings *settings    
    )
{
  int rc;
  ioctl_settopapi_struct_bvideo_get_format_settings st;
  st.format = format;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bvideo_get_format_settings, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult
bdisplay_set(
    bdisplay_t display, 
    const bdisplay_settings *settings   
    )
{
  int rc;
  ioctl_settopapi_struct_bdisplay_set st;
  st.display = display;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdisplay_set, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void
bdisplay_get(
    bdisplay_t display, 
    bdisplay_settings *settings 
    )
{
  int rc;
  ioctl_settopapi_struct_bdisplay_get st;
  st.display = display;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdisplay_get, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bdecode_window_t bdecode_window_open(
    bobject_t window_id, 
    bdisplay_t display 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_window_open st;
  st.window_id = window_id;
  st.display = display;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_window_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bdecode_window_t bdecode_window_open_mosaic(
    bdecode_window_t parent_window, 
    bobject_t mosaic_id 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_window_open_mosaic st;
  st.parent_window = parent_window;
  st.mosaic_id = mosaic_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_window_open_mosaic, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void
bdecode_window_close(
    bdecode_window_t window
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_window_close st;
  st.window = window;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_window_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bdecode_window_t bdecode_window_clone(
            bdecode_window_t window, 
            bobject_t clone_window_id, 
            bdisplay_t display 
        )
{
  int rc;
  ioctl_settopapi_struct_bdecode_window_clone st;
  st.window = window;
  st.clone_window_id = clone_window_id;
  st.display = display;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_window_clone, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bresult bdisplay_set_dac_audio_volume(
    bdisplay_t display,     
    const baudio_volume *volume 
    )
{
  int rc;
  ioctl_settopapi_struct_bdisplay_set_dac_audio_volume st;
  st.display = display;
  st.volume = volume;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdisplay_set_dac_audio_volume, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdisplay_get_dac_audio_volume(
    bdisplay_t display,     
    baudio_volume *volume   
    )
{
  int rc;
  ioctl_settopapi_struct_bdisplay_get_dac_audio_volume st;
  st.display = display;
  st.volume = volume;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdisplay_get_dac_audio_volume, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult boutput_rf_set_audio_volume(
    boutput_rf_t rf,
    const baudio_volume *volume 
    )
{
  int rc;
  ioctl_settopapi_struct_boutput_rf_set_audio_volume st;
  st.rf = rf;
  st.volume = volume;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_rf_set_audio_volume, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult boutput_spdif_set_audio_volume(
    boutput_spdif_t spdif,
    const baudio_volume *volume 
    )
{
  int rc;
  ioctl_settopapi_struct_boutput_spdif_set_audio_volume st;
  st.spdif = spdif;
  st.volume = volume;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_spdif_set_audio_volume, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult boutput_spdif_get_audio_volume(
    boutput_spdif_t spdif,
    baudio_volume *volume 
    )
{
  int rc;
  ioctl_settopapi_struct_boutput_spdif_get_audio_volume st;
  st.spdif = spdif;
  st.volume = volume;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_spdif_get_audio_volume, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult boutput_rf_get_audio_volume(
    boutput_rf_t rf,
    baudio_volume *volume   
    )
{
  int rc;
  ioctl_settopapi_struct_boutput_rf_get_audio_volume st;
  st.rf = rf;
  st.volume = volume;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_boutput_rf_get_audio_volume, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdecode_window_get(
    bdecode_window_t window,
    bdecode_window_settings *settings   
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_window_get st;
  st.window = window;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_window_get, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdecode_window_set(
    bdecode_window_t window,
    const bdecode_window_settings *settings
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_window_set st;
  st.window = window;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_window_set, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bmessage_stream_t bmessage_open(
        bmessage_format format
        )
{
  int rc;
  ioctl_settopapi_struct_bmessage_open st;
  st.format = format;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bmessage_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bmessage_stream_params_init(
        bmessage_stream_params *params,
        bmessage_stream_t stream)
{
  int rc;
  ioctl_settopapi_struct_bmessage_stream_params_init st;
  st.params = params;
  st.stream = stream;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bmessage_stream_params_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bmessage_start(
        bmessage_stream_t message_stream,
        const bmessage_stream_params *params
        )
{
  int rc;
  ioctl_settopapi_struct_bmessage_start st;
  st.message_stream = message_stream;
  st.params = params;
  b_register_callback(ioctl_settopapi_bmessage_data_ready_callback, (void*)message_stream, params->data_ready_callback, (void*)params->callback_context);
  b_register_callback(ioctl_settopapi_bmessage_overflow_callback, (void*)message_stream, params->overflow, (void*)params->callback_context);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bmessage_start, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bmessage_get_buffer(
        bmessage_stream_t message_stream, 
        const void ** p_bfr,                    
        size_t *length
        )
{
  int rc;
  ioctl_settopapi_struct_bmessage_get_buffer st;
  st.message_stream = message_stream;
  st.p_bfr = p_bfr;
  st.length = length;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bmessage_get_buffer, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  if (!st.__retval) {
  *st.p_bfr = b_kernel2user((unsigned long)*st.p_bfr, true);
  }
  return st.__retval;
}

bresult bmessage_read_complete(
        bmessage_stream_t message_stream, 
        size_t amount_consumed
        )
{
  int rc;
  ioctl_settopapi_struct_bmessage_read_complete st;
  st.message_stream = message_stream;
  st.amount_consumed = amount_consumed;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bmessage_read_complete, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bmessage_stop(
        bmessage_stream_t message_stream 
        )
{
  int rc;
  ioctl_settopapi_struct_bmessage_stop st;
  st.message_stream = message_stream;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bmessage_stop, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void bmessage_close(
        bmessage_stream_t message_stream 
        )
{
  int rc;
  ioctl_settopapi_struct_bmessage_close st;
  st.message_stream = message_stream;
  b_unregister_callback(ioctl_settopapi_bmessage_data_ready_callback, (void*)message_stream);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)message_stream);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  b_unregister_callback(ioctl_settopapi_bmessage_overflow_callback, (void*)message_stream);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)message_stream);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bmessage_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void brecpump_get_open_params(
                bobject_t id, 
                brecpump_open_params *open_params 
                )
{
  int rc;
  ioctl_settopapi_struct_brecpump_get_open_params st;
  st.id = id;
  st.open_params = open_params;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_brecpump_get_open_params, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

brecpump_t brecpump_open(
                bobject_t id, 
                const brecpump_open_params *open_params 
                )
{
  int rc;
  ioctl_settopapi_struct_brecpump_open st;
  st.id = id;
  st.open_params = open_params;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_brecpump_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void brecpump_close(brecpump_t recpump)
{
  int rc;
  ioctl_settopapi_struct_brecpump_close st;
  st.recpump = recpump;
  b_unregister_callback(ioctl_settopapi_brecpump_data_write_callback, (void*)recpump);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)recpump);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  b_unregister_callback(ioctl_settopapi_brecpump_index_write_callback, (void*)recpump);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)recpump);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  b_unregister_callback(ioctl_settopapi_brecpump_overflow_callback, (void*)recpump);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)recpump);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_brecpump_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void brecpump_params_init(
        brecpump_params *params, 
        brecpump_t recpump
        )
{
  int rc;
  ioctl_settopapi_struct_brecpump_params_init st;
  st.params = params;
  st.recpump = recpump;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_brecpump_params_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult brecpump_start(
        brecpump_t recpump,
        bstream_t stream,
        const brecpump_params *params
        )
{
  int rc;
  ioctl_settopapi_struct_brecpump_start st;
  st.recpump = recpump;
  st.stream = stream;
  st.params = params;
  b_register_callback(ioctl_settopapi_brecpump_data_write_callback, (void*)recpump, params->data_write_callback, (void*)params->callback_context);
  b_register_callback(ioctl_settopapi_brecpump_index_write_callback, (void*)recpump, params->index_write_callback, (void*)params->callback_context);
  b_register_callback(ioctl_settopapi_brecpump_overflow_callback, (void*)recpump, params->overflow, (void*)params->callback_context);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_brecpump_start, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult brecpump_stop(
        brecpump_t recpump
        )
{
  int rc;
  ioctl_settopapi_struct_brecpump_stop st;
  st.recpump = recpump;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_brecpump_stop, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void brecpump_immediate_stop(
        brecpump_t recpump
        )
{
  int rc;
  ioctl_settopapi_struct_brecpump_immediate_stop st;
  st.recpump = recpump;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_brecpump_immediate_stop, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult brecpump_data_get_buffer(
        brecpump_t recpump,
        const void **buffer, 
        size_t *buffer_size 
        )
{
  int rc;
  ioctl_settopapi_struct_brecpump_data_get_buffer st;
  st.recpump = recpump;
  st.buffer = buffer;
  st.buffer_size = buffer_size;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_brecpump_data_get_buffer, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  if (!st.__retval) {
  *st.buffer = b_kernel2user((unsigned long)*st.buffer, true);
  }
  return st.__retval;
}

bresult brecpump_index_get_buffer(
        brecpump_t recpump,
        const void **buffer, 
        size_t *buffer_size 
        )
{
  int rc;
  ioctl_settopapi_struct_brecpump_index_get_buffer st;
  st.recpump = recpump;
  st.buffer = buffer;
  st.buffer_size = buffer_size;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_brecpump_index_get_buffer, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  if (!st.__retval) {
  *st.buffer = b_kernel2user((unsigned long)*st.buffer, true);
  }
  return st.__retval;
}

bresult brecpump_data_write_complete(
        brecpump_t recpump,
        size_t amount_written
        )
{
  int rc;
  ioctl_settopapi_struct_brecpump_data_write_complete st;
  st.recpump = recpump;
  st.amount_written = amount_written;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_brecpump_data_write_complete, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult brecpump_index_write_complete(
        brecpump_t recpump,
        size_t amount_written
        )
{
  int rc;
  ioctl_settopapi_struct_brecpump_index_write_complete st;
  st.recpump = recpump;
  st.amount_written = amount_written;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_brecpump_index_write_complete, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void brecpump_get_status(
        brecpump_t recpump,
        brecpump_status *status 
        )
{
  int rc;
  ioctl_settopapi_struct_brecpump_get_status st;
  st.recpump = recpump;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_brecpump_get_status, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bcipher_t bcipher_open(
        bobject_t id
        )
{
  int rc;
  ioctl_settopapi_struct_bcipher_open st;
  st.id = id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bcipher_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bcipher_close(bcipher_t encrypt)
{
  int rc;
  ioctl_settopapi_struct_bcipher_close st;
  st.encrypt = encrypt;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bcipher_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void bcipher_settings_init(
        bcipher_settings *settings,     
        bcipher_t cipher                        
        )
{
  int rc;
  ioctl_settopapi_struct_bcipher_settings_init st;
  st.settings = settings;
  st.cipher = cipher;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bcipher_settings_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult
bcipher_convert_data(
        bcipher_t handle,               
        void *dest ,
        const void *source ,
        size_t datalen,                 
        const bcipher_settings *settings 
        )
{
  int rc;
  ioctl_settopapi_struct_bcipher_convert_data st;
  st.handle = handle;
  st.dest = dest;
  st.source = source;
  st.datalen = datalen;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bcipher_convert_data, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bencode_t bencode_open(
                bobject_t id 
                )
{
  int rc;
  ioctl_settopapi_struct_bencode_open st;
  st.id = id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bencode_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bencode_close(
                bencode_t encode 
                )
{
  int rc;
  ioctl_settopapi_struct_bencode_close st;
  st.encode = encode;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bencode_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void bencode_extended_settings_init(
        bencode_settings *settings,     
        bencode_quality quality,        
        bencode_t encode,               
        bencode_vpp_mode vpp_mode       
        )
{
  int rc;
  ioctl_settopapi_struct_bencode_extended_settings_init st;
  st.settings = settings;
  st.quality = quality;
  st.encode = encode;
  st.vpp_mode = vpp_mode;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bencode_extended_settings_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void bencode_settings_init(
        bencode_settings *settings, 
        bencode_quality quality,        
        bencode_t encode                        
        )
{
  int rc;
  ioctl_settopapi_struct_bencode_settings_init st;
  st.settings = settings;
  st.quality = quality;
  st.encode = encode;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bencode_settings_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bstream_t bencode_start(
        bencode_t encode, 
        bstream_t stream, 
        const bencode_settings *settings 
        )
{
  int rc;
  ioctl_settopapi_struct_bencode_start st;
  st.encode = encode;
  st.stream = stream;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bencode_start, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bencode_stop(
        bencode_t encode,       
        bstream_t stream        
        )
{
  int rc;
  ioctl_settopapi_struct_bencode_stop st;
  st.encode = encode;
  st.stream = stream;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bencode_stop, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void bpcm_play_settings_init(
        bpcm_play_settings *settings,   
        bpcm_play_t pcmplay             
        )
{
  int rc;
  ioctl_settopapi_struct_bpcm_play_settings_init st;
  st.settings = settings;
  st.pcmplay = pcmplay;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_play_settings_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bpcm_play_t bpcm_play_open(
        bobject_t id                            
        )
{
  int rc;
  ioctl_settopapi_struct_bpcm_play_open st;
  st.id = id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_play_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bpcm_play_close(
        bpcm_play_t pcmplay
        )
{
  int rc;
  ioctl_settopapi_struct_bpcm_play_close st;
  st.pcmplay = pcmplay;
  b_unregister_callback(ioctl_settopapi_bpcm_play_callback, (void*)pcmplay);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)pcmplay);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_play_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bpcm_play_start(
        bpcm_play_t pcmplay,
        bdisplay_t display,                                     
        const bpcm_play_settings *settings
        )
{
  int rc;
  ioctl_settopapi_struct_bpcm_play_start st;
  st.pcmplay = pcmplay;
  st.display = display;
  st.settings = settings;
  b_register_callback(ioctl_settopapi_bpcm_play_callback, (void*)pcmplay, settings->callback, (void*)settings->callback_context);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_play_start, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bpcm_play_get_status(
        bpcm_play_t pcmplay,
        bpcm_play_status *status 
        )
{
  int rc;
  ioctl_settopapi_struct_bpcm_play_get_status st;
  st.pcmplay = pcmplay;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_play_get_status, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bpcm_play_get_buffer(
        bpcm_play_t pcmplay,
        void **data,
        size_t *length
        )
{
  int rc;
  ioctl_settopapi_struct_bpcm_play_get_buffer st;
  st.pcmplay = pcmplay;
  st.data = data;
  st.length = length;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_play_get_buffer, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  if (!st.__retval) {
  *st.data = b_kernel2user((unsigned long)*st.data, true);
  }
  return st.__retval;
}

bresult bpcm_play_write_complete(
        bpcm_play_t pcmplay,
        size_t amount_written
        )
{
  int rc;
  ioctl_settopapi_struct_bpcm_play_write_complete st;
  st.pcmplay = pcmplay;
  st.amount_written = amount_written;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_play_write_complete, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bpcm_play_stop(
        bpcm_play_t pcmplay
        )
{
  int rc;
  ioctl_settopapi_struct_bpcm_play_stop st;
  st.pcmplay = pcmplay;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_play_stop, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bpcm_play_get_output_settings(
    bpcm_play_t pcmplay,
    bpcm_play_output_settings *settings 
    )
{
  int rc;
  ioctl_settopapi_struct_bpcm_play_get_output_settings st;
  st.pcmplay = pcmplay;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_play_get_output_settings, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bpcm_play_set_output_settings(
    bpcm_play_t pcmplay,
    const bpcm_play_output_settings *settings
    )
{
  int rc;
  ioctl_settopapi_struct_bpcm_play_set_output_settings st;
  st.pcmplay = pcmplay;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_play_set_output_settings, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bpcm_capture_settings_init(
    bpcm_capture_settings *settings,    
    bpcm_capture_t pcmcapture           
)
{
  int rc;
  ioctl_settopapi_struct_bpcm_capture_settings_init st;
  st.settings = settings;
  st.pcmcapture = pcmcapture;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_capture_settings_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bpcm_capture_t bpcm_capture_open(
    bobject_t id                                
)
{
  int rc;
  ioctl_settopapi_struct_bpcm_capture_open st;
  st.id = id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_capture_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bpcm_capture_close(
    bpcm_capture_t pcmcapture
)
{
  int rc;
  ioctl_settopapi_struct_bpcm_capture_close st;
  st.pcmcapture = pcmcapture;
  b_unregister_callback(ioctl_settopapi_bpcm_capture_callback, (void*)pcmcapture);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)pcmcapture);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_capture_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bpcm_capture_start(
    bpcm_capture_t pcmcapture,
    bdisplay_t display,                                 
    const bpcm_capture_settings *settings
)
{
  int rc;
  ioctl_settopapi_struct_bpcm_capture_start st;
  st.pcmcapture = pcmcapture;
  st.display = display;
  st.settings = settings;
  b_register_callback(ioctl_settopapi_bpcm_capture_callback, (void*)pcmcapture, settings->callback, (void*)settings->callback_context);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_capture_start, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bpcm_capture_get_buffer(
    bpcm_capture_t pcmcapture,
    void **data,
    size_t *length
)
{
  int rc;
  ioctl_settopapi_struct_bpcm_capture_get_buffer st;
  st.pcmcapture = pcmcapture;
  st.data = data;
  st.length = length;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_capture_get_buffer, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  if (!st.__retval) {
  *st.data = b_kernel2user((unsigned long)*st.data, true);
  }
  return st.__retval;
}

bresult bpcm_capture_read_complete(
    bpcm_capture_t pcmcapture,
    size_t amount_read
)
{
  int rc;
  ioctl_settopapi_struct_bpcm_capture_read_complete st;
  st.pcmcapture = pcmcapture;
  st.amount_read = amount_read;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_capture_read_complete, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bpcm_capture_stop(
    bpcm_capture_t pcmcapture
)
{
  int rc;
  ioctl_settopapi_struct_bpcm_capture_stop st;
  st.pcmcapture = pcmcapture;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bpcm_capture_stop, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bsmartcard_settings_init(
        bsmartcard_settings_t *settings
)
{
  int rc;
  ioctl_settopapi_struct_bsmartcard_settings_init st;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsmartcard_settings_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bsmartcard_t bsmartcard_open(
        bobject_t smartcard_id, 
        const bsmartcard_settings_t *settings 
)
{
  int rc;
  ioctl_settopapi_struct_bsmartcard_open st;
  st.smartcard_id = smartcard_id;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsmartcard_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bsmartcard_close(
        bsmartcard_t smartcard 
)
{
  int rc;
  ioctl_settopapi_struct_bsmartcard_close st;
  st.smartcard = smartcard;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsmartcard_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void bsmartcard_get_settings(
    bsmartcard_t smartcard,
    bsmartcard_settings_t *settings
)
{
  int rc;
  ioctl_settopapi_struct_bsmartcard_get_settings st;
  st.smartcard = smartcard;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsmartcard_get_settings, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bsmartcard_set_settings(
    bsmartcard_t smartcard,
    const bsmartcard_settings_t *settings
)
{
  int rc;
  ioctl_settopapi_struct_bsmartcard_set_settings st;
  st.smartcard = smartcard;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsmartcard_set_settings, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bsmartcard_read(
        bsmartcard_t smartcard, 
        void *data ,
        size_t length,                  
        size_t *length_read             
)
{
  int rc;
  ioctl_settopapi_struct_bsmartcard_read st;
  st.smartcard = smartcard;
  st.data = data;
  st.length = length;
  st.length_read = length_read;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsmartcard_read, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bsmartcard_write(
        bsmartcard_t smartcard, 
        const void *data ,
        size_t length,                  
        size_t *length_written  
)
{
  int rc;
  ioctl_settopapi_struct_bsmartcard_write st;
  st.smartcard = smartcard;
  st.data = data;
  st.length = length;
  st.length_written = length_written;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsmartcard_write, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bsmartcard_get_status(
        bsmartcard_t smartcard,
        bsmartcard_status *status               
)
{
  int rc;
  ioctl_settopapi_struct_bsmartcard_get_status st;
  st.smartcard = smartcard;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsmartcard_get_status, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bsmartcard_reset_card(
        bsmartcard_t smartcard, 
        void *data ,
        size_t length,                  
        size_t *length_read             
)
{
  int rc;
  ioctl_settopapi_struct_bsmartcard_reset_card st;
  st.smartcard = smartcard;
  st.data = data;
  st.length = length;
  st.length_read = length_read;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsmartcard_reset_card, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bsmartcard_reset(
        bsmartcard_t smartcard, 
        bool warm_reset 
)
{
  int rc;
  ioctl_settopapi_struct_bsmartcard_reset st;
  st.smartcard = smartcard;
  st.warm_reset = warm_reset;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsmartcard_reset, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bsmartcard_detect_card( 
                bsmartcard_t smartcard
)
{
  int rc;
  ioctl_settopapi_struct_bsmartcard_detect_card st;
  st.smartcard = smartcard;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsmartcard_detect_card, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bsmartcard_init(void)
{
  int rc;
  ioctl_settopapi_struct_bsmartcard_init st;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsmartcard_init, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bsmartcard_shutdown(void)
{
  int rc;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsmartcard_shutdown, NULL);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

buser_input_t buser_input_open(
                     bobject_t user_input_id 
                    )
{
  int rc;
  ioctl_settopapi_struct_buser_input_open st;
  st.user_input_id = user_input_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_buser_input_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void buser_input_close(
        buser_input_t ui 
    )
{
  int rc;
  ioctl_settopapi_struct_buser_input_close st;
  st.ui = ui;
  b_unregister_callback(ioctl_settopapi_buser_input_data_ready_callback, (void*)ui);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)ui);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_buser_input_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void buser_input_get_settings(
        buser_input_t ui,
        buser_input_settings *settings)
{
  int rc;
  ioctl_settopapi_struct_buser_input_get_settings st;
  st.ui = ui;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_buser_input_get_settings, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void buser_input_set_settings(
        buser_input_t ui,
        const buser_input_settings *settings)
{
  int rc;
  ioctl_settopapi_struct_buser_input_set_settings st;
  st.ui = ui;
  st.settings = settings;
  b_register_callback(ioctl_settopapi_buser_input_data_ready_callback, (void*)ui, settings->data_ready_callback, (void*)settings->callback_context);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_buser_input_set_settings, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult buser_input_get_event(
        buser_input_t ui, 
        buser_input_event *event ,
        unsigned nevents, 
        unsigned *result_nevents 
        )
{
  int rc;
  ioctl_settopapi_struct_buser_input_get_event st;
  st.ui = ui;
  st.event = event;
  st.nevents = nevents;
  st.result_nevents = result_nevents;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_buser_input_get_event, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

buser_output_t buser_output_open(
        bobject_t user_output_id 
        )
{
  int rc;
  ioctl_settopapi_struct_buser_output_open st;
  st.user_output_id = user_output_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_buser_output_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void buser_output_close(
        buser_output_t uo 
        )
{
  int rc;
  ioctl_settopapi_struct_buser_output_close st;
  st.uo = uo;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_buser_output_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult buser_output_set_led(
        buser_output_t ui, 
        unsigned led, 
        bool on                 
        )
{
  int rc;
  ioctl_settopapi_struct_buser_output_set_led st;
  st.ui = ui;
  st.led = led;
  st.on = on;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_buser_output_set_led, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult buser_output_display_message(
        buser_output_t ui, 
        const char *message     
        )
{
  int rc;
  ioctl_settopapi_struct_buser_output_display_message st;
  st.ui = ui;
  st.message = message;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_buser_output_display_message, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void buser_input_set_xmp_settings(
        buser_input_t ui,
        const buser_input_xmp_settings *settings)
{
  int rc;
  ioctl_settopapi_struct_buser_input_set_xmp_settings st;
  st.ui = ui;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_buser_input_set_xmp_settings, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void buser_input_get_xmp_settings(
        buser_input_t ui,
        buser_input_xmp_settings *settings)
{
  int rc;
  ioctl_settopapi_struct_buser_input_get_xmp_settings st;
  st.ui = ui;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_buser_input_get_xmp_settings, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult buser_input_send_xmp(
        buser_input_t remote, 
        const uint8_t *input_buffer ,
        size_t length 
        )
{
  int rc;
  ioctl_settopapi_struct_buser_input_send_xmp st;
  st.remote = remote;
  st.input_buffer = input_buffer;
  st.length = length;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_buser_input_send_xmp, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult buser_input_receive_xmp(
        buser_input_t remote, 
        uint8_t *output_data ,
        size_t length,
        unsigned *output_size,
        uint32_t *data_packet
        )
{
  int rc;
  ioctl_settopapi_struct_buser_input_receive_xmp st;
  st.remote = remote;
  st.output_data = output_data;
  st.length = length;
  st.output_size = output_size;
  st.data_packet = data_packet;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_buser_input_receive_xmp, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bgraphics_t bgraphics_open(
        bobject_t id,
        bdisplay_t display      
        )
{
  int rc;
  ioctl_settopapi_struct_bgraphics_open st;
  st.id = id;
  st.display = display;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bgraphics_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bgraphics_close(
        bgraphics_t graphics    
        )
{
  int rc;
  ioctl_settopapi_struct_bgraphics_close st;
  st.graphics = graphics;
  b_unregister_callback(ioctl_settopapi_bgraphics_operation_complete_callback, (void*)graphics);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)graphics);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bgraphics_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void bgraphics_get(
        bgraphics_t graphics,   
        bgraphics_settings *settings 
        )
{
  int rc;
  ioctl_settopapi_struct_bgraphics_get st;
  st.graphics = graphics;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bgraphics_get, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bgraphics_set(
        bgraphics_t graphics,   
        const bgraphics_settings *settings
        )
{
  int rc;
  ioctl_settopapi_struct_bgraphics_set st;
  st.graphics = graphics;
  st.settings = settings;
  b_register_callback(ioctl_settopapi_bgraphics_operation_complete_callback, (void*)graphics, settings->operation_complete_callback, (void*)settings->callback_context);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bgraphics_set, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bgraphics_sync(
        bgraphics_t graphics    
        )
{
  int rc;
  ioctl_settopapi_struct_bgraphics_sync st;
  st.graphics = graphics;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bgraphics_sync, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bsurface_sync(
        bsurface_t surface      
        )
{
  int rc;
  ioctl_settopapi_struct_bsurface_sync st;
  st.surface = surface;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsurface_sync, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bgraphics_flip(
        bgraphics_t graphics    
        )
{
  int rc;
  ioctl_settopapi_struct_bgraphics_flip st;
  st.graphics = graphics;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bgraphics_flip, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bgraphics_flip_sync(
        bgraphics_t graphics    
        )
{
  int rc;
  ioctl_settopapi_struct_bgraphics_flip_sync st;
  st.graphics = graphics;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bgraphics_flip_sync, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bsurface_create_settings_init(
        bsurface_create_settings *create_settings,      
        bgraphics_t graphics            
        )
{
  int rc;
  ioctl_settopapi_struct_bsurface_create_settings_init st;
  st.create_settings = create_settings;
  st.graphics = graphics;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsurface_create_settings_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bsurface_t bgraphics_create_framebuffer(
        bgraphics_t graphics,   
        const bsurface_create_settings *create_settings,
        unsigned int back_buffer_count 
        )
{
  int rc;
  ioctl_settopapi_struct_bgraphics_create_framebuffer st;
  st.graphics = graphics;
  st.create_settings = create_settings;
  st.back_buffer_count = back_buffer_count;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bgraphics_create_framebuffer, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bsurface_t bsurface_create(
        bgraphics_t graphics,   
        const bsurface_create_settings *create_settings
        )
{
  int rc;
  ioctl_settopapi_struct_bsurface_create st;
  st.graphics = graphics;
  st.create_settings = create_settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsurface_create, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bsurface_t bsurface_get_display(
        bgraphics_t graphics,   
        const bsurface_create_settings *create_settings
        )
{
  int rc;
  ioctl_settopapi_struct_bsurface_get_display st;
  st.graphics = graphics;
  st.create_settings = create_settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsurface_get_display, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bsurface_destroy(
        bsurface_t surface      
        )
{
  int rc;
  ioctl_settopapi_struct_bsurface_destroy st;
  st.surface = surface;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsurface_destroy, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bsurface_get_memory(
        bsurface_t s,
        bsurface_memory *memory 
        )
{
  int rc;
  ioctl_settopapi_struct_bsurface_get_memory st;
  st.s = s;
  st.memory = memory;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsurface_get_memory, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  if (!st.__retval) {
  memory->buffer = b_kernel2user((unsigned long)memory->buffer, true);
  }
  return st.__retval;
}

bresult bsurface_set(
        bsurface_t s,
        const bsurface_settings *settings
        )
{
  int rc;
  ioctl_settopapi_struct_bsurface_set st;
  st.s = s;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsurface_set, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bsurface_get(
        bsurface_t s,
        bsurface_settings *settings 
        )
{
  int rc;
  ioctl_settopapi_struct_bsurface_get st;
  st.s = s;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsurface_get, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bsurface_fill(
        bsurface_t surface,             
        const bsettop_rect *rect,       
        bgraphics_pixel pixel 
        )
{
  int rc;
  ioctl_settopapi_struct_bsurface_fill st;
  st.surface = surface;
  st.rect = rect;
  st.pixel = pixel;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsurface_fill, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bsurface_copy(
        bsurface_t destsurface,         
        const bsettop_rect *destrect,    
        bsurface_t srcsurface,          
        const bsettop_rect *srcrect      
        )
{
  int rc;
  ioctl_settopapi_struct_bsurface_copy st;
  st.destsurface = destsurface;
  st.destrect = destrect;
  st.srcsurface = srcsurface;
  st.srcrect = srcrect;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsurface_copy, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

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                  
        )
{
  int rc;
  ioctl_settopapi_struct_bsurface_blit st;
  st.destsurface = destsurface;
  st.destrect = destrect;
  st.operation = operation;
  st.src1 = src1;
  st.src1_rect = src1_rect;
  st.src2 = src2;
  st.src2_rect = src2_rect;
  st.pixel1 = pixel1;
  st.pixel2 = pixel2;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsurface_blit, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bsurface_blit_params_init(bsurface_blit_params *params)
{
  int rc;
  ioctl_settopapi_struct_bsurface_blit_params_init st;
  st.params = params;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsurface_blit_params_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bsurface_extended_blit(
        bsurface_t destsurface,
        const bsettop_rect *destrect,
        const bsurface_blit_params *params
        )
{
  int rc;
  ioctl_settopapi_struct_bsurface_extended_blit st;
  st.destsurface = destsurface;
  st.destrect = destrect;
  st.params = params;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsurface_extended_blit, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

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

        )
{
  int rc;
  ioctl_settopapi_struct_bsurface_blended_fill st;
  st.surface = surface;
  st.rect = rect;
  st.pixel = pixel;
  st.operation = operation;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsurface_blended_fill, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bsurface_load_clut(
        bsurface_t s,
        bgraphics_palette palette)
{
  int rc;
  ioctl_settopapi_struct_bsurface_load_clut st;
  st.s = s;
  st.palette = palette;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsurface_load_clut, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bplaypump_get_open_params(
                bobject_t id, 
                bplaypump_open_params *open_params 
                )
{
  int rc;
  ioctl_settopapi_struct_bplaypump_get_open_params st;
  st.id = id;
  st.open_params = open_params;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_get_open_params, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bplaypump_t bplaypump_open(
                bobject_t id,
                const bplaypump_open_params *open_params 
                )
{
  int rc;
  ioctl_settopapi_struct_bplaypump_open st;
  st.id = id;
  st.open_params = open_params;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bplaypump_close(bplaypump_t playpump)
{
  int rc;
  ioctl_settopapi_struct_bplaypump_close st;
  st.playpump = playpump;
  b_unregister_callback(ioctl_settopapi_bplaypump_read_callback, (void*)playpump);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)playpump);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void bplaypump_params_init(
        bplaypump_params *params, 
        bplaypump_t playpump
        )
{
  int rc;
  ioctl_settopapi_struct_bplaypump_params_init st;
  st.params = params;
  st.playpump = playpump;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_params_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bstream_t bplaypump_start(
        bplaypump_t playpump,
        const bstream_mpeg *mpeg, 
        const bplaypump_params *params
        )
{
  int rc;
  ioctl_settopapi_struct_bplaypump_start st;
  st.playpump = playpump;
  st.mpeg = mpeg;
  st.params = params;
  b_register_callback(ioctl_settopapi_bplaypump_read_callback, (void*)playpump, params->read_callback, (void*)params->callback_context);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_start, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bresult bplaypump_stop(
        bplaypump_t playpump
        )
{
  int rc;
  ioctl_settopapi_struct_bplaypump_stop st;
  st.playpump = playpump;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_stop, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bplaypump_get_buffer(
        bplaypump_t playpump,
        void **buffer, 
        size_t *size 
        )
{
  int rc;
  ioctl_settopapi_struct_bplaypump_get_buffer st;
  st.playpump = playpump;
  st.buffer = buffer;
  st.size = size;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_get_buffer, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  if (!st.__retval) {
  *st.buffer = b_kernel2user((unsigned long)*st.buffer, true);
  }
  return st.__retval;
}

bresult bplaypump_read_complete(
        bplaypump_t playpump,
        size_t skip, 
        size_t amount 
        )
{
  int rc;
  ioctl_settopapi_struct_bplaypump_read_complete st;
  st.playpump = playpump;
  st.skip = skip;
  st.amount = amount;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_read_complete, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bplaypump_set(
        bplaypump_t playpump,
        const bplaypump_settings *settings
        )
{
  int rc;
  ioctl_settopapi_struct_bplaypump_set st;
  st.playpump = playpump;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_set, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bplaypump_get(
        bplaypump_t playpump,
        bplaypump_settings *settings
        )
{
  int rc;
  ioctl_settopapi_struct_bplaypump_get st;
  st.playpump = playpump;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_get, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bplaypump_set_state(
        bplaypump_t playpump,
        bplaypump_state state,
        bool forward
        )
{
  int rc;
  ioctl_settopapi_struct_bplaypump_set_state st;
  st.playpump = playpump;
  st.state = state;
  st.forward = forward;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_set_state, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bplaypump_set_decoder_rate(
        bplaypump_t playpump,
        unsigned rate
        )
{
  int rc;
  ioctl_settopapi_struct_bplaypump_set_decoder_rate st;
  st.playpump = playpump;
  st.rate = rate;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_set_decoder_rate, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bplaypump_frame_advance(
        bplaypump_t playpump
        )
{
  int rc;
  ioctl_settopapi_struct_bplaypump_frame_advance st;
  st.playpump = playpump;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_frame_advance, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bplaypump_flush(
        bplaypump_t playpump
        )
{
  int rc;
  ioctl_settopapi_struct_bplaypump_flush st;
  st.playpump = playpump;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_flush, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bplaypump_get_status(
        bplaypump_t p,
        bplaypump_status *status 
        )
{
  int rc;
  ioctl_settopapi_struct_bplaypump_get_status st;
  st.p = p;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_get_status, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  if (!st.__retval) {
  status->buffer_base = b_kernel2user((unsigned long)status->buffer_base, true);
  }
  return st.__retval;
}

bresult bplaypump_p_set_pwm_value(
        bplaypump_t p, 
        int pwm_value)
{
  int rc;
  ioctl_settopapi_struct_bplaypump_p_set_pwm_value st;
  st.p = p;
  st.pwm_value = pwm_value;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_p_set_pwm_value, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bplaypump_get_source(bplaypump_t playpump, bplaypump_source *source)
{
  int rc;
  ioctl_settopapi_struct_bplaypump_get_source st;
  st.playpump = playpump;
  st.source = source;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_get_source, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bplaypump_set_source(bplaypump_t playpump, const bplaypump_source *source)
{
  int rc;
  ioctl_settopapi_struct_bplaypump_set_source st;
  st.playpump = playpump;
  st.source = source;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_set_source, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bplaypump_get_rtp_hdr_data(bplaypump_t p, const bplaypump_rtp_hdr_data_t *rtp_header_data, unsigned *entry_cnt)
{
  int rc;
  ioctl_settopapi_struct_bplaypump_get_rtp_hdr_data st;
  st.p = p;
  st.rtp_header_data = rtp_header_data;
  st.entry_cnt = entry_cnt;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bplaypump_get_rtp_hdr_data, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bencryption_params_init(
        bencryption_params *encryption  
)
{
  int rc;
  ioctl_settopapi_struct_bencryption_params_init st;
  st.encryption = encryption;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bencryption_params_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void bstream_mpeg_init(
        bstream_mpeg *mpeg              
        )
{
  int rc;
  ioctl_settopapi_struct_bstream_mpeg_init st;
  st.mpeg = mpeg;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_mpeg_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bband_t bstreamer_attach(
        bobject_t id,
        bstream_mpeg_type mpeg_type     
        )
{
  int rc;
  ioctl_settopapi_struct_bstreamer_attach st;
  st.id = id;
  st.mpeg_type = mpeg_type;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstreamer_attach, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bstream_t bstream_open(
        bband_t band,   
        const bstream_mpeg *mpegparams  
        )
{
  int rc;
  ioctl_settopapi_struct_bstream_open st;
  st.band = band;
  st.mpegparams = mpegparams;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bresult bstream_set_encryption(
        bstream_t stream,
        const bencryption_params *encryption
        )
{
  int rc;
  ioctl_settopapi_struct_bstream_set_encryption st;
  st.stream = stream;
  st.encryption = encryption;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_set_encryption, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bstream_join(bstream_t video_source, bstream_t audio_source)
{
  int rc;
  ioctl_settopapi_struct_bstream_join st;
  st.video_source = video_source;
  st.audio_source = audio_source;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_join, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bstream_t bstream_open_child(bstream_t parent, const bstream_mpeg *mpegparams)
{
  int rc;
  ioctl_settopapi_struct_bstream_open_child st;
  st.parent = parent;
  st.mpegparams = mpegparams;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_open_child, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bstream_close(
        bstream_t stream        
        )
{
  int rc;
  ioctl_settopapi_struct_bstream_close st;
  st.stream = stream;
  b_unregister_callback(ioctl_settopapi_bvbi_cc_data_ready_callback, (void*)stream);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)stream);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult
bstream_get_mpeg_parameters(
        bstream_t stream,
        bstream_status *status  
        )
{
  int rc;
  ioctl_settopapi_struct_bstream_get_mpeg_parameters st;
  st.stream = stream;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_get_mpeg_parameters, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult
bstream_set_mpeg_parameters(
        bstream_t stream,
        const bstream_mpeg *mpeg
        )
{
  int rc;
  ioctl_settopapi_struct_bstream_set_mpeg_parameters st;
  st.stream = stream;
  st.mpeg = mpeg;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_set_mpeg_parameters, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bband_get(
        bband_t band,
        bband_settings *settings 
        )
{
  int rc;
  ioctl_settopapi_struct_bband_get st;
  st.band = band;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bband_get, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bstream_start_pcr_monitor(bstream_t stream)
{
  int rc;
  ioctl_settopapi_struct_bstream_start_pcr_monitor st;
  st.stream = stream;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_start_pcr_monitor, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bstream_stop_pcr_monitor(bstream_t stream)
{
  int rc;
  ioctl_settopapi_struct_bstream_stop_pcr_monitor st;
  st.stream = stream;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_stop_pcr_monitor, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bstream_get_pcr_status(bstream_t stream, bstream_pcr_status *status)
{
  int rc;
  ioctl_settopapi_struct_bstream_get_pcr_status st;
  st.stream = stream;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_get_pcr_status, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bstream_vbi_get_settings(
        bstream_t stream,                                       
        bstream_vbi_settings *settings  
        )
{
  int rc;
  ioctl_settopapi_struct_bstream_vbi_get_settings st;
  st.stream = stream;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_vbi_get_settings, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bstream_vbi_set_settings(
        bstream_t stream,                                       
        const bstream_vbi_settings *settings    
        )
{
  int rc;
  ioctl_settopapi_struct_bstream_vbi_set_settings st;
  st.stream = stream;
  st.settings = settings;
  b_register_callback(ioctl_settopapi_bvbi_cc_data_ready_callback, (void*)stream, settings->cc_data_ready_callback, (void*)settings->callback_context);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_vbi_set_settings, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bstream_vbi_cc_read(
        bstream_t stream,                       
        bstream_vbi_cc *data ,
        size_t length,                          
        size_t *length_read                     
        )
{
  int rc;
  ioctl_settopapi_struct_bstream_vbi_cc_read st;
  st.stream = stream;
  st.data = data;
  st.length = length;
  st.length_read = length_read;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_vbi_cc_read, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bstream_vbi_cc708_read(
        bstream_t stream,                       
        bstream_cc_708 *data ,
        size_t length,                          
        size_t *length_read                     
        )
{
  int rc;
  ioctl_settopapi_struct_bstream_vbi_cc708_read st;
  st.stream = stream;
  st.data = data;
  st.length = length;
  st.length_read = length_read;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_vbi_cc708_read, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdisplay_vbi_cc_write(
        bdisplay_t display,                     
        const bstream_vbi_cc *data ,
        size_t length,                          
        size_t *length_written          
        )
{
  int rc;
  ioctl_settopapi_struct_bdisplay_vbi_cc_write st;
  st.display = display;
  st.data = data;
  st.length = length;
  st.length_written = length_written;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdisplay_vbi_cc_write, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bstream_vbi_tt_read(
        bstream_t stream,                       
        bstream_vbi_tt *data ,
        size_t length,                          
        size_t *length_read                     
        )
{
  int rc;
  ioctl_settopapi_struct_bstream_vbi_tt_read st;
  st.stream = stream;
  st.data = data;
  st.length = length;
  st.length_read = length_read;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bstream_vbi_tt_read, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdisplay_vbi_tt_write(
        bdisplay_t display,                     
        const bstream_vbi_tt *data ,
        size_t length,                          
    uint8_t polarity             
        )
{
  int rc;
  ioctl_settopapi_struct_bdisplay_vbi_tt_write st;
  st.display = display;
  st.data = data;
  st.length = length;
  st.polarity = polarity;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdisplay_vbi_tt_write, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdisplay_vbi_set_cgms(
        bdisplay_t display,                     
        uint32_t cgms_value                     
        )
{
  int rc;
  ioctl_settopapi_struct_bdisplay_vbi_set_cgms st;
  st.display = display;
  st.cgms_value = cgms_value;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdisplay_vbi_set_cgms, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdisplay_vbi_set_wss(
        bdisplay_t display,                     
        uint16_t wss_value                      
        )
{
  int rc;
  ioctl_settopapi_struct_bdisplay_vbi_set_wss st;
  st.display = display;
  st.wss_value = wss_value;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdisplay_vbi_set_wss, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdisplay_vbi_get_cgms(
        bdisplay_t display,                     
        bool *enabled
        )
{
  int rc;
  ioctl_settopapi_struct_bdisplay_vbi_get_cgms st;
  st.display = display;
  st.enabled = enabled;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdisplay_vbi_get_cgms, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdisplay_vbi_get_wss(
        bdisplay_t display,                     
        bool *enabled
        )
{
  int rc;
  ioctl_settopapi_struct_bdisplay_vbi_get_wss st;
  st.display = display;
  st.enabled = enabled;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdisplay_vbi_get_wss, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bdecode_t bdecode_open(
    bobject_t decode_id 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_open st;
  st.decode_id = decode_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bdecode_mosaic_settings_init(
    bdecode_t parent,                 
    bdecode_mosaic_settings *settings 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_mosaic_settings_init st;
  st.parent = parent;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_mosaic_settings_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bdecode_t bdecode_open_mosaic(
    bdecode_t parent,                       
    bobject_t decode_id,                    
    const bdecode_mosaic_settings *settings 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_open_mosaic st;
  st.parent = parent;
  st.decode_id = decode_id;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_open_mosaic, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bdecode_close(
    bdecode_t decode 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_close st;
  st.decode = decode;
  b_unregister_callback(ioctl_settopapi_bdecode_settings_still_picture_done, (void*)decode);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)decode);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  b_unregister_callback(ioctl_settopapi_bdecode_settings_video_source_changed, (void*)decode);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)decode);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  b_unregister_callback(ioctl_settopapi_bdecode_settings_audio_source_changed, (void*)decode);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)decode);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void bdecode_get(
    bdecode_t decode, 
    bdecode_settings *settings 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_get st;
  st.decode = decode;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_get, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  settings->still_picture_done = b_lookup_callback(ioctl_settopapi_bdecode_settings_still_picture_done, (void*)decode);
  settings->video.source_changed = b_lookup_callback(ioctl_settopapi_bdecode_settings_video_source_changed, (void*)decode);
  settings->audio.source_changed = b_lookup_callback(ioctl_settopapi_bdecode_settings_audio_source_changed, (void*)decode);
}

bresult bdecode_set(
    bdecode_t decode, 
    const bdecode_settings *settings
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_set st;
  st.decode = decode;
  st.settings = settings;
  b_register_callback(ioctl_settopapi_bdecode_settings_still_picture_done, (void*)decode, settings->still_picture_done, (void*)settings->callback_context);
  b_register_callback(ioctl_settopapi_bdecode_settings_video_source_changed, (void*)decode, settings->video.source_changed, (void*)settings->callback_context);
  b_register_callback(ioctl_settopapi_bdecode_settings_audio_source_changed, (void*)decode, settings->audio.source_changed, (void*)settings->callback_context);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_set, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdecode_display_surface(
    bdecode_t decode, 
    bsurface_t surface,
    bdecode_window_t window
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_display_surface st;
  st.decode = decode;
  st.surface = surface;
  st.window = window;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_display_surface, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdecode_start(
    bdecode_t decode, 
    bstream_t source, 
    bdecode_window_t window 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_start st;
  st.decode = decode;
  st.source = source;
  st.window = window;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_start, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bdecode_stop(
    bdecode_t decode 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_stop st;
  st.decode = decode;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_stop, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

baudio_decode_t bdecode_detach_audio(
    bdecode_t decode 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_detach_audio st;
  st.decode = decode;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_detach_audio, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bresult bdecode_attach_audio(
    bdecode_t decode, 
    baudio_decode_t audio 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_attach_audio st;
  st.decode = decode;
  st.audio = audio;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_attach_audio, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdecode_set_audio_program(
    bdecode_t decode, 
    unsigned index 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_set_audio_program st;
  st.decode = decode;
  st.index = index;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_set_audio_program, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

baudio_decode_t bdecode_get_audio(
    bdecode_t decode, 
    bobject_t audio_id 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_get_audio st;
  st.decode = decode;
  st.audio_id = audio_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_get_audio, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bvideo_decode_t bdecode_detach_video(
        bdecode_t decode 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_detach_video st;
  st.decode = decode;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_detach_video, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bresult bdecode_attach_video(
        bdecode_t decode, 
        bvideo_decode_t video 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_attach_video st;
  st.decode = decode;
  st.video = video;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_attach_video, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdecode_set_video_program(
        bdecode_t decode, 
        unsigned index 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_set_video_program st;
  st.decode = decode;
  st.index = index;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_set_video_program, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bvideo_decode_t bdecode_get_video(
    bdecode_t decode, 
    bobject_t video_id 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_get_video st;
  st.decode = decode;
  st.video_id = video_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_get_video, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void baudio_decode_get_status(
    baudio_decode_t audio, 
    baudio_decode_status *status 
    )
{
  int rc;
  ioctl_settopapi_struct_baudio_decode_get_status st;
  st.audio = audio;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_baudio_decode_get_status, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void bvideo_decode_get_status(
    bvideo_decode_t video, 
    bvideo_decode_status *status
    )
{
  int rc;
  ioctl_settopapi_struct_bvideo_decode_get_status st;
  st.video = video;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bvideo_decode_get_status, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bdecode_get_status(
    bdecode_t decode,  
    bdecode_status *status  
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_get_status st;
  st.decode = decode;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_get_status, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdecode_set_audio_volume(
    bdecode_t decode,
    const baudio_volume *volume
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_set_audio_volume st;
  st.decode = decode;
  st.volume = volume;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_set_audio_volume, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdecode_get_audio_volume(
    bdecode_t decode,
    baudio_volume *volume   
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_get_audio_volume st;
  st.decode = decode;
  st.volume = volume;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_get_audio_volume, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdecode_get_stc(bdecode_t decode, uint32_t *stc)
{
  int rc;
  ioctl_settopapi_struct_bdecode_get_stc st;
  st.decode = decode;
  st.stc = stc;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_get_stc, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdecode_set_stc(bdecode_t decode, uint32_t stc)
{
  int rc;
  ioctl_settopapi_struct_bdecode_set_stc st;
  st.decode = decode;
  st.stc = stc;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_set_stc, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bdecode_slow_clock(
    bdecode_t decode,
    bool slow
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_slow_clock st;
  st.decode = decode;
  st.slow = slow;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_slow_clock, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bdecode_read_metadata(
    bdecode_t decode,
    void *buffer ,
    unsigned size, 
    unsigned *amount_read 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_read_metadata st;
  st.decode = decode;
  st.buffer = buffer;
  st.size = size;
  st.amount_read = amount_read;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_read_metadata, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bdecode_allocate_capture_buffers(
    bdecode_t decode, 
    unsigned count 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_allocate_capture_buffers st;
  st.decode = decode;
  st.count = count;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_allocate_capture_buffers, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bsurface_t bdecode_acquire_capture_buffer(
    bdecode_t decode,
    bgraphics_t graphics,
    bool *top_field 
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_acquire_capture_buffer st;
  st.decode = decode;
  st.graphics = graphics;
  st.top_field = top_field;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_acquire_capture_buffer, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bresult bdecode_release_capture_buffer(
    bdecode_t decode, 
    bsurface_t surface
    )
{
  int rc;
  ioctl_settopapi_struct_bdecode_release_capture_buffer st;
  st.decode = decode;
  st.surface = surface;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bdecode_release_capture_buffer, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

void bsettop_get_power_state(bsettop_power_state *state)
{
  int rc;
  ioctl_settopapi_struct_bsettop_get_power_state st;
  st.state = state;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsettop_get_power_state, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bsettop_set_power_state(const bsettop_power_state *state)
{
  int rc;
  ioctl_settopapi_struct_bsettop_set_power_state st;
  st.state = state;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsettop_set_power_state, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

int bsettop_init_frontend(void)
{
  int rc;
  ioctl_settopapi_struct_bsettop_init_frontend st;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bsettop_init_frontend, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

btuner_t btuner_open(
                     bobject_t tuner_id 
                    )
{
  int rc;
  ioctl_settopapi_struct_btuner_open st;
  st.tuner_id = tuner_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void btuner_close(
                  btuner_t tuner 
                 )
{
  int rc;
  ioctl_settopapi_struct_btuner_close st;
  st.tuner = tuner;
  b_unregister_callback(ioctl_settopapi_btuner_qam_params_lock_callback, (void*)tuner);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)tuner);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  b_unregister_callback(ioctl_settopapi_btuner_oob_params_lock_callback, (void*)tuner);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)tuner);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  b_unregister_callback(ioctl_settopapi_btuner_sds_params_lock_callback, (void*)tuner);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)tuner);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  b_unregister_callback(ioctl_settopapi_btuner_vsb_params_lock_callback, (void*)tuner);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_free_handle_callbacks, (void*)tuner);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void btuner_qam_params_init(
    btuner_qam_params *qam,     
    btuner_t tuner              
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_qam_params_init st;
  st.qam = qam;
  st.tuner = tuner;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_qam_params_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void btuner_ofdm_params_init(
    btuner_ofdm_params *ofdm,    
    btuner_t tuner              
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_ofdm_params_init st;
  st.ofdm = ofdm;
  st.tuner = tuner;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_ofdm_params_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void btuner_analog_params_init(
    btuner_analog_params *analog,   
    btuner_t tuner                  
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_analog_params_init st;
  st.analog = analog;
  st.tuner = tuner;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_analog_params_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void btuner_qam_us_params_init(
    btuner_qam_us_params *us_param,     
    btuner_t tuner              
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_qam_us_params_init st;
  st.us_param = us_param;
  st.tuner = tuner;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_qam_us_params_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void btuner_sds_params_init(
    btuner_sds_params *sds,     
    btuner_t tuner              
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_sds_params_init st;
  st.sds = sds;
  st.tuner = tuner;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_sds_params_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void btuner_vsb_params_init(
    btuner_vsb_params *vsb,     
    btuner_t tuner              
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_vsb_params_init st;
  st.vsb = vsb;
  st.tuner = tuner;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_vsb_params_init, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

btuner_linein_t btuner_linein_open(bobject_t linein_id)
{
  int rc;
  ioctl_settopapi_struct_btuner_linein_open st;
  st.linein_id = linein_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_linein_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bband_t btuner_tune_qam(
    btuner_t tuner,
    unsigned freq, 
    const btuner_qam_params *params 
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_tune_qam st;
  st.tuner = tuner;
  st.freq = freq;
  st.params = params;
  b_register_callback(ioctl_settopapi_btuner_qam_params_lock_callback, (void*)tuner, params->lock_callback, (void*)params->callback_context);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_tune_qam, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bresult
btuner_tune_oob(
    btuner_t tuner,
    unsigned freq, 
    const btuner_qam_params *params 
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_tune_oob st;
  st.tuner = tuner;
  st.freq = freq;
  st.params = params;
  b_register_callback(ioctl_settopapi_btuner_oob_params_lock_callback, (void*)tuner, params->lock_callback, (void*)params->callback_context);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_tune_oob, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult
btuner_tune_qam_us(
    btuner_t tuner,
    unsigned freq, 
    const btuner_qam_us_params *params  
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_tune_qam_us st;
  st.tuner = tuner;
  st.freq = freq;
  st.params = params;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_tune_qam_us, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bband_t btuner_tune_sds(
    btuner_t tuner,
    unsigned freq, 
    const btuner_sds_params *params 
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_tune_sds st;
  st.tuner = tuner;
  st.freq = freq;
  st.params = params;
  b_register_callback(ioctl_settopapi_btuner_sds_params_lock_callback, (void*)tuner, params->lock_callback, (void*)params->callback_context);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_tune_sds, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bband_t btuner_tune_vsb(
    btuner_t tuner,
    unsigned freq, 
    const btuner_vsb_params *params 
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_tune_vsb st;
  st.tuner = tuner;
  st.freq = freq;
  st.params = params;
  b_register_callback(ioctl_settopapi_btuner_vsb_params_lock_callback, (void*)tuner, params->lock_callback, (void*)params->callback_context);
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_tune_vsb, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bband_t
btuner_tune_ofdm(
    btuner_t tuner, 
    unsigned freq,   
    const btuner_ofdm_params* params 
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_tune_ofdm st;
  st.tuner = tuner;
  st.freq = freq;
  st.params = params;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_tune_ofdm, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bstream_t btuner_tune_rf(
    btuner_t tuner,
    unsigned carrierfreq,   
    const btuner_analog_params *params  
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_tune_rf st;
  st.tuner = tuner;
  st.carrierfreq = carrierfreq;
  st.params = params;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_tune_rf, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bstream_t btuner_tune_linein(
    btuner_t tuner,
    btuner_linein_t linein, 
    const btuner_analog_params *params  
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_tune_linein st;
  st.tuner = tuner;
  st.linein = linein;
  st.params = params;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_tune_linein, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

bresult btuner_get_analog_status(
    btuner_t tuner, 
    btuner_analog_status *status    
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_get_analog_status st;
  st.tuner = tuner;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_get_analog_status, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult btuner_get_qam_status(
    btuner_t tuner,
    btuner_qam_status *status   
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_get_qam_status st;
  st.tuner = tuner;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_get_qam_status, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult btuner_get_qam_us_status(
    btuner_t tuner,
    btuner_qam_us_status *status    
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_get_qam_us_status st;
  st.tuner = tuner;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_get_qam_us_status, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult btuner_get_sds_status(
    btuner_t tuner,
    btuner_sds_status *status   
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_get_sds_status st;
  st.tuner = tuner;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_get_sds_status, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult btuner_get_vsb_status(
    btuner_t tuner,
    btuner_vsb_status *status   
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_get_vsb_status st;
  st.tuner = tuner;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_get_vsb_status, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult btuner_get_ofdm_status(
    btuner_t tuner,
    btuner_ofdm_status *status   
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_get_ofdm_status st;
  st.tuner = tuner;
  st.status = status;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_get_ofdm_status, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult btuner_get_soft_decisions(
    btuner_t tuner,
    btuner_soft_decision *data ,
    size_t length 
    )
{
  int rc;
  ioctl_settopapi_struct_btuner_get_soft_decisions st;
  st.tuner = tuner;
  st.data = data;
  st.length = length;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_btuner_get_soft_decisions, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bmem_ptr bmem_alloc(
        size_t buffer_length
)
{
  int rc;
  ioctl_settopapi_struct_bmem_alloc st;
  st.buffer_length = buffer_length;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bmem_alloc, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bmem_free(
        void *buffer
)
{
  int rc;
  ioctl_settopapi_struct_bmem_free st;
  st.buffer = buffer;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bmem_free, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bcablecard_t bcablecard_open(
        bobject_t cablecard_id 
        )
{
  int rc;
  ioctl_settopapi_struct_bcablecard_open st;
  st.cablecard_id = cablecard_id;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bcablecard_open, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);return NULL;}
  return st.__retval;
}

void bcablecard_close(
        bcablecard_t cablecard 
        )
{
  int rc;
  ioctl_settopapi_struct_bcablecard_close st;
  st.cablecard = cablecard;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bcablecard_close, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

void bcablecard_get(
        bcablecard_t cablecard,
        bcablecard_settings *settings 
        )
{
  int rc;
  ioctl_settopapi_struct_bcablecard_get st;
  st.cablecard = cablecard;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bcablecard_get, (void*)&st);
  if (rc) {BSETTOP_ERROR(berr_external_error);}
}

bresult bcablecard_set(
        bcablecard_t cablecard,
        const bcablecard_settings *settings
        )
{
  int rc;
  ioctl_settopapi_struct_bcablecard_set st;
  st.cablecard = cablecard;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bcablecard_set, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bcablecard_route_add_tuner(
   bcablecard_t cablecard,
   btuner_t tuner 
   )
{
  int rc;
  ioctl_settopapi_struct_bcablecard_route_add_tuner st;
  st.cablecard = cablecard;
  st.tuner = tuner;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bcablecard_route_add_tuner, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bcablecard_route_remove_tuner(
   bcablecard_t cablecard,
   btuner_t tuner 
   )
{
  int rc;
  ioctl_settopapi_struct_bcablecard_route_remove_tuner st;
  st.cablecard = cablecard;
  st.tuner = tuner;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bcablecard_route_remove_tuner, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}

bresult bcablecard_route_get(
        bcablecard_t cablecard,
        btuner_t tuner, 
        bcablecard_route_settings *settings 
        )
{
  int rc;
  ioctl_settopapi_struct_bcablecard_route_get st;
  st.cablecard = cablecard;
  st.tuner = tuner;
  st.settings = settings;
  rc = ioctl(g_ioctl_fd, BSETTOP_IOCTL_bcablecard_route_get, (void*)&st);
  if (rc) return BSETTOP_ERROR(berr_external_error);
  return st.__retval;
}