XMOS I2S Library

https://github.com/xmos/lib_i2s
Admin
A library providing Inter-IC Sound (I2S) functionality for XMOS microcontrollers, enabling audio...
Tokens:15,469
Snippets:48
Trust Score:9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Clock Configuration Example

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Demonstrates how to configure a clock source and start the clock for TDM components. This is a prerequisite for using the TDM components.

```C
configure_clock_src(mclk, p_mclk);
start_clock(mclk);
```

--------------------------------

### XC Hardware Initialization Functions

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Illustrates the initialization sequence for audio hardware using the lib_board_support library. It includes setting up the board configuration and starting the I2C master server task.

```XC
xk_audio_316_mc_ab_board_setup(hw_config); // Setup must be done on tile[0]
xk_audio_316_mc_ab_i2c_master(i_i2c);      // Run I2C master server task to allow control from tile[1]
```

--------------------------------

### XC Task Parallelism Setup

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Demonstrates the use of the 'par' construct in XC to start multiple tasks concurrently. This snippet shows how to initiate the I2S controller, I2C master, GPIO control, and the main loopback application task.

```XC
par {
    // Start I2S controller task
    // Start I2C master task
    // Start GPIO control task
    // Start loopback application task
}
return 0;
```

--------------------------------

### CMake Project Setup for app_simple_tdm_master

Source: https://github.com/xmos/lib_i2s/blob/develop/examples/app_simple_tdm_master/CMakeLists.txt

This CMakeLists.txt file initializes the project, sets the target hardware, includes common XMOS build utilities and dependencies, and defines compiler flags for optimization and debugging. It concludes by registering the application with the XMOS build system.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
project(app_simple_tdm_master)

set(APP_HW_TARGET           XK-EVK-XU316)

include(${CMAKE_CURRENT_LIST_DIR}/../deps.cmake)

set(APP_COMPILER_FLAGS      -Os
                            -g
                            -report
                            )

set(APP_PCA_ENABLE          ON)

set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)

XMOS_REGISTER_APP()
```

--------------------------------

### XC I2S Controller Interface Methods

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Details the callback methods used by the I2S controller to interact with the application. These include init() for setup, receive() for incoming data, send() for providing data to transmit, and restart_check() for control flow.

```XC
// Called before data streaming starts for initialization
void init() {
    // Reset and configure audio hardware
}

// Called when a frame of audio samples is received
void receive(audio_sample_t samples[]) {
    // Store received samples
}

// Called when the controller needs a new frame of samples to send
audio_sample_t[] send() {
    // Return previously received samples for loopback
}

// Called once per frame to control restart or shutdown
restart_status_t restart_check() {
    // Return I2S_NO_RESTART to continue running
    return I2S_NO_RESTART;
}
```

--------------------------------

### XC Hardware Configuration Defines

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Shows example preprocessor definitions for configuring I2S hardware parameters. These constants, such as SAMPLE_FREQUENCY and DATA_BITS, are used to set up the audio interface according to specific requirements.

```XC
#define SAMPLE_FREQUENCY 48000
#define MASTER_CLOCK_FREQUENCY 12288000
#define DATA_BITS 24
#define NUM_I2S_LINES 2
```

--------------------------------

### Python Development Dependencies

Source: https://github.com/xmos/lib_i2s/blob/develop/tests/requirements.txt

Lists development dependencies, typically installed in editable mode. These entries specify paths to setup.py files for local development or dependencies on other repositories.

```python
-e ./../../test_support
```

--------------------------------

### I²S Controller Task Instantiation (Master)

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Provides an example of instantiating an I²S controller (master) task within a 'par' statement. It shows how to connect to the i2s_frame_callback_if interface, enabling communication with the I²S bus.

```XMOS C
// Application task definition
par {
    my_application();
    // Instantiate an I2S controller component and connect to it
    i2s_master(i2s_frame_callback_if, i2s_config);
}
```

--------------------------------

### lib_i2s CMake Configuration

Source: https://github.com/xmos/lib_i2s/blob/develop/examples/CMakeLists.txt

This CMake script configures the lib_i2s project. It sets up the build environment by specifying the CMake version, including essential XMOS common modules, defining the project name, and integrating various example applications as subdirectories for building.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
project(lib_i2s_examples)
add_subdirectory(app_i2s_frame_loopback_demo)
add_subdirectory(app_i2s_frame_slave_loopback_demo)
add_subdirectory(app_simple_i2s_frame_master)
add_subdirectory(app_simple_i2s_frame_master_4b)
add_subdirectory(app_simple_i2s_frame_master_external_clock)
add_subdirectory(app_simple_i2s_frame_slave)
add_subdirectory(app_simple_tdm_master)
add_subdirectory(app_tdm_loopback_demo)
```

--------------------------------

### TDM Controller Task Instantiation

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Shows how to instantiate a TDM controller task within a 'par' statement. This example demonstrates connecting to the tdm_callback_if interface, which is used for TDM frame communication.

```XMOS C
// Instantiate a TDM controller component and connect to it
tdm_controller(tdm_callback_if, tdm_config);

// The application can connect via the tdm_callback_if interface connection.
```

--------------------------------

### Configure lib_i2s Tests with JSON Parameters

Source: https://github.com/xmos/lib_i2s/blob/develop/tests/i2s_frame_master_test/CMakeLists.txt

This CMake script sets up the build environment for testing the lib_i2s library. It reads configuration options from a JSON file, parses them into CMake variables, and then iterates through combinations of bit depth, MCLK family, I2S lines, and smoke test flags to define specific compiler flags for each test configuration. This allows for systematic testing across various hardware setups and feature combinations.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../../examples/deps.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../test_deps.cmake)

