i2s-std

I2S Standard mode bindings for ESP32 Provides I2S (Inter-IC Sound) standard mode functionality for audio applications

AssemblyScript

export enum I2sDataBitWidth {
  Width8 = 0,
  Width16 = 1,
  Width24 = 2,
  Width32 = 3
}

export enum I2sSlotMode {
  Mono = 0,
  Stereo = 1
}

export enum I2sRole {
  Master = 0,
  Slave = 1
}

export enum I2sError {
  Ok = 0,
  InvalidArg = 1,
  InvalidState = 2,
  NotSupported = 3,
  Timeout = 4,
  NoMemory = 5
}


// @ts-ignore
@external("i2s_std", "i2s_std_config_create")
export declare function i2sStdConfigCreate(): u32;


// @ts-ignore
@external("i2s_std", "i2s_std_config_clk_cfg_set_sample_rate_hz")
export declare function i2sStdConfigClkCfgSetSampleRateHz(config: u32, sampleRateHz: i32): void;


// @ts-ignore
@external("i2s_std", "i2s_std_config_slot_cfg_set_data_bit_width")
export declare function i2sStdConfigSlotCfgSetDataBitWidth(config: u32, dataBitWidth: i32): void;


// @ts-ignore
@external("i2s_std", "i2s_std_config_slot_cfg_set_slot_mode")
export declare function i2sStdConfigSlotCfgSetSlotMode(config: u32, slotMode: i32): void;


// @ts-ignore
@external("i2s_std", "i2s_std_config_slot_cfg_set_ws_width")
export declare function i2sStdConfigSlotCfgSetWsWidth(config: u32, wsWidth: i32): void;


// @ts-ignore
@external("i2s_std", "i2s_std_config_gpio_cfg_set_mclk")
export declare function i2sStdConfigGpioCfgSetMclk(config: u32, mclk: i32): void;


// @ts-ignore
@external("i2s_std", "i2s_std_config_gpio_cfg_set_bclk")
export declare function i2sStdConfigGpioCfgSetBclk(config: u32, bclk: i32): void;


// @ts-ignore
@external("i2s_std", "i2s_std_config_gpio_cfg_set_ws")
export declare function i2sStdConfigGpioCfgSetWs(config: u32, ws: i32): void;


// @ts-ignore
@external("i2s_std", "i2s_std_config_gpio_cfg_set_dout")
export declare function i2sStdConfigGpioCfgSetDout(config: u32, dout: i32): void;


// @ts-ignore
@external("i2s_std", "i2s_std_config_gpio_cfg_set_din")
export declare function i2sStdConfigGpioCfgSetDin(config: u32, din: i32): void;


// @ts-ignore
@external("i2s_std", "i2s_std_config_destroy")
export declare function i2sStdConfigDestroy(config: u32): void;


// @ts-ignore
@external("i2s_std", "i2s_channel_enable")
export declare function i2sChannelEnable(chanHandle: u32): I2sError;


// @ts-ignore
@external("i2s_std", "i2s_channel_disable")
export declare function i2sChannelDisable(chanHandle: u32): I2sError;


// @ts-ignore
@external("i2s_std", "i2s_channel_read")
export declare function i2sChannelRead(chanHandle: u32, buffer: u32, size: u32, timeoutMs: i32): u32;


// @ts-ignore
@external("i2s_std", "i2s_channel_read_result_get_bytes_read")
export declare function i2sChannelReadResultGetBytesRead(result: u32): u32;


// @ts-ignore
@external("i2s_std", "i2s_channel_read_result_get_ret")
export declare function i2sChannelReadResultGetRet(result: u32): u32;


// @ts-ignore
@external("i2s_std", "i2s_channel_read_result_destroy")
export declare function i2sChannelReadResultDestroy(result: u32): void;


// @ts-ignore
@external("i2s_std", "i2s_channel_preload_data")
export declare function i2sChannelPreloadData(txHandle: u32, buffer: u32, size: i32): I2sError;


// @ts-ignore
@external("i2s_std", "i2s_channel_preload_data_result_get_ret")
export declare function i2sChannelPreloadDataResultGetRet(result: u32): u32;


// @ts-ignore
@external("i2s_std", "i2s_channel_preload_data_result_get_bytes_loaded")
export declare function i2sChannelPreloadDataResultGetBytesLoaded(result: u32): u32;


// @ts-ignore
@external("i2s_std", "i2s_channel_preload_data_result_destroy")
export declare function i2sChannelPreloadDataResultDestroy(result: u32): void;


// @ts-ignore
@external("i2s_std", "i2s_channel_write")
export declare function i2sChannelWrite(chanHandle: u32, buffer: u32, size: i32): u32;


// @ts-ignore
@external("i2s_std", "i2s_channel_write_result_destroy")
export declare function i2sChannelWriteResultDestroy(result: u32): void;


// @ts-ignore
@external("i2s_std", "i2s_channel_write_result_get_ret")
export declare function i2sChannelWriteResultGetRet(result: u32): I2sError;


// @ts-ignore
@external("i2s_std", "i2s_channel_write_result_get_bytes_written")
export declare function i2sChannelWriteResultGetBytesWritten(result: u32): i32;


