From 945841e955420b931944af8f8d322d63f9468ed5 Mon Sep 17 00:00:00 2001 From: Mischa Siekmann <45062894+gnumpi@users.noreply.github.com> Date: Tue, 11 Mar 2025 13:24:30 +0100 Subject: [PATCH 1/6] GHA: updated venv creation for xmos-ai-tools dependency (#91) --- tools/ci/helper_functions.sh | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/ci/helper_functions.sh b/tools/ci/helper_functions.sh index a8a65ad..7cfdcbf 100755 --- a/tools/ci/helper_functions.sh +++ b/tools/ci/helper_functions.sh @@ -75,7 +75,8 @@ function setup_python_env() { # Activate the virtual environment echo "Activating virtual environment in ${venv_dir}..." source "${venv_dir}/bin/activate" - pip install --no-cache-dir xmos_ai_tools + python -m pip install --upgrade pip + pip install --no-cache-dir -r "${req_file}" echo "Python environment setup complete." else # Activate the virtual environment From 3e715c368298a8f8800483a0a20ab793b51bdca2 Mon Sep 17 00:00:00 2001 From: Mischa Siekmann Date: Tue, 11 Mar 2025 21:48:06 +0100 Subject: [PATCH 2/6] introducing usb-audio targets --- .../reference/fixed_delay/audio_pipeline_t0.c | 4 + .../SATELLITE1-USB.cmake} | 43 ++- .../bsp_config/SATELLITE1-USB/SATELLITE1.xn | 84 ++++++ .../SATELLITE1-USB/platform/app_pll_ctrl.c | 51 ++++ .../SATELLITE1-USB/platform/app_pll_ctrl.h | 19 ++ .../platform/driver_instances.c | 40 +++ .../platform/driver_instances.h | 65 +++++ .../SATELLITE1-USB/platform/platform_conf.h | 198 +++++++++++++ .../SATELLITE1-USB/platform/platform_init.c | 260 ++++++++++++++++++ .../SATELLITE1-USB/platform/platform_init.h | 12 + .../SATELLITE1-USB/platform/platform_start.c | 138 ++++++++++ .../bsp_config/SATELLITE1/usb_mode/dac_port.c | 38 --- .../bsp_config/bsp_config.cmake | 1 + satellite-xmos-firmware/firmware.cmake | 3 +- satellite-xmos-firmware/satellite1-usb.cmake | 214 ++++++++++++++ .../satellite1_usb_debug.cmake | 147 ---------- satellite-xmos-firmware/src/app_conf.h | 11 + satellite-xmos-firmware/src/main.c | 53 ++-- satellite-xmos-firmware/src/usb/tusb_config.h | 16 +- satellite-xmos-firmware/src/usb/usb_audio.c | 32 ++- tools/ci/firmwares.txt | 4 +- 21 files changed, 1182 insertions(+), 251 deletions(-) rename satellite-xmos-firmware/bsp_config/{SATELLITE1/SATELLITE1_USB.cmake => SATELLITE1-USB/SATELLITE1-USB.cmake} (54%) create mode 100644 satellite-xmos-firmware/bsp_config/SATELLITE1-USB/SATELLITE1.xn create mode 100644 satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/app_pll_ctrl.c create mode 100644 satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/app_pll_ctrl.h create mode 100644 satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/driver_instances.c create mode 100644 satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/driver_instances.h create mode 100644 satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_conf.h create mode 100644 satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_init.c create mode 100644 satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_init.h create mode 100644 satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_start.c delete mode 100644 satellite-xmos-firmware/bsp_config/SATELLITE1/usb_mode/dac_port.c create mode 100644 satellite-xmos-firmware/satellite1-usb.cmake delete mode 100644 satellite-xmos-firmware/satellite1_usb_debug.cmake diff --git a/satellite-xmos-firmware/audio_pipelines/reference/fixed_delay/audio_pipeline_t0.c b/satellite-xmos-firmware/audio_pipelines/reference/fixed_delay/audio_pipeline_t0.c index 12f936c..61e6aaa 100644 --- a/satellite-xmos-firmware/audio_pipelines/reference/fixed_delay/audio_pipeline_t0.c +++ b/satellite-xmos-firmware/audio_pipelines/reference/fixed_delay/audio_pipeline_t0.c @@ -92,8 +92,10 @@ static void stage_vnr_and_ic(frame_data_t *frame_data) /* Intentionally ignoring comms ch from here on out */ memcpy(frame_data->samples[0], ic_output, appconfAUDIO_PIPELINE_FRAME_ADVANCE * sizeof(int32_t)); +#if appconfAUDIO_PIPELINE_STORE_IC_AUDIO memcpy(frame_data->aec_reference_audio_samples[0], ic_output, appconfAUDIO_PIPELINE_FRAME_ADVANCE * sizeof(int32_t)); // Store the interference cancelled audio in the first reference channel #endif +#endif } static void stage_ns(frame_data_t *frame_data) @@ -107,8 +109,10 @@ static void stage_ns(frame_data_t *frame_data) ns_output, frame_data->samples[0]); memcpy(frame_data->samples[0], ns_output, appconfAUDIO_PIPELINE_FRAME_ADVANCE * sizeof(int32_t)); +#if appconfAUDIO_PIPELINE_STORE_NS_AUDIO memcpy(frame_data->aec_reference_audio_samples[1], ns_output, appconfAUDIO_PIPELINE_FRAME_ADVANCE * sizeof(int32_t)); // Store NS audio in the second reference channel #endif +#endif } static void stage_agc(frame_data_t *frame_data) diff --git a/satellite-xmos-firmware/bsp_config/SATELLITE1/SATELLITE1_USB.cmake b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/SATELLITE1-USB.cmake similarity index 54% rename from satellite-xmos-firmware/bsp_config/SATELLITE1/SATELLITE1_USB.cmake rename to satellite-xmos-firmware/bsp_config/SATELLITE1-USB/SATELLITE1-USB.cmake index 9e6f37e..403eb4e 100644 --- a/satellite-xmos-firmware/bsp_config/SATELLITE1/SATELLITE1_USB.cmake +++ b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/SATELLITE1-USB.cmake @@ -1,39 +1,48 @@ ## Create custom board targets for application -add_library(sln_voice_app_ffva_board_support_satellite1 INTERFACE) -target_sources(sln_voice_app_ffva_board_support_satellite1 +add_library(fph_ffva_board_support_satellite1_usb INTERFACE) +target_sources(fph_ffva_board_support_satellite1_usb INTERFACE - ${CMAKE_CURRENT_LIST_DIR}/platform/dac_port.c ${CMAKE_CURRENT_LIST_DIR}/platform/app_pll_ctrl.c ${CMAKE_CURRENT_LIST_DIR}/platform/driver_instances.c ${CMAKE_CURRENT_LIST_DIR}/platform/platform_init.c ${CMAKE_CURRENT_LIST_DIR}/platform/platform_start.c ) -target_include_directories(sln_voice_app_ffva_board_support_satellite1 +target_include_directories(fph_ffva_board_support_satellite1_usb INTERFACE ${CMAKE_CURRENT_LIST_DIR} ) -target_link_libraries(sln_voice_app_ffva_board_support_satellite1 +target_link_libraries(fph_ffva_board_support_satellite1_usb INTERFACE core::general rtos::freertos rtos::drivers::general - #rtos::drivers::audio - rtos::drivers::mic_array - fph::i2s_sync rtos::drivers::usb rtos::drivers::dfu_image - sln_voice::app::ffva::dac::aic3204 + fph::rtos_mic_array + fph::i2s_sync + fph::rtos_ws2812 ) -target_compile_options(sln_voice_app_ffva_board_support_satellite1 +target_compile_options(fph_ffva_board_support_satellite1_usb INTERFACE - ${CMAKE_CURRENT_LIST_DIR}/SATTELITE1.xn + ${CMAKE_CURRENT_LIST_DIR}/SATELLITE1.xn ) -target_link_options(sln_voice_app_ffva_board_support_satellite1 +target_link_options(fph_ffva_board_support_satellite1_usb INTERFACE - ${CMAKE_CURRENT_LIST_DIR}/SATTELITE1.xn + ${CMAKE_CURRENT_LIST_DIR}/SATELLITE1.xn ) -target_compile_definitions(sln_voice_app_ffva_board_support_satellite1 + +# MICS: +# North: 0 (pin 0 falling edge) +# South: 1 (pin 1 falling edge) +# East: 4 (pin 0 rising edge ) +# West: 5 (pin 1 rising edge ) +# pins 2 & 3 are not used + +# use East as first and West as second mic +set(MIC_MAPPING "4, 5") + +target_compile_definitions(fph_ffva_board_support_satellite1_usb INTERFACE XCOREAI_EXPLORER=1 PLATFORM_SUPPORTS_TILE_0=1 @@ -46,7 +55,11 @@ target_compile_definitions(sln_voice_app_ffva_board_support_satellite1 MIC_ARRAY_CONFIG_MCLK_FREQ=24576000 MIC_ARRAY_CONFIG_PDM_FREQ=3072000 MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME=240 + MIC_ARRAY_CONFIG_USE_DDR=1 + MIC_ARRAY_CONFIG_MIC_INPUT=8 MIC_ARRAY_CONFIG_MIC_COUNT=2 + MIC_ARRAY_CONFIG_INPUT_MAPPING={${MIC_MAPPING}} + MIC_ARRAY_CONFIG_CLOCK_BLOCK_A=XS1_CLKBLK_1 MIC_ARRAY_CONFIG_CLOCK_BLOCK_B=XS1_CLKBLK_2 MIC_ARRAY_CONFIG_PORT_MCLK=PORT_MCLK_IN @@ -55,4 +68,4 @@ target_compile_definitions(sln_voice_app_ffva_board_support_satellite1 ) ## Create an alias -add_library(sln_voice::app::ffva::satellite1 ALIAS sln_voice_app_ffva_board_support_satellite1) +add_library(fph::ffva::satellite1-usb ALIAS fph_ffva_board_support_satellite1_usb) diff --git a/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/SATELLITE1.xn b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/SATELLITE1.xn new file mode 100644 index 0000000..eb6823c --- /dev/null +++ b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/SATELLITE1.xn @@ -0,0 +1,84 @@ + + + Board + FutureProofHomes Satellite1 + + + tileref tile[2] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/app_pll_ctrl.c b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/app_pll_ctrl.c new file mode 100644 index 0000000..4d963ef --- /dev/null +++ b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/app_pll_ctrl.c @@ -0,0 +1,51 @@ +// Copyright 2022-2023 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +/* System headers */ +#include +#include +#include +#include + +/* App headers */ +#include "platform/app_pll_ctrl.h" + +void app_pll_set_numerator(int numerator) +{ + const unsigned tileid = get_local_tile_id(); + uint32_t fracval = APP_PLL_FRAC_NOM & 0xFFFF00FF; + uint32_t f; + + if (numerator > 255) { + f = 255; + } else if (numerator < 0) { + f = 0; + } else { + f = numerator; + } + + fracval |= (f << 8); + write_sswitch_reg_no_ack(tileid, XS1_SSWITCH_SS_APP_PLL_FRAC_N_DIVIDER_NUM, fracval); +} + +void app_pll_init(void) +{ + unsigned tileid = get_local_tile_id(); + + const unsigned APP_PLL_DISABLE = 0x0201FF04; + const unsigned APP_PLL_DIV_0 = 0x80000004; + + write_sswitch_reg(tileid, XS1_SSWITCH_SS_APP_PLL_CTL_NUM, APP_PLL_DISABLE); + + hwtimer_t tmr = hwtimer_alloc(); + { + xassert(tmr != 0); + hwtimer_delay(tmr, 100000); // 1ms with 100 MHz timer tick + } + hwtimer_free(tmr); + + write_sswitch_reg(tileid, XS1_SSWITCH_SS_APP_PLL_CTL_NUM, APP_PLL_CTL_VAL); + write_sswitch_reg(tileid, XS1_SSWITCH_SS_APP_PLL_CTL_NUM, APP_PLL_CTL_VAL); + write_sswitch_reg(tileid, XS1_SSWITCH_SS_APP_PLL_FRAC_N_DIVIDER_NUM, APP_PLL_FRAC_NOM); + write_sswitch_reg(tileid, XS1_SSWITCH_SS_APP_CLK_DIVIDER_NUM, APP_PLL_DIV_0); +} diff --git a/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/app_pll_ctrl.h b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/app_pll_ctrl.h new file mode 100644 index 0000000..b4f3e7c --- /dev/null +++ b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/app_pll_ctrl.h @@ -0,0 +1,19 @@ +// Copyright 2022-2023 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#ifndef APP_PLL_CTRL_H_ +#define APP_PLL_CTRL_H_ + +#include "platform_conf.h" + +#if (MIC_ARRAY_CONFIG_MCLK_FREQ != 24576000) +#error PLL values only valid if MIC_ARRAY_CONFIG_MCLK_FREQ == 24576000 +#endif + +#define APP_PLL_CTL_VAL 0x0A019803 // Valid for all fractional values +#define APP_PLL_FRAC_NOM 0x800095F9 // 24.576000 MHz + +void app_pll_set_numerator(int numerator); +void app_pll_init(void); + +#endif /* APP_PLL_CTRL_H_ */ diff --git a/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/driver_instances.c b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/driver_instances.c new file mode 100644 index 0000000..c947e0d --- /dev/null +++ b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/driver_instances.c @@ -0,0 +1,40 @@ +// Copyright 2022-2023 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#include "platform/driver_instances.h" + +static rtos_intertile_t intertile_ctx_s; +rtos_intertile_t *intertile_ctx = &intertile_ctx_s; + +static rtos_intertile_t intertile_usb_audio_ctx_s; +rtos_intertile_t *intertile_usb_audio_ctx = &intertile_usb_audio_ctx_s; + +static rtos_qspi_flash_t qspi_flash_ctx_s; +rtos_qspi_flash_t *qspi_flash_ctx = &qspi_flash_ctx_s; + +static rtos_gpio_t gpio_ctx_t0_s; +rtos_gpio_t *gpio_ctx_t0 = &gpio_ctx_t0_s; + +static rtos_gpio_t gpio_ctx_t1_s; +rtos_gpio_t *gpio_ctx_t1 = &gpio_ctx_t1_s; + +static rtos_mic_array_t mic_array_ctx_s; +rtos_mic_array_t *mic_array_ctx = &mic_array_ctx_s; + +static rtos_i2s_t i2s_ctx_s; +rtos_i2s_t *i2s_ctx = &i2s_ctx_s; + +static rtos_spi_slave_t spi_slave_ctx_s; +rtos_spi_slave_t *spi_slave_ctx = &spi_slave_ctx_s; + +static rtos_dfu_image_t dfu_image_ctx_s; +rtos_dfu_image_t *dfu_image_ctx = &dfu_image_ctx_s; + +static rtos_ws2812_t ws2812_ctx_s; +rtos_ws2812_t *ws2812_ctx = &ws2812_ctx_s; + +static device_control_t device_control_spi_ctx_s; +device_control_t *device_control_spi_ctx = &device_control_spi_ctx_s; + +static device_control_gpio_ctx_t device_control_gpio_ctx_s; +device_control_gpio_ctx_t *device_control_gpio_ctx = &device_control_gpio_ctx_s; \ No newline at end of file diff --git a/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/driver_instances.h b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/driver_instances.h new file mode 100644 index 0000000..2267c0c --- /dev/null +++ b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/driver_instances.h @@ -0,0 +1,65 @@ +// Copyright 2022-2023 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#ifndef DRIVER_INSTANCES_H_ +#define DRIVER_INSTANCES_H_ + +#include "rtos_gpio.h" +#include "rtos_intertile.h" +#include "rtos_i2s.h" +#include "rtos_mic_array.h" +#include "rtos_qspi_flash.h" +#include "rtos_dfu_image.h" +#include "rtos_spi_slave.h" + +#include +#include "rtos_ws2812.h" +#include "device_control.h" +#include "gpio/gpio_servicer.h" + +/* Tile specifiers */ +#define FLASH_TILE_NO 0 +#define SPI_CLIENT_TILE_NO 0 + +#define MICARRAY_TILE_NO 1 +#define I2S_TILE_NO 1 +#define SPEAKER_PIPELINE_TILE_NO I2S_TILE_NO +#define WS2812_TILE_NO 1 + + +/** TILE 0 Clock Blocks */ +#define FLASH_CLKBLK XS1_CLKBLK_1 +#define MCLK_CLKBLK XS1_CLKBLK_2 +#define SPI_CLKBLK XS1_CLKBLK_3 +#define XUD_CLKBLK_1 XS1_CLKBLK_4 /* Reserved for lib_xud */ +#define XUD_CLKBLK_2 XS1_CLKBLK_5 /* Reserved for lib_xud */ + +/** TILE 1 Clock Blocks */ +#define PDM_CLKBLK_1 XS1_CLKBLK_1 +#define PDM_CLKBLK_2 XS1_CLKBLK_2 +#define I2S_CLKBLK XS1_CLKBLK_3 +// #define UNUSED_CLKBLK XS1_CLKBLK_4 +// #define UNUSED_CLKBLK XS1_CLKBLK_5 + +/* Port definitions */ +#define PORT_MCLK PORT_MCLK_IN + +/*LED RING*/ +#define LED_RING_NUM_LEDS 24 +#define LED_RING_PORT_PIN 3 + +extern rtos_intertile_t *intertile_ctx; +extern rtos_intertile_t *intertile_usb_audio_ctx; +extern rtos_qspi_flash_t *qspi_flash_ctx; +extern rtos_gpio_t *gpio_ctx_t0; +extern rtos_gpio_t *gpio_ctx_t1; +extern rtos_mic_array_t *mic_array_ctx; +extern rtos_spi_slave_t *spi_slave_ctx; +extern rtos_i2s_t *i2s_ctx; +extern rtos_dfu_image_t *dfu_image_ctx; +extern rtos_ws2812_t *ws2812_ctx; + +extern device_control_t *device_control_spi_ctx; +extern device_control_gpio_ctx_t *device_control_gpio_ctx; + +#endif /* DRIVER_INSTANCES_H_ */ diff --git a/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_conf.h b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_conf.h new file mode 100644 index 0000000..c631329 --- /dev/null +++ b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_conf.h @@ -0,0 +1,198 @@ +// Copyright 2022-2024 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#ifndef PLATFORM_CONF_H_ +#define PLATFORM_CONF_H_ + +/* + * Board support package for FPH Satellite1 + */ + +#if __has_include("app_conf.h") +#include "app_conf.h" +#endif /* __has_include("app_conf.h") */ + +/*****************************************/ +/* Intertile Communication Configuration */ +/*****************************************/ + +#ifndef appconfGPIO_RPC_PRIORITY +#define appconfGPIO_RPC_PRIORITY (configMAX_PRIORITIES/2) +#endif /* appconfGPIO_RPC_PRIORITY */ + +#ifndef appconfMIC_ARRAY_RPC_PORT +#define appconfMIC_ARRAY_RPC_PORT 13 +#endif /* appconfMIC_ARRAY_RPC_PORT */ + +#ifndef appconfMIC_ARRAY_RPC_PRIORITY +#define appconfMIC_ARRAY_RPC_PRIORITY (configMAX_PRIORITIES-2) +#endif /* appconfMIC_ARRAY_RPC_PRIORITY */ + +#ifndef appconfI2S_RPC_PORT +#define appconfI2S_RPC_PORT 14 +#endif /* appconfI2S_RPC_PORT */ + +#ifndef appconfI2S_RPC_PRIORITY +#define appconfI2S_RPC_PRIORITY (configMAX_PRIORITIES-2) +#endif /* appconfI2S_RPC_PRIORITY */ + +#ifndef appconfSPI_DEV_CTRL_PORT +#define appconfSPI_DEV_CTRL_PORT 15 +#endif /* appconfSPI_DEV_CTRL_PORT */ + +#ifndef appconfSPI_DEV_CTRL_PRIORITY +#define appconfSPI_DEV_CTRL_PRIORITY (configMAX_PRIORITIES/2) +#endif /* appconfSPI_DEV_CTRL_PRIORITY */ + +#ifndef appconfUSB_CDC_PORT +#define appconfUSB_CDC_PORT 16 +#endif /* appconfUSP_CDC_PORT */ + +#ifndef appconfUSB_CDC_PRIORITY +#define appconfUSB_CDC_PRIORITY (configMAX_PRIORITIES/2) +#endif /* appconfSPI_DEV_CTRL_PRIORITY */ + + + +/*****************************************/ +/* I/O and interrupt cores for Tile 0 */ +/*****************************************/ +#ifndef appconfSPI_IO_CORE +#define appconfSPI_IO_CORE 1 /* Must be kept off core 0 with the RTOS tick ISR */ +#endif /* appconfSPI_IO_CORE */ + +#ifndef appconfSPI_INTERRUPT_CORE +#define appconfSPI_INTERRUPT_CORE 2 /* Must be kept off I/O cores. */ +#endif /* appconfSPI_INTERRUPT_CORE */ + + + + +/*****************************************/ +/* I/O and interrupt cores for Tile 1 */ +/*****************************************/ +#ifndef appconfPDM_MIC_IO_CORE +#define appconfPDM_MIC_IO_CORE 1 /* Must be kept off I/O cores. Must be kept off core 0 with the RTOS tick ISR */ +#endif /* appconfPDM_MIC_IO_CORE */ + +#ifndef appconfI2S_IO_CORE +#define appconfI2S_IO_CORE 2 /* Must be kept off core 0 with the RTOS tick ISR */ +#endif /* appconfI2S_IO_CORE */ + +#ifndef appconfPDM_MIC_INTERRUPT_CORE +#define appconfPDM_MIC_INTERRUPT_CORE 3 /* Must be kept off I/O cores. Best kept off core 0 with the tick ISR. */ +#endif /* appconfPDM_MIC_INTERRUPT_CORE */ + +#ifndef appconfI2S_INTERRUPT_CORE +#define appconfI2S_INTERRUPT_CORE 4 /* Must be kept off I/O cores. Best kept off core 0 with the tick ISR. */ +#endif /* appconfI2S_INTERRUPT_CORE */ + + +/*****************************************/ +/* I/O Task Priorities */ +/*****************************************/ +#ifndef appconfQSPI_FLASH_TASK_PRIORITY +#define appconfQSPI_FLASH_TASK_PRIORITY ( configMAX_PRIORITIES - 1 ) +#endif /* appconfQSPI_FLASH_TASK_PRIORITY */ + +#ifndef appconfSPI_TASK_PRIORITY +#define appconfSPI_TASK_PRIORITY (configMAX_PRIORITIES/2) +#endif /* appconfSPI_TASK_PRIORITY */ + +#ifndef appconfDEVICE_CONTROL_SPI_PRIORITY +#define appconfDEVICE_CONTROL_SPI_PRIORITY (configMAX_PRIORITIES-2) +#endif // appconfDEVICE_CONTROL_SPI_PRIORITY + + +/*****************************************/ +/* CONFIGURATION */ +/*****************************************/ + +#ifndef appconfAUDIO_CLOCK_FREQUENCY +#define appconfAUDIO_CLOCK_FREQUENCY MIC_ARRAY_CONFIG_MCLK_FREQ +#endif /* appconfAUDIO_CLOCK_FREQUENCY */ + +#ifndef appconfPDM_CLOCK_FREQUENCY +#define appconfPDM_CLOCK_FREQUENCY MIC_ARRAY_CONFIG_PDM_FREQ +#endif /* appconfPDM_CLOCK_FREQUENCY */ + +#ifndef appconfPIPELINE_AUDIO_SAMPLE_RATE +#define appconfPIPELINE_AUDIO_SAMPLE_RATE 16000 +#endif /* appconfPIPELINE_AUDIO_SAMPLE_RATE */ + +#ifndef appconfDEVICE_CTRL_SPI +#define appconfDEVICE_CTRL_SPI 0 +#endif /* appconfDEVICE_CTRL_SPI */ + +#ifndef APP_CONTROL_TRANSPORT_COUNT +#define APP_CONTROL_TRANSPORT_COUNT (appconfDEVICE_CTRL_SPI) +#endif // APP_CONTROL_TRANSPORT_COUNT + +#ifndef appconfEXTERNAL_MCLK +#define appconfEXTERNAL_MCLK 0 +#endif /* appconfEXTERNAL_MCLK */ + +#ifndef appconfI2S_MODE_MASTER +#define appconfI2S_MODE_MASTER 0 +#endif /* appconfI2S_MODE_MASTER */ +#ifndef appconfI2S_MODE_SLAVE +#define appconfI2S_MODE_SLAVE 1 +#endif /* appconfI2S_MODE_SLAVE */ +#ifndef appconfI2S_MODE +#define appconfI2S_MODE appconfI2S_MODE_MASTER +#endif /* appconfI2S_MODE */ + + +/*****************************************/ +/* DFU Settings */ +/*****************************************/ +#define FL_QUADDEVICE_W25Q64JV \ +{ \ + 0, /* Just specify 0 as flash_id */ \ + 256, /* page size */ \ + 32768, /* num pages */ \ + 3, /* address size */ \ + 4, /* log2 clock divider */ \ + 0x9F, /* QSPI_RDID */ \ + 0, /* id dummy bytes */ \ + 3, /* id size in bytes */ \ + 0xEF4017, /* device id (determined from xflash --spi-read-id 0x9F)*/ \ + 0x20, /* QSPI_SE */ \ + 4096, /* Sector erase is always 4KB */ \ + 0x06, /* QSPI_WREN */ \ + 0x04, /* QSPI_WRDI */ \ + PROT_TYPE_SR, /* Protection via SR */ \ + {{0x18,0x00},{0,0}}, /* QSPI_SP, QSPI_SU */ \ + 0x02, /* QSPI_PP */ \ + 0xEB, /* QSPI_READ_FAST */ \ + 1, /* 1 read dummy byte */ \ + SECTOR_LAYOUT_REGULAR, /* mad sectors */ \ + {4096,{0,{0}}}, /* regular sector sizes */ \ + 0x05, /* QSPI_RDSR */ \ + 0x01, /* QSPI_WRSR */ \ + 0x01, /* QSPI_WIP_BIT_MASK */ \ +} + +#ifndef BOARD_QSPI_SPEC +/* Set up a default SPI spec if the app has not provided + * one explicitly. + * Note: The version checks only work in XTC Tools >15.2.0 + * By default FL_QUADDEVICE_W25Q64JV is used + */ +#ifdef __XMOS_XTC_VERSION_MAJOR__ +#if (__XMOS_XTC_VERSION_MAJOR__ == 15) \ + && (__XMOS_XTC_VERSION_MINOR__ >= 2) \ + && (__XMOS_XTC_VERSION_PATCH__ >= 0) +/* In XTC >15.2.0 some SFDP support enables a generic + * default spec + */ +#define BOARD_QSPI_SPEC FL_QUADDEVICE_DEFAULT +#else +#define BOARD_QSPI_SPEC FL_QUADDEVICE_W25Q64JV +#endif +#else +#define BOARD_QSPI_SPEC FL_QUADDEVICE_W25Q64JV +#endif /* __XMOS_XTC_VERSION_MAJOR__ */ +#endif /* BOARD_QSPI_SPEC */ + +#endif /* PLATFORM_CONF_H_ */ diff --git a/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_init.c b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_init.c new file mode 100644 index 0000000..e2652d5 --- /dev/null +++ b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_init.c @@ -0,0 +1,260 @@ +// Copyright 2022-2024 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +/* System headers */ +#include + +/* App headers */ +#include "platform_conf.h" +#include "platform/app_pll_ctrl.h" +#include "platform/driver_instances.h" +#include "platform/platform_init.h" +#include "adaptive_rate_adjust.h" +#include "usb_support.h" +#include "usb_cdc.h" + +static void mclk_init(chanend_t other_tile_c) +{ +#if ON_TILE(1) && !appconfEXTERNAL_MCLK + app_pll_init(); +#endif +#if appconfUSB_AUDIO_ENABLED && ON_TILE(USB_TILE_NO) + adaptive_rate_adjust_init(); +#endif +} + +static void flash_init(void) +{ +#if ON_TILE(FLASH_TILE_NO) + fl_QuadDeviceSpec qspi_spec = BOARD_QSPI_SPEC; + fl_QSPIPorts qspi_ports = { + .qspiCS = PORT_SQI_CS, + .qspiSCLK = PORT_SQI_SCLK, + .qspiSIO = PORT_SQI_SIO, + .qspiClkblk = FLASH_CLKBLK, + }; + + rtos_dfu_image_init( + dfu_image_ctx, + &qspi_ports, + &qspi_spec, + 1); + + rtos_qspi_flash_init( + qspi_flash_ctx, + FLASH_CLKBLK, + PORT_SQI_CS, + PORT_SQI_SCLK, + PORT_SQI_SIO, + NULL); +#endif +} + +static void gpio_init(void) +{ + static rtos_driver_rpc_t gpio_rpc_config_t0; + static rtos_driver_rpc_t gpio_rpc_config_t1; + rtos_intertile_t *client_intertile_ctx[1] = {intertile_ctx}; + +#if ON_TILE(0) + rtos_gpio_init(gpio_ctx_t0); + + rtos_gpio_rpc_host_init( + gpio_ctx_t0, + &gpio_rpc_config_t0, + client_intertile_ctx, + 1); + + rtos_gpio_rpc_client_init( + gpio_ctx_t1, + &gpio_rpc_config_t1, + intertile_ctx); +#endif + +#if ON_TILE(1) + rtos_gpio_init(gpio_ctx_t1); + + rtos_gpio_rpc_client_init( + gpio_ctx_t0, + &gpio_rpc_config_t0, + intertile_ctx); + + rtos_gpio_rpc_host_init( + gpio_ctx_t1, + &gpio_rpc_config_t1, + client_intertile_ctx, + 1); +#endif +} + + + +static void spi_init(void) +{ +#if appconfDEVICE_CTRL_SPI + rtos_intertile_t *client_intertile_ctx[1] = {intertile_ctx}; +#if ON_TILE(SPI_CLIENT_TILE_NO) + rtos_spi_slave_init(spi_slave_ctx, + (1 << appconfSPI_IO_CORE), + SPI_CLKBLK, + SPI_MODE_3, + PORT_XSPI_CLK, + PORT_XSPI_MOSI, + PORT_XSPI_MISO, + PORT_XSPI_CS); + + device_control_init(device_control_spi_ctx, + DEVICE_CONTROL_HOST_MODE, + 3, //number of servicers + client_intertile_ctx, + 1); + + device_control_start(device_control_spi_ctx, + appconfSPI_DEV_CTRL_PORT, + -1); +#else + device_control_init(device_control_spi_ctx, + DEVICE_CONTROL_CLIENT_MODE, + 0, + client_intertile_ctx, + 1); + + device_control_start(device_control_spi_ctx, + appconfSPI_DEV_CTRL_PORT, + appconfSPI_DEV_CTRL_PRIORITY); +#endif +#endif +} + +static void mics_init(void) +{ + static rtos_driver_rpc_t mic_array_rpc_config; +#if ON_TILE(MICARRAY_TILE_NO) + rtos_intertile_t *client_intertile_ctx[1] = {intertile_ctx}; + rtos_mic_array_init( + mic_array_ctx, + (1 << appconfPDM_MIC_IO_CORE), + RTOS_MIC_ARRAY_CHANNEL_SAMPLE); + rtos_mic_array_rpc_host_init( + mic_array_ctx, + &mic_array_rpc_config, + client_intertile_ctx, + 1); +#else + rtos_mic_array_rpc_client_init( + mic_array_ctx, + &mic_array_rpc_config, + intertile_ctx); +#endif +} + +static void i2s_init(void) +{ +#if appconfI2S_ENABLED + static rtos_driver_rpc_t i2s_rpc_config; +#if ON_TILE(I2S_TILE_NO) + rtos_intertile_t *client_intertile_ctx[1] = {intertile_ctx}; + port_t p_i2s_dout[appconfI2S_AUDIO_OUTPUTS] = { + PORT_I2S_DOUT1, + PORT_I2S_DOUT2 + }; + port_t p_i2s_din[appconfI2S_AUDIO_INPUTS] = { + PORT_I2S_DIN + }; + + rtos_i2s_master_init( + i2s_ctx, + (1 << appconfI2S_IO_CORE), + p_i2s_dout, + appconfI2S_AUDIO_OUTPUTS, + p_i2s_din, + appconfI2S_AUDIO_INPUTS, + PORT_I2S_BCLK, + PORT_I2S_LRCLK, + PORT_MCLK, + I2S_CLKBLK); + rtos_i2s_rpc_host_init( + i2s_ctx, + &i2s_rpc_config, + client_intertile_ctx, + 1); +#else + rtos_i2s_rpc_client_init( + i2s_ctx, + &i2s_rpc_config, + intertile_ctx); +#endif +#endif + +} + +static void usb_init(void) +{ +#if appconfUSB_ENABLED && ON_TILE(USB_TILE_NO) + usb_manager_init(); +#endif +} + +static void ws2812_init(void) +{ +#if ON_TILE(WS2812_TILE_NO) + rtos_ws2812_init(ws2812_ctx, PORT_LED_RING, LED_RING_PORT_PIN, LED_RING_NUM_LEDS); +#endif +} + +static void servicer_init(void) +{ +#if ON_TILE(0) + static device_control_gpio_ports_t gpio_res_info[GPIO_CONTROLLER_MAX_RESOURCES]; + gpio_res_info[0].resource_idx = RESOURCE_IN_A; + gpio_res_info[0].writeable = false; + gpio_res_info[0].port_id = PORT_BUTTONS; + gpio_res_info[0].bit_mask = 240; + gpio_res_info[0].bit_shift = 4; + gpio_res_info[0].status_register = 1; + + + gpio_res_info[1].resource_idx = RESOURCE_IN_B; + gpio_res_info[1].writeable = false; + gpio_res_info[1].port_id = PORT_ROTARY_ENC; + gpio_res_info[1].bit_mask = 14; + gpio_res_info[1].bit_shift = 1; + gpio_res_info[1].status_register = 2; + + gpio_servicer_init( device_control_gpio_ctx, + gpio_ctx_t0, + gpio_res_info, + 1 ); +#endif +} + +static void usb_cdc_init(){ +#if appconfUSB_CDC_ENABLED +#if ON_TILE(USB_TILE_NO) + rtos_intertile_t *client_intertile_ctx[1] = {intertile_ctx}; + rtos_cdc_rpc_host_init(client_intertile_ctx,1); +#else + rtos_cdc_rpc_client_init(intertile_ctx); +#endif +#endif +} + + + +void platform_init(chanend_t other_tile_c) +{ + rtos_intertile_init(intertile_ctx, other_tile_c); +#if appconfUSB_AUDIO_ENABLED + rtos_intertile_init(intertile_usb_audio_ctx, other_tile_c); +#endif + mclk_init(other_tile_c); + gpio_init(); + flash_init(); + spi_init(); + mics_init(); + i2s_init(); + usb_init(); + ws2812_init(); + servicer_init(); + usb_cdc_init(); +} diff --git a/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_init.h b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_init.h new file mode 100644 index 0000000..3eeea9d --- /dev/null +++ b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_init.h @@ -0,0 +1,12 @@ +// Copyright 2022-2023 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +#ifndef PLATFORM_INIT_H_ +#define PLATFORM_INIT_H_ + +#include + +void platform_init(chanend_t other_tile_c); +void platform_start(void); + +#endif /* PLATFORM_INIT_H_ */ diff --git a/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_start.c b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_start.c new file mode 100644 index 0000000..8bb2379 --- /dev/null +++ b/satellite-xmos-firmware/bsp_config/SATELLITE1-USB/platform/platform_start.c @@ -0,0 +1,138 @@ +// Copyright 2022-2024 XMOS LIMITED. +// This Software is subject to the terms of the XMOS Public Licence: Version 1. + +/* System headers */ +#include + +/* FreeRTOS headers */ +#include "FreeRTOS.h" + +/* Library headers */ +#include "fs_support.h" + +/* App headers */ +#include "platform_conf.h" +#include "platform/driver_instances.h" +#include "usb_support.h" +#include "usb_cdc.h" + + +#if appconfDEVICE_CTRL_SPI +#include "device_control_spi.h" +#endif + + +static void gpio_start(void) +{ + rtos_gpio_rpc_config(gpio_ctx_t0, appconfGPIO_T0_RPC_PORT, appconfGPIO_RPC_PRIORITY); + rtos_gpio_rpc_config(gpio_ctx_t1, appconfGPIO_T1_RPC_PORT, appconfGPIO_RPC_PRIORITY); + +#if ON_TILE(0) + rtos_gpio_start(gpio_ctx_t0); +#endif +#if ON_TILE(1) + rtos_gpio_start(gpio_ctx_t1); +#endif +} + +static void flash_start(void) +{ +#if ON_TILE(FLASH_TILE_NO) + uint32_t flash_core_map = ~((1 << appconfUSB_INTERRUPT_CORE) | (1 << appconfUSB_SOF_INTERRUPT_CORE)); + rtos_qspi_flash_start(qspi_flash_ctx, appconfQSPI_FLASH_TASK_PRIORITY); + rtos_qspi_flash_op_core_affinity_set(qspi_flash_ctx, flash_core_map); +#endif +} + + +static void spi_start(void) +{ +#if appconfDEVICE_CTRL_SPI && ON_TILE(SPI_CLIENT_TILE_NO) +#if 0 //do we need this? + const rtos_gpio_port_id_t wifi_rst_port = rtos_gpio_port(WIFI_WUP_RST_N); + rtos_gpio_port_enable(gpio_ctx_t0, wifi_rst_port); + rtos_gpio_port_out(gpio_ctx_t0, wifi_rst_port, 0x00); + + const rtos_gpio_port_id_t wifi_cs_port = rtos_gpio_port(WIFI_CS_N); + rtos_gpio_port_enable(gpio_ctx_t0, wifi_cs_port); + rtos_gpio_port_out(gpio_ctx_t0, wifi_cs_port, 0x0F); +#endif + rtos_spi_slave_start(spi_slave_ctx, + device_control_spi_ctx, + (rtos_spi_slave_start_cb_t) device_control_spi_start_cb, + (rtos_spi_slave_xfer_done_cb_t) device_control_spi_xfer_done_cb, + appconfSPI_INTERRUPT_CORE, + appconfSPI_TASK_PRIORITY); +#endif +} + +static void mics_start(void) +{ + rtos_mic_array_rpc_config(mic_array_ctx, appconfMIC_ARRAY_RPC_PORT, appconfMIC_ARRAY_RPC_PRIORITY); + +#if ON_TILE(MICARRAY_TILE_NO) + rtos_mic_array_start( + mic_array_ctx, + 2 * MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME, + appconfPDM_MIC_INTERRUPT_CORE); +#endif +} + +static void i2s_start(void) +{ +#if appconfI2S_ENABLED + rtos_i2s_rpc_config(i2s_ctx, appconfI2S_RPC_PORT, appconfI2S_RPC_PRIORITY); + +#if ON_TILE(I2S_TILE_NO) + rtos_i2s_start( + i2s_ctx, + rtos_i2s_mclk_bclk_ratio(appconfAUDIO_CLOCK_FREQUENCY, appconfI2S_AUDIO_SAMPLE_RATE), + I2S_MODE_I2S, + 2.2 * MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME * 3, + 1.2 * MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME * 3, + appconfI2S_INTERRUPT_CORE); +#endif +#endif +} + +static void usb_start(void) +{ +#if appconfUSB_ENABLED && ON_TILE(USB_TILE_NO) + usb_manager_start(appconfUSB_MGR_TASK_PRIORITY); +#endif +} + +static void ws2812_start(void) +{ +#if ON_TILE(WS2812_TILE_NO) + rtos_ws2812_start(ws2812_ctx); +#endif +} + +static void usb_cdc_start(void) +{ +#if appconfUSB_CDC_ENABLED + rtos_cdc_rpc_config(appconfUSB_CDC_PORT, appconfUSB_CDC_PRIORITY); +#if ON_TILE(USB_TILE_NO) + rtos_cdc_start(); +#endif +#endif +} + + + +void platform_start(void) +{ + rtos_intertile_start(intertile_ctx); +#if appconfUSB_AUDIO_ENABLED + rtos_intertile_start(intertile_usb_audio_ctx); +#endif + gpio_start(); + flash_start(); + spi_start(); + mics_start(); + i2s_start(); + usb_start(); + ws2812_start(); + usb_cdc_start(); +} diff --git a/satellite-xmos-firmware/bsp_config/SATELLITE1/usb_mode/dac_port.c b/satellite-xmos-firmware/bsp_config/SATELLITE1/usb_mode/dac_port.c deleted file mode 100644 index 73f9584..0000000 --- a/satellite-xmos-firmware/bsp_config/SATELLITE1/usb_mode/dac_port.c +++ /dev/null @@ -1,38 +0,0 @@ -// Copyright 2022-2023 XMOS LIMITED. -// This Software is subject to the terms of the XMOS Public Licence: Version 1. - -/* System headers */ -#include - -/* FreeRTOS headers */ -#include "FreeRTOS.h" - -/* App headers */ -#include "platform_conf.h" -#include "platform/driver_instances.h" -#include "aic3204.h" - -int aic3204_reg_write(uint8_t reg, uint8_t val) -{ - i2c_regop_res_t ret; - - ret = rtos_i2c_master_reg_write(i2c_master_ctx, AIC3204_I2C_DEVICE_ADDR, reg, val); - - if (ret == I2C_REGOP_SUCCESS) { - return 0; - } else { - return -1; - } -} - -void aic3204_codec_reset(void) -{ - const rtos_gpio_port_id_t codec_rst_port = rtos_gpio_port(PORT_CODEC_RST_N); - rtos_gpio_port_enable(gpio_ctx_t1, codec_rst_port); - rtos_gpio_port_out(gpio_ctx_t1, codec_rst_port, 0xF); -} - -void aic3204_wait(uint32_t wait_ms) -{ - vTaskDelay(pdMS_TO_TICKS(wait_ms)); -} diff --git a/satellite-xmos-firmware/bsp_config/bsp_config.cmake b/satellite-xmos-firmware/bsp_config/bsp_config.cmake index 66d1d87..c17b887 100644 --- a/satellite-xmos-firmware/bsp_config/bsp_config.cmake +++ b/satellite-xmos-firmware/bsp_config/bsp_config.cmake @@ -1,5 +1,6 @@ include(${CMAKE_CURRENT_LIST_DIR}/dac/dac.cmake) include(${CMAKE_CURRENT_LIST_DIR}/SATELLITE1/SATELLITE1.cmake) +include(${CMAKE_CURRENT_LIST_DIR}/SATELLITE1-USB/SATELLITE1-USB.cmake) include(${CMAKE_CURRENT_LIST_DIR}/XCORE-AI-EXPLORER/XCORE-AI-EXPLORER.cmake) diff --git a/satellite-xmos-firmware/firmware.cmake b/satellite-xmos-firmware/firmware.cmake index 8b4eb2e..db0d52d 100644 --- a/satellite-xmos-firmware/firmware.cmake +++ b/satellite-xmos-firmware/firmware.cmake @@ -91,5 +91,6 @@ endif() # XMOS Firmware Targets #********************** include(${CMAKE_CURRENT_LIST_DIR}/satellite1.cmake) +include(${CMAKE_CURRENT_LIST_DIR}/satellite1-usb.cmake) include(${CMAKE_CURRENT_LIST_DIR}/explorer_devboard.cmake) -include(${CMAKE_CURRENT_LIST_DIR}/satellite1_usb_debug.cmake) + diff --git a/satellite-xmos-firmware/satellite1-usb.cmake b/satellite-xmos-firmware/satellite1-usb.cmake new file mode 100644 index 0000000..9bc7de9 --- /dev/null +++ b/satellite-xmos-firmware/satellite1-usb.cmake @@ -0,0 +1,214 @@ +query_tools_version() + +set(FFVA_FD_PIPELINE_CONFIGS + aec__vnr_ic__ns__agc + aec__vnr_ic__ns + aec__vnr_ic + vnr_ic__ns + vnr_ic + ns +) + +set(FFVA_AP "fixed_delay") + +foreach(FFVA_PL_CFG ${FFVA_FD_PIPELINE_CONFIGS}) + + set(FFVA_INT_COMPILE_DEFINITIONS + ${APP_COMPILE_DEFINITIONS} + appconfDEVICE_CTRL_SPI=0 + appconfEXTERNAL_MCLK=0 + appconfI2S_ENABLED=1 + + appconfUSB_ENABLED=1 + appconfUSB_AUDIO_ENABLED=1 + appconfUSB_AUDIO_MODE=1 + appconfUSB_CDC_ENABLED=1 + + appconfAEC_REF_DEFAULT=appconfAEC_REF_USB + appconfI2S_MODE=appconfI2S_MODE_MASTER + appconfI2S_AUDIO_SAMPLE_RATE=16000 + appconfAUDIO_SPK_PL_SR_FACTOR=1 + + appconfAUDIO_PIPELINE_STORE_IC_AUDIO=0 + appconfAUDIO_PIPELINE_STORE_NS_AUDIO=0 + + #appconfAUDIO_PIPELINE_SKIP_AEC=0 + #appconfAUDIO_PIPELINE_SKIP_NS=0 + #appconfAUDIO_PIPELINE_SKIP_IC_AND_VNR=0 + #appconfAUDIO_PIPELINE_SKIP_AGC=1 + ) + if(${FFVA_PL_CFG} STREQUAL aec__vnr_ic__ns__agc) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_AEC=0) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_NS=0) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_IC_AND_VNR=0) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_AGC=0) + elseif(${FFVA_PL_CFG} STREQUAL aec__vnr_ic__ns) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_AEC=0) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_NS=0) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_IC_AND_VNR=0) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_AGC=1) + elseif(${FFVA_PL_CFG} STREQUAL aec__vnr_ic) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_AEC=0) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_NS=1) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_IC_AND_VNR=0) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_AGC=1) + elseif(${FFVA_PL_CFG} STREQUAL vnr_ic__ns) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_AEC=1) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_NS=0) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_IC_AND_VNR=0) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_AGC=1) + elseif(${FFVA_PL_CFG} STREQUAL vnr_ic) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_AEC=1) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_NS=1) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_IC_AND_VNR=0) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_AGC=1) + elseif(${FFVA_PL_CFG} STREQUAL ns) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_AEC=1) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_NS=0) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_IC_AND_VNR=1) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfAUDIO_PIPELINE_SKIP_AGC=1) + endif() + + if(${FFVA_AP} STREQUAL bypass ) + set(PL_NAME fixed_delay) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfPIPELINE_BYPASS=1) + else() + set(PL_NAME ${FFVA_AP}) + list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfPIPELINE_BYPASS=0) + endif() + + # message(${FFVA_INT_COMPILE_DEFINITIONS}) + + #********************** + # Tile Targets + #********************** + set(TARGET_NAME tile0_satellite1_usb_firmware_${FFVA_PL_CFG}) + add_executable(${TARGET_NAME} EXCLUDE_FROM_ALL) + target_sources(${TARGET_NAME} PUBLIC ${APP_SOURCES}) + target_include_directories(${TARGET_NAME} PUBLIC ${APP_INCLUDES}) + target_compile_definitions(${TARGET_NAME} + PUBLIC + ${FFVA_INT_COMPILE_DEFINITIONS} + THIS_XCORE_TILE=0 + ) + target_compile_options(${TARGET_NAME} PRIVATE ${APP_COMPILER_FLAGS}) + target_link_libraries(${TARGET_NAME} + PUBLIC + ${APP_COMMON_LINK_LIBRARIES} + fph::ffva::satellite1-usb + fph::ffva::ap::${PL_NAME} + sln_voice::app::ffva::sp::passthrough + ) + target_link_options(${TARGET_NAME} PRIVATE ${APP_LINK_OPTIONS}) + unset(TARGET_NAME) + + set(TARGET_NAME tile1_satellite1_usb_firmware_${FFVA_PL_CFG}) + add_executable(${TARGET_NAME} EXCLUDE_FROM_ALL) + target_sources(${TARGET_NAME} PUBLIC ${APP_SOURCES}) + target_include_directories(${TARGET_NAME} PUBLIC ${APP_INCLUDES}) + target_compile_definitions(${TARGET_NAME} + PUBLIC + ${FFVA_INT_COMPILE_DEFINITIONS} + THIS_XCORE_TILE=1 + ) + target_compile_options(${TARGET_NAME} PRIVATE ${APP_COMPILER_FLAGS}) + target_link_libraries(${TARGET_NAME} + PUBLIC + ${APP_COMMON_LINK_LIBRARIES} + fph::ffva::satellite1-usb + fph::ffva::ap::${PL_NAME} + sln_voice::app::ffva::sp::passthrough + ) + target_link_options(${TARGET_NAME} PRIVATE ${APP_LINK_OPTIONS}) + unset(TARGET_NAME) + + #********************* + # Create version.h + #********************* + SET(VERSIONING_CMD "build") + if(USE_DEV_TRACKING) + list(APPEND VERSIONING_CMD "--track") + endif() + + add_custom_target(satellite1_usb_firmware_${FFVA_PL_CFG}_versioning + COMMAND ${Python3_EXECUTABLE} ${VERSIONING_SCRIPT} ${VERSIONING_CMD} satellite1_usb_firmware_${FFVA_PL_CFG} + COMMENT "Running versioning.py build satellite1_firmware_${FFVA_AP}" + VERBATIM + ) + add_dependencies(tile0_satellite1_usb_firmware_${FFVA_PL_CFG} satellite1_usb_firmware_${FFVA_PL_CFG}_versioning) + add_dependencies(tile1_satellite1_usb_firmware_${FFVA_PL_CFG} satellite1_usb_firmware_${FFVA_PL_CFG}_versioning) + + #********************** + # Merge binaries + #********************** + merge_binaries(satellite1_usb_firmware_${FFVA_PL_CFG} tile0_satellite1_usb_firmware_${FFVA_PL_CFG} tile1_satellite1_usb_firmware_${FFVA_PL_CFG} 1) + + #********************** + # Create run and debug targets + #********************** + create_run_target(satellite1_usb_firmware_${FFVA_PL_CFG}) + create_debug_target(satellite1_usb_firmware_${FFVA_PL_CFG}) + create_upgrade_img_target(satellite1_usb_firmware_${FFVA_PL_CFG} ${XTC_VERSION_MAJOR} ${XTC_VERSION_MINOR}) + + #********************** + # Create data partition support targets + #********************** + set(TARGET_NAME satellite1_usb_firmware_${FFVA_PL_CFG}) + set(DATA_PARTITION_FILE ${TARGET_NAME}_data_partition.bin) + set(FATFS_FILE ${TARGET_NAME}_fat.fs) + set(FATFS_CONTENTS_DIR ${TARGET_NAME}_fatmktmp) + + add_custom_target( + ${FATFS_FILE} ALL + COMMAND ${CMAKE_COMMAND} -E rm -rf ${FATFS_CONTENTS_DIR}/fs/ + COMMAND ${CMAKE_COMMAND} -E make_directory ${FATFS_CONTENTS_DIR}/fs/ + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_LIST_DIR}/filesystem_support/demo.txt ${FATFS_CONTENTS_DIR}/fs/ + COMMAND fatfs_mkimage --input=${FATFS_CONTENTS_DIR} --output=${FATFS_FILE} + COMMENT + "Create filesystem" + VERBATIM + ) + + set_target_properties(${FATFS_FILE} PROPERTIES + ADDITIONAL_CLEAN_FILES ${FATFS_CONTENTS_DIR} + ) + + # The filesystem is the only component in the data partition, copy it to + # the assocated data partition file which is required for CI. + add_custom_command( + OUTPUT ${DATA_PARTITION_FILE} + COMMAND ${CMAKE_COMMAND} -E copy ${FATFS_FILE} ${DATA_PARTITION_FILE} + DEPENDS + ${FATFS_FILE} + COMMENT + "Create data partition" + VERBATIM + ) + + list(APPEND DATA_PARTITION_FILE_LIST + ${FATFS_FILE} + ${DATA_PARTITION_FILE} + ) + + create_data_partition_directory( + #[[ Target ]] ${TARGET_NAME} + #[[ Copy Files ]] "${DATA_PARTITION_FILE_LIST}" + #[[ Dependencies ]] "${DATA_PARTITION_FILE_LIST}" + ) + + create_flash_image_target( + #[[ Target ]] ${TARGET_NAME} + #[[ Boot Partition Size ]] 0x100000 + # #[[ Data Partition Contents ]] ${DATA_PARTITION_FILE} + # #[[ Dependencies ]] ${DATA_PARTITION_FILE} + + ) + create_flash_app_target( + #[[ Target ]] ${TARGET_NAME} + #[[ Boot Partition Size ]] 0x100000 + #[[ Data Partition Contents ]] ${DATA_PARTITION_FILE} + #[[ Dependencies ]] ${DATA_PARTITION_FILE} + ) + + unset(DATA_PARTITION_FILE_LIST) +endforeach() diff --git a/satellite-xmos-firmware/satellite1_usb_debug.cmake b/satellite-xmos-firmware/satellite1_usb_debug.cmake deleted file mode 100644 index 36eded5..0000000 --- a/satellite-xmos-firmware/satellite1_usb_debug.cmake +++ /dev/null @@ -1,147 +0,0 @@ -query_tools_version() - -set(FFVA_AP bypass) -set(VARIANT_NAME satellite1_usb_debug) - -set(FFVA_INT_COMPILE_DEFINITIONS -${APP_COMPILE_DEFINITIONS} - appconfEXTERNAL_MCLK=0 - appconfI2S_ENABLED=1 - appconfUSB_ENABLED=1 - appconfUSB_AUDIO_MODE=1 # appconfUSB_AUDIO_TESTING (enables 6 channels) - appconfUSB_CDC_ENABLED=1 - appconfAEC_REF_DEFAULT=appconfAEC_REF_I2S - appconfI2S_MODE=appconfI2S_MODE_MASTER - appconfI2S_AUDIO_SAMPLE_RATE=48000 - appconfI2S_ESP_ENABLED=1 - - ## VK Voice uses 12288000 for RPI integration, EXPLORER Board uses default 24576000 - # MIC_ARRAY_CONFIG_MCLK_FREQ=12288000 -) -if(${FFVA_AP} STREQUAL bypass ) - set(PL_NAME fixed_delay) - list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfPIPELINE_BYPASS=1) -else() - set(PL_NAME ${FFVA_AP}) - list(APPEND FFVA_INT_COMPILE_DEFINITIONS appconfPIPELINE_BYPASS=0) -endif() - -# message(${FFVA_INT_COMPILE_DEFINITIONS}) - -#********************** -# Tile Targets -#********************** -set(TARGET_NAME tile0_${VARIANT_NAME}) -add_executable(${TARGET_NAME} EXCLUDE_FROM_ALL) -target_sources(${TARGET_NAME} PUBLIC ${APP_SOURCES}) -target_include_directories(${TARGET_NAME} PUBLIC ${APP_INCLUDES}) -target_compile_definitions(${TARGET_NAME} - PUBLIC - ${FFVA_INT_COMPILE_DEFINITIONS} - THIS_XCORE_TILE=0 -) -target_compile_options(${TARGET_NAME} PRIVATE ${APP_COMPILER_FLAGS}) -target_link_libraries(${TARGET_NAME} - PUBLIC - ${APP_COMMON_LINK_LIBRARIES} - sln_voice::app::ffva::xcore_ai_explorer - fph::ffva::ap::${PL_NAME} - sln_voice::app::ffva::sp::passthrough -) -target_link_options(${TARGET_NAME} PRIVATE ${APP_LINK_OPTIONS}) -unset(TARGET_NAME) - -set(TARGET_NAME tile1_${VARIANT_NAME}) -add_executable(${TARGET_NAME} EXCLUDE_FROM_ALL) -target_sources(${TARGET_NAME} PUBLIC ${APP_SOURCES}) -target_include_directories(${TARGET_NAME} PUBLIC ${APP_INCLUDES}) -target_compile_definitions(${TARGET_NAME} - PUBLIC - ${FFVA_INT_COMPILE_DEFINITIONS} - THIS_XCORE_TILE=1 -) -target_compile_options(${TARGET_NAME} PRIVATE ${APP_COMPILER_FLAGS}) -target_link_libraries(${TARGET_NAME} - PUBLIC - ${APP_COMMON_LINK_LIBRARIES} - sln_voice::app::ffva::xcore_ai_explorer - fph::ffva::ap::${PL_NAME} - sln_voice::app::ffva::sp::passthrough -) -target_link_options(${TARGET_NAME} PRIVATE ${APP_LINK_OPTIONS}) -unset(TARGET_NAME) - -#********************** -# Merge binaries -#********************** -merge_binaries(${VARIANT_NAME} tile0_${VARIANT_NAME} tile1_${VARIANT_NAME} 1) - -#********************** -# Create run and debug targets -#********************** -create_run_target(${VARIANT_NAME}) -create_debug_target(${VARIANT_NAME}) -create_upgrade_img_target(${VARIANT_NAME} ${XTC_VERSION_MAJOR} ${XTC_VERSION_MINOR}) - -#********************** -# Create data partition support targets -#********************** -set(TARGET_NAME ${VARIANT_NAME}) -set(DATA_PARTITION_FILE ${TARGET_NAME}_data_partition.bin) -set(FATFS_FILE ${TARGET_NAME}_fat.fs) -set(FATFS_CONTENTS_DIR ${TARGET_NAME}_fatmktmp) - -add_custom_target( - ${FATFS_FILE} ALL - COMMAND ${CMAKE_COMMAND} -E rm -rf ${FATFS_CONTENTS_DIR}/fs/ - COMMAND ${CMAKE_COMMAND} -E make_directory ${FATFS_CONTENTS_DIR}/fs/ - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_LIST_DIR}/filesystem_support/demo.txt ${FATFS_CONTENTS_DIR}/fs/ - COMMAND fatfs_mkimage --input=${FATFS_CONTENTS_DIR} --output=${FATFS_FILE} - COMMENT - "Create filesystem" - VERBATIM -) - -set_target_properties(${FATFS_FILE} PROPERTIES - ADDITIONAL_CLEAN_FILES ${FATFS_CONTENTS_DIR} -) - -# The filesystem is the only component in the data partition, copy it to -# the assocated data partition file which is required for CI. -add_custom_command( - OUTPUT ${DATA_PARTITION_FILE} - COMMAND ${CMAKE_COMMAND} -E copy ${FATFS_FILE} ${DATA_PARTITION_FILE} - DEPENDS - ${FATFS_FILE} - COMMENT - "Create data partition" - VERBATIM -) - -list(APPEND DATA_PARTITION_FILE_LIST - ${FATFS_FILE} - ${DATA_PARTITION_FILE} -) - -create_data_partition_directory( - #[[ Target ]] ${TARGET_NAME} - #[[ Copy Files ]] "${DATA_PARTITION_FILE_LIST}" - #[[ Dependencies ]] "${DATA_PARTITION_FILE_LIST}" -) - -create_flash_image_target( - #[[ Target ]] ${TARGET_NAME} - #[[ Boot Partition Size ]] 0x100000 -# #[[ Data Partition Contents ]] ${DATA_PARTITION_FILE} -# #[[ Dependencies ]] ${DATA_PARTITION_FILE} - -) -create_flash_app_target( - #[[ Target ]] ${TARGET_NAME} - #[[ Boot Partition Size ]] 0x100000 - #[[ Data Partition Contents ]] ${DATA_PARTITION_FILE} - #[[ Dependencies ]] ${DATA_PARTITION_FILE} -) - -unset(DATA_PARTITION_FILE_LIST) - diff --git a/satellite-xmos-firmware/src/app_conf.h b/satellite-xmos-firmware/src/app_conf.h index 7eeb2a0..327de91 100644 --- a/satellite-xmos-firmware/src/app_conf.h +++ b/satellite-xmos-firmware/src/app_conf.h @@ -24,7 +24,10 @@ #define appconfPDM_CLOCK_FREQUENCY MIC_ARRAY_CONFIG_PDM_FREQ #define appconfAUDIO_PIPELINE_SAMPLE_RATE 16000 #define appconfAUDIO_PIPELINE_CHANNELS MIC_ARRAY_CONFIG_MIC_COUNT + +#ifndef appconfAUDIO_SPK_PL_SR_FACTOR #define appconfAUDIO_SPK_PL_SR_FACTOR 3 +#endif /* If in channel sample format, appconfAUDIO_PIPELINE_FRAME_ADVANCE == MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME*/ #define appconfAUDIO_PIPELINE_FRAME_ADVANCE MIC_ARRAY_CONFIG_SAMPLES_PER_FRAME @@ -68,6 +71,14 @@ #define appconfAUDIO_PIPELINE_SKIP_AGC 0 #endif +#ifndef appconfAUDIO_PIPELINE_STORE_IC_AUDIO +#define appconfAUDIO_PIPELINE_STORE_IC_AUDIO 1 +#endif + +#ifndef appconfAUDIO_PIPELINE_STORE_NS_AUDIO +#define appconfAUDIO_PIPELINE_STORE_NS_AUDIO 1 +#endif + #ifndef appconfI2S_ENABLED #define appconfI2S_ENABLED 1 #endif diff --git a/satellite-xmos-firmware/src/main.c b/satellite-xmos-firmware/src/main.c index d2b5bd3..58e3b15 100644 --- a/satellite-xmos-firmware/src/main.c +++ b/satellite-xmos-firmware/src/main.c @@ -37,7 +37,6 @@ volatile int mic_from_usb = appconfMIC_SRC_DEFAULT; volatile int aec_ref_source = appconfAEC_REF_DEFAULT; -#if appconfI2S_ENABLED #if ON_TILE(SPEAKER_PIPELINE_TILE_NO) rtos_osal_queue_t *ref_input_queue; @@ -48,8 +47,8 @@ void speaker_pipeline_input(void *input_app_data, size_t ch_count, size_t frame_count) { - - if (!appconfUSB_ENABLED || aec_ref_source == appconfAEC_REF_I2S) { +#if ON_TILE(SPEAKER_PIPELINE_TILE_NO) + if (!appconfUSB_AUDIO_ENABLED || aec_ref_source == appconfAEC_REF_I2S) { /* This shouldn't need to block given it shares a clock with the PDM mics */ xassert(frame_count == appconfAUDIO_SPK_PIPELINE_FRAME_ADVANCE); @@ -70,6 +69,22 @@ void speaker_pipeline_input(void *input_app_data, *(tmpptr + i + frame_count) = tmp[i][0][1]; } } + +#if appconfUSB_AUDIO_ENABLED + int32_t **usb_mic_audio_frame = NULL; + if (true) { + usb_mic_audio_frame = input_audio_frames; + /* + * As noted above, this does not block. + * and expects ref L, ref R, mic 0, mic 1 + */ + usb_audio_recv(intertile_usb_audio_ctx, + frame_count, + usb_mic_audio_frame, + ch_count); + } +#endif +#endif } int speaker_pipeline_output(void *output_app_data, @@ -77,6 +92,7 @@ int speaker_pipeline_output(void *output_app_data, size_t ch_count, size_t frame_count) { +#if ON_TILE(SPEAKER_PIPELINE_TILE_NO) (void) output_app_data; xassert(frame_count == appconfAUDIO_SPK_PIPELINE_FRAME_ADVANCE); @@ -95,14 +111,13 @@ int speaker_pipeline_output(void *output_app_data, frame_count, portMAX_DELAY); -#if ON_TILE(SPEAKER_PIPELINE_TILE_NO) void* frame_data; frame_data = pvPortMalloc( appconfAUDIO_PIPELINE_FRAME_ADVANCE * appconfAUDIO_PIPELINE_CHANNELS * sizeof( int32_t )); - static int64_t sum[2]; - static int32_t src_data[2][SRC_FF3V_FIR_NUM_PHASES][SRC_FF3V_FIR_TAPS_PER_PHASE] __attribute__((aligned (8))); // down sample reference signal to 16kHz if needed if (appconfI2S_AUDIO_SAMPLE_RATE == 3*appconfAUDIO_PIPELINE_SAMPLE_RATE) { + static int64_t sum[2]; + static int32_t src_data[2][SRC_FF3V_FIR_NUM_PHASES][SRC_FF3V_FIR_TAPS_PER_PHASE] __attribute__((aligned (8))); int32_t tmp_out[appconfAUDIO_PIPELINE_FRAME_ADVANCE][1][appconfAUDIO_PIPELINE_CHANNELS]; for( int frame=0; frame < frame_count; frame +=3 ){ @@ -122,10 +137,11 @@ int speaker_pipeline_output(void *output_app_data, // send to microphone pipeline as reference (void) rtos_osal_queue_send(ref_input_queue, &frame_data, RTOS_OSAL_WAIT_FOREVER); + #endif return AUDIO_PIPELINE_FREE_FRAME; } -#endif + void audio_pipeline_input(void *input_app_data, @@ -180,28 +196,6 @@ void audio_pipeline_input(void *input_app_data, frame_count, portMAX_DELAY); -#if appconfUSB_AUDIO_ENABLED - int32_t **usb_mic_audio_frame = NULL; - size_t ch_cnt = 2; /* ref frames */ - - if (aec_ref_source == appconfAEC_REF_USB) { - usb_mic_audio_frame = input_audio_frames; - } - - if (mic_from_usb) { - ch_cnt += 2; /* mic frames */ - } - - /* - * As noted above, this does not block. - * and expects ref L, ref R, mic 0, mic 1 - */ - usb_audio_recv(intertile_usb_audio_ctx, - frame_count, - usb_mic_audio_frame, - ch_cnt); -#endif - } int audio_pipeline_output(void *output_app_data, @@ -294,6 +288,7 @@ static void mem_analysis(void) { for (;;) { rtos_printf("Tile[%d]:\n\tMinimum heap free: %d\n\tCurrent heap free: %d\n", THIS_XCORE_TILE, xPortGetMinimumEverFreeHeapSize(), xPortGetFreeHeapSize()); + cdc_printf("Tile[%d]:\n\tMinimum heap free: %d\n\tCurrent heap free: %d\n", THIS_XCORE_TILE, xPortGetMinimumEverFreeHeapSize(), xPortGetFreeHeapSize()); reset_watchdog(); vTaskDelay(pdMS_TO_TICKS(5000)); } diff --git a/satellite-xmos-firmware/src/usb/tusb_config.h b/satellite-xmos-firmware/src/usb/tusb_config.h index 08957f4..457df10 100644 --- a/satellite-xmos-firmware/src/usb/tusb_config.h +++ b/satellite-xmos-firmware/src/usb/tusb_config.h @@ -99,7 +99,7 @@ #define CFG_TUD_CDC_TX_BUFSIZE (TUD_OPT_HIGH_SPEED ? 512 : 64) // CDC Endpoint transfer buffer size, more is faster -#define CFG_TUD_CDC_EP_BUFSIZE (TUD_OPT_HIGH_SPEED ? 512 : 64) +#define CFG_TUD_CDC_EP_BUFSIZE (TUD_OPT_HIGH_SPEED ? 512 : 64) #endif //-------------------------------------------------------------------- @@ -121,7 +121,7 @@ extern const uint16_t tud_audio_desc_lengths[CFG_TUD_AUDIO]; #define CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX 2 #else #define CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_TX 6 -#define CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX 4 +#define CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX 2 #endif #if (appconfMIC_SRC_DEFAULT == appconfMIC_SRC_USB) @@ -136,7 +136,13 @@ extern const uint16_t tud_audio_desc_lengths[CFG_TUD_AUDIO]; #endif // EP and buffer sizes -#define AUDIO_FRAMES_PER_USB_FRAME (appconfUSB_AUDIO_SAMPLE_RATE / 1000) +#define appconfUSB_SPK_SAMPLE_RATE 16000 +#define AUDIO_FRAMES_PER_USB_SPK_FRAME (appconfUSB_SPK_SAMPLE_RATE / 1000) + +#define appconfUSB_MICS_SAMPLE_RATE 16000 +#define AUDIO_FRAMES_PER_USB_MICS_FRAME (appconfUSB_MICS_SAMPLE_RATE / 1000) + + #if appconfUSB_AUDIO_SAMPLE_RATE == 48000 #define USB_TASK_STACK_SIZE 2000 #endif @@ -144,12 +150,12 @@ extern const uint16_t tud_audio_desc_lengths[CFG_TUD_AUDIO]; // To support USB Adaptive/Asynchronous, maximum packet size must be large enough to accommodate an extra set of samples per frame. // Adding 1 to AUDIO_SAMPLES_PER_USB_FRAME allows this. #define CFG_TUD_AUDIO_ENABLE_EP_IN 1 -#define CFG_TUD_AUDIO_FUNC_1_EP_IN_SZ ((AUDIO_FRAMES_PER_USB_FRAME + 1) * CFG_TUD_AUDIO_FUNC_1_N_BYTES_PER_SAMPLE_TX * CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_TX) +#define CFG_TUD_AUDIO_FUNC_1_EP_IN_SZ ((AUDIO_FRAMES_PER_USB_MICS_FRAME + 1) * CFG_TUD_AUDIO_FUNC_1_N_BYTES_PER_SAMPLE_TX * CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_TX) #define CFG_TUD_AUDIO_FUNC_1_EP_IN_SZ_MAX (CFG_TUD_AUDIO_FUNC_1_EP_IN_SZ) // Maximum EP IN size for all AS alternate settings used #define CFG_TUD_AUDIO_FUNC_1_EP_IN_SW_BUF_SZ CFG_TUD_AUDIO_FUNC_1_EP_IN_SZ #define CFG_TUD_AUDIO_ENABLE_EP_OUT 1 -#define CFG_TUD_AUDIO_FUNC_1_EP_OUT_SZ ((AUDIO_FRAMES_PER_USB_FRAME + 1) * CFG_TUD_AUDIO_FUNC_1_N_BYTES_PER_SAMPLE_RX * CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX) +#define CFG_TUD_AUDIO_FUNC_1_EP_OUT_SZ ((AUDIO_FRAMES_PER_USB_SPK_FRAME + 1) * CFG_TUD_AUDIO_FUNC_1_N_BYTES_PER_SAMPLE_RX * CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX) #define CFG_TUD_AUDIO_FUNC_1_EP_OUT_SZ_MAX (CFG_TUD_AUDIO_FUNC_1_EP_OUT_SZ + 2) // Maximum EP OUT size for all AS alternate settings used. Plus 2 for CRC #define CFG_TUD_AUDIO_FUNC_1_EP_OUT_SW_BUF_SZ CFG_TUD_AUDIO_FUNC_1_EP_OUT_SZ*3 #endif diff --git a/satellite-xmos-firmware/src/usb/usb_audio.c b/satellite-xmos-firmware/src/usb/usb_audio.c index 0c99e90..86d09e3 100644 --- a/satellite-xmos-firmware/src/usb/usb_audio.c +++ b/satellite-xmos-firmware/src/usb/usb_audio.c @@ -141,7 +141,8 @@ void usb_audio_send(rtos_intertile_t *intertile_ctx, for(int ch=0; ch> src_32_shift; + const int channel_shift = (ch == 2 || ch == 3) ? src_32_shift : 16 - 6; + usb_audio_in_frame[i][ch] = frame_buf_ptr[i+(appconfAUDIO_PIPELINE_FRAME_ADVANCE*ch)] >> channel_shift; } } } @@ -161,7 +162,7 @@ void usb_audio_recv(rtos_intertile_t *intertile_ctx, int32_t **frame_buffers, size_t num_chans) { - static samp_t usb_audio_out_frame[appconfAUDIO_PIPELINE_FRAME_ADVANCE][CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX]; + static samp_t usb_audio_out_frame[appconfAUDIO_SPK_PIPELINE_FRAME_ADVANCE][CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX]; size_t bytes_received; int32_t *frame_buf_ptr = (int32_t *) frame_buffers; @@ -170,7 +171,7 @@ void usb_audio_recv(rtos_intertile_t *intertile_ctx, #elif CFG_TUD_AUDIO_FUNC_1_N_BYTES_PER_SAMPLE_RX == 4 const int src_32_shift = 0; #endif - xassert(frame_count == appconfAUDIO_PIPELINE_FRAME_ADVANCE); + xassert(frame_count == appconfAUDIO_SPK_PIPELINE_FRAME_ADVANCE); bytes_received = rtos_intertile_rx_len( intertile_ctx, @@ -190,9 +191,9 @@ void usb_audio_recv(rtos_intertile_t *intertile_ctx, if (frame_buf_ptr != NULL) { for(int ch=0; ch=. */ @@ -630,10 +631,10 @@ bool tud_audio_tx_done_pre_load_cb(uint8_t rhport, * This buffer needs to be large enough to hold any size of transaction, * but if it's any bigger than twice nominal then we have bigger issues */ - samp_t stream_buffer_audio_frames[2 * AUDIO_FRAMES_PER_USB_FRAME / RATE_MULTIPLIER][CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_TX]; + samp_t stream_buffer_audio_frames[2 * AUDIO_FRAMES_PER_USB_MICS_FRAME / RATE_MULTIPLIER][CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_TX]; /* This buffer has to be large enough to contain any size transaction */ - samp_t usb_audio_frames[2 * RATE_MULTIPLIER * AUDIO_FRAMES_PER_USB_FRAME][CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_TX]; + samp_t usb_audio_frames[2 * RATE_MULTIPLIER * AUDIO_FRAMES_PER_USB_MICS_FRAME][CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_TX]; /* * Copying XUA_lite logic basically verbatim - if the host is streaming out, @@ -642,7 +643,7 @@ bool tud_audio_tx_done_pre_load_cb(uint8_t rhport, * This assumes (as with XUA_lite) that the host sends the same number of samples for each channel. * This also assumes that TX and RX rates are the same, which is an assumption made elsewhere. * This finally assumes that at nominal rate, - * AUDIO_FRAMES_PER_USB_FRAME == prev_n_bytes_received / (CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX * sizeof(samp_t)) + * AUDIO_FRAMES_PER_USB_MICS_FRAME == prev_n_bytes_received / (CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX * sizeof(samp_t)) */ if (host_streaming_out && (0 != prev_n_bytes_received)) { @@ -650,10 +651,11 @@ bool tud_audio_tx_done_pre_load_cb(uint8_t rhport, } else { - tx_size_bytes = sizeof(samp_t) * AUDIO_FRAMES_PER_USB_FRAME * CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_TX; + tx_size_bytes = sizeof(samp_t) * AUDIO_FRAMES_PER_USB_MICS_FRAME * CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_TX; } tx_size_frames = tx_size_bytes / (sizeof(samp_t) * CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_TX); + if (!mic_interface_open) { ready = 0; mic_interface_open = true; @@ -817,7 +819,7 @@ void usb_audio_init(rtos_intertile_t *intertile_ctx, * Note: Given the way that the USB callback notifies usb_audio_out_task, * the size of this buffer MUST NOT be greater than 2 VFE frames. */ - samples_from_host_stream_buf = xStreamBufferCreate(2 * sizeof(samp_t) * appconfAUDIO_PIPELINE_FRAME_ADVANCE * CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX, + samples_from_host_stream_buf = xStreamBufferCreate(2 * sizeof(samp_t) * appconfAUDIO_SPK_PIPELINE_FRAME_ADVANCE * CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX, 0); /* diff --git a/tools/ci/firmwares.txt b/tools/ci/firmwares.txt index f5f84eb..78b3784 100644 --- a/tools/ci/firmwares.txt +++ b/tools/ci/firmwares.txt @@ -1 +1,3 @@ -satellite1_fixed satellite1_firmware_fixed_delay No SATELLITE1 xmos_cmake_toolchain/xs3a.cmake \ No newline at end of file +satellite1_fixed satellite1_firmware_fixed_delay No SATELLITE1 xmos_cmake_toolchain/xs3a.cmake +usb_aec_ic_ns satellite1_usb_firmware_aec__vnr_ic__ns No SATELLITE1 xmos_cmake_toolchain/xs3a.cmake +usb_ic_ns satellite1_usb_firmware_vnr_ic__ns No SATELLITE1 xmos_cmake_toolchain/xs3a.cmake \ No newline at end of file From a4d9c18552a712f3f4d8086c80ca1d111f7f424e Mon Sep 17 00:00:00 2001 From: Mischa Siekmann Date: Wed, 12 Mar 2025 13:19:15 +0100 Subject: [PATCH 3/6] added orbit library, build usb_ns target only --- .../aec/AnalysisExplorerBoardFixedDelay.ipynb | 1194 ++++++++++++++++ .../aec/AnalysisSatellite1FixedDelay.ipynb | 1248 +++++++++++++++++ orbit/notebooks/VAD-Analysis.ipynb | 213 +++ orbit/orbit/__init__.py | 20 + orbit/orbit/audio/__init__.py | 0 orbit/orbit/audio/analysis.py | 27 + orbit/orbit/audio/sox.py | 18 + orbit/orbit/audio/utils.py | 164 +++ orbit/orbit/audio/vad_silero.py | 22 + orbit/orbit/builder/__init__.py | 0 orbit/orbit/builder/tracking.py | 79 ++ orbit/orbit/builder/xmos.py | 102 ++ orbit/orbit/tracking/__init__.py | 0 orbit/pyproject.toml | 4 + tests/test_hw_sat1_firmware/README.md | 0 tests/test_hw_sat1_firmware/__init__.py | 0 tests/test_hw_sat1_firmware/conftest.py | 67 + tests/test_hw_sat1_firmware/test_usb_dfu.py | 24 + tools/ci/firmwares.txt | 3 +- 19 files changed, 3183 insertions(+), 2 deletions(-) create mode 100644 batch_runs/aec/AnalysisExplorerBoardFixedDelay.ipynb create mode 100644 batch_runs/aec/AnalysisSatellite1FixedDelay.ipynb create mode 100644 orbit/notebooks/VAD-Analysis.ipynb create mode 100644 orbit/orbit/__init__.py create mode 100644 orbit/orbit/audio/__init__.py create mode 100644 orbit/orbit/audio/analysis.py create mode 100644 orbit/orbit/audio/sox.py create mode 100644 orbit/orbit/audio/utils.py create mode 100644 orbit/orbit/audio/vad_silero.py create mode 100644 orbit/orbit/builder/__init__.py create mode 100644 orbit/orbit/builder/tracking.py create mode 100644 orbit/orbit/builder/xmos.py create mode 100644 orbit/orbit/tracking/__init__.py create mode 100644 orbit/pyproject.toml create mode 100644 tests/test_hw_sat1_firmware/README.md create mode 100644 tests/test_hw_sat1_firmware/__init__.py create mode 100644 tests/test_hw_sat1_firmware/conftest.py create mode 100644 tests/test_hw_sat1_firmware/test_usb_dfu.py diff --git a/batch_runs/aec/AnalysisExplorerBoardFixedDelay.ipynb b/batch_runs/aec/AnalysisExplorerBoardFixedDelay.ipynb new file mode 100644 index 0000000..89bc725 --- /dev/null +++ b/batch_runs/aec/AnalysisExplorerBoardFixedDelay.ipynb @@ -0,0 +1,1194 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import sys\n", + "import os\n", + "PRJ_ROOT = \"/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3\"\n", + "sys.path.append(str(PRJ_ROOT))\n", + "from orbit.audio.utils import read_wav_wave\n", + "from orbit.audio.analysis import estimate_time_delay\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Explorer Board with (adapted) \"example_ffva_ua_fixed_delay\" Firmware" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [], + "source": [ + "RES_DIR = Path(\".\").parent / \"results\"/ \"test_delayConfigs_fdPipeline_explorer\"\n", + "RUNS_PER_CASE = 5\n", + "test_cases = dict([ (int(case_dir.name.split(\"_\")[-1]),case_dir) for case_dir in RES_DIR.iterdir() if case_dir.is_dir() ])" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Case 1 - Delay: -100\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-100/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-100/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-100/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-100/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-100/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + "Case 2 - Delay: -50\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-50/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-50/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-50/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-50/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-50/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + "Case 3 - Delay: -47\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-47/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-47/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-47/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-47/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-47/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + "Case 4 - Delay: -46\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-46/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-46/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-46/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-46/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-46/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + "Case 5 - Delay: -45\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-45/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-45/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-45/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-45/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-45/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + "Case 6 - Delay: -44\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-44/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-44/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-44/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-44/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-44/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + "Case 7 - Delay: -20\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-20/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-20/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-20/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-20/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-20/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + "Case 8 - Delay: -15\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-15/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-15/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-15/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-15/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-15/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + "Case 9 - Delay: -10\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-10/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-10/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-10/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-10/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-10/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + "Case 10 - Delay: -5\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-5/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-5/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-5/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-5/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-5/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + "Case 11 - Delay: -2\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-2/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-2/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-2/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-2/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-2/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + "Case 12 - Delay: -1\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-1/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-1/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-1/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-1/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-1/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + "Case 13 - Delay: 0\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_0/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_0/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_0/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_0/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_0/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + "Case 14 - Delay: 1\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_1/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_1/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_1/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_1/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_1/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + "Case 15 - Delay: 2\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_2/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_2/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_2/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_2/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_2/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + "Case 16 - Delay: 5\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_5/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_5/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_5/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_5/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_5/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + "Case 17 - Delay: 10\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_10/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_10/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_10/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_10/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_10/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + "Case 18 - Delay: 15\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_15/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_15/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_15/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_15/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_15/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + "Case 19 - Delay: 20\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_20/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_20/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_20/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_20/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_20/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + "Case 20 - Delay: 50\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_50/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_50/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_50/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_50/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_50/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", + "Case 21 - Delay: 100\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_100/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_100/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_100/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_100/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_100/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n" + ] + } + ], + "source": [ + "#load data into channels array [test_cases * run_per_test_case, channels, samples]\n", + "channels = np.empty((0,0,0))\n", + "for idx, dealy in enumerate(sorted(test_cases)):\n", + " print(f\"Case {idx+1} - Delay: {dealy}\")\n", + " case_dir = test_cases[dealy]\n", + " runs = sorted(case_dir.glob(\"*.wav\"))\n", + " for run in runs:\n", + " print(f\" Run {run.name}\")\n", + " fs, data = read_wav_wave( run.absolute().as_posix() )\n", + " if channels.size == 0:\n", + " channels = data[:,:, None].T\n", + " else:\n", + " if channels.shape[2] > data.shape[0]:\n", + " channels = channels[:, :, :data.shape[0]]\n", + " elif channels.shape[2] < data.shape[0]:\n", + " data = data[:channels.shape[2], :]\n", + " channels = np.vstack((channels, data[:,:,None].T))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Raw Microphone Channels (4 & 5) " + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "metadata": {}, + "outputs": [], + "source": [ + "mic_channel_mean_var = channels[:,[4,5],:].var(axis=2).mean(axis=1).reshape(len(test_cases), RUNS_PER_CASE)\n", + "channel4 = channels[:,4,:].reshape(len(test_cases), RUNS_PER_CASE, -1)\n", + "channel4_var = channel4.var(axis=2)\n", + "channel4_var /= mic_channel_mean_var\n", + "channel5 = channels[:,5,:].reshape(len(test_cases), RUNS_PER_CASE, -1)\n", + "channel5_var = channel5.var(axis=2)\n", + "channel5_var /= mic_channel_mean_var" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.boxplot( [channel4_var.flatten(), channel5_var.flatten()] );\n", + "plt.xticks([1,2], [\"Raw-Mic 1 (ch 4)\", \"Raw-Mic 2 (ch 5)\"]);\n", + "plt.axhline(1, color='black', linestyle='--');\n", + "plt.text(2.02, 1.015, \"$(\\sigma^2_{mic_1} + \\sigma^2_{mic_2})\\; / \\; 2$\", fontsize=10, color='black');\n", + "plt.title(\"Energie Distribution of Raw-Mic Signals \\n (Normalized by Mean Energie of Mic Signals per Run)\");\n", + "plt.ylabel(\"Normalized Energy\");\n", + "plt.grid(True);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Recordings of Mic1 are consistently about 60% higher than Mic2\n" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.6363645302697837" + ] + }, + "execution_count": 142, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean((channel4_var - channel5_var)/ channel5_var)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Processed Channel 1 (w/o Auto-Gain-Control)" + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "metadata": {}, + "outputs": [], + "source": [ + "#calc variances per run and normalize by mean variance of mic channels\n", + "channel1 = channels[:,1,:].reshape(len(test_cases), 5, -1)\n", + "channel1_var = channel1.var(axis=2)\n", + "channel1_var /= mic_channel_mean_var" + ] + }, + { + "cell_type": "code", + "execution_count": 180, + "metadata": {}, + "outputs": [], + "source": [ + "#normalize each run by the mean over the test case\n", + "channel1_var_mean = channel1_var.mean(axis=1)\n", + "channel1_var_run_norm = channel1_var / channel1_var_mean[:,None]" + ] + }, + { + "cell_type": "code", + "execution_count": 181, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.title(\"Distribution of Processed Signal Energies (w/o AGC)\\n (Normalized by Mean Energie of Mic Signals and over Test Case Runs)\");\n", + "plt.boxplot( channel1_var_run_norm );\n", + "plt.xticks(range(1, RUNS_PER_CASE+1), [f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", + "plt.xlabel(\"Runs per Test Case (configured fixed delay)\");\n", + "plt.ylabel(\"Normalized Energy\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- the first run of a test case (after flashing, and hence resetting of the XMOS) has consistently a higher energy than later runs\n", + "- => algorithm needs time (samples) to estimate the parameter of the transfer channel model" + ] + }, + { + "cell_type": "code", + "execution_count": 195, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,5))\n", + "plt.title(\"Processed Signal Energies (w/o AGC)\\n (Normalized by Mean Energie of Mic Signals)\")\n", + "plt.plot(channel1_var);\n", + "plt.grid(True)\n", + "plt.xticks( np.arange(len(test_cases)), map(str, sorted(test_cases.keys())) );\n", + "plt.legend([f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", + "plt.xlabel(\"Test Case (configured fixed delay)\");\n", + "plt.ylabel(\"Normalized Energy\");\n" + ] + }, + { + "cell_type": "code", + "execution_count": 183, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.006, 0.02)" + ] + }, + "execution_count": 183, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Take only Runs 2-5 for each test case\n", + "plt.figure(figsize=(10,5))\n", + "plt.title(\"Distribution of Energy of Runs 2-5 per Test Case (w/o AGC)\\n (Normalized by Mean Energie of Mic Signals)\");\n", + "plt.boxplot(channel1_var[:,1:].T);\n", + "plt.grid(True)\n", + "plt.xticks( np.arange(1, len(test_cases)+1), map(str, sorted(test_cases.keys())) );\n", + "plt.xlabel(\"Test Case (configured fixed delay)\");\n", + "plt.ylabel(\"Normalized Energy\");\n", + "plt.ylim(0.006,0.02)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Processed Channel 0 (with Auto-Gain-Control)" + ] + }, + { + "cell_type": "code", + "execution_count": 184, + "metadata": {}, + "outputs": [], + "source": [ + "#calc variances per run and normalize by mean variance of mic channels\n", + "channel0 = channels[:,0,:].reshape(len(test_cases), RUNS_PER_CASE, -1)\n", + "channel0_var = channel0.var(axis=2)\n", + "channel0_var /= mic_channel_mean_var" + ] + }, + { + "cell_type": "code", + "execution_count": 185, + "metadata": {}, + "outputs": [], + "source": [ + "#normalize each run by the mean over the test case\n", + "channel0_var_mean = channel0_var.mean(axis=1)\n", + "channel0_var_run_norm = channel0_var / channel0_var_mean[:,None]" + ] + }, + { + "cell_type": "code", + "execution_count": 186, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.title(\"Distribution of Processed Signal Energies (w. AGC)\\n (Normalized by Mean Energie of Mic Signals and over Test Case Runs)\");\n", + "plt.boxplot( channel0_var_run_norm );\n", + "plt.xticks(range(1, RUNS_PER_CASE+1), [f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", + "plt.xlabel(\"Runs per Test Case (configured fixed delay)\");\n", + "plt.ylabel(\"Normalized Energy\");" + ] + }, + { + "cell_type": "code", + "execution_count": 193, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,5))\n", + "plt.title(\"Processed Signal Energies (w. AGC)\\n (Normalized by Mean Energie of Mic Signals)\")\n", + "plt.plot(channel0_var);\n", + "plt.grid(True)\n", + "plt.xticks( np.arange(len(test_cases)), map(str, sorted(test_cases.keys())) );\n", + "plt.legend([f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", + "plt.xlabel(\"Test Case (configured fixed delay)\");\n", + "plt.ylabel(\"Normalized Energy\");" + ] + }, + { + "cell_type": "code", + "execution_count": 191, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(500.0, 5000.0)" + ] + }, + "execution_count": 191, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Take only Runs 2-5 for each test case\n", + "plt.figure(figsize=(10,5))\n", + "plt.title(\"Distribution of Energy of Runs 2-5 per Test Case (w. AGC)\\n (Normalized by Mean Energie of Mic Signals)\");\n", + "plt.boxplot(channel0_var[:,1:].T);\n", + "plt.grid(True)\n", + "plt.xticks( np.arange(1, len(test_cases)+1), map(str, sorted(test_cases.keys())) );\n", + "plt.xlabel(\"Test Case (configured fixed delay)\");\n", + "plt.ylabel(\"Normalized Energy\");\n", + "plt.ylim(500,5000)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculated Delay between Raw Mics and Reference Signals by Maximizing the Cross-Correlation\n", + "##### Example for Run 2 of Test-Case 0" + ] + }, + { + "cell_type": "code", + "execution_count": 196, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "audio_data = channels[1,:,:].T\n", + "fs=16000\n", + "channel_names = [\n", + " \"PROC 0\",\n", + " \"RPOC 1\",\n", + " \"REF 0\",\n", + " \"REF 1\",\n", + " \"MIC 0\",\n", + " \"MIC 1\"\n", + "]\n", + "combinations = ((2,3),(4,5),(2,4),(2,5),(3,4),(3,5))\n", + "fig, axes = plt.subplots(3, 2, figsize=(12, 12), sharex=True)\n", + "axes = axes.flatten()\n", + "for i, comb in enumerate(combinations):\n", + " chirp_signal = audio_data[:,comb[0]] / np.max(audio_data[:,comb[0]])\n", + " mic_signal = audio_data[:,comb[1]] / np.max(audio_data[:,comb[1]])\n", + " # Estimate the delay\n", + " estimated_delay_sec, correlation = estimate_time_delay(chirp_signal, mic_signal, fs)\n", + " # Plot the cross-correlation\n", + " lags = np.arange(-len(chirp_signal)+ 1, len(chirp_signal)) / fs\n", + "\n", + " axes[i].plot(lags * 1000, correlation)\n", + " axes[i].axvline(x=estimated_delay_sec * 1000, color='r', linestyle='--', label=f\"Estimated Delay: {estimated_delay_sec * 1000:.2f} ms\")\n", + " axes[i].set_title(f\"CC({channel_names[comb[0]]},{channel_names[comb[1]]}) {estimated_delay_sec * 1000:.2f} ms\")\n", + " axes[i].set_xlabel(\"Time Lag (ms)\")\n", + " axes[i].set_ylabel(\"Correlation\")\n", + " axes[i].set_xlim((-80,80))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Does the measured delay depend on the configured fixed-delay?\n", + "\n", + "Answer: No" + ] + }, + { + "cell_type": "code", + "execution_count": 205, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimated delay for case 0 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", + "Estimated delay for case 1 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", + "Estimated delay for case 2 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", + "Estimated delay for case 3 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", + "Estimated delay for case 4 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", + "Estimated delay for case 5 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", + "Estimated delay for case 6 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", + "Estimated delay for case 7 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", + "Estimated delay for case 8 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", + "Estimated delay for case 9 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", + "Estimated delay for case 10 is [0.0468125, 0.0468125, 0.0468125, 0.046875]\n", + "Estimated delay for case 11 is [0.0468125, 0.0468125, 0.0468125, 0.0469375]\n", + "Estimated delay for case 12 is [0.0468125, 0.0468125, 0.0468125, 0.0469375]\n", + "Estimated delay for case 13 is [0.0468125, 0.0468125, 0.0468125, 0.0469375]\n", + "Estimated delay for case 14 is [0.0468125, 0.0468125, 0.0468125, 0.0469375]\n", + "Estimated delay for case 15 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", + "Estimated delay for case 16 is [0.0464375, 0.0464375, 0.0464375, 0.0465625]\n", + "Estimated delay for case 17 is [0.0464375, 0.0464375, 0.0464375, 0.0465625]\n", + "Estimated delay for case 18 is [0.0464375, 0.0464375, 0.0464375, 0.0465625]\n", + "Estimated delay for case 19 is [0.0464375, 0.0464375, 0.0464375, 0.0465625]\n", + "Estimated delay for case 20 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 21 is [0.046625, 0.046625, 0.046625, 0.04675]\n", + "Estimated delay for case 22 is [0.046625, 0.046625, 0.046625, 0.04675]\n", + "Estimated delay for case 23 is [0.046625, 0.046625, 0.046625, 0.04675]\n", + "Estimated delay for case 24 is [0.046625, 0.046625, 0.046625, 0.04675]\n", + "Estimated delay for case 25 is [0.0463125, 0.0463125, 0.0463125, 0.046375]\n", + "Estimated delay for case 26 is [0.0463125, 0.0463125, 0.0463125, 0.0464375]\n", + "Estimated delay for case 27 is [0.0463125, 0.0463125, 0.0463125, 0.0464375]\n", + "Estimated delay for case 28 is [0.0463125, 0.0463125, 0.0463125, 0.0464375]\n", + "Estimated delay for case 29 is [0.0463125, 0.0463125, 0.0463125, 0.0464375]\n", + "Estimated delay for case 30 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 31 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 32 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 33 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 34 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 35 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 36 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 37 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 38 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 39 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 40 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", + "Estimated delay for case 41 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", + "Estimated delay for case 42 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", + "Estimated delay for case 43 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", + "Estimated delay for case 44 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", + "Estimated delay for case 45 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", + "Estimated delay for case 46 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", + "Estimated delay for case 47 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", + "Estimated delay for case 48 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", + "Estimated delay for case 49 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", + "Estimated delay for case 50 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", + "Estimated delay for case 51 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", + "Estimated delay for case 52 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", + "Estimated delay for case 53 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", + "Estimated delay for case 54 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", + "Estimated delay for case 55 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 56 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 57 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 58 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 59 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 60 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", + "Estimated delay for case 61 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", + "Estimated delay for case 62 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", + "Estimated delay for case 63 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", + "Estimated delay for case 64 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", + "Estimated delay for case 65 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 66 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 67 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 68 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 69 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 70 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 71 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 72 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 73 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 74 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", + "Estimated delay for case 75 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", + "Estimated delay for case 76 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", + "Estimated delay for case 77 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", + "Estimated delay for case 78 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", + "Estimated delay for case 79 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", + "Estimated delay for case 80 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", + "Estimated delay for case 81 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", + "Estimated delay for case 82 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", + "Estimated delay for case 83 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", + "Estimated delay for case 84 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", + "Estimated delay for case 85 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", + "Estimated delay for case 86 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", + "Estimated delay for case 87 is [0.04675, 0.04675, 0.04675, 0.0468125]\n", + "Estimated delay for case 88 is [0.04675, 0.04675, 0.04675, 0.0468125]\n", + "Estimated delay for case 89 is [0.04675, 0.04675, 0.04675, 0.0468125]\n", + "Estimated delay for case 90 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", + "Estimated delay for case 91 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", + "Estimated delay for case 92 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", + "Estimated delay for case 93 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", + "Estimated delay for case 94 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", + "Estimated delay for case 95 is [0.0466875, 0.0466875, 0.0466875, 0.04675]\n", + "Estimated delay for case 96 is [0.0469375, 0.0469375, 0.0469375, 0.047]\n", + "Estimated delay for case 97 is [0.0469375, 0.0469375, 0.0469375, 0.047]\n", + "Estimated delay for case 98 is [0.0469375, 0.0469375, 0.0469375, 0.047]\n", + "Estimated delay for case 99 is [0.0469375, 0.0469375, 0.0469375, 0.047]\n", + "Estimated delay for case 100 is [0.046625, 0.046625, 0.046625, 0.04675]\n", + "Estimated delay for case 101 is [0.0468125, 0.0468125, 0.0468125, 0.046875]\n", + "Estimated delay for case 102 is [0.0468125, 0.0468125, 0.0468125, 0.046875]\n", + "Estimated delay for case 103 is [0.046875, 0.046875, 0.046875, 0.0469375]\n", + "Estimated delay for case 104 is [0.046875, 0.046875, 0.046875, 0.0469375]\n" + ] + } + ], + "source": [ + "normed = channels / np.max(channels,axis=2)[:,:,None]\n", + "est_delays = []\n", + "for idx in range(channels.shape[0]):\n", + " this_delays = []\n", + " this_delays.append(estimate_time_delay(normed[idx,2,:], normed[idx,4,:], 16000)[0])\n", + " this_delays.append(estimate_time_delay(normed[idx,2,:], normed[idx,4,:], 16000)[0])\n", + " this_delays.append(estimate_time_delay(normed[idx,3,:], normed[idx,4,:], 16000)[0])\n", + " this_delays.append(estimate_time_delay(normed[idx,3,:], normed[idx,5,:], 16000)[0])\n", + " #this_delays.append(estimate_time_delay(normed[idx,4,:], normed[idx,5,:], 16000)[0])\n", + " est_delays.append(this_delays)\n", + " print(f\"Estimated delay for case {idx} is {est_delays[idx]}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 210, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(46.2, 47.1)" + ] + }, + "execution_count": 210, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.title(\"Variation of Estimated Delays over all Test Cases and Runs\")\n", + "plt.boxplot(np.array(est_delays)*1000);\n", + "plt.ylabel(\"Estimated Delay (ms)\");\n", + "plt.xticks(range(1,5), [\"(REF0, MIC0)\", \"(REF0, MIC1)\", \"(REF1, MIC0)\", \"(REF1, MIC1)\"]);\n", + "plt.ylim(46.2,47.1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/batch_runs/aec/AnalysisSatellite1FixedDelay.ipynb b/batch_runs/aec/AnalysisSatellite1FixedDelay.ipynb new file mode 100644 index 0000000..e45771c --- /dev/null +++ b/batch_runs/aec/AnalysisSatellite1FixedDelay.ipynb @@ -0,0 +1,1248 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import sys\n", + "import os\n", + "PRJ_ROOT = \"/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3\"\n", + "sys.path.append(str(PRJ_ROOT))\n", + "from orbit.audio.utils import read_wav_wave\n", + "from orbit.audio.analysis import estimate_time_delay\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Satellite1 with \"nexus_demo_test\" Firmware" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "RES_DIR = Path(\".\").parent / \"results\"/ \"test_delayConfigs_fdPipeline_Sat1\"\n", + "RUNS_PER_CASE = 5\n", + "test_cases = dict([ (int(case_dir.name.split(\"_\")[-1]),case_dir) for case_dir in RES_DIR.iterdir() if case_dir.is_dir() ])" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Case 1 - Delay: -100\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-100/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-100/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-100/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-100/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-100/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + "Case 2 - Delay: -50\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-50/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-50/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-50/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-50/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-50/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + "Case 3 - Delay: -20\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-20/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-20/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-20/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-20/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-20/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + "Case 4 - Delay: -15\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-15/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-15/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-15/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-15/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-15/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + "Case 5 - Delay: -10\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-10/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-10/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-10/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-10/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-10/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + "Case 6 - Delay: -5\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-5/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-5/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-5/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-5/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-5/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + "Case 7 - Delay: -2\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-2/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-2/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-2/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-2/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-2/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + "Case 8 - Delay: -1\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-1/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-1/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-1/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-1/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-1/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + "Case 9 - Delay: 0\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_0/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_0/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_0/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_0/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_0/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + "Case 10 - Delay: 1\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_1/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_1/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_1/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_1/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_1/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + "Case 11 - Delay: 2\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_2/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_2/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_2/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_2/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_2/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + "Case 12 - Delay: 5\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_5/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_5/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_5/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_5/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_5/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + "Case 13 - Delay: 10\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_10/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_10/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_10/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_10/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_10/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + "Case 14 - Delay: 15\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_15/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_15/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_15/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_15/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_15/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + "Case 15 - Delay: 20\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_20/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_20/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_20/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_20/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_20/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + "Case 16 - Delay: 50\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_50/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_50/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_50/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_50/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_50/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + "Case 17 - Delay: 100\n", + " Run test_r0.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_100/test_r0.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r1.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_100/test_r1.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", + " Run test_r2.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_100/test_r2.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r3.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_100/test_r3.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", + " Run test_r4.wav\n", + "\n", + "\n", + "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_100/test_r4.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n" + ] + } + ], + "source": [ + "#load data into channels array [test_cases * run_per_test_case, channels, samples]\n", + "channels = np.empty((0,0,0))\n", + "for idx, dealy in enumerate(sorted(test_cases)):\n", + " print(f\"Case {idx+1} - Delay: {dealy}\")\n", + " case_dir = test_cases[dealy]\n", + " runs = sorted(case_dir.glob(\"*.wav\"))\n", + " for run in runs:\n", + " print(f\" Run {run.name}\")\n", + " fs, data = read_wav_wave( run.absolute().as_posix() )\n", + " if channels.size == 0:\n", + " channels = data[:,:, None].T\n", + " else:\n", + " if channels.shape[2] > data.shape[0]:\n", + " channels = channels[:, :, :data.shape[0]]\n", + " elif channels.shape[2] < data.shape[0]:\n", + " data = data[:channels.shape[2], :]\n", + " channels = np.vstack((channels, data[:,:,None].T))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Raw Microphone Channels (4 & 5) " + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "mic_channel_mean_var = channels[:,[4,5],:].var(axis=2).mean(axis=1).reshape(len(test_cases), RUNS_PER_CASE)\n", + "channel4 = channels[:,4,:].reshape(len(test_cases), RUNS_PER_CASE, -1)\n", + "channel4_var = channel4.var(axis=2)\n", + "channel4_var /= mic_channel_mean_var\n", + "channel5 = channels[:,5,:].reshape(len(test_cases), RUNS_PER_CASE, -1)\n", + "channel5_var = channel5.var(axis=2)\n", + "channel5_var /= mic_channel_mean_var" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.boxplot( [channel4_var.flatten(), channel5_var.flatten()] );\n", + "plt.xticks([1,2], [\"Raw-Mic 1 (ch 4)\", \"Raw-Mic 2 (ch 5)\"]);\n", + "plt.axhline(1, color='black', linestyle='--');\n", + "plt.text(2.02, 1.015, \"$(\\sigma^2_{mic_1} + \\sigma^2_{mic_2})\\; / \\; 2$\", fontsize=10, color='black');\n", + "plt.title(\"Energie Distribution of Raw-Mic Signals \\n (Normalized by Mean Energie of Mic Signals per Run)\");\n", + "plt.ylabel(\"Normalized Energy\");\n", + "plt.grid(True);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Recordings of Mic2 are consistently about 10% higher than Mic1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.12180081843998401" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean((channel5_var - channel4_var/ channel4_var))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Processed Channel 1 (w/o Auto-Gain-Control)" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "#calc variances per run and normalize by mean variance of mic channels\n", + "channel1 = channels[:,1,:].reshape(len(test_cases), 5, -1)\n", + "channel1_var = channel1.var(axis=2)\n", + "channel1_var /= mic_channel_mean_var" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [], + "source": [ + "#normalize each run by the mean over the test case\n", + "channel1_var_mean = channel1_var.mean(axis=1)\n", + "channel1_var_run_norm = channel1_var / channel1_var_mean[:,None]" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.title(\"Distribution of Processed Signal Energies (w/o AGC)\\n (Normalized by Mean Energie of Mic Signals and over Test Case Runs)\");\n", + "plt.boxplot( channel1_var_run_norm );\n", + "plt.xticks(range(1, RUNS_PER_CASE+1), [f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", + "plt.xlabel(\"Runs per Test Case (configured fixed delay)\");\n", + "plt.ylabel(\"Normalized Energy\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- the first run of a test case (after flashing, and hence resetting of the XMOS) has consistently a higher energy than later runs\n", + "- => algorithm needs time (samples) to estimate the parameter of the transfer channel model" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,5))\n", + "plt.title(\"Processed Signal Energies (w/o AGC)\\n (Normalized by Mean Energie of Mic Signals)\")\n", + "plt.plot(channel1_var);\n", + "plt.grid(True)\n", + "plt.xticks( np.arange(len(test_cases)), map(str, sorted(test_cases.keys())) );\n", + "plt.legend([f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", + "plt.xlabel(\"Test Case (configured fixed delay)\");\n", + "plt.ylabel(\"Normalized Energy\");\n" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.001, 0.004)" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Take only Runs 2-5 for each test case\n", + "plt.figure(figsize=(10,5))\n", + "plt.title(\"Distribution of Energy of Runs 2-5 per Test Case (w/o AGC)\\n (Normalized by Mean Energie of Mic Signals)\");\n", + "plt.boxplot(channel1_var[:,1:].T);\n", + "plt.grid(True)\n", + "plt.xticks( np.arange(1, len(test_cases)+1), map(str, sorted(test_cases.keys())) );\n", + "plt.xlabel(\"Test Case (configured fixed delay)\");\n", + "plt.ylabel(\"Normalized Energy\");\n", + "plt.ylim(0.001,0.004)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Processed Channel 0 (with Auto-Gain-Control)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "#calc variances per run and normalize by mean variance of mic channels\n", + "channel0 = channels[:,0,:].reshape(len(test_cases), RUNS_PER_CASE, -1)\n", + "channel0_var = channel0.var(axis=2)\n", + "channel0_var /= mic_channel_mean_var" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [], + "source": [ + "#normalize each run by the mean over the test case\n", + "channel0_var_mean = channel0_var.mean(axis=1)\n", + "channel0_var_run_norm = channel0_var / channel0_var_mean[:,None]" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.title(\"Distribution of Processed Signal Energies (w. AGC)\\n (Normalized by Mean Energie of Mic Signals and over Test Case Runs)\");\n", + "plt.boxplot( channel0_var_run_norm );\n", + "plt.xticks(range(1, RUNS_PER_CASE+1), [f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", + "plt.xlabel(\"Runs per Test Case (configured fixed delay)\");\n", + "plt.ylabel(\"Normalized Energy\");" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,5))\n", + "plt.title(\"Processed Signal Energies (w. AGC)\\n (Normalized by Mean Energie of Mic Signals)\")\n", + "plt.plot(channel0_var);\n", + "plt.grid(True)\n", + "plt.xticks( np.arange(len(test_cases)), map(str, sorted(test_cases.keys())) );\n", + "plt.legend([f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", + "plt.xlabel(\"Test Case (configured fixed delay)\");\n", + "plt.ylabel(\"Normalized Energy\");" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 2000.0)" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Take only Runs 2-5 for each test case\n", + "plt.figure(figsize=(10,5))\n", + "plt.title(\"Distribution of Energy of Runs 2-5 per Test Case (w. AGC)\\n (Normalized by Mean Energie of Mic Signals)\");\n", + "plt.boxplot(channel0_var[:,1:].T);\n", + "plt.grid(True)\n", + "plt.xticks( np.arange(1, len(test_cases)+1), map(str, sorted(test_cases.keys())) );\n", + "plt.xlabel(\"Test Case (configured fixed delay)\");\n", + "plt.ylabel(\"Normalized Energy\");\n", + "plt.ylim(0,2000)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculated Delay between Raw Mics and Reference Signals by Maximizing the Cross-Correlation\n", + "##### Example for Run 2 of Test-Case 0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "audio_data = channels[15,:,:].T\n", + "fs=16000\n", + "channel_names = [\n", + " \"PROC 0\", #AEC + IC + NS + AGC\n", + " \"RPOC 1\", #AEC only\n", + " \"REF 0\",\n", + " \"REF 1\",\n", + " \"MIC 0\",\n", + " \"MIC 1\"\n", + "]\n", + "combinations = ((2,3),(4,5),(2,4),(2,5),(3,4),(3,5))\n", + "fig, axes = plt.subplots(3, 2, figsize=(12, 12), sharex=True)\n", + "axes = axes.flatten()\n", + "for i, comb in enumerate(combinations):\n", + " chirp_signal = audio_data[:,comb[0]] / np.max(audio_data[:,comb[0]])\n", + " mic_signal = audio_data[:,comb[1]] / np.max(audio_data[:,comb[1]])\n", + " # Estimate the delay\n", + " estimated_delay_sec, correlation = estimate_time_delay(chirp_signal, mic_signal, fs)\n", + " # Plot the cross-correlation\n", + " lags = np.arange(-len(chirp_signal)+ 1, len(chirp_signal)) / fs\n", + "\n", + " axes[i].plot(lags * 1000, correlation)\n", + " axes[i].axvline(x=estimated_delay_sec * 1000, color='r', linestyle='--', label=f\"Estimated Delay: {estimated_delay_sec * 1000:.2f} ms\")\n", + " axes[i].set_title(f\"CC({channel_names[comb[0]]},{channel_names[comb[1]]}) {estimated_delay_sec * 1000:.2f} ms\")\n", + " axes[i].set_xlabel(\"Time Lag (ms)\")\n", + " axes[i].set_ylabel(\"Correlation\")\n", + " axes[i].set_xlim((-80,80))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Does the measured delay depend on the configured fixed-delay?\n", + "\n", + "Answer: Yes\n", + "\n", + "Why is this different to the EXPLORER tests?" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimated delay for case 0 is [-0.0724375, -0.0724375, -0.0724375, -0.072625]\n", + "Estimated delay for case 1 is [-0.0724375, -0.0724375, -0.0724375, -0.072625]\n", + "Estimated delay for case 2 is [-0.0724375, -0.0724375, -0.0724375, -0.072625]\n", + "Estimated delay for case 3 is [-0.0724375, -0.0724375, -0.0724375, -0.072625]\n", + "Estimated delay for case 4 is [-0.0724375, -0.0724375, -0.0724375, -0.072625]\n", + "Estimated delay for case 5 is [-0.029125, -0.029125, -0.029125, -0.0293125]\n", + "Estimated delay for case 6 is [-0.029125, -0.029125, -0.029125, -0.0293125]\n", + "Estimated delay for case 7 is [-0.0293125, -0.0293125, -0.0293125, -0.0295]\n", + "Estimated delay for case 8 is [-0.0293125, -0.0293125, -0.0293125, -0.0295]\n", + "Estimated delay for case 9 is [-0.0293125, -0.0293125, -0.0293125, -0.0295]\n", + "Estimated delay for case 10 is [-0.0026875, -0.0026875, -0.0026875, -0.002875]\n", + "Estimated delay for case 11 is [-0.0026875, -0.0026875, -0.0026875, -0.002875]\n", + "Estimated delay for case 12 is [-0.0026875, -0.0026875, -0.0026875, -0.002875]\n", + "Estimated delay for case 13 is [-0.0026875, -0.0026875, -0.0026875, -0.002875]\n", + "Estimated delay for case 14 is [-0.0026875, -0.0026875, -0.0026875, -0.002875]\n", + "Estimated delay for case 15 is [0.0025625, 0.0025625, 0.0025625, 0.002375]\n", + "Estimated delay for case 16 is [0.0025625, 0.0025625, 0.0025625, 0.002375]\n", + "Estimated delay for case 17 is [0.0025625, 0.0025625, 0.0025625, 0.002375]\n", + "Estimated delay for case 18 is [0.0025625, 0.0025625, 0.0025625, 0.002375]\n", + "Estimated delay for case 19 is [0.0025625, 0.0025625, 0.0025625, 0.002375]\n", + "Estimated delay for case 20 is [0.0121875, 0.0121875, 0.0121875, 0.012]\n", + "Estimated delay for case 21 is [0.0121875, 0.0121875, 0.0121875, 0.012]\n", + "Estimated delay for case 22 is [0.0121875, 0.0121875, 0.0121875, 0.012]\n", + "Estimated delay for case 23 is [0.0121875, 0.0121875, 0.0121875, 0.012]\n", + "Estimated delay for case 24 is [0.0121875, 0.0121875, 0.0121875, 0.012]\n", + "Estimated delay for case 25 is [0.01775, 0.01775, 0.01775, 0.0175625]\n", + "Estimated delay for case 26 is [0.0178125, 0.0178125, 0.0178125, 0.0175625]\n", + "Estimated delay for case 27 is [0.0178125, 0.0178125, 0.0178125, 0.0175625]\n", + "Estimated delay for case 28 is [0.0178125, 0.0178125, 0.0178125, 0.0175625]\n", + "Estimated delay for case 29 is [0.0178125, 0.0178125, 0.0178125, 0.0175625]\n", + "Estimated delay for case 30 is [0.00975, 0.00975, 0.00975, 0.0095625]\n", + "Estimated delay for case 31 is [0.00975, 0.00975, 0.00975, 0.0095625]\n", + "Estimated delay for case 32 is [0.00975, 0.00975, 0.00975, 0.0095625]\n", + "Estimated delay for case 33 is [0.00975, 0.00975, 0.00975, 0.0095625]\n", + "Estimated delay for case 34 is [0.00975, 0.00975, 0.00975, 0.0095625]\n", + "Estimated delay for case 35 is [0.0044375, 0.0044375, 0.0044375, 0.00425]\n", + "Estimated delay for case 36 is [0.0044375, 0.0044375, 0.0044375, 0.00425]\n", + "Estimated delay for case 37 is [0.0044375, 0.0044375, 0.0044375, 0.00425]\n", + "Estimated delay for case 38 is [0.0044375, 0.0044375, 0.0044375, 0.00425]\n", + "Estimated delay for case 39 is [0.0044375, 0.0044375, 0.0044375, 0.00425]\n", + "Estimated delay for case 40 is [0.009125, 0.009125, 0.009125, 0.008875]\n", + "Estimated delay for case 41 is [0.0091875, 0.0091875, 0.0091875, 0.0089375]\n", + "Estimated delay for case 42 is [0.0091875, 0.0091875, 0.0091875, 0.0089375]\n", + "Estimated delay for case 43 is [0.0091875, 0.0091875, 0.0091875, 0.0089375]\n", + "Estimated delay for case 44 is [0.0091875, 0.0091875, 0.0091875, 0.0089375]\n", + "Estimated delay for case 45 is [0.0071875, 0.0071875, 0.0071875, 0.007]\n", + "Estimated delay for case 46 is [0.0071875, 0.0071875, 0.0071875, 0.007]\n", + "Estimated delay for case 47 is [0.0071875, 0.0071875, 0.0071875, 0.007]\n", + "Estimated delay for case 48 is [0.0071875, 0.0071875, 0.0071875, 0.007]\n", + "Estimated delay for case 49 is [0.0071875, 0.0071875, 0.0071875, 0.007]\n", + "Estimated delay for case 50 is [0.0059375, 0.0059375, 0.0059375, 0.00575]\n", + "Estimated delay for case 51 is [0.0059375, 0.0059375, 0.0059375, 0.00575]\n", + "Estimated delay for case 52 is [0.0059375, 0.0059375, 0.0059375, 0.00575]\n", + "Estimated delay for case 53 is [0.0059375, 0.0059375, 0.0059375, 0.00575]\n", + "Estimated delay for case 54 is [0.0059375, 0.0059375, 0.0059375, 0.00575]\n", + "Estimated delay for case 55 is [0.007375, 0.007375, 0.007375, 0.0071875]\n", + "Estimated delay for case 56 is [0.0074375, 0.0074375, 0.0074375, 0.0071875]\n", + "Estimated delay for case 57 is [0.0074375, 0.0074375, 0.0074375, 0.0071875]\n", + "Estimated delay for case 58 is [0.0074375, 0.0074375, 0.0074375, 0.0071875]\n", + "Estimated delay for case 59 is [0.0074375, 0.0074375, 0.0074375, 0.0071875]\n", + "Estimated delay for case 60 is [0.0051875, 0.0051875, 0.0051875, 0.0049375]\n", + "Estimated delay for case 61 is [0.0051875, 0.0051875, 0.0051875, 0.0049375]\n", + "Estimated delay for case 62 is [0.0051875, 0.0051875, 0.0051875, 0.0049375]\n", + "Estimated delay for case 63 is [0.0051875, 0.0051875, 0.0051875, 0.0049375]\n", + "Estimated delay for case 64 is [0.0051875, 0.0051875, 0.0051875, 0.005]\n", + "Estimated delay for case 65 is [0.0096875, 0.0096875, 0.0096875, 0.0095]\n", + "Estimated delay for case 66 is [0.0096875, 0.0096875, 0.0096875, 0.0095]\n", + "Estimated delay for case 67 is [0.0096875, 0.0096875, 0.0096875, 0.0095]\n", + "Estimated delay for case 68 is [0.0096875, 0.0096875, 0.0096875, 0.0095]\n", + "Estimated delay for case 69 is [0.0096875, 0.0096875, 0.0096875, 0.0095]\n", + "Estimated delay for case 70 is [0.015375, 0.015375, 0.015375, 0.015125]\n", + "Estimated delay for case 71 is [0.015375, 0.015375, 0.015375, 0.015125]\n", + "Estimated delay for case 72 is [0.015375, 0.015375, 0.015375, 0.015125]\n", + "Estimated delay for case 73 is [0.015375, 0.015375, 0.015375, 0.015125]\n", + "Estimated delay for case 74 is [0.015375, 0.015375, 0.015375, 0.0151875]\n", + "Estimated delay for case 75 is [0.0095, 0.0095, 0.0095, 0.0093125]\n", + "Estimated delay for case 76 is [0.0095, 0.0095, 0.0095, 0.0093125]\n", + "Estimated delay for case 77 is [0.0095, 0.0095, 0.0095, 0.0093125]\n", + "Estimated delay for case 78 is [0.0095, 0.0095, 0.0095, 0.0093125]\n", + "Estimated delay for case 79 is [0.0095, 0.0095, 0.0095, 0.0093125]\n", + "Estimated delay for case 80 is [0.01325, 0.01325, 0.01325, 0.0130625]\n", + "Estimated delay for case 81 is [0.01325, 0.01325, 0.01325, 0.0130625]\n", + "Estimated delay for case 82 is [0.01325, 0.01325, 0.01325, 0.0130625]\n", + "Estimated delay for case 83 is [0.01325, 0.01325, 0.01325, 0.0130625]\n", + "Estimated delay for case 84 is [0.01325, 0.01325, 0.01325, 0.0130625]\n" + ] + } + ], + "source": [ + "normed = channels / np.max(channels,axis=2)[:,:,None]\n", + "est_delays = []\n", + "for idx in range(channels.shape[0]):\n", + " this_delays = []\n", + " this_delays.append(estimate_time_delay(normed[idx,2,:], normed[idx,4,:], 16000)[0])\n", + " this_delays.append(estimate_time_delay(normed[idx,2,:], normed[idx,4,:], 16000)[0])\n", + " this_delays.append(estimate_time_delay(normed[idx,3,:], normed[idx,4,:], 16000)[0])\n", + " this_delays.append(estimate_time_delay(normed[idx,3,:], normed[idx,5,:], 16000)[0])\n", + " #this_delays.append(estimate_time_delay(normed[idx,4,:], normed[idx,5,:], 16000)[0])\n", + " est_delays.append(this_delays)\n", + " print(f\"Estimated delay for case {idx} is {est_delays[idx]}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-10.0, 20.0)" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.title(\"Variation of Estimated Delays over all Test Cases and Runs\")\n", + "plt.boxplot(np.array(est_delays)*1000);\n", + "plt.ylabel(\"Estimated Delay (ms)\");\n", + "plt.xticks(range(1,5), [\"(REF0, MIC0)\", \"(REF0, MIC1)\", \"(REF1, MIC0)\", \"(REF1, MIC1)\"]);\n", + "plt.ylim(-10,20)" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,5))\n", + "plt.title(\"(REF0,MIC0) Estimated Delays\")\n", + "plt.boxplot(np.array(est_delays)[:,0].reshape(len(test_cases),-1).T*1000);\n", + "plt.grid(True)\n", + "plt.ylabel(\"Estimated Delay (ms)\");\n", + "plt.xticks( np.arange(1, len(test_cases)+1), map(str, sorted(test_cases.keys())) );\n", + "plt.xlabel(\"Test Case (configured fixed delay)\");" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-5.0, 20.0)" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,5))\n", + "plt.title(\"(REF0,MIC0) Estimated Delays\")\n", + "plt.boxplot(np.array(est_delays)[:,0].reshape(len(test_cases),-1).T*1000);\n", + "plt.grid(True)\n", + "plt.ylabel(\"Estimated Delay (ms)\");\n", + "plt.xticks( np.arange(1, len(test_cases)+1), map(str, sorted(test_cases.keys())) );\n", + "plt.xlabel(\"Test Case (configured fixed delay)\");\n", + "plt.ylim(-5,20)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Further Analysis of Test Case with 1ms fixed delay" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(0, -100),\n", + " (1, -50),\n", + " (2, -20),\n", + " (3, -15),\n", + " (4, -10),\n", + " (5, -5),\n", + " (6, -2),\n", + " (7, -1),\n", + " (8, 0),\n", + " (9, 1),\n", + " (10, 2),\n", + " (11, 5),\n", + " (12, 10),\n", + " (13, 15),\n", + " (14, 20),\n", + " (15, 50),\n", + " (16, 100)]" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(enumerate(sorted(test_cases)))" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Case 10 - Delay: 1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "TEST_CASE_IDX = 9\n", + "print(f\"Case {TEST_CASE_IDX+1} - Delay: {sorted(test_cases)[TEST_CASE_IDX]}\")\n", + "fs=16000\n", + "audio_data = channels[TEST_CASE_IDX*RUNS_PER_CASE+3,:].T\n", + "channel_names = [\n", + " \"PROC 0\",\n", + " \"RPOC 1\",\n", + " \"REF 0\",\n", + " \"REF 1\",\n", + " \"MIC 0\",\n", + " \"MIC 1\"\n", + "]\n", + "num_samples, num_channels = audio_data.shape if len(audio_data.shape) > 1 else (len(audio_data), 1)\n", + "\n", + "# Create time axis\n", + "time_axis = np.linspace(0, num_samples / fs, num=num_samples)\n", + "\n", + "# Limit to first 6 channels for plotting\n", + "num_channels_to_plot = min(num_channels, 6)\n", + "\n", + "# Create subplots\n", + "fig, axes = plt.subplots(num_channels_to_plot, 1, figsize=(12, 8), sharex=True)\n", + "fig.suptitle(f\"Waveform of chirp_record ({num_channels} Channels)\", fontsize=14)\n", + "\n", + "if num_channels_to_plot == 1:\n", + " axes = [axes] # Ensure axes is iterable for mono files\n", + "\n", + "# Plot each channel separately\n", + "for i in range(num_channels_to_plot):\n", + " axes[i].plot(time_axis, audio_data[:, i], label=f\"{channel_names[i]}\", color=f\"C{i}\")\n", + " axes[i].set_ylabel(\"Amplitude\")\n", + " axes[i].legend(loc=\"upper right\")\n", + " axes[i].grid(True)\n", + "\n", + "# Set common labels\n", + "axes[-1].set_xlabel(\"Time (seconds)\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/orbit/notebooks/VAD-Analysis.ipynb b/orbit/notebooks/VAD-Analysis.ipynb new file mode 100644 index 0000000..7db2735 --- /dev/null +++ b/orbit/notebooks/VAD-Analysis.ipynb @@ -0,0 +1,213 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from orbit.audio.utils import read_wav_wave\n", + "from silero_vad import load_silero_vad, get_speech_timestamps\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "SAMPLING_RATE=16000" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "model = load_silero_vad()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Reading '/Users/mischa/Projects/AEC/no_ref_record.wav/untitled.wav'...\n", + "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 214640\n" + ] + } + ], + "source": [ + "wav_file = \"/Users/mischa/Projects/AEC/no_ref_record.wav/untitled.wav\"\n", + "fs, samples = read_wav_wave(wav_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "audio_data = samples\n", + "channel_names = [\n", + " \"PROC 0\",\n", + " \"RPOC 1\",\n", + " \"REF 0\",\n", + " \"REF 1\",\n", + " \"MIC 0\",\n", + " \"MIC 1\"\n", + "]\n", + "num_samples, num_channels = audio_data.shape if len(audio_data.shape) > 1 else (len(audio_data), 1)\n", + "\n", + "# Create time axis\n", + "time_axis = np.linspace(0, num_samples / fs, num=num_samples)\n", + "\n", + "# Limit to first 6 channels for plotting\n", + "num_channels_to_plot = min(num_channels, 6)\n", + "\n", + "# Create subplots\n", + "fig, axes = plt.subplots(num_channels_to_plot, 1, figsize=(12, 8), sharex=True)\n", + "fig.suptitle(f\"Waveform of chirp_record ({num_channels} Channels)\", fontsize=14)\n", + "\n", + "if num_channels_to_plot == 1:\n", + " axes = [axes] # Ensure axes is iterable for mono files\n", + "\n", + "# Plot each channel separately\n", + "for i in range(num_channels_to_plot):\n", + " axes[i].plot(time_axis, audio_data[:, i], label=f\"{channel_names[i]}\", color=f\"C{i}\")\n", + " axes[i].set_ylabel(\"Amplitude\")\n", + " axes[i].legend(loc=\"upper right\")\n", + " axes[i].grid(True)\n", + "\n", + "# Set common labels\n", + "axes[-1].set_xlabel(\"Time (seconds)\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "min_speech_duration_ms: int (default - 250 milliseconds)\n", + " Final speech chunks shorter min_speech_duration_ms are thrown out\n", + "\n", + " max_speech_duration_s: int (default - inf)\n", + " Maximum duration of speech chunks in seconds\n", + " Chunks longer than max_speech_duration_s will be split at the timestamp of the last silence that lasts more than 100ms (if any), to prevent agressive cutting.\n", + " Otherwise, they will be split aggressively just before max_speech_duration_s.\n", + "\n", + " min_silence_duration_ms: int (default - 100 milliseconds)\n", + " In the end of each speech chunk wait for min_silence_duration_ms before separating it\n", + "\n", + " speech_pad_ms: int (default - 30 milliseconds)\n", + " Final speech chunks are padded by speech_pad_ms each side\n", + "\n", + "neg_threshold: float (default = threshold - 0.15)\n", + " Negative threshold (noise or exit threshold). If model's current state is SPEECH, values BELOW this value are considered as NON-SPEECH." + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "CHANNEL = 1\n", + "options= {\n", + " \"threshold\" : 0.5,\n", + " \"min_speech_duration_ms\" : 1000,\n", + " \"min_speech_duration_ms\" : 250,\n", + " \"max_speech_duration_s\" : float('inf'),\n", + " \"min_silence_duration_ms\" : 100,\n", + " \"speech_pad_ms\" : 30,\n", + " \"neg_threshold\" : None\n", + "}\n", + "\n", + "speech_timestamps = get_speech_timestamps( samples[:,CHANNEL], model, sampling_rate=SAMPLING_RATE, visualize_probs=True, return_seconds=True, **options)\n", + "plt.axhline( options[\"threshold\"], color=\"red\")\n", + "for region in speech_timestamps:\n", + " plt.axvspan(region[\"start\"], region[\"end\"] , color=\"red\", alpha=0.3, label=\"Highlighted Region\")\n", + "\n", + "curr_ax = plt.gca()\n", + "new_ax = plt.subplot(2,1,1)\n", + "curr_ax.set_position(new_ax.get_position())\n", + "new_ax.remove()\n", + "#plt.gcf().set_size_inches((16,16))\n", + "#fig = plt.figure(figsize=(12,4));\n", + "plt.subplot(2,1,2)\n", + "plt.plot(time_axis, audio_data[:, CHANNEL], label=f\"{channel_names[CHANNEL]}\", color=f\"C{CHANNEL}\")\n", + "plt.ylabel(\"Amplitude\")\n", + "plt.legend(loc=\"upper right\")\n", + "plt.xlim( curr_ax.get_xlim() )\n", + "plt.grid(True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/orbit/orbit/__init__.py b/orbit/orbit/__init__.py new file mode 100644 index 0000000..114a65e --- /dev/null +++ b/orbit/orbit/__init__.py @@ -0,0 +1,20 @@ +from pathlib import Path + +PROJ_ROOT = Path(__file__).parent.parent + +XTC_PATH="/Users/mischa/Projects/FutureProofHomes/XMOS_XTC_15.3.1" + +BOARD_USB_IDS = { + "Satellite1" : "20b1:4a05", + "Explorer" : "20b1:4001" +} + +BOARD_SND_CARD_NAMES = { + "Satellite1" : "SATELLITE1", + "Explorer" : "XCORE-VOICE" +} + +BOARD_XTAG_IDS = { + "Satellite1" : "W256H8UD", + "Explorer" : "4LG2K2A6" +} \ No newline at end of file diff --git a/orbit/orbit/audio/__init__.py b/orbit/orbit/audio/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/orbit/orbit/audio/analysis.py b/orbit/orbit/audio/analysis.py new file mode 100644 index 0000000..a231618 --- /dev/null +++ b/orbit/orbit/audio/analysis.py @@ -0,0 +1,27 @@ +from orbit.audio.utils import read_wav_wave +import numpy as np +from scipy.signal import correlate + +def calc_channel_variances( wav_file:str ) -> list[float]: + fs, audio_data = read_wav_wave(wav_file) + return audio_data.var(axis=0) + + +def estimate_time_delay(reference_signal:np.array, delayed_signal:np.array, fs=int) -> tuple[float, np.array]: + """ + Estimate time delay using cross-correlation. + + Parameters: + reference_signal (numpy array): Original signal. + delayed_signal (numpy array): Delayed version of the signal. + fs (int): Sampling rate in Hz. + + Returns: + estimated_delay_sec (float): Estimated delay in seconds. + correlation (numpy array): Cross-correlation of the two signals. + """ + correlation = correlate(delayed_signal, reference_signal, mode="full") + delay_samples = np.argmax(correlation) - len(reference_signal) + 1 + estimated_delay_sec = delay_samples / fs + + return estimated_delay_sec, correlation \ No newline at end of file diff --git a/orbit/orbit/audio/sox.py b/orbit/orbit/audio/sox.py new file mode 100644 index 0000000..6937349 --- /dev/null +++ b/orbit/orbit/audio/sox.py @@ -0,0 +1,18 @@ +import subprocess +import time + +def run_playback_and_record( play_file:str, out_file:str, device:str, timeout_s:int=90 ) -> None : + """Run playback and record in parallel.""" + print( f"Running playback and record for {play_file} on device {device} ..." ) + + cmd = f'sox -t coreaudio {device} --channels=6 --rate=16000 -b 16 --encoding=signed-integer --endian=little --no-dither -t wavpcm "{out_file}" &' + cmd += "SOX_PID=$!; " + cmd += f'sox -t wav "{play_file}" -t coreaudio {device}' + cmd += "&& kill $SOX_PID" + try: + subprocess.run(cmd, timeout=timeout_s, text=True, shell=True) + except subprocess.TimeoutExpired: + print(f'Timeout for {cmd} ({timeout_s}s) expired') + raise subprocess.TimeoutExpired + + time.sleep(2) diff --git a/orbit/orbit/audio/utils.py b/orbit/orbit/audio/utils.py new file mode 100644 index 0000000..670057c --- /dev/null +++ b/orbit/orbit/audio/utils.py @@ -0,0 +1,164 @@ +import pyaudio +import wave +import threading +import numpy as np + +def list_audio_devices(): + """Lists all available audio devices.""" + audio = pyaudio.PyAudio() + print("\nAvailable Audio Devices:\n") + for i in range(audio.get_device_count()): + device_info = audio.get_device_info_by_index(i) + print(f"ID {device_info['index']}: {device_info['name']} - " + f"Input Channels: {device_info['maxInputChannels']}, Output Channels: {device_info['maxOutputChannels']}") + audio.terminate() + +def get_audio_device_index(device_name:str) -> int: + """Returns the device index for a given device name.""" + audio = pyaudio.PyAudio() + di = None + for i in range(audio.get_device_count()): + device_info = audio.get_device_info_by_index(i) + if device_info['name'].startswith(device_name): + di = i + break + audio.terminate() + return di + + +def play_audio(playback_file, rate, chunk, output_device): + """Plays a WAV file using a separate thread.""" + wf = wave.open(playback_file, 'rb') + play_channels = wf.getnchannels() + play_rate = wf.getframerate() + + # Ensure playback rate matches file rate + if rate != play_rate: + print(f"⚠️ Warning: WAV file sample rate ({play_rate} Hz) differs from playback rate ({rate} Hz).") + + audio = pyaudio.PyAudio() + + # Open playback stream + play_stream = audio.open(format=pyaudio.paInt16, + channels=play_channels, + rate=rate, + output=True, + output_device_index=output_device, + frames_per_buffer=chunk) + + print(f"Playing '{playback_file}' ({play_channels} channels)...") + + while True: + data = wf.readframes(chunk) + if not data: + break + play_stream.write(data) + + # Cleanup + wf.close() + play_stream.stop_stream() + play_stream.close() + audio.terminate() + print("🔇 Playback finished.") + +def record_audio(output_file, channels, rate, chunk, duration, input_device): + """Records multi-channel audio in a separate thread.""" + + FORMAT = pyaudio.paInt16 # 16-bit PCM + audio = pyaudio.PyAudio() + + # Open recording stream + record_stream = audio.open(format=FORMAT, + channels=channels, + rate=rate, + input=True, + input_device_index=input_device, + frames_per_buffer=chunk) + + print(f"🎤 Recording {channels} channels at {rate} Hz for {duration} seconds...") + + frames = [] + for _ in range(0, int(rate / chunk * duration)): + data = record_stream.read(chunk, exception_on_overflow=False) + frames.append(data) + + # Cleanup + record_stream.stop_stream() + record_stream.close() + audio.terminate() + + # Save recorded audio + with wave.open(output_file, 'wb') as wf: + wf.setnchannels(channels) + wf.setsampwidth(audio.get_sample_size(FORMAT)) + wf.setframerate(rate) + wf.writeframes(b''.join(frames)) + + print(f"Recording complete! Saved as {output_file}") + + +class ThreadWithException(threading.Thread): + + def run(self): + self.exc = None # Store exception here + try: + print("Thread running...") + super().run() + except Exception as e: + self.exc = e # Store the exception + +def run_playback_and_record( play_file:str, out_device:int, rec_file:str, in_device:int, duration:int ): + # Create separate threads for playback and recording + play_thread = ThreadWithException(target=play_audio, args=(play_file, 16000, 1024, out_device)) + record_thread = ThreadWithException(target=record_audio, args=(rec_file, 6, 16000, 1024, duration, in_device)) + + # Start both threads + play_thread.start() + record_thread.start() + + # Wait for both to finish + play_thread.join() + record_thread.join() + if play_thread.exc: + print(f"Exception in thread: {play_thread.exc}") + raise play_thread.exc # Optionally re-raise it in the main thread + + if record_thread.exc: + print(f"Exception in thread: {record_thread.exc}") + raise record_thread.exc # Optionally re-raise it in the main thread + + print("🎵 Playback and recording completed.") + + +def read_wav_wave(filename:str) -> tuple[int, np.array]: + """ + Read a WAV file using the `wave` module and return its data as a NumPy array. + + Parameters: + filename (str): Path to the WAV file. + + Returns: + fs (int): Sampling rate in Hz. + audio_data (numpy array): Audio data with shape (Samples, Channels). + """ + with wave.open(filename, "rb") as wf: + num_channels = wf.getnchannels() + sample_width = wf.getsampwidth() + fs = wf.getframerate() + num_frames = wf.getnframes() + + print("\n") + print(f"Reading '{filename}'...") + print(f"Channels: {num_channels}, Sample Width: {sample_width} bytes, Sample Rate: {fs} Hz, Frames: {num_frames}") + + # Read raw audio data + raw_data = wf.readframes(num_frames) + + # Convert raw bytes to NumPy array + audio_data = np.frombuffer(raw_data, dtype=np.int16) # 16-bit PCM + + # Reshape if multichannel + if num_channels > 1: + audio_data = audio_data.reshape(-1, num_channels) + + return fs, audio_data \ No newline at end of file diff --git a/orbit/orbit/audio/vad_silero.py b/orbit/orbit/audio/vad_silero.py new file mode 100644 index 0000000..1f74bdb --- /dev/null +++ b/orbit/orbit/audio/vad_silero.py @@ -0,0 +1,22 @@ +import numpy as np +from silero_vad import load_silero_vad, get_speech_timestamps +from orbit.audio.utils import read_wav_wave + +def vad_silero(wav_file:str=None, channel:int=0, audio:np.array=None) -> list[dict]: + vad = load_silero_vad() + if wav_file: + fs, audio = read_wav_wave(wav_file) + if fs != 16000: + raise ValueError("Only 16kHz audio is supported.") + if audio.shape[1] > 1: + audio = audio[:, channel] + elif audio is None: + raise ValueError("Either wav_file or audio must be provided.") + + speech_timestamps = get_speech_timestamps( + audio, + vad, + return_seconds=True, # Return speech timestamps in seconds (default is samples) + ) + + return speech_timestamps \ No newline at end of file diff --git a/orbit/orbit/builder/__init__.py b/orbit/orbit/builder/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/orbit/orbit/builder/tracking.py b/orbit/orbit/builder/tracking.py new file mode 100644 index 0000000..2b40275 --- /dev/null +++ b/orbit/orbit/builder/tracking.py @@ -0,0 +1,79 @@ +import dataclasses +from pathlib import Path +import hashlib +import subprocess +from typing import Any, Union +import sys + +from orbit import PROJ_ROOT + +@dataclasses.dataclass +class GitInfo: + branch: str + commit: str + last_tag: Union[str, None] = None + patch_str: str = "" + + @classmethod + def from_ws(cls, repo_root:str=PROJ_ROOT) -> tuple[str]: + try: + branch = subprocess.run( + ["git", "rev-parse", "--abbrev-ref", "HEAD"], + cwd=repo_root, capture_output=True, text=True, check=True + ).stdout.strip() + commit_hash = subprocess.run( + ["git", "rev-parse", "--short" ,"HEAD"], + cwd=repo_root, capture_output=True, text=True, check=True + ).stdout.strip() + + try: + last_tag =subprocess.run(['git', 'describe', '--tags', '--abbrev=0'], + cwd=repo_root, capture_output=True, text=True, check=True + ).stdout.strip() + except: + last_tag = None # current repo doesn't have any tag + + patch_str = subprocess.run(['git', 'diff'], + cwd=repo_root, capture_output=True, text=True, check=True + ).stdout + + + + return cls(branch, commit_hash, last_tag, patch_str) + + except subprocess.CalledProcessError: + print("Calling git failed!") + sys.exit(1) + + def as_dict(self, skip_patch_str=False): + data_dict = dataclasses.asdict(self) + if skip_patch_str: + data_dict.pop("patch_str") + return data_dict + + def __str__(self): + return f"{self.commit}" + ("+patch" if self.patch_str else "") + f"@{self.branch}" + + def __repr__(self): + return f"GitInfo({str(self)})" + + + + + +def create_patch_file( repo_root:Path, patch_file:Path ) -> str: + try: + with patch_file.open("w") as f: + subprocess.run( + ["git", "diff" ], + cwd=repo_root, stdout=f + ) + except: + print( "Error while trying to create patch file.") + sys.exit(1) + + md5 = None + with patch_file.open("rb") as f: + md5 = hashlib.md5(f.read()).hexdigest() + + return md5 \ No newline at end of file diff --git a/orbit/orbit/builder/xmos.py b/orbit/orbit/builder/xmos.py new file mode 100644 index 0000000..cf40a53 --- /dev/null +++ b/orbit/orbit/builder/xmos.py @@ -0,0 +1,102 @@ +import os +import subprocess +import select + +from pathlib import Path + +from orbit import PROJ_ROOT, XTC_PATH + +SOURCE_CMD="zsh" + + +def setup_xtc_env(xtc_path:str=XTC_PATH) -> None: + print( f"Activating XTC environment at {xtc_path} ..." ) + script = os.path.join(xtc_path, "SetEnv.sh" ) + pipe = subprocess.Popen( f"{SOURCE_CMD} {script} && env -0", stdout=subprocess.PIPE, shell=True) + output = pipe.communicate()[0].decode('utf-8') + output = output[:-1] # fix for index out for range in 'env[ line[0] ] = line[1]' + + env = {} + # split using null char + for line in output.split('\x00'): + line = line.split( '=', 1) + env[ line[0] ] = line[1] + + os.environ.update(env) + +def setup_py_env(env_path:str) -> None: + print( f"Activating Python environment at {env_path} ..." ) + script = os.path.join(env_path, "bin", "activate" ) + pipe = subprocess.Popen( f". {script} && env -0", stdout=subprocess.PIPE, shell=True) + output = pipe.communicate()[0].decode('utf-8') + output = output[:-1] # fix for index out for range in 'env[ line[0] ] = line[1]' + + env = {} + # split using null char + for line in output.split('\x00'): + line = line.split( '=', 1) + env[ line[0] ] = line[1] + + os.environ.update(env) + + +def run_command(command, cwd=None): + """Runs a shell command and prints the output.""" + env = os.environ.copy() + print( f"CMD: {command}") + process = subprocess.Popen(command, shell=True, cwd=cwd, + #stdout=subprocess.PIPE, stderr=subprocess.STDOUT, + text=True, env=env) + + #while process.stdout.readable(): + # line = process.stdout.readline() + # + # if not line: + # break + # print(line, end="") # Print output in real-time + + + process.wait() + if process.returncode != 0: + raise RuntimeError(f"Command failed: {command}") + + + +def build_firmware( build_dir:Path, variant:str, src_dir:Path=PROJ_ROOT, clean:bool=False, defines:list[str] = [] ) -> bool: + """Configures and builds a CMake project using Make.""" + + setup_xtc_env(XTC_PATH) + setup_py_env("/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/.venv") + + run_command( "which python3" ) + + full_build_dir = src_dir / build_dir + if clean and full_build_dir.exists(): + print(f"Cleaning build directory: {build_dir}") + subprocess.run(f"rm -rf {build_dir}", shell=True, cwd=src_dir) + + os.makedirs( src_dir / build_dir, exist_ok=True) + + defstr = " ".join([ "-D {}".format(d) for d in defines ]) + + print(f"Running CMake configuration in '{build_dir}'...") + run_command(f"cmake -B {build_dir} --toolchain xmos_cmake_toolchain/xs3a.cmake {defstr}", cwd=src_dir) + + + print(f"Building {variant}...") + run_command(f"make -C {build_dir} {variant} -j", cwd=src_dir) + + +def usb_dfu_upload( device:str, image:Path, reset:bool=True ) -> bool : + print( f"Uploading {image} to alt=1 of device: {device}...") + run_command( f"dfu-util -d {device} -a 1 -D {str(image)} {'-R' if reset else ''}" ) + + +def usb_dfu_download( device:str, dst:Path ) -> bool : + print( f"Downloading alt=1 of device: {device} to {dst}...") + run_command( f"dfu-util -d {device} -a 1 -U {str(dst)} " ) + + +def reset_device(xtag_id:str) -> bool: + print( "Resetting device..." ) + run_command( f"xrun --adapter-id {xtag_id} --reset" ) \ No newline at end of file diff --git a/orbit/orbit/tracking/__init__.py b/orbit/orbit/tracking/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/orbit/pyproject.toml b/orbit/pyproject.toml new file mode 100644 index 0000000..6a295ef --- /dev/null +++ b/orbit/pyproject.toml @@ -0,0 +1,4 @@ +[project] +name = "orbit" +version = "0.1" +dependencies = [] \ No newline at end of file diff --git a/tests/test_hw_sat1_firmware/README.md b/tests/test_hw_sat1_firmware/README.md new file mode 100644 index 0000000..e69de29 diff --git a/tests/test_hw_sat1_firmware/__init__.py b/tests/test_hw_sat1_firmware/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/test_hw_sat1_firmware/conftest.py b/tests/test_hw_sat1_firmware/conftest.py new file mode 100644 index 0000000..ccb12c9 --- /dev/null +++ b/tests/test_hw_sat1_firmware/conftest.py @@ -0,0 +1,67 @@ +import pytest +from pathlib import Path + +from orbit.builder.xmos import build_firmware, reset_device +from orbit.testing.xmos import run_firmware +from orbit import BOARD_XTAG_IDS, BOARD_USB_IDS +from tests import PROJ_ROOT +from tests.conftest import HW_TESTS + +import time + +BOARD = "Satellite1" +VARIANT = "satellite1_firmware_fixed_delay" +BUILD_DIR = "build_test_satellite1_firmware_fixed_delay" + +@pytest.fixture(scope="session", autouse=True) +def setup_firmware(): + """Build Satellite1 firmware and run it using xrun.""" + + if HW_TESTS != "build_and_xrun": + yield + return + + try: + build_firmware( + build_dir=BUILD_DIR, + src_dir=PROJ_ROOT, + variant=f"create_upgrade_img_{VARIANT}", + clean=False, + defines=[] + ) + except Exception as e: + pytest.exit(f"Firmware build failed: {e}") + + target = PROJ_ROOT / BUILD_DIR / f"{VARIANT}.upgrade.bin" + if not target.exists(): + pytest.exit(f"Firmware build failed, target not found: {target}") + + print("Running firmware with xrun...") + target_xe = PROJ_ROOT / BUILD_DIR / f"{VARIANT}.xe" + + reset_device(BOARD_XTAG_IDS[BOARD]) + pid = run_firmware( + firmware=target_xe, + xtag_id=BOARD_XTAG_IDS[BOARD], + ) + + # Wait for firmware to start + time.sleep(5) + + yield # Tests execute here + + print("Stopping xrun...") + pid.terminate() + + +@pytest.fixture(scope="session") +def upgrade_image() -> Path: + return PROJ_ROOT / BUILD_DIR / f"{VARIANT}.upgrade.bin" + +@pytest.fixture(scope="session") +def xtag_id() -> str: + return BOARD_XTAG_IDS[BOARD] + +@pytest.fixture(scope="session") +def usb_dev_id() -> str: + return BOARD_USB_IDS[BOARD] \ No newline at end of file diff --git a/tests/test_hw_sat1_firmware/test_usb_dfu.py b/tests/test_hw_sat1_firmware/test_usb_dfu.py new file mode 100644 index 0000000..012d0db --- /dev/null +++ b/tests/test_hw_sat1_firmware/test_usb_dfu.py @@ -0,0 +1,24 @@ +import pytest +from pathlib import Path +import filecmp +from orbit.builder.xmos import usb_dfu_upload, usb_dfu_download +import os + +from tests.conftest import HW_TESTS + +@pytest.mark.skipif( HW_TESTS is None, reason="Hardware tests disabled") +def test_usb_dfu(upgrade_image:Path, usb_dev_id:str) -> None: + assert( upgrade_image.exists() ) + + usb_dfu_upload( usb_dev_id, upgrade_image, reset=False ) + download_file = upgrade_image.with_suffix(".download.bin") + if download_file.exists(): + os.remove( download_file ) + usb_dfu_download( usb_dev_id, download_file ) + assert( filecmp.cmp(upgrade_image, download_file) ) + + + + + + \ No newline at end of file diff --git a/tools/ci/firmwares.txt b/tools/ci/firmwares.txt index 78b3784..bbbb2f4 100644 --- a/tools/ci/firmwares.txt +++ b/tools/ci/firmwares.txt @@ -1,3 +1,2 @@ satellite1_fixed satellite1_firmware_fixed_delay No SATELLITE1 xmos_cmake_toolchain/xs3a.cmake -usb_aec_ic_ns satellite1_usb_firmware_aec__vnr_ic__ns No SATELLITE1 xmos_cmake_toolchain/xs3a.cmake -usb_ic_ns satellite1_usb_firmware_vnr_ic__ns No SATELLITE1 xmos_cmake_toolchain/xs3a.cmake \ No newline at end of file +usb_ns_only satellite1_usb_firmware_ns No SATELLITE1 xmos_cmake_toolchain/xs3a.cmake \ No newline at end of file From 809014bfcba215b1a59dd01497c9b88177a45911 Mon Sep 17 00:00:00 2001 From: Mischa Siekmann Date: Thu, 27 Mar 2025 10:24:28 +0100 Subject: [PATCH 4/6] updated README for usb build variant --- README.md | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index d926d4c..a9b7689 100644 --- a/README.md +++ b/README.md @@ -13,9 +13,18 @@ A variant which bypasses the mic-pipeline. Hence, the raw mic signal is streamed Firmware for debugging purposes only. It runs on the XCORE.AI evaluation board. -**satellite1_usb_debug** - -Firmware for debugging purposes only. It enables basic logging on the satellite1 via usb-cdc. +**satellite1_usb_firmware_PIPELINE_CONFIGURATION** + +PIPELINE_CONFIGURATION: +- aec__vnr_ic__ns__agc +- aec__vnr_ic__ns +- aec__vnr_ic +- vnr_ic__ns +- vnr_ic +- ns + +Work in progress firmware, currently for debugging purposes only. +It configures the Satellite1 as an USB-Audio device and enables basic logging on the satellite1 via usb-cdc. ## Firmware Files From 215ae6462d7050eea1048db6332e6d83e29d81ab Mon Sep 17 00:00:00 2001 From: Mischa Siekmann Date: Thu, 27 Mar 2025 10:31:36 +0100 Subject: [PATCH 5/6] moved orbit library to separate repository --- .../aec/AnalysisExplorerBoardFixedDelay.ipynb | 1194 ---------------- .../aec/AnalysisSatellite1FixedDelay.ipynb | 1248 ----------------- orbit/notebooks/VAD-Analysis.ipynb | 213 --- orbit/orbit/__init__.py | 20 - orbit/orbit/audio/__init__.py | 0 orbit/orbit/audio/analysis.py | 27 - orbit/orbit/audio/sox.py | 18 - orbit/orbit/audio/utils.py | 164 --- orbit/orbit/audio/vad_silero.py | 22 - orbit/orbit/builder/__init__.py | 0 orbit/orbit/builder/tracking.py | 79 -- orbit/orbit/builder/xmos.py | 102 -- orbit/orbit/tracking/__init__.py | 0 orbit/pyproject.toml | 4 - 14 files changed, 3091 deletions(-) delete mode 100644 batch_runs/aec/AnalysisExplorerBoardFixedDelay.ipynb delete mode 100644 batch_runs/aec/AnalysisSatellite1FixedDelay.ipynb delete mode 100644 orbit/notebooks/VAD-Analysis.ipynb delete mode 100644 orbit/orbit/__init__.py delete mode 100644 orbit/orbit/audio/__init__.py delete mode 100644 orbit/orbit/audio/analysis.py delete mode 100644 orbit/orbit/audio/sox.py delete mode 100644 orbit/orbit/audio/utils.py delete mode 100644 orbit/orbit/audio/vad_silero.py delete mode 100644 orbit/orbit/builder/__init__.py delete mode 100644 orbit/orbit/builder/tracking.py delete mode 100644 orbit/orbit/builder/xmos.py delete mode 100644 orbit/orbit/tracking/__init__.py delete mode 100644 orbit/pyproject.toml diff --git a/batch_runs/aec/AnalysisExplorerBoardFixedDelay.ipynb b/batch_runs/aec/AnalysisExplorerBoardFixedDelay.ipynb deleted file mode 100644 index 89bc725..0000000 --- a/batch_runs/aec/AnalysisExplorerBoardFixedDelay.ipynb +++ /dev/null @@ -1,1194 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [], - "source": [ - "from pathlib import Path\n", - "import sys\n", - "import os\n", - "PRJ_ROOT = \"/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3\"\n", - "sys.path.append(str(PRJ_ROOT))\n", - "from orbit.audio.utils import read_wav_wave\n", - "from orbit.audio.analysis import estimate_time_delay\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Explorer Board with (adapted) \"example_ffva_ua_fixed_delay\" Firmware" - ] - }, - { - "cell_type": "code", - "execution_count": 104, - "metadata": {}, - "outputs": [], - "source": [ - "RES_DIR = Path(\".\").parent / \"results\"/ \"test_delayConfigs_fdPipeline_explorer\"\n", - "RUNS_PER_CASE = 5\n", - "test_cases = dict([ (int(case_dir.name.split(\"_\")[-1]),case_dir) for case_dir in RES_DIR.iterdir() if case_dir.is_dir() ])" - ] - }, - { - "cell_type": "code", - "execution_count": 103, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Case 1 - Delay: -100\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-100/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-100/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-100/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-100/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-100/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - "Case 2 - Delay: -50\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-50/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-50/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-50/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-50/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-50/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - "Case 3 - Delay: -47\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-47/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-47/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-47/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-47/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-47/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - "Case 4 - Delay: -46\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-46/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-46/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-46/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-46/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-46/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - "Case 5 - Delay: -45\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-45/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-45/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-45/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-45/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-45/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - "Case 6 - Delay: -44\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-44/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-44/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-44/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-44/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-44/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - "Case 7 - Delay: -20\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-20/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-20/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-20/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-20/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-20/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - "Case 8 - Delay: -15\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-15/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-15/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-15/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-15/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-15/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - "Case 9 - Delay: -10\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-10/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-10/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-10/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-10/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-10/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - "Case 10 - Delay: -5\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-5/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-5/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-5/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-5/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-5/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - "Case 11 - Delay: -2\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-2/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-2/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-2/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-2/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-2/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - "Case 12 - Delay: -1\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-1/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-1/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-1/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-1/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_-1/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - "Case 13 - Delay: 0\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_0/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_0/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_0/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_0/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_0/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - "Case 14 - Delay: 1\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_1/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_1/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_1/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_1/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_1/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - "Case 15 - Delay: 2\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_2/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_2/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_2/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_2/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_2/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - "Case 16 - Delay: 5\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_5/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_5/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_5/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_5/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_5/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - "Case 17 - Delay: 10\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_10/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_10/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_10/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_10/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_10/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - "Case 18 - Delay: 15\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_15/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_15/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_15/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_15/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_15/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - "Case 19 - Delay: 20\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_20/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_20/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_20/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_20/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_20/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - "Case 20 - Delay: 50\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_50/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_50/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_50/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_50/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_50/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 925815\n", - "Case 21 - Delay: 100\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_100/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_100/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_100/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_100/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_explorer/test_delayConfigs_fdPipeline_explorer_delayCfg_100/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926156\n" - ] - } - ], - "source": [ - "#load data into channels array [test_cases * run_per_test_case, channels, samples]\n", - "channels = np.empty((0,0,0))\n", - "for idx, dealy in enumerate(sorted(test_cases)):\n", - " print(f\"Case {idx+1} - Delay: {dealy}\")\n", - " case_dir = test_cases[dealy]\n", - " runs = sorted(case_dir.glob(\"*.wav\"))\n", - " for run in runs:\n", - " print(f\" Run {run.name}\")\n", - " fs, data = read_wav_wave( run.absolute().as_posix() )\n", - " if channels.size == 0:\n", - " channels = data[:,:, None].T\n", - " else:\n", - " if channels.shape[2] > data.shape[0]:\n", - " channels = channels[:, :, :data.shape[0]]\n", - " elif channels.shape[2] < data.shape[0]:\n", - " data = data[:channels.shape[2], :]\n", - " channels = np.vstack((channels, data[:,:,None].T))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Raw Microphone Channels (4 & 5) " - ] - }, - { - "cell_type": "code", - "execution_count": 143, - "metadata": {}, - "outputs": [], - "source": [ - "mic_channel_mean_var = channels[:,[4,5],:].var(axis=2).mean(axis=1).reshape(len(test_cases), RUNS_PER_CASE)\n", - "channel4 = channels[:,4,:].reshape(len(test_cases), RUNS_PER_CASE, -1)\n", - "channel4_var = channel4.var(axis=2)\n", - "channel4_var /= mic_channel_mean_var\n", - "channel5 = channels[:,5,:].reshape(len(test_cases), RUNS_PER_CASE, -1)\n", - "channel5_var = channel5.var(axis=2)\n", - "channel5_var /= mic_channel_mean_var" - ] - }, - { - "cell_type": "code", - "execution_count": 134, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.boxplot( [channel4_var.flatten(), channel5_var.flatten()] );\n", - "plt.xticks([1,2], [\"Raw-Mic 1 (ch 4)\", \"Raw-Mic 2 (ch 5)\"]);\n", - "plt.axhline(1, color='black', linestyle='--');\n", - "plt.text(2.02, 1.015, \"$(\\sigma^2_{mic_1} + \\sigma^2_{mic_2})\\; / \\; 2$\", fontsize=10, color='black');\n", - "plt.title(\"Energie Distribution of Raw-Mic Signals \\n (Normalized by Mean Energie of Mic Signals per Run)\");\n", - "plt.ylabel(\"Normalized Energy\");\n", - "plt.grid(True);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "- Recordings of Mic1 are consistently about 60% higher than Mic2\n" - ] - }, - { - "cell_type": "code", - "execution_count": 142, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.6363645302697837" - ] - }, - "execution_count": 142, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.mean((channel4_var - channel5_var)/ channel5_var)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Processed Channel 1 (w/o Auto-Gain-Control)" - ] - }, - { - "cell_type": "code", - "execution_count": 179, - "metadata": {}, - "outputs": [], - "source": [ - "#calc variances per run and normalize by mean variance of mic channels\n", - "channel1 = channels[:,1,:].reshape(len(test_cases), 5, -1)\n", - "channel1_var = channel1.var(axis=2)\n", - "channel1_var /= mic_channel_mean_var" - ] - }, - { - "cell_type": "code", - "execution_count": 180, - "metadata": {}, - "outputs": [], - "source": [ - "#normalize each run by the mean over the test case\n", - "channel1_var_mean = channel1_var.mean(axis=1)\n", - "channel1_var_run_norm = channel1_var / channel1_var_mean[:,None]" - ] - }, - { - "cell_type": "code", - "execution_count": 181, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.title(\"Distribution of Processed Signal Energies (w/o AGC)\\n (Normalized by Mean Energie of Mic Signals and over Test Case Runs)\");\n", - "plt.boxplot( channel1_var_run_norm );\n", - "plt.xticks(range(1, RUNS_PER_CASE+1), [f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", - "plt.xlabel(\"Runs per Test Case (configured fixed delay)\");\n", - "plt.ylabel(\"Normalized Energy\");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "- the first run of a test case (after flashing, and hence resetting of the XMOS) has consistently a higher energy than later runs\n", - "- => algorithm needs time (samples) to estimate the parameter of the transfer channel model" - ] - }, - { - "cell_type": "code", - "execution_count": 195, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10,5))\n", - "plt.title(\"Processed Signal Energies (w/o AGC)\\n (Normalized by Mean Energie of Mic Signals)\")\n", - "plt.plot(channel1_var);\n", - "plt.grid(True)\n", - "plt.xticks( np.arange(len(test_cases)), map(str, sorted(test_cases.keys())) );\n", - "plt.legend([f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", - "plt.xlabel(\"Test Case (configured fixed delay)\");\n", - "plt.ylabel(\"Normalized Energy\");\n" - ] - }, - { - "cell_type": "code", - "execution_count": 183, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.006, 0.02)" - ] - }, - "execution_count": 183, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Take only Runs 2-5 for each test case\n", - "plt.figure(figsize=(10,5))\n", - "plt.title(\"Distribution of Energy of Runs 2-5 per Test Case (w/o AGC)\\n (Normalized by Mean Energie of Mic Signals)\");\n", - "plt.boxplot(channel1_var[:,1:].T);\n", - "plt.grid(True)\n", - "plt.xticks( np.arange(1, len(test_cases)+1), map(str, sorted(test_cases.keys())) );\n", - "plt.xlabel(\"Test Case (configured fixed delay)\");\n", - "plt.ylabel(\"Normalized Energy\");\n", - "plt.ylim(0.006,0.02)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Processed Channel 0 (with Auto-Gain-Control)" - ] - }, - { - "cell_type": "code", - "execution_count": 184, - "metadata": {}, - "outputs": [], - "source": [ - "#calc variances per run and normalize by mean variance of mic channels\n", - "channel0 = channels[:,0,:].reshape(len(test_cases), RUNS_PER_CASE, -1)\n", - "channel0_var = channel0.var(axis=2)\n", - "channel0_var /= mic_channel_mean_var" - ] - }, - { - "cell_type": "code", - "execution_count": 185, - "metadata": {}, - "outputs": [], - "source": [ - "#normalize each run by the mean over the test case\n", - "channel0_var_mean = channel0_var.mean(axis=1)\n", - "channel0_var_run_norm = channel0_var / channel0_var_mean[:,None]" - ] - }, - { - "cell_type": "code", - "execution_count": 186, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.title(\"Distribution of Processed Signal Energies (w. AGC)\\n (Normalized by Mean Energie of Mic Signals and over Test Case Runs)\");\n", - "plt.boxplot( channel0_var_run_norm );\n", - "plt.xticks(range(1, RUNS_PER_CASE+1), [f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", - "plt.xlabel(\"Runs per Test Case (configured fixed delay)\");\n", - "plt.ylabel(\"Normalized Energy\");" - ] - }, - { - "cell_type": "code", - "execution_count": 193, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10,5))\n", - "plt.title(\"Processed Signal Energies (w. AGC)\\n (Normalized by Mean Energie of Mic Signals)\")\n", - "plt.plot(channel0_var);\n", - "plt.grid(True)\n", - "plt.xticks( np.arange(len(test_cases)), map(str, sorted(test_cases.keys())) );\n", - "plt.legend([f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", - "plt.xlabel(\"Test Case (configured fixed delay)\");\n", - "plt.ylabel(\"Normalized Energy\");" - ] - }, - { - "cell_type": "code", - "execution_count": 191, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(500.0, 5000.0)" - ] - }, - "execution_count": 191, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Take only Runs 2-5 for each test case\n", - "plt.figure(figsize=(10,5))\n", - "plt.title(\"Distribution of Energy of Runs 2-5 per Test Case (w. AGC)\\n (Normalized by Mean Energie of Mic Signals)\");\n", - "plt.boxplot(channel0_var[:,1:].T);\n", - "plt.grid(True)\n", - "plt.xticks( np.arange(1, len(test_cases)+1), map(str, sorted(test_cases.keys())) );\n", - "plt.xlabel(\"Test Case (configured fixed delay)\");\n", - "plt.ylabel(\"Normalized Energy\");\n", - "plt.ylim(500,5000)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Calculated Delay between Raw Mics and Reference Signals by Maximizing the Cross-Correlation\n", - "##### Example for Run 2 of Test-Case 0" - ] - }, - { - "cell_type": "code", - "execution_count": 196, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "audio_data = channels[1,:,:].T\n", - "fs=16000\n", - "channel_names = [\n", - " \"PROC 0\",\n", - " \"RPOC 1\",\n", - " \"REF 0\",\n", - " \"REF 1\",\n", - " \"MIC 0\",\n", - " \"MIC 1\"\n", - "]\n", - "combinations = ((2,3),(4,5),(2,4),(2,5),(3,4),(3,5))\n", - "fig, axes = plt.subplots(3, 2, figsize=(12, 12), sharex=True)\n", - "axes = axes.flatten()\n", - "for i, comb in enumerate(combinations):\n", - " chirp_signal = audio_data[:,comb[0]] / np.max(audio_data[:,comb[0]])\n", - " mic_signal = audio_data[:,comb[1]] / np.max(audio_data[:,comb[1]])\n", - " # Estimate the delay\n", - " estimated_delay_sec, correlation = estimate_time_delay(chirp_signal, mic_signal, fs)\n", - " # Plot the cross-correlation\n", - " lags = np.arange(-len(chirp_signal)+ 1, len(chirp_signal)) / fs\n", - "\n", - " axes[i].plot(lags * 1000, correlation)\n", - " axes[i].axvline(x=estimated_delay_sec * 1000, color='r', linestyle='--', label=f\"Estimated Delay: {estimated_delay_sec * 1000:.2f} ms\")\n", - " axes[i].set_title(f\"CC({channel_names[comb[0]]},{channel_names[comb[1]]}) {estimated_delay_sec * 1000:.2f} ms\")\n", - " axes[i].set_xlabel(\"Time Lag (ms)\")\n", - " axes[i].set_ylabel(\"Correlation\")\n", - " axes[i].set_xlim((-80,80))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Does the measured delay depend on the configured fixed-delay?\n", - "\n", - "Answer: No" - ] - }, - { - "cell_type": "code", - "execution_count": 205, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Estimated delay for case 0 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", - "Estimated delay for case 1 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", - "Estimated delay for case 2 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", - "Estimated delay for case 3 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", - "Estimated delay for case 4 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", - "Estimated delay for case 5 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", - "Estimated delay for case 6 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", - "Estimated delay for case 7 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", - "Estimated delay for case 8 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", - "Estimated delay for case 9 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", - "Estimated delay for case 10 is [0.0468125, 0.0468125, 0.0468125, 0.046875]\n", - "Estimated delay for case 11 is [0.0468125, 0.0468125, 0.0468125, 0.0469375]\n", - "Estimated delay for case 12 is [0.0468125, 0.0468125, 0.0468125, 0.0469375]\n", - "Estimated delay for case 13 is [0.0468125, 0.0468125, 0.0468125, 0.0469375]\n", - "Estimated delay for case 14 is [0.0468125, 0.0468125, 0.0468125, 0.0469375]\n", - "Estimated delay for case 15 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", - "Estimated delay for case 16 is [0.0464375, 0.0464375, 0.0464375, 0.0465625]\n", - "Estimated delay for case 17 is [0.0464375, 0.0464375, 0.0464375, 0.0465625]\n", - "Estimated delay for case 18 is [0.0464375, 0.0464375, 0.0464375, 0.0465625]\n", - "Estimated delay for case 19 is [0.0464375, 0.0464375, 0.0464375, 0.0465625]\n", - "Estimated delay for case 20 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 21 is [0.046625, 0.046625, 0.046625, 0.04675]\n", - "Estimated delay for case 22 is [0.046625, 0.046625, 0.046625, 0.04675]\n", - "Estimated delay for case 23 is [0.046625, 0.046625, 0.046625, 0.04675]\n", - "Estimated delay for case 24 is [0.046625, 0.046625, 0.046625, 0.04675]\n", - "Estimated delay for case 25 is [0.0463125, 0.0463125, 0.0463125, 0.046375]\n", - "Estimated delay for case 26 is [0.0463125, 0.0463125, 0.0463125, 0.0464375]\n", - "Estimated delay for case 27 is [0.0463125, 0.0463125, 0.0463125, 0.0464375]\n", - "Estimated delay for case 28 is [0.0463125, 0.0463125, 0.0463125, 0.0464375]\n", - "Estimated delay for case 29 is [0.0463125, 0.0463125, 0.0463125, 0.0464375]\n", - "Estimated delay for case 30 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 31 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 32 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 33 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 34 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 35 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 36 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 37 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 38 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 39 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 40 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", - "Estimated delay for case 41 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", - "Estimated delay for case 42 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", - "Estimated delay for case 43 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", - "Estimated delay for case 44 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", - "Estimated delay for case 45 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", - "Estimated delay for case 46 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", - "Estimated delay for case 47 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", - "Estimated delay for case 48 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", - "Estimated delay for case 49 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", - "Estimated delay for case 50 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", - "Estimated delay for case 51 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", - "Estimated delay for case 52 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", - "Estimated delay for case 53 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", - "Estimated delay for case 54 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", - "Estimated delay for case 55 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 56 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 57 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 58 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 59 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 60 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", - "Estimated delay for case 61 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", - "Estimated delay for case 62 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", - "Estimated delay for case 63 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", - "Estimated delay for case 64 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", - "Estimated delay for case 65 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 66 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 67 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 68 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 69 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 70 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 71 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 72 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 73 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 74 is [0.046625, 0.046625, 0.046625, 0.0466875]\n", - "Estimated delay for case 75 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", - "Estimated delay for case 76 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", - "Estimated delay for case 77 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", - "Estimated delay for case 78 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", - "Estimated delay for case 79 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", - "Estimated delay for case 80 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", - "Estimated delay for case 81 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", - "Estimated delay for case 82 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", - "Estimated delay for case 83 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", - "Estimated delay for case 84 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", - "Estimated delay for case 85 is [0.0464375, 0.0464375, 0.0464375, 0.0465]\n", - "Estimated delay for case 86 is [0.0465, 0.0465, 0.0465, 0.0465625]\n", - "Estimated delay for case 87 is [0.04675, 0.04675, 0.04675, 0.0468125]\n", - "Estimated delay for case 88 is [0.04675, 0.04675, 0.04675, 0.0468125]\n", - "Estimated delay for case 89 is [0.04675, 0.04675, 0.04675, 0.0468125]\n", - "Estimated delay for case 90 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", - "Estimated delay for case 91 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", - "Estimated delay for case 92 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", - "Estimated delay for case 93 is [0.0465625, 0.0465625, 0.0465625, 0.0466875]\n", - "Estimated delay for case 94 is [0.0465625, 0.0465625, 0.0465625, 0.046625]\n", - "Estimated delay for case 95 is [0.0466875, 0.0466875, 0.0466875, 0.04675]\n", - "Estimated delay for case 96 is [0.0469375, 0.0469375, 0.0469375, 0.047]\n", - "Estimated delay for case 97 is [0.0469375, 0.0469375, 0.0469375, 0.047]\n", - "Estimated delay for case 98 is [0.0469375, 0.0469375, 0.0469375, 0.047]\n", - "Estimated delay for case 99 is [0.0469375, 0.0469375, 0.0469375, 0.047]\n", - "Estimated delay for case 100 is [0.046625, 0.046625, 0.046625, 0.04675]\n", - "Estimated delay for case 101 is [0.0468125, 0.0468125, 0.0468125, 0.046875]\n", - "Estimated delay for case 102 is [0.0468125, 0.0468125, 0.0468125, 0.046875]\n", - "Estimated delay for case 103 is [0.046875, 0.046875, 0.046875, 0.0469375]\n", - "Estimated delay for case 104 is [0.046875, 0.046875, 0.046875, 0.0469375]\n" - ] - } - ], - "source": [ - "normed = channels / np.max(channels,axis=2)[:,:,None]\n", - "est_delays = []\n", - "for idx in range(channels.shape[0]):\n", - " this_delays = []\n", - " this_delays.append(estimate_time_delay(normed[idx,2,:], normed[idx,4,:], 16000)[0])\n", - " this_delays.append(estimate_time_delay(normed[idx,2,:], normed[idx,4,:], 16000)[0])\n", - " this_delays.append(estimate_time_delay(normed[idx,3,:], normed[idx,4,:], 16000)[0])\n", - " this_delays.append(estimate_time_delay(normed[idx,3,:], normed[idx,5,:], 16000)[0])\n", - " #this_delays.append(estimate_time_delay(normed[idx,4,:], normed[idx,5,:], 16000)[0])\n", - " est_delays.append(this_delays)\n", - " print(f\"Estimated delay for case {idx} is {est_delays[idx]}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 210, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(46.2, 47.1)" - ] - }, - "execution_count": 210, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGzCAYAAADHdKgcAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAVGZJREFUeJzt3Qm8TfX+//EPyZghMqQMkXkmiURFRVK5t5mSJN3IVCr/BpSiUlRucRURXbc03bpdkptcJWS6usYMUZSQ+VCx/4/39/db+7f3Pvucs/eZ9jl7vZ6Px36cs9dee+3vWt81fNZ3WgUCgUDAAAAAfKRgohMAAACQ2wiAAACA7xAAAQAA3yEAAgAAvkMABAAAfIcACAAA+A4BEAAA8B0CIAAA4DsEQAAAwHcIgPKoBQsWWIECBdzf7KRljhgxwvKyZcuWWZs2baxEiRIuvatWrUpoem6//XarXr26JZu8sC/khTT4hfZh7cs5fY5B/rFt2za3D7z++uvmRwRAMbr66qutePHidujQoTTn6d69uxUuXNj27t1rifTxxx/n24vKb7/9Ztdff73t27fPxo0bZ2+88YZVq1Yt6rzeCTyt16xZs2L+3Z07d7ptluhgK9Kbb75p48ePT/gJ0nudeuqpdsYZZ7gA9f/9v/9n27dvT1jakPPSO75CX9kRRB09etQdg/Eu66effrL777/f6tat687RunFq0aKFjRo1yvbv35/ldMFSnWtPOeUUq1Chgl133XW2bt06y68KJToB+YWCmw8//NDee+89u+2226IevB988IF16tTJypUrl+Xfa9eunaWkpLiAKjMB0J///OeoQZCWWahQ3s32zZs323fffWeTJ0+2O++8M6bvDBgwwFq2bJlqeuvWreMKgEaOHOnukps2bRr2mdJy8uRJS1QA9M0339igQYMskW6++Wa78sor3Xb45ZdfXCmdArMXXnjBXnvtNbvpppsSmj7kDN2AhJo+fbrNmzcv1fR69epl+bd0DtUxKBdffHFM39F+qP3y8OHD1qNHDxf4yNdff21jxoyxhQsX2ieffJLltCH8XKsb1f/85z82ceJEFxzpHFWpUiXLb/LulTAPlgCVLFnSXZCiBUAKfo4cOeICpaw4duyYC3oKFixoRYsWteyWE8vMTrt373Z/y5QpE/N3LrroIncnklNU6uF3zZs3dxeYUApUL7/8cuvZs6e7ADZp0iRh6UtmoeeE3BaZ51999ZULgCKnJ4JKd7p16+ZKI1auXOlKgEI9+eST7uYF2eeiiHNtnTp17E9/+pMLjB944AHLb6gCi1GxYsXsD3/4g82fPz94kQ6lwEgBkgIlVd+oSLZRo0Z22mmnWalSpaxz5862evXqqMWKqqp55JFH7KyzznJFuAcPHoxaP//vf//bVQ9VrVrVihQpYlWqVLHBgwe7Uh2P6vhV+iOhRZbptbnQyUPpUzqV3g4dOrgTXSjVEeu7X3zxhQ0ZMsTKly/vipp1Avr5559j2ob/+te/3AGk7ynAueaaa8KKT5X29u3bu/+1nvq9WO8EM6KTdtu2bd3vah114KoKR7SNvRKkXr16BbeZVy8e2QbIqxYaO3as29Y1atRw+aZgYMeOHRYIBOyJJ56ws88+2+03Wk/tE5EBc5cuXaxy5couL2vWrOm+c+LEieA8Wvd//OMfLtDw0hSajuPHj9vw4cPt3HPPDe4POglpeii9136iPPP20e+//z7L21RVk9pGv/76qz3zzDOpLk4qtVKalDal8emnn86wJE3res8997j80bZTaar2BW1zz5YtW9y2UBVppC+//NJ99te//tW9V5W10qHtpnSo2P6yyy6zFStWZLh+GR0XKmXQb02bNi3Vd+fOnes+++ijj4LTfvjhB7vjjjusYsWKLi0NGjSwKVOmxHxOSIv2Q1VJaltpm6kUZPbs2ZZblKcqDdT66AZL69e3b19XUhhK2+uKK65wVahK5znnnOO2hyh/tX+KSoG8/T29qvxJkya5bfr888+nCn5E6dA2jOeYk02bNtkf//hHV6Kh9dFxrBLOAwcOhM03Y8YMt621LmXLlnXz6PjPzLIixXKu985N2je1Ha699lr3v7ajrj+R66VjUvOXLl3anQd79uyZ5SpCnc+9kvuM2kwqL0OvRaL3/fv3t/fff98aNmwYPC7mzJkTNl9WjuP0UAIUB5Xu6GT31ltvuUzz6OKmE56qCXQw/Pe//3UZqh1YB7nqqHWw6uK+du1adwCG0kGoOzzttLpYpVXt9fbbb7tiYkXcOtktXbrUXnrpJXcx02eiE4+qc6IVU0ejtGon1kleF0+Vdiituvh+/vnn1qpVq7D57733Xjv99NPdhVcnLZ34tC3+9re/pfs7n376qbuYKFjQgaADWWm/8MIL3U6sHVtp1wn/qaeeCha16iSWER0ce/bsSTVd20gHmNbxqquussaNG9vjjz/uDqBvv/3WBXOi0gtNf+yxx+yuu+4KHtS6qKRn5syZ7uKvbaJ9QEHADTfcYJdeeqm7kD344IPud7SeytvQi50CB52sFEzqr4JD/b4udM8++6yb5+GHH3YnSuWvd7HXvN5FR4HMokWLXJq1DmvWrHHzbdy40e1/HlUl6mR9yy23uHXSb+lCkB1UzagLifY3j/ZR7es6KStPdRJXYDJs2DDbtWtXum2aVKWheXWR0MVC+9grr7zi9kcdOwoGtA9pv9H210UhMk8U5CnolLvvvtsFA9pH69ev79rnaZsp8FapVlaOi/POO8+lRecDXUxC6XjQcaILvugccMEFFwRP+LpI/fOf/7TevXu7PI+s4oz1nCCqhtS+oPOT9kcFTzr3KPjKrnxOj/JY+7NuHnTcbt261SZMmOACSB1j2na6adQNgtb7oYcechdg5e27777rlqHpymed23RTpZtN0TGblr///e/ufBtr6W8sx5y2n/JM21zHtQIX7cfalgoWFDx4pUuPPvqoO951fOkmUMe5mi5ovbV+sS4rs+d6jwId/Y72SQXDOtc+99xz7rjU90U3ZTomtO/rmND54r333ku138bLuzHRvp5ZSpP2A9346Nh98cUXXdCo9oVec5LMHscZCiBmv//+e+DMM88MtG7dOmz6xIkTA9qUc+fOde+PHTsWOHHiRNg8W7duDRQpUiTw+OOPB6d99tln7ns1atQIHD16NGx+7zP99UTOI6NHjw4UKFAg8N133wWn9evXz303Gk0fPnx48P21114bKFy4cGDz5s3BaTt37gyULFky0K5du+C0qVOnuu927NgxcPLkyeD0wYMHB0455ZTA/v37A+lp2rRpoEKFCoG9e/cGp61evTpQsGDBwG233ZZqvd9+++10lxc6b1qvXbt2ufnGjRvn3v/8889pLmvZsmVuHq1npJ49ewaqVasWlpeat3z58mHrPWzYMDe9SZMmgd9++y04/eabb3bbWPtFennZt2/fQPHixcPm69KlS9hve9544w237f79739H3Re/+OIL937VqlXu/T333BM23y233JJqX4jGW9dnn302zXmuueYaN8+BAwfc+yeeeCJQokSJwMaNG8Pme+ihh9y+sn379uC0yDRE2y6LFy92802fPj04bdKkSW7aunXrgtN+/fXXwBlnnOHyy1O6dGl3PMQr1uNCeX7qqacG9u3bF5x2/PjxQJkyZQJ33HFHcFrv3r3duWPPnj1hv3PTTTe5NHrrnd45IS2R82k7NGzYMHDppZeGTdd+FLptop1jMhJ5btH+p/czZ84Mm2/OnDlh09977z33XsdZWnR8xrJPek4//XR3rMUqlmNu5cqVGZ5/tm3b5vbjJ598Mmz6mjVrAoUKFQpOj2VZ8aQ12rle+anfCL2uSLNmzQItWrQIvn///ffdfM8880zY9eyiiy5K87wXyttXpkyZ4vJJx4Ly+Nxzz3VpWrp0aViaop2zlK+R1yW913H27bffhl0XNP2ll17K8nGcEarA4qC6Zt2ZLl68OKxIXtVfKqlQEbmohMGrr1d0rmjVq3aJVmSnKFx3MhkJnUftjVTqoTt67Ue664iX0qYGgio61Z2s58wzz3SlBYqwI4veVdoQWoypu2QtR1UXadFdv3pXqWhURcUe3d2pGFONtrNCd3EqgYh8eb/ltSdSEXh2NmbWXXboXZxXWqb2EaENzTVdd4O6+4uWl14Jlral7vrWr1+f4W/rLlB3cSr613e9l0qf5LPPPnN/vW2rO/NQ2dmo2iuV8npIKm1aF90VhqatY8eObl9Rw9S0hG4XNbTUsaPqM+Vh6LGjO29VKajEx6NSWP1OaPsUfW/JkiWuVDQnjosbb7zRpdMryRB9V3f4+kx0fL7zzjvWtWtX93/oNtGdu0r5Is8LsZ4TIreZqp20PG3/rFYPxEJ5rWNAx3HoeqlqSPuFtx96x6BKP7S9soPyQCUGsYrlmPOOZ+1Lmh6N8lrnEe2DoeusEp5atWoF1zmWZWXXuV4lJKG0Xqoq9ug8oHOSVyLkXc/uvffeuNKlKkuV1qkWQx1+tK+ppiFaJ5RY6byg0qrQ64JKXkPTn5njOBYEQHHyGjkr6BEVSaq+VoGRdijRwaGqCB0MCoZU562dRq3mo9X9qposFioS9IIIr67XazOTUZ1yNCq21YGpwCySLq5aj8g6bVVnhPKKPiPr+0N5wVFav6ODWwd5ZqmtlQ6iyJdXbaALkapMVFStQFV5pWqLrAZDkdvCO+Gpvj7a9NBtpCoWFfXrMx3sykvvwh1LXqptgZah74W+ateu7T732qlp2ysYDz3BpJUXmaUeOOJdjJQ21eFHpk15Epq2aFQ1qoDWazvkHTsKKEK3i06ICii841AUDKkK1QsCRdWS6qGi5Z1//vmu+jX0xJrV40INvxWEhlYB63+l20uHlqf0/+Uvf0m1TVRtFG2bxHpO8IIKVa8pINS5watOysw5IV7Ka/2O2mRErpv2C2+9dJ5StYba92jbqDpm6tSpqdqrxUPHTXrDkkSK5ZjTdlcV2auvvurSqQBV7fxCt6XWWYGIzu+R66wqGW+dY1lWdpzrle9e+6nQ83Lo+UbnAQXw3s1KZs8Dj/3vzabXG1ppyWrj/MjzaLT0Z+Y4jgVtgOKkOxud8NTIUo1o9VcHQ2jvL7VhUf2womXV5Wsn1k6iu+5oF91Y7vR0V6q7LLU1UdsSpUGNiVWqoAMlt7ppe0FepP8pzcybtH1V6qA7MzUq1sVZFyldoHS3ntY6ZSSt72W0jXQx1MlMJ2G1PVJwopOY7tiVt7HkpeZR4KcGoNFEBmE5SScmXQC1Pl7atK+m1SvEC9Ki0R2pLow6VtS+SBcrlTgqaI3cLjoBqwRCbYa0LdQmRO0IQk/IukvX3bBO2MprtfVQY2zdxatNWnZQgK02IQrkFQQqHWoP6JUCeunWxTatNheRbV1iLf3RzZfa/6jtycsvv+wucmpzo20YGhzmFK2b8j60JC6Ud2FWHqoNhxqRazgRlYro/Ki2KpoWeWGOhc6BKllW6WpGw4XEc8wpTTqnqsRY+4xKT0ePHu3SqXZpmlfrozZc0Y710HXJaFnZca7P7PkrKzebohJS3Sj06dPHdTDxzjmRDZ09kY2y47mm5NRxTACUCQp2FOCoREcnGd0JhBYB6kC/5JJL3PgokQeh7gQyQw1c1bhVjbBDu+GHNj71pLUDRjs5qVHphg0bUn2mImFdSLLjQuoNZJjW72ib6ADPSVoXVVHqpaBBQaoaGSso0gEd6zbLDmograodHby6cHnUeDRSWunSCVy9CrU+6aVd214nTPXSCL3bi5YXmaHqYC07tNpJadPdv3eijIeOHQUJunCEdgOP1ltFRfDah3XxVTWjTsa33nprqvkUFCgw0kt352o0qYAlrRNnvMeFAiCVbKiaSyWMqpoJHRfJ632nC0Bmtkl69Ju6kCugUImZRwFQblBeq9GtSlhjCdpUUqWXtr/OnTqXqtG2SmfjPQZVAqj9T9tAAWd2HXPehV4v9SJTgK3105g3GlxR66yLs0p40gvmY1lWVs/1sdJ5QD2YdVyGBmgbsnge0FhLCkqUn1onr/Qm2vGaXjOJWMR7HMeCKrBM8Ep7VByoO5DIsX8U0UaWiOhONbQNSLy8KDl0ufpfPUAiecFERl0ctUz1zNDdSWibJvVY0clJUb13V5/VHVeDC+qADk2TSg4UzWsgs5wU2QVdvMEOvSL4WLdZdoiWl7qL1R18JKUrWpG57oi0P0Ub50TVSF6VondyUM+KUNkxurROaLoj1d330KFDw9KmC5MuypG0fX///fc0lxnt2FHvl2h3jyph0YVP1Znq4aOLTGhJir4Tue1UWqH2C+lVvcR7XKhaTL+tUkW9tL+HXmS1PFX/6EKtfT5SrMNIpJVWBQ6h20dpDu0FmJOU1/ptlXRHUj57x5OqMyLzNfIYVNAZzzGodi/a1vfdd58LGCLpIukFGbEecwpeI/dP5a2CXi+d6qGm5SnojVwnvfeeBBDLsrJ6ro+VzrFKi6pGPSdOnHDHVlYoGNS+rePvxx9/DE7TcacCgtB2oAqUMiOzx3EsKAHKBEX+apCmE6REBkDqcq1iVtXvaz5F9LpLDW1QGS8Vg2rHUrdYXfh0AtYJNVrbG280VBW3qt7Za7wdjU4Q3hg5iqx1UVF3X+1YkWO7ZIWKLHUxVrWGuv563eBVxZHVx3aoGkClBJF0MfS6vqsKTF2CdSekE6NOfCqC1nqLtq3aleguRnfrCjxUqhBPW4xYaZ/QXZJKOpRHuoCpIWG0akTlpS6qakugUkbdvenOVyUduvDrIqBSLN1V6kShEgpNV/Chbtq6yChI0PrqJKLf1p2guufHQ1UF6kqv0iRdoNRdXfufl/bQwEPBkKqBdBwoQNI6KCDTcaASHl2g0yoJ1Xe0PO0X6u6qQEolDGmNrq47ZAV32gYqEg+l9iHKY3WTVlsdbTstS2kPLWHKjuNCpUC6IVJpjPbvyHYRulNWGrVPqcpA66bAXNtVaYoWpMdC+7RKNFUapgba2rfVzkQNx0MvQDlF1UrqBq9qHd0MKnBUFZzayeimTxdtbX/d/GgfVBscHWvKGwXvOo95N0AqQdJ20f6ukhU1HdDYMHpFo2NIF1V9X/t56EjQ2q5qnuCNBh/rMaeu8epqrQ4OSoOCBs3nBbGi9Gv/0LAO2pdVFaRzhkqTlB51FNF5OpZlZfVcHyudM3SO0BAESrO287vvvpst7cR0vOuco5sq7ee61qjqTnmtba2SWQVe2gaZaZifleM4Q9ner8wn/vznP7uueueff36qz9Sl8r777nPdXosVKxa48MILXVfe9u3bu1csXb6jdVFdu3at64Z+2mmnue6+ffr0CXYZDO3GqO6N9957r+umrS6KodkcrZvpihUrAldccYVbrrqEXnLJJYEvv/wybB6vG3xkN9Z4utJ++umnbltom5QqVSrQtWtXt07Rlpcd3eC99Zw/f77rql25cmXX5VJ/1TU9spv2Bx98EKhfv77ryhq6TdPqBh/ZNTyttEfbduqmfsEFF7htofQ88MADbhiFyG15+PBh12Vd3ar1WWg61N356aefDjRo0MANsaBuwer6OnLkyGCXdElJSQkMGDAgUK5cOdc9Xdt9x44dcXWD917aNmXLlg20atXKdQEP7ZIb6tChQ+5zdZPVNtf+2qZNm8DYsWNduj2Rafjll18CvXr1cvNrf9R+uX79+lRduENp/TUkwPfffx82Xd3Rhw4d6rpKq/u61l3/v/zyy4FYxHJceDZt2hTcRosWLYo6z08//eS68lapUsV1na9UqVKgQ4cOgb/85S+Z2v89r732WqBWrVpuH6hbt67b36J1Oc6JbvAerYP2Pe3P2taNGjVy+7S6S3vbUsdc1apVXTo1JMZVV10V+Prrr8OWo+2r5WifibVLvH5Dw3HUrl07ULRoUZdXWoa6o4ceB7Ecc1u2bHHDF9SsWdMtS/u68l3nrkjvvPNOoG3btm6/0kvbXttnw4YNcS8rUqzneuWnfjtStPzXECS33nqrO/eqW/mtt94a7Kofazf4tPbLiy++2C3XGxbkk08+cUMxKB/r1KkTmDFjRprd4KN1bw/dV7N6HKenwP8mAgDypWbNmrnSApVsAUCsaAMEIN/S4xVU9RLt+XwAkB5KgADkO2pMvHz5ctcGQN3PNSZIXn/QL4C8hRIgAPmOGlOrk4FGFVZjV4IfAPk2AFLrcbXM94bo9564He0V+TC4UGrZrp4I3oMwVTwOILmo56B6pGnkXW+EXADIdwGQurOpi2loV1oNNKaxA0JfGndBXeDSG/hI3W3VdTWySywAAECeGQdII1NqHB2NCRE6MqbGStDD5UJpjAUNvJXesOneSLChA5gBAADkqQCoX79+bjAvDRGf1tDgogaPqs7SIF/ZTYObhY4oqaJ1DUzmVaMBAIC8T/26NHiiRorO6EGtCQ2A9AwYjQypKrCM6LlaGnJeI3pmN41iquo1AACQ/+3YsSPNB84mPABS4gYOHOiGm8+oB4cem6Bn8OgBpDlBQ5rrUQMeDQ9etWpVl8bseBYWAADIeXoGm9oQ6/EkGUlYAKQqLe+Jrh49y0jPbJowYYKrkvIeCqcur3qeSE4NdqanKIc+Sdmj4IcACACA/CWW5isJC4A6dOjgHo4YSuN66EFwepCaF/x41V9XX321lS9fPgEpBQAAySZhAZCKpyKf8qsncKvhceh0PbVapUIff/xx1OUoYFIbHj15VtR4efv27bZz5073fsOGDe6vepRF9ioDAAD+lCfGAUrPlClTXEMmDW4YjQIctdnx/P3vf3cPR1TPMrnpppvc+4kTJ+ZamgEAQN7Gs8DSaERVunRpF1jRBggAgOS7fuf5EiAAAIDsRgAEAAB8hwAIAAD4DgEQAADwHQIgAADgOwRAAADAdwiAAACA7xAAAQAA3yEAAgAAvkMABAAAfIcACAAA+A4BEAAA8B0CIAAA4DsEQAAAwHcIgAAAgO8QAAEAAN8hAAIAAL5DAAQAAHyHAAgAAPgOARAAAPAdAiAAAOA7BEAAAMB3CIAAAIDvEAABAADfIQACAAC+QwAEAAB8hwAIAAD4DgEQAADwHQIgAADgOwRAAAAkkcOHD1u3bt2scePG7q/eIw8HQGPGjLECBQrYoEGD3Ptt27a599Feb7/9dprLCQQC9thjj9mZZ55pxYoVs44dO9qmTZtycU0AAEiM888/30qWLGnvv/++rVmzxv3Ve01HHgyAli1bZpMmTXLRqqdKlSq2a9eusNfIkSPttNNOs86dO6e5rGeeecZefPFFmzhxoi1ZssRKlChhV1xxhR07diyX1gYAgNynIEfXUxUU3HrrrbZ69Wr3V+81nSAoXIGAikwSSEVzzZs3t5dfftlGjRplTZs2tfHjx0edt1mzZm7e1157LernWpXKlSvbfffdZ/fff7+bduDAAatYsaK9/vrrdtNNN8WUpoMHD1rp0qXdd0uVKpWFtQMAIHeupSrpUbBz9OhRK1q0aPAzFQAUL17cXSMPHTrkChKSVTzX74SXAPXr18+6dOniqqrSs3z5clu1apX17t07zXm2bt1qP/74Y9iytCFatWplixcvTvN7x48fdxst9AUAQH6hkh7p0aNHWPAjen/LLbeEzYcEB0CzZs2yFStW2OjRozOcV6U+9erVszZt2qQ5j4IfUYlPKL33PotGv69AyXup+g0AgPxi8+bN7q9X+xFpyJAhYfMhgQHQjh07bODAgTZz5sxU0WqklJQUe/PNN9Mt/cmKYcOGueIy76W0AQCQX9SsWdP9HTt2bNTPn3/++bD5kMA2QGqZru55p5xySnDaiRMnXP1lwYIFXbWU99kbb7zhgp8ffvjBypcvn+Yyt2zZ4jJ35cqVri2Rp3379u79Cy+8EFPaaAMEAMhPaAOUj9oAdejQwXXRU7se73XeeedZ9+7d3f+hgZGqv66++up0gx8555xzrFKlSjZ//vywjaHeYK1bt87R9QEAIFEU1LRs2dIFOQp21BZITUz01wt+9HkyBz/xKmQJoki1YcOGYdPUZb1cuXJh07/99ltbuHChffzxx1GXU7duXdeGR6VJ3jhC6k1Wq1YtFxA9+uijrmfYtddem+PrBABAoixdujTYFV7NS/TyKPjR58gDAVCspkyZYmeffbZdfvnlUT/fsGGDK+ryPPDAA3bkyBG76667bP/+/da2bVubM2dOhu2MAADI7xTkqDpMvb3U4FnNQtSMhJKfPDgOUF5EGyAAAPKffNEGCAAAIFEIgAAAgO8QAAEAAN8hAAIAAL5DAAQAAHyHAAgAAPgOARAAAPAdAiAAAOA7BEAAAMB3CIAAAIDvEAABAADfIQACAAC+QwAEAAB8hwAIzuHDh61bt27WuHFj91fvkbzIb38hv/1l37591qhRIytXrpz7q/dIrUAgEAhEme5rBw8etNKlS9uBAwesVKlSluzOP/98W7ZsWarpLVu2tKVLlyYkTcg55Le/kN/+UqlSJfvpp59STa9YsaL9+OOPluwOxnH9pgTI57yTY4ECBezWW2+11atXu796r+n6HMmD/PYX8tu/wc8FF1xg8+fPd39F0/U5/g8lQD4uAVIxeMmSJd3J8OjRo1a0aNHgZ8eOHbPixYubdo9Dhw7ZaaedltC0IuvIb38hv/1F1Vyq8pLIPPX2Bdm7d6+VLVvWkhUlQIiJ7gSlR48eYSdH0ftbbrklbD7kb+S3v5Df/tK+fXv3VyU+kQGt3nulfd58IADytc2bN7u/999/f9TPhwwZEjYf8jfy21/Ib3/ZuXOn+/vkk09G/fzxxx8Pmw8EQL5Ws2ZN93fs2LFRP3/++efD5kP+Rn77C/ntL5UrV3Z/H3744aifP/bYY2HzgTZAUdEGiDYCyYj89hfy219oA/Q/aAOEmOgAUVdYnQR1MlRbgRUrVri/3slRn3NyTA7kt7+Q3/6ioEZd3UXBTqtWrWzu3Lnurxf86PNkDn7iRQmQj0uAPIwT4i/kt7+Q3/7COEAHY75+EwBF4bcAyCsiVW8QNYhUm4A33niDO8MkRn77C/ntv+ow9fZSg2e1+fn88899U/JzkAAoa/wYAAEAkN/RBggAACAdBEAAAMB3CIAAAIDvEAABAADfIQACAAC+k2cCoDFjxrgRSwcNGhQ2ffHixXbppZdaiRIlXIvudu3aWUpKSprL0QiYWka1atWsWLFi1qZNm6hjYAAAAP/KEwGQApRJkyZZ48aNUwU/nTp1sssvv9wN2KX5+vfvbwULpp3sO++80+bNm+fGuVizZo37bseOHe2HH37IhTUBAAD5QcLHAdIAXc2bN7eXX37ZRo0aZU2bNrXx48e7zy644AK77LLL7IknnohpWSoZ0pDfH3zwgXXp0iU4vUWLFta5c2e3/FgwDhAAAPlPvhoHqF+/fi5YUSlNqN27d9uSJUusQoUKrhpLw3hrZMtFixaluazff//dTpw4EfbQP1FVWHrfO378uNtooS8AAJC8EhoAzZo1yz2cb/To0ak+27Jli/s7YsQI69Onj82ZM8eVFHXo0ME2bdoUdXkq/WndurUrMdIQ4AqGZsyY4arSdu3alWY69PuKGL1XlSpVsnEtAQBAXpOwAGjHjh02cOBAmzlzZqoSGzl58qT727dvX+vVq5c1a9bMxo0bZ3Xq1LEpU6akuVy1/VGt3llnnWVFihSxF1980W6++eZ02w0NGzbMFZd5L6UNAAAkr0KJ+uHly5e7ai6V6nhUYrNw4UKbMGGCbdiwwU2rX79+2Pfq1atn27dvT3O5etCfHvx25MgRV5V15pln2o033mg1atRI8zsKlPQCAAD+kLAASFVZ6qUVSiU9devWtQcffNAFLHqKrRcIeTZu3OgaNGdE3eb1+uWXX2zu3Ln2zDPPZPs6AACA/ClhAZDa6zRs2DBsmgKWcuXKBacPHTrUhg8fbk2aNHG9w6ZNm2br16+32bNnhwVS3bp1c93jRcGOqsBUVfbtt9+6ZSioUnAFAACQ0AAoFhrQ8NixYzZ48GDbt2+fC4Q0xo+quTybN2+2PXv2BN+rDY/a9Hz//fdWtmxZ++Mf/2hPPvmknXrqqQlai/zh119/dUMRaHtq+95zzz1WuHDhRCcLOYT89hfyG4hC4wAh3IEDBzQ2kvvrB0OHDg0UKlTIrbP30ntNR/Ihv/2F/IafHIjj+p3wcYCQWA888IA9++yzrupx8uTJbrgA/dV7TdfnSB7kt7+Q30AeHgk6L/LLSNAqFvfaXanKsFChQmGDSp599tm2d+9e16OO4vL8j/z2F/IbfnQwjut3nm4DhJylNgE6EeoRIaEnR9H7xx9/3I3DpPkiH1KL/If89hfyOzkcPXrUdf6Jlx4NtW3bNqtevbp7GkK86tata8WLF7dkRgDkY2oQKVdddVXUz73p3nzI38hvfyG/k4OCHz3PMhFj9TUPGacvGREA+ZjXm+6jjz6yO++8M9Xnmh46H/I38ttfyO/koJIYBSPxWrdunfXo0cM9DkoDCGfmd5MdbYCioA0QbQSSEfntL+S3v+k5myo58kNJTr59GjwSRyc9jbH0008/uZPhX/7yF/cQWf3Ve03X55wckwP57S/kN5CBXOiWn+8wDhDjhCQz8ttfyG9/Wr58uctr/fWTA3Fcv6kC83EVWChGivUX8ttfyG//oQrsQIbXbwKgKPwYAAEAkgcB0AHaAAEAAEQiAAIAAL5DAAQAAHyHAAgAAPgOARAAAPAdAiAAAOA7BEAAAMB3CIAAAIDvEAABAADfIQACAAC+QwAEAAB8hwAIAAD4TqHMfGn79u323Xff2dGjR618+fLWoEEDK1KkSPanDgAAIJEB0LZt2+yVV16xWbNm2ffff2+hD5EvXLiwXXTRRXbXXXfZH//4RytYkIIlAACQd8UUqQwYMMCaNGliW7dutVGjRtnatWvdo+Z//fVX+/HHH+3jjz+2tm3b2mOPPWaNGze2ZcuW5XzKAQAAcrIEqESJErZlyxYrV65cqs8qVKhgl156qXsNHz7c5syZYzt27LCWLVtmNk0AAACJD4BGjx4d8wI7deqUlfQAAADkuLgb66SkpLjGzx41hh4/frzNnTs3u9MGAACQN3qBXXPNNfaHP/zB7r77btu/f7+1atXKTj31VNuzZ489//zz9qc//SlnUoqYKUBdv369ZSa4VWP36tWrW7FixeL+ft26da148eJxfw9ZQ377C/kNJCgAWrFihY0bN879P3v2bKtYsaKtXLnS3nnnHdcImgAo8XRybNGiRa7/7vLly6158+a5/rt+R377C/kNJCgA0t1HyZIl3f+ffPKJKw1St/cLLrjAVYdl1pgxY2zYsGE2cOBAV6XmWbx4sT388MO2ZMkSO+WUU6xp06auui2tO5gTJ07YiBEjbMaMGa6HWuXKle3222+3Rx55xAoUKGB+oDs1nazitW7dOuvRo4fbdvXq1cvU7yL3kd/+Qn4DCQqAzj33XHv//fetW7duLhAZPHiwm757924rVapUphKhbvOTJk1yXehDKfhRo2oFRi+99JIVKlTIVq9ene44Q08//bQbr2jatGlugMavv/7aevXqZaVLl3bd+f1AxdRZuVPTyZE7vfyD/PYX8htIUACkaq5bbrnFBT4dOnSw1q1bB0uDmjVrFncCDh8+bN27d7fJkye7MYZC6TcUtDz00EPBaXXq1El3eV9++aVrp9SlSxf3XvXdf/3rX23p0qVxpw0AACSnuHuBXXfdde5RGCpZ0Zg/HgVDXtugePTr188FKx07dgybrhIlVXtpnKE2bdq4tkbt27e3RYsWpbs8zTt//nzbuHGje68SI32nc+fOaX7n+PHjdvDgwbAXAABIXpl6FlilSpXcK9T5558f93L0WA01qo42crQGXhS15xk7dqxr+zN9+nQXaH3zzTdWq1atqMtUaZECGNVXq82Q2gQ9+eSTrpQpvXGORo4cGXf6AQCATwKgY8eOufY4n332mSulOXnyZNjnCmhiodGi1eB53rx5VrRo0VSfe8vt27eva8MjqmJT6c6UKVPSHJzxrbfespkzZ9qbb77p2gCtWrXKBg0a5BpD9+zZM+p31MZoyJAhwfcKoKpUqRLTegAAAB8EQL1793btfVQVplKfzPasUi8GBVChjfFUWrNw4UKbMGGCbdiwwU2rX79+qgZ8qoJLy9ChQ10p0E033eTeN2rUyPVOU8CUVgCkJ9nzNHsAAPwj7gDoo48+cg8/vfDCC7P0w6rKWrNmTdg0lfSo6urBBx+0GjVquFIbLxDyqG1Peu151E0/speYqsIiS6oAAIB/xR0AnXXWWcFxgLJCy2jYsGGqh67qgavedJXm6AGrehK92gCpa7sGAdMAjKGBlLrk9+/f373v2rWra/NTtWpVVwWmQRo1QvUdd9yR5TQDAACfBkDPPfecK6GZOHGiVatWzXKS2u6ozZG6w+/bt88FQmozVLNmzeA8mzdvdo/h8Kh90qOPPmr33HOPq2JTKZLaEan7PgAAQKYCoPPOO88FJaqi0oBceg5YKAUqmbVgwYJU09SeJ3QcoEh6tk1kyZJGkg4dTRoAACBLAdDNN99sP/zwgz311FNubB6/PF4CAAD4OADSSMt6RIWqowAAAHwxErR6aaWkpORMagAAAPJiAKSntt93332uvc7evXt5hAQAAEj+KjA9nd3rfh4qEAi49kAazBAAACCpAiA9AgMAAMBXAZCeyA4AAJD0bYDSe/ZWNOomDwAAkK8DoJYtW7rRlJctW5bmPAcOHLDJkye7x1i888472ZlGAACA3K8CW7t2rXu+1mWXXWZFixa1Fi1auEdM6P9ffvnFff7f//7XPdn9mWeesSuvvDJ7UwkAAJDbJUB6QKkeKLpr1y6bMGGC1apVyz1/a9OmTe7z7t272/Lly90AiQQ/AAAgqRpBFytWzK677jr3AgAA8M1AiAAAAPkdARAAAPAdAiAAAOA7BEAAAMB34g6Ajhw5kjMpAQAAyKsBUMWKFe2OO+6wRYsW5UyKAAAA8loANGPGDNu3b59deumlVrt2bRszZozt3LkzZ1IHAACQFwKga6+91t5//333vK+7777b3nzzTatWrZpdddVV9u6779rvv/+eE+kEAABIfCPo8uXL25AhQ+w///mPGyX6008/dQMk6hEZjz32mB09ejT7UgkAAJCokaBD/fTTTzZt2jR7/fXX7bvvvnPBT+/eve3777+3p59+2r766iv75JNPsjOtAAAAiQmAVM01depUmzt3rtWvX9/uuece69Gjh5UpUyY4T5s2baxevXrZk0IAAIBEB0C9evWym266yb744gtr2bJl1HlUDfbwww9nR/oAAAASHwDpifDFixfP8KGpw4cPz0q6AAAA8k4AFBr8HDt2zH799dewz0uVKpU9KQMAAMhLI0H379/fKlSoYCVKlLDTTz897AUAAJB0AdADDzxg//rXv+yVV16xIkWK2KuvvmojR4507X6mT5+eM6kEAABIZBXYhx9+6AKdiy++2DWIvuiii+zcc891gyHOnDnTunfvnp3pAwAASHwJkB6DUaNGjWB7H72Xtm3b2sKFC7M/hQAAAIkOgBT8bN261f1ft25de+utt4IlQ6FjAcVLzxQrUKCADRo0KGz64sWL3XPH1N5IAVe7du0sJSUlzeVUr17dLSfy1a9fv0ynDQAAJJdMjQO0evVqa9++vT300EPWtWtXmzBhgv3222/ukRiZsWzZMps0aZI1btw4VfDTqVMnGzZsmL300ktWqFAh99sFCxZMd1knTpwIvv/mm2/ssssus+uvvz5TaQMAAMkn7gBo8ODBwf87duxo69evt+XLl7t2QJEBTCwOHz7s2g1NnjzZRo0aleq3BgwY4AItT506dTJ8RllkyVLNmjVdwAYAAJClh6F61Pj5D3/4Q6aCH1HVVJcuXVwwFWr37t22ZMkS191ej9aoWLGiC2IWLVoU87I1RtGMGTPsjjvucNVgaTl+/LgdPHgw7AUAAHxeAvTiiy/GvECV2MRq1qxZtmLFCldtFWnLli3u74gRI2zs2LHWtGlT1/usQ4cOrlqrVq1aGS7//ffft/3799vtt9+e7nyjR492XfkBAIA/xBQAjRs3LqaFqZQl1gBox44dNnDgQJs3b54VLVo01ecnT550f/v27evaHUmzZs1s/vz5NmXKFBe0ZOS1116zzp07uzGK0qM2RkOGDAm+VwlQlSpVYloPAACQpAGQ1+srO6ndkKq5mjdvHpymxsvqSq9G1Rs2bHDT9MT5UHrK/Pbt2zNc/nfffWeffvqpe3p9RjSgo14AAMAf4m4EHdq+RoGRGhird1a8VJW1Zs2asGkq6VHX+gcffNB1t1fJjRcIeTZu3OhKdTIydepU135I7YsAAABCxR25HD161O69916bNm1aMCBRsKJpZ511VliPrfSULFnSGjZsGDZNY/2UK1cuOH3o0KHuqfJNmjRxbYD0m+p1Nnv27LBAqlu3bu75ZKHVZwqAevbsmangDACA7LblP4vt+J7vcuW3fty61ZpVKmg/rpxr6/ZvzJXfLHJGNavRuLXlF3FHB2ovo7F4FixY4Mbo8agXlxosxxoAxUKDIuqJ8+oOrxGnFQipzZBKnTybN2+2PXv2hH1PVV+qJlPvLwAAEm3Tpk02c8AlNuLi3GluUc/Mrux7mtmOMWY7cuUnbcSC49Z98pqYOinlywBIPav+9re/2QUXXBDWtbxBgwYuGMkKBVWRFFClF1Rt27Yt1bTLL7/cAoFAltICAEB2OXTokE1a/qudf+twO+ecc3L89zS8y86dO11Tktxo47p161abtPxhu/rQIcsv4g6Afv75Z9e2JtKRI0fSHWsHAAA/+/FwwCo1u8LqhXT+yUlNLfekrFhhPx7+f5bUAyGed9559o9//CP43gt6Xn31VWvdOv/U/QEAAP+KuwToqaeecr2w1q5da7///ru98MIL7v8vv/zSPv/885xJJQAAQCJLgNq2bWurVq1ywU+jRo3sk08+cVVienBpixYtsjNtAAAAOSJTfcTVC0sPLwUAAPBFAHTgwAHXFV29r9T+R2MAaSyeUqVK5UwKAQAAEhkA6cnqGnAw8mnppUuXtokTJ9qNN96Y3ekDAABIXBsgPbVdj6q49tprbeXKlZaSkuJGhf7666+ta9euduutt7oBEgEAAJKmBOill15ywc/rr78eNl0PM50+fboLhtQjTE9qBwAASIoSoC+++ML69u2b5ud33323LVq0KLvSBQAAkPgASENq165dO83P9dkPP/yQXekCAABIfACkKq6iRYum+bmeNaIHlwIAACRVL7C5c+e6Hl/R7N+/P7vSBAAAkHcCoJ49e6b7OQ9DBQAASRUAnTx5MmdTAgAAkFefBQYAAJDfEQABAADfIQACAAC+QwAEAAB8hwAIAAD4DgEQAADwnZi6wZ9++ukxj/Gzb9++rKYJAAAg8QHQ+PHjg//v3bvXRo0aZVdccYW1bt3aTVu8eLEbJfrRRx/NuZQCAADkZgAUOgL0H//4R3v88cetf//+wWkDBgywCRMm2KeffmqDBw/OrrTBzDZt2mSHDh3Kld9at25d2N/cULJkSatVq1au/V5eR377C/kN5JNHYYhKep5++ulU0zt16mQPPfRQdqUL/3tyrF27dq7/bo8ePXL19zZu3MhJkvz2HfIbyGcBULly5eyDDz6w++67L2y6pukzZB/vznDGjBlWr169HP+9lJQU27Ztm1WvXt2KFSuW47+nO1GdjHPrDjivI7/9hfwG8lkANHLkSLvzzjttwYIF1qpVKzdtyZIlNmfOHJs8eXJOpNH3dHJs3rx5rvzWhRdemCu/g7SR3/5CfgP5JAC6/fbb3QH74osv2rvvvuum6f2iRYuCAREAAEBSBUCiQGfmzJnZnxoAAIC8OhDi5s2b7ZFHHrFbbrnFdu/e7ab985//tP/+97/ZnT4AAIDEB0Cff/65NWrUyLX7eeedd+zw4cNu+urVq2348OGZTsiYMWPcYIuDBg0Km64xhi699FIrUaKElSpVytq1a+ca86Xnhx9+cI3v1Chbjf2U3q+//jrTaQMAAD4PgNTVXQMhzps3zwoXLhycriDlq6++ylQili1bZpMmTbLGjRunCn7Uvf7yyy+3pUuXuvk0/lDBgmkn+5dffnEN/U499VRXKrV27Vp77rnn3GjWAAAAmWoDtGbNGnvzzTdTTa9QoYLt2bMn7q2qEqTu3bu7HmQKrEJpUEUNshg6vlCdOnXSXZ7GKKpSpYpNnTo1OO2cc86JO10AACB5xV0CVKZMGdu1a1eq6StXrrSzzjor7gT069fPunTpYh07dgybrrZFqmZTYNWmTRurWLGitW/f3vU2S8/f//53O++88+z66693323WrFmG3fOPHz9uBw8eDHsBAIDkFXcAdNNNN9mDDz5oP/74o2uzc/LkSfviiy/s/vvvt9tuuy2uZc2aNctWrFhho0ePTvXZli1b3N8RI0ZYnz593DhDGiujQ4cObgTVtOh7r7zyiht5VKNW/+lPf3KlSNOmTUvzO/r90qVLB18qQQIAAMkr7gDoqaeesrp167ogQdVX9evXdw2TVUqjnmGx2rFjhw0cONB1py9atGiqzxVYSd++fa1Xr16uJGfcuHGuCmzKlClpLlffU6CkdOo7d911lwugJk6cmOZ3hg0bZgcOHAi+lDYAAJC84m4DpIbPqlJ67LHHXHsgBUEKNOJ91svy5ctdNVfoCKgnTpywhQsXugerbtiwwU1TgBVKgy5u3749zeWeeeaZUb+jHmtpKVKkiHsBAAB/iLsESE+CP3r0qCsBuvLKK+2GG25wwY+6puuzWKkqSwHUqlWrgi+13VGDaP1fo0YNq1y5cjAQCn2wXrVq1dJcrnqAxfsdAADgLwUz8ywwb+yfUAqK9FmsSpYsaQ0bNgx7aawfjd2j/9W+aOjQoe6RG7Nnz7Zvv/3WHn30UVu/fr317t07LJBSiVFozzF1x1cVmL6jHmt/+ctfXGNrAACATFWBBQIBF5xE0kCIZcuWzdatqkERjx075oKaffv2WZMmTdz4QzVr1gwblTq0+33Lli3tvffec+16VCKlLvDjx493JUsAAABxBUAaSFCBj161a9cOC4LUdkelQnfffXeWtqqeMB9JYwCFjgMUadu2bammXXXVVe4FAACQpQBIpSgq/bnjjjtcVZe6i4c2jK5evbq1bt061sUBAADk/QCoZ8+e7q+qlNTlXY+aAAAA8EUbII3G7FH7nF9//TXscz2wFAAAIKl6gam3lx5IqsdMqNeW2gaFvgAAAJIuAFLX9H/961/ucRMaPPDVV191bYI0Zs/06dNzJpUAAACJrAL78MMPXaBz8cUXu0dUXHTRRXbuuee6gQb1WAu6mwMAgKQrAdJ4PBql2Wvvo/fStm1b9xgLAACApCsBUvCzdetWq1q1qnso6ltvvWXnn3++KxkqU6ZMzqTSxyqdVsCK7d9otjPuWDXP03pp/fB/yG9/Ib/9Q+1nZcWKFbnye3o8lcbJ0xA1xYoVy/HfW7dunSV9AKRqL436rN5gGqCwa9eu7lEUv/32mz3//PM5k0of69uisNVb2NcsCQvX6v3v+uH/kN/+Qn77hx7jJH369LFkVrJkSUvaAEiPpfB07NjRZaqe7K52QI0bN87u9PnepOW/2o2PvW716ta1ZLNu/Xqb9NwtdnWiE5KHkN/+Qn77x7XXXuv+quakePHiuVIi06NHD5sxY4bVq6dwNHeCn1q1alnSBkCR1PiZJ63nnB8PByylTG2zyk0t2aT8eNKtH/4P+e0v5Ld/nHHGGXbnnXfm+u8q+GnevHmu/27SBkDLli2zzz77zHbv3m0nT54M+4xqMAAAkHQB0FNPPWWPPPKI1alTxypWrBj2UNRoT4kHAADI9wHQCy+8YFOmTLHbb789Z1IEAACQw+Lue1mwYEG78MILcyY1AAAAeTEAUi+wP//5zzmTGgAAgLxYBXb//fdbly5drGbNmla/fn079dRTwz5/9913szN9AAAAiQ+ABgwY4HqAXXLJJVauXDkaPgMAgOQPgKZNm2bvvPOOKwUCAADwRRugsmXLuuovAAAA3wRAI0aMsOHDhwcf7AYAAJD0VWAvvviibd682Q2CqKfMRjaCzq0n3QIAAORaAOQ90A0AAMA3AZCqvwAAAHzVBggAAMAXJUDq+bVx40Y744wz7PTTT0937J99+/ZlZ/oAAACyXUwB0Lhx46xkyZLB/xn8EAAAJH0A1LNnz+D/PAUeAAD4rg3QKaecYrt37041fe/eve4zAACApAuAAoFA1OnHjx+3woULZ0eaAAAA8kY3eA2AKGr/8+qrr9ppp50W/OzEiRO2cOFCq1u3bqYTMmbMGBs2bJgNHDjQxo8fH5y+ePFie/jhh23JkiWuhKlp06Y2d+5cK1asWJojVY8cOTJsWp06dWz9+vWZThsAAPBpAKTGz14J0MSJE8Oqu1Tyo1GhNT0zli1bZpMmTbLGjRuHTVfw06lTJxcYvfTSS1aoUCFbvXq1FSyYfsFVgwYN7NNPPw2+1/cAAAA8MUcGW7dudX8vueQSe/fdd113+Oxw+PBh6969u02ePNlGjRoV9tngwYNtwIAB9tBDD4WV5mREAU+lSpWyJX0AACD5xF008tlnn4W9V/XXmjVrrFq1apkKivr162ddunSxjh07hgVAamitai8FR23atHHPH1MV25NPPmlt27ZNd5mbNm2yypUrW9GiRa1169Y2evRoq1q1aprzq/2SXp6DBw9aXuA9cDa3nq+WkpJi27Ztc6V5aVUxZqd169bl+G/kJ+S3v5DfQD4LgAYNGmSNGjWy3r17u+CnXbt2rqqqePHi9tFHH9nFF18c87JmzZrlDn5VgUXasmVLsE3P2LFjXduf6dOnW4cOHeybb76xWrVqRV1mq1at7PXXX3clRbt27XLtgS666CL3HW8so0gKkCLbDeUFXrulPn36WDJLK1/8hvz2F/IbyGcB0Ntvv209evRw/3/44YfujkIH8htvvOEaK3/xxRcxLWfHjh2uwfO8efNcSU2kkydPur99+/a1Xr16uf+bNWtm8+fPtylTprigJZrOnTsH/1ebIgVEKp166623XNAWjdoYDRkyJKwEqEqVKpZo3oNnVfKlADM37tiUtzNmzLB69epZbp0c0wpm/Yb89hfyG8hnAZDG+/Ha13z88cd2/fXXW+3ate2OO+6wF154IeblLF++3FVzNW/ePFVvsgkTJtiGDRvctPr164d9Twfu9u3bY/6dMmXKuPR9++23ac5TpEgR98pr9OiRO++8M9d/V9s4NF+QO8hvfyG/gXw2DlDFihVt7dq1LliZM2eOXXbZZcH67HgGQlRVltoOrVq1Kvg677zzXJsf/V+jRg3XjscLhDx6JplKdOJpZK32Q2eeeWYcawkAAJJZ3CVAqo664YYbXEChMYHUeFnUYDmecYBUNNqwYcOwaSVKlLBy5coFpw8dOtSGDx9uTZo0cW2Apk2b5qrbZs+eHRZIdevWzfr37+/e33///da1a1cXJO3cudN9X4HZzTffHO+qAgCAJBV3AKRGyQpQ1IZH1V9e1ZGCjNDu6tlBDa6PHTvmusPrKfMKhNRmqGbNmsF5VLqzZ8+e4Pvvv//eBTuqqitfvrzrMfbVV1+5/wEAACRTIwRed9116T4wNbMWLFiQapqCqvQCKzXCjuxZBgAAkC1tgK688ko7cOBA2KMr9u/fH3yvEpfIBssAAAD5OgDS87dCBwt86qmnXLWU5/fff0/VYBkAACBfB0CRT4FP66nwAAAASdcNHgAAwDcBkLq86xU5DQAAIGl7ganK6/bbbw92e1f39LvvvtuN3SOh7YMAAACSIgCK7ObuPQ8s1G233ZY9qQIAAMgLAdDUqVNzMh0AAAC5hkbQAADAdwiAAACA7xAAAQAA3yEAAgAAvkMABAAAfIcACAAA+A4BEAAA8B0CIAAA4DsEQAAAwHcIgAAAgO8QAAEAAN8hAAIAAL5DAAQAAHyHAAgAAPgOARAAAPAdAiAAAOA7BEAAAMB3CIAAAIDvEAABAADfIQACAAC+QwAEAAB8hwAIAAD4Tp4JgMaMGWMFChSwQYMGhU1fvHixXXrppVaiRAkrVaqUtWvXzlJSUrK0TAAA4G+FLA9YtmyZTZo0yRo3bpwq+OnUqZMNGzbMXnrpJStUqJCtXr3aChYsmOllAgAAJLwE6PDhw9a9e3ebPHmynX766WGfDR482AYMGGAPPfSQNWjQwOrUqWM33HCDFSlSJNPLBAAASHgA1K9fP+vSpYt17NgxbPru3bttyZIlVqFCBWvTpo1VrFjR2rdvb4sWLcr0MtNy/PhxO3jwYNgLAAAkr4RWgc2aNctWrFjhqqsibdmyxf0dMWKEjR071po2bWrTp0+3Dh062DfffGO1atWKe5lpGT16tI0cOTILawIAAPKThJUA7dixwwYOHGgzZ860okWLpvr85MmT7m/fvn2tV69e1qxZMxs3bpyrBpsyZUqmlpkWtTE6cOBA8KXlAACA5JWwEqDly5e7aq7mzZsHp504ccIWLlxoEyZMsA0bNrhp9evXD/tevXr1bPv27Zlapqq6TjnllFTfU5uijNoVAQCA5JGwAEhVWWvWrAmbppKeunXr2oMPPmg1atSwypUrBwMhz8aNG61z586ZWma04AcAAPhPwgKgkiVLWsOGDcOmaayfcuXKBacPHTrUhg8fbk2aNHFtgKZNm2br16+32bNnhwU93bp1s/79+8e0TAAAgDwxDlBaNIDhsWPHXHf4ffv2uUBo3rx5VrNmzeA8mzdvtj179iQ0nQAAIH/JUwHQggULUk3TGEB6pWXbtm1xLxMAAPhbwscBAgAAyG0EQAAAwHfyVBUYAAD4P0ePHnWdf+K1bt26sL/xqlu3rhUvXtySGQEQAAB5lIKfFi1aZPr7PXr0yNT3li9fHjamXjIiAAIAII9SSYyCkXilpKS4TkLVq1e3YsWKZep3kx0BEAAAeZSqoTJbEnPhhRdme3qSCY2gAQCA7xAAAQAA3yEAAgAAvkMABAAAfIcACAAA+A4BEAAA8B0CIAAA4DsEQAAAwHcIgAAAgO8QAAEAAN8hAAIAAL5DAAQAAHyHAAgAAPgOARAAAPAdAiAAAOA7BEAAAMB3CIAAAIDvEAABAADfIQACAAC+QwAEAAB8hwAIAAD4DgEQAADwnUKJTgCy39GjR239+vVxf2/dunVhf+NVt25dK168eKa+i8wjv/2F/AayR4FAIBDIpmUljYMHD1rp0qXtwIEDVqpUKctvVqxYYS1atMj1312+fLk1b94813/X78hvfyG/gey5fueZEqAxY8bYsGHDbODAgTZ+/Pjg9MWLF9vDDz9sS5YssVNOOcWaNm1qc+fOtWLFikVdziuvvOJe27Ztc+8bNGhgjz32mHXu3Nn8QndqOlnFKyUlxW236tWrp7l9M/pd5D7y21/IbyCJSoCWLVtmN9xwg4vWLrnkkmAApOCnU6dOLjDq2rWrFSpUyFavXm3XXHONFSlSJOqyPvzwQxco1apVy7Rq06ZNs2effdZWrlzpgiE/lAABAOBHB+O4fic8ADp8+LArVn355Zdt1KhRroTHC4AuuOACu+yyy+yJJ57I0m+ULVvWBUG9e/eOaX4CIAAA8p94rt8J7wXWr18/69Kli3Xs2DFs+u7du121V4UKFaxNmzZWsWJFa9++vS1atCjmZZ84ccJmzZplR44csdatW6c53/Hjx91GC30BAIDkldAASMGJGvSNHj061Wdbtmxxf0eMGGF9+vSxOXPmuJKiDh062KZNm9Jd7po1a+y0005z1WR33323vffee1a/fv0059fvK2L0XlWqVMmGtQMAAHlVwgKgHTt2uAbPM2fOtKJFi6b6/OTJk+5v3759rVevXtasWTMbN26c1alTx6ZMmZLusjXPqlWrXAnSn/70J+vZs6etXbs2zfnVxkjFZd5LaQMAAMkrYb3A1ItB1Vyh3SpVZbVw4UKbMGGCbdiwwU2LLLmpV6+ebd++Pd1lFy5c2M4991z3v7qLqpH1Cy+8YJMmTYo6v0qK0mpUDQAAkk/CAiBVZamqKpRKetTV8sEHH7QaNWpY5cqVg4GQZ+PGjXF3aVdpktr5AAAAJDQAKlmypDVs2DBsWokSJaxcuXLB6UOHDrXhw4dbkyZNXO8wdWnXCKizZ88OC6S6detm/fv3D1ZnKUCqWrWqHTp0yN58801bsGCBGzsIAAAgTw2EGM2gQYPs2LFjNnjwYNu3b58LhObNm2c1a9YMzrN582bbs2dP8L2q1W677TbbtWuXa9DcuHFjF/yoOz0AAECeGAcoL2IcIAAA8p98NQ4QAABAbiMAAgAAvkMABAAAfIcACAAA+A4BEAAA8B0CIAAA4DsEQAAAwHcIgAAAgO8QAAEAAN8hAAIAAL5DAAQAAHyHAAgAAPgOARAAAPAdAiAAAOA7BEAAAMB3CIAAAIDvEAABAADfIQACAAC+QwAEAAB8hwAIAAD4DgEQAADwHQIgAADgOwRAAADAdwiAAACA7xAAAQAA3yEAAgAAvkMABAAAfIcACAAA+A4BEAAA8B0CIAAA4Dt5JgAaM2aMFShQwAYNGhQ2ffHixXbppZdaiRIlrFSpUtauXTtLSUlJczmjR4+2li1bWsmSJa1ChQp27bXX2oYNG3JhDQAAQH6RJwKgZcuW2aRJk6xx48apgp9OnTrZ5ZdfbkuXLnXz9e/f3woWTDvZn3/+ufXr18+++uormzdvnv3222/u+0eOHMmFNQEAAPlBgUAgEEhkAg4fPmzNmze3l19+2UaNGmVNmza18ePHu88uuOACu+yyy+yJJ57I9PJ//vlnVxKkwEilR7E4ePCglS5d2g4cOOBKnQAAQN4Xz/W7kCWYSmu6dOliHTt2dAGQZ/fu3bZkyRLr3r27tWnTxjZv3mx169a1J5980tq2bRvz8rURpGzZsmnOc/z4cfeK/I42JAAAyB+863ZMZTuBBPrrX/8aaNiwYSAlJcW9b9++fWDgwIHu/8WLFyv1gbJlywamTJkSWLFiRWDQoEGBwoULBzZu3BjT8k+cOBHo0qVL4MILL0x3vuHDh7vf4sWLFy9evHhZvn/t2LEjwxghYSVAO3bssIEDB7p2OkWLFk31+cmTJ93fvn37Wq9evdz/zZo1s/nz59uUKVNcY+dYSpe++eYbW7RoUbrzDRs2zIYMGRL22/v27bNy5cq5htl+ipyrVKni8oaqv+RHfvsL+e0vfs3vQCBghw4dssqVK2c4b8ICoOXLl7tqLrX/8Zw4ccIWLlxoEyZMCPbcql+/ftj36tWrZ9u3b89w+Wos/dFHH7nlnX322enOW6RIEfcKVaZMGfMrHSx+OmD8jvz2F/LbX/yY36VLl45pvoQFQB06dLA1a9aETVNJj9r5PPjgg1ajRg0XwUV2Yd+4caN17tw53ejv3nvvtffee88WLFhg55xzTo6tAwAAyJ8SFgBpnJ6GDRuGTdNYP6p28qYPHTrUhg8fbk2aNHG9w6ZNm2br16+32bNnhwVS3bp1cyU+XrXXm2++aR988IH7jR9//DEYERYrVixX1xEAAORNCe8Flh4Ninjs2DEbPHiwa5OjQEhthmrWrBmcR73D9uzZE3z/yiuvuL8XX3xx2LKmTp1qt99+ey6mPv9RNaACzsjqQCQn8ttfyG9/Ib/zwThAAAAAvhwJGgAAIDcRAAEAAN8hAAIAAL5DAAQAAHyHACiX7N271z2Uddu2bYlOSr6nh+S+8847lleR19nnpptusueee87yMvI7+5Df/vLQQw+5cfsSJqaHaiHLBg8eHLjzzjuD77du3Rr23JLTTz890K5du8DChQtjek5ZnTp1gvPoGWrR5vntt9/c5ydPngw8+uijgUqVKgWKFi0a6NChQ8zPU/N89tlnbpllypQJPrvNs3Tp0uBvRs7/yy+/BKcpHZMmTQqcf/75gRIlSgRKly4daNGiRWDcuHGBI0eOBOd766233PoVKVLEPSvuH//4R9jvffjhh4Fzzz3XPestLyKvY8vrb775JvCHP/whUK1aNfd9fRZpzZo1bnvt378/kFclMr/feeedwGWXXeaemajpK1eujDv9XnoLFiwY+P7778M+27lzZ+CUU05xn2u+0Pkjf2v27NkuvaVKlXJ53qhRo8DIkSMDe/fuDdtXmjVr5p7pWLNmzcDUqVPDlkF+J09+79y5M3DzzTcHatWqFShQoEDwOZ+hfv7550DJkiUDmzdvDiQCJUC54OjRo/baa69Z7969U3326aef2q5du9wjOzTy9VVXXWU//fRT2DwNGjRw84S+Ip9v1qdPn1TzFCr0P8M8PfPMM/biiy/axIkTbcmSJW7AySuuuMKNsRQvDS6pUbZDad2qVq2a4XdvvfVWN7bTNddcY5999pmtWrXKHn30UTdo5SeffOLm+fLLL+3mm29222rlypV27bXXupee6ebRSOB61ss///lPy2vI69jzWttKI76PGTPGKlWqFHU5GhRV437NmDHD8qJE5/eRI0esbdu29vTTT2d5Xc466yybPn162DQNPqvpGXn44YftxhtvtJYtW7rjUserSnJWr15tb7zxhptn69at1qVLF7vkkkvc/qD9484777S5c+cGl0N+J09+Hz9+3MqXL2+PPPKIG8MvmjPOOMOdn7zx+3JdQsIun3n77bcD5cuXD5sWLar+z3/+46Z98MEHYXcNTZo0SXf5isKjRdfenbhKA5599tngNN1dqXTlr3/9a8zr4N3lP/LII4GOHTsGpx89etTd3avUIb1Sgb/97W/u/fvvvx81jd4d3w033BDo0qVL2OetWrUK9O3bN2xar169Aj169AjkNeR17HkdSqVA0UqARHeVbdu2DeRFiczvjH4zVt53ld+6Ww9Vu3btYH6nVSKwZMkS9378+PFRl+/tFw888ECgQYMGYZ/deOONgSuuuCJsGvmdHPkd63pNmzYtcPbZZwcSgRKgXPDvf//bWrRoke48KSkpwWi8cOHC2fbbuuvS40A6duwYnKbHgrRq1coWL14c9/J0Z6/18R5Iq7Y41atXD3uobTQzZ860OnXquBKBSAUKFAg+vE5pCk2r6A4hMq3nn3++S0deQ17HntexUl4vXbrU3VHmNYnM7+x29dVX2y+//BIskdBfve/atWuG+X3aaafZPffcE/Vz78HS8Rzb5Hf+z+9YKb+///77hLSpIgDKBd99950rEo2mTZs2bmdSVcXYsWPdwaXnm4XSQ2M1T+jr7rvvDpvn5ZdfDvv8vvvuc9O9Z6FVrFgxbH699z6Lhxr/qQrq9ddfd++nTJlid9xxR4bf27Rpk7soZkRpiiWt2p47duywkydPWl5CXsee17HS9vz1118ztQ7JnN/Z7dRTT7UePXq4fBb91XtNzyi/VZWZ0XxpHdsHDx50QYOH/E6O/I6Vtz21bXNbnn4WWLLQwV20aNGon/3tb3+zunXrujrUBx54wF1sIncsXUz+/ve/h00rVapU2Pvu3bu7etnMRuHx0EVw4MCB7mDR3dvbb7+dYWlMdj9xRQ+2VfCju8S89JBb8jpn8tprf5HXJGN+60L+1FNPubxWnv/+++/pfof8/h/kd/7LbwKgXKCGXipajKZKlSpWq1Yt99KOpyfb6wAKfYCdilHPPffcdH9D1QrR5vEal6ox3plnnhmcrvdNmzbN1PqoVOCuu+5yDQFVXFquXLkMv1O7dm1bv359hvMpvZENB/U+spGsHo6rO628FPwIeR17XsdKeS1qUJnXJDK/c0KjRo3cRVwdEerVq+caJavBckb5reqT3377Ld1SgbSObQUAoccx+Z0c+R2rROY3VWC5oFmzZrZ27doM57vuuutca38VgWaXc845x5145s+fH5ymImf1EGrdunWmlqk03nbbbbZgwYKYqkTklltusY0bN7peQNHuKA4cOOD+V5pC0yrz5s1LlVadWLRd8xryOva8jpXy+uyzz3YXn7wmkfmdU5TP8eb34cOH01y3/fv3x31sk9/5P79jpfxWIKUecrmNACgXqKHff//73zTvHEIbiA4YMMB1Cw4tDtTdhOrDQ1+Rd1LpLVPdTUeNGuWKXlUHrQua6l3VvTyznnjiCfv555/dusXihhtucN0mdaeh4tavv/7a1fl+9NFHrmGkukqLqlvmzJnjulSqFGHEiBFu3v79+4ctT9Uwl19+ueU15HXsea12Hrrb1Ev///DDD+7/b7/9Nl/kdaLz27t71jbzLsobNmxw77PSfkbdsJXf6qIeCzWyV5WP2qror6pRlN8Kdq6//nrXtVrU1mXLli1uHh3buoC+9dZbNnjw4LDlkd/Jkd/iHd8KmPQboWkPze+LLrooMaX5Cel75kMaEG7ixIkZdmPUIHEaSOvpp59Od/AsdW2OteukNzhexYoV3fc0ON6GDRvC5tEyevbsmeYyog12F+q9997LcHA8DVz4yiuvBFq2bBkoXry4G0BLg+O98MILrot16ECI6o6pwdLUbTZyIEQN3nXqqacGduzYEciLyOvY8jpyADnvpfR5NBCjut4vXrw4kFclMr81kGC0ZWjZHuV16DaNt0u1pscyMJ6GP9AAgBrYTgPjNW7cOPD444+H7RfaV5o2beqO7Ro1aqQaCJH8Tq78tihp1ZAXoTQQZDzDdGQnAqBc8tFHHwXq1auXZ0cvrlq1aqqTUV6l8UT69OkTyKvI6+zz8ssvu5Fv87K8nt+6SIVeIPMy8ttf+f3xxx+7bemNdJ3baASdSzQCqroPqphfjeXyEhXpquGdqkvyA3XPHjJkiOVV5HX2UduAl156yfKyvJzfam+1efNm+8c//mH5Afntr/w+cuSITZ06NTjSdW4roCgoIb8MAACQIDSCBgAAvkMABAAAfIcACAAA+A4BEAAA8B0CIAAA4DsEQAAAwHcIgAAAgO8QAAEAAN8hAAIAAOY3/x+kCVpMAN8hqgAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.title(\"Variation of Estimated Delays over all Test Cases and Runs\")\n", - "plt.boxplot(np.array(est_delays)*1000);\n", - "plt.ylabel(\"Estimated Delay (ms)\");\n", - "plt.xticks(range(1,5), [\"(REF0, MIC0)\", \"(REF0, MIC1)\", \"(REF1, MIC0)\", \"(REF1, MIC1)\"]);\n", - "plt.ylim(46.2,47.1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.15" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/batch_runs/aec/AnalysisSatellite1FixedDelay.ipynb b/batch_runs/aec/AnalysisSatellite1FixedDelay.ipynb deleted file mode 100644 index e45771c..0000000 --- a/batch_runs/aec/AnalysisSatellite1FixedDelay.ipynb +++ /dev/null @@ -1,1248 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from pathlib import Path\n", - "import sys\n", - "import os\n", - "PRJ_ROOT = \"/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3\"\n", - "sys.path.append(str(PRJ_ROOT))\n", - "from orbit.audio.utils import read_wav_wave\n", - "from orbit.audio.analysis import estimate_time_delay\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Satellite1 with \"nexus_demo_test\" Firmware" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": {}, - "outputs": [], - "source": [ - "RES_DIR = Path(\".\").parent / \"results\"/ \"test_delayConfigs_fdPipeline_Sat1\"\n", - "RUNS_PER_CASE = 5\n", - "test_cases = dict([ (int(case_dir.name.split(\"_\")[-1]),case_dir) for case_dir in RES_DIR.iterdir() if case_dir.is_dir() ])" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Case 1 - Delay: -100\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-100/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-100/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-100/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-100/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-100/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - "Case 2 - Delay: -50\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-50/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-50/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-50/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-50/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-50/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - "Case 3 - Delay: -20\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-20/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-20/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-20/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-20/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-20/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - "Case 4 - Delay: -15\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-15/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-15/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-15/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-15/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-15/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - "Case 5 - Delay: -10\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-10/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-10/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-10/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-10/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-10/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - "Case 6 - Delay: -5\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-5/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-5/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-5/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-5/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-5/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - "Case 7 - Delay: -2\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-2/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-2/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-2/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-2/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-2/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - "Case 8 - Delay: -1\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-1/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-1/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-1/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-1/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_-1/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - "Case 9 - Delay: 0\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_0/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_0/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_0/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_0/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_0/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - "Case 10 - Delay: 1\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_1/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_1/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_1/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_1/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_1/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - "Case 11 - Delay: 2\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_2/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_2/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_2/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_2/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_2/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - "Case 12 - Delay: 5\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_5/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_5/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_5/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_5/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_5/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - "Case 13 - Delay: 10\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_10/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_10/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_10/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_10/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_10/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - "Case 14 - Delay: 15\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_15/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_15/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_15/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_15/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_15/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - "Case 15 - Delay: 20\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_20/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_20/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_20/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_20/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_20/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - "Case 16 - Delay: 50\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_50/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_50/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_50/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_50/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_50/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - "Case 17 - Delay: 100\n", - " Run test_r0.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_100/test_r0.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r1.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_100/test_r1.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926838\n", - " Run test_r2.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_100/test_r2.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r3.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_100/test_r3.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n", - " Run test_r4.wav\n", - "\n", - "\n", - "Reading '/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/batch_runs/aec/results/test_delayConfigs_fdPipeline_Sat1/test_delayConfigs_fdPipeline_Sat1_delayCfg_100/test_r4.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 926497\n" - ] - } - ], - "source": [ - "#load data into channels array [test_cases * run_per_test_case, channels, samples]\n", - "channels = np.empty((0,0,0))\n", - "for idx, dealy in enumerate(sorted(test_cases)):\n", - " print(f\"Case {idx+1} - Delay: {dealy}\")\n", - " case_dir = test_cases[dealy]\n", - " runs = sorted(case_dir.glob(\"*.wav\"))\n", - " for run in runs:\n", - " print(f\" Run {run.name}\")\n", - " fs, data = read_wav_wave( run.absolute().as_posix() )\n", - " if channels.size == 0:\n", - " channels = data[:,:, None].T\n", - " else:\n", - " if channels.shape[2] > data.shape[0]:\n", - " channels = channels[:, :, :data.shape[0]]\n", - " elif channels.shape[2] < data.shape[0]:\n", - " data = data[:channels.shape[2], :]\n", - " channels = np.vstack((channels, data[:,:,None].T))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Raw Microphone Channels (4 & 5) " - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [], - "source": [ - "mic_channel_mean_var = channels[:,[4,5],:].var(axis=2).mean(axis=1).reshape(len(test_cases), RUNS_PER_CASE)\n", - "channel4 = channels[:,4,:].reshape(len(test_cases), RUNS_PER_CASE, -1)\n", - "channel4_var = channel4.var(axis=2)\n", - "channel4_var /= mic_channel_mean_var\n", - "channel5 = channels[:,5,:].reshape(len(test_cases), RUNS_PER_CASE, -1)\n", - "channel5_var = channel5.var(axis=2)\n", - "channel5_var /= mic_channel_mean_var" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.boxplot( [channel4_var.flatten(), channel5_var.flatten()] );\n", - "plt.xticks([1,2], [\"Raw-Mic 1 (ch 4)\", \"Raw-Mic 2 (ch 5)\"]);\n", - "plt.axhline(1, color='black', linestyle='--');\n", - "plt.text(2.02, 1.015, \"$(\\sigma^2_{mic_1} + \\sigma^2_{mic_2})\\; / \\; 2$\", fontsize=10, color='black');\n", - "plt.title(\"Energie Distribution of Raw-Mic Signals \\n (Normalized by Mean Energie of Mic Signals per Run)\");\n", - "plt.ylabel(\"Normalized Energy\");\n", - "plt.grid(True);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "- Recordings of Mic2 are consistently about 10% higher than Mic1\n" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.12180081843998401" - ] - }, - "execution_count": 66, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.mean((channel5_var - channel4_var/ channel4_var))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Processed Channel 1 (w/o Auto-Gain-Control)" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": {}, - "outputs": [], - "source": [ - "#calc variances per run and normalize by mean variance of mic channels\n", - "channel1 = channels[:,1,:].reshape(len(test_cases), 5, -1)\n", - "channel1_var = channel1.var(axis=2)\n", - "channel1_var /= mic_channel_mean_var" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "metadata": {}, - "outputs": [], - "source": [ - "#normalize each run by the mean over the test case\n", - "channel1_var_mean = channel1_var.mean(axis=1)\n", - "channel1_var_run_norm = channel1_var / channel1_var_mean[:,None]" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.title(\"Distribution of Processed Signal Energies (w/o AGC)\\n (Normalized by Mean Energie of Mic Signals and over Test Case Runs)\");\n", - "plt.boxplot( channel1_var_run_norm );\n", - "plt.xticks(range(1, RUNS_PER_CASE+1), [f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", - "plt.xlabel(\"Runs per Test Case (configured fixed delay)\");\n", - "plt.ylabel(\"Normalized Energy\");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "- the first run of a test case (after flashing, and hence resetting of the XMOS) has consistently a higher energy than later runs\n", - "- => algorithm needs time (samples) to estimate the parameter of the transfer channel model" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10,5))\n", - "plt.title(\"Processed Signal Energies (w/o AGC)\\n (Normalized by Mean Energie of Mic Signals)\")\n", - "plt.plot(channel1_var);\n", - "plt.grid(True)\n", - "plt.xticks( np.arange(len(test_cases)), map(str, sorted(test_cases.keys())) );\n", - "plt.legend([f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", - "plt.xlabel(\"Test Case (configured fixed delay)\");\n", - "plt.ylabel(\"Normalized Energy\");\n" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.001, 0.004)" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Take only Runs 2-5 for each test case\n", - "plt.figure(figsize=(10,5))\n", - "plt.title(\"Distribution of Energy of Runs 2-5 per Test Case (w/o AGC)\\n (Normalized by Mean Energie of Mic Signals)\");\n", - "plt.boxplot(channel1_var[:,1:].T);\n", - "plt.grid(True)\n", - "plt.xticks( np.arange(1, len(test_cases)+1), map(str, sorted(test_cases.keys())) );\n", - "plt.xlabel(\"Test Case (configured fixed delay)\");\n", - "plt.ylabel(\"Normalized Energy\");\n", - "plt.ylim(0.001,0.004)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Processed Channel 0 (with Auto-Gain-Control)" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": {}, - "outputs": [], - "source": [ - "#calc variances per run and normalize by mean variance of mic channels\n", - "channel0 = channels[:,0,:].reshape(len(test_cases), RUNS_PER_CASE, -1)\n", - "channel0_var = channel0.var(axis=2)\n", - "channel0_var /= mic_channel_mean_var" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "metadata": {}, - "outputs": [], - "source": [ - "#normalize each run by the mean over the test case\n", - "channel0_var_mean = channel0_var.mean(axis=1)\n", - "channel0_var_run_norm = channel0_var / channel0_var_mean[:,None]" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmMAAAHcCAYAAACavK1AAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAaOtJREFUeJzt3QncTOX///HLvm8l+1qEZC9CJd9CpUKbVlpoL6KUUqIiRWj5pkVkSamU9k2kkEKLylq2rCk7Ec7/8b5+3zP/M3PPzD1zu2fOfc+8no/HpPvMcq5zznXO+ZxrzeM4jmMAAADgi7z+rBYAAABCMAYAAOAjgjEAAAAfEYwBAAD4iGAMAADARwRjAAAAPiIYAwAA8BHBGAAAgI8IxgAAAHxEMJZCHnroIZMnT56krOuMM86wL9esWbPsut98882krP+aa64xNWrUMDnZ7t27TY8ePUyFChXsvundu7ffSUpJ48ePt/t39erV2fab+j2dTzmBe27p31Sm46ft1PFMtqlTp5qjjjrKnrPp5pRTTjH9+vXzOxlpj2Ash99g3FfhwoVNpUqVTIcOHcxTTz1ldu3alS3r2bBhg73p/PDDDyanyclpi8WQIUPscbz55pvNxIkTzdVXXx3xswosvce7XLly5rTTTjNvv/12UtOc6r7++mtzzjnnmMqVK9tzqlq1aub88883r776qkm1a0bo65tvvvE7iTnSoUOHzMCBA83tt99uihcvntR1f/jhh/bY6Np++PDhiJ/buXOnefTRR81JJ51kSpUqZQoVKmSqV69uunbtaj744IOw39m8ebO56667TN26dU3RokVNsWLFTLNmzcwjjzxitm/fHvjcPffcY5599lmzadOmhGwjYpM/xs/BJ4MHDzY1a9Y0//77rz1Z9HSsEpYnn3zSvPvuu6Zhw4aBzw4YMMDce++9cQc8gwYNssFA48aNY/7ep59+ahItWtpefPHFqBevnOCLL76wT5260MdC29i3b9/Atj///PPmwgsvNM8995y56aabEpza1PfGG2/Ym5f2c69evUyZMmXMqlWrzOzZs21+uuKKKwKf3bdvn8mfP3+uvmaEqlWrlsnJFFxovxcoUCCp633vvffMsmXLzA033GCSbfLkyfb6plJBXS/OOuusDJ9ZuXKlfQhfs2aN6dKli+nWrZsNGtetW2eDufPOO89MmDAh6GHvu+++M+eee64t6bvqqqtsECYLFiwwjz32mM3z7jW8U6dOpmTJkua///2vzTvwR+682qQRPcXracjVv39/e9LqBLzgggvMkiVLTJEiRex7unkk+gayd+9e+5RVsGBB46dkX7CzYsuWLeaEE06I+fMqrdGF06WLrm6gI0eOjBiMHTx40Aalfh+P3EClrDoeKiEK3V86Vl4qNUuVa4Zf9uzZY0tjYuXWACTbuHHjTOvWre35l+z9M336dDN06FCbBgVmocGYzm8FYCrl+vLLL206vfSgp6BKpXsulXrpO/ny5TPff/+9LRnzUgmbHj5cefPmNRdffLEN6PTwm6ymLghGNWUu9J///Mc88MAD9klp0qRJUduMffbZZ+bUU081pUuXtk9TderUMffdd599T6VsJ598sv3/a6+9NlCd4bbZUJuwE0880SxcuNCcfvrpNghzvxvaZsyli4I+o3ZSuhArYNQTnJeeBNXmK5T3NzNLW7g2Y7q4qWSpatWqthhf2zp8+HDjOE7Q5/Q7t912m3nnnXfs9umz9evXNx9//HFM+1837uuvv96UL1/e3jwaNWpkXnnllQxtfFTqoioEN+3xtmnSPqxXr579HW+bGm3TqFGjzHHHHWfT/uuvv9r3FaSralP7XcdbT7wK1kOtX7/epl9VI/q+SlFUlXrgwIGgC7pKYN19qaBw2LBhGUojX3vtNfvUXaJECft03aBBAzN69OjA+yrR1QW+du3adl8dffTRNj8qX3otXbrU3hDUbkefUzChkt9Qv/zyi83/egCpUqWKrXKJtYT0t99+s3kqXOCqauHM2ozpuCpdSp/2vUouw51zseYvnb+33HKLzafaHu2bSy65JFvbvoXjzUcvvPBCIB9p36hEJVQsx8atIlXAoG3S/tTxcaka7Nhjj7Xb2bx5c/PVV19luIZEajMWy/pjzWeh/vnnH3tcQoMglUg3bdo0aJmqs5U+77rnz59vl3300UcmXmqCoJJAHfPLLrvMTJs2zaYntDT3559/ttf70EDM1b59exuAu5QvdY6r9iQ0EBNdt1SL4tWuXTubH3Nrk5BUQMlYLqUiaQU9eirq2bNn2M/oxqUSNFVlqvhZF1wVec+ZM8e+rxu9lj/44IO2iF43cmnVqlXgN/766y97outioVIbncjR6KlLFye1Q1DQoqBBFzqd5G4JXixiSZuXAi4FfjNnzrSBhqqiPvnkE3P33XfbC5NKl0LbDunipxuHAgm1w7vooovM2rVr7YU8El08dQPRftQNV4GMLpgKDhXAqPpLaVcbsTvvvNPekNyqx2OOOcbEQzcYBbKh6dFTtC7a2i86prpJff755/Y46YanAEHpfPrpp+0FfNGiRYHAVdWfuhkqrfq+LtbaP+p4oVJPBSr6t02bNnb5jTfeaNtVzZ0715bKbty40R5T0Y3u8ssvN2eeeaYN1ETBn/KX9oMoLXryV0cGrVdtX1RVojTpBuDmU7dkQtXsCibVoLpz587mrbfesk/5omr6tm3b2tIC93MKJmLNV6oGmzFjhvnjjz+CAoVYqITh7LPPNhUrVrQ3fT10KH9GOqax5C8FPtqvOreUHgUjqpJW/lKArYefrNixY4fZunVr0DKdk6H5SO3k1PZUx1jvP/744zYI+f333wMlz7EeG5e2V/tE560ejkTbpHNF57DOCW2nvq9q4syOQ6zrjyWfhaMHTT2EhAZeSqtKrfQ7esjQ9UX5WqVICiR1rRH9v5ZFCpSiUUmY8rMeupQHtH2qMlVw5tLf4i0xz4yCRZ0TCmBj5VZjahubNGkS13YgmzjIkcaNG6fiHOe7776L+JlSpUo5TZo0Cfw9cOBA+x3XyJEj7d9//vlnxN/Q7+szWl+oNm3a2PfGjBkT9j29XDNnzrSfrVy5srNz587A8qlTp9rlo0ePDiyrXr26071790x/M1ra9H39juudd96xn33kkUeCPnfxxRc7efLkcVauXBlYps8VLFgwaNmPP/5olz/99NNONKNGjbKfmzRpUmDZgQMHnJYtWzrFixcP2nalr2PHjlF/z/vZ9u3b22Oll9Jz2WWX2XXdfvvt9jOrVq2yf5csWdLZsmVL0PcbN27slCtXzvnrr7+Ctilv3rxOt27dAsv0/1oWLl8dPnzY/vvwww87xYoVc5YvXx70/r333uvky5fPWbt2rf27V69eNi0HDx6MuF2NGjXKdB+ceeaZToMGDZx//vknKC2tWrVyateuHVjWu3dvu/3z588PLNN+0Hmg5do/0YwdOzZw7Nu2bes88MADzldffeUcOnQow2f1OZ1PrvPPP98pWrSos379+sCyFStWOPnz5w865+LJX3v37s2w3nnz5tnPTZgwIcO5pX9juWaEexUqVCjwOTcfHX300c7ff/8dWD59+nS7/L333ov72LjrPvXUU4Pyw/79++16Tj75ZOfff/8NLB8/frz9vPd8d9PlPd9jXX8s+Sycl156ya5z8eLFQcvda8+HH35o//7pp5/s35dcconTokWLwOcuuOCCoGtwrDZv3mzzzosvvhhYpm3q1KlT0Of026VLl87w/d27dweuFXrt2LEj8F6ZMmXs/oiX8uzNN98c9/eQPaimzMVU7RitV6WqqkRPeFlt7K6SF1UTxkrtnFQS4NLTmUoT1NA0kfT7aiNxxx13BC1XqZTuj6HVCCqtU/WMS6WHegJWqUBm69GTrEqEXCpF0HrVWFbVNFmlUk6VKuilqk+VuKkE1C11cqmExVsio9IqlTyqdE6lZN5tUqmAu++VB1R1puqWcG2K3Oo2rVclAyq5UAmL+9I+U4mQGv+6+UulH9GqgvQZlW6sWLEi7Pt///23rV699NJLbV5216USWTVa1vdUQifaDnWIUMmHS/vhyiuvjGn/XnfddbZKSiVPKrl6+OGH7XaqakslVJFom1XyqNIYVe26VHXrrR6KN395S/RUCqpt1m9qn6lEJ6tUJahj4n2Fq0ZTZwYdY5db+uymMZ5j41Ipvc5Dl0qn9Hkt97Zn1THzrjuceNafWT6LRL8loWlR6ZCur25eVwmYSvF0fdOxUemxrivKR+5+i4eq91WipnPZpWuKjtO2bdsCy1QyF66H5/333x+4Vujl7Xyi73ivwbFyz3f4g2rKXEw3/9C2LqEX25deeskW3asIXNVJqoZQgKQLQSxUPRBP43Dd2EJv8LrBJLodjNo76EYZehFSlaH7vpeq3sJdjLwXwkjr0TaG7r9I64lHixYtbBso7TNVUek33YDaK7SnnLtOtT0Kpd9Qda2CJuUXXajVjika3dB++umniFVwbmN3VUmpysgdKkJtV3TjVHWeS1V5art2/PHH2/XqPQWYbi9gVffqpqY2MXpFWp9+X9upfRQq3HZHopu4XrqZqorq9ddfN2PGjLHV+WqbFO580vpV7RuuN2KkHoqx5C/9ptt4W0GFt22jqhqzSsFqLA34Q9PoBiRuGuM5NpnlzdD9pMAss3EC41l/ZvksM6HtShVQtmzZ0gZhon8VdKkdmoJzdQJRkw0FjFkJxtTWV8dJwaAbECoAVJWpHobcnp26nrnve+ncU54NV4WpoD8rQx9pH9B43z8EY7mU2r3ogh2tu7qevPVkp3ZUakiuUgHdfNQAWqUw3ifYaL+R3SKd8LrIxZKm7BBpPaEX5WQqW7Zs2K7tyTgmXipBU4lapIEgdcMTBS4qkVOwpyd6vRRYqPTA7dCgjh9qOK/SWeU5PRyo/Z4CID0kuCW2Gg9JQVI4iRiSQcGubqJ6ab+rHZjS371796TlL41rpf2ljhK68Wv8KJ0baj+UjGFbMktjVo5NdubNeNafWT6LxG1HpwA0tP2aAi+1gVX7TAVjKo3Sw5GCPf3ttp+NNxjTw47bUSL04dVtS+YGY2rTqXNMwbo36NU56J6HoT1Q3e8osIvnQVrtSHUuwB8EY7mUGohLpIuUSyU4KhHTS71rNBCpLioK0HTjz+4nodBqAl3Y9YTrfULVE7h30EHvU7QaoLviSZsaZ6sqSU+E3tIxlXa472cH/Y5KjXSj8JaOZfd64k2TaKykUEqXLrBq+KwbpZ6a1TsrGlWvqRQtlsBQF3tVe+qlfaIndvXmUkmGe6NU1amquvXS7+rGqQbXukm6x1tVvZmtT9sZrhoq3HbHwy1FUnVvOAo6dcNTPg4Vblms1GlCwd+IESMCy3TjD3du+CGeY5NZ3tR+UmN1lzphqLQ8WslVvOuPls8icXsbqseyegJ7KchSQDNlyhQbDLlBl37XDcYUEGXWqSlcsKVt0jU8NCBWtac6e6ijh0ouVfqlKk19J9ZR8nUuzps3z3Zw8DaniEbbp211S/iRfLQZy4XUjkLtXVQlEK29jIrQQ7mDp+7fv9/+644DlF03AI1V4y0i1w1HNzlv2xrd7FXM7x1K4f33388wBEY8adMAhypZe+aZZ4KW6+lYQV2ktj3x0nrUq08ljN4bi3ouqm2HeiEmm9rk6biqNMq7rxR0qZRAaRYFj2r3pB5aassTqUREVY26mKvEK5R+X9srodUn+n335urmr9DPaB8pSHPfV6CjNlwK4MIFQ3/++Wfg/7Udyjfffvtt0Pu6UcVCPSnDcdvURaru1A1TwYDa26k3qksBRlaGNPD+bmhJrPKRd8woP8VzbKIFuip90rhWbr4RHbPMmgTEs/7M8lm0XoR6oAh3PqhKXEGT2mwq0NPwJKKgTPlQ7UO9pWJKox5+1P4vGm27vqdmJGoy4n2p97coAHTPRY2Np+t9pBkUQvOQxiTUNUHtZZcvXx62alfNIbxUZR+ttzoSj5KxHE4Xe53gupBp4D8FYmqQqydOdWGONkii2lGomrJjx4728zoJNcqyiuNVBO8GRip6V3G+SpQUAOkiFG4E71jooqXf1tOp0qthEHRR9A6/oSdVBWlq16GLjaoX1IbC2+A53rTpaVBP3ir10xO3GsArEFG1haqBQn87q1R9oJuDGsvrAqZ2L9oWdQnXtmal4Wx2eOKJJ2zAqeouDe3hDm2hqi/veFkqGdV+UdCobdGTsG4iaqeip3Ltb90QlLf0VK7t1A1Lbc4WL15st1X7V6VtOo4K+FXtrTylkk2tU4Gh+4StG4luqPoN5Q3d9PQbGurA2+BceUYlE8onKhFR3lFAqOr4H3/80X5OJQMqTVC+0dAZ7tAWbmllZtSmSHlHeUX5Qduk0lQFpxpjS8sj0T7UftMQBhqTzQ38VWWV1bGZtH+1PTpG2k/aXqUn2tAq8VwzQulG6y15jkWsxyYSBTrad6qSVT7R+a78o7HEdAwyK/2Odf2x5LNwdP1UW0ft99DR51WVrd9TEOSOMeaWjCnv6OUNxjT0ix6IVMoWqT2cxiVzh8UJR1WRGmZDAZuGB1IwqPHIVAOi/aA2v+5YgirN0nmqUjRd4701D/qOHl50LnpH4FfnAwV6uk546Z6ikjiGtfBRNvXKRDYL7aaubscVKlRw2rVrZ4eJ8A6hEGloixkzZtiu0pUqVbLf17+XX355hiEL1KX9hBNOCHTTd7uWq9t5/fr1w6Yv0tAWU6ZMcfr372+HWShSpIjtbr5mzZoM3x8xYoQdBkNd7lu3bu0sWLAgw29GS1vo0Baya9cu584777TbWaBAAdv1/YknnggM2eDS79x6660Z0hRpyI1w3dKvvfZap2zZsna/qut9uOE34h3aIrPPul3/tU3hfP7553Zfar9ryAkNx/Drr79m+JyOh4a4OOaYY+z+P/bYY+3+0DAE3n2p41irVi27jdpWdb0fPny4HcpD3nzzTTsch461PlOtWjXnxhtvdDZu3Bj4HQ010rx5c9s9X+mqW7eu8+ijjwZ+w/Xbb7/ZNCmP69gpb5x33nl2HV4aYkB5pHDhwvYzGobDHbIis6EtlDc1XMhxxx1n06LfUN66//77M5xPoUNbuOeThhrQtuo3NCxC37597e9kJX9t27YtkI80LEqHDh2cpUuXZvhcdgxt4T13ouWjcNsdy7HJbCiep556ym6X8pvyw5w5c5xmzZo5Z599dtShLWJdf6z5LJxp06bZ4W/cIVu87r77bpumYcOGBS3XeaHlSptLxyyzfKhhakK/F+qhhx6yn9FwKK7t27c7gwcPtvlPeUV5sGrVqnboHu9QJF4bNmyw18Pjjz/e5lENzaJ9rv3iHQpDQ7tUrFjRGTBgQJS9hETLo//4GQwCQG6lat+sDKmQ7tS+UL11VdLjnZrHDyrlVMmaSu1UHZhuVP2uoTFUQ6HqTfiDNmMAEANV/XopAFN7s3DTgsEEdUoIfeZX21JVceeEfae2e6qiVJWoGv6nG7WJU7UpgZi/KBkDgBjoZqU2dGq3pPZxmuZHDcQ1VVK4IQrw/+f01DRImuZH7eHUbmns2LG2XaHaXTLJPUADfgCIiToOqPGzetNqZgo1glaHCAKx6NSYXRPOa8gGlYapgb3GonvssccIxID/oWQMAADAR7QZAwAA8BHBGAAAQKoHYxoxW20DjmQS5dxEgxpqgEANbOjSwId+TMKqdXoH/YzUwFaf0yCJSA/qxeZXTzbNkarBKDXgpvJdIqb/iSXfZze/zvGceIyzSh0kMptAHMjJTjnllJinrkp6MKZR0TVHlnfePl0kdOEKN+q1G8wMHz48GclDkm9WmjYndOoj2blzp50/UZ/JbORsvymNkV6ajgThadoajeek46yhBDQCvTvtVSg9zLj7VLMDhFJzVzUM1/sazT5RNNzBwIED7Wj7Sqt6BCqY1CwA3umRgFivEd6XHoaP1N69e+31Nd7f0mwGmohdc3RqxgHlb43Wr+mScsocqZGuCXrlz5/fzlqgIF4zEuQEmjlB1zZ19MlRvSk1VYimmpg7d27Y9zUnobo3u9M1pKoBAwaYe++91+9k5AjqiaZeaaFPD9OmTTO5Sbt27WyvsFCaPDin09Q+fvjuu+/s3KUaXDPWyadVgvbqq68GpvByaW5ATYmj/BRuTDBdqI+U5hnU9DeaXkiTemtaHwVnGuhVaerSpYupVKmS/SznOLz0oBE6tpqmHQpdnh2TcysYGzRokP3/WEtDdS5qyiTlZ++USZpKSj1dNZWeX9eJzGhcOE1tpjHsNF2VgjQ9sGk+3mhTBCaDpl0rWbKknXowdIotX4OxcePG2TmvVHQXSst1YVYm0hxbiaIDpmpSlcj4RTeG7Lg5pAJdAMIFY7q5aY61t956y+QGCrp0EcsJo5lr0vV4LkJ+DSmg+VFFc2DGk180d6aGRvCeQ8ovuoFs3bo1w3ey64Ks0ck1jpjmCtQo5aHXFe9k95zj6UlzVIYr3Q29NihoUDCWE64ZKvXSg4QGvFX+VsmY16OPPur7zAjRaB5eTUIvmiNXc+Vq8FrFESp595PiDE36ruBbsU2sTRcSHp3oYqYJYsMlSJMqazBATdSrgQAz8/vvv9uBAzVOjYpUFeB98MEHYds/vfbaa/ZJVUWY+qyqwFSUWbx4cTuxqqo19P96X0WKoomQlVadWKpS1cXeS2PkqEhXk9bqu4p+lSkymyw3XHsSpSVSsbW3rYsGlVQViSbbVgmAqmUUxGi5l/7WvtQUI9qvF1xwgS01iHdakPvuu89UqFDB7gP9hrc6UenQxLV//vlnhu9q0mndYHWDyoxuaiox9U5mrCJdTYIeesOLdz8o+NcxLFeunP2cpjnR4Jyh1C5FeUBPU82bN7c3bw3mqRMoO+kpVdVbv/76q53IXHlRee7xxx/P8ja61bgKEOrXr28/q3ZYogmzNQm4qgE1ebeqG7RP9B1V/3vTFfoEHev6I1HApOBI69bFUTcdb9WB1qfSJdHE3EqTzoPMqImDqjd1I3MpCFIbx0j5JVybMaVFk6irJEvbpydrTfrtDahCaYoY0QThoZRndA2I1mZMJXR33HGH3R/ueal0hKbP/a4mkdY+0bmkCcSvvfZaW+qRlTwejiZyV55RPtSE0rqhhV7nQmn/PPjgg/bYKk26Nmiy6pkzZ0ZsXqIJ3DURuNKnY61SmHD3Bp0b2o/6V5Nbx0MlD27+1zG99dZbg6rWdI7oOh26/9w8peucrnneCdbdSbh1rPRgqBJQL/ceonyhhwR97sorrzRH8iA1atQoux3aD+XLlzc33nij2bZtW9DnVFqlycKVj3R+Ke9ed911gf2u6764N//M2kw+//zzNh8++eSTGQIxUTp0/3RNnz7d7g/33NGxVem2d/+5s1JcdNFFdt9qe3QNuuyyy8yOHTuCPjdp0qTAtUL388suuyxs05VYuRO2u+drtDaToe0S48m3uk/pnNR26TMaCFolYd5rq1trojbyus/FKqGPcTrYCnw0C30kancxcuRIm3GilY6pbrtVq1b2xNLFTe02XnnlFXtx00VZUb6XMoqe/hU86WbilgQo8yiAUtWDboi6oemk1Qmotm06sTRf2pgxY2wVlAZ2VMZ3g0FdQBQQapnSpEytm59utm51RSx0woVW0+iGqvToIuueqNo+BQwKdlScrYBR+2v58uU2LS49HSiD6+ak/aTARidPPPQ0pEypOm+VYOgioTQqQ+mkufrqq22x6+uvvx7Upsu9MeokjKVEQvtemVk3AbcYV7+pi1y4NMezH3RT0oVNn1cphQL9W265xf6GLtZeuvHpCUY3aAUJL7/8sj1RdZHQb2RGgWe4UhndoL0lT7qwasBQ5Ss9tWlfaR8rqFdejHcbRcd36tSp9jjoAq2Li843BXw6hv3797d5+qWXXgpbjXck+zgcVRPoIqUL2NChQ+25MXr0aDNnzhz75K3gQudXnTp17AXPrWbQhS8z2jadhypNdfeXbpy6wOsirhKzzKhtl4Ju3ay1fboBaX/pWOiaEqmk0G3nqiBdN6d4G+grP+k46dzRw6OqVqOdl8of2i/ah3pA1fHT9UBP/VnJ414q6dC1U3le113lXwXv8+fPjxjUih5klQ4FMD179rS1GRpBX8GBOmep/ZyXzmt9Rtc47S9dZ5X3df3Uw5yo+kvXCwWS2lYF2+5NLha6Xyjw0PVJAfWyZcvsftHNU3lO6+natat90NYDu67ZLh1v7TMdG5UMiaoOdQ3QNmlf6zP6PVWNK/96b94HDx60n9N7uoErsM0q7SP33NGxWbVqlXnmmWfsOt3t0LW4ffv2NuBSNbjOJd383WYdWq60aj/oPqh9LQ0bNoy4Xt1rdU1XXoiF0qjrc58+fey/uv4oQFfeeOKJJwL3Ae0X3W9Vna+ATOeYmiLpvFMg795nHnjgAZvXdd/Sw/3TTz9t7wvutSJebjCkB4ysiiXfKs8qQNf2KU/o2OghUXGON4+4Vb46hk2aNIktAYmchfzzzz+3s8+Hm1W+TZs2Tv369e3/Dxo0yH5u4cKF9m/Neq+/n3jiicDne/fubZd99dVXgWW7du1yatas6dSoUcPOPC8zZ860nzv22GOdvXv3Bq2ze/fu9r0hQ4YElm3bts0pUqSIkydPHue1114LLF+6dKn97MCBAwPL/vnnn8B6XEproUKFnMGDBwct03fHjRsXWKbfiba7V6xY4ZQqVcpp166dc/DgQbts4sSJTt68eYO2WcaMGWN/a86cOfbvH374wf59yy23BH3uiiuuyLAN4bj7rHLlys7OnTsDy6dOnWqXjx49OrCsZcuWTosWLYK+P23aNPs5/U407j74888/nbvuusupVatW4L2TTz7Zufbaa+3/6zO33npr4L1Y94OEHnPp0KGDzQ9e1atXt9+dPXt2YNmWLVvssezbt2/U7XDTGOk1ZcqUoHyuZRMmTAgs279/v1OhQgXnoosuytI26m999pdffgn67O23327z8ffffx9Y9tdffzlHHXWU/Y7ypTddemVl/aEOHDjglCtXzjnxxBOdffv2BZa///779rsPPvhgYJnOCS377rvvIv5euM8+88wzTokSJQLH95JLLnHatm0bOJYdO3YM+m5ovu/WrZvdvnDrPXz4cMQ0aH116tSxv6f1XHPNNc7YsWOdzZs3Z/hs6Dmu65n+1rXLS78Rmj73u9ddd13QZ7t06eIcffTRGdIUSx4PPcadOnUKXHPjoeuR8qyXrpvly5cPSq973VN6//7778Dy6dOnZ7gPNG7c2KlYsaKzffv2wLJPP/00sJ+j0XlasGBBp3379kHXY+URff/ll18OHFdd07znmfe65p77uo+ULl3a6dmzZ9DnNm3aZK/J3uXuPeTee+914qVrmjd/6FzT35MnTw763Mcffxy0/O233870nNE1NZZrvatMmTJOo0aNYk57uDx34403OkWLFrX3RdF1R2l44403Iv7O6tWrnXz58jmPPvpo0PLFixc7+fPnz7A80jVBsYW2ed26dc6bb77pHHPMMfbarb8j5X/vMfTmsVjzrfJ8aFwSjfLozTff7MQqodWUetqJJVrVU5o+4zZADEcT8urJ1tuIVxG6nnIVFatkyktPOYr8w1E07lIUrqd1lSJ465q1TO8pKnaphMFtd6YSNm2f0qDPxlLNGq3NgZ5otA/09O8+ranaRyUUeopXCYz7UhWFuNUE2jeiJyuv3r17x5UOlQSq2N2lpyYVw7q/735GT9Le4mCV5qlKSyWEsdKTuEqm9CTr/hvp6TzW/SDeY66SE31O6dJxDC0q11O5W7ztPmHqWHqPeTQqntZTUehLpVNeyiPediIqhVFe9q4nnm0UbZPSH1qyqhIkb0mFqgBiqUaJd/2hVSh6QlTpjLdkVCVA+r3QpgRZoXNTVX56ytbTq/6NVprjpRIjleyp57bbzsQrWmmX8pPy+9133x0oIVBJqs4LPR1Hq8J1q461X7z0vUhCe+Iqf+o6oxIIb5pizeNeup6p6UK4KsNodD1ySw61L9VcQ6VD2pfhrnsqkfJe891zzM3vGzdutKXtuka7pSVu1U5ong5HHcJUCqPrm7cdsErtVCrt5jcdV5WI6frlnQBcpfBqKuDeS3TOquRGJX/evK/tbtGiRdi8r1KoI6VzTtuv7fauV6Uquma463VLipTn1aEkOyg/ea/1mfHmOZ1/SqeOq0oQ3eYm7rH85JNPwlYNi0rzlId0Pnu3uUKFCnZasWjXGS+ViOp6rfuO7lO6f6u0L9aS1XAyy7faBzoP1BQqtBo5HP1WuJqTSJLS2jSzGZd0EHViqb2KiinDBW+qf9WJEcrtiaL31e7A5VYthtLNwq1f965fBzH0oqzl3p2uTKSqF7VVUHGyt75c1aZZpYuIghv1OPX+jurflyxZkiG9oY2hte26KIVW+SiwiEfoHHvaH2o/5K0PV4bVsVIApmJqXfx1kVB7tXiqcFR0qxu1ioZ1sdHJ6N74Q8W6H9xiYeWjefPmZbggKK3ei786kIRS3ovlRBPlmVh6BIbLW1qPqoiyso2R8rfygYKxUDqGmYl3/aHrjZTfdIzDDUsRL6VL+1r5RcdV516sVSyqBtHNx3t9iIfyjKos9NK2zpgxw1ZPqTpJ76ldXjjueRl6rKIdj9A86V4LlSfd9mnx5HEvVY0rkNGDgNKgqi8FtOHaw4VSk5ARI0bYG683IAiXD6Ntgze/hJvTM5YH20j5TTdKdxJ37/VKzS10o9a2KihTcOZWRbl5XyJdf7ztAkVVw0dy03dpvTpebrOUSOecAm1Vj6mwQs0G1A6qc+fOdntiaYIQaZsUVMVKVXOqplf1pPfBQNwHAOUFVWOqHZruDwpmVJWuB1E3T2qbFQ9Ems+1wP+qAzOj6md1oNK61bxEPT+zui9izbf6fVVh9+3b17apU7MDtTtWAYXuX6G0nfHcExMajLmBRSw3N7ftmDKcTp4jFalUzC11inW5N5DUpMCq61bDSbVJU6mDLrYKThSoZYWCO5WGqb1XaNsL/abaFSlzh6OngmRTBlUGdIMxtblR6UBWegjpYqK2DnpC00UzUm/XWPeDAtozzzzTBgD6rJbrAq2Lr/JW6DGK5Zhnh1jWE++xjpS/syon5rVw+UUPLmpEq7ZjWWlbcqTUhkznv0qydePXeRApGEtEXok3j4c+uKptlR6eVGqnXst6sNR5HK1WQtcmta9SAKASQgUPSqfaenlLyGPdhmTSDVNtedRuT/lHbcVUwqrrjcvdZ2o3Fu6mGtpD1ltDciS0Xu1L5aFw3Acjd0Bu9cZU+lXypDyo4FjLVIoWL+UflU6qhDGzntUqNVRAqABObT310K9CDQXNCvC9eU5pUl5Rg3+1C1RtjfKJ0qkAVp/V9qjNZ7h8UjzGbdEDhVvKrXypUk4dX+Vv9ze0nnB5LrTTQTz5Vvd6lbCrpF3HQfGAtk9BamjbMO03tefNEcGY20tDpUiZcUvH1DDT7XEVehHUjg7lFpF6B5RNFJ0QqoJS49Uj2emur776ynYw0HaHq0pSpldPTV18o0XY2nZlcl0YvU+L4fZXNO4TojcTqgoxtCGongRURafqDl1IlAljafAeSiePbgSqtggdeycr+0EXKgWGegr2PuXEWvTtp1i3MRrlAx2vUOGWZef63XNP+S20dEHLsuvcVACkEg1d2FXVFCvd1HQj0RhE2flQon0W7Tfd81LXP29JQCzHI1F5XNU5CkT00o1YDZTVoFodPiJ1vtF1T4Gnqpi8eUOlc1nh5ofQ602s1yxvflO6XNoe7evQ0mpViemhVyU6yjcKzrxDLbk1CgqMYh37LjtovSqpVMlkLA9XSrNeOl4qIdY9Q6MGqNlNvOesAgqVrCogV/VsNKqWU1W5jr8a2bsi3df1UKeXStJU26PtU4c4PbRom3VfUSlado3HmO9/Dwa6N6u02h3rT+douCYnRzoTkLZBpWN6KQ+rEEVBqB5aXOq4oPwYzxhyCW0zpnp5PbmpTUksFJToaTfcQGnqRqyeO8pA3rZW6pmlkyuWtgbZcdBDI23V+2dl5F8FILpIKKJ3e6OE0vv67XDjvejpTtsvbg+z0F5l8ZYwqseYt+haF2Gl0/19l/52x3VR77CsjpujTK006kTSk04kse4H98nGe4xUjK2hAHK6WLcxGvVk0vnh7U6t9j2Rnryza/16QtWNTBdcbxsqPf2q6jPeXr2R6IlXJal6YAs3c0ckKsXQ07MCmXDXomglNgpQw7X70AVd7VSjNQXQ8RCVPnmp51hWHUked9vwulQiouumfitaW6Rw61Q7Ou+1OB5qb6cbmKo+vW3c1HYrtO1vOAqYlHZd77xp0kOyfi80vynwVL7U+lQiGDoOlY6TgnXVfITbD+GG8skOSodKaVTLEkpt8txhOlSzFJpH3VoU93xze3TGOmq+2ibqOCigUG/pcFWkbolvuOOvQCM0XyvYVbq9FJTp/HPTqeBfv6eS2NBtchwnQx6NlapudQ/R/cQdXkn3FxXWeI+fzmdV82eFmgSEDt2kdahmJ7TtqAayF41skGPajKkERePHxFJ/qtIxVVeGKzJXtOt2bVfRp6oIdXIpOld0n4wBXVU9p0BR3ZC1k9X1Xzc679NZrLQNyiQax0lPN14qidJL3eFVvK4TR0++esLQyasMpuUqJtWNUCemnm50cuhipLSpXUu8T+DapwoOtX0amkAZW21LVDUUWq+vIQX0FKITK7Mnq2h0vDMT635QGxhdpHWjVgmK2ocouFCgoKAyu+ki5n0acqk9gRrlxiPWbYxGeUnp0brVSNwd2kIlKArKop1/R7J+5QcF5so3qs5QfnCHttCDktoTZpdwpeax0I1W1SZKnzt0h/KEHqbUpi1SlacCBJUAqe2LSiUUEOppW+1UdAGONpaTGmKrrY/OI91k3KEt3JtfVkpAjySP67uqhtOxVR5VoKxzWMFLtMbcuu6pVEQlk/qsrrkKvBXIeRvGx0MPYPotXW9U5ab86Y6BltlvqqRTJXm6T2jIGB0blZLp+qehVUIfDjW0kq5jGlpFx8xbRSkKxBTk6xzQZ3Vt0zo0XIE6A2h/aT9lN+VFHUPtCz1A6fjoXFJpi/Klzh+1i9R9Ttum/a+bvx6YdcyVbhVSiErWdDxU8qcSJ13L1UYyUjtJlRrpvqzv6/7hHYFf1Y+617rtT3U/0ed17um+pXyrmozQYEpVdRpqR50mlAYFZvqc7hE6D0TpV5Cn46e2yHpIUt5btWqVTY/OTdUWZYWq0LVudbLRdUz5SlX5CrbV6UYBpvKt8lhou7dY6LxVzYGCaO1rVV8rzbrWKc+EXjd03Y15WAtxEmzRokUZhqQIHdrCS91H1Z04XBfS3377zbn44ottN+TChQs7zZs3t93nww3TEK57rbq0FitWLMPySGkJ7TKvLrwa9kBdsjUcRuvWrZ158+Zl6EIby9AW7pAH4V7e7skaNmDYsGE2feq6qy7JzZo1s8OB7NixI/A5DSlwxx132O652sbzzz/fdvONZ2gLDcnQv39/O0yBtk/bvmbNmrDf+fbbb+131L08Vt6hLaIJHdoinv3w7rvvOg0bNrT5Q0Oe6Dvq6h46tEO44RCidYcOl8ZIL+/3I+Wt0O7V8WxjuP3jUvfy0047zX6/SpUqztChQ52nnnrKfkdd9aNtZ6zrj+T11193mjRpYr+r4TSuvPJK548//gj6TFaHtogmlqEtRHlZQ1y43eA1FIT2Y+iwDV6///67HZrjlFNOseeFut/r+1rfF198EfTZcMPX7Nmzx65D+6N48eJO586dnWXLltnPPfbYY5meG+4+8ObdWPN46DF+/vnnndNPP91eI7T9xx13nHP33Xdnemw1RISGA9J+1vd0jHXdjTREQLiu/+GOx1tvveXUq1fP/uYJJ5xgh8gJd15EoqEs6tat6xQoUMAOs6FhBHT/COf++++3afAOpxPuOqghQnT/0b7V/tEwJAsWLMj0HpKVoS1cL7zwgj3PdM3V8C0NGjRw+vXr52zYsCFwD7388sudatWq2X2lfHjeeecFpUvmzp1rf0dDKsQ6zIXWceeddzrHH3+83WYNVaHf0BAT3nyhoW10DiiNlSpVsun75JNPgoY00rmioU603/RbyvMafkbDUITSsT/11FPtvtSrbt26dv/o3MjqNUHDnGjdernDQ02aNMme59onGk5Fac5qvt26datNo9KqNCufaJgnDZUSmg7FCAMGDHDiked/K0woRZMaEDVauyDkLiru1ROVqjb1RImcS9X/GpxYJQ6RGqkieVQKoidmlWIeyejtAHIeNe5Xe2i14VZVcKySMlmjqghUfHqkDeeQc6iYXFU27mjPyBnUvstL1WN6CFJ1EIGY/8dDVG2pZhXextAAUoOabKi6Np5ALGnjjGl8sGjzvyH3UCNoNbJVxwl3GinkHGrnocasahOltgxq1Kz2EeqCjeTT2GRqzKueXmpjok4NeqltTE4YLgRA9spqx5akVFMidahBtm7yahSpEpd4RnFG4mmid/WC1UjramirBslqgJ7MLvsIbsirhuZ6gFE1sRr1qlpfjclDx68CkL4IxgAAAHyUlDZjAAAACI9gDAAAwEe+NlrQQHt6uRNRazA2TY8TOuK7lwbDU2NkfUdTjKjngjvwXSw0PcmGDRtsW6esTjsDAACSy3EcO+ithspKxkDvSeX4SIMXfvDBB87y5cvtYG/33XefHcDv559/Dvt5DTyXL18+5/HHH3d+/fVXO6iaPr948eKY1+kOhMqLFy9evHjxyn2vdevWOakmxzXg1zQOmqtR0xeE0jQWmiPv/fffDyzTFCMafFTTHMRC0wVp6pN169bZ6SQAAEDOt3PnTjskjObg1PSJqSTH9K3WPHiqglSw5c6JFW78jj59+gQt0xALGvE2Es1F5p3E050IW4EYwRgAALlLnhRsYuR7pasm29ZI7oUKFbKTe2riTU3CGc6mTZvsBLde+lvLI9EkrIqg3RcDLQIAgJzE92CsTp06dq62+fPnm5tvvtnODK8BErOLZodX1aT7UvUkAABATuF7NWXBggVNrVq17P83a9bMfPfdd2b06NF2YuNQFSpUsKO/e+lvLY9EJW56AQAA5ES+l4yFG3rC28bLS23JZsyYkWG6kUhtzAAAAHI6X0vGVIWoMcU0X5sa1r/66qtm1qxZ5pNPPrHvd+vWzVSuXNm2+5JevXqZNm3amBEjRpiOHTua1157zSxYsMBOWg0AAJAb+RqMbdmyxQZcGzdutI3rGzZsaAOxdu3a2ffXrl0bNLBbq1atbMA2YMAAOyGyBn1VT8oTTzzRx60AAADIuhw3zlgyxilR4KfG/AxtAQBA7rAzhe/fOa7NGAAAQDohGAMAAPARwRgAAICPCMYAAAB8RDAGAADgI4IxAACAdJ4OCcbs3bvXLF26NK7v7Nu3z6xevdrUqFHDFClSJObv1a1b1xQtWjQLqQQAAIlAMJYDKBDTvJzJsHDhQtO0adOkrAsAAGSOYCwHUGmVgqR4LFmyxFx11VVm0qRJpl69enGtCwAA5BwEYzmAqg2zWlqlQIySLgAAci8a8AMAAPiIYAwAAMBHBGMAAAA+IhgDAADwEcEYAACAjwjGAAAAfEQwBgAA4COCMQAAAB8RjAEAAPiIYAwAAMBHBGMAAAA+IhgDAADwEcEYAACAjwjGAAAAfEQwBgAA4COCMQAAAB8RjAEAAPiIYAwAAMBHBGMAAAA+IhgDAADwEcEYAACAjwjGAAAAfEQwBgAA4COCMQAAAB8RjAEAAPiIYAwAAMBHBGMAAAA+IhgDAADwEcEYAACAjwjGAAAAfEQwBgAA4COCMQAAAB8RjAEAAPgov58rB3K7Q4cOma+++sps3LjRVKxY0Zx22mkmX758ficLAJCLEIwlyIoVK8yuXbsS9vtLliwJ+jdRSpQoYWrXrp3QdeRW06ZNM3379jWrV68OLKtRo4YZMWKEufDCC31NGwAg9yAYS1AgdvzxxydlXVdddVXC17F8+XICsjCB2MUXX2zOO+88M2XKFHPiiSean3/+2QwZMsQuf/PNNwnIAAAxyeM4jmPSyM6dO02pUqXMjh07TMmSJROyjkWLFplmzZqZSZMmmXr16iVkHfv27bMlMiqJKVKkSELWoVI3BXsLFy40TZs2Tcg6cmvVZK1atUyDBg3MO++8Y/Lm/f9NLw8fPmw6d+5sAzMF5VRZAkDuuX/7hZKxBFIglsggpnXr1gn7bUSmNmIKhFUi5g3ERH/379/ftGrVyn7ujDPO8C2dAIDcgd6UQJzUWF9UNRmOu9z9HAAA0RCMAXFSr0lRVWQ47nL3cwAAREMwBsRJw1eorZ4a66uNmJf+Hjp0qKlZs6b9HAAAmSEYA+KkRvkavuL999+3jfXnzZtnhzHRv/pby4cPH07jfQBATGjAD2SBhq3Q8BUaZ0yN9V0qEWNYCwBArikZU3XOySefbAcWLVeunC1VWLZsWdTvjB8/3uTJkyfoVbhw4aSlGXAp4Fq5cqWZOXOmefXVV+2/Gs6CQAwAkGtKxr788ktz66232oDs4MGD5r777jPt27c3v/76qylWrFjE72l8EW/QpoAM8IOqIhm+AgCQa4Oxjz/+OEOpl0rINMjo6aefHvF7Cr4qVKiQhBQCAACkUQN+jaorRx11VNTP7d6921SvXt1UrVrVdOrUyfzyyy8RP7t//347aq/3BQAAkFPkmGBMQwL07t3bjiofaTBNqVOnjnn55ZfN9OnT7XRD+p4aUP/xxx8R26Vp+gT3pQAOAAAgp8gxwZjajmmwzNdeey3q51q2bGm6detmGjdubNq0aWMnbD7mmGPM888/H/bzmppGJW7ua926dQnaAgAAgFw6tMVtt91mx2aaPXu2qVKlSlzfLVCggGnSpInt1RZOoUKF7AsAACAn8rVkzHEcG4i9/fbb5osvvrBjNMXr0KFDZvHixUw9AwAAcqX8fldNanwmtf/SWGObNm2yy9W2q0iRIvb/VSVZuXJl2/ZLBg8ebE455RRTq1Yts337dvPEE0+YNWvWmB49evi5KQAAALkvGHvuuefsv6HjNI0bN85cc8019v/Xrl1r8ub9/wV427ZtMz179rSBW5kyZUyzZs3M3LlzzQknnJDk1AMAAOTyYEzVlJmZNWtW0N8jR460LwAAgFSQY3pTAgAApCOCMQAAAB8RjAEAAPiIYAwAAMBHBGMAAAA+IhgDAADwEcEYAACAjwjGAAAAfEQwBgAA4COCMQAAAB8RjAEAAPiIYAwAAMBHBGMAAAA+IhgDAADwEcEYAACAjwjGAAAAfEQwBgAA4COCMQAAAB8RjAEAAPiIYAwAAMBHBGMAAAA+IhgDAADwEcEYAACAjwjGAAAAfEQwBgAA4KP8fq48lVUonscU2b7cmA25N95V+rUdAAAgcQjGEuTGZgVNvdk3GjPb5Fr1/rcdAAAgcQjGEuT5hQdM1wfHm3p165rcasnSpeb5EVeYC/xOCAAAKYxgLEE27XbMvtLHG1Opscmt9m06bLcDAAAkTu5t0AQAAJACCMYAAAB8RDAGAADgI4IxAAAAHxGMAQAA+IhgDAAAwEcEYwAAAD4iGAMAAPARwRgAAICPCMYAAAB8RDAGAADgI4IxAAAAHxGMAQAA+IhgDAAAwEcEYwAAAD4iGAMAAPARwRgAAEBuCsbGjRtn9u7dm5jUAAAApJm4g7F7773XVKhQwVx//fVm7ty5iUkVAABAmog7GFu/fr155ZVXzNatW80ZZ5xh6tata4YNG2Y2bdqUmBQCAACksLiDsfz585suXbqY6dOnm3Xr1pmePXuayZMnm2rVqpkLLrjALj98+HBiUgsAAJBijqgBf/ny5c2pp55qWrZsafLmzWsWL15sunfvbo477jgza9as7EslAABAispSMLZ582YzfPhwU79+fVtVuXPnTvP++++bVatW2WrMSy+91AZlAAAAyOZg7PzzzzdVq1Y148ePt1WUCr6mTJlizjrrLPt+sWLFTN++fW0VZmaGDh1qTj75ZFOiRAlTrlw507lzZ7Ns2bJMv/fGG2/YtmqFCxc2DRo0MB9++GG8mwEAAJA7gzEFTV9++aX5+eefTe/evc1RRx2V4TPHHHOMLSXLjH7n1ltvNd9884357LPPzL///mvat29v9uzZE/E76sF5+eWX296c33//vQ3g9FJ6AAAAcps8juM4Jof4888/A8He6aefHvYzXbt2tcGaqkVdp5xyimncuLEZM2ZMputQlWqpUqXMjh07TMmSJU0iLFq0yDRr1swsXLjQNG3a1ORWqbIdAIDcb2cS7t9+yR/vF5566qmwy/PkyWOrDWvVqmUDqXz58sWdGO1gCVfa5po3b57p06dP0LIOHTqYd955J+71AQAA5LpgbOTIkbYES6PwlylTxi7btm2bKVq0qClevLjZsmWLOfbYY83MmTNt27JYaTgMVXu2bt3anHjiiRE/p/HM1IvTS39HGuds//799uWNrAEAAHJtm7EhQ4bYRvcrVqwwf/31l30tX77ctGjRwowePdqsXbvWjtB/5513xvW7ajumdl+vvfaayU7qJKBiTfcVT4AIAACQ44KxAQMG2NIxjSXmUtWkhrro37+/qVKlinn88cfNnDlzYv7N2267zbYBU2mavh+NAj0NreGlv7U8HKVJ1Z/uK5ZengAAADk2GNu4caM5ePBghuVa5lYVVqpUyezatSvT31LfAQVib7/9tvniiy9MzZo1M/2OBpidMWNG0DL1xNTycAoVKmQb+nlfAAAAuTYYa9u2rbnxxhvtsBIu/f/NN99s/vOf/9i/NRJ/LIGVqiYnTZpkXn31VTvWmII5vfbt2xf4TLdu3WzplqtXr17m448/NiNGjDBLly41Dz30kFmwYIEN6gAAAFI+GBs7dqzt7aghD1TqpNdJJ51kl+k9UUN+BUuZee6552zVoUbxr1ixYuD1+uuvBz6jNmgqjXO1atXKBm8vvPCCadSokXnzzTdtT8pojf4BAABSojelqhUPHDhg3n33XRskuaPl16lTx768pWex/l5mws1xeckll9gXAABA2gVjaqz/yy+/ZAjAAAAAkOBqyrx585ratWvb4SwAAADgQ5uxxx57zNx9993MBQkAAODHCPzq3ajR99V4vmDBgqZIkSJB7//999/ZkS4AAIC0EHcwNmrUqMSkBAAAIA3FHYx17949MSkBAABIQ3G3GZPffvvNTot0+eWX24nB5aOPPrK9LAEAAJDAYOzLL780DRo0MPPnzzfTpk0zu3fvtst//PFHM3DgwHh/DgAAIK3FHYzde++95pFHHrHzQaoBv0tTIX3zzTfZnT4AAICUFncwpnknu3TpkmF5uXLlzNatW7MrXQAAAGkh7mCsdOnSQXNFeicLr1y5cnalCwAAIC3EHYxddtll5p577jGbNm0yefLkMYcPHzZz5swxd911lx2DDAAAAAkMxoYMGWLq1q1rqlatahvvn3DCCeb00083rVq1sj0sAQAAkMBxxtRo/8UXXzQPPPCAnRJJAVmTJk3snJUAAABIcDDmqlatmn0BAAAgicHYoUOHzPjx482MGTPsgK9qM+b1xRdfHEFyAAAA0kvcwVivXr1sMNaxY0dz4okn2kb8AAAASFIw9tprr5mpU6eac889N4urBAAAQJZ7U6oBf61ateL9GgAAALIjGOvbt68ZPXq0cRwn3q8CAADgSKspv/76azNz5kzz0Ucfmfr165sCBQoEva/JwwEAAJCgYEzTIYWbmxIAAABJCMbGjRuXhdUAAADgiNqMaUyxaA4ePGi+/fbbWH8OAAAA8QRjFStWDArIGjRoYNatWxf4+6+//jItW7bM/hQCAACksJiDsdDek6tXrzb//vtv1M8AAAAgm4e2iIbR+AEAAHwMxgAAAJCg3pQq9dq1a5cpXLiwrY7U37t37zY7d+6077v/AgAAIAHBmAKw448/PujvJk2aBP1NNSUAAECCgjGNug8AAACfgrE2bdpk86oBAABAA34AAAAfEYwBAAD4iGAMAADARwRjAAAAPiIYAwAAyOm9KS+88MKYf3DatGlHkh4AAIC0ElPJWKlSpQKvkiVLmhkzZpgFCxYE3l+4cKFdpvcBAACQzSVj48aNC/z/PffcYy699FIzZswYky9fPrvs0KFD5pZbbrGBGgAAABLYZuzll182d911VyAQE/1/nz597HsAAABIYDB28OBBs3Tp0gzLtezw4cPx/hwAAEBai3k6JNe1115rrr/+evPbb7+Z5s2b22Xz5883jz32mH0PAAAACQzGhg8fbipUqGBGjBhhNm7caJdVrFjR3H333aZv377x/hwAAEBaizsYy5s3r+nXr5997dy50y6j4T4AAEASB31Vu7HPP//cTJkyxeTJk8cu27Bhg9m9e3cWkwEAAJCe4i4ZW7NmjTn77LPN2rVrzf79+027du1MiRIlzLBhw+zfGvICAAAACSoZ69WrlznppJPMtm3bTJEiRQLLu3TpYgd+BQAAQAJLxr766iszd+5cU7BgwaDlNWrUMOvXr4/35wAAANJa3CVjGktMI+6H+uOPP2x1JQAAABIYjLVv396MGjUq8Lca8Kvh/sCBA825554b788BAACktbirKTW+WIcOHcwJJ5xg/vnnH3PFFVeYFStWmLJly9relQAAAEhgMFalShXz448/mtdff93+q1Ixjch/5ZVXBjXoBwAAQILGGcufP78Nvh5//HHz3//+1/To0SNLgdjs2bPN+eefbypVqmSrO995552on581a5b9XOhr06ZNWdkMAACA3BeM5cuXz7Rt29b8/fffQcs3b95s34vHnj17TKNGjcyzzz4b1/eWLVtmp2JyX+XKlYvr+wAAALm2mtJxHDu4q8Yae++990z9+vWD3ovHOeecY1/xUvBVunTpuL8HAACQ60vGVC341ltv2erFli1bmunTpwe9lwyNGze2k5Nr9P85c+YkZZ0AAAA5IhhT6ZeqI0ePHm2GDx9uunbtah555JG4S8WyQgGYpltSMKhX1apVzRlnnGEWLVoU8TsqxdOE5t4XAABArq2m9LrhhhtM7dq1zSWXXGIb4ydanTp17MvVqlUr89tvv5mRI0eaiRMnhv3O0KFDzaBBgxKeNgAAgKSUjFWvXj2oob4a83/zzTdm3bp1xg/Nmzc3K1eujPh+//79zY4dOwIvv9IJAACQLSVjq1atyrCsVq1a5vvvv7c9KpPthx9+sNWXkRQqVMi+AAAAUq6a0qtw4cK21CweGjDWW6qlQE/B1VFHHWWqVatmS7U0+fiECRPs+5qGqWbNmrYHp0b/f+mll8wXX3xhPv300+zaDAAAgJwXjCk4Wr58uZ3yqEyZMlF7TYaOPxbNggULbDWnq0+fPvbf7t27m/Hjx9sxxNauXRt4/8CBA6Zv3742QCtatKhp2LCh+fzzz4N+AwAAIOWCMTWQL1GihP1/7yThR0o9IaP1wlRA5tWvXz/7AgAASKtgTCVV4f4fAAAASQjG4hmbq2TJkkeSHgAAgLQSUzCmqYcyG11f1Y36zKFDh7IrbQAAACkvpmBs5syZiU8JAABAGoopGGvTpk3iUwIAAJCGsjzO2N69e+2wExpuwkvDTQAAACBBwdiff/5prr32WvPRRx+FfZ82YwAAAAmcm7J3795m+/btZv78+aZIkSLm448/Nq+88oqdMPzdd9+N9+cAAADSWtwlY5p+aPr06eakk04yefPmtVMgtWvXzg5pMXToUNOxY8fEpBQAACAFxV0ytmfPHlOuXDn7/5oaSdWW0qBBA7No0aLsTyEAAEAKizsYq1Onjlm2bJn9/0aNGpnnn3/ezhU5ZswYU7FixUSkEQAAIGXFXU3Zq1cvO4G3DBw40Jx99tlm8uTJpmDBghnmkgQAAEA2B2NXXXVV4P+bNWtm1qxZY5YuXWqqVatmypYtG+/PAQAApLUsjzPmKlq0qGnatGn2pAYAACDNxB2MaQ7KN998006RtGXLFnP48OGg96dNm5ad6QMAAEhp+bMyzpga7bdt29aUL18+0wnEAQAAkI3B2MSJE23p17nnnhvvVwEAAHCkQ1uUKlXKHHvssfF+DQAAANkRjD300ENm0KBBZt++ffF+FQAAAEdaTXnppZeaKVOm2FH4a9SoYQoUKBD0PqPwAwAAJDAY6969u1m4cKEdb4wG/AAAAEkOxj744APzySefmFNPPfUIVw0AAIC424xVrVrVlCxZMjGpAQAASDNxB2MjRoww/fr1M6tXr05MigAAANJIluam3Lt3rznuuOPsVEihDfj//vvv7EwfAABASos7GBs1alRiUgIAAJCG4grG/v33X/Pll1+aBx54wNSsWTNxqQIAAEgTcbUZU5XkW2+9lbjUAAAApJm4qyk7d+5s3nnnHXPnnXcmJkUAACAitdteunRpXN/RrDnqeKfB2osUKRLz9+rWrWvbhyOHBWO1a9c2gwcPNnPmzDHNmjUzxYoVC3r/jjvuyM70AQAADwViuv8mgwZ5b9q0aVLWlc7iDsbGjh1rSpcubQ+QXl4ajZ9gDACAxFFpVej9NzNLliyxoyFMmjTJ1KtXL651IQcGY6tWrUpMSgAAQKZUbZjV0ioFYpR0pcCgr16O49gXAAAAkhiMTZgwwTRo0MA2AtSrYcOGZuLEiVlMAgAAQPqKu5ryySeftOOM3XbbbaZ169Z22ddff21uuukms3XrVnpZAgAAJDIYe/rpp81zzz1nunXrFlh2wQUXmPr165uHHnqIYAwAACCRwdjGjRtNq1atMizXMr2H/xsDRhYtWpSwdWR1zJh4e98AAIAcFozVqlXLTJ061dx3331By19//XU7Bhn+bwwY6dmzp0kFJUqU8DsJAACkrLiDsUGDBpmuXbua2bNnB9qMaQDYGTNm2CAN/zdLQaJHLs7qmDFZCcQIsgEAyEHB2EUXXWTmz59vRo4caadFEgUD3377rWnSpEki0pjrlC1b1vTo0SMp62LMGAAA0iwYE03DoBIZAAAA+DjoKwAAAJJUMpY3b14792Q0ev/gwYNHmCQAAID0EXMw9vbbb0d8b968eeapp54yhw8fzq50AQAApIWYg7FOnTplWLZs2TJz7733mvfee89ceeWVZvDgwdmdPgAAgJSWpTZjGzZssGNoaX5KVUv+8MMP5pVXXjHVq1fP/hQCAACksLiCsR07dph77rnHDvz6yy+/2LHFVCp24oknJi6FAAAAKSzmasrHH3/cDBs2zFSoUMFMmTIlbLUlAAAAEhSMqW2Y5kBUqZiqJPUKZ9q0aXEmAQAAIH3FHIx169Yt06EtAAAAkKBgbPz48XH+NAAAADLDCPwAAAA+IhgDAABI12Bs9uzZ5vzzzzeVKlWy7dHeeeedTL8za9Ys07RpU1OoUCHbmYDqUwAAkBZtxhJhz549plGjRua6664zF154YaafX7VqlenYsaO56aabzOTJk+04Zz169DAVK1Y0HTp0SEqaASTP3r17zdKlS2P+/L59+8zq1atNjRo1bO/veNStW9cULVo0C6lMDxwLIEWDsXPOOce+YjVmzBhTs2ZNM2LECPt3vXr1zNdff21GjhxJMAakIN38mzVrlpR1LVy40Ja6IzyOBZCiwVi8NCH5WWedFbRMQVjv3r19SxNST7JKAHj6j20f6cYcqyVLlpirrrrKTJo0yT6sxbsuRMaxSKwVK1aYXbt2Jez3dTy8/yZCiRIlTO3atRP2+6ksVwVjmzZtMuXLlw9apr937txpb4jhboT79++3L5c+C+SEEgCe/jOnYDUr+0g3f/Zt9uJYJDYQO/7445OyLgXIibR8+XICslQPxrJi6NChZtCgQX4nA7lIskoA0vHpH0BGbolYVkoRk9GGL57rYCJL91JZrgrGNC/m5s2bg5bp75IlS0bMXP379zd9+vQJKhmrWrVqwtOK9Cn+z6p4qkJTpQogFapiUuVYIOdJdCli69atE/bbSKNgrGXLlubDDz8MWvbZZ5/Z5ZFoCAy9kJ5Sqfg/t1cBcCwAIAcGY7t37zYrV64MGrrihx9+MEcddZSpVq2aLdVav369mTBhgn1fQ1o888wzpl+/fnY4jC+++MJMnTrVfPDBByadGowfSQlAujUaT4Xi/1SpAuBYAEAODMYWLFhg2rZtG/jbrU7s3r27Hcx148aNZu3atYH3NayFAq8777zTjB492lSpUsW89NJLuX5YiyNpMB5vCUC6Nhqn+D/n4FikR7UxVcZALgnGzjjjDOM4TsT3w42ur+98//33Jp0bjB/pcAoAkKxqY6qMgRRrM5aqstplnBIAADm12pgqYyB2BGMAkMYSWW3MAyOQCyYKBwAASHcEYwAAAD4iGAMAAPARwRgAAICPCMYAAAB8RDAGAADgI4IxAAAAHxGMAQAA+IhgDAAAwEcEYwAAAD4iGAMAAPARwRgAAICPCMYAAAB8RDAGAADgI4IxAAAAHxGMAQAA+IhgDAAAwEcEYwAAAD4iGAMAAPARwRgAAICP8vu5ciAZKhTPY4psX27Mhtz77KH0azsAAKmHYAwp78ZmBU292TcaM9vkWvX+tx0AgNRDMIaU9/zCA6brg+NNvbp1TW61ZOlS8/yIK8wFficEAJDtCMaQ8jbtdsy+0scbU6mxya32bTpstyO3o8oYADIiGAOQNFQZA0BGBGMAkoYqYwDIiGAMQNJQZQwAGeXehhsAAAApgGAMAADARwRjAAAAPiIYAwAA8BHBGAAAgI8IxgAAAHzE0BYAkKZy+4wIzIaAVEEwBgBpKrfPiMBsCEgVBGMAkKZy+4wIzIaAVEEwhpS2d+9e+++iRYsSto59+/aZ1atXmxo1apgiRYokZB1LlixJyO8iveX2GRGYDQGpgmAMKW3p0qX23549e5pUUKJECb+TAADIZgRjSGmdO3e2/9atW9cULVo0YaVWV111lZk0aZKpV0+tWBIXiNWuXTthvw8A8AfBGFJa2bJlTY8ePZKyLgViTZs2Tcq6AACpg2AMAACfMcxIeiMYAwDAZwwzkt4IxgAA8BnDjKQ3gjEAAHzGMCPpLXdWTgMAAKQIgjEAAAAfEYwBAAD4iGAMAADARwRjAAAAPiIYAwAA8BHBGAAAQLoHY88++6ypUaOGKVy4sGnRooX59ttvI352/PjxJk+ePEEvfQ8AACA38j0Ye/31102fPn3MwIEDzaJFi0yjRo1Mhw4dzJYtWyJ+p2TJkmbjxo2B15o1a5KaZgAAgJQJxp588knTs2dPc+2115oTTjjBjBkzxhQtWtS8/PLLEb+j0rAKFSoEXuXLl09qmgEAAFJiOqQDBw6YhQsXmv79+weW5c2b15x11llm3rx5Eb+3e/duU716dXP48GHTtGlTM2TIEFO/fv2wn92/f799uXbu3JnNWwEgFnv37rX/qgQ8Ufbt22dWr15tmz0UKVIkIetYsmRJQn4XQPryNRjbunWrOXToUIaSLf29dOnSsN+pU6eOLTVr2LCh2bFjhxk+fLhp1aqV+eWXX0yVKlUyfH7o0KFm0KBBCdsGALFxz2mVhKeCEiVKmNws0cExgTGQwhOFt2zZ0r5cCsTq1atnnn/+efPwww9n+LxK3dQmzVsyVrVq1aSlF8D/6dy5s/23bt26tilCom7OV111lZk0aZK9LiQyEKtdu7bJzVIpOCYw9j84JjDOxcFY2bJlTb58+czmzZuDlutvtQWLRYECBUyTJk3MypUrw75fqFAh+wLgL53vPXr0SMq6FIipCQP8C44JjGNHYAxfg7GCBQuaZs2amRkzZgQuDGoHpr9vu+22mH5D1ZyLFy825557boJTCwCpI1nBMYFx+pQap0JgnLbVlKpC7N69uznppJNM8+bNzahRo8yePXts70rp1q2bqVy5sm37JYMHDzannHKKqVWrltm+fbt54okn7NAWyXriBgAgO1FqDN+Dsa5du5o///zTPPjgg2bTpk2mcePG5uOPPw406l+7dq3tYenatm2bLcrVZ8uUKWNL1ubOnWuHxQAAAMhtfA/GRFWSkaolZ82aFfT3yJEj7QsAACAV+D7oKwAAQDrLESVjQE7rZh5pnLtoXbrj7dqdyMa6AIDcg2AMCKFATG0R46WeSvHQ7BM0pAUAEIwBYUqsFCglejBFrQcAAIIxIISqDuMtsWrdunXC0gMASG004AcAAPARJWMATLp3phA6VADwC8EYAJPunSmEDhUA/EIwBsCke2cKd10A4AeCMQA5Fp0pAKQDGvADAAD4iGAMAADARwRjAAAAPiIYAwAA8BHBGAAAgI/oTQkAQAoPhnwkAyIzGHJyEIwBAJAGgyFnZUBkBkNODoIxAABSeDDkIxkQmcGQk4NgDACAFB8MWRgQOeeiAT8AAICPCMYAAAB8RDAGAADgI4IxAAAAH9GAHwCQ7WNbZXVcK2FsK6QbgjEAQMLGtop3XCthbCukG4IxAEC2j22V1XGt3HUB6SSP4ziOSSM7d+40pUqVMjt27DAlS5b0OzkAACDN79804AcAAPARwRgAAICPCMYAAAB8RDAGAADgI4IxAAAAHxGMAQAA+IhgDAAAwEcEYwAAAD4iGAMAAPARwRgAAICPCMYAAAB8RDAGAADgI4IxAAAAH+U3acZxnMDs7wAAIHfY+b/7tnsfTyVpF4zt2rXL/lu1alW/kwIAALJwHy9VqpRJJXmcVAwxozh8+LDZsGGDKVGihMmTJ4/JzU8ICijXrVtnSpYs6Xdy0hrHIufgWOQcHIucJRWOh+M4NhCrVKmSyZs3tVpZpV3JmA5glSpVTKrQSZVbT6xUw7HIOTgWOQfHImfJ7cejVIqViLlSK7QEAADIZQjGAAAAfEQwlksVKlTIDBw40P4Lf3Escg6ORc7BschZOB45W9o14AcAAMhJKBkDAADwEcEYAACAjwjGAAAAfEQwlmTXXHONHWxWrwIFCpiaNWuafv36mX/++Sfh6542bZpp3769Ofroo+36f/jhB5PO/DoW//77r7nnnntMgwYNTLFixewAht26dbODEacrP8+Lhx56yNStW9ceizJlypizzjrLzJ8/36QzP4+H10033WTTMGrUKJOu/DwW3nW7r7PPPjvh601HaTfoa06gzDxu3Dh7U164cKHp3r27zeTDhg1L6Hr37NljTj31VHPppZeanj17JnRduYUfx2Lv3r1m0aJF5oEHHjCNGjUy27ZtM7169TIXXHCBWbBggUlXfp0Xxx9/vHnmmWfMsccea/bt22dGjhxpH1pWrlxpjjnmGJOu/Doerrffftt888039mEl3fl5LNx1u+iNmRiUjPlAmblChQp2aorOnTvbJ/HPPvss8H6NGjUyPAk2btzYPsG7dCK+9NJLpkuXLqZo0aKmdu3a5t1334263quvvto8+OCDdn3w71hoBGmtQ0FxnTp1zCmnnGKDAV1k165da9KVX+fFFVdcYdelYKx+/frmySeftFPH/PTTTyad+XU8ZP369eb22283kydPtqVB6c7PY+Gu232p9BjZj2DMZz///LOZO3euKViwYNzfHTRokL2h66Zx7rnnmiuvvNL8/fffCUlnOvDzWOzYscNeLEuXLh33ulORX8fiwIED5oUXXrABs0otkfzjofmD9eB499132+AY/p4bs2bNMuXKlbMPjjfffLP566+/jiD1iIRgzAfvv/++KV68uClcuLBtN7RlyxZ74clKff7ll19uatWqZYYMGWJ2795tvv3224SkOVXlhGOhth9qQ6bv5+Y543LzsfCuW9WUKnUoW7asSWd+HQ9VveXPn9/ccccdR7gFqcOvY6EqygkTJpgZM2bY4/Lll1+ac845xxw6dOgItwihaDPmg7Zt25rnnnvOtuHShV8Xnosuuiju32nYsGHg/9X4WDdynaTIPcdCbUD0pKqxl5WOdObnsdC61aFl69at5sUXX7THRI34VSKQrvw4HqqqHz16tG1TqZJi+HtuXHbZZYH/VxCo7x933HG2tOzMM8/MwpYgEkrGfKCTQE8mqgZ5+eWX7UV/7Nixgffz5s1rb86hN+1QoW0pdPFSET9yx7FwA7E1a9bYkph0LhXz+1i461b7Pa1TNzvvutORH8fjq6++ssFBtWrV7DHQS+dH3759bbuodJVT7hlqV6kSY3VuQfYiGPOZTqL77rvPDBgwwPbkEvXg2rhxY+Azaky8atUqH1OZHpJ5LNxAbMWKFebzzz+3w40g55wXukHt378/Ib+dGyXreKitmNozqZTSfak3parkPvnkkyPejlTg57nxxx9/2DZjFStWzPbfTncEYznAJZdcYvLly2eeffZZ+/d//vMfM3HiRPuUuHjxYtuNWe8fKTXU1MXt119/tX8vW7bM/r1p06Yj/u1UkYxjoUDs4osvtsNYqLeY2l/oGOilBuRI3rFQtY9ubBpCQSUwqia77rrrbG8+rR/JPR56KDnxxBODXirNUS8+NSBH8o6F2pMpCNa5sXr1atturFOnTraErkOHDtm0JXARjOUAKoq/7bbbzOOPP25vDv379zdt2rQx5513nunYsaPtyqx6+iOlbsxNmjSxv+m2B9DfY8aMyYatSA3JOBa60etY6ClT3c/1lOm+1EsKyTsWumEtXbrUtr/ReGPnn3++ffLXTY2efP5cp5Bzzg2VUmr8Q50b119/vWnWrJk9NxhrLPvlcUIrmgEAAJA0lIwBAAD4iGAMAADARwRjAAAAPiIYAwAA8BHBGAAAgI8IxgAAAHxEMAYAAOAjgjEAAAAfEYwByLEeeOABc8MNNyR1nXv37rUj8mvidk2kvH37djtJ9ahRo0xONX78eFO6dOmon9FMA5oIvXDhwnbmB01xo+3TlGiJlJV9d80119hR5GM1a9aswLHKLpqZRDMyAMlAMAbf6IKrC6hemn+uZs2apl+/fuaff/4x6eChhx4KbH+k15H8tm64sdCkwvfff7+pW7euvVFrHsCzzjrLTJs2zfg5QYfm6hw9erRNWzK98sordsoXTU2lyZdLlSplvvvuu6QHhdlt4MCBplixYnZOWs0zWLVqVbt9mv8RGWmO0kWLFtm8ACRa/oSvAYji7LPPNuPGjbOTZ2uSZk1wqyBk2LBhJpVoMnBtV968///556677jI33XRT4O+TTz7Z3vB79uyZtHSpJOHUU081O3bsMI888ohNg+a9+/LLL21grAmIMytxSZSXXnrJtGrVylSvXj2p6/3tt99MvXr1goKUY445xpc8kt3bpXkLvftTgTfCK1iwoLniiivMU089ZU477TS/k4MUR8kYfKUJZ3VD0FO6qiVUIvPZZ59FreJQiY9Kfly6genG3aVLF1O0aFFTu3ZtOxG3a9u2bebKK6+0N9QiRYrY9xUARnLGGWfYSXj1UqlI2bJlbXWZt5Ro//79NpiqXLmyLW1o0aKFrSoJrTZSOk444QS7nWvXrg1aT/Hixe22uy9NzFuiRInA3wpQL730Uvs7Rx11lOnUqZOtWnJpfc2bN7fr12dat25t1qxZY9c9aNAg8+OPPwZK2LQsnPvuu8/+5vz5820grLRqUmAFhKq+Uhpl4sSJ5qSTTgqkTzepLVu2xLyP161bF3VbwnnttdcyVBMdPnzYTo5cq1Ytu0+rVatmHn300cD7ixcvtgGk0nD00Ufb4Hb37t0Zqr+GDx9uJ2bXZ2699Va7r91jP2LECDN79my73/R3uHyoKj8FsSpJ1D77/PPP7effeeediNVm2p9a5m53pDySWd5yv6ttV35Xvtfk5tFovXrYGTx4sP1/nT+h1ZR6r1KlSkG/peCtbdu2dr/L119/bQMT7V+ds3fccYedqNqlPKFjpvdV0j158mQTSxDap08fuy90PPQQEFoiq/UPHTrU/qZ+u1GjRubNN9+M+Jvahssvv9zuQ+2jBg0amClTpgTenzBhgl2X9rWX8sbVV18d+FvbouOzb9++TLcDOCKaKBzwQ/fu3Z1OnToF/l68eLFToUIFp0WLFoFl1atXd0aOHBn0vUaNGjkDBw4M/K1sXKVKFefVV191VqxY4dxxxx1O8eLFnb/++su+f+uttzqNGzd2vvvuO2fVqlXOZ5995rz77rsR09WmTRv7/V69ejlLly51Jk2a5BQtWtR54YUXAp/p0aOH06pVK2f27NnOypUrnSeeeMIpVKiQs3z5cvv+uHHjnAIFCtjPzJkzx/7Onj17ou4P77YeOHDAqVevnnPdddc5P/30k/Prr786V1xxhVOnTh1n//79zr///uuUKlXKueuuu+z69f748eOdNWvWOHv37nX69u3r1K9f39m4caN9aVmoQ4cOOWXKlHFuuOEGJzNjx451PvzwQ+e3335z5s2b57Rs2dI555xzAu9H28eZbUs4OnZ58uRxvvnmm6Dl/fr1s2nWtmq7v/rqK+fFF1+07+3evdupWLGic+GFF9q8NGPGDKdmzZo2n7n0/yVLlnRuuukmZ8mSJc57770XdGy13p49e9rt035z85D32Bw8eNCmvV27ds4PP/xg09C8eXObD99++237mZkzZ9q/t23bFlj3999/b5dp/0TLI5nlLe2TvHnzOsOGDXOWLVvmjB492ildurTND5FoW5QflC/0/7t27bLpUHqULne7tN2dO3e2fz/zzDP2d5WnRGkpVqyY3Q9Ki9LcpEkT55prrgmsR3lC56fyyIIFC+x2FClSJMM57KXt0DF96623bN64/vrrnRIlSgRdGx555BGnbt26zscff2zzoPad9smsWbPC7u8//vjD7jdtmz7/1FNPOfny5XPmz59v39f5oP01derUwDo2b97s5M+f3/niiy8Cy3Q8tK/1+0AiEYzBN7ox6gKpC7wurLqY6sL35ptvxh2MDRgwIPC3bspa9tFHH9m/zz//fOfaa6+NOV0KxhQ8HD58OLDsnnvusctENyele/369UHfO/PMM53+/fvb/9fNQmnQzTpW3m2dOHGiveF706DARTe2Tz75xAYJ+n33ZhRK+0f7KRrdfPQbTz75pBMvBV36rm7qme3jzLYlHDdwWbt2bWDZzp07bT5xg69QCqh0U9fxd33wwQc2T23atCmQ57SfFXi4LrnkEqdr166BvxWEKw9EOjbKV7ppK6hxKfjMSjAWmkdiyVuXX365c+655wa9r/RHC8bCnTehwZgocFEgpPyu4zN58uTAewqSQgN3BaLav/v27bOBoX7v22+/DbyvgFfLogVjCqAff/zxwN960NDDlRuM/fPPPzZgnjt3btD3lB7ti0j7O1THjh1tMOq6+eabgx4oRowY4Rx77LFB+VTc4B9IJNqMwVeqAnnuuedsVcfIkSNteyX1ZItXw4YNA/+vqh31hHOr0W6++Wb7m2qM2759e1sVobZI0ajXmbcBfcuWLW31lapUVBWmf1Wd56UqD1V9eNuceNMVD1Uxrly50lYLeqlzg9r+aDtU5dahQwfTrl07W72rakBVvcUqnsb5quJS1ZbSpSpJt9pK1WqqYou2jzPblnDcaiFVA7qWLFli9/GZZ54Z9jt6X9VXOv4uVd0qrWq0Xr58ebusfv36tkrYpX2mYxor/Zaq6LztrVRdnBWheSSWvKXtVNWkl/Lnxx9/bI7Usccea6twb7zxRtO1a1dbHe3Scfzpp5+Cqh6Vh7R/V61aZZYvX27P32bNmgXeV6eQaG0O1VZRnQhUFevSb6hK3M2fyjvq4ap87nXgwAHTpEmTsL+rfThkyBAzdepUs379evtZ7UNVWbpUFa82knpf1Zmq+nU7FXmpWlTrBxKJYAy+0o1T7X/k5ZdftjfTsWPHmuuvv94uU2Pm0KDBbd/jpd6YXrqgugHDOeecY9tSffjhh7Y9mm7maiekm05WqA2SbuYKULw3dXHbWLkX8az2iNQ6dFML1+bGbUyuNllqs6Ob8Ouvv24GDBhgt0+BZCz0O7pRqv1TNAqUFfTppfToewrC9Lducpnt41i2JZTa6YkCP/cz2p/ZIVpeyS5uI3xv3g2Xb0PzSKx5K5HUXk7rVpuygwcP2uDITZuCNOW5UGq/pmAsEdw2fx988IENmrzUzi6cJ554wvbEVTs/tRfTdaZ3796B/CoK5HS9UfsxPUD88ssvdh2h/v7776R04EB6owE/cgzdwNSgXEGFWzKii6CenL3DMOgpPF76HTVQnzRpkr1Av/DCC1E/rwbtXt98841tlK6blC7ievJWyZsCSe8ru3qnNW3a1KxYscKUK1cuwzrUqcCltPTv398Ow6Def6+++mqgxEVpzGx/X3bZZTZI2rBhQ9iboG7GCtbUIPqxxx6zjbdV2uFtvJ/ZPo51W7yOO+44W7r566+/BpZp/yt40bAM4agHpEpvvA3K58yZY7ezTp06Jrvot9QhYfPmzYFlGvrCy715e/NuLON5xZK3tJ3h8md2UFCvIU3UYUAB98MPPxx4T8dRxyM0XXopvylfKL8okPSWIkYb+0vHXyWT3u0J/Q1v54bQ9aqEMhwdd3USueqqq2zApRK/cMFijx49bImYHmxUuhz6eyq5VQlupBI4ILsQjCFHueSSS2zA8+yzz9q/1TNOPfk01o+qcHSzDy0xyMyDDz5opk+fbqs79PT7/vvv2xtaNLrwq4eXbibqhfX000+bXr162fdUhaSeg926dbM3LgWH3377re3tFe7JOiv0+yod0g1F26516AapUok//vjD/q0gbN68ebZE6tNPP7UBj7td6v2nzygA2Lp1a4ZeYy71RNQNSNVEKiHQzVa/o1JK3YAUkKnUQzdb7YPff//d9i7z3qQz28eZbUs4CqB0c1TvPZeqLO+55x7b205p1Y1SQYhKUt316DPKIz///LOZOXOmuf32223vOLeKMjuoukzBotajajvd+PUAIW4plxsoqGpX+1P5QtXcmYklb7mloSp11G8/88wz2VJFqWOh6mYNK6OeogpQVNXnBnra9wr61ctY+Urr1jHX326QqqFqVHqm4EoBlYKdzEo0dV4p0FdPVAX+t9xyS1AAp+pt9S6988477RhwOu6qDld+1N/hKHBXCa3Sq2pdpckbPLtUDavtfvHFF+24YqGUXxXI6XgDCZXQFmlAHL0pXUOHDnWOOeYY2xB7x44dtnGyesBVrVrVNqQN14DfbTjtUmNmNZCWhx9+2Da+V4Pko446yq7z999/j5guNd6+5ZZbbI87rVcNeO+7776ghr3qIfjggw86NWrUsD3i1Ai5S5cutregaN2ZNagOFdpZQQ3Eu3Xr5pQtW9Y2XFfjYvX00z5Rg3T1etN6CxYsaL+r9KiHpNvo+aKLLrK94bR/3H0Rzvbt2517773XqV27tv2t8uXLO2eddZbdp+42q6eqtlXpUI879ZT0Nv7ObB9H25ZI1HuzcuXKgW0S/b961ml7td+rVavmDBkyJPC+9n/btm2dwoUL23RoHW4ng0h5LrTBfmYN+N2G6a1bt7b7S7381CtT+0O9/Vxff/2106BBA5uW0047zXnjjTcyNOAPl0cyy1tu71Y1ctf+VueJ4cOHH1EDfh1ndRLo0KFDUD6//fbbneOOOy6wD9U4X71I1dtYHW8aNmzoPProo0HHWQ3ldYx1bCZMmBC2E46XGuxrn+tcU37t06ePzSve46Q0jRo1ynYE0T7R9UFp/fLLL8M24FcHF31f6SxXrpzt4BP6m66rr77a5hWdM6Hat29vr0dAouXRfxIb7gG5i8aW0lhmOXn6m3SgS5NK7FQiojGjcjKVjqk0SSWDlKLkLmrfqE4dGtzVSyW8KplX9Wak6nQgu9CAH0COpCo/tTuLp6djsrz99tu2Qb2qwxSAqapNPTcJxHIPdQ5Rdble//3vfzO8r/Z+qg4nEEMyEIwByLFUQhnrHJvJtGvXLtuGSm0L1R5O7dtiaROGnENtIhWQqY1cuA4eOqZAslBNCQAA4CN6UwIAAPiIYAwAAMBHBGMAAAA+IhgDAADwEcEYAACAjwjGAAAAfEQwBgAA4COCMQAAAB8RjAEAABj//D/qsEUqk8m75QAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.title(\"Distribution of Processed Signal Energies (w. AGC)\\n (Normalized by Mean Energie of Mic Signals and over Test Case Runs)\");\n", - "plt.boxplot( channel0_var_run_norm );\n", - "plt.xticks(range(1, RUNS_PER_CASE+1), [f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", - "plt.xlabel(\"Runs per Test Case (configured fixed delay)\");\n", - "plt.ylabel(\"Normalized Energy\");" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10,5))\n", - "plt.title(\"Processed Signal Energies (w. AGC)\\n (Normalized by Mean Energie of Mic Signals)\")\n", - "plt.plot(channel0_var);\n", - "plt.grid(True)\n", - "plt.xticks( np.arange(len(test_cases)), map(str, sorted(test_cases.keys())) );\n", - "plt.legend([f\"Run {i+1}\" for i in range(RUNS_PER_CASE)]);\n", - "plt.xlabel(\"Test Case (configured fixed delay)\");\n", - "plt.ylabel(\"Normalized Energy\");" - ] - }, - { - "cell_type": "code", - "execution_count": 80, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.0, 2000.0)" - ] - }, - "execution_count": 80, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Take only Runs 2-5 for each test case\n", - "plt.figure(figsize=(10,5))\n", - "plt.title(\"Distribution of Energy of Runs 2-5 per Test Case (w. AGC)\\n (Normalized by Mean Energie of Mic Signals)\");\n", - "plt.boxplot(channel0_var[:,1:].T);\n", - "plt.grid(True)\n", - "plt.xticks( np.arange(1, len(test_cases)+1), map(str, sorted(test_cases.keys())) );\n", - "plt.xlabel(\"Test Case (configured fixed delay)\");\n", - "plt.ylabel(\"Normalized Energy\");\n", - "plt.ylim(0,2000)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Calculated Delay between Raw Mics and Reference Signals by Maximizing the Cross-Correlation\n", - "##### Example for Run 2 of Test-Case 0" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "audio_data = channels[15,:,:].T\n", - "fs=16000\n", - "channel_names = [\n", - " \"PROC 0\", #AEC + IC + NS + AGC\n", - " \"RPOC 1\", #AEC only\n", - " \"REF 0\",\n", - " \"REF 1\",\n", - " \"MIC 0\",\n", - " \"MIC 1\"\n", - "]\n", - "combinations = ((2,3),(4,5),(2,4),(2,5),(3,4),(3,5))\n", - "fig, axes = plt.subplots(3, 2, figsize=(12, 12), sharex=True)\n", - "axes = axes.flatten()\n", - "for i, comb in enumerate(combinations):\n", - " chirp_signal = audio_data[:,comb[0]] / np.max(audio_data[:,comb[0]])\n", - " mic_signal = audio_data[:,comb[1]] / np.max(audio_data[:,comb[1]])\n", - " # Estimate the delay\n", - " estimated_delay_sec, correlation = estimate_time_delay(chirp_signal, mic_signal, fs)\n", - " # Plot the cross-correlation\n", - " lags = np.arange(-len(chirp_signal)+ 1, len(chirp_signal)) / fs\n", - "\n", - " axes[i].plot(lags * 1000, correlation)\n", - " axes[i].axvline(x=estimated_delay_sec * 1000, color='r', linestyle='--', label=f\"Estimated Delay: {estimated_delay_sec * 1000:.2f} ms\")\n", - " axes[i].set_title(f\"CC({channel_names[comb[0]]},{channel_names[comb[1]]}) {estimated_delay_sec * 1000:.2f} ms\")\n", - " axes[i].set_xlabel(\"Time Lag (ms)\")\n", - " axes[i].set_ylabel(\"Correlation\")\n", - " axes[i].set_xlim((-80,80))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Does the measured delay depend on the configured fixed-delay?\n", - "\n", - "Answer: Yes\n", - "\n", - "Why is this different to the EXPLORER tests?" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Estimated delay for case 0 is [-0.0724375, -0.0724375, -0.0724375, -0.072625]\n", - "Estimated delay for case 1 is [-0.0724375, -0.0724375, -0.0724375, -0.072625]\n", - "Estimated delay for case 2 is [-0.0724375, -0.0724375, -0.0724375, -0.072625]\n", - "Estimated delay for case 3 is [-0.0724375, -0.0724375, -0.0724375, -0.072625]\n", - "Estimated delay for case 4 is [-0.0724375, -0.0724375, -0.0724375, -0.072625]\n", - "Estimated delay for case 5 is [-0.029125, -0.029125, -0.029125, -0.0293125]\n", - "Estimated delay for case 6 is [-0.029125, -0.029125, -0.029125, -0.0293125]\n", - "Estimated delay for case 7 is [-0.0293125, -0.0293125, -0.0293125, -0.0295]\n", - "Estimated delay for case 8 is [-0.0293125, -0.0293125, -0.0293125, -0.0295]\n", - "Estimated delay for case 9 is [-0.0293125, -0.0293125, -0.0293125, -0.0295]\n", - "Estimated delay for case 10 is [-0.0026875, -0.0026875, -0.0026875, -0.002875]\n", - "Estimated delay for case 11 is [-0.0026875, -0.0026875, -0.0026875, -0.002875]\n", - "Estimated delay for case 12 is [-0.0026875, -0.0026875, -0.0026875, -0.002875]\n", - "Estimated delay for case 13 is [-0.0026875, -0.0026875, -0.0026875, -0.002875]\n", - "Estimated delay for case 14 is [-0.0026875, -0.0026875, -0.0026875, -0.002875]\n", - "Estimated delay for case 15 is [0.0025625, 0.0025625, 0.0025625, 0.002375]\n", - "Estimated delay for case 16 is [0.0025625, 0.0025625, 0.0025625, 0.002375]\n", - "Estimated delay for case 17 is [0.0025625, 0.0025625, 0.0025625, 0.002375]\n", - "Estimated delay for case 18 is [0.0025625, 0.0025625, 0.0025625, 0.002375]\n", - "Estimated delay for case 19 is [0.0025625, 0.0025625, 0.0025625, 0.002375]\n", - "Estimated delay for case 20 is [0.0121875, 0.0121875, 0.0121875, 0.012]\n", - "Estimated delay for case 21 is [0.0121875, 0.0121875, 0.0121875, 0.012]\n", - "Estimated delay for case 22 is [0.0121875, 0.0121875, 0.0121875, 0.012]\n", - "Estimated delay for case 23 is [0.0121875, 0.0121875, 0.0121875, 0.012]\n", - "Estimated delay for case 24 is [0.0121875, 0.0121875, 0.0121875, 0.012]\n", - "Estimated delay for case 25 is [0.01775, 0.01775, 0.01775, 0.0175625]\n", - "Estimated delay for case 26 is [0.0178125, 0.0178125, 0.0178125, 0.0175625]\n", - "Estimated delay for case 27 is [0.0178125, 0.0178125, 0.0178125, 0.0175625]\n", - "Estimated delay for case 28 is [0.0178125, 0.0178125, 0.0178125, 0.0175625]\n", - "Estimated delay for case 29 is [0.0178125, 0.0178125, 0.0178125, 0.0175625]\n", - "Estimated delay for case 30 is [0.00975, 0.00975, 0.00975, 0.0095625]\n", - "Estimated delay for case 31 is [0.00975, 0.00975, 0.00975, 0.0095625]\n", - "Estimated delay for case 32 is [0.00975, 0.00975, 0.00975, 0.0095625]\n", - "Estimated delay for case 33 is [0.00975, 0.00975, 0.00975, 0.0095625]\n", - "Estimated delay for case 34 is [0.00975, 0.00975, 0.00975, 0.0095625]\n", - "Estimated delay for case 35 is [0.0044375, 0.0044375, 0.0044375, 0.00425]\n", - "Estimated delay for case 36 is [0.0044375, 0.0044375, 0.0044375, 0.00425]\n", - "Estimated delay for case 37 is [0.0044375, 0.0044375, 0.0044375, 0.00425]\n", - "Estimated delay for case 38 is [0.0044375, 0.0044375, 0.0044375, 0.00425]\n", - "Estimated delay for case 39 is [0.0044375, 0.0044375, 0.0044375, 0.00425]\n", - "Estimated delay for case 40 is [0.009125, 0.009125, 0.009125, 0.008875]\n", - "Estimated delay for case 41 is [0.0091875, 0.0091875, 0.0091875, 0.0089375]\n", - "Estimated delay for case 42 is [0.0091875, 0.0091875, 0.0091875, 0.0089375]\n", - "Estimated delay for case 43 is [0.0091875, 0.0091875, 0.0091875, 0.0089375]\n", - "Estimated delay for case 44 is [0.0091875, 0.0091875, 0.0091875, 0.0089375]\n", - "Estimated delay for case 45 is [0.0071875, 0.0071875, 0.0071875, 0.007]\n", - "Estimated delay for case 46 is [0.0071875, 0.0071875, 0.0071875, 0.007]\n", - "Estimated delay for case 47 is [0.0071875, 0.0071875, 0.0071875, 0.007]\n", - "Estimated delay for case 48 is [0.0071875, 0.0071875, 0.0071875, 0.007]\n", - "Estimated delay for case 49 is [0.0071875, 0.0071875, 0.0071875, 0.007]\n", - "Estimated delay for case 50 is [0.0059375, 0.0059375, 0.0059375, 0.00575]\n", - "Estimated delay for case 51 is [0.0059375, 0.0059375, 0.0059375, 0.00575]\n", - "Estimated delay for case 52 is [0.0059375, 0.0059375, 0.0059375, 0.00575]\n", - "Estimated delay for case 53 is [0.0059375, 0.0059375, 0.0059375, 0.00575]\n", - "Estimated delay for case 54 is [0.0059375, 0.0059375, 0.0059375, 0.00575]\n", - "Estimated delay for case 55 is [0.007375, 0.007375, 0.007375, 0.0071875]\n", - "Estimated delay for case 56 is [0.0074375, 0.0074375, 0.0074375, 0.0071875]\n", - "Estimated delay for case 57 is [0.0074375, 0.0074375, 0.0074375, 0.0071875]\n", - "Estimated delay for case 58 is [0.0074375, 0.0074375, 0.0074375, 0.0071875]\n", - "Estimated delay for case 59 is [0.0074375, 0.0074375, 0.0074375, 0.0071875]\n", - "Estimated delay for case 60 is [0.0051875, 0.0051875, 0.0051875, 0.0049375]\n", - "Estimated delay for case 61 is [0.0051875, 0.0051875, 0.0051875, 0.0049375]\n", - "Estimated delay for case 62 is [0.0051875, 0.0051875, 0.0051875, 0.0049375]\n", - "Estimated delay for case 63 is [0.0051875, 0.0051875, 0.0051875, 0.0049375]\n", - "Estimated delay for case 64 is [0.0051875, 0.0051875, 0.0051875, 0.005]\n", - "Estimated delay for case 65 is [0.0096875, 0.0096875, 0.0096875, 0.0095]\n", - "Estimated delay for case 66 is [0.0096875, 0.0096875, 0.0096875, 0.0095]\n", - "Estimated delay for case 67 is [0.0096875, 0.0096875, 0.0096875, 0.0095]\n", - "Estimated delay for case 68 is [0.0096875, 0.0096875, 0.0096875, 0.0095]\n", - "Estimated delay for case 69 is [0.0096875, 0.0096875, 0.0096875, 0.0095]\n", - "Estimated delay for case 70 is [0.015375, 0.015375, 0.015375, 0.015125]\n", - "Estimated delay for case 71 is [0.015375, 0.015375, 0.015375, 0.015125]\n", - "Estimated delay for case 72 is [0.015375, 0.015375, 0.015375, 0.015125]\n", - "Estimated delay for case 73 is [0.015375, 0.015375, 0.015375, 0.015125]\n", - "Estimated delay for case 74 is [0.015375, 0.015375, 0.015375, 0.0151875]\n", - "Estimated delay for case 75 is [0.0095, 0.0095, 0.0095, 0.0093125]\n", - "Estimated delay for case 76 is [0.0095, 0.0095, 0.0095, 0.0093125]\n", - "Estimated delay for case 77 is [0.0095, 0.0095, 0.0095, 0.0093125]\n", - "Estimated delay for case 78 is [0.0095, 0.0095, 0.0095, 0.0093125]\n", - "Estimated delay for case 79 is [0.0095, 0.0095, 0.0095, 0.0093125]\n", - "Estimated delay for case 80 is [0.01325, 0.01325, 0.01325, 0.0130625]\n", - "Estimated delay for case 81 is [0.01325, 0.01325, 0.01325, 0.0130625]\n", - "Estimated delay for case 82 is [0.01325, 0.01325, 0.01325, 0.0130625]\n", - "Estimated delay for case 83 is [0.01325, 0.01325, 0.01325, 0.0130625]\n", - "Estimated delay for case 84 is [0.01325, 0.01325, 0.01325, 0.0130625]\n" - ] - } - ], - "source": [ - "normed = channels / np.max(channels,axis=2)[:,:,None]\n", - "est_delays = []\n", - "for idx in range(channels.shape[0]):\n", - " this_delays = []\n", - " this_delays.append(estimate_time_delay(normed[idx,2,:], normed[idx,4,:], 16000)[0])\n", - " this_delays.append(estimate_time_delay(normed[idx,2,:], normed[idx,4,:], 16000)[0])\n", - " this_delays.append(estimate_time_delay(normed[idx,3,:], normed[idx,4,:], 16000)[0])\n", - " this_delays.append(estimate_time_delay(normed[idx,3,:], normed[idx,5,:], 16000)[0])\n", - " #this_delays.append(estimate_time_delay(normed[idx,4,:], normed[idx,5,:], 16000)[0])\n", - " est_delays.append(this_delays)\n", - " print(f\"Estimated delay for case {idx} is {est_delays[idx]}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(-10.0, 20.0)" - ] - }, - "execution_count": 83, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.title(\"Variation of Estimated Delays over all Test Cases and Runs\")\n", - "plt.boxplot(np.array(est_delays)*1000);\n", - "plt.ylabel(\"Estimated Delay (ms)\");\n", - "plt.xticks(range(1,5), [\"(REF0, MIC0)\", \"(REF0, MIC1)\", \"(REF1, MIC0)\", \"(REF1, MIC1)\"]);\n", - "plt.ylim(-10,20)" - ] - }, - { - "cell_type": "code", - "execution_count": 84, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10,5))\n", - "plt.title(\"(REF0,MIC0) Estimated Delays\")\n", - "plt.boxplot(np.array(est_delays)[:,0].reshape(len(test_cases),-1).T*1000);\n", - "plt.grid(True)\n", - "plt.ylabel(\"Estimated Delay (ms)\");\n", - "plt.xticks( np.arange(1, len(test_cases)+1), map(str, sorted(test_cases.keys())) );\n", - "plt.xlabel(\"Test Case (configured fixed delay)\");" - ] - }, - { - "cell_type": "code", - "execution_count": 85, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(-5.0, 20.0)" - ] - }, - "execution_count": 85, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0wAAAHWCAYAAABE/wm7AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAVUNJREFUeJzt3QmcTfX7wPFnMIaxM4ydQZpIFJFky67FEhUqSqV+SZaENkNCKRWJ/hXRQoulH4YJWSpLllTabRVZQkyMZRrn/3q+de/v3pl7xh3uvXPPzOf9el0z95xzz33uuV93znO/3+9zIizLsgQAAAAAkEGejIsAAAAAAIqECQAAAABskDABAAAAgA0SJgAAAACwQcIEAAAAADZImAAAAADABgkTAAAAANggYQIAAAAAGyRMAAAAAGCDhAkA/vXss89KfHy8nD17NrtDyTWmTZsmlStXltOnT0s4iYiIkISEBMlJ3nzzTfO6du/enatjAICsImECABFJTk6WZ555RoYNGyZ58vzvo1FP7jxvRYsWlebNm8vixYttTwbtbuvXr7fdr+tWtmxZr30ePXpU7r33XildurQUKlRIWrZsKVu2bPHrNfXp08cd88mTJzOs//nnn93P+9xzz7mXr1q1yiz78MMPMzxmx44d0q9fP6lWrZoUKFDA7LtJkyby0ksvZXiOtWvXyjXXXCPR0dHmdQ0YMECOHz+eIcYzZ87Iq6++mqXX5Oum8WRFYmJi2CVFKSkpJiZ9D7KLPr/ncdX3T5PaG264QWbMmBF2yS0ABFu+oD8DADjA9OnT5e+//5YePXpkWNemTRu54447xLIs+eWXX2Tq1Knm5HHJkiXSrl27DNuPHj1a4uLiMiyvUaOGz/16KliwoPt37em67rrr5KuvvpKhQ4dKTEyMvPLKK9KiRQvZvHmzXHTRRed8Xfny5TMn4QsXLpSbb77Za90777xjkoxTp06JPzRJ7N69u0RFRZm4L730UpPsfPbZZya+b7/9Vv7v//7PbLt161Zp1aqVXHLJJTJx4kTZs2ePSco0SdPj5qLP37t3b7PNgw8+aE7Qz0Wf//XXX8+wPG/evJLVhGnKlCk+kyZN/vTYhZq+V6NGjTK/6/ucnbSdFy5c2CRIe/fulaSkJLnrrrvkxRdflEWLFkmlSpWyNT4ACBUSJgAQMd+c33jjjT57KWrWrCm33Xab+/5NN90ktWrVMr0qvhKmDh06SIMGDc75nOn3m5728GgvzQcffCDdunUzyzTp0ceNHDlS3n33Xb+SC+0Bmj17doaESR+vCdncuXPPuZ9du3bJrbfeKlWqVJFPPvlEypUr5173wAMPyPbt27163R599FEpUaKE6SnRXihVtWpVueeee+Tjjz+Wtm3burfVuHQ45MqVK+Xaa689ZyyayGR23AIhq71VOZG2OU3SXZ588kmTZGuyrImzZ48pAORkDMkDkOtpMvD1119L69at/dpee030RFKHpwWTJkyxsbHStWtX9zIdmqcJxkcffeT30KiePXuaXh0d3ueyceNG09uj6/yhCY0Op3vjjTe8kiXP3rOHHnrIPbxx2bJlJqlxJUtKT7S1x+L999/3emz9+vWlZMmS5jUFSmpqqump0V44TX5KlSplhgdqXK6hfdq7pDyHn9nNYXINU/vpp5/M6ypWrJh5L5544gnT8/jbb79Jp06dzOvV4YfPP/+8VzzaE6cJh75WfawOr2zatKlJEl10Xo/uU2nsrpg84/jhhx9MIqPHS1+XJub//e9/M7x+7e3T5FN7LCtWrChjxowJyNy8Xr16yd133y0bNmxwH0sXXda+fXvz+nQYnw5d/fzzz8+5T33fNXEvX768SfCrV68uTz31lKSlpbm30S8IIiMj5Y8//sjweB2yWrx4cXdP6aZNm8wXGfp/VF+/9vZqzxgAnC8SJgC5nvbiqCuuuMKv7Y8dOyZ//vmn6UGxW3/o0CGv2+HDhzNspyd46bfzTIK+/PJLE5PnnCrVsGFDM3RLT979oQmXnnjPmzfPq3dJC1z4+5p1SJ/OW7r66qvPue0333xjhjem72XLnz+/1KtXz7yu9DQOf06uXdIfN71pouaiSYYmHTrn6+WXX5bHHnvMzMNxzf/SeVg6JFK99dZb7tu53HLLLSbxGD9+vDRq1MgkIjpETfdVoUIFMw9Ok8eHH35Y1qxZ436cxqbDCHWYnW6j8enJv57Y6/BFpcmSDoNTXbp0ccfkSpg1Cbrqqqvk+++/l+HDh5ukTBOvzp07y/z5893PtX//fvO6db+63cCBA2XWrFmmRzQQbr/9dvNTewpdtNexWbNm5nVqcjN27FiToGvS9sUXX2S6P537p4n04MGDTYyaVGpyqbF7Pqe2qffeey9DIqpfLGivryaQBw8eNL2Xmnzq4ydPnmySPHrDAFwQCwByuccff9zSj8O//vorwzpd3rdvX+uPP/6wDh48aG3atMlq3769WT5hwgSvbWfMmGGW+7pFRUVl2K+vm+7DpVChQtZdd92VIabFixebbZcuXZrp6+rdu7fZh+rWrZvVqlUr83taWppVtmxZa9SoUdauXbsyvJaVK1eaZR988IG5f+zYMXO/U6dOfh1PfZxuv2bNmgzrunfvbp47vXvvvdcqWLDgOfetr8nu2LVr1869Xd26da3rrrsu03098MAD5nG+6PKRI0e67+vvukzjdPn777+tihUrWhEREdb48ePdy//880/zWjRWz21Pnz7t9Ry6XWxsrNd7rO0s/XO76PtXp04d69SpU+5lZ8+eta6++mrroosuci8bOHCg2ceGDRvcy7TtFitWzCzX9zwzrteqsfiicev6Ll26uGPQ59fjr7+7pKSkWHFxcVabNm0y/B/xjEG3S69fv35WdHS012tt3Lix1ahRI6/t5s2bZ/anbVbNnz/f3N+4cWOmrxEAsoI5TAByPe390Xkx+i23LzoMTW8uOjTokUceMd+I+6JDvXSe0bkKEugQrv79+3stq127tlfhAR2iZDe/xlflOzs69E7nnWjvw7Zt28xPf4fjuXpuihQp4tf2rrjsYvcVt/bW6XLtOdPhXJnRfWiPV3qe8210iJb2yOiwQ3+KY/hLh6N5vqfai6YFLfr27ev13BdffLHs3LnTa1tXG9AeKu190Z/6eH+qHh45csT04mhBkb/++svcXLSXSnt1tDCD9nJpMQvtidKeSBftvdKeFi0acqFc/09cMWhPlh7nxx9/PENPqhb+0F4yfa3pe0p9FTrRfWovqw5X1MqJOgSxbt267iGd999/vxkKq8P2lM6p0uITOvzPdeyVFqXQx+n/VQC4UCRMAHAOrsRGh//o3B8dbqQn9nYngHqi6k/RB51bktm8KT2R9DVPyTVXw/NE81w6duxoEh4d0qQnuFdeeaUZOubP9XBc85A8T9Iz44rLLnZfcf/TqfPP3KFz0cTjXPPNNLHQ900TV63mp3NrdFjXZZddJhdCh/V50vk6msB5Jmuu5emTh5kzZ5phdJoE6BwrF18VFdPTohp6jHTOlN580eFomjBpJUcdLpieJnGB4CoN70qgNVlSWu3Qjg5TtRvCqomtJluaEHoOq3Q9znM4pA4v1CRJh+zpOk2MBg0a5G43mjjp8DwdjvnCCy+YIZA6ZFG/HPCVwAOAP0iYAOR6WhBA50doQuCrF8UzsdHEQ0+ONYHSeSKeBRkCTYsr7Nu3L8Ny1zKdJO8vPVnUWPWkXXs+snL9IU2Y9Lm0Z8rfuD3jTB+7r7h1Tpj2LGUlCcyMzqfRnggtKKBzbXT+kJ5A64VyPXuJsspXT6FdOXNXEqjefvttU2hCT961BHuZMmXM48aNG+dX8RBXwQadG+WrMqOvsvXB4moHrudzxTZhwgQzR80Xu95b7WnTJEfbmCa52nOkCaj2uuk10TwLVWjCdf3117sTJp27pEm5Z8VE1/XDdM6S9kK6SqFroqrL7OIAgMyQMAHI9bT4gatanj89EFowQE++9VtxnZzvT6/I+dCTz08//TTDcCatRqbJRfphf+ei37Lr9aZ0X1oiPCv0RFWvsbRu3Tpp3Lhxpttqj44OcdRqZZ6lzLWHTnu30pc3dx17rT4YSFpJ7s477zQ37RXRJEoTRVfCFKz3zRc9ideiGVp4w/N5dSidJ7uY9LFKh5idq3dNS7+7en08/fjjjxIIruIYrsTNNTxOkx5/K026aNl57YnT46Lvj2d78EWH5WnPofb0auJ0+eWXew1jddEhiXp7+umnTYETHY44Z86cC0qWAeReVMkDkOu5EgA9wfeHJgNDhgwx1coCWQo7PS0ffeDAAa/qdloNTq/LpBfOzeoQI+0R03LNWjVOS19nhc7Z0opsesKpMaWnvSSuKmw6HE1PnLVXxXMYn55oa+Kic6nS0x4Ffyrw+Sv9cDjtWdAeEc9hgvp6lGe59WBx9UJ59jpp4qsJqCfX/K30MWmPlA4v03k9vnruPMttay+o9qZ4VqfT9ZpgXChNPrS3Tv/P6PwkpVXtNGnSCxO7huvZxebPcdHE2m6ulV7jTHt4tdLg6tWrM1yPS3sqPfelXL1e/pbhB4D06GECkOvpt/faK7J8+XK/r9eiw6t0WJCeuOkwK096zSOdp5KeJgSungJ/Eyb9llx7SL777jtzoqgnknp9Gp2jkT4eHW6n38zrBWJ90Z4l7RU7H3pCrCfLOo9Ee4L0m349Znpy67q4rsbgot/s6+vV4VZ6nRwtjKDDorTks84n8rR582ZT1EB7Dvyhwyc1GfNFe/w0EdILC2uC4brGkybD2svjWWRD16kBAwaY3hI9ec9qz1tWeug08dX49JpD+j7p8ECN0zPJ0CGJukznmmkPosaux1lvWkxEryVVp04dcwFgbUuavGrSpcf3q6++cie3mpzqcdZrY+nx0N5B7XnS6435S4+XJpr6HmtBCR3epqXftZiCvt+e7UqTKE1mtLdH26vOpdLH6HWmtOfJV5EOpW1Eh9rp/Cd9H7SHTWNPn/S4aA+bvkea9Ov71aNHD6/1+n9A/4/ocdY2qwn7a6+9ZmLQRBIAzkuWauoBQA41ceJEq3DhwhlKHOvHpJaf9iUhIcGrpHFmZcXTlwzPbL+ejhw5YsqalypVypRZbt68uc+SyTfddJMpZa0ln32VFbfjT1lxTz/99JN1zz33WFWrVrXy589vFSlSxGrSpIk1efJkrxLQ6tNPPzUlrwsUKGCVLl3avN7k5OQM+xw2bJhVuXJlr5LU51NW3LNc9ZgxY6yGDRtaxYsXN8clPj7eevrpp60zZ854lfp+8MEHTWxaGtzzT6JdWfH0pbbtjrG+T7Vr13bf19c2duxYq0qVKqbE/OWXX24tWrTIPF6XeVq7dq1Vv359c3zTx7Fjxw7rjjvuMKXZIyMjrQoVKljXX3+99eGHH3rt4+uvvzYx6LHXbZ566inrjTfeyFJZcddN96Hl0/V5pk+fnuF9dvnyyy+trl27mraqr1Ff180332ytWLEi07Lin3/+uXXVVVeZ96l8+fLWI488YiUlJXn93/L0xRdfmHVt27bNsG7Lli1Wjx49THvSGMqUKWPi1ssBAMD5itB/zi/VAoCcQytu6Tf2zz77rFeJaKeIjY01vT468d5JdJiU9ojpRUa1NwQ4F+1J02F2ejFe10V0ASCYmMMEAP/Ou9GhTJpweFbmcgIty6zXMNKqYk4zY8YMM8zqvvvuy+5Q4BA6xE6HCgazQiUAeKKHCQAAhD2dB6Vz+fQ6VDoXbeLEidkdEoBcgoQJAACEPR26qUUutECHFobwdc00AMixQ/L0wn161Xn98NPSqVpxKv31IvTq8A888IC5wKR2xeuVvH2VtgUAADnP7t27zdDTBQsWkCwByH0Jk15LQZMhvW7EsmXLJDU11ZSePXHihHubQYMGme54LWWq2//++++MXwYAAACQ+4bk6UXutKdJEyO98rdWrypdurS5Bohel0TpNU70WiB6/Qm9TgkAAAAA5IoL12qCpPSCfa6LGmqvk1453iU+Pl4qV66cacKk5Wo9r+ytla/04og6rE8vjgcAAAAgd7Isy1zgunz58uYi3I5JmDSpGThwoDRp0sRc2Vzt379f8ufPL8WLF89w3RFdl9ncqFGjRgU9ZgAAAADO9Ntvv0nFihWdkzDpXKZt27bJZ599dsH7GjFihAwePNir50p7pXbt2hXQCaPa+7Vy5Upp2bKluZ6IUxB36DgxZqfG7cSYFXGHjhNjdmrcToxZEXfoODFmp8btxJiDHbf2LsXFxZ0zLwirhEmvq7Bo0SJZs2aNV5ZXtmxZOXPmjBw9etSrl0mr5Ok6O1FRUeaWng71K1q0aEDfyOjoaDPUz2kNkLhDw4kxOzVuJ8asiDt0nBizU+N2YsyKuEPHiTE7NW4nxhzsuF37O9dUnTzhMn5Qk6X58+fLJ598YjI9T/Xr1zcvaMWKFe5lWnb8119/lcaNG2dDxAAAAAByg3zhMgxPK+B99NFHpkvMNS+pWLFiUrBgQfOzb9++Znidq3fowQcfNMkSFfIAAAAA5OiEaerUqeZnixYtvJbPmDFD+vTpY35/4YUXTPUKvWCtVr7TK32/8sor2RIvAAAAgNwhLBImfy4FVaBAAZkyZYq5AQAAAEAohMUcJgAAAAAIRyRMAAAAAGCDhAkAAAAAbJAwAQAAAIANEiYAAAAAsEHCBAAAAAA2SJgAAAAAwAYJEwAAAADYIGECAAAAABskTAAAAABgg4QJAAAAAGyQMAEAAACADRImAAAAALBBwgQAAAAANkiYAAAAAMAGCRMAAAAA2CBhAgAAAAAbJEwAAAAAYIOECQAAAABskDABAAAAgA0SJgAAAACwQcIEAAAAADZImADkGGlpabJ69WpZs2aN+an3AQAALgQJE4AcYd68eVKjRg1p06aNTJw40fzU+7ocAADgfJEwAXA8TYq6desmderUkU8//VRmz55tfup9XU7SBAAAzle+834kAITIoUOHJGnuLIlOS/ZanpJyQn7+ebssX75cOtQrJ/XL55MVb0+UAwcOSGxsrLmfVq+cvPBIH/k66S3JkyePVK9eTaKjC3ntJyautjTt0D3ErwoAADgBCROAsLdgwQLZM/tRSWgRlXFlOZGE27Wz/LiIrPhnWVn9Z9s/v9+o/0SIyCf/3D/+781DwvunpXRcHYmPjw/uCwEAAI5DwgQg7HXu3FmS0pJlvo8eptWr18imTZvk+uuvl3z58ollWe4epoiICElNTZXFixdLgwYNpGLFij57mFoNq02yBAAAfCJhAhD2YmJipFe/wT7XVWiwSl5r2VJe6TtCrrrqKpMgJSYmSseOHSUyMlLWrVsnY95YKBOHPCMtWrQIeewAAMDZKPoAwNGaNm0qVatWlbFjx8rZs2e91un9cePGSVxcnNkOAAAgq0iYADha3rx55fnnn5dFixaZoXvr16+XkydPmp96X5c/99xzZjsAAICsYkgeAMfr2rWrfPjhhzJkyBBp1qyZe7n2LOlyXQ8AAHA+SJgA5AiaFHXq1ElWrlwpS5YskQ4dOkjLli3pWQIAABeEhAlAjqHJUfPmzeXEiRPmJ8kSAAC4UMxhAgAAAAAbJEwAAAAAYIOECQAAAABskDABAAAAgA0SJgAAAACwQcIEAAAAADZImAAAAADABgkTAAAAANggYQIAAAAAGyRMAAAAAGCDhAkAAAAAbJAwAQAAAIANEiYAAAAAsEHCBAAAAAA2SJgAAAAAwAYJEwAAAADYIGECAAAAABskTAAAAABgg4QJAAAAAGyQMAEAAACADRImAAAAALBBwgQAAAAANkiYAAAAAMAGCRMAAAAA2CBhAgAAAAAbJEwAAAAAYIOECQAAAABskDABAAAAgA0SJgAAAACwkc9uBQAAAJAbHDp0SJLmzpLotGSv5SkpJ2THjp0ZtrcsSw4cOCBbl8yUiIgIr3XVq1eT6OhCXsti4mpL0w7dgxQ9go2ECQAAALnaggULZM/sRyWhRVTGlbE2Dyqr/2zLuPz4vzcPCe+fltJxdSQ+Pj4g8SK0SJgAAACQq3Xu3FmS0pJlfhZ7mGJjY/3qYWo1rDbJkoOFTcK0Zs0amTBhgmzevFn27dsn8+fPN43XpU+fPjJz5kyvx7Rr106WLl2aDdECAAAgp4iJiZFe/Qb7vX1qaqokJiZKx44dJTIyMqixIfuFTdGHEydOSN26dWXKlCm227Rv394kU67b7NmzQxojAAAAgNwlbHqYOnToYG6ZiYqKkrJlzYBRAAAAAMg9CZM/Vq1aJWXKlJESJUrItddeK2PGjJFSpUrZbn/69Glzc0lOTnZ3o+otUFz7CuQ+Q4G4Q8eJMTs1bifGrIg7dJwYs1PjdmLMirhDx4kxOzVuJ8Yc7Lj93WeEpbPWwoxOnks/h2nOnDkSHR0tcXFxsmPHDnn00UelcOHCsm7dOsmbN6/P/SQkJMioUaMyLH/33XfNvgAAAADkTikpKdKzZ085duyYFC1a1PkJU3o7d+6U6tWry/Lly6VVq1Z+9zBVqlTJ1NrP7KCcT3a6bNkyadOmjaMm/hF36DgxZqfG7cSYFXGHjhNjdmrcToxZEXfoODFmp8btxJiDHbfmBlrw41wJk6OG5HmqVq2aeYHbt2+3TZh0zpPe0tODHYyGEqz9Bhtxh44TY3Zq3E6MWRF36DgxZqfG7cSYFXGHjhNjdmrcTow5WHH7u7+wqZKXVXv27JHDhw9LuXLlsjsUAAAAADlU2PQwHT9+3PQWuezatUu2bt0qJUuWNDedi3TTTTeZKnk6h+mRRx6RGjVqmGsxAQAAAECOTpg2bdokLVu2dN8fPPifi4f17t1bpk6dKl9//bW5cO3Ro0elfPny0rZtW3nqqad8DrkDAAAAgByVMLVo0UIyqz+RlJQU0ngAAAAAwLFzmAAAAAAg2EiYAAAAAMAGCRMAAAAA2CBhAgAAAAAbJEwAAAAAYIOECQAAAABskDABAAAAgA0SJgAAAACwQcIEAAAAADZImAAAAADABgkTAAAAANggYQIAAAAAGyRMAAAAAGCDhAkAAAAAbJAwAQAAAIANEiYAAAAAsEHCBAAAAAA2SJgAAAAAwAYJEwAAAADYyGe3AgAAAAAC6dChQ5I0d5ZEpyV7LU9JOSE7duzMsL1lWXLgwAHZumSmREREZFhfvXo1iY4u5L4fE1dbmnboHtCYSZgAAAAAhMSCBQtkz+xHJaFFVMaVsTYPKqv/bPO97vi/t38lvH9aSsfVkfj4eAkUEiYAAAAAIdG5c2dJSkuW+VnsYYqNjfWrh6nVsNoBTZYUCRMAAACAkIiJiZFe/Qb7vX1qaqokJiZKx44dJTIyUrIDRR8AAAAAwAYJEwAAAADYIGECAAAAABskTAAAAABgg4QJAAAAAGyQMAEAAACADRImAAAAALBBwgQAAAAANkiYAAAAAMAGCRMAAAAA2CBhAgAAAAAbJEwAAAAAYCOfnIdff/1VfvnlF0lJSZHSpUtL7dq1JSoq6nx2BSCEDh06JElzZ0l0WrLX8pSUE7Jjx84M21uWJQcOHJCtS2ZKRESE17rq1atJdHQhr2UxcbWlaYfuQYoeAAAgjBOm3bt3y9SpU2XOnDmyZ88ecyLlkj9/fmnatKnce++9ctNNN0mePHRcAeFowYIFsmf2o5LQwscXHLE2Dyqr/2zLuPz4vzcPCe+fltJxdSQ+Pj4g8QIAADgiYRowYIDMnDlT2rVrJ2PGjJGGDRtK+fLlpWDBgnLkyBHZtm2bfPrpp/Lkk0/KqFGjZMaMGXLllVcGP3oAWdK5c2dJSkuW+VnsYYqNjfWrh6nVsNokSwAAIPclTIUKFZKdO3dKqVKlMqwrU6aMXHvtteY2cuRIWbp0qfz2228kTEAYiomJkV79Bvu9fWpqqiQmJkrHjh0lMjIyqLEBAAA4NmEaN26c3zts3779hcQDAAAAAGEjy5ONTp48aYo9uGjxhxdffFGSkpICHRsAAAAAOCth6tSpk8yaNcv8fvToUWnUqJE8//zzZm6EFoUAAAAAgFybMG3ZssVUxFMffvihmQyuvUyaRE2aNCkYMQIAAACAMxImHY5XpEgR8/vHH38sXbt2NWXEr7rqKpM4AQAAAECuTZhq1KhhruWilfB03lLbtm3N8oMHD0rRokWDESMAAAAAOCNh0mstPfzww1K1alUzf6lx48bu3qbLL788GDECAAAAQPiWFffUrVs3ueaaa2Tfvn1St25d9/JWrVpJly5dAh0fAAAAADgnYVJly5Y1N08NGzYMVEwAAAAA4MyE6dSpUzJ58mRZuXKlmbd09uzZDFX0AAAAACBXJkx9+/Y185V0aJ72KkVERAQnMgAAAABwWsK0aNEiSUxMlCZNmgQnIgAAAABwapW8ChUquK/DBAAAAAA5WZYTpueff16GDRvGRWoBAAAA5HhZHpLXoEEDU/ihWrVqEh0dLZGRkV7rjxw5Esj4AAAAAMA5CVOPHj1k7969MnbsWImNjaXoAwAAAIAcK8sJ09q1a2XdunVeF60FAAAAgJwoy3OY4uPj5eTJk8GJBgAAAACcnDCNHz9ehgwZIqtWrZLDhw9LcnKy1w0AAAAAcu2QvPbt25ufrVq18lpuWZaZz5SWlha46AAAAADASQnTypUrgxMJAAAAADg9YWrevHlwIgEAAAAAJ85h+vXXX7O0Uy07DgAAAAC5ImG68sorpV+/frJx40bbbY4dOyavvfaaXHrppTJ37txAxggAAAAA4Tsk77vvvpOnn35a2rRpIwUKFJD69etL+fLlze9//vmnWf/tt9/KFVdcIc8++6x07Ngx+JEDAAAAQDj0MJUqVUomTpwo+/btk5dfflkuuugiOXTokPz8889mfa9evWTz5s3mgrYkSwAAAAByZdGHggULSrdu3cwNAAAAAHK6LF+4NljWrFkjN9xwgxnqp9dzWrBgQYbrPD355JNSrlw5k7i1bt3a3cMFAAAAADk6YTpx4oTUrVtXpkyZ4nO9zo2aNGmSTJs2TTZs2CCFChWSdu3ayalTp0IeKwAAAIDcIcvXYQqWDh06mJsv2rv04osvyuOPPy6dOnUyy2bNmiWxsbGmJ+rWW28NcbQAAAAAcoOwSZgys2vXLtm/f78ZhudSrFgxadSokSk0YZcwnT592txckpOTzc/U1FRzCxTXvgK5z1Ag7tBxYsxOjduJMSviDh0nxuzUuJ0YsyLu0HFizE6N24kxBztuf/cZYWn3TRaHzulwuGDSOUzz58+Xzp07m/tr166VJk2ayO+//27mMLncfPPNZtv33nvP534SEhJk1KhRGZa/++67Eh0dHcRXAAAAACCcpaSkSM+ePc31ZIsWLRq4HiYdBqeJyl133SXXXHONhLMRI0bI4MGDvXqYKlWqJG3bts30oJxPdrps2TJznarIyEhxCuIOHSfG7NS4nRizIu7QcWLMTo3biTEr4g4dJ8bs1LidGHOw43aNPjuXLCdMb7/9trz55pty7bXXStWqVU3idMcdd5jqdsFStmxZ8/PAgQNePUx6v169eraPi4qKMrf09GAHo6EEa7/BRtyh48SYnRq3E2NWxB06TozZqXE7MWZF3KHjxJidGrcTYw5W3P7uL8sJkw6T09sff/whb731lkmennjiCVOxTpOnG2+8UfLlC+zUqLi4OJM0rVixwp0gaUao1fLuv//+gD4XAASKXuA7ae4siU773zdYKSknZMeOnRm21dHR+iXQ1iUzzVDj9KpXrybR0f8bDh0TV1uadugexOgBAIA678ymdOnSZrib3iZPnixDhw6VxMREiYmJkfvuu0+GDx+epXlCx48fl+3bt3sVeti6dauULFlSKleuLAMHDpQxY8bIRRddZBIoTdK0V8s1zwkAwo1W8dwz+1FJaJGupzvW5gGmM32b73XH/739K+H901I6ro7Ex8cHLF4ACAS+LEJOc94JkzbumTNnmh6mX375Rbp16yZ9+/aVPXv2yDPPPCPr16+Xjz/+2O/9bdq0SVq2bOm+75p71Lt3b/McjzzyiCk4ce+998rRo0fN/KmlS5dKgQIFzvclAEBQ6Rc6SWnJMj8LJw06T9Sfk4ZWw2qTLAEIS3xZBMntCdO8efNkxowZkpSUJLVq1ZL//Oc/ctttt0nx4sXd21x99dVyySWXZGm/LVq0MCcMdvQEYvTo0eYGAE6gPe69+v2v8My5JrVqL33Hjh0dObYcAFz4sih7e/PsjndWe/MUPXrnmTDdeeed5rpHn3/+uVx55ZU+t9Ghco899lhWdw0AAACH48uiMOjNs+vRy0JvnqJH7zwTpn379p1zblLBggVl5MiRFxIXAAABl5aWJqtXr5Y1a9aYawrqUPC8efNmd1gAELDevHP1MPnbm6fo0TvPhMkzWTp16pScOXPGa30gr28EAECg6JDyIUOGyO7du839iRMnmstjPP/889K1a9fsDg8AsozevNDIk9UHaOGF/v37S5kyZcy3cyVKlPC6AQAQjsmSFieqU6eOfPrppzJ79mzzU+/rcl0PAEBAepi0Wt3KlStl6tSpcvvtt8uUKVNk79698uqrr8r48eOzujsAAIJaxvjs2bOyfPly6VCvnNQvn09WvD3RPSxF76fVKycvPNJHvk56S/LkycPEZwDAhSVMCxculFmzZpmqdloAomnTplKjRg2pUqWKvPPOO9KrV6+s7hIAgKCWMU64Pc+/s5lXZJz4fKP+o+P5P/nnPhOfAQAXkjAdOXJEqlWr5p6vpPeVXhfp/vvvz+ruAAAIahljvT6gXuvv+uuvl3z58mWY+Kzj+hcvXiwNGjSQihUrMvEZAHBhCZMmS7t27ZLKlSubPx7vv/++NGzY0PQ8eV6LCQCAcJj4vGrVKnmtZUt5pe8IueqqqzJMfF63bp2MeWOhTBzyjBk9AQDABRV90GF4X331lfl9+PDhZg5TgQIFZNCgQTJ06NCs7g4AgKDSoeNaDW/s2LFmPpMnvT9u3DiJi4sz2wEAcME9TJoYubRu3Vp++OEH2bx5s5nHdNlll2V1dwAABJVeZ0lLh2s1PB26p1/unTx5UtavXy8TJkyQRYsWyYcffsj1mAAAgUmY0tNiD3oDACBc6XWWNCnS6zA1a9bMvVx7lnQ512ECAFxQwjRp0iTx14ABA/zeFgCAUNGkqFOnTubSGEuWLJEOHTpIy5Yt6VkCAFx4wvTCCy/4s5mpNkTCBAAIV5ocNW/e3FyEXX+SLAEAApIwaVU8AAAAAMhtslwlz+XMmTPy448/yt9//x3YiAAAAADAqQlTSkqK9O3bV6Kjo6V27dry66+/muUPPvigjB8/PhgxAgAAAIAzEqYRI0aY6zDphQD1+kueJcbfe++9QMcHAAAAAM4pK75gwQKTGOnV0rXIg4v2Nu3YsSPQ8QEAAACAc3qY/vjjDylTpkyG5VpxyDOBAgAAAIBclzA1aNBAFi9e7L7vSpJef/11ady4cWCjAwAAAAAnDckbO3asudjfd999ZyrkvfTSS+b3tWvXyurVq4MTJQAAAAA4oYfpmmuuka1bt5pkqU6dOvLxxx+bIXrr1q2T+vXrBydKAAAAAHBCD5OqXr26vPbaa4GPBgAAAACcnDAdO3ZMli1bJrt37zbzl6pVqyatWrWSokWLBidCAAAAAHBCwvT2229L//79JTk52Wt5sWLFZNq0aXLLLbcEOj4AAAAACP85TFu2bJE777xTOnfuLF9++aWcPHlSUlJSZNOmTXLDDTfI7bffbi5oCwAAAAC5rodp8uTJJll68803vZZfccUVMmvWLJM8acW86dOnByNOAAAAAAjfHqbPP/9c+vXrZ7v+vvvuk88++yxQcQEAAACAcxKm33//XWrWrGm7Xtft3bs3UHEBAACEXFpamrmu5Jo1a8xPvQ8gd/M7YdIhdwUKFLBdHxUVJadOnQpUXAAAACE1b948qVGjhrRp00YmTpxofup9XQ4g98pSlbykpCRTEc+Xo0ePBiomAACAkNKkqFu3bnL99dfLW2+9JXv27JGKFSvKs88+a5Z/+OGH0rVr1+wOE0C4J0y9e/fOdL1elwkAACDcHDp0SJLmzpLotP9dGiUl5YTs2LFTzp49K8uXL5cO9cpJ/fL5ZMXbE+XAgQMSGxtr7qfVKycvPNJHvk56S/LkySPVq1eT6OhC7v3ExNWWph26Z9MrAxA2CZN+mAAAADjRggULZM/sRyWhRZT3ith/fiTcrrMUjovIin8WlNV/tv3z+436j34p/Mk/94//e/tXwvunpXRcHYmPjw/BKwEQ1j1MAAAATqSXRklKS5b5PnqYdPidXldSh+Ply5dPLMty9zDp6JnU1FRZvHixNGjQwAzTS9/D1GpYbZIlIAcjYQIAADleTEyM9Oo32Oe6VatWyWstW8orfUfIVVddZRKkxMRE6dixo0RGRsq6detkzBsLZeKQZ6RFixYhjx1A9iJhAgAgTObUePZ6pOfq9di6ZGaGOcPpezwU82r817RpU6lataqMHTvWDN1LPyVh3LhxEhcXZ7YDkPuQMAEAEE5zajzm1WTgOa/GU7o5NYp5Nf7LmzevPP/886Yang7dGzp0qJw8eVLWr18vEyZMkEWLFpkqebodgNyHhAkAgDCZU+NPD5NrXs25epiYV5M1WjJck6IhQ4ZIs2bN3Mu1Z4mS4kDuRsIEAECYzanxJf28GgSeJkWdOnWSlStXypIlS6RDhw7SsmVLepaAXM6vhKlEiRJ+X2PpyJEjFxoTAABAttDkqHnz5nLixAnzk2QJgF8J04svvuj+/fDhwzJmzBhp166dNG7c2CzT6jFJSUnyxBNPBC9SAAAAAAjHhKl3797u32+66SYZPXq09O/f371swIAB8vLLL5urZA8aNCg4kQIAAABAiOllrbNEe5Lat2+fYbku04QJAAAAAHJtwlSqVCn56KOPMizXZboOAAAAAHJtlbxRo0bJ3Xffba6K3ahRI7Nsw4YNsnTpUnnttdeCESMAAAAAOCNh6tOnj1xyySUyadIkmTdvnlmm9z/77DN3AgUAAAAAufY6TJoYvfPOO4GPBgAAAACcPIdJ7dixQx5//HHp2bOnHDx40CzTC7x9++23gY4PAAAAAJyTMK1evVrq1Klj5i3NnTtXjh8/bpZ/9dVXMnLkyGDECAAAAADOSJiGDx9uLly7bNkyyZ8/v3v5tddeK+vXrw90fAAAAADgnITpm2++kS5dumRYXqZMGTl06FCg4gIAAAAA5yVMxYsXl3379mVY/uWXX0qFChUCFRcAAAAAOC9huvXWW2XYsGGyf/9+iYiIkLNnz8rnn38uDz/8sNxxxx3BiRIAAAAAnJAwjR07VuLj46VSpUqm4EOtWrWkWbNmcvXVV5vKeQAAAACQa6/DpIUeXnvtNXnyySfNfCZNmi6//HK56KKLghMhAAAIGzpfOWnuLIlOS/ZanpJyQnbs2Om1zLIsOXDggGxdMtOMSkmvevVqEh1dyGtZTFxtadqhe5CiB4AQJEyjR482w++0h0lvLidPnpQJEyaYRAoAAORMCxYskD2zH5WEFlEZV8b6eEBZ/Web753plUn+uTqJW8L7p6V0XB0zmgUAHJkwjRo1Su677z6Jjo72Wp6SkmLWkTABAJBzde7cWZLSkmV+FnqYYmNj/e5hajWsNskSAGcnTPrh5+tDTy9cW7JkyUDFBQAAwlBMTIz06jfYr21TU1MlMTFROnbsKJGRkUGPDQCyNWEqUaKESZT0VrNmTa+kKS0tzcxl0p4nAAAAAMh1CdOLL75oepfuuusuM/SuWLFiXoUgqlatKo0bNw5WnAAAAAAQvglT7969zc+4uDhTQpyudQAAAAA5XZbnMDVv3tz9+6lTp+TMmTNe64sWLRqYyAAAAADAaReu1Wp4/fv3lzJlykihQoXM3CbPGwAAAADk2oRp6NCh8sknn8jUqVMlKipKXn/9dTOnqXz58jJr1qzgRAkAAAAAThiSt3DhQpMYtWjRQu68805p2rSp1KhRQ6pUqSLvvPOO9OrVKziRAgAAAEC49zAdOXJEqlWr5p6vpPfVNddcI2vWrAl8hAAAAADglB4mTZZ27dollStXNlfifv/996Vhw4am56l48eLBiVJEEhISzNA/TxdffLH88MMPQXtOAACA7HLo0CFJmjtLotOSvZanpJyQHTt2ZtheL/9y4MAB2bpkptf1MlX16tUkOrqQ17KYuNrStEP3IEUP5OKESYfhffXVV6Za3vDhw+WGG26Ql19+2VzNe+LEiRJMtWvXluXLl7vv58uX5fABAAAcYcGCBbJn9qOS0CIq48pYmweV1X+2ZVx+/N+bh4T3T0vpuDrmC3AA9rKccQwaNMj9e+vWrU0Pz+bNm808pssuu0yCSROksmXNJwEAAECO1rlzZ0lKS5b5Wexhio2N9auHqdWw2iRLgB8uuItGiz3oLRR+/vlnU42vQIEC0rhxYxk3bpwZGmjn9OnT5uaSnPzPB472huktUFz7CuQ+Q4G4Q8eJMTs1bifGrIg7dJwYs1PjdmLM4RR3sWLF5Oa7HvR7e4132bJl0qZNG4mMjPT7MdkpXI51bojbiTEHO25/9xlh6dcRWbRx40ZZuXKlHDx4UM6ePeu1LljD8pYsWSLHjx8385b27dtn5jPt3btXtm3bJkWKFPF73pN69913JTo6OihxAgAAAAh/en3Znj17yrFjx0wxu4AlTGPHjpXHH3/cJC7pu3z1d71GUygcPXrU9Gxpgta3b1+/e5gqVapkJlFmdlCy6ny+0QkHxB06TozZqXE7MWZF3KHjxJidGrcTY1bEHTpOjNmpcTsx5mDHrblBTEzMOROmLA/Je+mll2T69OnSp08fyU5aka9mzZqyfft22230wrp6S08PdjAaSrD2G2zEHTpOjNmpcTsxZkXcoePEmJ0atxNjVsQdOk6M2alxOzHmYMXt7/6yfB2mPHnySJMmTSS76fC8HTt2SLly5bI7FAAAAAA5VJ7zqZI3ZcoUCbWHH35YVq9eLbt375a1a9dKly5dJG/evNKjR4+QxwIAAAAgd8h3PonLddddJ9WrV5datWpl6MqaN2+eBMOePXtMcnT48GEpXbq0XHPNNbJ+/XrzOwAAAACERcI0YMAAUyGvZcuWUqpUqQx1/oNlzpw5IXkeAAAAADjvhGnmzJkyd+5c08sEAMhZtIpo0txZEp3FC2VuXTLTrwtlxsTVlqYdugcpegAAwiBhKlmypBmOBwDIeRYsWCB7Zj8qCS0yVhiVWJsHldV/tmVcfvzfm4eE909L6bg6Eh8fH5B4AQAIu4RJLwY7cuRImTFjBhd/BYAcpnPnzpKUlizzs9jDlP66fHY9TK2G1SZZAgDk7IRp0qRJppy3/nGsWrVqhqIPW7ZsCWR8AIAQ0gv49eo3OEsXFExMTJSOHTs68roeAAAEPGHSbx8BAAAAIDfIcsKkw/EAAAAAIDfI8oVrAQAAACC3yOdvZbyffvrJjG0vUaJEptdeOnLkSCDjAwAAAIDwTpheeOEFKVKkiPv3UF2sFgAAAADCPmHq3bu3+/c+ffoEMx4AAAAAcO4cprx588rBgwczLD98+LBZBwAAAAC5NmHSixT6cvr0acmfP38gYgIAAAAAZ5UV1wvWKp2/9Prrr0vhwoXd69LS0mTNmjVcvR0AAABA7kyYtNiDq4dp2rRpXsPvtGepatWqZjkAAAAA5LqEadeuXeZny5YtZd68eaa8OAAAAADkZFmew7Ry5UqvZEmH423dulX+/PPPQMcGAAAAAM5KmAYOHChvvPGGO1lq1qyZXHHFFVKpUiVZtWpVMGIEAAAAAGckTB988IHUrVvX/L5w4ULZvXu3/PDDDzJo0CB57LHHghEjAAAAADgjYdLrLZUtW9b8npiYKN27d5eaNWvKXXfdJd98800wYgQAAAAAZyRMsbGx8t1335nheEuXLpU2bdqY5SkpKVy4FgAAAEDurJLncuedd8rNN98s5cqVM9dkat26tVm+YcMGrsMEAAAAIHcnTAkJCXLppZfKb7/9ZobjRUVFmeXauzR8+PBgxAgAAAAAzkiYVLdu3TIs6927dyDiAQAAAADnzWHq2LGjHDt2zH1//PjxcvToUa9iELVq1Qp8hAAAAAAQ7glTUlKSnD592n1/7NixcuTIEff9v//+W3788cfARwgAAAAA4Z4wWZaV6X0AAAAAkNxeVhwAAAAAcgu/EyYtIa639MsAAAAAQHJ7lTwdgtenTx93GfFTp07JfffdJ4UKFTL3Pec3AQAAAECuSpjSlw2/7bbbMmxzxx13BCYqwAEOHTokSXNnSXRastfylJQTsmPHzgxfOBw4cEC2Lpnps2e2evVqEh39z5cPLjFxtaVph+5Bih4AAAABTZhmzJjh76ZArrBgwQLZM/tRSWjxT6+rl1gfDyir/2zzvbPj/948JLx/WkrH1ZH4+PiAxAsAAIAQXbgWgEjnzp0lKS1Z5mehhyk2NtbvHqZWw2qTLAEAAGQzEibgPMXExEivfoP92jY1NVUSExPNBaAjIyODHhsAAAACg7LiAAAAAGCDhAkAAAAAbJAwAQAAAIANEiYAAAAAsEHCBAAAAAA2SJgAAAAAwAYJEwAAAADYIGECAAAAABskTAAAAABgg4QJAAAAAGyQMAEAAACADRImAAAAALBBwgQAAAAANkiYAAAAAMAGCRMAAAAA2CBhAgAAAAAbJEwAAAAAYIOECQAAAABskDABAAAAgA0SJgAAAACwQcIEAAAAADZImAAAAADABgkTAAAAANggYQIAAAAAGyRMAAAAAGCDhAkAAAAAbJAwAQAAAIANEiYAAAAAsEHCBAAAAAA2SJgAAAAAwAYJEwAAAADYIGECAAAAABskTAAAAACQUxKmKVOmSNWqVaVAgQLSqFEj+eKLL7I7JAAAAAA5lKMSpvfee08GDx4sI0eOlC1btkjdunWlXbt2cvDgwewODQAAAEAO5KiEaeLEiXLPPffInXfeKbVq1ZJp06ZJdHS0TJ8+PbtDAwAAAJAD5ROHOHPmjGzevFlGjBjhXpYnTx5p3bq1rFu3zudjTp8+bW4uycnJ5mdqaqq5BYprX4HcZygQd+g4MWanxu3EmBVxh44TY3Zq3E6MWRF36DgxZqfG7cSYgx23v/uMsCzLEgf4/fffpUKFCrJ27Vpp3Lixe/kjjzwiq1evlg0bNmR4TEJCgowaNSrD8nfffdf0TAEAAADInVJSUqRnz55y7NgxKVq0qPN7mM6H9kbpnCfPHqZKlSpJ27ZtMz0o55OdLlu2TNq0aSORkZHiFMQdOk6M2alxOzFmRdyh48SYnRq3E2NWxB06TozZqXE7MeZgx+0afXYujkmYYmJiJG/evHLgwAGv5Xq/bNmyPh8TFRVlbunpwQ5GQwnWfoONuEPHiTE7NW4nxqyIO3ScGLNT43ZizIq4Q8eJMTs1bifGHKy4/d2fY4o+5M+fX+rXry8rVqxwLzt79qy57zlEDwAAAAACxTE9TEqH1/Xu3VsaNGggDRs2lBdffFFOnDhhquYBAAAAQK5OmG655Rb5448/5Mknn5T9+/dLvXr1ZOnSpRIbG5vdoQEAAADIgRyVMKn+/fubGwAAAAAEm2PmMAEAAABAqJEwAQAAAIANEiYAAAAAsEHCBAAAAAA2SJgAAAAAwAYJEwAAAADYIGECAAAAABskTAAAAABgg4QJAAAAAGyQMAEAAACADRImAAAAALBBwgQAAAAANkiYAAAAAMAGCRMAAAAA2CBhAgAAAAAbJEwAAAAAYIOECQAAAABskDABAAAAgA0SJgAAAACwQcIEAAAAADZImAAAAADABgkTAAAAANggYQIAAAAAGyRMAAAAAGCDhAkAAAAAbJAwAQAAAIANEiYAAAAAsEHCBAAAAAA2SJgAAAAAwAYJEwAAAADYIGECAAAAABskTAAAAABgg4QJAAAAAGzks1sBhMqhQ4ckae4siU5L9lqeknJCduzYmWF7y7LkwIEDsnXJTImIiPBaV716NYmOLuS1LCautjTt0D1I0QMAACAnI2FCtluwYIHsmf2oJLSIyrgy1uZBZfWfbRmXH//35iHh/dNSOq6OxMfHByReAAAA5B4kTMh2nTt3lqS0ZJmfxR6m2NhYv3qYWg2rTbIEAACA80LChGwXExMjvfoN9nv71NRUSUxMlI4dO0pkZGRQYwMAAEDuRtEHAAAAALBBwgQAAAAANkiYAAAAAMAGCRMAAAAA2CBhAgAAAAAbJEwAAAAAYIOECQAAAABskDABAAAAgA0SJgAAAACwQcIEAAAAADZImAAAAADABgkTAAAAANggYQIAAAAAGyRMAAAAAGCDhAkAAAAAbJAwAQAAAIANEiYAAAAAsEHCBAAAAAA2SJgAAAAAwAYJEwAAAADYIGECAAAAABskTAAAAABgg4QJAAAAAGyQMAEAAACADRImAAAAALBBwgQAAAAANkiYAAAAAMAGCRMAAAAA2CBhAgAAAACnJ0xVq1aViIgIr9v48eOzOywAAAAAOVg+cZDRo0fLPffc475fpEiRbI0HAAAAQM7mqIRJE6SyZctmdxgAAAAAcglHJUw6BO+pp56SypUrS8+ePWXQoEGSL5/9Szh9+rS5uRw7dsz8PHLkiKSmpgYsLt1XSkqKHD58WCIjI8UpiDt0nBizU+N2YsyKuEPHiTE7NW4nxqyIO3ScGLNT43ZizMGO+6+//jI/LcvKGQnTgAED5IorrpCSJUvK2rVrZcSIEbJv3z6ZOHGi7WPGjRsno0aNyrA8Li4uyNECAAAAcAJNnIoVK2a7PsI6V0oVRMOHD5dnnnkm022+//57iY+Pz7B8+vTp0q9fPzl+/LhERUX51cN09uxZ07tUqlQpUzQiUJKTk6VSpUry22+/SdGiRcUpiDt0nBizU+N2YsyKuEPHiTE7NW4nxqyIO3ScGLNT43ZizMGOW9MgTZbKly8vefLkCc8epiFDhkifPn0y3aZatWo+lzdq1Ej+/vtv2b17t1x88cU+t9FEKn0yVbx4cQkWfROd1ABdiDt0nBizU+N2YsyKuEPHiTE7NW4nxqyIO3ScGLNT43ZizMGMO7OepbBImEqXLm1u52Pr1q0mEyxTpkzA4wIAAAAAx8xhWrdunWzYsEFatmxpKuXpfS34cNttt0mJEiWyOzwAAAAAOZQjEiYdVjdnzhxJSEgwc5K0aIMmTIMHD5ZwiW/kyJG2c6nCFXGHjhNjdmrcToxZEXfoODFmp8btxJgVcYeOE2N2atxOjDlc4s7Wog8AAAAAEM7sy0EAAAAAQC5HwgQAAAAANkiYAAAAAMAGCRMAAAAA2CBhOod58+ZJ27ZtpVSpUhIREWGu/5TeqVOn5IEHHjDbFC5cWG666SY5cOCA1za//vqrXHfddRIdHW2uHTV06FBz4d1Q0QsEa/yet/bt23ttc+TIEenVq5e5KJhe4Ldv375y/PhxyS6pqakybNgwqVOnjhQqVMhchfmOO+6Q33//Pazj9rfdtGjRIsN7ct9994nT23p286ethxt/23q48afNhKMpU6ZI1apVpUCBAuYi6F988YWEszVr1sgNN9xg2oUe5wULFki4GzdunFx55ZXmUiD6N69z587y448/SrjTarzpPz/i4+PFSe1Ba3k9+eSTUq5cOSlYsKC0bt1afv75Zwn3uMPxs9ufdhyOfxfP1Y7DIeY1AWjHoTz/I2E6hxMnTsg111wjzzzzjO02WuJ84cKF8sEHH8jq1avNSU7Xrl3d69PS0kyydObMGVm7dq3MnDlT3nzzTdMQQkk/ePbt2+e+zZ4922u9Nrpvv/1Wli1bJosWLTKN+d5775XskpKSIlu2bJEnnnjC/NSTM/2guvHGG8M6bn/bjbrnnnu83pNnn31WnNzWw8W52nq48bethxt/23k4ee+998wlKbRErR7runXrSrt27eTgwYMSzsdZ49REzyn080FPyNavX28+m/VLAU2u9bWEu9q1a3t9fnz22WfipPagf0cmTZok06ZNM9ew1C9htI3rSXK4t+Nw++z2px2H69/FzNpxOMR8IgDtOKTnf1pWHOe2a9cuLb9uffnll17Ljx49akVGRloffPCBe9n3339vtl23bp25n5iYaOXJk8fav3+/e5upU6daRYsWtU6fPh2S+Hv37m116tTJdv13331nYt64caN72ZIlS6yIiAhr7969Vrj44osvTJy//PKLI+K2azeqefPm1kMPPWTlpLYeDs7V1p0ifVsPZ5m183DTsGFD64EHHnDfT0tLs8qXL2+NGzfOcgI9zvPnz7ec5uDBgyb21atXW+Fs5MiRVt26dS2nSN8ezp49a5UtW9aaMGGC12d3VFSUNXv2bCuc27ETPrvTt+Nw/buYWTsOx5jlPNpxqM//6GG6QJs3bzbfOGhXoYt2e1auXFnWrVtn7utPHWoTGxvr3kaz5OTkZJMZh8qqVatMl/LFF18s999/vxw+fNi9TmPU7swGDRq4l+lrypMnj8nsw8WxY8dM163G6qS47bzzzjsSExMjl156qYwYMcL0NDi5rYeLzNq6U6Rv67hw2suv7dizDetnhd4Ptzac02h7ViVLlpRwp8N+dJhQtWrVzDfYOqTeKXbt2iX79+/3auPFihUzQ0+d0MbD/bM7fTsO57+Ldu04nGPOSjsO9flfvoDvMZfRNzR//vwZTmo0OdJ1rm08kyXXete6UNBubu1ujYuLkx07dsijjz4qHTp0MA0ub968Jg79kPKUL18+86EQqhjPRbthdZ5Hjx49zHhV5YS47fTs2VOqVKliPtC+/vpr89p0GJYOx3JqWw8H52rrTuCrrePCHTp0yAyR9vV5/MMPP2RbXDnd2bNnZeDAgdKkSRPz5VA40xMyHTKvJ+w6jGnUqFHStGlT2bZtm5nHEu5cn8W+2ng4fU478bPbVzsO17+LmbXjcI05q+041Od/9DCl+7ZfJ7+5bp9++qnklNdx6623mvkQ2tOlkxZ1rOfGjRvNtzlOOP76bcjNN99sJgFOnTpVckK70XG22tOo74l++zNr1iyZP3+++UMRrjGHG9p66OSUNoPQ0zkgeqI2Z84cCXd6gt69e3e57LLLzOdzYmKiHD16VN5///3sDi3HC/fPbtpx7kYPkwf9j6pZuUuFChXO+ZiyZcuaYR7aED2zda02outc26SvwuSqRuLaJtSvQ7todSjY9u3bpVWrViaO9JOetYqfViAJRoxZidt1AvnLL7/IJ5984vWNezjHnVWufeh7Ur16dXFiWw+182nr4eB82np2C1Q7z07aDvSb6vTVoLKzDed0/fv3d0/GrlixojiNftbVrFnTfH44gasda5vW6mIuer9evXriJOH02W3XjsPx7+K52nGbNm3CPuayfrTjUJ//0cPkQbvba9So4b5pGcNzqV+/vkRGRsqKFSvcy3RYlY4Vbdy4sbmvP7/55huvN1YreujJUK1atbLldezZs8eMDXY1RI1R//Po2FYXPWHTLmjPk6Rg8hW36wRSx+IuX77clMD0FK5xnw9XSWbPDwentfVQO5+2Hg7Op61nt0C18+ykw1C0HXu2Yf2s0PvZ1YZzKu0h1ZNM7TXXz2QdZuVEWqJYe/3D6fMjM3qc9WTRs43rfGmd0+G0Nh4On93nasfh+HfxXO3YCTHH+dGOQ37+F/AyEjnM4cOHTeWnxYsXm2occ+bMMff37dvn3ua+++6zKleubH3yySfWpk2brMaNG5uby99//21deumlVtu2ba2tW7daS5cutUqXLm2NGDEiJK/hr7/+sh5++GFT/USrWS1fvty64oorrIsuusg6deqUe7v27dtbl19+ubVhwwbrs88+M+t79OhhZZczZ85YN954o1WxYkVz3PSYu26e1QXDLW5/2s327dut0aNHm/ai78lHH31kVatWzWrWrFnYxuxPW89u/rb1cONvWw83/rSZcKMxaqWlN99801RZuvfee63ixYt7VTENN9qu9bjqTY/zxIkTze/hXEHx/vvvt4oVK2atWrXKqz2npKRY4WzIkCEmZv38+Pzzz63WrVtbMTExpjqaU9rD+PHjTZvWvytff/21qTwXFxdnnTx5MmzjDtfPbn/acTj+XTxXOw6HmP8KQDsO5fkfCdM5zJgxw7yR6W9astFF37z//Oc/VokSJazo6GirS5cuGU4Ydu/ebXXo0MEqWLCgabTamFNTU0PyGvQ/tiZrmqRpKckqVapY99xzT4YTBD350YZWuHBhU/L8zjvvNA06u0sV+7qtXLkybOP2p938+uuvJjkqWbKkOXmrUaOGNXToUOvYsWNhG7O/bT07+dvWw42/bT3c+NNmwtHkyZPNyUL+/PlNmfH169db4UzbgK/jrGWYw5Vde9Y2E85uueUWq1y5cqZtVKhQwdzXL7ic1B60JPMTTzxhxcbGmr8vrVq1sn788cewjjtcP7v9acfh+HfxXO04HGJeGYB2HMrzvwj9J/D9VgAAAADgfMxhAgAAAAAbJEwAAAAAYIOECQAAAABskDABAAAAgA0SJgAAAACwQcIEAAAAADZImAAAAADABgkTAAAAANggYQIAnLfDhw9LmTJlZPfu3SF93gULFkiNGjUkb968MnDgQHnzzTelePHiEs6qVq0qL774YqbbJCQkSGxsrERERJjX2KdPH+ncuXNQ4zqfY6fvt8a4detWvx/TokUL814FypkzZ8wx3bRpU8D2CQC+kDABQCb0pDCzm57gXsi+9aTYHytXrpSOHTtKqVKlJDo6WmrVqiVDhgyRvXv3SnZ6+umnpVOnTubENZT69esn3bp1k99++02eeuopueWWW+Snn34SJ/v+++9l1KhR8uqrr8q+ffukQ4cO8tJLL5mEBhnlz59fHn74YRk2bFh2hwIghyNhAoBM6Imr66a9A0WLFvVapidswaYn0K1bt5ayZcvK3Llz5bvvvpNp06bJsWPH5Pnnn5fskpKSIm+88Yb07ds3pM97/PhxOXjwoLRr107Kly8vRYoUkYIFC5qermDTXo1g2bFjh/mpCai+11FRUVKsWLGw7znLTr169ZLPPvtMvv322+wOBUAORsIEAJnQE1fXTU9etVfIc9mcOXPkkksukQIFCkh8fLy88sorXifX/fv3l3Llypn1VapUkXHjxpl1rh6ZLl26mH3a9dDs2bNHBgwYYG7Tp083w5p022bNmsnrr78uTz75pHtoXI8ePaRChQqmB6pOnToye/Zsr319+OGHZrkmF9pTpUnYiRMn3Ot1f3avxZfExERzUn/VVVd5LdeT1+uvv94kl5rMNG3a1J0MnD17VkaPHi0VK1Y0j61Xr54sXbo0w1CvefPmScuWLc1rqVu3rqxbt86sX7Vqldmnuvbaa822uszXsLIxY8aYJEq3v/vuu2X48OHm+TIbIqbD33QYnIsea+3BuuOOO8zruffee81yPUnX16XHslKlSub98TyWmtDdcMMNZn1cXJy88847mR5L7anU7VWePHnM61KeQ/L++OMP0+bGjh3rftzatWtNT8uKFSvM/dOnT5skXttBoUKFpFGjRub4eNJjVblyZXNstf1p2zmXL774Qi6//HLTNho0aCBffvllhm22bdtmesUKFy5shhXefvvtcujQIdt9vvXWW2Zf+v7o6+rZs6c5bsqyLDPk8rnnnvN6jA4B1GOzfft2c79EiRLSpEkT8/8QAILGAgD4ZcaMGVaxYsXc999++22rXLly1ty5c62dO3eanyVLlrTefPNNs37ChAlWpUqVrDVr1li7d++2Pv30U+vdd9816w4ePGjpR7Duc9++fea+LxMnTjTb/f7775nGtmfPHvN8X375pbVjxw5r0qRJVt68ea0NGzaY9fr4fPnymf3t2rXL+vrrr60pU6ZYf/31l1+vxZcBAwZY7du3zxCHPq5r167Wxo0brR9//NGaPn269cMPP7hfT9GiRa3Zs2ebZY888ogVGRlp/fTTT2a9xqavNz4+3lq0aJF5fLdu3awqVapYqamp1unTp80y3UZj1GOny3y9NwUKFDDPrduPGjXKPG/dunXd2zRv3tx66KGHvOLv1KmT1bt3b/d9fV593HPPPWdt377dfStUqJD1wgsvmLg///xz6/LLL7f69OnjflyHDh3Mc61bt87atGmTdfXVV1sFCxY0j/FF3wd9Dfq69DXpTWksGpPL4sWLzfHSY5ucnGxVq1bNGjRokHv93XffbZ5L25zGqW0iKirKfXzXr19v5cmTx3rmmWfMcXnppZes4sWLex07X7GVLl3a6tmzp7Vt2zZr4cKF5nk1Vm1v6s8//zTbjBgxwvr++++tLVu2WG3atLFatmxpe7zfeOMNKzEx0bRXPU6NGzc2x83l6aeftmrVqpWhzTVr1sxr2bBhw8y+ASBYSJgAwE/pT8qrV6/uToBcnnrqKXPipx588EHr2muvtc6ePetzf3rCOX/+/Eyf8/777zcn7Ofjuuuus4YMGWJ+37x5s3k+Tdx8Oddr8UVP5O+66y6vZXrCHBcXZ505c8bnY8qXL29OhD1deeWV1n/+8x+vhOn11193r//222/NMj0Rd52c6/2VK1favjeNGjWyHnjgAa/nadKkyXklTJ07d/bapm/fvta9997rtUyTYU1ETp486U7ovvjiC/d6jV2X2SVMSttC+u8x0ydMSo9VzZo1TQJTp04d69SpU2b5L7/8YpLkvXv3em3fqlUr876oHj16WB07dvRaf8stt2SaML366qtWqVKlzGtzmTp1qlfCpG2lbdu2Xo/77bffzDZ6POyOtydNAnV7VxKvr8Mz6dc2FRMTkyGJ16SvatWqtvsFgAvFkDwAOA86/EqHmen8HR2C5LrpMDDX8DMdTqVDiC6++GIzZOvjjz/O8vNoXuUanpWZtLQ0M3RMh9yVLFnSxJKUlCS//vqrWa/D2lq1amXWd+/eXV577TX5888//X4tvpw8edIM0fKkr1eHqkVGRmbYPjk5WX7//XczhMqT3teCB54uu+wy9+86pFG5hmv548cff5SGDRt6LUt/3186bMzTV199ZYa1eR4rnU+lww137dplXku+fPmkfv367sfoEMdAzUXSYWp///23fPDBB2aonw5tVN98841pBzVr1vSKbfXq1e73UWPTYXqeGjdunOnz6WP0/fB8r9M/Ro+JFibxfF59zcquDW3evNkMQ9ThgTosr3nz5ma5q83q/LTrrrvODEVVCxcuNEMOtf160mGPOp8OAIIlX9D2DAA5mBYeUJp4pD8B1VLX6oorrjAn0EuWLJHly5fLzTffbOYN6Vwif+nJrxZ30AITrsTBlwkTJpiKalqYQpMinb+i83NcRQo0pmXLlpk5L5q4TZ48WR577DHZsGGDmctyrtfiS0xMjDvp8jx5DQTPhMuVMGpCEkg6V+ifjr7/SU1NzbCdHsv0771W6dMkOD09+Q92tT5NQDTx1OOhc770/XbFpe+XJiLp3zdNYIJJn1uTn2eeeSbDOl/tVpN0TTL1pklf6dKlTaKk9z0La+jcM50L9cILL8iMGTNMNURXe3U5cuSIeTwABAs9TABwHnRSu34DvnPnTjM53fOmk/xdtFCAnuRpMvLee++ZKnd6gudKCrRHIDNaOlsn9T/77LM+1x89etT8/Pzzz011tdtuu830JlWrVi3DibsmHtqbo6WrddK+7nf+/Pl+v5b0tAiAVuzzpD0Rn376qc/EQ4+FPo/G6knva5n0QNJevY0bN3otS39fT7I1EXXR90ILF5yLJsL6utMfK73pMdWeFe0B0sTFs8fL9V5dCE0m9D3WNqU9ippQuHre9P3Q16D308elRRWUFvXQJNnT+vXrM31OfczXX38tp06dsn2MHhMt9qFFMtI/d/qEU/3www+m2MT48eNNj6QeM189iFpKXx8/depUUxzkrrvuyrCNvmf62gEgWEiYAOA8aeKhVe8mTZpkkhMdEqXfgk+cONGs159aqU5PDnW9DqHSE1fX0Cw9udTqZvv378/QU+OiFdj023XtPdIhczq86pdffjFJhvZy6Emzuuiii9w9SDqEStcdOHDAvR89SdbqanqRT/0mX6vQadU1PRn257X4or0BepLsGbtWBdShd7feeqt5rp9//tlUQ9OEQQ0dOtT0QmjyqMu0cp0O43vooYckkB588EFT8nzmzJkmBh1eqCf9nsMbtcre4sWLzU3fo/vvv9+vpEav+6PHWV+rxq77/+ijj8x9V7LWvn178x7ocdfESRObQPS+aa+g9jjq+6RxaA+kK4nQ37XMtlb00/dXeze1up2+r/oalfaKaeKhw/o07pdfftmrSqEvWr1Oj9s999xjEkWtjpi+et0DDzxgvgjQSo2amGovmA4JvfPOO31+KaA9cZpcak+nJur//e9/3W3Zk/aU6dDWESNGmDbua/igJuht27bN8rEEAL9d8CwoAMgl0hcWUO+8845Vr149K3/+/FaJEiVMBa958+aZdf/3f/9n1mlFNS3coJPvtXqYy3//+1+rRo0apnqdFhfIzLJly6x27dqZ59Dqb1pF7uGHH3ZXzzt8+LApDlC4cGGrTJky1uOPP27dcccd7oIB3333nXm8VjLTqmlaNGDy5Ml+vxY7DRs2tKZNm+a17KuvvjIFAKKjo60iRYpYTZs2NZXQVFpampWQkGBVqFDBVHvTIgxLlixxP9ZV9MFVTMBXkQd/ij6o0aNHmyIBeky0OIVWWLvqqqvc67WIgBbV0Kp+eszGjRvns+iDr0INWtBBq8DpvvX9veyyy7yKWWiVOy26oce6cuXK1qxZs2z35W/RB3292la0wITn8dK29corr7hf05NPPmmKIOjx1cqHXbp0MVURPavTVaxY0VTtu+GGG0wFwMyKPiitYqfvlbYNbSNaoTD9+6SV+PS5tOqe7lvb6MCBA91FT9IXfdAiIxqnHiMtLqL/H9LvU2nb0eXPPvtshrjWrl1rni8lJSXT+AHgQkToP/6nVwAA/I/2XGivkQ6L0jlB4axNmzamh097vOAc2oOkBUt+++03M3zUkw5N1CGojz76aLbFByDno+gDAOC8aRUzHdq1d+9eM3wwXGjVtGnTpplhgzqsS4dGauENHbYIZ9CKeDpsVC/qq5Xx0idLOp9LC14MGjQo22IEkDvQwwQAyHG05LlWbdPiFlqsQOcVPf7449K1a9fsDg1+0tLtOm+vXr16Zo5ThQoVsjskALkUCRMAAAAA2AjvAecAAAAAkI1ImAAAAADABgkTAAAAANggYQIAAAAAGyRMAAAAAGCDhAkAAAAAbJAwAQAAAIANEiYAAAAAEN/+H2kJSnDflPyZAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10,5))\n", - "plt.title(\"(REF0,MIC0) Estimated Delays\")\n", - "plt.boxplot(np.array(est_delays)[:,0].reshape(len(test_cases),-1).T*1000);\n", - "plt.grid(True)\n", - "plt.ylabel(\"Estimated Delay (ms)\");\n", - "plt.xticks( np.arange(1, len(test_cases)+1), map(str, sorted(test_cases.keys())) );\n", - "plt.xlabel(\"Test Case (configured fixed delay)\");\n", - "plt.ylim(-5,20)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Further Analysis of Test Case with 1ms fixed delay" - ] - }, - { - "cell_type": "code", - "execution_count": 94, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[(0, -100),\n", - " (1, -50),\n", - " (2, -20),\n", - " (3, -15),\n", - " (4, -10),\n", - " (5, -5),\n", - " (6, -2),\n", - " (7, -1),\n", - " (8, 0),\n", - " (9, 1),\n", - " (10, 2),\n", - " (11, 5),\n", - " (12, 10),\n", - " (13, 15),\n", - " (14, 20),\n", - " (15, 50),\n", - " (16, 100)]" - ] - }, - "execution_count": 94, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "list(enumerate(sorted(test_cases)))" - ] - }, - { - "cell_type": "code", - "execution_count": 100, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Case 10 - Delay: 1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "TEST_CASE_IDX = 9\n", - "print(f\"Case {TEST_CASE_IDX+1} - Delay: {sorted(test_cases)[TEST_CASE_IDX]}\")\n", - "fs=16000\n", - "audio_data = channels[TEST_CASE_IDX*RUNS_PER_CASE+3,:].T\n", - "channel_names = [\n", - " \"PROC 0\",\n", - " \"RPOC 1\",\n", - " \"REF 0\",\n", - " \"REF 1\",\n", - " \"MIC 0\",\n", - " \"MIC 1\"\n", - "]\n", - "num_samples, num_channels = audio_data.shape if len(audio_data.shape) > 1 else (len(audio_data), 1)\n", - "\n", - "# Create time axis\n", - "time_axis = np.linspace(0, num_samples / fs, num=num_samples)\n", - "\n", - "# Limit to first 6 channels for plotting\n", - "num_channels_to_plot = min(num_channels, 6)\n", - "\n", - "# Create subplots\n", - "fig, axes = plt.subplots(num_channels_to_plot, 1, figsize=(12, 8), sharex=True)\n", - "fig.suptitle(f\"Waveform of chirp_record ({num_channels} Channels)\", fontsize=14)\n", - "\n", - "if num_channels_to_plot == 1:\n", - " axes = [axes] # Ensure axes is iterable for mono files\n", - "\n", - "# Plot each channel separately\n", - "for i in range(num_channels_to_plot):\n", - " axes[i].plot(time_axis, audio_data[:, i], label=f\"{channel_names[i]}\", color=f\"C{i}\")\n", - " axes[i].set_ylabel(\"Amplitude\")\n", - " axes[i].legend(loc=\"upper right\")\n", - " axes[i].grid(True)\n", - "\n", - "# Set common labels\n", - "axes[-1].set_xlabel(\"Time (seconds)\")\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.15" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/orbit/notebooks/VAD-Analysis.ipynb b/orbit/notebooks/VAD-Analysis.ipynb deleted file mode 100644 index 7db2735..0000000 --- a/orbit/notebooks/VAD-Analysis.ipynb +++ /dev/null @@ -1,213 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from orbit.audio.utils import read_wav_wave\n", - "from silero_vad import load_silero_vad, get_speech_timestamps\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "SAMPLING_RATE=16000" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "model = load_silero_vad()" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "Reading '/Users/mischa/Projects/AEC/no_ref_record.wav/untitled.wav'...\n", - "Channels: 6, Sample Width: 2 bytes, Sample Rate: 16000 Hz, Frames: 214640\n" - ] - } - ], - "source": [ - "wav_file = \"/Users/mischa/Projects/AEC/no_ref_record.wav/untitled.wav\"\n", - "fs, samples = read_wav_wave(wav_file)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "audio_data = samples\n", - "channel_names = [\n", - " \"PROC 0\",\n", - " \"RPOC 1\",\n", - " \"REF 0\",\n", - " \"REF 1\",\n", - " \"MIC 0\",\n", - " \"MIC 1\"\n", - "]\n", - "num_samples, num_channels = audio_data.shape if len(audio_data.shape) > 1 else (len(audio_data), 1)\n", - "\n", - "# Create time axis\n", - "time_axis = np.linspace(0, num_samples / fs, num=num_samples)\n", - "\n", - "# Limit to first 6 channels for plotting\n", - "num_channels_to_plot = min(num_channels, 6)\n", - "\n", - "# Create subplots\n", - "fig, axes = plt.subplots(num_channels_to_plot, 1, figsize=(12, 8), sharex=True)\n", - "fig.suptitle(f\"Waveform of chirp_record ({num_channels} Channels)\", fontsize=14)\n", - "\n", - "if num_channels_to_plot == 1:\n", - " axes = [axes] # Ensure axes is iterable for mono files\n", - "\n", - "# Plot each channel separately\n", - "for i in range(num_channels_to_plot):\n", - " axes[i].plot(time_axis, audio_data[:, i], label=f\"{channel_names[i]}\", color=f\"C{i}\")\n", - " axes[i].set_ylabel(\"Amplitude\")\n", - " axes[i].legend(loc=\"upper right\")\n", - " axes[i].grid(True)\n", - "\n", - "# Set common labels\n", - "axes[-1].set_xlabel(\"Time (seconds)\")\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "min_speech_duration_ms: int (default - 250 milliseconds)\n", - " Final speech chunks shorter min_speech_duration_ms are thrown out\n", - "\n", - " max_speech_duration_s: int (default - inf)\n", - " Maximum duration of speech chunks in seconds\n", - " Chunks longer than max_speech_duration_s will be split at the timestamp of the last silence that lasts more than 100ms (if any), to prevent agressive cutting.\n", - " Otherwise, they will be split aggressively just before max_speech_duration_s.\n", - "\n", - " min_silence_duration_ms: int (default - 100 milliseconds)\n", - " In the end of each speech chunk wait for min_silence_duration_ms before separating it\n", - "\n", - " speech_pad_ms: int (default - 30 milliseconds)\n", - " Final speech chunks are padded by speech_pad_ms each side\n", - "\n", - "neg_threshold: float (default = threshold - 0.15)\n", - " Negative threshold (noise or exit threshold). If model's current state is SPEECH, values BELOW this value are considered as NON-SPEECH." - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "CHANNEL = 1\n", - "options= {\n", - " \"threshold\" : 0.5,\n", - " \"min_speech_duration_ms\" : 1000,\n", - " \"min_speech_duration_ms\" : 250,\n", - " \"max_speech_duration_s\" : float('inf'),\n", - " \"min_silence_duration_ms\" : 100,\n", - " \"speech_pad_ms\" : 30,\n", - " \"neg_threshold\" : None\n", - "}\n", - "\n", - "speech_timestamps = get_speech_timestamps( samples[:,CHANNEL], model, sampling_rate=SAMPLING_RATE, visualize_probs=True, return_seconds=True, **options)\n", - "plt.axhline( options[\"threshold\"], color=\"red\")\n", - "for region in speech_timestamps:\n", - " plt.axvspan(region[\"start\"], region[\"end\"] , color=\"red\", alpha=0.3, label=\"Highlighted Region\")\n", - "\n", - "curr_ax = plt.gca()\n", - "new_ax = plt.subplot(2,1,1)\n", - "curr_ax.set_position(new_ax.get_position())\n", - "new_ax.remove()\n", - "#plt.gcf().set_size_inches((16,16))\n", - "#fig = plt.figure(figsize=(12,4));\n", - "plt.subplot(2,1,2)\n", - "plt.plot(time_axis, audio_data[:, CHANNEL], label=f\"{channel_names[CHANNEL]}\", color=f\"C{CHANNEL}\")\n", - "plt.ylabel(\"Amplitude\")\n", - "plt.legend(loc=\"upper right\")\n", - "plt.xlim( curr_ax.get_xlim() )\n", - "plt.grid(True)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.15" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/orbit/orbit/__init__.py b/orbit/orbit/__init__.py deleted file mode 100644 index 114a65e..0000000 --- a/orbit/orbit/__init__.py +++ /dev/null @@ -1,20 +0,0 @@ -from pathlib import Path - -PROJ_ROOT = Path(__file__).parent.parent - -XTC_PATH="/Users/mischa/Projects/FutureProofHomes/XMOS_XTC_15.3.1" - -BOARD_USB_IDS = { - "Satellite1" : "20b1:4a05", - "Explorer" : "20b1:4001" -} - -BOARD_SND_CARD_NAMES = { - "Satellite1" : "SATELLITE1", - "Explorer" : "XCORE-VOICE" -} - -BOARD_XTAG_IDS = { - "Satellite1" : "W256H8UD", - "Explorer" : "4LG2K2A6" -} \ No newline at end of file diff --git a/orbit/orbit/audio/__init__.py b/orbit/orbit/audio/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/orbit/orbit/audio/analysis.py b/orbit/orbit/audio/analysis.py deleted file mode 100644 index a231618..0000000 --- a/orbit/orbit/audio/analysis.py +++ /dev/null @@ -1,27 +0,0 @@ -from orbit.audio.utils import read_wav_wave -import numpy as np -from scipy.signal import correlate - -def calc_channel_variances( wav_file:str ) -> list[float]: - fs, audio_data = read_wav_wave(wav_file) - return audio_data.var(axis=0) - - -def estimate_time_delay(reference_signal:np.array, delayed_signal:np.array, fs=int) -> tuple[float, np.array]: - """ - Estimate time delay using cross-correlation. - - Parameters: - reference_signal (numpy array): Original signal. - delayed_signal (numpy array): Delayed version of the signal. - fs (int): Sampling rate in Hz. - - Returns: - estimated_delay_sec (float): Estimated delay in seconds. - correlation (numpy array): Cross-correlation of the two signals. - """ - correlation = correlate(delayed_signal, reference_signal, mode="full") - delay_samples = np.argmax(correlation) - len(reference_signal) + 1 - estimated_delay_sec = delay_samples / fs - - return estimated_delay_sec, correlation \ No newline at end of file diff --git a/orbit/orbit/audio/sox.py b/orbit/orbit/audio/sox.py deleted file mode 100644 index 6937349..0000000 --- a/orbit/orbit/audio/sox.py +++ /dev/null @@ -1,18 +0,0 @@ -import subprocess -import time - -def run_playback_and_record( play_file:str, out_file:str, device:str, timeout_s:int=90 ) -> None : - """Run playback and record in parallel.""" - print( f"Running playback and record for {play_file} on device {device} ..." ) - - cmd = f'sox -t coreaudio {device} --channels=6 --rate=16000 -b 16 --encoding=signed-integer --endian=little --no-dither -t wavpcm "{out_file}" &' - cmd += "SOX_PID=$!; " - cmd += f'sox -t wav "{play_file}" -t coreaudio {device}' - cmd += "&& kill $SOX_PID" - try: - subprocess.run(cmd, timeout=timeout_s, text=True, shell=True) - except subprocess.TimeoutExpired: - print(f'Timeout for {cmd} ({timeout_s}s) expired') - raise subprocess.TimeoutExpired - - time.sleep(2) diff --git a/orbit/orbit/audio/utils.py b/orbit/orbit/audio/utils.py deleted file mode 100644 index 670057c..0000000 --- a/orbit/orbit/audio/utils.py +++ /dev/null @@ -1,164 +0,0 @@ -import pyaudio -import wave -import threading -import numpy as np - -def list_audio_devices(): - """Lists all available audio devices.""" - audio = pyaudio.PyAudio() - print("\nAvailable Audio Devices:\n") - for i in range(audio.get_device_count()): - device_info = audio.get_device_info_by_index(i) - print(f"ID {device_info['index']}: {device_info['name']} - " - f"Input Channels: {device_info['maxInputChannels']}, Output Channels: {device_info['maxOutputChannels']}") - audio.terminate() - -def get_audio_device_index(device_name:str) -> int: - """Returns the device index for a given device name.""" - audio = pyaudio.PyAudio() - di = None - for i in range(audio.get_device_count()): - device_info = audio.get_device_info_by_index(i) - if device_info['name'].startswith(device_name): - di = i - break - audio.terminate() - return di - - -def play_audio(playback_file, rate, chunk, output_device): - """Plays a WAV file using a separate thread.""" - wf = wave.open(playback_file, 'rb') - play_channels = wf.getnchannels() - play_rate = wf.getframerate() - - # Ensure playback rate matches file rate - if rate != play_rate: - print(f"⚠️ Warning: WAV file sample rate ({play_rate} Hz) differs from playback rate ({rate} Hz).") - - audio = pyaudio.PyAudio() - - # Open playback stream - play_stream = audio.open(format=pyaudio.paInt16, - channels=play_channels, - rate=rate, - output=True, - output_device_index=output_device, - frames_per_buffer=chunk) - - print(f"Playing '{playback_file}' ({play_channels} channels)...") - - while True: - data = wf.readframes(chunk) - if not data: - break - play_stream.write(data) - - # Cleanup - wf.close() - play_stream.stop_stream() - play_stream.close() - audio.terminate() - print("🔇 Playback finished.") - -def record_audio(output_file, channels, rate, chunk, duration, input_device): - """Records multi-channel audio in a separate thread.""" - - FORMAT = pyaudio.paInt16 # 16-bit PCM - audio = pyaudio.PyAudio() - - # Open recording stream - record_stream = audio.open(format=FORMAT, - channels=channels, - rate=rate, - input=True, - input_device_index=input_device, - frames_per_buffer=chunk) - - print(f"🎤 Recording {channels} channels at {rate} Hz for {duration} seconds...") - - frames = [] - for _ in range(0, int(rate / chunk * duration)): - data = record_stream.read(chunk, exception_on_overflow=False) - frames.append(data) - - # Cleanup - record_stream.stop_stream() - record_stream.close() - audio.terminate() - - # Save recorded audio - with wave.open(output_file, 'wb') as wf: - wf.setnchannels(channels) - wf.setsampwidth(audio.get_sample_size(FORMAT)) - wf.setframerate(rate) - wf.writeframes(b''.join(frames)) - - print(f"Recording complete! Saved as {output_file}") - - -class ThreadWithException(threading.Thread): - - def run(self): - self.exc = None # Store exception here - try: - print("Thread running...") - super().run() - except Exception as e: - self.exc = e # Store the exception - -def run_playback_and_record( play_file:str, out_device:int, rec_file:str, in_device:int, duration:int ): - # Create separate threads for playback and recording - play_thread = ThreadWithException(target=play_audio, args=(play_file, 16000, 1024, out_device)) - record_thread = ThreadWithException(target=record_audio, args=(rec_file, 6, 16000, 1024, duration, in_device)) - - # Start both threads - play_thread.start() - record_thread.start() - - # Wait for both to finish - play_thread.join() - record_thread.join() - if play_thread.exc: - print(f"Exception in thread: {play_thread.exc}") - raise play_thread.exc # Optionally re-raise it in the main thread - - if record_thread.exc: - print(f"Exception in thread: {record_thread.exc}") - raise record_thread.exc # Optionally re-raise it in the main thread - - print("🎵 Playback and recording completed.") - - -def read_wav_wave(filename:str) -> tuple[int, np.array]: - """ - Read a WAV file using the `wave` module and return its data as a NumPy array. - - Parameters: - filename (str): Path to the WAV file. - - Returns: - fs (int): Sampling rate in Hz. - audio_data (numpy array): Audio data with shape (Samples, Channels). - """ - with wave.open(filename, "rb") as wf: - num_channels = wf.getnchannels() - sample_width = wf.getsampwidth() - fs = wf.getframerate() - num_frames = wf.getnframes() - - print("\n") - print(f"Reading '{filename}'...") - print(f"Channels: {num_channels}, Sample Width: {sample_width} bytes, Sample Rate: {fs} Hz, Frames: {num_frames}") - - # Read raw audio data - raw_data = wf.readframes(num_frames) - - # Convert raw bytes to NumPy array - audio_data = np.frombuffer(raw_data, dtype=np.int16) # 16-bit PCM - - # Reshape if multichannel - if num_channels > 1: - audio_data = audio_data.reshape(-1, num_channels) - - return fs, audio_data \ No newline at end of file diff --git a/orbit/orbit/audio/vad_silero.py b/orbit/orbit/audio/vad_silero.py deleted file mode 100644 index 1f74bdb..0000000 --- a/orbit/orbit/audio/vad_silero.py +++ /dev/null @@ -1,22 +0,0 @@ -import numpy as np -from silero_vad import load_silero_vad, get_speech_timestamps -from orbit.audio.utils import read_wav_wave - -def vad_silero(wav_file:str=None, channel:int=0, audio:np.array=None) -> list[dict]: - vad = load_silero_vad() - if wav_file: - fs, audio = read_wav_wave(wav_file) - if fs != 16000: - raise ValueError("Only 16kHz audio is supported.") - if audio.shape[1] > 1: - audio = audio[:, channel] - elif audio is None: - raise ValueError("Either wav_file or audio must be provided.") - - speech_timestamps = get_speech_timestamps( - audio, - vad, - return_seconds=True, # Return speech timestamps in seconds (default is samples) - ) - - return speech_timestamps \ No newline at end of file diff --git a/orbit/orbit/builder/__init__.py b/orbit/orbit/builder/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/orbit/orbit/builder/tracking.py b/orbit/orbit/builder/tracking.py deleted file mode 100644 index 2b40275..0000000 --- a/orbit/orbit/builder/tracking.py +++ /dev/null @@ -1,79 +0,0 @@ -import dataclasses -from pathlib import Path -import hashlib -import subprocess -from typing import Any, Union -import sys - -from orbit import PROJ_ROOT - -@dataclasses.dataclass -class GitInfo: - branch: str - commit: str - last_tag: Union[str, None] = None - patch_str: str = "" - - @classmethod - def from_ws(cls, repo_root:str=PROJ_ROOT) -> tuple[str]: - try: - branch = subprocess.run( - ["git", "rev-parse", "--abbrev-ref", "HEAD"], - cwd=repo_root, capture_output=True, text=True, check=True - ).stdout.strip() - commit_hash = subprocess.run( - ["git", "rev-parse", "--short" ,"HEAD"], - cwd=repo_root, capture_output=True, text=True, check=True - ).stdout.strip() - - try: - last_tag =subprocess.run(['git', 'describe', '--tags', '--abbrev=0'], - cwd=repo_root, capture_output=True, text=True, check=True - ).stdout.strip() - except: - last_tag = None # current repo doesn't have any tag - - patch_str = subprocess.run(['git', 'diff'], - cwd=repo_root, capture_output=True, text=True, check=True - ).stdout - - - - return cls(branch, commit_hash, last_tag, patch_str) - - except subprocess.CalledProcessError: - print("Calling git failed!") - sys.exit(1) - - def as_dict(self, skip_patch_str=False): - data_dict = dataclasses.asdict(self) - if skip_patch_str: - data_dict.pop("patch_str") - return data_dict - - def __str__(self): - return f"{self.commit}" + ("+patch" if self.patch_str else "") + f"@{self.branch}" - - def __repr__(self): - return f"GitInfo({str(self)})" - - - - - -def create_patch_file( repo_root:Path, patch_file:Path ) -> str: - try: - with patch_file.open("w") as f: - subprocess.run( - ["git", "diff" ], - cwd=repo_root, stdout=f - ) - except: - print( "Error while trying to create patch file.") - sys.exit(1) - - md5 = None - with patch_file.open("rb") as f: - md5 = hashlib.md5(f.read()).hexdigest() - - return md5 \ No newline at end of file diff --git a/orbit/orbit/builder/xmos.py b/orbit/orbit/builder/xmos.py deleted file mode 100644 index cf40a53..0000000 --- a/orbit/orbit/builder/xmos.py +++ /dev/null @@ -1,102 +0,0 @@ -import os -import subprocess -import select - -from pathlib import Path - -from orbit import PROJ_ROOT, XTC_PATH - -SOURCE_CMD="zsh" - - -def setup_xtc_env(xtc_path:str=XTC_PATH) -> None: - print( f"Activating XTC environment at {xtc_path} ..." ) - script = os.path.join(xtc_path, "SetEnv.sh" ) - pipe = subprocess.Popen( f"{SOURCE_CMD} {script} && env -0", stdout=subprocess.PIPE, shell=True) - output = pipe.communicate()[0].decode('utf-8') - output = output[:-1] # fix for index out for range in 'env[ line[0] ] = line[1]' - - env = {} - # split using null char - for line in output.split('\x00'): - line = line.split( '=', 1) - env[ line[0] ] = line[1] - - os.environ.update(env) - -def setup_py_env(env_path:str) -> None: - print( f"Activating Python environment at {env_path} ..." ) - script = os.path.join(env_path, "bin", "activate" ) - pipe = subprocess.Popen( f". {script} && env -0", stdout=subprocess.PIPE, shell=True) - output = pipe.communicate()[0].decode('utf-8') - output = output[:-1] # fix for index out for range in 'env[ line[0] ] = line[1]' - - env = {} - # split using null char - for line in output.split('\x00'): - line = line.split( '=', 1) - env[ line[0] ] = line[1] - - os.environ.update(env) - - -def run_command(command, cwd=None): - """Runs a shell command and prints the output.""" - env = os.environ.copy() - print( f"CMD: {command}") - process = subprocess.Popen(command, shell=True, cwd=cwd, - #stdout=subprocess.PIPE, stderr=subprocess.STDOUT, - text=True, env=env) - - #while process.stdout.readable(): - # line = process.stdout.readline() - # - # if not line: - # break - # print(line, end="") # Print output in real-time - - - process.wait() - if process.returncode != 0: - raise RuntimeError(f"Command failed: {command}") - - - -def build_firmware( build_dir:Path, variant:str, src_dir:Path=PROJ_ROOT, clean:bool=False, defines:list[str] = [] ) -> bool: - """Configures and builds a CMake project using Make.""" - - setup_xtc_env(XTC_PATH) - setup_py_env("/Users/mischa/Projects/FutureProofHomes/Satellite1-XMOS-15.3/.venv") - - run_command( "which python3" ) - - full_build_dir = src_dir / build_dir - if clean and full_build_dir.exists(): - print(f"Cleaning build directory: {build_dir}") - subprocess.run(f"rm -rf {build_dir}", shell=True, cwd=src_dir) - - os.makedirs( src_dir / build_dir, exist_ok=True) - - defstr = " ".join([ "-D {}".format(d) for d in defines ]) - - print(f"Running CMake configuration in '{build_dir}'...") - run_command(f"cmake -B {build_dir} --toolchain xmos_cmake_toolchain/xs3a.cmake {defstr}", cwd=src_dir) - - - print(f"Building {variant}...") - run_command(f"make -C {build_dir} {variant} -j", cwd=src_dir) - - -def usb_dfu_upload( device:str, image:Path, reset:bool=True ) -> bool : - print( f"Uploading {image} to alt=1 of device: {device}...") - run_command( f"dfu-util -d {device} -a 1 -D {str(image)} {'-R' if reset else ''}" ) - - -def usb_dfu_download( device:str, dst:Path ) -> bool : - print( f"Downloading alt=1 of device: {device} to {dst}...") - run_command( f"dfu-util -d {device} -a 1 -U {str(dst)} " ) - - -def reset_device(xtag_id:str) -> bool: - print( "Resetting device..." ) - run_command( f"xrun --adapter-id {xtag_id} --reset" ) \ No newline at end of file diff --git a/orbit/orbit/tracking/__init__.py b/orbit/orbit/tracking/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/orbit/pyproject.toml b/orbit/pyproject.toml deleted file mode 100644 index 6a295ef..0000000 --- a/orbit/pyproject.toml +++ /dev/null @@ -1,4 +0,0 @@ -[project] -name = "orbit" -version = "0.1" -dependencies = [] \ No newline at end of file From 7e772f23d22bc362636c7080073d9794e477fff1 Mon Sep 17 00:00:00 2001 From: Mischa Siekmann Date: Mon, 14 Jul 2025 21:12:13 +0200 Subject: [PATCH 6/6] reset the watchdog on tile0 only --- satellite-xmos-firmware/src/main.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/satellite-xmos-firmware/src/main.c b/satellite-xmos-firmware/src/main.c index 58e3b15..b41c3fd 100644 --- a/satellite-xmos-firmware/src/main.c +++ b/satellite-xmos-firmware/src/main.c @@ -289,7 +289,9 @@ static void mem_analysis(void) for (;;) { rtos_printf("Tile[%d]:\n\tMinimum heap free: %d\n\tCurrent heap free: %d\n", THIS_XCORE_TILE, xPortGetMinimumEverFreeHeapSize(), xPortGetFreeHeapSize()); cdc_printf("Tile[%d]:\n\tMinimum heap free: %d\n\tCurrent heap free: %d\n", THIS_XCORE_TILE, xPortGetMinimumEverFreeHeapSize(), xPortGetFreeHeapSize()); - reset_watchdog(); +#if ON_TILE(0) + reset_watchdog(); +#endif vTaskDelay(pdMS_TO_TICKS(5000)); } }