# Get JSON lists
file(READ ${CMAKE_CURRENT_LIST_DIR}/test_params.json JSON_CONTENT)

# Parse the JSON file into variables
string(JSON BITDEPTHS_LIST GET ${JSON_CONTENT} BITDEPTHS)
string(JSON SMOKE_LIST GET ${JSON_CONTENT} SMOKE)
string(JSON MCLK_FAMILIES_LIST GET ${JSON_CONTENT} MCLK_FAMILIES)
string(JSON I2S_LINES_LIST GET ${JSON_CONTENT} I2S_LINES)

# Convert JSON lists to CMake lists
string(JSON NUM_BITDEPTHS LENGTH ${BITDEPTHS_LIST})
string(JSON NUM_SMOKES LENGTH ${SMOKE_LIST})
string(JSON NUM_MCLK_FAMILIES LENGTH ${MCLK_FAMILIES_LIST})
string(JSON NUM_I2S_LINES LENGTH ${I2S_LINES_LIST})

# Subtract one off each of the lengths because RANGE includes last element
math(EXPR NUM_BITDEPTHS "${NUM_BITDEPTHS} - 1")
math(EXPR NUM_SMOKES "${NUM_SMOKES} - 1")
math(EXPR NUM_MCLK_FAMILIES "${NUM_MCLK_FAMILIES} - 1")
math(EXPR NUM_I2S_LINES "${NUM_I2S_LINES} - 1")

set(APP_PCA_ENABLE          ON)
project(test_i2s_frame_master)
set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)
set(APP_HW_TARGET           XCORE-200-EXPLORER)

# Iterate through combinations
foreach(i RANGE 0 ${NUM_BITDEPTHS})
    string(JSON BITDEPTH GET ${BITDEPTHS_LIST} ${i})
    foreach(j RANGE 0 ${NUM_SMOKES})
        string(JSON SMOKE GET ${SMOKE_LIST} ${j})
        foreach(k RANGE 0 ${NUM_MCLK_FAMILIES})
            string(JSON MCLK_FAMILY GET ${MCLK_FAMILIES_LIST} ${k})
            foreach(l RANGE 0 ${NUM_I2S_LINES})
                string(JSON INPUT_OUTPUT GET ${I2S_LINES_LIST} ${l})
                string(JSON INPUT GET ${INPUT_OUTPUT} INPUT) # Extract out the pair of values for input and output
                string(JSON OUTPUT GET ${INPUT_OUTPUT} OUTPUT)
                set(config "${BITDEPTH}_${MCLK_FAMILY}_${INPUT}_${OUTPUT}_${SMOKE}")
                message(STATUS "Building config: ${config}")

                set(APP_COMPILER_FLAGS_${config}
                                            -O3
                                            -report
                                            -g
                                            -DMCLK_FAMILY=${MCLK_FAMILY}
                                            -DDATA_BITS=${BITDEPTH}
                                            -DNUM_OUT=${OUTPUT}
                                            -DNUM_IN=${INPUT})

                if(${SMOKE} MATCHES 1)
                    list(APPEND APP_COMPILER_FLAGS_${config} -DSMOKE=1)
                endif()
            endforeach()
        endforeach()
    endforeach()
endforeach()

XMOS_REGISTER_APP()

```

--------------------------------

### Python Released Dependencies

Source: https://github.com/xmos/lib_i2s/blob/develop/tests/requirements.txt

Specifies a known working combination of Python modules required by the code in this repository. Installing these specific versions ensures a controlled infrastructure for development, testing, and release.

```python
flake8==7.0.0
pytest==8.2.2
pytest-xdist==3.6.1
```

--------------------------------

### CMake Build Configuration for lib_i2s

Source: https://github.com/xmos/lib_i2s/blob/develop/tests/i2s_frame_master_external_clock_test/CMakeLists.txt

This CMake script configures the build process for the lib_i2s project. It reads test parameters from a JSON file, parses them into CMake variables, and then iterates through combinations to define specific compiler flags for different I2S configurations. It relies on XMOS-specific CMake modules and example dependencies.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../../examples/deps.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../test_deps.cmake)

# Get JSON lists
file(READ ${CMAKE_CURRENT_LIST_DIR}/test_params.json JSON_CONTENT)

# Parse the JSON file into variables
string(JSON BITDEPTHS_LIST GET ${JSON_CONTENT} BITDEPTHS)
string(JSON SMOKE_LIST GET ${JSON_CONTENT} SMOKE)
string(JSON I2S_LINES_LIST GET ${JSON_CONTENT} I2S_LINES)

# Convert JSON lists to CMake lists
string(JSON NUM_BITDEPTHS LENGTH ${BITDEPTHS_LIST})
string(JSON NUM_SMOKES LENGTH ${SMOKE_LIST})
string(JSON NUM_I2S_LINES LENGTH ${I2S_LINES_LIST})

# Subtract one off each of the lengths because RANGE includes last element
math(EXPR NUM_BITDEPTHS "${NUM_BITDEPTHS} - 1")
math(EXPR NUM_SMOKES "${NUM_SMOKES} - 1")
math(EXPR NUM_I2S_LINES "${NUM_I2S_LINES} - 1")

set(APP_PCA_ENABLE          ON)
project(test_i2s_frame_master_external_clock)
set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)
set(APP_HW_TARGET           XCORE-200-EXPLORER)

# Iterate through combinations
foreach(i RANGE 0 ${NUM_BITDEPTHS})
    string(JSON BITDEPTH GET ${BITDEPTHS_LIST} ${i})
    foreach(j RANGE 0 ${NUM_SMOKES})
        string(JSON SMOKE GET ${SMOKE_LIST} ${j})
        foreach(l RANGE 0 ${NUM_I2S_LINES})
            string(JSON INPUT_OUTPUT GET ${I2S_LINES_LIST} ${l})
            string(JSON INPUT GET ${INPUT_OUTPUT} INPUT) # Extract out the pair of values for input and output
            string(JSON OUTPUT GET ${INPUT_OUTPUT} OUTPUT)
            set(config "${BITDEPTH}_${INPUT}_${OUTPUT}_${SMOKE}")
            message(STATUS "Building config: ${config}")

            set(APP_COMPILER_FLAGS_${config}
                                        -O3
                                        -report
                                        -g
                                        -DDATA_BITS=${BITDEPTH}
                                        -DNUM_OUT=${OUTPUT}
                                        -DNUM_IN=${INPUT})

            if(${SMOKE} MATCHES 1)
                list(APPEND APP_COMPILER_FLAGS_${config} -DSMOKE=1)
            endif()
        endforeach()
    endforeach()
endforeach()

XMOS_REGISTER_APP()

```