// @ts-ignore
@external("i2s_std", "i2s_chan_cfg_create")
export declare function i2sChanCfgCreate(): u32;


// @ts-ignore
@external("i2s_std", "i2s_chan_cfg_set_id")
export declare function i2sChanCfgSetId(config: u32, id: i32): void;


// @ts-ignore
@external("i2s_std", "i2s_chan_cfg_set_role")
export declare function i2sChanCfgSetRole(config: u32, role: i32): void;


// @ts-ignore
@external("i2s_std", "i2s_chan_cfg_destroy")
export declare function i2sChanCfgDestroy(config: u32): void;


// @ts-ignore
@external("i2s_std", "i2s_new_channel")
export declare function i2sNewChannel(chanCfg: u32, createTxHandle: boolean, createRxHandle: boolean): I2sError;


// @ts-ignore
@external("i2s_std", "i2s_new_channel_result_get_ret")
export declare function i2sNewChannelResultGetRet(result: u32): I2sError;


// @ts-ignore
@external("i2s_std", "i2s_new_channel_result_get_tx_handle")
export declare function i2sNewChannelResultGetTxHandle(result: u32): u32;


// @ts-ignore
@external("i2s_std", "i2s_new_channel_result_get_rx_handle")
export declare function i2sNewChannelResultGetRxHandle(result: u32): u32;


// @ts-ignore
@external("i2s_std", "i2s_new_channel_result_destroy")
export declare function i2sNewChannelResultDestroy(result: u32): void;


// @ts-ignore
@external("i2s_std", "i2s_channel_init_std_mode")
export declare function i2sChannelInitStdMode(chanHandle: u32, stdConfig: u32): I2sError;

Zig

pub const I2sDataBitWidth = enum(u32) {
  width8 = 0,
  width16 = 1,
  width24 = 2,
  width32 = 3
};

pub const I2sSlotMode = enum(u32) {
  mono = 0,
  stereo = 1
};

pub const I2sRole = enum(u32) {
  master = 0,
  slave = 1
};

pub const I2sError = enum(u32) {
  ok = 0,
  invalidArg = 1,
  invalidState = 2,
  notSupported = 3,
  timeout = 4,
  noMemory = 5
};


pub extern "i2s_std" fn i2s_std_config_create() u32;

pub extern "i2s_std" fn i2s_std_config_clk_cfg_set_sample_rate_hz(config: u32, sample_rate_hz: i32) void;

pub extern "i2s_std" fn i2s_std_config_slot_cfg_set_data_bit_width(config: u32, data_bit_width: i32) void;

pub extern "i2s_std" fn i2s_std_config_slot_cfg_set_slot_mode(config: u32, slot_mode: i32) void;

pub extern "i2s_std" fn i2s_std_config_slot_cfg_set_ws_width(config: u32, ws_width: i32) void;

pub extern "i2s_std" fn i2s_std_config_gpio_cfg_set_mclk(config: u32, mclk: i32) void;

pub extern "i2s_std" fn i2s_std_config_gpio_cfg_set_bclk(config: u32, bclk: i32) void;

pub extern "i2s_std" fn i2s_std_config_gpio_cfg_set_ws(config: u32, ws: i32) void;

pub extern "i2s_std" fn i2s_std_config_gpio_cfg_set_dout(config: u32, dout: i32) void;

pub extern "i2s_std" fn i2s_std_config_gpio_cfg_set_din(config: u32, din: i32) void;

pub extern "i2s_std" fn i2s_std_config_destroy(config: u32) void;

pub extern "i2s_std" fn i2s_channel_enable(chan_handle: u32) I2sError;

pub extern "i2s_std" fn i2s_channel_disable(chan_handle: u32) I2sError;

pub extern "i2s_std" fn i2s_channel_read(chan_handle: u32, buffer: u32, size: u32, timeout_ms: i32) u32;

pub extern "i2s_std" fn i2s_channel_read_result_get_bytes_read(result: u32) u32;

pub extern "i2s_std" fn i2s_channel_read_result_get_ret(result: u32) u32;

pub extern "i2s_std" fn i2s_channel_read_result_destroy(result: u32) void;

pub extern "i2s_std" fn i2s_channel_preload_data(tx_handle: u32, buffer: u32, size: i32) I2sError;

pub extern "i2s_std" fn i2s_channel_preload_data_result_get_ret(result: u32) u32;

pub extern "i2s_std" fn i2s_channel_preload_data_result_get_bytes_loaded(result: u32) u32;

pub extern "i2s_std" fn i2s_channel_preload_data_result_destroy(result: u32) void;

pub extern "i2s_std" fn i2s_channel_write(chan_handle: u32, buffer: u32, size: i32) u32;

pub extern "i2s_std" fn i2s_channel_write_result_destroy(result: u32) void;

pub extern "i2s_std" fn i2s_channel_write_result_get_ret(result: u32) I2sError;

pub extern "i2s_std" fn i2s_channel_write_result_get_bytes_written(result: u32) i32;

pub extern "i2s_std" fn i2s_chan_cfg_create() u32;

pub extern "i2s_std" fn i2s_chan_cfg_set_id(config: u32, id: i32) void;

pub extern "i2s_std" fn i2s_chan_cfg_set_role(config: u32, role: i32) void;