--------------------------------

### Build and Run TDM Loopback Demo

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Commands to configure, build, and run the TDM loopback demonstration application. This process is similar to the I2S demo, utilizing CMake and xmake.

```Shell
cd examples
cd app_tdm_loopback_demo
cmake -G "Unix Makefiles" -B build
xmake -j -C build
xrun bin/app_tdm_loopback_demo.xe
```

--------------------------------

### Build and Run I2S Loopback Demo

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Commands to configure, build, and run the I2S frame loopback demonstration application. It uses CMake for configuration and xmake for building.

```Shell
cd examples
cd app_i2s_frame_loopback_demo
cmake -G "Unix Makefiles" -B build
xmake -j -C build
xrun bin/app_i2s_frame_loopback_demo.xe
```

--------------------------------

### I²S Configuration Parameters

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Details key configuration parameters for the I²S protocol, essential for setting up communication. This includes clock ratios, data alignment modes, and the number of data bits per word.

```APIDOC
I2S_Configuration_Parameters:
  MCLK_BCLK_RATIO: The fixed ratio between the master clock and the bit clock.
  MODE: The mode - the alignment of the data respective to WS. Supported modes are 'Standard (Philips)' and 'Left-Justified'.
  NUM_DATA_BITS: The number of bits in a data word; this is usually 32, but can be adjusted to any value below 32 if required when using one bit ports for I/O.
```

--------------------------------

### XMOS i2s Frame Loopback Demo CMake Configuration

Source: https://github.com/xmos/lib_i2s/blob/develop/examples/app_i2s_frame_loopback_demo/CMakeLists.txt

This CMake script sets up the build environment for the i2s frame loopback demo application on XMOS hardware. It defines the target hardware, includes common XMOS modules, and specifies compiler optimization flags and board support.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
project(app_i2s_frame_loopback_demo)

set(APP_HW_TARGET           xk-audio-316-mc.xn)

include(${CMAKE_CURRENT_LIST_DIR}/../deps.cmake)

set(APP_COMPILER_FLAGS      -Os
                            -g
                            -report
                            -DBOARD_SUPPORT_BOARD=XK_AUDIO_316_MC_AB)

set(APP_PCA_ENABLE          ON)

set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)

XMOS_REGISTER_APP()
```

--------------------------------

### XMOS lib_i2s CMake Configuration

Source: https://github.com/xmos/lib_i2s/blob/develop/examples/app_i2s_frame_slave_loopback_demo/CMakeLists.txt

Configures the build environment for the XMOS lib_i2s frame slave loopback demo. It sets the minimum CMake version, includes common XMOS modules, defines the project name, target hardware, compiler flags, and registers the application.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
project(app_i2s_frame_slave_loopback_demo)

set(APP_HW_TARGET           xk-audio-316-mc.xn)

include(${CMAKE_CURRENT_LIST_DIR}/../deps.cmake)

set(APP_COMPILER_FLAGS      -O2
                            -report
                            -g
                            -DBOARD_SUPPORT_BOARD=XK_AUDIO_316_MC_AB
                            -DDEBUG_PRINT_ENABLE=1)

set(APP_PCA_ENABLE          ON)

set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)

XMOS_REGISTER_APP()
```

--------------------------------

### CMakeLists for I2S Frame Master App

Source: https://github.com/xmos/lib_i2s/blob/develop/examples/app_simple_i2s_frame_master_4b/CMakeLists.txt

This CMakeLists.txt file configures a specific application, app_simple_i2s_frame_master_4b, for the XK-EVK-XU316 target. It sets up the project, includes necessary common modules and dependencies, defines compiler flags, and registers the application.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
project(app_simple_i2s_frame_master_4b)

set(APP_HW_TARGET           XK-EVK-XU316)

include(${CMAKE_CURRENT_LIST_DIR}/../deps.cmake)

set(APP_COMPILER_FLAGS      -Os
                            -g
                            -report
                            )

set(APP_PCA_ENABLE          ON)

set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)