pub extern "i2s_std" fn i2s_chan_cfg_destroy(config: u32) void;

pub extern "i2s_std" fn i2s_new_channel(chan_cfg: u32, create_tx_handle: i32, create_rx_handle: i32) I2sError;

pub extern "i2s_std" fn i2s_new_channel_result_get_ret(result: u32) I2sError;

pub extern "i2s_std" fn i2s_new_channel_result_get_tx_handle(result: u32) u32;

pub extern "i2s_std" fn i2s_new_channel_result_get_rx_handle(result: u32) u32;

pub extern "i2s_std" fn i2s_new_channel_result_destroy(result: u32) void;

pub extern "i2s_std" fn i2s_channel_init_std_mode(chan_handle: u32, std_config: u32) I2sError;

Rust

#[derive(Debug, Clone, Copy)]
#[repr(u32)]
pub enum I2sDataBitWidth {
  Width8 = 0,
  Width16 = 1,
  Width24 = 2,
  Width32 = 3
}

#[derive(Debug, Clone, Copy)]
#[repr(u32)]
pub enum I2sSlotMode {
  Mono = 0,
  Stereo = 1
}

#[derive(Debug, Clone, Copy)]
#[repr(u32)]
pub enum I2sRole {
  Master = 0,
  Slave = 1
}

#[derive(Debug, Clone, Copy)]
#[repr(u32)]
pub enum I2sError {
  Ok = 0,
  InvalidArg = 1,
  InvalidState = 2,
  NotSupported = 3,
  Timeout = 4,
  NoMemory = 5
}

#[link(wasm_import_module = "i2s_std")]
extern "C" { 
  #[link_name = "i2s_std_config_create"]
  fn unsafe_i2s_std_config_create() -> u32;

  #[link_name = "i2s_std_config_clk_cfg_set_sample_rate_hz"]
  fn unsafe_i2s_std_config_clk_cfg_set_sample_rate_hz(config: u32, sample_rate_hz: i32);

  #[link_name = "i2s_std_config_slot_cfg_set_data_bit_width"]
  fn unsafe_i2s_std_config_slot_cfg_set_data_bit_width(config: u32, data_bit_width: i32);

  #[link_name = "i2s_std_config_slot_cfg_set_slot_mode"]
  fn unsafe_i2s_std_config_slot_cfg_set_slot_mode(config: u32, slot_mode: i32);

  #[link_name = "i2s_std_config_slot_cfg_set_ws_width"]
  fn unsafe_i2s_std_config_slot_cfg_set_ws_width(config: u32, ws_width: i32);

  #[link_name = "i2s_std_config_gpio_cfg_set_mclk"]
  fn unsafe_i2s_std_config_gpio_cfg_set_mclk(config: u32, mclk: i32);

  #[link_name = "i2s_std_config_gpio_cfg_set_bclk"]
  fn unsafe_i2s_std_config_gpio_cfg_set_bclk(config: u32, bclk: i32);

  #[link_name = "i2s_std_config_gpio_cfg_set_ws"]
  fn unsafe_i2s_std_config_gpio_cfg_set_ws(config: u32, ws: i32);

  #[link_name = "i2s_std_config_gpio_cfg_set_dout"]
  fn unsafe_i2s_std_config_gpio_cfg_set_dout(config: u32, dout: i32);

  #[link_name = "i2s_std_config_gpio_cfg_set_din"]
  fn unsafe_i2s_std_config_gpio_cfg_set_din(config: u32, din: i32);

  #[link_name = "i2s_std_config_destroy"]
  fn unsafe_i2s_std_config_destroy(config: u32);

  #[link_name = "i2s_channel_enable"]
  fn unsafe_i2s_channel_enable(chan_handle: u32) -> I2sError;

  #[link_name = "i2s_channel_disable"]
  fn unsafe_i2s_channel_disable(chan_handle: u32) -> I2sError;

  #[link_name = "i2s_channel_read"]
  fn unsafe_i2s_channel_read(chan_handle: u32, buffer: u32, size: u32, timeout_ms: i32) -> u32;

  #[link_name = "i2s_channel_read_result_get_bytes_read"]
  fn unsafe_i2s_channel_read_result_get_bytes_read(result: u32) -> u32;

  #[link_name = "i2s_channel_read_result_get_ret"]
  fn unsafe_i2s_channel_read_result_get_ret(result: u32) -> u32;

  #[link_name = "i2s_channel_read_result_destroy"]
  fn unsafe_i2s_channel_read_result_destroy(result: u32);

  #[link_name = "i2s_channel_preload_data"]
  fn unsafe_i2s_channel_preload_data(tx_handle: u32, buffer: u32, size: i32) -> I2sError;

  #[link_name = "i2s_channel_preload_data_result_get_ret"]
  fn unsafe_i2s_channel_preload_data_result_get_ret(result: u32) -> u32;

  #[link_name = "i2s_channel_preload_data_result_get_bytes_loaded"]
  fn unsafe_i2s_channel_preload_data_result_get_bytes_loaded(result: u32) -> u32;

  #[link_name = "i2s_channel_preload_data_result_destroy"]
  fn unsafe_i2s_channel_preload_data_result_destroy(result: u32);

  #[link_name = "i2s_channel_write"]
  fn unsafe_i2s_channel_write(chan_handle: u32, buffer: u32, size: i32) -> u32;

  #[link_name = "i2s_channel_write_result_destroy"]
  fn unsafe_i2s_channel_write_result_destroy(result: u32);

  #[link_name = "i2s_channel_write_result_get_ret"]
  fn unsafe_i2s_channel_write_result_get_ret(result: u32) -> I2sError;

  #[link_name = "i2s_channel_write_result_get_bytes_written"]
  fn unsafe_i2s_channel_write_result_get_bytes_written(result: u32) -> i32;

  #[link_name = "i2s_chan_cfg_create"]
  fn unsafe_i2s_chan_cfg_create() -> u32;

  #[link_name = "i2s_chan_cfg_set_id"]
  fn unsafe_i2s_chan_cfg_set_id(config: u32, id: i32);

  #[link_name = "i2s_chan_cfg_set_role"]
  fn unsafe_i2s_chan_cfg_set_role(config: u32, role: i32);

  #[link_name = "i2s_chan_cfg_destroy"]
  fn unsafe_i2s_chan_cfg_destroy(config: u32);

  #[link_name = "i2s_new_channel"]
  fn unsafe_i2s_new_channel(chan_cfg: u32, create_tx_handle: i32, create_rx_handle: i32) -> I2sError;

  #[link_name = "i2s_new_channel_result_get_ret"]
  fn unsafe_i2s_new_channel_result_get_ret(result: u32) -> I2sError;

  #[link_name = "i2s_new_channel_result_get_tx_handle"]
  fn unsafe_i2s_new_channel_result_get_tx_handle(result: u32) -> u32;

  #[link_name = "i2s_new_channel_result_get_rx_handle"]
  fn unsafe_i2s_new_channel_result_get_rx_handle(result: u32) -> u32;

  #[link_name = "i2s_new_channel_result_destroy"]
  fn unsafe_i2s_new_channel_result_destroy(result: u32);

  #[link_name = "i2s_channel_init_std_mode"]
  fn unsafe_i2s_channel_init_std_mode(chan_handle: u32, std_config: u32) -> I2sError;
}