XMOS_REGISTER_APP()
```

--------------------------------

### Include lib_i2s and Board Headers

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Includes the main lib_i2s header and a relevant header from lib_board_support for hardware configuration.

```C
#include "i2s.h"
#include "xk_audio_316_mc_ab/board.h"
```

--------------------------------

### lib_i2s CMakeLists.txt Configuration

Source: https://github.com/xmos/lib_i2s/blob/develop/examples/app_simple_i2s_frame_slave/CMakeLists.txt

This CMake script sets up the build environment for the lib_i2s project. It defines the minimum required CMake version, includes common modules and dependencies, specifies the project name, hardware target, compiler flags, and registers the application.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
project(app_simple_i2s_frame_slave)

set(APP_HW_TARGET           XK-EVK-XU316)

include(${CMAKE_CURRENT_LIST_DIR}/../deps.cmake)

set(APP_COMPILER_FLAGS      -Os
                            -g
                            -report
                            )

set(APP_PCA_ENABLE          ON)

set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)

XMOS_REGISTER_APP()
```

--------------------------------

### XC Audio Hardware Configuration

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Shows the configuration of audio hardware parameters such as sample frequency, clock frequency, and data bits using lib_board_support functions. These settings define the operational parameters for the I2S interface.

```XC
xk_audio_316_mc_ab_AudioHwInit(i_i2c, hw_config);
xk_audio_316_mc_ab_AudioHwConfig(i_i2c, hw_config, SAMPLE_FREQUENCY, MASTER_CLOCK_FREQUENCY, 0, DATA_BITS, DATA_BITS);
```

--------------------------------

### Configure lib_i2s Project with CMake

Source: https://github.com/xmos/lib_i2s/blob/develop/examples/app_simple_i2s_frame_master_external_clock/CMakeLists.txt

This CMake script sets up the build environment for the lib_i2s project. It defines the minimum required CMake version, includes common XMOS modules, sets the project name, target hardware, compiler flags, and registers the application.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
project(app_simple_i2s_frame_master_external_clock)

set(APP_HW_TARGET           XK-EVK-XU316)

include(${CMAKE_CURRENT_LIST_DIR}/../deps.cmake)

set(APP_COMPILER_FLAGS      -Os
                            -g
                            -report
                            )

set(APP_PCA_ENABLE          ON)

set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)

XMOS_REGISTER_APP()
```

--------------------------------

### lib_i2s CMake Build Configuration

Source: https://github.com/xmos/lib_i2s/blob/develop/tests/CMakeLists.txt

This CMakeLists.txt file defines the build system for the lib_i2s project. It specifies the minimum required CMake version, includes common XMOS build scripts, sets the project name, and adds several subdirectories, each containing specific test cases for I2S and TDM functionalities.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
project(lib_i2s_tests)
add_subdirectory(backpressure_test)
add_subdirectory(i2s_frame_master_test)
add_subdirectory(i2s_frame_slave_test)
add_subdirectory(i2s_frame_master_4b_test)
add_subdirectory(i2s_frame_slave_4b_test)
add_subdirectory(i2s_frame_master_external_clock_test)
add_subdirectory(i2s_frame_master_external_clock_4b_test)
add_subdirectory(tdm_master_cb_test)
add_subdirectory(test_tdm_callback_sequence)
```

--------------------------------

### CMake Configuration for TDM Callback Sequence Tests

Source: https://github.com/xmos/lib_i2s/blob/develop/tests/test_tdm_callback_sequence/CMakeLists.txt

This script sets up the build environment for TDM callback sequence tests. It includes necessary CMake modules, reads test parameters from 'test_params.json', and dynamically generates compiler flags for different test configurations based on JSON data. It iterates through smoke test options, input/output counts, and TDM channels per frame to define build variants.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../../examples/deps.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../test_deps.cmake)

# Get JSON lists
file(READ ${CMAKE_CURRENT_LIST_DIR}/test_params.json JSON_CONTENT)

# Parse the JSON file into variables
string(JSON SMOKE_LIST GET ${JSON_CONTENT} SMOKE)
string(JSON NUMS_IN_OUT_LIST GET ${JSON_CONTENT} NUMS_IN_OUT)

# Convert JSON lists to CMake lists
string(JSON NUM_SMOKES LENGTH ${SMOKE_LIST})
string(JSON NUM_NUMS_IN_OUT LENGTH ${NUMS_IN_OUT_LIST})

# Subtract one off each of the lengths because RANGE includes last element
math(EXPR NUM_SMOKES "${NUM_SMOKES} - 1")
math(EXPR NUM_NUMS_IN_OUT "${NUM_NUMS_IN_OUT} - 1")

set(APP_PCA_ENABLE          ON)
project(test_tdm_callback_sequence)
set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)
set(APP_HW_TARGET           XCORE-200-EXPLORER)

# Iterate through combinations
foreach(j RANGE 0 ${NUM_SMOKES})
    string(JSON SMOKE GET ${SMOKE_LIST} ${j})
    foreach(l RANGE 0 ${NUM_NUMS_IN_OUT})
        string(JSON INPUT_OUTPUT GET ${NUMS_IN_OUT_LIST} ${l})
        string(JSON INPUT GET ${INPUT_OUTPUT} INPUT) # Extract out the pair of values for input and output
        string(JSON OUTPUT GET ${INPUT_OUTPUT} OUTPUT)
        string(JSON TDM_CHANS_PER_FRAME GET ${INPUT_OUTPUT} TDM_CHANS_PER_FRAME)
        set(config "${INPUT}_${OUTPUT}_${TDM_CHANS_PER_FRAME}_${SMOKE}")
        message(STATUS "Building config: ${config}")

        set(APP_COMPILER_FLAGS_${config}
                                    -O3
                                    -report
                                    -g
                                    -DNUM_OUT=${OUTPUT}
                                    -DNUM_IN=${INPUT}
                                    -DTDM_CHANS_PER_FRAME=${TDM_CHANS_PER_FRAME}
                                    -DTDM=1)

        if(${SMOKE} MATCHES 1)
            list(APPEND APP_COMPILER_FLAGS_${config} -DSMOKE=1)
        endif()
    endforeach()