pub fn i2s_std_config_create() -> u32 {
  unsafe {
    return unsafe_i2s_std_config_create();
  }
}


pub fn i2s_std_config_clk_cfg_set_sample_rate_hz(config: u32, sample_rate_hz: i32) {
  unsafe {
    unsafe_i2s_std_config_clk_cfg_set_sample_rate_hz(config, sample_rate_hz);
  }
}


pub fn i2s_std_config_slot_cfg_set_data_bit_width(config: u32, data_bit_width: i32) {
  unsafe {
    unsafe_i2s_std_config_slot_cfg_set_data_bit_width(config, data_bit_width);
  }
}


pub fn i2s_std_config_slot_cfg_set_slot_mode(config: u32, slot_mode: i32) {
  unsafe {
    unsafe_i2s_std_config_slot_cfg_set_slot_mode(config, slot_mode);
  }
}


pub fn i2s_std_config_slot_cfg_set_ws_width(config: u32, ws_width: i32) {
  unsafe {
    unsafe_i2s_std_config_slot_cfg_set_ws_width(config, ws_width);
  }
}


pub fn i2s_std_config_gpio_cfg_set_mclk(config: u32, mclk: i32) {
  unsafe {
    unsafe_i2s_std_config_gpio_cfg_set_mclk(config, mclk);
  }
}


pub fn i2s_std_config_gpio_cfg_set_bclk(config: u32, bclk: i32) {
  unsafe {
    unsafe_i2s_std_config_gpio_cfg_set_bclk(config, bclk);
  }
}


pub fn i2s_std_config_gpio_cfg_set_ws(config: u32, ws: i32) {
  unsafe {
    unsafe_i2s_std_config_gpio_cfg_set_ws(config, ws);
  }
}


pub fn i2s_std_config_gpio_cfg_set_dout(config: u32, dout: i32) {
  unsafe {
    unsafe_i2s_std_config_gpio_cfg_set_dout(config, dout);
  }
}


pub fn i2s_std_config_gpio_cfg_set_din(config: u32, din: i32) {
  unsafe {
    unsafe_i2s_std_config_gpio_cfg_set_din(config, din);
  }
}


pub fn i2s_std_config_destroy(config: u32) {
  unsafe {
    unsafe_i2s_std_config_destroy(config);
  }
}


pub fn i2s_channel_enable(chan_handle: u32) -> I2sError {
  unsafe {
    return unsafe_i2s_channel_enable(chan_handle);
  }
}


pub fn i2s_channel_disable(chan_handle: u32) -> I2sError {
  unsafe {
    return unsafe_i2s_channel_disable(chan_handle);
  }
}


pub fn i2s_channel_read(chan_handle: u32, buffer: u32, size: u32, timeout_ms: i32) -> u32 {
  unsafe {
    return unsafe_i2s_channel_read(chan_handle, buffer, size, timeout_ms);
  }
}


pub fn i2s_channel_read_result_get_bytes_read(result: u32) -> u32 {
  unsafe {
    return unsafe_i2s_channel_read_result_get_bytes_read(result);
  }
}


pub fn i2s_channel_read_result_get_ret(result: u32) -> u32 {
  unsafe {
    return unsafe_i2s_channel_read_result_get_ret(result);
  }
}


pub fn i2s_channel_read_result_destroy(result: u32) {
  unsafe {
    unsafe_i2s_channel_read_result_destroy(result);
  }
}


pub fn i2s_channel_preload_data(tx_handle: u32, buffer: u32, size: i32) -> I2sError {
  unsafe {
    return unsafe_i2s_channel_preload_data(tx_handle, buffer, size);
  }
}


pub fn i2s_channel_preload_data_result_get_ret(result: u32) -> u32 {
  unsafe {
    return unsafe_i2s_channel_preload_data_result_get_ret(result);
  }
}


pub fn i2s_channel_preload_data_result_get_bytes_loaded(result: u32) -> u32 {
  unsafe {
    return unsafe_i2s_channel_preload_data_result_get_bytes_loaded(result);
  }
}


pub fn i2s_channel_preload_data_result_destroy(result: u32) {
  unsafe {
    unsafe_i2s_channel_preload_data_result_destroy(result);
  }
}


pub fn i2s_channel_write(chan_handle: u32, buffer: u32, size: i32) -> u32 {
  unsafe {
    return unsafe_i2s_channel_write(chan_handle, buffer, size);
  }
}


pub fn i2s_channel_write_result_destroy(result: u32) {
  unsafe {
    unsafe_i2s_channel_write_result_destroy(result);
  }
}


pub fn i2s_channel_write_result_get_ret(result: u32) -> I2sError {
  unsafe {
    return unsafe_i2s_channel_write_result_get_ret(result);
  }
}


pub fn i2s_channel_write_result_get_bytes_written(result: u32) -> i32 {
  unsafe {
    return unsafe_i2s_channel_write_result_get_bytes_written(result);
  }
}


pub fn i2s_chan_cfg_create() -> u32 {
  unsafe {
    return unsafe_i2s_chan_cfg_create();
  }
}


pub fn i2s_chan_cfg_set_id(config: u32, id: i32) {
  unsafe {
    unsafe_i2s_chan_cfg_set_id(config, id);
  }
}


pub fn i2s_chan_cfg_set_role(config: u32, role: i32) {
  unsafe {
    unsafe_i2s_chan_cfg_set_role(config, role);
  }
}


pub fn i2s_chan_cfg_destroy(config: u32) {
  unsafe {
    unsafe_i2s_chan_cfg_destroy(config);
  }
}


pub fn i2s_new_channel(chan_cfg: u32, create_tx_handle: i32, create_rx_handle: i32) -> I2sError {
  unsafe {
    return unsafe_i2s_new_channel(chan_cfg, create_tx_handle, create_rx_handle);
  }
}


pub fn i2s_new_channel_result_get_ret(result: u32) -> I2sError {
  unsafe {
    return unsafe_i2s_new_channel_result_get_ret(result);
  }
}


pub fn i2s_new_channel_result_get_tx_handle(result: u32) -> u32 {
  unsafe {
    return unsafe_i2s_new_channel_result_get_tx_handle(result);
  }
}


pub fn i2s_new_channel_result_get_rx_handle(result: u32) -> u32 {
  unsafe {
    return unsafe_i2s_new_channel_result_get_rx_handle(result);
  }
}


pub fn i2s_new_channel_result_destroy(result: u32) {
  unsafe {
    unsafe_i2s_new_channel_result_destroy(result);
  }
}


pub fn i2s_channel_init_std_mode(chan_handle: u32, std_config: u32) -> I2sError {
  unsafe {
    return unsafe_i2s_channel_init_std_mode(chan_handle, std_config);
  }
}

TinyGo

package i2s-std

type I2sDataBitWidth uint32
const (
  Width8 I2sDataBitWidth = 0
  Width16 I2sDataBitWidth = 1
  Width24 I2sDataBitWidth = 2
  Width32 I2sDataBitWidth = 3
)
type I2sSlotMode uint32
const (
  Mono I2sSlotMode = 0
  Stereo I2sSlotMode = 1
)
type I2sRole uint32
const (
  Master I2sRole = 0
  Slave I2sRole = 1
)
type I2sError uint32
const (
  Ok I2sError = 0
  InvalidArg I2sError = 1
  InvalidState I2sError = 2
  NotSupported I2sError = 3
  Timeout I2sError = 4
  NoMemory I2sError = 5
)


//go:wasmimport i2s_std i2s_std_config_create
func I2sStdConfigCreate() uint32;

//go:wasmimport i2s_std i2s_std_config_clk_cfg_set_sample_rate_hz
func I2sStdConfigClkCfgSetSampleRateHz(Config uint32, SampleRateHz int32);

//go:wasmimport i2s_std i2s_std_config_slot_cfg_set_data_bit_width
func I2sStdConfigSlotCfgSetDataBitWidth(Config uint32, DataBitWidth int32);

//go:wasmimport i2s_std i2s_std_config_slot_cfg_set_slot_mode
func I2sStdConfigSlotCfgSetSlotMode(Config uint32, SlotMode int32);