endforeach()

XMOS_REGISTER_APP()

```

--------------------------------

### lib_i2s CMake Build Configuration

Source: https://github.com/xmos/lib_i2s/blob/develop/examples/app_simple_i2s_frame_master/CMakeLists.txt

This snippet defines the CMake build system for the lib_i2s project. It sets the minimum CMake version, includes common XMOS scripts, defines the project name, target hardware (XK-EVK-XU316), compiler flags (-Os, -g, -report), enables PCA, sets the sandbox directory, and registers the application.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
project(app_simple_i2s_frame_master)

set(APP_HW_TARGET           XK-EVK-XU316)

include(${CMAKE_CURRENT_LIST_DIR}/../deps.cmake)

set(APP_COMPILER_FLAGS      -Os
                            -g
                            -report
                            )

set(APP_PCA_ENABLE          ON)

set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)

XMOS_REGISTER_APP()
```

--------------------------------

### XMOS lib_i2s CMake Build Configuration

Source: https://github.com/xmos/lib_i2s/blob/develop/tests/i2s_frame_master_4b_test/CMakeLists.txt

This CMake script configures the build process for the XMOS lib_i2s project. It reads test parameters from a JSON file, iterates through various MCLK families and I2S line configurations, and defines compiler flags for each combination. It then registers the application using `XMOS_REGISTER_APP()`.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../../examples/deps.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../test_deps.cmake)

# Get JSON lists
file(READ ${CMAKE_CURRENT_LIST_DIR}/test_params.json JSON_CONTENT)

# Parse the JSON file into variables
string(JSON MCLK_FAMILIES_LIST GET ${JSON_CONTENT} MCLK_FAMILIES)
string(JSON I2S_LINES_LIST GET ${JSON_CONTENT} I2S_LINES)

# Convert JSON lists to CMake lists
string(JSON NUM_MCLK_FAMILIES LENGTH ${MCLK_FAMILIES_LIST})
string(JSON NUM_I2S_LINES LENGTH ${I2S_LINES_LIST})

# Subtract one off each of the lengths because RANGE includes last element
math(EXPR NUM_MCLK_FAMILIES "${NUM_MCLK_FAMILIES} - 1")
math(EXPR NUM_I2S_LINES "${NUM_I2S_LINES} - 1")

project(test_i2s_frame_master_4b)
set(APP_PCA_ENABLE          ON)
set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)
set(APP_HW_TARGET           XCORE-200-EXPLORER)

# Iterate through combinations
foreach(k RANGE 0 ${NUM_MCLK_FAMILIES})
    string(JSON MCLK_FAMILY GET ${MCLK_FAMILIES_LIST} ${k})
    foreach(l RANGE 0 ${NUM_I2S_LINES})
        string(JSON INPUT_OUTPUT GET ${I2S_LINES_LIST} ${l})
        string(JSON INPUT GET ${INPUT_OUTPUT} INPUT) # Extract out the pair of values for input and output
        string(JSON OUTPUT GET ${INPUT_OUTPUT} OUTPUT)
        set(config "${INPUT}_${OUTPUT}_${MCLK_FAMILY}")
        message(STATUS "Building config: ${config}")

        set(APP_COMPILER_FLAGS_${config}
                                    -O3
                                    -report
                                    -g
                                    -DMCLK_FAMILY=${MCLK_FAMILY}
                                    -DNUM_OUT=${OUTPUT}
                                    -DNUM_IN=${INPUT})
    endforeach()
endforeach()

XMOS_REGISTER_APP()

```

--------------------------------

### Include Platform and XS1 Headers

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Includes necessary headers for xcore specific defines and functions, typically platform.h and xs1.h.

```C
#include <platform.h>
#include <xs1.h>
```

--------------------------------

### CMake Build Configuration for lib_i2s

Source: https://github.com/xmos/lib_i2s/blob/develop/tests/tdm_master_cb_test/CMakeLists.txt

This CMake script configures the build process for the lib_i2s project. It reads test parameters from a JSON file, iterates through combinations of smoke tests and I2S line configurations, and defines specific compiler flags for each combination, including optimization, debugging, and feature flags like SMOKE.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../../examples/deps.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../test_deps.cmake)

# Get JSON lists
file(READ ${CMAKE_CURRENT_LIST_DIR}/test_params.json JSON_CONTENT)

# Parse the JSON file into variables
string(JSON SMOKE_LIST GET ${JSON_CONTENT} SMOKE)
string(JSON I2S_LINES_LIST GET ${JSON_CONTENT} I2S_LINES)

# Convert JSON lists to CMake lists
string(JSON NUM_SMOKES LENGTH ${SMOKE_LIST})
string(JSON NUM_I2S_LINES LENGTH ${I2S_LINES_LIST})

# Subtract one off each of the lengths because RANGE includes last element
math(EXPR NUM_SMOKES "${NUM_SMOKES} - 1")
math(EXPR NUM_I2S_LINES "${NUM_I2S_LINES} - 1")

set(APP_PCA_ENABLE          ON)
project(test_tdm_master_cb)
set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)
set(APP_HW_TARGET           XCORE-200-EXPLORER)

# Iterate through combinations
foreach(j RANGE 0 ${NUM_SMOKES})
    string(JSON SMOKE GET ${SMOKE_LIST} ${j})
    foreach(l RANGE 0 ${NUM_I2S_LINES})
        string(JSON INPUT_OUTPUT GET ${I2S_LINES_LIST} ${l})
        string(JSON INPUT GET ${INPUT_OUTPUT} INPUT) # Extract out the pair of values for input and output
        string(JSON OUTPUT GET ${INPUT_OUTPUT} OUTPUT)
        set(config "${INPUT}_${OUTPUT}_${SMOKE}")
        message(STATUS "Building config: ${config}")

        set(APP_COMPILER_FLAGS_${config}
                                    -O3
                                    -report
                                    -g
                                    -DNUM_OUT=${OUTPUT}
                                    -DNUM_IN=${INPUT})

        if(${SMOKE} MATCHES 1)
            list(APPEND APP_COMPILER_FLAGS_${config} -DSMOKE=1)
        endif()
    endforeach()
endforeach()

XMOS_REGISTER_APP()

```