//go:wasmimport i2s_std i2s_std_config_slot_cfg_set_ws_width
func I2sStdConfigSlotCfgSetWsWidth(Config uint32, WsWidth int32);

//go:wasmimport i2s_std i2s_std_config_gpio_cfg_set_mclk
func I2sStdConfigGpioCfgSetMclk(Config uint32, Mclk int32);

//go:wasmimport i2s_std i2s_std_config_gpio_cfg_set_bclk
func I2sStdConfigGpioCfgSetBclk(Config uint32, Bclk int32);

//go:wasmimport i2s_std i2s_std_config_gpio_cfg_set_ws
func I2sStdConfigGpioCfgSetWs(Config uint32, Ws int32);

//go:wasmimport i2s_std i2s_std_config_gpio_cfg_set_dout
func I2sStdConfigGpioCfgSetDout(Config uint32, Dout int32);

//go:wasmimport i2s_std i2s_std_config_gpio_cfg_set_din
func I2sStdConfigGpioCfgSetDin(Config uint32, Din int32);

//go:wasmimport i2s_std i2s_std_config_destroy
func I2sStdConfigDestroy(Config uint32);

//go:wasmimport i2s_std i2s_channel_enable
func I2sChannelEnable(ChanHandle uint32) uint32;

//go:wasmimport i2s_std i2s_channel_disable
func I2sChannelDisable(ChanHandle uint32) uint32;

//go:wasmimport i2s_std i2s_channel_read
func I2sChannelRead(ChanHandle uint32, Buffer uint32, Size uint32, TimeoutMs int32) uint32;

//go:wasmimport i2s_std i2s_channel_read_result_get_bytes_read
func I2sChannelReadResultGetBytesRead(Result uint32) uint32;

//go:wasmimport i2s_std i2s_channel_read_result_get_ret
func I2sChannelReadResultGetRet(Result uint32) uint32;

//go:wasmimport i2s_std i2s_channel_read_result_destroy
func I2sChannelReadResultDestroy(Result uint32);

//go:wasmimport i2s_std i2s_channel_preload_data
func I2sChannelPreloadData(TxHandle uint32, Buffer uint32, Size int32) uint32;

//go:wasmimport i2s_std i2s_channel_preload_data_result_get_ret
func I2sChannelPreloadDataResultGetRet(Result uint32) uint32;

//go:wasmimport i2s_std i2s_channel_preload_data_result_get_bytes_loaded
func I2sChannelPreloadDataResultGetBytesLoaded(Result uint32) uint32;

//go:wasmimport i2s_std i2s_channel_preload_data_result_destroy
func I2sChannelPreloadDataResultDestroy(Result uint32);

//go:wasmimport i2s_std i2s_channel_write
func I2sChannelWrite(ChanHandle uint32, Buffer uint32, Size int32) uint32;

//go:wasmimport i2s_std i2s_channel_write_result_destroy
func I2sChannelWriteResultDestroy(Result uint32);

//go:wasmimport i2s_std i2s_channel_write_result_get_ret
func I2sChannelWriteResultGetRet(Result uint32) uint32;

//go:wasmimport i2s_std i2s_channel_write_result_get_bytes_written
func I2sChannelWriteResultGetBytesWritten(Result uint32) int32;

//go:wasmimport i2s_std i2s_chan_cfg_create
func I2sChanCfgCreate() uint32;

//go:wasmimport i2s_std i2s_chan_cfg_set_id
func I2sChanCfgSetId(Config uint32, Id int32);

//go:wasmimport i2s_std i2s_chan_cfg_set_role
func I2sChanCfgSetRole(Config uint32, Role int32);

//go:wasmimport i2s_std i2s_chan_cfg_destroy
func I2sChanCfgDestroy(Config uint32);

//go:wasmimport i2s_std i2s_new_channel
func I2sNewChannel(ChanCfg uint32, CreateTxHandle int32, CreateRxHandle int32) uint32;

//go:wasmimport i2s_std i2s_new_channel_result_get_ret
func I2sNewChannelResultGetRet(Result uint32) uint32;

//go:wasmimport i2s_std i2s_new_channel_result_get_tx_handle
func I2sNewChannelResultGetTxHandle(Result uint32) uint32;

//go:wasmimport i2s_std i2s_new_channel_result_get_rx_handle
func I2sNewChannelResultGetRxHandle(Result uint32) uint32;

//go:wasmimport i2s_std i2s_new_channel_result_destroy
func I2sNewChannelResultDestroy(Result uint32);

//go:wasmimport i2s_std i2s_channel_init_std_mode
func I2sChannelInitStdMode(ChanHandle uint32, StdConfig uint32) uint32;

C

typedef enum {
  I2S_DATA_BIT_WIDTH_WIDTH8,
  I2S_DATA_BIT_WIDTH_WIDTH16,
  I2S_DATA_BIT_WIDTH_WIDTH24,
  I2S_DATA_BIT_WIDTH_WIDTH32
} i2s_data_bit_width_t;

typedef enum {
  I2S_SLOT_MODE_MONO,
  I2S_SLOT_MODE_STEREO
} i2s_slot_mode_t;

typedef enum {
  I2S_ROLE_MASTER,
  I2S_ROLE_SLAVE
} i2s_role_t;

typedef enum {
  I2S_ERROR_OK,
  I2S_ERROR_INVALID_ARG,
  I2S_ERROR_INVALID_STATE,
  I2S_ERROR_NOT_SUPPORTED,
  I2S_ERROR_TIMEOUT,
  I2S_ERROR_NO_MEMORY
} i2s_error_t;


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_std_config_create")))
extern unsigned int i2s_std_config_create();


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_std_config_clk_cfg_set_sample_rate_hz")))
extern void i2s_std_config_clk_cfg_set_sample_rate_hz(unsigned int config, int sample_rate_hz);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_std_config_slot_cfg_set_data_bit_width")))
extern void i2s_std_config_slot_cfg_set_data_bit_width(unsigned int config, int data_bit_width);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_std_config_slot_cfg_set_slot_mode")))
extern void i2s_std_config_slot_cfg_set_slot_mode(unsigned int config, int slot_mode);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_std_config_slot_cfg_set_ws_width")))
extern void i2s_std_config_slot_cfg_set_ws_width(unsigned int config, int ws_width);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_std_config_gpio_cfg_set_mclk")))
extern void i2s_std_config_gpio_cfg_set_mclk(unsigned int config, int mclk);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_std_config_gpio_cfg_set_bclk")))
extern void i2s_std_config_gpio_cfg_set_bclk(unsigned int config, int bclk);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_std_config_gpio_cfg_set_ws")))
extern void i2s_std_config_gpio_cfg_set_ws(unsigned int config, int ws);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_std_config_gpio_cfg_set_dout")))
extern void i2s_std_config_gpio_cfg_set_dout(unsigned int config, int dout);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_std_config_gpio_cfg_set_din")))
extern void i2s_std_config_gpio_cfg_set_din(unsigned int config, int din);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_std_config_destroy")))
extern void i2s_std_config_destroy(unsigned int config);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_channel_enable")))
extern i2s_error_t i2s_channel_enable(unsigned int chan_handle);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_channel_disable")))
extern i2s_error_t i2s_channel_disable(unsigned int chan_handle);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_channel_read")))
extern unsigned int i2s_channel_read(unsigned int chan_handle, unsigned int buffer, unsigned int size, int timeout_ms);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_channel_read_result_get_bytes_read")))
extern unsigned int i2s_channel_read_result_get_bytes_read(unsigned int result);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_channel_read_result_get_ret")))
extern unsigned int i2s_channel_read_result_get_ret(unsigned int result);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_channel_read_result_destroy")))
extern void i2s_channel_read_result_destroy(unsigned int result);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_channel_preload_data")))
extern i2s_error_t i2s_channel_preload_data(unsigned int tx_handle, unsigned int buffer, int size);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_channel_preload_data_result_get_ret")))
extern unsigned int i2s_channel_preload_data_result_get_ret(unsigned int result);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_channel_preload_data_result_get_bytes_loaded")))
extern unsigned int i2s_channel_preload_data_result_get_bytes_loaded(unsigned int result);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_channel_preload_data_result_destroy")))
extern void i2s_channel_preload_data_result_destroy(unsigned int result);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_channel_write")))
extern unsigned int i2s_channel_write(unsigned int chan_handle, unsigned int buffer, int size);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_channel_write_result_destroy")))
extern void i2s_channel_write_result_destroy(unsigned int result);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_channel_write_result_get_ret")))
extern i2s_error_t i2s_channel_write_result_get_ret(unsigned int result);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_channel_write_result_get_bytes_written")))
extern int i2s_channel_write_result_get_bytes_written(unsigned int result);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_chan_cfg_create")))
extern unsigned int i2s_chan_cfg_create();


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_chan_cfg_set_id")))
extern void i2s_chan_cfg_set_id(unsigned int config, int id);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_chan_cfg_set_role")))
extern void i2s_chan_cfg_set_role(unsigned int config, int role);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_chan_cfg_destroy")))
extern void i2s_chan_cfg_destroy(unsigned int config);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_new_channel")))
extern i2s_error_t i2s_new_channel(unsigned int chan_cfg, bool create_tx_handle, bool create_rx_handle);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_new_channel_result_get_ret")))
extern i2s_error_t i2s_new_channel_result_get_ret(unsigned int result);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_new_channel_result_get_tx_handle")))
extern unsigned int i2s_new_channel_result_get_tx_handle(unsigned int result);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_new_channel_result_get_rx_handle")))
extern unsigned int i2s_new_channel_result_get_rx_handle(unsigned int result);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_new_channel_result_destroy")))
extern void i2s_new_channel_result_destroy(unsigned int result);


__attribute__((import_module("i2s_std")))
__attribute__((import_name("i2s_channel_init_std_mode")))
extern i2s_error_t i2s_channel_init_std_mode(unsigned int chan_handle, unsigned int std_config);

C++

typedef enum {
  I2S_DATA_BIT_WIDTH_WIDTH8,
  I2S_DATA_BIT_WIDTH_WIDTH16,
  I2S_DATA_BIT_WIDTH_WIDTH24,
  I2S_DATA_BIT_WIDTH_WIDTH32
} i2s_data_bit_width_t;