--------------------------------

### I2S Callback Interface

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Documentation for the I2S callback interface, defining how applications can receive and process I2S frames.

```APIDOC
i2s_frame_callback_if:
  Group of functions defining the I2S frame callback interface.
  - Provides mechanisms for handling I2S data frames.
  - Likely includes callback registration and data handling functions.
```

--------------------------------

### Application CMakeLists.txt Dependency

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Shows how to add lib_i2s and lib_board_support to an application's CMakeLists.txt file to manage dependencies.

```C
set(APP_DEPENDENT_MODULES     "lib_i2s"
                                "lib_board_support")
```

--------------------------------

### TDM Callback Interface

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Documentation for the TDM callback interface, specifying how applications can handle TDM data streams.

```APIDOC
tdm_callback_if:
  Group of functions defining the TDM callback interface.
  - Enables applications to register and handle TDM data callbacks.
  - Facilitates processing of time-division multiplexed audio data.
```

--------------------------------

### I2S Task Instances

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Details the available I2S task instances for managing I2S communication in master and slave modes, including variations for data width and clocking.

```APIDOC
i2s_frame_master:
  I2S master task instance.
    - Configures and manages I2S communication as the master.

i2s_frame_master_4b:
  I2S master task instance supporting 4-bit data.
    - Similar to i2s_frame_master but optimized for 4-bit data transfer.

i2s_frame_master_external_clock:
  I2S master task instance using an external clock source.
    - Allows synchronization with an external clock signal.

i2s_frame_master_external_clock_4b:
  I2S master task instance with 4-bit data and external clock.
    - Combines external clocking with 4-bit data support.

i2s_frame_slave:
  I2S slave task instance.
    - Configures and manages I2S communication as the slave.

i2s_frame_slave_4b:
  I2S slave task instance supporting 4-bit data.
    - Similar to i2s_frame_slave but optimized for 4-bit data transfer.
```

--------------------------------

### XMOS Application CMake Configuration

Source: https://github.com/xmos/lib_i2s/blob/develop/examples/app_tdm_loopback_demo/CMakeLists.txt

This CMake script configures the build for an XMOS application. It sets the minimum required CMake version, includes common XMOS modules, defines the project name, target hardware, compiler flags, and registers the application using XMOS-specific commands.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
project(app_tdm_loopback_demo)

set(APP_HW_TARGET           xk-audio-316-mc.xn)

include(${CMAKE_CURRENT_LIST_DIR}/../deps.cmake)

set(APP_COMPILER_FLAGS      -Os
                            -g
                            -report
                            -DBOARD_SUPPORT_BOARD=XK_AUDIO_316_MC_AB)

set(APP_PCA_ENABLE          ON)

set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)

XMOS_REGISTER_APP()
```

--------------------------------

### I²S Target Task Instantiation (Slave)

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Illustrates the instantiation of an I²S target (slave) task. Similar to the controller, it uses a 'par' statement and connects via the i2s_frame_callback_if interface to receive or transmit I²S frames.

```XMOS C
// Instantiate an I2S target component and connect to it
i2s_target(i2s_frame_callback_if, i2s_config);

// The application can connect via the i2s_frame_callback_if interface connection.
// For example, the following code instantiates an I2S target component and connects to it.
```

--------------------------------

### TDM Task Instances

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Details the available TDM task instances for managing TDM communication, primarily in master mode.

```APIDOC
tdm_master:
  TDM master task instance.
    - Manages TDM communication as the master device.
    - Handles data framing and synchronization for TDM streams.