typedef enum {
  I2S_SLOT_MODE_MONO,
  I2S_SLOT_MODE_STEREO
} i2s_slot_mode_t;

typedef enum {
  I2S_ROLE_MASTER,
  I2S_ROLE_SLAVE
} i2s_role_t;

typedef enum {
  I2S_ERROR_OK,
  I2S_ERROR_INVALID_ARG,
  I2S_ERROR_INVALID_STATE,
  I2S_ERROR_NOT_SUPPORTED,
  I2S_ERROR_TIMEOUT,
  I2S_ERROR_NO_MEMORY
} i2s_error_t;

extern "C" {
  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_std_config_create")))
  extern unsigned int i2s_std_config_create();

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_std_config_clk_cfg_set_sample_rate_hz")))
  extern void i2s_std_config_clk_cfg_set_sample_rate_hz(unsigned int config, int sample_rate_hz);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_std_config_slot_cfg_set_data_bit_width")))
  extern void i2s_std_config_slot_cfg_set_data_bit_width(unsigned int config, int data_bit_width);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_std_config_slot_cfg_set_slot_mode")))
  extern void i2s_std_config_slot_cfg_set_slot_mode(unsigned int config, int slot_mode);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_std_config_slot_cfg_set_ws_width")))
  extern void i2s_std_config_slot_cfg_set_ws_width(unsigned int config, int ws_width);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_std_config_gpio_cfg_set_mclk")))
  extern void i2s_std_config_gpio_cfg_set_mclk(unsigned int config, int mclk);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_std_config_gpio_cfg_set_bclk")))
  extern void i2s_std_config_gpio_cfg_set_bclk(unsigned int config, int bclk);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_std_config_gpio_cfg_set_ws")))
  extern void i2s_std_config_gpio_cfg_set_ws(unsigned int config, int ws);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_std_config_gpio_cfg_set_dout")))
  extern void i2s_std_config_gpio_cfg_set_dout(unsigned int config, int dout);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_std_config_gpio_cfg_set_din")))
  extern void i2s_std_config_gpio_cfg_set_din(unsigned int config, int din);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_std_config_destroy")))
  extern void i2s_std_config_destroy(unsigned int config);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_channel_enable")))
  extern i2s_error_t i2s_channel_enable(unsigned int chan_handle);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_channel_disable")))
  extern i2s_error_t i2s_channel_disable(unsigned int chan_handle);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_channel_read")))
  extern unsigned int i2s_channel_read(unsigned int chan_handle, unsigned int buffer, unsigned int size, int timeout_ms);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_channel_read_result_get_bytes_read")))
  extern unsigned int i2s_channel_read_result_get_bytes_read(unsigned int result);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_channel_read_result_get_ret")))
  extern unsigned int i2s_channel_read_result_get_ret(unsigned int result);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_channel_read_result_destroy")))
  extern void i2s_channel_read_result_destroy(unsigned int result);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_channel_preload_data")))
  extern i2s_error_t i2s_channel_preload_data(unsigned int tx_handle, unsigned int buffer, int size);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_channel_preload_data_result_get_ret")))
  extern unsigned int i2s_channel_preload_data_result_get_ret(unsigned int result);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_channel_preload_data_result_get_bytes_loaded")))
  extern unsigned int i2s_channel_preload_data_result_get_bytes_loaded(unsigned int result);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_channel_preload_data_result_destroy")))
  extern void i2s_channel_preload_data_result_destroy(unsigned int result);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_channel_write")))
  extern unsigned int i2s_channel_write(unsigned int chan_handle, unsigned int buffer, int size);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_channel_write_result_destroy")))
  extern void i2s_channel_write_result_destroy(unsigned int result);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_channel_write_result_get_ret")))
  extern i2s_error_t i2s_channel_write_result_get_ret(unsigned int result);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_channel_write_result_get_bytes_written")))
  extern int i2s_channel_write_result_get_bytes_written(unsigned int result);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_chan_cfg_create")))
  extern unsigned int i2s_chan_cfg_create();

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_chan_cfg_set_id")))
  extern void i2s_chan_cfg_set_id(unsigned int config, int id);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_chan_cfg_set_role")))
  extern void i2s_chan_cfg_set_role(unsigned int config, int role);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_chan_cfg_destroy")))
  extern void i2s_chan_cfg_destroy(unsigned int config);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_new_channel")))
  extern i2s_error_t i2s_new_channel(unsigned int chan_cfg, bool create_tx_handle, bool create_rx_handle);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_new_channel_result_get_ret")))
  extern i2s_error_t i2s_new_channel_result_get_ret(unsigned int result);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_new_channel_result_get_tx_handle")))
  extern unsigned int i2s_new_channel_result_get_tx_handle(unsigned int result);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_new_channel_result_get_rx_handle")))
  extern unsigned int i2s_new_channel_result_get_rx_handle(unsigned int result);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_new_channel_result_destroy")))
  extern void i2s_new_channel_result_destroy(unsigned int result);

  __attribute__((import_module("i2s_std")))
  __attribute__((import_name("i2s_channel_init_std_mode")))
  extern i2s_error_t i2s_channel_init_std_mode(unsigned int chan_handle, unsigned int std_config);
}