```

--------------------------------

### CMake Configuration for lib_i2s Test App

Source: https://github.com/xmos/lib_i2s/blob/develop/tests/i2s_frame_slave_4b_test/CMakeLists.txt

This CMake script sets up the build environment for a lib_i2s test application. It includes dependency management, reads test parameters from a JSON file, and dynamically generates build configurations based on these parameters, including compiler flags and defines for different test scenarios.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../../examples/deps.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../test_deps.cmake)

# Get JSON lists
file(READ ${CMAKE_CURRENT_LIST_DIR}/test_params.json JSON_CONTENT)

# Parse the JSON file into variables
string(JSON SMOKE_LIST GET ${JSON_CONTENT} SMOKE)
string(JSON NUM_INVERTS_LIST GET ${JSON_CONTENT} INVERT)
string(JSON I2S_LINES_LIST GET ${JSON_CONTENT} I2S_LINES)

# Convert JSON lists to CMake lists
string(JSON NUM_SMOKES LENGTH ${SMOKE_LIST})
string(JSON NUM_INVERTS LENGTH ${NUM_INVERTS_LIST})
string(JSON NUM_I2S_LINES LENGTH ${I2S_LINES_LIST})

# Subtract one off each of the lengths because RANGE includes last element
math(EXPR NUM_SMOKES "${NUM_SMOKES} - 1")
math(EXPR NUM_INVERTS "${NUM_INVERTS} - 1")
math(EXPR NUM_I2S_LINES "${NUM_I2S_LINES} - 1")

set(APP_HW_TARGET           XCORE-200-EXPLORER)
project(test_i2s_frame_slave_4b)
set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)
set(APP_PCA_ENABLE          ON)

# Iterate through combinations
foreach(j RANGE 0 ${NUM_SMOKES})
    string(JSON SMOKE GET ${SMOKE_LIST} ${j})
    foreach(k RANGE 0 ${NUM_INVERTS})
        string(JSON INVERT GET ${NUM_INVERTS_LIST} ${k})
        foreach(l RANGE 0 ${NUM_I2S_LINES})
            string(JSON INPUT_OUTPUT GET ${I2S_LINES_LIST} ${l})
            string(JSON INPUT GET ${INPUT_OUTPUT} INPUT) # Extract out the pair of values for input and output
            string(JSON OUTPUT GET ${INPUT_OUTPUT} OUTPUT)
            set(config "${INVERT}_${INPUT}_${OUTPUT}_${SMOKE}")
            message(STATUS "Building config: ${config}")

            set(APP_COMPILER_FLAGS_${config}
                                        -O3
                                        -report
                                        -g
                                        -DNUM_OUT=${OUTPUT}
                                        -DNUM_IN=${INPUT})
            if(${INVERT} MATCHES 1)
                list(APPEND APP_COMPILER_FLAGS_${config} -DSLAVE_INVERT_BCLK=1)
            endif()
        endforeach()
    endforeach()
endforeach()

XMOS_REGISTER_APP()

```

--------------------------------

### I²S Modes

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Describes the different operational modes for I²S data alignment and channel configuration. lib_i2s currently supports Standard (Philips) and Left-Justified modes.

```APIDOC
I2S_Modes:
  Standard (Philips): Data is aligned with the Word Select (WS) signal change, commonly used with PCM audio. Data is transferred on the second falling edge after the WS transitions.
  Left-Justified: Data starts immediately with the WS change, aligning MSB (Most Significant Bit) with the WS transition. Data is transferred on the next falling edge after the WS transition.
  Right-Justified: Data is right-aligned with the WS, with the LSB (Least Significant Bit) ending at the WS transition. This mode can be achieved by setting lib_i2s to Left Justified mode and right-shifting data appropriately.
```

--------------------------------

### Configure I2S Backpressure Tests with CMake

Source: https://github.com/xmos/lib_i2s/blob/develop/tests/backpressure_test/CMakeLists.txt

This CMake script configures test builds for the lib_i2s project by reading parameters from a JSON file. It iterates through various combinations of bit depth, sample rate, I2S lines, and receive/transmit delays. For each combination, it generates a unique configuration name and sets specific compiler flags, enabling flexible testing of I2S backpressure scenarios.

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../../examples/deps.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../test_deps.cmake)

# Get JSON lists
file(READ ${CMAKE_CURRENT_LIST_DIR}/test_params.json JSON_CONTENT)

# Parse the JSON file into variables
string(JSON BITDEPTHS_LIST GET ${JSON_CONTENT} BITDEPTHS)
string(JSON SAMPLE_RATES_LIST GET ${JSON_CONTENT} SAMPLE_RATES)
string(JSON I2S_LINES_LIST GET ${JSON_CONTENT} I2S_LINES)
string(JSON RX_TX_INCS_LIST GET ${JSON_CONTENT} RX_TX_INCS)

# Convert JSON lists to CMake lists
string(JSON NUM_BITDEPTHS LENGTH ${BITDEPTHS_LIST})
string(JSON NUM_SAMPLE_RATES LENGTH ${SAMPLE_RATES_LIST})
string(JSON NUM_I2S_LINES LENGTH ${I2S_LINES_LIST})
string(JSON NUM_RX_TX_INCS LENGTH ${RX_TX_INCS_LIST})

# Subtract one off each of the lengths because RANGE includes last element
math(EXPR NUM_BITDEPTHS "${NUM_BITDEPTHS} - 1")
math(EXPR NUM_SAMPLE_RATES "${NUM_SAMPLE_RATES} - 1")
math(EXPR NUM_I2S_LINES "${NUM_I2S_LINES} - 1")
math(EXPR NUM_RX_TX_INCS "${NUM_RX_TX_INCS} - 1")

project(test_i2s_backpressure)
set(APP_HW_TARGET           XCORE-200-EXPLORER)
set(APP_PCA_ENABLE          ON)
set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)

# Iterate through combinations
foreach(i RANGE 0 ${NUM_BITDEPTHS})
    string(JSON BITDEPTH GET ${BITDEPTHS_LIST} ${i})
    foreach(j RANGE 0 ${NUM_SAMPLE_RATES})
        string(JSON SAMPLE_RATE GET ${SAMPLE_RATES_LIST} ${j})
        foreach(k RANGE 0 ${I2S_LINES_LIST})
            string(JSON I2S_LINES GET ${I2S_LINES_LIST} ${k})
            foreach(l RANGE 0 ${RX_TX_INCS_LIST})
                string(JSON RX_TX GET ${RX_TX_INCS_LIST} ${l})
                string(JSON RX GET ${RX_TX} RX) # Extract out the pair of values
                string(JSON TX GET ${RX_TX} TX)

                set(cfg_name "${BITDEPTH}_${SAMPLE_RATE}_${I2S_LINES}_${RX}_${TX}")
                message(STATUS "Building cfg_name: ${cfg_name}")

                set(APP_COMPILER_FLAGS_${cfg_name}   
                                            -O3
                                            -report
                                            -g
                                            -DSAMPLE_FREQUENCY=${SAMPLE_RATE}
                                            -DDATA_BITS=${BITDEPTH}
                                            -DNUM_I2S_LINES=${I2S_LINES}
                                            -DRECEIVE_DELAY_INCREMENT=${RX}
                                            -DSEND_DELAY_INCREMENT=${TX}
                                            -DGENERATE_MCLK=1
                                            -DSIM=1
                                            -DDEBUG_PRINT_ENABLE=1)

            endforeach()
        endforeach()
    endforeach()
endforeach()

XMOS_REGISTER_APP()

```

--------------------------------

### CMake Configuration for lib_i2s Tests

Source: https://github.com/xmos/lib_i2s/blob/develop/tests/i2s_frame_slave_test/CMakeLists.txt

This script configures the build for testing the lib_i2s library. It reads test parameters from 'test_params.json', parses them, and then iterates through combinations of bit depth, smoke test flags, inversion flags, and I2S line configurations. For each combination, it defines specific compiler flags and registers the application using XMOS_REGISTER_APP().

```cmake
cmake_minimum_required(VERSION 3.21)
include($ENV{XMOS_CMAKE_PATH}/xcommon.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../../examples/deps.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/../test_deps.cmake)

# Get JSON lists
file(READ ${CMAKE_CURRENT_LIST_DIR}/test_params.json JSON_CONTENT)

# Parse the JSON file into variables
string(JSON BITDEPTHS_LIST GET ${JSON_CONTENT} BITDEPTHS)
string(JSON SMOKE_LIST GET ${JSON_CONTENT} SMOKE)
string(JSON NUM_INVERTS_LIST GET ${JSON_CONTENT} INVERT)
string(JSON I2S_LINES_LIST GET ${JSON_CONTENT} I2S_LINES)

# Convert JSON lists to CMake lists
string(JSON NUM_BITDEPTHS LENGTH ${BITDEPTHS_LIST})
string(JSON NUM_SMOKES LENGTH ${SMOKE_LIST})
string(JSON NUM_INVERTS LENGTH ${NUM_INVERTS_LIST})
string(JSON NUM_I2S_LINES LENGTH ${I2S_LINES_LIST})

# Subtract one off each of the lengths because RANGE includes last element
math(EXPR NUM_BITDEPTHS "${NUM_BITDEPTHS} - 1")
math(EXPR NUM_SMOKES "${NUM_SMOKES} - 1")
math(EXPR NUM_INVERTS "${NUM_INVERTS} - 1")
math(EXPR NUM_I2S_LINES "${NUM_I2S_LINES} - 1")

set(APP_HW_TARGET           XCORE-200-EXPLORER)
project(test_i2s_frame_slave)
set(XMOS_SANDBOX_DIR        ${CMAKE_CURRENT_LIST_DIR}/../../..)
set(APP_PCA_ENABLE          ON)


# Iterate through combinations
foreach(i RANGE 0 ${NUM_BITDEPTHS})
    string(JSON BITDEPTH GET ${BITDEPTHS_LIST} ${i})
    foreach(j RANGE 0 ${NUM_SMOKES})
        string(JSON SMOKE GET ${SMOKE_LIST} ${j})
        foreach(k RANGE 0 ${NUM_INVERTS})
            string(JSON INVERT GET ${NUM_INVERTS_LIST} ${k})
            foreach(l RANGE 0 ${NUM_I2S_LINES})
                string(JSON INPUT_OUTPUT GET ${I2S_LINES_LIST} ${l})
                string(JSON INPUT GET ${INPUT_OUTPUT} INPUT) # Extract out the pair of values for input and output
                string(JSON OUTPUT GET ${INPUT_OUTPUT} OUTPUT)
                set(config "${BITDEPTH}_${INVERT}_${INPUT}_${OUTPUT}_${SMOKE}")
                message(STATUS "Building config: ${config}")

                set(APP_COMPILER_FLAGS_${config}
                                            -O3
                                            -report
                                            -g
                                            -DDATA_BITS=${BITDEPTH}
                                            -DNUM_OUT=${OUTPUT}
                                            -DNUM_IN=${INPUT})

                if(${SMOKE} MATCHES 1)
                    list(APPEND APP_COMPILER_FLAGS_${config} -DSLAVE_INVERT_BCLK=1)
                endif()

                if(${INVERT} MATCHES 1)
                    list(APPEND APP_COMPILER_FLAGS_${config} -DSMOKE=1)
                endif()
            endforeach()
        endforeach()
    endforeach()
endforeach()

XMOS_REGISTER_APP()

```

--------------------------------

### I2S and TDM Data Types

Source: https://github.com/xmos/lib_i2s/blob/develop/doc/rst/lib_i2s.rst

Defines the supporting data types for I2S and TDM configurations and modes. Includes enums for modes and restart types, and structs for detailed configurations.

```APIDOC
i2s_mode_t:
  Enumeration for I2S modes.

i2s_config_t:
  Structure for I2S configuration parameters.
    - Parameters likely include clock settings, data width, etc.

tdm_config_t:
  Structure for TDM configuration parameters.
    - Parameters likely include clock settings, number of channels, etc.

i2s_restart_t:
  Enumeration for I2S restart control.
```
Tokens:
Raw