diff --git a/CMakeLists.txt b/CMakeLists.txt index dfc89ad..b4132c9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,20 +1,20 @@ -set(COMPONENT_SRCS - src/mn_process_commands.c - src/model_path.c - ) - -set(COMPONENT_ADD_INCLUDEDIRS - esp-tts/esp_tts_chinese/include - include - ) - -set(COMPONENT_REQUIRES - json - spiffs - ) - -register_component() if(IDF_TARGET STREQUAL "esp32") + set(COMPONENT_ADD_INCLUDEDIRS + esp-tts/esp_tts_chinese/include + include/esp32 + ) + set(COMPONENT_SRCS + src/mn_process_commands.c + src/model_path.c + ) + + set(COMPONENT_REQUIRES + json + spiffs + ) + + register_component() + target_link_libraries(${COMPONENT_TARGET} "-L ${CMAKE_CURRENT_SOURCE_DIR}/lib/esp32") target_link_libraries(${COMPONENT_TARGET} "-L ${CMAKE_CURRENT_SOURCE_DIR}/esp-tts/esp_tts_chinese") IF (IDF_VERSION_MAJOR GREATER 3) @@ -44,6 +44,21 @@ ENDIF (IDF_VERSION_MAJOR GREATER 3) voice_set_template "-Wl,--end-group") elseif(${IDF_TARGET} STREQUAL "esp32s2") + set(COMPONENT_ADD_INCLUDEDIRS + esp-tts/esp_tts_chinese/include + include/esp32 + ) + set(COMPONENT_SRCS + src/mn_process_commands.c + src/model_path.c + ) + + set(COMPONENT_REQUIRES + json + spiffs + ) + + register_component() target_link_libraries(${COMPONENT_TARGET} "-L ${CMAKE_CURRENT_SOURCE_DIR}/esp-tts/esp_tts_chinese") target_link_libraries(${COMPONENT_TARGET} "-Wl,--start-group" esp_tts_chinese_esp32s2 @@ -51,6 +66,21 @@ elseif(${IDF_TARGET} STREQUAL "esp32s2") voice_set_template_esp32s2 "-Wl,--end-group") elseif(${IDF_TARGET} STREQUAL "esp32s3") + set(COMPONENT_ADD_INCLUDEDIRS + esp-tts/esp_tts_chinese/include + include/esp32s3 + ) + set(COMPONENT_SRCS + src/mn_process_commands.c + src/model_path.c + ) + + set(COMPONENT_REQUIRES + json + spiffs + ) + + register_component() target_link_libraries(${COMPONENT_TARGET} "-L ${CMAKE_CURRENT_SOURCE_DIR}/lib/esp32s3") target_link_libraries(${COMPONENT_TARGET} "-L ${CMAKE_CURRENT_SOURCE_DIR}/esp-tts/esp_tts_chinese") diff --git a/include/customized_word_wn5.h b/include/esp32/customized_word_wn5.h similarity index 100% rename from include/customized_word_wn5.h rename to include/esp32/customized_word_wn5.h diff --git a/include/esp32/dl_lib.h b/include/esp32/dl_lib.h new file mode 100644 index 0000000..5afe563 --- /dev/null +++ b/include/esp32/dl_lib.h @@ -0,0 +1,357 @@ +// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#ifndef DL_LIB_H +#define DL_LIB_H + +#include "dl_lib_matrix.h" +#include "dl_lib_matrixq.h" +#include "dl_lib_matrixq8.h" + +typedef int padding_state; + +void *dl_lib_calloc(int cnt, int size, int align); + +void *dl_lib_calloc_psram(int cnt, int size, int align); + +void dl_lib_free(void *d); +/** + * @brief Does a fast version of the exp() operation on a floating point number. + * + * As described in https://codingforspeed.com/using-faster-exponential-approximation/ + * Should be good til an input of 5 or so with a steps factor of 8. + * + * @param in Floating point input + * @param steps Approximation steps. More is more precise. 8 or 10 should be good enough for most purposes. + * @return Exp()'ed output + */ +fptp_t fast_exp(double x, int steps); + +/** + * @brief Does a fast version of the exp() operation on a floating point number. + * + * @param in Floating point input + * @return Exp()'ed output + */ +double fast_exp_pro(double x); + +/** + * @brief Does a softmax operation on a matrix. + * + * @param in Input matrix + * @param out Output matrix. Can be the same as the input matrix; if so, output results overwrite the input. + */ +void dl_softmax(const dl_matrix2d_t *in, dl_matrix2d_t *out); + + +/** + * @brief Does a softmax operation on a quantized matrix. + * + * @param in Input matrix + * @param out Output matrix. Can be the same as the input matrix; if so, output results overwrite the input. + */ +void dl_softmax_q(const dl_matrix2dq_t *in, dl_matrix2dq_t *out); + +/** + * @brief Does a sigmoid operation on a floating point number + * + * @param in Floating point input + * @return Sigmoid output + */ + +fptp_t dl_sigmoid_op(fptp_t in); + + +/** + * @brief Does a sigmoid operation on a matrix. + * + * @param in Input matrix + * @param out Output matrix. Can be the same as the input matrix; if so, output results overwrite the input. + */ +void dl_sigmoid(const dl_matrix2d_t *in, dl_matrix2d_t *out); + +/** + * @brief Does a tanh operation on a floating point number + * + * @param in Floating point input number + * @return Tanh value + */ +fptp_t dl_tanh_op(fptp_t v); + +/** + * @brief Does a tanh operation on a matrix. + * + * @param in Input matrix + * @param out Output matrix. Can be the same as the input matrix; if so, output results overwrite the input. + */ +void dl_tanh(const dl_matrix2d_t *in, dl_matrix2d_t *out); + + +/** + * @brief Does a relu (Rectifier Linear Unit) operation on a floating point number + * + * @param in Floating point input + * @param clip If value is higher than this, it will be clipped to this value + * @return Relu output + */ +fptp_t dl_relu_op(fptp_t in, fptp_t clip); + +/** + * @brief Does a ReLu operation on a matrix. + * + * @param in Input matrix + * @param clip If values are higher than this, they will be clipped to this value + * @param out Output matrix. Can be the same as the input matrix; if so, output results overwrite the input. + */ +void dl_relu(const dl_matrix2d_t *in, fptp_t clip, dl_matrix2d_t *out); + +/** + * @brief Fully connected layer operation + * + * @param in Input vector + * @param weight Weights of the neurons + * @param bias Biases for the neurons. Can be NULL if a bias of 0 is required. + * @param out Output array. Outputs are placed here. Needs to be an initialized, weight->w by in->h in size, matrix. + */ +void dl_fully_connect_layer(const dl_matrix2d_t *in, const dl_matrix2d_t *weight, const dl_matrix2d_t *bias, dl_matrix2d_t *out); + +/** + * @brief Pre-calculate the sqrtvari variable for the batch_normalize function. + * The sqrtvari matrix depends on the variance and epsilon values, which normally are constant. Hence, + * this matrix only needs to be calculated once. This function does that. + * + * @param + * @return + */ +void dl_batch_normalize_get_sqrtvar(const dl_matrix2d_t *variance, fptp_t epsilon, dl_matrix2d_t *out); + +/** + * @brief Batch-normalize a matrix + * + * @param m The matrix to normalize + * @param offset Offset matrix + * @param scale Scale matrix + * @param mean Mean matrix + * @param sqrtvari Matrix precalculated using dl_batch_normalize_get_sqrtvar + * @return + */ +void dl_batch_normalize(dl_matrix2d_t *m, const dl_matrix2d_t *offset, const dl_matrix2d_t *scale, + const dl_matrix2d_t *mean, const dl_matrix2d_t *sqrtvari); + +/** + * @brief Do a basic LSTM layer pass. + * + * @warning Returns state_h pointer, so do not free result. + + * @param in Input vector + * @param state_c Internal state of the LSTM network + * @param state_h Internal state (previous output values) of the LSTM network + * @param weights Weights for the neurons + * @param bias Bias for the neurons. Can be NULL if no bias is required + * @return Output values of the neurons + */ +dl_matrix2d_t *dl_basic_lstm_layer(const dl_matrix2d_t *in, dl_matrix2d_t *state_c, dl_matrix2d_t *state_h, + const dl_matrix2d_t *weight, const dl_matrix2d_t *bias); + +/** + * @brief Do a basic LSTM layer pass, partial quantized version. + * This LSTM function accepts 16-bit fixed-point weights and 32-bit float-point bias. + * + * @warning Returns state_h pointer, so do not free result. + + * @param in Input vector + * @param state_c Internal state of the LSTM network + * @param state_h Internal state (previous output values) of the LSTM network + * @param weights Weights for the neurons, need to be quantised + * @param bias Bias for the neurons. Can be NULL if no bias is required + * @return Output values of the neurons + */ +dl_matrix2dq_t *dl_basic_lstm_layer_quantised_weights(const dl_matrix2d_t *in, dl_matrix2d_t *state_c, dl_matrix2d_t *state_h, + const dl_matrix2dq_t *weight, const dl_matrix2d_t *bias); + +/** + * @brief Do a fully-connected layer pass, fully-quantized version. + * + * @param in Input vector + * @param weight Weights of the neurons + * @param bias Bias values of the neurons. Can be NULL if no bias is needed. + * @param shift Number of bits to shift the result back by. See dl_lib_matrixq.h for more info + * @return Output values of the neurons + */ +void dl_fully_connect_layer_q(const dl_matrix2dq_t *in, const dl_matrix2dq_t *weight, const dl_matrix2dq_t *bias, dl_matrix2dq_t *out, int shift); + +/** + * @brief Do a basic LSTM layer pass, fully-quantized version + * + * @warning Returns state_h pointer, so do not free result. + + * @param in Input vector + * @param state_c Internal state of the LSTM network + * @param state_h Internal state (previous output values) of the LSTM network + * @param weights Weights for the neurons + * @param bias Bias for the neurons. Can be NULL if no bias is required + * @param shift Number of bits to shift the result back by. See dl_lib_matrixq.h for more info + * @return Output values of the neurons + */ +dl_matrix2dq_t *dl_basic_lstm_layer_q(const dl_matrix2dq_t *in, dl_matrix2dq_t *state_c, dl_matrix2dq_t *state_h, + const dl_matrix2dq_t *weight, const dl_matrix2dq_t *bias, int shift); + +/** + * @brief Batch-normalize a matrix, fully-quantized version + * + * @param m The matrix to normalize + * @param offset Offset matrix + * @param scale Scale matrix + * @param mean Mean matrix + * @param sqrtvari Matrix precalculated using dl_batch_normalize_get_sqrtvar + * @param shift Number of bits to shift the result back by. See dl_lib_matrixq.h for more info + * @return + */ +void dl_batch_normalize_q(dl_matrix2dq_t *m, const dl_matrix2dq_t *offset, const dl_matrix2dq_t *scale, + const dl_matrix2dq_t *mean, const dl_matrix2dq_t *sqrtvari, int shift); + +/** + * @brief Does a relu (Rectifier Linear Unit) operation on a fixed-point number + * This accepts and returns fixed-point 32-bit number with the last 15 bits being the bits after the decimal + * point. (Equivalent to a mantissa in a quantized matrix with exponent -15.) + * + * @param in Fixed-point input + * @param clip If value is higher than this, it will be clipped to this value + * @return Relu output + */ +qtp_t dl_relu_q_op(qtp_t in, qtp_t clip); + +/** + * @brief Does a ReLu operation on a matrix, quantized version + * + * @param in Input matrix + * @param clip If values are higher than this, they will be clipped to this value + * @param out Output matrix. Can be the same as the input matrix; if so, output results overwrite the input. + */ +void dl_relu_q(const dl_matrix2dq_t *in, fptp_t clip, dl_matrix2dq_t *out); + +/** + * @brief Does a sigmoid operation on a fixed-point number. + * This accepts and returns a fixed-point 32-bit number with the last 15 bits being the bits after the decimal + * point. (Equivalent to a mantissa in a quantized matrix with exponent -15.) + * + * @param in Fixed-point input + * @return Sigmoid output + */ +int dl_sigmoid_op_q(const int in); +int16_t dl_sigmoid_op_q8(const int16_t in); +/** + * @brief Does a sigmoid operation on a matrix, quantized version + * + * @param in Input matrix + * @param out Output matrix. Can be the same as the input matrix; if so, output results overwrite the input. + */ +void dl_sigmoid_q(const dl_matrix2dq_t *in, dl_matrix2dq_t *out); + +/** + * @brief Does a tanh operation on a matrix, quantized version + * + * @param in Input matrix + * @param out Output matrix. Can be the same as the input matrix; if so, output results overwrite the input. + */ +void dl_tanh_q(const dl_matrix2dq_t *in, dl_matrix2dq_t *out); + +/** + * @brief Does a tanh operation on a fixed-point number. + * This accepts and returns a fixed-point 32-bit number with the last 15 bits being the bits after the decimal + * point. (Equivalent to a mantissa in a quantized matrix with exponent -15.) + * + * @param in Fixed-point input + * @return tanh output + */ +int dl_tanh_op_q(int v); +int16_t dl_tanh_op_q8(int16_t v); + +void load_mat_psram_mn4(void); +void load_mat_psram_mn3(void); + +qtp_t dl_hard_sigmoid_op(qtp_t in, int exponent); +qtp_t dl_hard_tanh_op(qtp_t in, int exponent); + +int16_t dl_table_tanh_op(int16_t in, int exponent); +int16_t dl_table_sigmoid_op(int16_t in, int exponent); + +void dl_hard_sigmoid_q(const dl_matrix2dq_t *in, dl_matrix2dq_t *out); +void dl_hard_tanh_q(const dl_matrix2dq_t *in, dl_matrix2dq_t *out); + +void dl_table_sigmoid_q(const dl_matrix2dq_t *in, dl_matrix2dq_t *out); +void dl_table_tanh_q(const dl_matrix2dq_t *in, dl_matrix2dq_t *out); + + +/** + * @brief Filter out the number greater than clip in the matrix, quantized version + * + * @param in Input matrix + * @param clip If values are higher than this, they will be clipped to this value + * @param out Output matrix. Can be the same as the input matrix; if so, output results overwrite the input. + */ +void dl_minimum(const dl_matrix2d_t *in, fptp_t clip, dl_matrix2d_t *out); + +/** + * @brief Filter out the number greater than clip in the matrix, float version + * + * @param in Input matrix + * @param clip If values are higher than this, they will be clipped to this value + * @param out Output matrix. Can be the same as the input matrix; if so, output results overwrite the input. + */ +void dl_minimum_q(const dl_matrix2dq_t *in, fptp_t clip, dl_matrix2dq_t *out); +/** + * @brief Do a basic CNN layer pass. + * + * @Warning This just supports the single channel input image, and the output is single row matrix. + That is to say, the height of output is 1, and the weight of output is out_channels*out_image_width*out_image_height + * + * @param in Input single channel image + * @param weight Weights of the neurons, weight->w = out_channels, weight->h = filter_width*filter_height + * @param bias Bias for the CNN layer. + * @param filter_height The height of convolution kernel + * @param filter_width The width of convolution kernel + * @param out_channels The number of output channels of convolution kernel + * @param stride_x The step length of the convolution window in x(width) direction + * @param stride_y The step length of the convolution window in y(height) direction + * @param pad One of `"VALID"` or `"SAME"`, 0 is "VALID" and the other is "SAME" + * @param out The result of CNN layer, out->h=1. + * @return The result of CNN layer. + */ +dl_matrix2d_t *dl_basic_conv_layer(const dl_matrix2d_t *in, const dl_matrix2d_t *weight, const dl_matrix2d_t *bias, int filter_width, int filter_height, + const int out_channels, const int stride_x, const int stride_y, padding_state pad, const dl_matrix2d_t* out); + + +/** + * @brief Do a basic CNN layer pass, quantised wersion. + * + * @Warning This just supports the single channel input image, and the output is single row matrix. + That is to say, the height of output is 1, and the weight of output is out_channels*out_image_width*out_image_height + * + * @param in Input single channel image + * @param weight Weights of the neurons, weight->w = out_channels, weight->h = filter_width*filter_height, + * @param bias Bias of the neurons. + * @param filter_height The height of convolution kernel + * @param filter_width The width of convolution kernel + * @param out_channels The number of output channels of convolution kernel + * @param stride_x The step length of the convolution window in x(width) direction + * @param stride_y The step length of the convolution window in y(height) direction + * @param pad One of `"VALID"` or `"SAME"`, 0 is "VALID" and the other is "SAME" + * @param out The result of CNN layer, out->h=1 + * @return The result of CNN layer + */ +dl_matrix2d_t *dl_basic_conv_layer_quantised_weight(const dl_matrix2d_t *in, const dl_matrix2dq_t *weight, const dl_matrix2d_t *bias, int filter_width, int filter_height, + const int out_channels, const int stride_x, const int stride_y, padding_state pad, const dl_matrix2d_t* out); + +#endif + diff --git a/include/dl_lib_coefgetter_if.h b/include/esp32/dl_lib_coefgetter_if.h similarity index 100% rename from include/dl_lib_coefgetter_if.h rename to include/esp32/dl_lib_coefgetter_if.h diff --git a/include/dl_lib_conv_queue.h b/include/esp32/dl_lib_conv_queue.h similarity index 100% rename from include/dl_lib_conv_queue.h rename to include/esp32/dl_lib_conv_queue.h diff --git a/include/esp32/dl_lib_convq8_queue.h b/include/esp32/dl_lib_convq8_queue.h new file mode 100644 index 0000000..c2df87f --- /dev/null +++ b/include/esp32/dl_lib_convq8_queue.h @@ -0,0 +1,221 @@ +// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#ifndef DL_LIB_CONVQ8_QUEUE_H +#define DL_LIB_CONVQ8_QUEUE_H + + +#include "dl_lib_matrixq.h" +#include "dl_lib_matrixq8.h" +#include "dl_lib_conv_queue.h" +#include "dl_lib_convq_queue.h" + +typedef struct { + int n; /*< the length of queue */ + int c; /*< the channel number of queue element*/ + int front; /*< the front(top) position of queue */ + int flag; /*< not used */ + int exponent; /*< The values in items should be multiplied by pow(2,exponent) + to get the real values */ + q8tp_t *itemq; /*< Pointer to item array */ +} dl_convq8_queue_t; + +/** + * @brief Allocate a fixed-point convolution queue + * + * @param n The length of queue + * @param c The channel number of elements in the queue + * @return The convolution queue, or NULL if out of memory + */ +dl_convq8_queue_t *dl_convq8_queue_alloc(int n, int c); + +/** + * @brief Free a fixed-point convolution queue + * + * @param cq The fixed-point convolution queue to free + */ +void dl_convq8_queue_free(dl_convq8_queue_t *cq); + +/** + * @brief Insert the float-point element at the end of queue. + * The precision of fixed-point numbers is described by the Qm.f notation, + * + * @param cq Input fixed-point convolution queue + * @param item The float-point element + * @param m_bit The number of integer bits including the sign bits + * @param f_bit The number of fractional bits + */ +void dl_convq8_queue_push_by_qmf(dl_convq8_queue_t *cq, fptp_t* item, int m_bit, int f_bit); + +/** + * @brief Get the pointer of element in the queue by offset + * + * @param cq Input fixed-point convolution queue + * @param offset Offset from the front of the queue + * @return Pointer of the element + */ +q8tp_t *dl_get_queue_itemq8(dl_convq8_queue_t *cq, int offset); + +/** + * @brief Fast and quantised implement for 1D atrous convolution (a.k.a. convolution with holes or dilated convolution) + * based on convolution queue. + * + * @Warning All input and output convolution queue and matrix should be allocated. The return pointer + * is last element of output queue and should not be freed separately. + * + * @param in Input fixed-point convolution queue + * @param out Output fixed-point convolution queue + * @param rate A positive int, the stride with which we sample input value + * @param size A positive int, the size of 1D-filter + * @param kernel Kernel matrix of filter + * @param bias The bias matrix of filter. Can be NULL if a bias of 0 is required. + * @param out_exponent Shift ratio used in dot operation between two 16-bit fixed point vector + * @param offset Offset used to calculate the beginning of input conv queue + * @param prenum The num to control the parameter size of preload operation + * @return The result of atrous convolution + */ +void dl_atrous_conv1dq8_steps(dl_convq8_queue_t *in, dl_convq8_queue_t *out, int rate, int size, + dl_matrix2dq8_t* kernel, dl_matrix2dq8_t* bias, + int out_exponent, int offset, int prenum); + +/** + * @brief Fast implement of dilation layer as follows + * + * |-> [gate(sigmoid)] -| + * input - | |-> (*) - output + * |-> [filter(tanh)] -| + * + * @Warning All input and output convolution queue and matrix should be allocated. The return pointer + * is last element of output queue and should not be freed separately. + * + * @param in Input fixed-point convolution queue + * @param out Output fixed-point convolution queue + * @param rate A positive int, the stride with which we sample input value + * @param size A positive int, the size of 1D-filter + * @param filter_kernel The kernel matrix of filter + * @param filter_bias The bias matrix of filter. Can be NULL if a bias of 0 is required. + * @param gate_kernel The kernel matrix of gate + * @param gate_bias The bias matrix of gate. Can be NULL if a bias of 0 is required. + * @param offset Offset used to calculate the beginning of input conv queue + * @param prenum The num to control the parameter size of preload operation + * @return The result of dilation layer + */ +void dl_dilation_layerq8_steps(dl_convq8_queue_t *in, dl_convq8_queue_t *out, int rate, int size, + dl_matrix2dq8_t* filter_kernel, dl_matrix2dq8_t* filter_bias, + dl_matrix2dq8_t* gate_kernel, dl_matrix2dq8_t* gate_bias, + int offset, int prenum); + + + + +dl_conv_queue_t *dl_convq8_queue_add(dl_convq8_queue_t *cq1, dl_convq8_queue_t *cq2); + + +/** + * @brief Allocate a 8-bit fixed-point Multi-Channel convolution queue + * + * @param n The length of queue + * @param c The number of elements in the queue + * @param nch　　The channel number + * @return The convolution queue, or NULL if out of memory + */ +dl_convq8_queue_t **dl_convq8_queue_mc_alloc(int n, int c, int nch); + +/** + * @brief Free a 8-bit fixed-point Multi-Channel convolution queue + * + * @param cqm The fixed-point convolution queue to free + * @param nch The channel number + */ +void dl_convq8_queue_mc_free(dl_convq8_queue_t **cqm, int nch); + +/** + * @brief Tanh activation function for 8-bit fixed-point Multi-Channel convolution queue input + * + * @param cqm Input 8-bit fixed-point Multi-Channel convolution queue + * @param offset Offset used to calculate the beginning of input conv queue + * @param nch The channel number + */ +void dl_tanh_convq8_mc(dl_convq8_queue_t **cqm, int offset, int nch); + +/** + * @brief Fast and quantised 16-bit implement for Multi-channel 1D atrous convolution (a.k.a. convolution with holes or dilated convolution) + * Usually, this layer is used as first layer for 8-bit network. + * + * @Warning All input and output convolution queue and matrix should be allocated. The return pointer + * Input is a 16-bit queue point, Output is an 8-bit queue point. + * + * @param in Input 16bit fixed-point convolution queue array + * @param out Output 8bit fixed-point convolution queue array + * @param rate A positive int, the stride with which we sample input value + * @param size A positive int, the size of 1D-filter + * @param kernel The kernel matrix of filter + * @param bias The bias matrix of filter. Can be NULL if a bias of 0 is required. + * @param out_exponent Exponent of output + * @param offset Offset used to calculate the beginning of input conv queue + * @param prenum The num to control the parameter size of preload operation + */ +void dl_atrous_conv1dq8_16in_mc_steps(dl_convq_queue_t **in, dl_convq8_queue_t **out, int nch, int rate, int size, + dl_matrix2dq_t* kernel, dl_matrix2dq_t* bias, int out_exponent, int offset, int prenum); + +/** + * @brief Fast and quantised 8-bit implement for Multi-channel 1D atrous convolution (a.k.a. convolution with holes or dilated convolution) + * based on convolution queue. + * + * @Warning All input and output convolution queue and matrix should be allocated. The return pointer + * is last element of output queue and should not be freed separately. + * + * @param in Input 8bit fixed-point convolution queue array + * @param out Output 8bit fixed-point convolution queue array + * @param rate A positive int, the stride with which we sample input value + * @param size A positive int, the size of 1D-filter + * @param kernel The kernel matrix of filter + * @param bias The bias matrix of filter. Can be NULL if a bias of 0 is required. + * @param out_exponent Exponent of output + * @param offset Offset used to calculate the beginning of input conv queue + * @param prenum The num to control the parameter size of preload operation + */ +void dl_atrous_conv1dq8_mc_steps(dl_convq8_queue_t **in, dl_convq8_queue_t **out, + int nch, int rate, int size, + dl_matrix2dq8_t* kernel, dl_matrix2dq8_t* bias, + int out_exponent, int offset, int prenum); + +/** + * @brief Fast implement of 8-bit dilation layer as follows + * + * |-> [gate(sigmoid)] -| + * input - | |-> (*) - output + * |-> [filter(tanh)] -| + * + * @Warning All input and output convolution queue and matrix should be allocated. The return pointer + * is last element of output queue and should not be freed separately. + * + * @param in Input 8-bit fixed-point convolution queue + * @param out Output 8-bit fixed-point convolution queue + * @param rate A positive int, the stride with which we sample input value + * @param size A positive int, the size of 1D-filter + * @param filter_kernel The kernel matrix of filter + * @param filter_bias The bias matrix of filter. Can be NULL if a bias of 0 is required. + * @param gate_kernel The kernel matrix of gate + * @param gate_bias The bias matrix of gate. Can be NULL if a bias of 0 is required. + * @param offset Offset used to calculate the beginning of input conv queue + * @param prenum The num to control the parameter size of preload operation + */ +void dl_dilation_layerq8_mc_steps(dl_convq8_queue_t **in, dl_convq8_queue_t **out, int nch, int rate, int size, + dl_matrix2dq8_t* filter_kernel, dl_matrix2dq8_t* filter_bias, + dl_matrix2dq8_t* gate_kernel, dl_matrix2dq8_t* gate_bias, + int offset, int prenum); + +void print_convq8(dl_convq8_queue_t *cq, int offset); +void print_convq(dl_convq_queue_t *cq, int offset); +#endif \ No newline at end of file diff --git a/include/esp32/dl_lib_convq_queue.h b/include/esp32/dl_lib_convq_queue.h new file mode 100644 index 0000000..e9df1e5 --- /dev/null +++ b/include/esp32/dl_lib_convq_queue.h @@ -0,0 +1,326 @@ +// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#ifndef DL_LIB_CONVQ_QUEUE_H +#define DL_LIB_CONVQ_QUEUE_H + +#include "dl_lib_matrixq.h" +#include "dl_lib_conv_queue.h" +#include "dl_lib.h" + + +//fixed-point convolution FIFO queue. +typedef struct { + int n; /*< the length of queue */ + int c; /*< the channel number of queue element*/ + int front; /*< the front(top) position of queue */ + int flag; /*< not used */ + int exponent; /*< The values in items should be multiplied by pow(2,exponent) + to get the real values */ + qtp_t *itemq; /*< Pointer to item array */ +} dl_convq_queue_t; + +/** + * @brief Allocate a fixed-point convolution queue + * + * @param n The length of queue + * @param c The channel number of elements in the queue + * @return The convolution queue, or NULL if out of memory + */ +dl_convq_queue_t *dl_convq_queue_alloc(int n, int c); +dl_convq_queue_t *dl_convq_queue_alloc_from_psram(int n, int c); +void dl_convq_to_matrix2dq(dl_convq_queue_t *cq, dl_matrix2dq_t* out, int row); + +/** + * @brief Free a fixed-point convolution queue + * + * @param cq The fixed-point convolution queue to free + */ +void dl_convq_queue_free(dl_convq_queue_t *cq); + +/** + * @brief Move the front pointer of queue forward, + the First(oldest) element become the last(newest) element, + * + * @param cq Input fixed-point convolution queue + * @return Pointer of oldest element + */ +inline qtp_t *dl_convq_queue_pop(dl_convq_queue_t *cq); +inline qtp_t *dl_convq_queue_popn(dl_convq_queue_t *cq, int n); +/** + * @brief Remove the oldest element, then insert the input element at the end of queue + * + * @param cq Input fixed-point convolution queue + * @param item The new element + */ +void dl_convq_queue_push(dl_convq_queue_t *cq, dl_matrix2dq_t *a, int shift); + +/** + * @brief Insert the float-point element at the end of queue. + * The precision of fixed-point numbers is described by the Qm.f notation, + * + * @param cq Input fixed-point convolution queue + * @param item The float-point element + * @param m_bit The number of integer bits including the sign bits + * @param f_bit The number of fractional bits + */ +void dl_convq_queue_push_by_qmf(dl_convq_queue_t *cq, fptp_t* item, int m_bit, int f_bit); + +void dl_convq16_queue_push_by_qmf(dl_convq_queue_t *cq, fptp_t* item, int m_bit, int f_bit); + +dl_conv_queue_t *dl_queue_from_convq(dl_convq_queue_t *cq1); + +/** + * @brief Get the pointer of element in the queue by offset + * + * @param cq Input fixed-point convolution queue + * @param last_num Offset from the front of the queue + * @return Pointer of the element + */ +inline qtp_t *dl_get_queue_itemq(dl_convq_queue_t *cq, int last_num); + +/** + * @brief Does a tanh operation on the one of element in the convolution queue. + * Gets the pointer of element in the convolution queue by offset, and does a + * tanh operation by this pointer, then return the pointer + * + * @param cq Input fixed-point convolution queue + * @param offset Offset from the front of the queue + * @return Pointer of the element + */ +void dl_tanh_convq(dl_convq_queue_t *cq, int offset); + +/** + * @brief Does a tanh operation on the one of element in multi channel convolution queue. + * Gets the pointer of element in the convolution queue by offset, and does a + * tanh operation by this pointer, then return the pointer + * + * @param cq Input fixed-point multi channnel convolution queue + * @param offset Offset from the front of the queue + * @param nch The channel number of cqm + * @return Pointer of the element + */ +void dl_tanh_convq_mc(dl_convq_queue_t **cqm, int offset, int nch); + +/** + * @brief Does a relu operation on the one of element in the convolution queue. + * Gets the pointer of element in the convolution queue by offset, and does a + * relu operation by this pointer, then return the pointer + * + * @param cq Input fixed-point convolution queue + * @param offset Offset from the front of the queue + * @return Pointer of the element + */ +void dl_relu_convq(dl_convq_queue_t *cq, fptp_t clip, int last_num); + +/** + * @brief Does a softmax operation on the one of element in the convolution queue. + * Gets the pointer of element in the convolution queue by offset, input data + stay as it is. Results are saved into the *out* array. + * + * @param cq Input fixed-point convolution queue + * @param offset Offset from the front of the queue + * @param out Old array to re-use. Passing NULL will allocate a new matrix. + * @return softmax results + */ +fptp_t * dl_softmax_step_q(dl_convq_queue_t *cq, int offset, fptp_t *out); + +/** + * @brief Fast and quantised implement for 1D atrous convolution (a.k.a. convolution with holes or dilated convolution) + * based on convolution queue. + * + * @Warning All input and output convolution queue and matrix should be allocated. The return pointer + * is last element of output queue and should not be freed separately. + * + * @param in Input fixed-point convolution queue + * @param out Output fixed-point convolution queue + * @param rate A positive int, the stride with which we sample input value + * @param size A positive int, the size of 1D-filter + * @param kernel The kernel matrix of filter + * @param bias The bias matrix of filter. Can be NULL if a bias of 0 is required. + * @param shift Shift ratio used in dot operation between two 16-bit fixed point vector + * @return The result of atrous convolution + */ +qtp_t * dl_atrous_conv1dq(dl_convq_queue_t *in, dl_convq_queue_t *out, int rate, int size, + dl_matrix2dq_t* kernel, dl_matrix2dq_t* bias, int shift, int prenum); + +/** + * @brief Fast implement of dilation layer as follows + * + * |-> [gate(sigmoid)] -| + * input - | |-> (*) - output + * |-> [filter(tanh)] -| + * + * @Warning All input and output convolution queue and matrix should be allocated. The return pointer + * is last element of output queue and should not be freed separately. + * + * @param in Input fixed-point convolution queue + * @param out Output fixed-point convolution queue + * @param rate A positive int, the stride with which we sample input value + * @param size A positive int, the size of 1D-filter + * @param filter_kernel The kernel matrix of filter + * @param filter_bias The bias matrix of filter. Can be NULL if a bias of 0 is required. + * @param gate_kernel The kernel matrix of gate + * @param gate_bias The bias matrix of gate. Can be NULL if a bias of 0 is required. + * @param filter_shift Shift ratio used in filter operation between two 16-bit fixed point vector + * @param gate_shift Shift ratio used in gate operation between two 16-bit fixed point vector + * @return The result of dilation layer + */ +qtp_t *dl_dilation_layerq_steps(dl_convq_queue_t *in, dl_convq_queue_t *out, int rate, int size, + dl_matrix2dq_t* filter_kernel, dl_matrix2dq_t* filter_bias, + dl_matrix2dq_t* gate_kernel, dl_matrix2dq_t* gate_bias, + int filter_shift, int gate_shift, int offset, int prenum); + + +qtp_t *dl_dilation_layerq(dl_convq_queue_t *in, dl_convq_queue_t *out, int rate, int size, + dl_matrix2dq_t* filter_kernel, dl_matrix2dq_t* filter_bias, + dl_matrix2dq_t* gate_kernel, dl_matrix2dq_t* gate_bias, + int filter_shift, int gate_shift, int prenum); + +qtp_t *dl_dilation_layerq16(dl_convq_queue_t *in, dl_convq_queue_t *out, int rate, int size, + dl_matrix2dq_t* filter_kernel, dl_matrix2dq_t* filter_bias, + dl_matrix2dq_t* gate_kernel, dl_matrix2dq_t* gate_bias, int prenum); + + +qtp_t *dl_atrous_conv1dq_steps(dl_convq_queue_t *in, dl_convq_queue_t *out, int rate, int size, + dl_matrix2dq_t* kernel, dl_matrix2dq_t* bias, int shift, int offset, int prenum); + +/** + * @brief Add a pair of fixed-point convolution queue item-by-item, and return float-point convolution queue + * + * @param cq1 First fixed-point convolution queue + * @param cq2 Seconf fixed-point convolution queue + * @return The result of float-point convolution queue + */ +dl_conv_queue_t *dl_convq_queue_add(dl_convq_queue_t *cq1, dl_convq_queue_t *cq2); + +/** + * @brief Fast implement of LSTM layer by dl_atrous_conv1dq function + * + * @Warning LSTM kernel is split into two part, the first part input is the last layer output, + * and kernel is parameter *in_weight*. The second part input is the last frame LSTM output, + * the kernel is parameters *h_weight*. + * + * @param in Input fixed-point convolution queue + * @param out Output fixed-point convolution queue + * @param state_c Internal state of the LSTM network + * @param state_h Internal state (previous output values) of the LSTM network + * @param in_weight the LSTM kernel needed by first part + * @param h_weight the LSTM kernel needed by second part + * @param bias The bias matrix of LSTM. Can be NULL if a bias of 0 is required. + * @in_shift Shift ratio used in first part + * @h_shift Shift ratio used in second part + * @return The result of LSTM layer + */ +dl_matrix2dq_t *dl_convq_lstm_layer(const dl_convq_queue_t *in, dl_convq_queue_t *out, dl_matrix2dq_t *state_c, + dl_matrix2dq_t *state_h, const dl_matrix2dq_t *in_weight, const dl_matrix2dq_t *h_weight, + const dl_matrix2dq_t *bias, int in_shift, int h_shift, int prenum); +dl_matrix2dq_t *dl_basic_lstm_layer1_q(const dl_convq_queue_t *in, dl_matrix2dq_t *state_c, dl_matrix2dq_t *state_h, + const dl_matrix2dq_t *weight, const dl_matrix2dq_t *bias, int step, int shift); + +dl_matrix2dq_t *dl_convq16_lstm_layer(const dl_convq_queue_t *in, dl_convq_queue_t *out, dl_matrix2dq_t *state_c, + dl_matrix2dq_t *state_h, const dl_matrix2dq_t *in_weight, const dl_matrix2dq_t *h_weight, + const dl_matrix2dq_t *bias, int prenum); + +/** + * @brief Allocate a fixed-point multi channel convolution queue + * + * @param n The length of queue + * @param c The channel number of elements in the queue + * @param nch the channel numbet of convolution queue + * @return The convolution queue, or NULL if out of memory + */ +dl_convq_queue_t **dl_convq_queue_mc_alloc(int n, int c, int nch); + +/** + * @brief Free a fixed-point multi channel convolution queue + * + * @param cqm The fixed-point convolution queue to free + * @param nch The channel number of cqm + */ +void dl_convq_queue_mc_free(dl_convq_queue_t **cqm, int nch); + +/** + * @brief Fast and quantised implement for 1D atrous convolution (a.k.a. convolution with holes or dilated convolution) + * based on convolution queue. + * + * @Warning All input and output convolution queue and matrix should be allocated. The return pointer + * is last element of output queue and should not be freed separately. + * + * @param in Input fixed-point convolution queue + * @param out Output fixed-point convolution queue + * @param nch The channel number of input + * @param rate A positive int, the stride with which we sample input value + * @param size A positive int, the size of 1D-filter + * @param kernel The kernel matrix of filter + * @param bias The bias matrix of filter. Can be NULL if a bias of 0 is required. + * @param shift Shift ratio used in dot operation between two 16-bit fixed point vector + * @param offset the offset to calculate input convq + * @param prenum the preload size, 0: do not use preload function + * @return The result of atrous convolution + */ +qtp_t *dl_atrous_conv1dq_mc_steps( dl_convq_queue_t **in, + dl_convq_queue_t **out, + int nch, + int rate, + int size, + dl_matrix2dq_t* kernel, + dl_matrix2dq_t* bias, + int shift, + int offset, + int prenum); + +/** + * @brief Fast implement of dilation layer as follows for multi channel input + * + * |-> [gate(sigmoid)] -| + * input - | |-> (*) - output + * |-> [filter(tanh)] -| + * + * @Warning All input and output convolution queue and matrix should be allocated. The return pointer + * is last element of output queue and should not be freed separately. + * + * @param in Input fixed-point convolution queue + * @param out Output fixed-point convolution queue + * @param nch The channel number of input + * @param rate A positive int, the stride with which we sample input value + * @param size A positive int, the size of 1D-filter + * @param filter_kernel The kernel matrix of filter + * @param filter_bias The bias matrix of filter. Can be NULL if a bias of 0 is required. + * @param gate_kernel The kernel matrix of gate + * @param gate_bias The bias matrix of gate. Can be NULL if a bias of 0 is required. + * @param filter_shift Shift ratio used in filter operation between two 16-bit fixed point vector + * @param gate_shift Shift ratio used in gate operation between two 16-bit fixed point vector + * @param offset The offset to calculate input convq + * @param prenum The preload size, 0: do not use preload function + * @return The result of dilation layer + */ +qtp_t *dl_dilation_layerq_mc_steps( dl_convq_queue_t **in, + dl_convq_queue_t **out, + int nch, + int rate, + int size, + dl_matrix2dq_t* filter_kernel, + dl_matrix2dq_t* filter_bias, + dl_matrix2dq_t* gate_kernel, + dl_matrix2dq_t* gate_bias, + int filter_shift, + int gate_shift, + int offset, + int prenum); + +void test_atrous_convq(int size, int rate, int in_channel, int out_channel); +void test_lstm_convq(int size, int in_dim, int lstm_cell); +void dl_nn_tanh_i16(dl_convq_queue_t **cqm, int offset, int nch); + +#endif \ No newline at end of file diff --git a/include/esp32/dl_lib_matrix.h b/include/esp32/dl_lib_matrix.h new file mode 100644 index 0000000..9e25c84 --- /dev/null +++ b/include/esp32/dl_lib_matrix.h @@ -0,0 +1,245 @@ +// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#ifndef DL_LIB_MATRIX_H +#define DL_LIB_MATRIX_H + +#if CONFIG_BT_SHARE_MEM_REUSE +#include "freertos/FreeRTOS.h" +#endif + +typedef float fptp_t; + +#if CONFIG_BT_SHARE_MEM_REUSE +extern multi_heap_handle_t gst_heap; +#endif + +//Flags for matrices +#define DL_MF_FOREIGNDATA (1<<0) /*< Matrix *item data actually points to another matrix and should not be freed */ + +//'Normal' float matrix +typedef struct { + int w; /*< Width */ + int h; /*< Height */ + int stride; /*< Row stride, essentially how many items to skip to get to the same position in the next row */ + int flags; /*< Flags. OR of DL_MF_* values */ + fptp_t *item; /*< Pointer to item array */ +} dl_matrix2d_t; + +//Macro to quickly access the raw items in a matrix +#define DL_ITM(m, x, y) m->item[(x)+(y)*m->stride] + + +/** + * @brief Allocate a matrix + * + * @param w Width of the matrix + * @param h Height of the matrix + * @return The matrix, or NULL if out of memory + */ +dl_matrix2d_t *dl_matrix_alloc(int w, int h); + + +/** + * @brief Free a matrix + * Frees the matrix structure and (if it doesn't have the DL_MF_FOREIGNDATA flag set) the m->items space as well. + * + * @param m Matrix to free + */ +void dl_matrix_free(dl_matrix2d_t *m); + +/** + * @brief Zero out the matrix + * Sets all entries in the matrix to 0. + * + * @param m Matrix to zero + */ +void dl_matrix_zero(dl_matrix2d_t *m); + +/** + * @brief Copy the matrix into psram + * Copy the matrix from flash or iram/psram into psram + * + * @param m Matrix to zero + */ +dl_matrix2d_t *dl_matrix_copy_to_psram(const dl_matrix2d_t *m); + +/** + * @brief Generate a new matrix using a range of items from an existing matrix. + * When using this, the data of the new matrix is not allocated/copied but it re-uses a pointer + * to the existing data. Changing the data in the resulting matrix, as a result, will also change + * the data in the existing matrix that has been sliced. + * + * @param x X-offset of the origin of the returned matrix within the sliced matrix + * @param y Y-offset of the origin of the returned matrix within the sliced matrix + * @param w Width of the resulting matrix + * @param h Height of the resulting matrix + * @param in Old matrix (with foreign data) to re-use. Passing NULL will allocate a new matrix. + * @return The resulting slice matrix, or NULL if out of memory + */ +dl_matrix2d_t *dl_matrix_slice(const dl_matrix2d_t *src, int x, int y, int w, int h, dl_matrix2d_t *in); + +/** + * @brief select a range of items from an existing matrix and flatten them into one dimension. + * + * @Warning The results are flattened in row-major order. + * + * @param x X-offset of the origin of the returned matrix within the sliced matrix + * @param y Y-offset of the origin of the returned matrix within the sliced matrix + * @param w Width of the resulting matrix + * @param h Height of the resulting matrix + * @param in Old matrix to re-use. Passing NULL will allocate a new matrix. + * @return The resulting flatten matrix, or NULL if out of memory + */ +dl_matrix2d_t *dl_matrix_flatten(const dl_matrix2d_t *src, int x, int y, int w, int h, dl_matrix2d_t *in); + +/** + * @brief Generate a matrix from existing floating-point data + * + * @param w Width of resulting matrix + * @param h Height of resulting matrix + * @param data Data to populate matrix with + * @return A newaly allocated matrix populated with the given input data, or NULL if out of memory. + */ +dl_matrix2d_t *dl_matrix_from_data(int w, int h, int stride, const void *data); + + +/** + * @brief Multiply a pair of matrices item-by-item: res=a*b + * + * @param a First multiplicand + * @param b Second multiplicand + * @param res Multiplicated data. Can be equal to a or b to overwrite that. + */ +void dl_matrix_mul(const dl_matrix2d_t *a, const dl_matrix2d_t *b, dl_matrix2d_t *res); + +/** + * @brief Do a dotproduct of two matrices : res=a.b + * + * @param a First multiplicand + * @param b Second multiplicand + * @param res Dotproduct data. *Must* be a *different* matrix from a or b! + */ +void dl_matrix_dot(const dl_matrix2d_t *a, const dl_matrix2d_t *b, dl_matrix2d_t *res); + +/** + * @brief Add a pair of matrices item-by-item: res=a-b + * + * @param a First matrix + * @param b Second matrix + * @param res Added data. Can be equal to a or b to overwrite that. + */ +void dl_matrix_add(const dl_matrix2d_t *a, const dl_matrix2d_t *b, dl_matrix2d_t *out); + + +/** + * @brief Divide a pair of matrices item-by-item: res=a/b + * + * @param a First matrix + * @param b Second matrix + * @param res Divided data. Can be equal to a or b to overwrite that. + */ +void dl_matrix_div(const dl_matrix2d_t *a, const dl_matrix2d_t *b, dl_matrix2d_t *out); + +/** + * @brief Subtract a matrix from another, item-by-item: res=a-b + * + * @param a First matrix + * @param b Second matrix + * @param res Subtracted data. Can be equal to a or b to overwrite that. + */ +void dl_matrix_sub(const dl_matrix2d_t *a, const dl_matrix2d_t *b, dl_matrix2d_t *out); + +/** + * @brief Add a constant to every item of the matrix + * + * @param subj Matrix to add the constant to + * @param add The constant + */ +void dl_matrix_add_const(dl_matrix2d_t *subj, const fptp_t add); + + +/** + * @brief Concatenate the rows of two matrices into a new matrix + * + * @param a First matrix + * @param b Second matrix + * @return A newly allocated array with as avlues a|b + */ +dl_matrix2d_t *dl_matrix_concat(const dl_matrix2d_t *a, const dl_matrix2d_t *b); + +dl_matrix2d_t *dl_matrix_concat_h( dl_matrix2d_t *a, const dl_matrix2d_t *b); + +/** + * @brief Print the contents of a matrix to stdout. Used for debugging. + * + * @param a The matrix to print. + */ +void dl_printmatrix(const dl_matrix2d_t *a); + +/** + * @brief Return the average square error given a correct and a test matrix. + * + * ...Well, more or less. If anything, it gives an indication of the error between + * the two. Check the code for the exact implementation. + * + * @param a First of the two matrices to compare + * @param b Second of the two matrices to compare + * @return value indicating the relative difference between matrices + */ +float dl_matrix_get_avg_sq_err(const dl_matrix2d_t *a, const dl_matrix2d_t *b); + + + +/** + * @brief Check if two matrices have the same shape, that is, the same amount of rows and columns + * + * @param a First of the two matrices to compare + * @param b Second of the two matrices to compare + * @return true if the two matrices are shaped the same, false otherwise. + */ +int dl_matrix_same_shape(const dl_matrix2d_t *a, const dl_matrix2d_t *b); + + +/** + * @brief Get a specific item from the matrix + * + * Please use these for external matrix access instead of DL_ITM + * + * @param m Matrix to access + * @param x Column address + * @param y Row address + * @return Value in that position + */ +inline static fptp_t dl_matrix_get(const dl_matrix2d_t *m, const int x, const int y) { + return DL_ITM(m, x, y); +} + +/** + * @brief Set a specific item in the matrix to the given value + * + * Please use these for external matrix access instead of DL_ITM + * + * @param m Matrix to access + * @param x Column address + * @param y Row address + * @param val Value to write to that position + */ +inline static void dl_matrix_set(dl_matrix2d_t *m, const int x, const int y, fptp_t val) { + DL_ITM(m, x, y)=val; +} + +void matrix_get_range(const dl_matrix2d_t *m, fptp_t *rmin, fptp_t *rmax); + +#endif + diff --git a/include/dl_lib_matrixq.h b/include/esp32/dl_lib_matrixq.h similarity index 100% rename from include/dl_lib_matrixq.h rename to include/esp32/dl_lib_matrixq.h diff --git a/include/esp32/dl_lib_matrixq8.h b/include/esp32/dl_lib_matrixq8.h new file mode 100644 index 0000000..f7dc471 --- /dev/null +++ b/include/esp32/dl_lib_matrixq8.h @@ -0,0 +1,60 @@ +// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#ifndef DL_LIB_MATRIXQ8_H +#define DL_LIB_MATRIXQ8_H + +#include +#include "dl_lib_matrix.h" + +typedef int8_t q8tp_t; + +typedef struct { + int w; + int h; + int stride; //Normally equals h, not w! + int flags; + int exponent; //The values in items should be multiplied by pow(2,exponent) to get the real values. + q8tp_t *itemq; +} dl_matrix2dq8_t; + +#define DL_Q8TP_SHIFT 7 +#define DL_Q8TP_RANGE ((1<itemq[(y)+(x)*m->stride] + +/** + * @brief Allocate a matrix + * + * @param w Width of the matrix + * @param h Height of the matrix + * @return The matrix, or NULL if out of memory + */ +dl_matrix2dq8_t *dl_matrixq8_alloc(int w, int h); + +/** + * @brief Free a quantized matrix + * Frees the matrix structure and (if it doesn't have the DL_MF_FOREIGNDATA flag set) the m->items space as well. + * + * @param m Matrix to free + */ +void dl_matrixq8_free(dl_matrix2dq8_t *m); +/** + * @brief Convert a floating-point matrix to a quantized matrix + * + * @param m Floating-point matrix to convert + * @param out Quantized matrix to re-use. If NULL, allocate a new one. + * @Return The quantized version of the floating-point matrix + */ +dl_matrix2dq8_t *dl_matrixq8_from_matrix2d(const dl_matrix2d_t *m, dl_matrix2dq8_t *out); + +#endif \ No newline at end of file diff --git a/include/esp_aec.h b/include/esp32/esp_aec.h similarity index 100% rename from include/esp_aec.h rename to include/esp32/esp_aec.h diff --git a/include/esp32/esp_afe_sr_iface.h b/include/esp32/esp_afe_sr_iface.h new file mode 100644 index 0000000..ce3c13d --- /dev/null +++ b/include/esp32/esp_afe_sr_iface.h @@ -0,0 +1,239 @@ +#pragma once +#include "stdint.h" +#include "esp_wn_iface.h" +#include "esp_wn_models.h" + +//AFE: Audio Front-End +//SR: Speech Recognition +//afe_sr/AFE_SR: the audio front-end for speech recognition + +//Opaque AFE_SR data container +typedef struct esp_afe_sr_data_t esp_afe_sr_data_t; + +//Set AFE_SR mode +typedef enum { + SR_MODE_LOW_COST = 0, + SR_MODE_HIGH_PERF = 1 +} afe_sr_mode_t; + +// the output state of fetch function +typedef enum { + AFE_FETCH_CHANNEL_VERIFIED = -2, // wwe state: output channel is verified + AFE_FETCH_NOISE = -1, // vad state: noise or silence + AFE_FETCH_SPEECH = 0, // vad state: speech + AFE_FETCH_WWE_DETECTED = 1 // wwe state: wake word is detected +} afe_fetch_mode_t; + +typedef struct { + bool aec_init; + bool se_init; + bool vad_init; + bool wakenet_init; + int vad_mode; + esp_wn_iface_t *wakenet_model; + model_coeff_getter_t *wakenet_coeff; + det_mode_t wakenet_mode; + afe_sr_mode_t afe_mode; + int afe_perferred_core; + int afe_perferred_priority; + int afe_ringbuf_size; + int alloc_from_psram; + int agc_mode; +} afe_config_t; + + +#if CONFIG_IDF_TARGET_ESP32 +#define AFE_CONFIG_DEFAULT() { \ + .aec_init = true, \ + .se_init = true, \ + .vad_init = true, \ + .wakenet_init = true, \ + .vad_mode = 3, \ + .wakenet_model = &WAKENET_MODEL, \ + .wakenet_coeff = &WAKENET_COEFF, \ + .wakenet_mode = DET_MODE_90, \ + .afe_mode = SR_MODE_HIGH_PERF, \ + .afe_perferred_core = 0, \ + .afe_perferred_priority = 5, \ + .afe_ringbuf_size = 50, \ + .alloc_from_psram = 1, \ + .agc_mode = 2, \ +} +#elif CONFIG_IDF_TARGET_ESP32S3 +#define AFE_CONFIG_DEFAULT() { \ + .aec_init = true, \ + .se_init = true, \ + .vad_init = true, \ + .wakenet_init = true, \ + .vad_mode = 3, \ + .wakenet_model = &WAKENET_MODEL, \ + .wakenet_coeff = &WAKENET_COEFF, \ + .wakenet_mode = DET_MODE_2CH_90, \ + .afe_mode = SR_MODE_LOW_COST, \ + .afe_perferred_core = 0, \ + .afe_perferred_priority = 5, \ + .afe_ringbuf_size = 50, \ + .alloc_from_psram = 2, \ + .agc_mode = 2, \ +} +#endif +/** + * @brief Function to initialze a AFE_SR instance with a specified mode + * + * @param mode The mode of AFE_SR + * @param perferred_core The perferred core to be pinned. + * If all task in AFE_SR can not run in real time by only one core, the another core would be used. + * @returns Handle to the AFE_SR data + */ +typedef esp_afe_sr_data_t* (*esp_afe_sr_iface_op_create_t)(afe_sr_mode_t mode, int perferred_cor); + +/** + * @brief Function to initialze a AFE_SR instance + * + * @param afe_config The config of AFE_SR + * @returns Handle to the AFE_SR data + */ +typedef esp_afe_sr_data_t* (*esp_afe_sr_iface_op_create_from_config_t)(afe_config_t *afe_config); + +/** + * @brief Get the amount of each channel samples per frame that need to be passed to the function + * + * Every speech enhancement AFE_SR processes a certain number of samples at the same time. This function + * can be used to query that amount. Note that the returned amount is in 16-bit samples, not in bytes. + * + * @param afe The AFE_SR object to query + * @return The amount of samples to feed the fetch function + */ +typedef int (*esp_afe_sr_iface_op_get_samp_chunksize_t)(esp_afe_sr_data_t *afe); + +/** + * @brief Get the channel number of samples that need to be passed to the fetch function + * + * @param afe The AFE_SR object to query + * @return The amount of samples to feed the fetch function + */ +typedef int (*esp_afe_sr_iface_op_get_channel_num_t)(esp_afe_sr_data_t *afe); + +/** + * @brief Get the sample rate of the samples to feed to the function + * + * @param afe The AFE_SR object to query + * @return The sample rate, in hz + */ +typedef int (*esp_afe_sr_iface_op_get_samp_rate_t)(esp_afe_sr_data_t *afe); + +/** + * @brief Feed samples of an audio stream to the AFE_SR + * + * @Warning The input data should be arranged in the format of [CH0_0, CH1_0, ..., CHN_0, CH0_1, CH1_1, ..., CHN_1, ...]. + * The last channel is reference signal or far-end signal. + * + * @param afe The AFE_SR object to queryq + * + * @param in The input microphone signal, only support signed 16-bit @ 16 KHZ. The frame size can be queried by the + * `get_samp_chunksize`. The channel number can be queried `get_channel_num`. + * @return The size of input + */ +typedef int (*esp_afe_sr_iface_op_feed_t)(esp_afe_sr_data_t *afe, const int16_t* in); + +/** + * @brief fetch enhanced samples of an audio stream from the AFE_SR + * + * @Warning The output is single channel data, no matter how many channels the input is. + * + * @param afe The AFE_SR object to query + * @param out The output enhanced signal. The frame size can be queried by the `get_samp_chunksize`. + * @return The state of output, please refer to the definition of `afe_fetch_mode_t` + */ +typedef afe_fetch_mode_t (*esp_afe_sr_iface_op_fetch_t)(esp_afe_sr_data_t *afe, int16_t* out); + +/** + * @brief Initial wakenet and wake words coefficient, or reset wakenet and wake words coefficient + * when wakenet has been initialized. + * + * @param afe The AFE_SR object to query + * @param wakenet The pointer of wakenet + * @param model_coeff The coefficient of wake word model + * @return 0: fail, 1: success + */ +typedef int (*esp_afe_sr_iface_op_set_wakenet_t)(esp_afe_sr_data_t *afe, + esp_wn_iface_t *wakenet, + const model_coeff_getter_t *model_coeff); + +/** + * @brief Disable wakenet model. + * + * @param afe The AFE_SR object to query + * @return 0: fail, 1: success + */ +typedef int (*esp_afe_sr_iface_op_disable_wakenet_t)(esp_afe_sr_data_t *afe); + +/** + * @brief Enable wakenet model. + * + * @param afe The AFE_SR object to query + * @return 0: fail, 1: success + */ +typedef int (*esp_afe_sr_iface_op_enable_wakenet_t)(esp_afe_sr_data_t *afe); + +/** + * @brief Disable AEC algorithm. + * + * @param afe The AFE_SR object to query + * @return 0: fail, 1: success + */ +typedef int (*esp_afe_sr_iface_op_disable_aec_t)(esp_afe_sr_data_t *afe); + +/** + * @brief Enable AEC algorithm. + * + * @param afe The AFE_SR object to query + * @return 0: fail, 1: success + */ +typedef int (*esp_afe_sr_iface_op_enable_aec_t)(esp_afe_sr_data_t *afe); + +/** + * @brief Disable SE algorithm. + * + * @param afe The AFE_SR object to query + * @return 0: fail, 1: success + */ +typedef int (*esp_afe_sr_iface_op_disable_se_t)(esp_afe_sr_data_t *afe); + +/** + * @brief Enable SE algorithm. + * + * @param afe The AFE_SR object to query + * @return 0: fail, 1: success + */ +typedef int (*esp_afe_sr_iface_op_enable_se_t)(esp_afe_sr_data_t *afe); + +/** + * @brief Destroy a AFE_SR instance + * + * @param afe AFE_SR object to destroy + */ +typedef void (*esp_afe_sr_iface_op_destroy_t)(esp_afe_sr_data_t *afe); + + +/** + * This structure contains the functions used to do operations on a AFE_SR. + */ +typedef struct { + esp_afe_sr_iface_op_create_t create; + esp_afe_sr_iface_op_create_from_config_t create_from_config; + esp_afe_sr_iface_op_feed_t feed; + esp_afe_sr_iface_op_fetch_t fetch; + esp_afe_sr_iface_op_get_samp_chunksize_t get_feed_chunksize; + esp_afe_sr_iface_op_get_samp_chunksize_t get_fetch_chunksize; + esp_afe_sr_iface_op_get_channel_num_t get_channel_num; + esp_afe_sr_iface_op_get_samp_rate_t get_samp_rate; + esp_afe_sr_iface_op_set_wakenet_t set_wakenet; + esp_afe_sr_iface_op_disable_wakenet_t disable_wakenet; + esp_afe_sr_iface_op_enable_wakenet_t enable_wakenet; + esp_afe_sr_iface_op_disable_aec_t disable_aec; + esp_afe_sr_iface_op_enable_aec_t enable_aec; + esp_afe_sr_iface_op_disable_se_t disable_se; + esp_afe_sr_iface_op_enable_se_t enable_se; + esp_afe_sr_iface_op_destroy_t destroy; +} esp_afe_sr_iface_t; diff --git a/include/esp_afe_sr_models.h b/include/esp32/esp_afe_sr_models.h similarity index 100% rename from include/esp_afe_sr_models.h rename to include/esp32/esp_afe_sr_models.h diff --git a/include/esp_agc.h b/include/esp32/esp_agc.h similarity index 100% rename from include/esp_agc.h rename to include/esp32/esp_agc.h diff --git a/include/esp_map.h b/include/esp32/esp_map.h similarity index 100% rename from include/esp_map.h rename to include/esp32/esp_map.h diff --git a/include/esp_mase.h b/include/esp32/esp_mase.h similarity index 100% rename from include/esp_mase.h rename to include/esp32/esp_mase.h diff --git a/include/esp32/esp_mn_iface.h b/include/esp32/esp_mn_iface.h new file mode 100644 index 0000000..4cbd53e --- /dev/null +++ b/include/esp32/esp_mn_iface.h @@ -0,0 +1,89 @@ +#pragma once +#include "stdint.h" +// #include "esp_err.h" +#include "dl_lib_coefgetter_if.h" +#include "esp_wn_iface.h" +// //Opaque model data container +// typedef struct model_iface_data_t model_iface_data_t; + +/** + * @brief Initialze a model instance with specified model coefficient. + * + * @param coeff The wakenet model coefficient. + * @param coeff The wakenet model coefficient. + * @parm sample_length Audio length for speech recognition, in ms. + * @returns Handle to the model data. + */ +typedef model_iface_data_t* (*esp_mn_iface_op_create_t)(const model_coeff_getter_t *coeff, int sample_length); + + +/** + * @brief Callback function type to fetch the amount of samples that need to be passed to the detect function + * + * Every speech recognition model processes a certain number of samples at the same time. This function + * can be used to query that amount. Note that the returned amount is in 16-bit samples, not in bytes. + * + * @param model The model object to query + * @return The amount of samples to feed the detect function + */ +typedef int (*esp_mn_iface_op_get_samp_chunksize_t)(model_iface_data_t *model); + +/** + * @brief Callback function type to fetch the number of frames recognized by the command word + * + * @param model The model object to query + * @return The number of the frames recognized by the command word + */ +typedef int (*esp_mn_iface_op_get_samp_chunknum_t)(model_iface_data_t *model); + +/** + * @brief Set the detection threshold to manually abjust the probability + * + * @param model The model object to query + * @param det_treshold The threshold to trigger speech commands, the range of det_threshold is 0.5~0.9999 + */ +typedef int (*esp_mn_iface_op_set_det_threshold_t)(model_iface_data_t *model, float det_threshold); + +/** + * @brief Get the sample rate of the samples to feed to the detect function + * + * @param model The model object to query + * @return The sample rate, in hz + */ +typedef int (*esp_mn_iface_op_get_samp_rate_t)(model_iface_data_t *model); + +/** + * @brief Feed samples of an audio stream to the speech recognition model and detect if there is a speech command found. + * + * @param model The model object to query. + * @param samples An array of 16-bit signed audio samples. The array size used can be queried by the + * get_samp_chunksize function. + * @return The command id, return 0 if no command word is detected, + */ +typedef int (*esp_mn_iface_op_detect_t)(model_iface_data_t *model, int16_t *samples); + + +/** + * @brief Destroy a speech commands recognition model + * + * @param model The Model object to destroy + */ +typedef void (*esp_mn_iface_op_destroy_t)(model_iface_data_t *model); + +/** + * @brief Reset the speech commands recognition model + * + */ +typedef void (*esp_mn_iface_op_reset_t)(model_iface_data_t *model, char *command_str, char *err_phrase_id); + + +typedef struct { + esp_mn_iface_op_create_t create; + esp_mn_iface_op_get_samp_rate_t get_samp_rate; + esp_mn_iface_op_get_samp_chunksize_t get_samp_chunksize; + esp_mn_iface_op_get_samp_chunknum_t get_samp_chunknum; + esp_mn_iface_op_set_det_threshold_t set_det_threshold; + esp_mn_iface_op_detect_t detect; + esp_mn_iface_op_destroy_t destroy; + esp_mn_iface_op_reset_t reset; +} esp_mn_iface_t; diff --git a/include/esp_mn_models.h b/include/esp32/esp_mn_models.h similarity index 100% rename from include/esp_mn_models.h rename to include/esp32/esp_mn_models.h diff --git a/include/esp_ns.h b/include/esp32/esp_ns.h similarity index 100% rename from include/esp_ns.h rename to include/esp32/esp_ns.h diff --git a/include/esp_vad.h b/include/esp32/esp_vad.h similarity index 100% rename from include/esp_vad.h rename to include/esp32/esp_vad.h diff --git a/include/esp32/esp_wn_iface.h b/include/esp32/esp_wn_iface.h new file mode 100644 index 0000000..08c7494 --- /dev/null +++ b/include/esp32/esp_wn_iface.h @@ -0,0 +1,156 @@ +#pragma once +#include "stdint.h" +#include "dl_lib_coefgetter_if.h" + +//Opaque model data container +typedef struct model_iface_data_t model_iface_data_t; + +//Set wake words recognition operating mode +//The probability of being wake words is increased with increasing mode, +//As a consequence also the false alarm rate goes up +typedef enum { + DET_MODE_90 = 0, //Normal, response accuracy rate about 90% + DET_MODE_95 = 1, //Aggressive, response accuracy rate about 95% + DET_MODE_2CH_90 = 2, + DET_MODE_2CH_95 = 3, + DET_MODE_3CH_90 = 4, + DET_MODE_3CH_95 = 5, +} det_mode_t; + +typedef struct { + int wake_word_num; //The number of all wake words + char **wake_word_list; //The name list of wake words +} wake_word_info_t; + +/** + * @brief Easy function type to initialze a model instance with a detection mode and specified wake word coefficient + * + * @param det_mode The wake words detection mode to trigger wake words, DET_MODE_90 or DET_MODE_95 + * @param model_coeff The specified wake word model coefficient + * @returns Handle to the model data + */ +typedef model_iface_data_t* (*esp_wn_iface_op_create_t)(const model_coeff_getter_t *model_coeff, det_mode_t det_mode); + +/** + * @brief Callback function type to fetch the amount of samples that need to be passed to the detect function + * + * Every speech recognition model processes a certain number of samples at the same time. This function + * can be used to query that amount. Note that the returned amount is in 16-bit samples, not in bytes. + * + * @param model The model object to query + * @return The amount of samples to feed the detect function + */ +typedef int (*esp_wn_iface_op_get_samp_chunksize_t)(model_iface_data_t *model); + +/** + * @brief Callback function type to fetch the channel number of samples that need to be passed to the detect function + * + * Every speech recognition model processes a certain number of samples at the same time. This function + * can be used to query that amount. Note that the returned amount is in 16-bit samples, not in bytes. + * + * @param model The model object to query + * @return The amount of samples to feed the detect function + */ +typedef int (*esp_wn_iface_op_get_channel_num_t)(model_iface_data_t *model); + + +/** + * @brief Get the sample rate of the samples to feed to the detect function + * + * @param model The model object to query + * @return The sample rate, in hz + */ +typedef int (*esp_wn_iface_op_get_samp_rate_t)(model_iface_data_t *model); + +/** + * @brief Get the number of wake words + * + * @param model The model object to query + * @returns the number of wake words + */ +typedef int (*esp_wn_iface_op_get_word_num_t)(model_iface_data_t *model); + +/** + * @brief Get the name of wake word by index + * + * @Warning The index of wake word start with 1 + + * @param model The model object to query + * @param word_index The index of wake word + * @returns the detection threshold + */ +typedef char* (*esp_wn_iface_op_get_word_name_t)(model_iface_data_t *model, int word_index); + +/** + * @brief Set the detection threshold to manually abjust the probability + * + * @param model The model object to query + * @param det_treshold The threshold to trigger wake words, the range of det_threshold is 0.5~0.9999 + * @param word_index The index of wake word + * @return 0: setting failed, 1: setting success + */ +typedef int (*esp_wn_iface_op_set_det_threshold_t)(model_iface_data_t *model, float det_threshold, int word_index); + +/** + * @brief Get the wake word detection threshold of different modes + * + * @param model The model object to query + * @param word_index The index of wake word + * @returns the detection threshold + */ +typedef float (*esp_wn_iface_op_get_det_threshold_t)(model_iface_data_t *model, int word_index); + +/** + * @brief Feed samples of an audio stream to the keyword detection model and detect if there is a keyword found. + * + * @Warning The index of wake word start with 1, 0 means no wake words is detected. + * + * @param model The model object to query + * @param samples An array of 16-bit signed audio samples. The array size used can be queried by the + * get_samp_chunksize function. + * @return The index of wake words, return 0 if no wake word is detected, else the index of the wake words. + */ +typedef int (*esp_wn_iface_op_detect_t)(model_iface_data_t *model, int16_t *samples); + +/** + * @brief Get the volume gain + * + * @param model The model object to query + * @param target_db The target dB to calculate volume gain + * @returns the volume gain + */ +typedef float (*esp_wn_iface_op_get_vol_gain_t)(model_iface_data_t *model, float target_db); + +/** + * @brief Get the triggered channel index. Channel index starts from zero + * + * @param model The model object to query + * @return The channel index + */ +typedef int (*esp_wn_iface_op_get_triggered_channel_t)(model_iface_data_t *model); + +/** + * @brief Destroy a speech recognition model + * + * @param model Model object to destroy + */ +typedef void (*esp_wn_iface_op_destroy_t)(model_iface_data_t *model); + + +/** + * This structure contains the functions used to do operations on a wake word detection model. + */ +typedef struct { + esp_wn_iface_op_create_t create; + esp_wn_iface_op_get_samp_chunksize_t get_samp_chunksize; + esp_wn_iface_op_get_channel_num_t get_channel_num; + esp_wn_iface_op_get_samp_rate_t get_samp_rate; + esp_wn_iface_op_get_word_num_t get_word_num; + esp_wn_iface_op_get_word_name_t get_word_name; + esp_wn_iface_op_set_det_threshold_t set_det_threshold; + esp_wn_iface_op_get_det_threshold_t get_det_threshold; + esp_wn_iface_op_get_triggered_channel_t get_triggered_channel; + esp_wn_iface_op_get_vol_gain_t get_vol_gain; + esp_wn_iface_op_detect_t detect; + esp_wn_iface_op_destroy_t destroy; +} esp_wn_iface_t; diff --git a/include/esp_wn_models.h b/include/esp32/esp_wn_models.h similarity index 100% rename from include/esp_wn_models.h rename to include/esp32/esp_wn_models.h diff --git a/include/hijeson_wn5X3.h b/include/esp32/hijeson_wn5X3.h similarity index 100% rename from include/hijeson_wn5X3.h rename to include/esp32/hijeson_wn5X3.h diff --git a/include/hilexin_wn5.h b/include/esp32/hilexin_wn5.h similarity index 100% rename from include/hilexin_wn5.h rename to include/esp32/hilexin_wn5.h diff --git a/include/hilexin_wn5X2.h b/include/esp32/hilexin_wn5X2.h similarity index 100% rename from include/hilexin_wn5X2.h rename to include/esp32/hilexin_wn5X2.h diff --git a/include/hilexin_wn5X3.h b/include/esp32/hilexin_wn5X3.h similarity index 100% rename from include/hilexin_wn5X3.h rename to include/esp32/hilexin_wn5X3.h diff --git a/include/mn_process_commands.h b/include/esp32/mn_process_commands.h similarity index 100% rename from include/mn_process_commands.h rename to include/esp32/mn_process_commands.h diff --git a/include/model_path.h b/include/esp32/model_path.h similarity index 100% rename from include/model_path.h rename to include/esp32/model_path.h diff --git a/include/multinet2_ch.h b/include/esp32/multinet2_ch.h similarity index 100% rename from include/multinet2_ch.h rename to include/esp32/multinet2_ch.h diff --git a/include/nihaoxiaoxin_wn5X3.h b/include/esp32/nihaoxiaoxin_wn5X3.h similarity index 100% rename from include/nihaoxiaoxin_wn5X3.h rename to include/esp32/nihaoxiaoxin_wn5X3.h diff --git a/include/nihaoxiaoxin_wn6.h b/include/esp32/nihaoxiaoxin_wn6.h similarity index 100% rename from include/nihaoxiaoxin_wn6.h rename to include/esp32/nihaoxiaoxin_wn6.h diff --git a/include/nihaoxiaozhi_wn5.h b/include/esp32/nihaoxiaozhi_wn5.h similarity index 100% rename from include/nihaoxiaozhi_wn5.h rename to include/esp32/nihaoxiaozhi_wn5.h diff --git a/include/nihaoxiaozhi_wn5X2.h b/include/esp32/nihaoxiaozhi_wn5X2.h similarity index 100% rename from include/nihaoxiaozhi_wn5X2.h rename to include/esp32/nihaoxiaozhi_wn5X2.h diff --git a/include/nihaoxiaozhi_wn5X3.h b/include/esp32/nihaoxiaozhi_wn5X3.h similarity index 100% rename from include/nihaoxiaozhi_wn5X3.h rename to include/esp32/nihaoxiaozhi_wn5X3.h diff --git a/include/sr_flash.h b/include/esp32/sr_flash.h similarity index 100% rename from include/sr_flash.h rename to include/esp32/sr_flash.h diff --git a/include/esp32s3/customized_word_wn5.h b/include/esp32s3/customized_word_wn5.h new file mode 100644 index 0000000..57199e5 --- /dev/null +++ b/include/esp32s3/customized_word_wn5.h @@ -0,0 +1,8 @@ +//Generated by mkmodel +#pragma once +#include +#include "dl_lib_coefgetter_if.h" +#include "dl_lib_matrix.h" +#include "dl_lib_matrixq.h" + +extern const model_coeff_getter_t get_coeff_customized_word_wn5; diff --git a/include/dl_lib.h b/include/esp32s3/dl_lib.h similarity index 100% rename from include/dl_lib.h rename to include/esp32s3/dl_lib.h diff --git a/include/esp32s3/dl_lib_coefgetter_if.h b/include/esp32s3/dl_lib_coefgetter_if.h new file mode 100644 index 0000000..f1a9373 --- /dev/null +++ b/include/esp32s3/dl_lib_coefgetter_if.h @@ -0,0 +1,72 @@ +// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#ifndef DL_LIB_COEFGETTER_IF_H +#define DL_LIB_COEFGETTER_IF_H + +#include "dl_lib_matrix.h" +#include "dl_lib_matrixq.h" +#include "dl_lib_matrixq8.h" +#include "cJSON.h" + +//Set this if the coefficient requested is a batch-normalization popvar matrix which needs to be preprocessed by +//dl_batch_normalize_get_sqrtvar first. +#define COEF_GETTER_HINT_BNVAR (1<<0) + +/* +This struct describes the basic information of model data: +word_num: the number of wake words or speech commands +word_list: the name list of wake words or speech commands +thres_list: the threshold list of wake words or speech commands +info_str: the string used to reflect the version and information of model data + which consist of the architecture of network, the version of model data, wake words and their threshold +*/ +typedef struct { + int word_num; + char **word_list; + int *win_list; + float *thresh_list; + char *info_str; +} model_info_t; + +/* +Alphabet struct describes the basic grapheme or phoneme. +item_num: the number of baisc item(grapheme or phonemr) +items: the list of basic item +*/ +typedef struct { + int item_num; + char **items; +}alphabet_t; + +/* +This struct describes a generic coefficient getter: a way to get the constant coefficients needed for a neural network. +For the two getters, the name describes the name of the coefficient matrix, usually the same as the Numpy filename the +coefficient was originally stored in. The arg argument can be used to optionally pass an additional user-defined argument +to the getter (e.g. the directory to look for files in the case of the Numpy file loader getter). The hint argument +is a bitwise OR of the COEF_GETTER_HINT_* flags or 0 when none is needed. Use the free_f/free_q functions to release the +memory for the returned matrices, when applicable. +*/ +typedef struct { + const dl_matrix2d_t* (*getter_f)(const char *name, void *arg, int hint); + const dl_matrix2dq_t* (*getter_q)(const char *name, void *arg, int hint); + const dl_matrix2dq8_t* (*getter_q8)(const char *name, void *arg, int hint); + void (*free_f)(const dl_matrix2d_t *m); + void (*free_q)(const dl_matrix2dq_t *m); + void (*free_q8)(const dl_matrix2dq8_t *m); + const model_info_t* (*getter_info)(void *arg); + const alphabet_t* (*getter_alphabet)(void *arg); + const cJSON* (*getter_config)(void *arg); +} model_coeff_getter_t; + +#endif \ No newline at end of file diff --git a/include/esp32s3/dl_lib_conv_queue.h b/include/esp32s3/dl_lib_conv_queue.h new file mode 100644 index 0000000..e0ca0a1 --- /dev/null +++ b/include/esp32s3/dl_lib_conv_queue.h @@ -0,0 +1,164 @@ +// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#ifndef DL_LIB_CONV_QUEUE_H +#define DL_LIB_CONV_QUEUE_H + + +#include "dl_lib_matrix.h" +typedef float fptp_t; + + +//Flags for matrices +#define DL_MF_FOREIGNDATA (1<<0) /*< Matrix *item data actually points to another matrix and should not be freed */ + +//Float convolution FIFO queue. +typedef struct { + int n; /*< the length of queue */ + int c; /*< the channel number of queue element*/ + int front; /*< the front(top) position of queue */ + int flag; /*< not used*/ + fptp_t *item; /*< Pointer to item array */ +} dl_conv_queue_t; + +/** + * @brief Allocate a convolution queue + * + * @param n The length of queue + * @param c The channel number of elements in the queue + * @return The convolution queue, or NULL if out of memory + */ +dl_conv_queue_t *dl_conv_queue_alloc(int n, int c); + +/** + * @brief Free a convolution queue + * + * @param cq The convolution queue to free + */ +void dl_conv_queue_free(dl_conv_queue_t *cq); + +void dl_conv_to_matrix2d(dl_conv_queue_t *cq, dl_matrix2d_t* out); + +/** + * @brief Move the front pointer of queue forward, + the First(oldest) element become the last(newest) element, + * + * @param cq Input convolution queue + * @return Pointer of oldest element + */ +fptp_t *dl_conv_queue_pop(dl_conv_queue_t *cq); + +/** + * @brief Remove the oldest element, then insert the input element at the end of queue + * + * @param cq Input convolution queue + * @param item The new element + */ +void dl_conv_queue_push(dl_conv_queue_t *cq, fptp_t* item); + + +/** + * @brief Get the pointer of element in the queue by offset + * + * @param cq Input convolution queue + * @param offset Offset from the front of the queue + * @return Pointer of the element + */ +fptp_t *dl_get_queue_item(dl_conv_queue_t *cq, int offset); + +/** + * @brief Does a sigmoid operation on the one of element in the convolution queue. + * Gets the pointer of element in the convolution queue by offset, and does a sigmoid operation + * by this pointer, then return the pointer + * + * @param cq Input convolution queue + * @param offset Offset from the front of the queue + * @return Pointer of the element + */ +fptp_t *dl_sigmoid_step(dl_conv_queue_t *cq, int offset); + +/** + * @brief Does a tanh operation on the one of element in the convolution queue. + * Gets the pointer of element in the convolution queue by offset, and does a tanh operation + * by this pointer, then return the pointer + * + * @param cq Input convolution queue + * @param offset Offset from the front of the queue + * @return Pointer of the element + */ +fptp_t *dl_tanh_step(dl_conv_queue_t *cq, int offset); + +/** + * @brief Does a softmax operation on the one of element in the convolution queue. + * Gets the pointer of element in the convolution queue by offset, and does a softmax operation + * by this pointer, then return the pointer + * + * @param cq Input convolution queue + * @param offset Offset from the front of the queue + * @return Pointer of the element + */ +fptp_t *dl_softmax_step(dl_conv_queue_t *cq, int offset); + +fptp_t *dl_relu_step(dl_conv_queue_t *cq, int offset); +fptp_t *dl_relu_look(dl_matrix2d_t *cq, int offset); +dl_matrix2d_t *dl_matrix_concat1(const dl_conv_queue_t *a, const dl_matrix2d_t *b); +dl_matrix2d_t *dl_basic_lstm_layer1(const dl_conv_queue_t *in, dl_matrix2d_t *state_c, dl_matrix2d_t *state_h, + const dl_matrix2d_t *weight, const dl_matrix2d_t *bias); +/** + * @brief Fast implement for 1D atrous convolution (a.k.a. convolution with holes or dilated convolution) + * based on convolution queue. + * + * @Warning All input and output convolution queue and matrix should be allocated. The return pointer + * is first element of output queue and should not be freed separately. + * + * @param in Input convolution queue + * @param out Output convolution queue + * @param rate A positive int, the stride with which we sample input value + * @param size A positive int, the size of 1D-filter + * @param kernel The kernel matrix of filter + * @param bias The bias matrix of filter. Can be NULL if a bias of 0 is required. + * @return The result of atrous convolution + */ +fptp_t *dl_atrous_conv1d_step(dl_conv_queue_t *in, dl_conv_queue_t *out, int rate, int size, + dl_matrix2d_t* kernel, dl_matrix2d_t* bias); +fptp_t *dl_look_conv_step(dl_conv_queue_t *in, dl_matrix2d_t *out, int rate, int size, + dl_matrix2d_t* kernel, dl_matrix2d_t* bias); + +/** + * @brief Fast implement of dilation layer as follows + * + * |-> [gate(sigmoid)] -| + * input - | |-> (*) - output + * |-> [filter(tanh)] -| + * + * @Warning All input and output convolution queue and matrix should be allocated. The return pointer + * is first element of output queue and should not be freed separately. + * + * @param in Input convolution queue + * @param out Output convolution queue + * @param rate A positive int, the stride with which we sample input value + * @param size A positive int, the size of 1D-filter + * @param filter_kernel The kernel matrix of filter + * @param filter_bias The bias matrix of filter. Can be NULL if a bias of 0 is required. + * @param gate_kernel The kernel matrix of gate + * @param gate_bias The bias matrix of gate. Can be NULL if a bias of 0 is required. + * @return The result of dilation layer + */ +fptp_t *dl_dilation_layer(dl_conv_queue_t *in, dl_conv_queue_t *out, int rate, int size, + dl_matrix2d_t* filter_kernel, dl_matrix2d_t* filter_bias, + dl_matrix2d_t* gate_kernel, dl_matrix2d_t* gate_bias); + + +void test_atrous_conv(int size, int rate, int in_channel, int out_channel); + +#endif \ No newline at end of file diff --git a/include/dl_lib_convq8_queue.h b/include/esp32s3/dl_lib_convq8_queue.h similarity index 100% rename from include/dl_lib_convq8_queue.h rename to include/esp32s3/dl_lib_convq8_queue.h diff --git a/include/dl_lib_convq_queue.h b/include/esp32s3/dl_lib_convq_queue.h similarity index 100% rename from include/dl_lib_convq_queue.h rename to include/esp32s3/dl_lib_convq_queue.h diff --git a/include/dl_lib_matrix.h b/include/esp32s3/dl_lib_matrix.h similarity index 100% rename from include/dl_lib_matrix.h rename to include/esp32s3/dl_lib_matrix.h diff --git a/include/esp32s3/dl_lib_matrixq.h b/include/esp32s3/dl_lib_matrixq.h new file mode 100644 index 0000000..5f0474a --- /dev/null +++ b/include/esp32s3/dl_lib_matrixq.h @@ -0,0 +1,378 @@ +// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#ifndef DL_LIB_MATRIXQ_H +#define DL_LIB_MATRIXQ_H + +#include +#include "dl_lib_matrix.h" + +typedef int16_t qtp_t; + +//Quantized matrix. Uses fixed numbers and has the storage for the rows/columns inverted +//for easy use as a multiplicand without stressing out the flash cache too much. +typedef struct { + int w; + int h; + int stride; //Normally equals h, not w! + int flags; + int exponent; //The values in items should be multiplied by pow(2,exponent) to get the real values. + qtp_t *itemq; +} dl_matrix2dq_t; + +#define DL_QTP_SHIFT 15 +#define DL_QTP_RANGE ((1<itemq[(y)+(x)*m->stride] +#define DL_QTP_EXP_NA 255 //non-applicable exponent because matrix is null + +#define DL_SHIFT_AUTO 32 + +/** + * @info About quantized matrices and shift values + * + * Grab a coffee (or tea, or hot water) and sit down when you read this for the first + * time. Quantized matrices can speed up your operations, but come with some quirks, and + * it's good to understand how they work before using them. + * + * The data in the quantized matrix type is stored similarily to floating-point types: + * when storing a real value, the value is stored as a mantissa (base number) and an + * exponent. The 'real' value that can be re-derived from those two numbers is something + * similar to mantissa*2^exponent. Up to this point, there's not that much difference from + * the standard floating point implementations like e.g. IEEE-754. + * + * The difference with respect to quantized matrices is that for a quantized matrix, it is + * assumed all values stored have more-or-less the same order of magnitude. This allows the + * matrix to only store all the mantissas, while the exponents are shared; there is only one + * exponent for the entire matrix. This makes it quicker to handle matrix operations - the + * logic to fix the exponents only needs to happen once, while the rest can be done in simple + * integer arithmetic. It also nets us some memory savings - while normally a floating point + * number is 32-bit, storing only 16-bit mantissas as the matrix items almost halves the + * memory requirements. + * + * While most of the details of handling the intricacies of the quantized matrixes are done + * transparently by the code in dl_lib_matrixq.c, some implementation details leak out, + * specifically in places where addition/subtraction/division happens. + * + * The problem is that the routines do not know what the size of the resulting operation is. For + * instance, when adding two matrices of numbers, the resulting numbers *could* be large enough + * to overflow the mantissa of the result if the exponent is the same. However, if by default we + * assume the mantissas needs to be scaled back, we may lose precision. + * + * In order to counter this, all operations that have this issue have a ``shift`` argument. If + * the argument is zero, the routine will be conservative, that is, increase the exponent of + * the result to such an extent it's mathematically impossible a value in the result will exceed + * the maximum value that can be stored. However, when this argument is larger than zero, the + * algorithm will hold back on this scaling by the indicated amount of bits, preserving precision + * but increasing the chance of some of the calculated values not fitting in the mantissa anymore. + * If this happens, the value will be clipped to the largest (or, for negative values, smallest) + * value possible. (Neural networks usually are okay with this happening for a limited amount + * of matrix indices). + * + * For deciding on these shift values, it is recommended to start with a shift value of one, then + * use dl_matrixq_check_sanity on the result. If this indicates clipping, lower the shift value. + * If it indicates bits are under-used, increase it. Note that for adding and subtraction, only + * shift values of 0 or 1 make sense; these routines will error out if you try to do something + * else. + * + * For neural networks and other noise-tolerant applications, note that even when + * dl_matrixq_check_sanity does not indicate any problems, twiddling with the shift value may lead + * to slightly improved precision. Feel free to experiment. + **/ + + +/** + * @brief Allocate a matrix + * + * @param w Width of the matrix + * @param h Height of the matrix + * @return The matrix, or NULL if out of memory + */ +dl_matrix2dq_t *dl_matrixq_alloc(int w, int h); +dl_matrix2dq_t *dl_matrixq_alloc_psram(int w, int h); +/** + * @brief Convert a floating-point matrix to a quantized matrix + * + * @param m Floating-point matrix to convert + * @param out Quantized matrix to re-use. If NULL, allocate a new one. + * @Return The quantized version of the floating-point matrix + */ +dl_matrix2dq_t *dl_matrixq_from_matrix2d(const dl_matrix2d_t *m, dl_matrix2dq_t *out); + +/** + * TODO: DESCRIBE THIS FUNCTION + */ +dl_matrix2dq_t *dl_matrixq_from_matrix2d_by_qmf(const dl_matrix2d_t *m, dl_matrix2dq_t *out, int m_bit, int f_bit); + + +/** + * @brief Convert a quantized matrix to a floating-point one. + * + * @param m Floating-point matrix to convert + * @param out Quantized matrix to re-use. If NULL, allocate a new one. + * @Return The quantized version of the floating-point matrix + **/ +dl_matrix2d_t *dl_matrix2d_from_matrixq(const dl_matrix2dq_t *m, dl_matrix2d_t *out); + + +/** + * @brief Free a quantized matrix + * Frees the matrix structure and (if it doesn't have the DL_MF_FOREIGNDATA flag set) the m->items space as well. + * + * @param m Matrix to free + */ +void dl_matrixq_free(dl_matrix2dq_t *m); + +/** + * @brief Zero out the matrix + * Sets all entries in the matrix to 0. + * + * @param m Matrix to zero + */ +void dl_matrixq_zero(dl_matrix2dq_t *m); + +/** + * @brief Copy the matrix into psram + * Copy the matrix from flash or iram/psram into psram + * + * @param m Matrix to copy + */ +dl_matrix2dq_t *dl_matrixq_copy_to_psram(const dl_matrix2dq_t *m); + +/** + * @brief Do a dotproduct of two quantized matrices : res=a.b, Result is a fixed-point matrix. + * + * @param a First multiplicand + * @param b Second multiplicand + * @param res Dotproduct data. *Must* be a *different* matrix from a or b! + * @param shift Shift ratio + */ +void dl_matrixq_dot(const dl_matrix2dq_t *a, const dl_matrix2dq_t *b, dl_matrix2dq_t *res, int shift); + +/** + * @brief Do a dotproduct of two quantized matrices: res=a.b, Result is a floating-point matrix. + * + * @param a First multiplicand + * @param b Second multiplicand + * @param res Dotproduct data. *Must* be a *different* matrix from a or b! + */ +void dl_matrixq_dot_matrix_out(const dl_matrix2dq_t *a, const dl_matrix2dq_t *b, dl_matrix2d_t *res); + +/** + * @brief Do a dotproduct of two quantized matrices : res=a.b. This always uses the simple & stupid C algo for the dot product. + * + * Result is a fixed-point matrix. + * + * Use this only if you expect something is wrong with the accelerated routines that dl_matrixq_dot calls; this function can be + * much slower than dl_matrixq_dot . + * + * @param a First multiplicand + * @param b Second multiplicand + * @param res Dotproduct data. *Must* be a *different* matrix from a or b! + * @param shift Shift ratio + */ +void dl_matrixq_dot_c_impl(const dl_matrix2dq_t *a, const dl_matrix2dq_t *b, dl_matrix2dq_t *res, int shift); + +/** + * @brief Do a dotproduct of two quantized matrices : res=a.b. This always uses the simple & stupid C algo for the dot product. + * + * Result is a floating-point matrix. + * + * Use this only if you expect something is wrong with the accelerated routines that dl_matrixq_dot_matrix_out calls; this function can be + * much slower than dl_matrixq_dot_matrix_out. + * + * @param a First multiplicand + * @param b Second multiplicand + * @param res Dotproduct data. *Must* be a *different* matrix from a or b! + */ +void dl_matrixq_dot_matrix_out_c_impl(const dl_matrix2dq_t *a, const dl_matrix2dq_t *b, dl_matrix2d_t *res); + +/** + * @brief Do a dotproduct of a floating point and a quantized matrix. Result is a floating-point matrix. + * + * @param a First multiplicand; float matrix + * @param b Second multiplicand; quantized matrix + * @param res Dotproduct data; float matrix. *Must* be a *different* matrix from a or b! + */ +void dl_matrix_matrixq_dot(const dl_matrix2d_t *a, const dl_matrix2dq_t *b, dl_matrix2d_t *res); + + +/** + * @brief Print the contents of a quantized matrix to stdout. Used for debugging. + * + * @param a The matrix to print. + */ +void dl_printmatrixq(const dl_matrix2dq_t *a); + + +/** + * @brief Add a pair of quantizedmatrices item-by-item: res=a-b + * + * @param a First matrix + * @param b Second matrix + * @param res Added data. Can be equal to a or b to overwrite that. + * @param shift Shift value. Only 0 or 1 makes sense here. + */ +void dl_matrixq_add(const dl_matrix2dq_t *a, const dl_matrix2dq_t *b, dl_matrix2dq_t *res, int shift); + +/** + * @brief Generate a new matrix using a range of items from an existing matrix. + * When using this, the data of the new matrix is not allocated/copied but it re-uses a pointer + * to the existing data. Changing the data in the resulting matrix, as a result, will also change + * the data in the existing matrix that has been sliced. + * + * @Warning In contrast to the floating point equivalent of this function, the fixed-point version + * of this has the issue that as soon as the output exponent of one of the slices changes, the data + * in the sliced matrix gets corrupted (because the exponent of that matrix is still the same.) If you + * use this function, either treat the slices as read-only, or assume the sliced matrix contains + * garbage after modifying the data in one of the slices. + * + * @param x X-offset of the origin of the returned matrix within the sliced matrix + * @param y Y-offset of the origin of the returned matrix within the sliced matrix + * @param w Width of the resulting matrix + * @param h Height of the resulting matrix + * @param in Old matrix (with foreign data) to re-use. Passing NULL will allocate a new matrix. + * @return The resulting slice matrix, or NULL if out of memory + */ +dl_matrix2dq_t *dl_matrixq_slice(const dl_matrix2dq_t *src, int x, int y, int w, int h, dl_matrix2dq_t *in); + +/** + * @brief select a range of items from an existing matrix and flatten them into one dimension. + * + * @Warning The results are flattened in row-major order. + * + * @param x X-offset of the origin of the returned matrix within the sliced matrix + * @param y Y-offset of the origin of the returned matrix within the sliced matrix + * @param w Width of the resulting matrix + * @param h Height of the resulting matrix + * @param in Old matrix to re-use. Passing NULL will allocate a new matrix. + * @return The resulting flatten matrix, or NULL if out of memory + */ +dl_matrix2dq_t *dl_matrixq_flatten(const dl_matrix2dq_t *src, int x, int y, int w, int h, dl_matrix2dq_t *in); + +/** + * @brief Subtract a quantized matrix from another, item-by-item: res=a-b + * + * @param a First matrix + * @param b Second matrix + * @param res Subtracted data. Can be equal to a or b to overwrite that. + * @param shift Shift value. Only 0 or 1 makes sense here. + */ +void dl_matrixq_sub(const dl_matrix2dq_t *a, const dl_matrix2dq_t *b, dl_matrix2dq_t *res, int shift); + +/** + * @brief Multiply a pair of quantized matrices item-by-item: res=a*b + * + * @param a First multiplicand + * @param b Second multiplicand + * @param res Multiplicated data. Can be equal to a or b to overwrite that matrix. + */ +void dl_matrixq_mul( dl_matrix2dq_t *a, dl_matrix2dq_t *b, dl_matrix2dq_t *res); + +/** + * @brief Divide a pair of quantized matrices item-by-item: res=a/b + * + * @param a First matrix + * @param b Second matrix + * @param res Divided data. Can be equal to a or b to overwrite that. + */ +void dl_matrixq_div(const dl_matrix2dq_t *a, const dl_matrix2dq_t *b, dl_matrix2dq_t *out, int shift); + +/** + * @brief Check if two quantized matrices have the same shape, that is, the same amount of + * rows and columns + * + * @param a First of the two matrices to compare + * @param b Second of the two matrices to compare + * @return true if the two matrices are shaped the same, false otherwise. + */ +int dl_matrixq_same_shape(const dl_matrix2dq_t *a, const dl_matrix2dq_t *b); + +/** + * @brief Concatenate the rows of two quantized matrices into a new matrix + * + * @param a First matrix + * @param b Second matrix + * @return A newly allocated quantized matrix with as values a|b + */ +dl_matrix2dq_t *dl_matrixq_concat(const dl_matrix2dq_t *a, const dl_matrix2dq_t *b); + +/** + * @brief Add a constant to every item of the quantized matrix + * + * @param subj Matrix to add the constant to + * @param add The constant + */ +void dl_matrixq_add_const(dl_matrix2dq_t *subj, const fptp_t add, int shift); + +/** + * @brief Check the sanity of a quantized matrix + * + * Due to the nature of quantized matrices, depending on the calculations a quantized + * matrix is the result of and the shift values chosen in those calculations, a quantized + * matrix may have an exponent and mantissas that lead to a loss of precision, either because + * most significant mantissa bits are unused, or because a fair amount of mantissas are + * clipped. This function checks if this is the case and will report a message to stdout + * if significant loss of precision is detected. + * + * @param m The quantized matrix to check + * @param name A string to be displayed in the message if the sanity check fails + * @return True if matrix is sane, false otherwise + **/ + +int dl_matrixq_check_sanity(dl_matrix2dq_t *m, const char *name); + +/** + * @brief re-adjust the exponent of the matrix to fit the mantissa better + * + * This function will shift up all the data in the mantissas so there are no + * most-significant bits that are unused in all mantissas. It will also adjust + * the exponent to keep the actua values in the matrix the same. + * + * Some operations done on a matrix, especially operations that re-use the + * result of earlier operations done in the same way, can lead to the loss of + * data because the exponent of the quantized matrix is never re-adjusted. You + * can do that implicitely by calling this function. + * + * @param m The matrix to re-adjust +**/ +void dl_matrixq_readjust_exp(dl_matrix2dq_t *m); + + + +/** + * @brief Get the floating-point value of a specific item from the quantized matrix + * + * @param m Matrix to access + * @param x Column address + * @param y Row address + * @return Value in that position + */ +fptp_t dl_matrixq_get(const dl_matrix2dq_t *m, const int x, const int y); + +/** + * @brief Set a specific item in the quantized matrix to the given + * floating-point value + * + * @warning If the given value is more than the exponent in the quantized matrix + * allows for, all mantissas in the matrix will be shifted down to make the value + * 'fit'. If, however, the exponent is such that the value would result in a + * quantized mantissa of 0, nothing is done. + * + * @param m Matrix to access + * @param x Column address + * @param y Row address + * @param val Value to write to that position + */ +void dl_matrixq_set(dl_matrix2dq_t *m, const int x, const int y, fptp_t val); + +#endif diff --git a/include/dl_lib_matrixq8.h b/include/esp32s3/dl_lib_matrixq8.h similarity index 100% rename from include/dl_lib_matrixq8.h rename to include/esp32s3/dl_lib_matrixq8.h diff --git a/include/esp32s3/esp_aec.h b/include/esp32s3/esp_aec.h new file mode 100644 index 0000000..03afc90 --- /dev/null +++ b/include/esp32s3/esp_aec.h @@ -0,0 +1,112 @@ +// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License +#ifndef _ESP_AEC_H_ +#define _ESP_AEC_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define USE_AEC_FFT // Not kiss_fft +#define AEC_USE_SPIRAM 0 +#define AEC_SAMPLE_RATE 16000 // Only Support 16000Hz +#define AEC_FRAME_LENGTH_MS 16 +#define AEC_FILTER_LENGTH 1200 // Number of samples of echo to cancel + +typedef void* aec_handle_t; + +/** + * @brief Creates an instance to the AEC structure. + * + * @deprecated This API will be deprecated after version 1.0, please use aec_pro_create + * + * @param sample_rate The Sampling frequency (Hz) must be 16000. + * + * @param frame_length The length of the audio processing must be 16ms. + * + * @param filter_length Number of samples of echo to cancel. + * + * @return + * - NULL: Create failed + * - Others: The instance of AEC + */ +aec_handle_t aec_create(int sample_rate, int frame_length, int filter_length); + +/** + * @brief Creates an instance to the AEC structure. + * + * @deprecated This API will be deprecated after version 1.0, please use aec_pro_create + * + * @param sample_rate The Sampling frequency (Hz) must be 16000. + * + * @param frame_length The length of the audio processing must be 16ms. + * + * @param filter_length Number of samples of echo to cancel. + * + * @param nch Number of input signal channel. + * + * @return + * - NULL: Create failed + * - Others: The instance of AEC + */ +aec_handle_t aec_create_multimic(int sample_rate, int frame_length, int filter_length, int nch); + +/** + * @brief Creates an instance of more powerful AEC. + * + * @param frame_length Length of input signal. Must be 16ms if mode is 0; otherwise could be 16ms or 32ms. Length of input signal to aec_process must be modified accordingly. + * + * @param nch Number of microphones. + * + * @param mode Mode of AEC (0 to 5), indicating aggressiveness and RAM allocation. 0: mild; 1 or 2: medium (1: internal RAM, 2: SPIRAM); 3 and 4: aggressive (3: internal RAM, 4: SPIRAM); 5: agressive, accelerated for ESP32-S3. + * + * @return + * - NULL: Create failed + * - Others: An Instance of AEC + */ +aec_handle_t aec_pro_create(int frame_length, int nch, int mode); + +/** + * @brief Performs echo cancellation a frame, based on the audio sent to the speaker and frame from mic. + * + * @param inst The instance of AEC. + * + * @param indata An array of 16-bit signed audio samples from mic. + * + * @param refdata An array of 16-bit signed audio samples sent to the speaker. + * + * @param outdata Returns near-end signal with echo removed. + * + * @return None + * + */ +void aec_process(const aec_handle_t inst, int16_t *indata, int16_t *refdata, int16_t *outdata); + +/** + * @brief Free the AEC instance + * + * @param inst The instance of AEC. + * + * @return None + * + */ +void aec_destroy(aec_handle_t inst); + +#ifdef __cplusplus +} +#endif + +#endif //_ESP_AEC_H_ diff --git a/include/esp_afe_sr_iface.h b/include/esp32s3/esp_afe_sr_iface.h similarity index 100% rename from include/esp_afe_sr_iface.h rename to include/esp32s3/esp_afe_sr_iface.h diff --git a/include/esp32s3/esp_afe_sr_models.h b/include/esp32s3/esp_afe_sr_models.h new file mode 100644 index 0000000..5424134 --- /dev/null +++ b/include/esp32s3/esp_afe_sr_models.h @@ -0,0 +1,6 @@ +#pragma once +#include "esp_afe_sr_iface.h" + +extern const esp_afe_sr_iface_t esp_afe_sr_2mic; +extern const esp_afe_sr_iface_t esp_afe_sr_1mic; + diff --git a/include/esp32s3/esp_agc.h b/include/esp32s3/esp_agc.h new file mode 100644 index 0000000..20b0e3f --- /dev/null +++ b/include/esp32s3/esp_agc.h @@ -0,0 +1,39 @@ +// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License +#ifndef _ESP_AGC_H_ +#define _ESP_AGC_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +////all positive value is valid, negective is error +typedef enum { + ESP_AGC_SUCCESS = 0, ////success + ESP_AGC_FAIL = -1, ////agc fail + ESP_AGC_SAMPLE_RATE_ERROR = -2, ///sample rate can be only 8khz, 16khz, 32khz + ESP_AGC_FRAME_SIZE_ERROR = -3, ////the input frame size should be only 10ms, so should together with sample-rate to get the frame size +} ESP_AGE_ERR; + + +void *esp_agc_open(int agc_mode, int sample_rate); +void set_agc_config(void *agc_handle, int gain_dB, int limiter_enable, int target_level_dbfs); +int esp_agc_process(void *agc_handle, short *in_pcm, short *out_pcm, int frame_size, int sample_rate); +void esp_agc_close(void *agc_handle); + +#ifdef __cplusplus +} +#endif + +#endif // _ESP_AGC_H_ diff --git a/include/esp32s3/esp_map.h b/include/esp32s3/esp_map.h new file mode 100644 index 0000000..794afdc --- /dev/null +++ b/include/esp32s3/esp_map.h @@ -0,0 +1,90 @@ +// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License +#ifndef _ESP_MAP_H_ +#define _ESP_MAP_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#define MAP_SAMPLE_RATE 16000 // Supports 16kHz only +#define MAP_FRAME_SIZE 16 // Supports 16ms only +#define MAP_MIC_DISTANCE 50 // According to physical design of mic-array +#define MAP_AEC_ON true +#define MAP_AEC_OFF false +#define MAP_AEC_FILTER_LENGTH 1200 // Number of samples of echo to cancel + +/** + * @brief Sets mic-array type, currently 2-mic line array and 3-mic circular array + * are supported. + */ +typedef enum { + TWO_MIC_LINE = 0, + THREE_MIC_CIRCLE = 1 +} map_mic_array_type_t; + +typedef void* mic_array_processor_t; + +/** + * @brief Creates an instance to the MAP structure. + * + * @param sample_rate The sampling frequency (Hz) must be 16000. + * + * @param frame_size The length of the audio processing must be 16ms. + * + * @param array_type '0' for 2-mic line array and '1' for 3-mic circular array. + * + * @param mic_distance The distance between neiboring microphones in mm. + * + * @param aec_on Decides whether to turn on AEC. + * + * @param filter_length Number of samples of echo to cancel, effective when AEC is on. + * + * @return + * - NULL: Create failed + * - Others: An instance of MAP + */ +mic_array_processor_t map_create(int fs, int frame_size, int array_type, float mic_distance, bool aec_on, int filter_length); + +/** + * @brief Performs mic array processing for one frame. + * + * @param inst The instance of MAP. + * + * @param in An array of 16-bit signed audio samples from mic. + * + * @param far_end An array of 16-bit signed audio samples sent to the speaker, can be none when AEC is turned off. + * + * @param dsp_out Returns enhanced signal. + * + * @return None + * + */ +void map_process(mic_array_processor_t st, int16_t *in, int16_t *far_end, int16_t *dsp_out); + +/** + * @brief Free the MAP instance + * + * @param inst The instance of MAP. + * + * @return None + * + */ +void map_destory(mic_array_processor_t st); + +#ifdef __cplusplus +} +#endif + +#endif \ No newline at end of file diff --git a/include/esp32s3/esp_mase.h b/include/esp32s3/esp_mase.h new file mode 100644 index 0000000..3cf403f --- /dev/null +++ b/include/esp32s3/esp_mase.h @@ -0,0 +1,94 @@ +// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License + +#ifndef _ESP_MASE_H_ +#define _ESP_MASE_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#define MASE_SAMPLE_RATE 16000 // Supports 16kHz only +#define MASE_FRAME_SIZE 16 // Supports 16ms only +#define MASE_MIC_DISTANCE 65 // According to physical design of mic-array + +/** + * @brief Sets mic-array type, currently 2-mic line array and 3-mic circular array + * are supported. + */ +typedef enum { + TWO_MIC_LINE = 0, + THREE_MIC_CIRCLE = 1 +} mase_mic_array_type_t; + +/** + * @brief Sets operating mode, supporting normal mode and wake-up enhancement mode + */ +typedef enum { + NORMAL_ENHANCEMENT_MODE = 0, + WAKE_UP_ENHANCEMENT_MODE = 1 +} mase_op_mode_t; + +typedef void* mase_handle_t; + +/** + * @brief Creates an instance to the MASE structure. + * + * @param sample_rate The sampling frequency (Hz) must be 16000. + * + * @param frame_size The length of the audio processing must be 16ms. + * + * @param array_type '0' for 2-mic line array and '1' for 3-mic circular array. + * + * @param mic_distance The distance between neiboring microphones in mm. + * + * @param operating_mode '0' for normal mode and '1' for wake-up enhanced mode. + * + * @param filter_strength Strengh of the mic-array speech enhancement, must be 0, 1, 2 or 3. + * + * @return + * - NULL: Create failed + * - Others: An instance of MASE + */ +mase_handle_t mase_create(int fs, int frame_size, int array_type, float mic_distance, int operating_mode, int filter_strength); + +/** + * @brief Performs mic array processing for one frame. + * + * @param inst The instance of MASE. + * + * @param in An array of 16-bit signed audio samples from mic. + * + * @param dsp_out Returns enhanced signal. + * + * @return None + * + */ +void mase_process(mase_handle_t st, int16_t *in, int16_t *dsp_out); + +/** + * @brief Free the MASE instance + * + * @param inst The instance of MASE. + * + * @return None + * + */ +void mase_destory(mase_handle_t st); + +#ifdef __cplusplus +} +#endif + +#endif \ No newline at end of file diff --git a/include/esp_mn_iface.h b/include/esp32s3/esp_mn_iface.h similarity index 100% rename from include/esp_mn_iface.h rename to include/esp32s3/esp_mn_iface.h diff --git a/include/esp32s3/esp_mn_models.h b/include/esp32s3/esp_mn_models.h new file mode 100644 index 0000000..5b18654 --- /dev/null +++ b/include/esp32s3/esp_mn_models.h @@ -0,0 +1,77 @@ +#pragma once +#include "esp_mn_iface.h" + +//Contains declarations of all available speech recognion models. Pair this up with the right coefficients and you have a model that can recognize +//a specific phrase or word. +extern const esp_mn_iface_t esp_sr_multinet1_single_quantized_en; +extern const esp_mn_iface_t esp_sr_multinet3_single_quantized_en; +extern const esp_mn_iface_t esp_sr_multinet2_single_quantized_cn; +extern const esp_mn_iface_t esp_sr_multinet3_single_quantized_cn; +extern const esp_mn_iface_t esp_sr_multinet4_single_quantized_cn; +extern const esp_mn_iface_t esp_sr_multinet3_continuous_quantized_cn; +extern const esp_mn_iface_t esp_sr_multinet5_quantized; +extern const esp_mn_iface_t esp_sr_multinet5_quantized8; + +/* + Configure wake word to use based on what's selected in menuconfig. +*/ +#if defined CONFIG_USE_MULTINET +#ifdef CONFIG_SR_MN_EN_MULTINET1_SINGLE_RECOGNITION +#include "multinet1_en.h" +#define MULTINET_MODEL esp_sr_multinet1_single_quantized_en +#define MULTINET_COEFF get_coeff_multinet1_en +#elif CONFIG_SR_MN_EN_MULTINET3_SINGLE_RECOGNITION +#include "multinet3_en.h" +#define MULTINET_MODEL esp_sr_multinet3_single_quantized_en +#define MULTINET_COEFF get_coeff_multinet3_en +#elif CONFIG_SR_MN_CN_MULTINET2_SINGLE_RECOGNITION +#include "multinet2_ch.h" +#define MULTINET_MODEL esp_sr_multinet2_single_quantized_cn +#define MULTINET_COEFF get_coeff_multinet2_ch +#elif CONFIG_SR_MN_CN_MULTINET2_CONTINUOUS_RECOGNITION + +#elif CONFIG_SR_MN_CN_MULTINET3_SINGLE_RECOGNITION +#define MULTINET_MODEL esp_sr_multinet3_single_quantized_cn +#define MULTINET_COEFF "mn3cn" +#elif CONFIG_SR_MN_CN_MULTINET4_SINGLE_RECOGNITION +#define MULTINET_MODEL esp_sr_multinet4_single_quantized_cn +#define MULTINET_COEFF "mn4cn" +#elif CONFIG_SR_MN_CN_MULTINET3_CONTINUOUS_RECOGNITION +#define MULTINET_MODEL esp_sr_multinet3_continuous_quantized_cn +#define MULTINET_COEFF "mn3cn" +#elif CONFIG_SR_MN_EN_MULTINET5_SINGLE_RECOGNITION +#define MULTINET_MODEL esp_sr_multinet5_quantized +#define MULTINET_COEFF "mn5en" +#elif CONFIG_SR_MN_EN_MULTINET5_SINGLE_RECOGNITION_QUANT8 +#define MULTINET_MODEL esp_sr_multinet5_quantized8 +#define MULTINET_COEFF "mn5q8en" +#else +#error No valid wake word selected. +#endif +#else +#define MULTINET_MODEL "NULL" +#define MULTINET_COEFF "NULL" +#endif +/* example + +static const esp_mn_iface_t *multinet = &MULTINET_MODEL; + +//Initialize MultiNet model data +model_iface_data_t *model_data = multinet->create(&MULTINET_COEFF); +add_speech_commands(multinet, model_data); + +//Set parameters of buffer +int audio_chunksize=model->get_samp_chunksize(model_data); +int frequency = model->get_samp_rate(model_data); +int16_t *buffer=malloc(audio_chunksize*sizeof(int16_t)); + +//Detect +int r=model->detect(model_data, buffer); +if (r>0) { + printf("Detection triggered output %d.\n", r); +} + +//Destroy model +model->destroy(model_data) + +*/ diff --git a/include/esp32s3/esp_ns.h b/include/esp32s3/esp_ns.h new file mode 100644 index 0000000..1932600 --- /dev/null +++ b/include/esp32s3/esp_ns.h @@ -0,0 +1,85 @@ +// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License +#ifndef _ESP_NS_H_ +#define _ESP_NS_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define NS_USE_SPIARM 0 +#define NS_FRAME_LENGTH_MS 10 //Supports 10ms, 20ms, 30ms + +/** +* The Sampling frequency (Hz) must be 16000Hz +*/ + +typedef void* ns_handle_t; + +/** + * @brief Creates an instance to the NS structure. + * + * @param frame_length The length of the audio processing can be 10ms, 20ms, 30ms. + * + * @return + * - NULL: Create failed + * - Others: The instance of NS + */ +ns_handle_t ns_create(int frame_length); + +/** + * @brief Creates an instance of the more powerful noise suppression algorithm. + * + * @warning frame_length only supports be 10 ms. + * + * @param frame_length The length of the audio processing can only be 10ms. + * @param mode 0: Mild, 1: Medium, 2: Aggressive + * + * @return + * - NULL: Create failed + * - Others: The instance of NS + */ +ns_handle_t ns_pro_create(int frame_length, int mode); + +/** + * @brief Feed samples of an audio stream to the NS and get the audio stream after Noise suppression. + * + * @param inst The instance of NS. + * + * @param indata An array of 16-bit signed audio samples. + * + * @param outdata An array of 16-bit signed audio samples after noise suppression. + * + * @return None + * + */ +void ns_process(ns_handle_t inst, int16_t *indata, int16_t *outdata); + +/** + * @brief Free the NS instance + * + * @param inst The instance of NS. + * + * @return None + * + */ +void ns_destroy(ns_handle_t inst); + +#ifdef __cplusplus +} +#endif + +#endif //_ESP_NS_H_ diff --git a/include/esp32s3/esp_vad.h b/include/esp32s3/esp_vad.h new file mode 100644 index 0000000..e1a76cf --- /dev/null +++ b/include/esp32s3/esp_vad.h @@ -0,0 +1,104 @@ +// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License +#ifndef _ESP_VAD_H_ +#define _ESP_VAD_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define SAMPLE_RATE_HZ 16000 //Supports 32000, 16000, 8000 +#define VAD_FRAME_LENGTH_MS 30 //Supports 10ms, 20ms, 30ms + +/** + * @brief Sets the VAD operating mode. A more aggressive (higher mode) VAD is more + * restrictive in reporting speech. + */ +typedef enum { + VAD_MODE_0 = 0, + VAD_MODE_1, + VAD_MODE_2, + VAD_MODE_3, + VAD_MODE_4 +} vad_mode_t; + +typedef enum { + VAD_SILENCE = 0, + VAD_SPEECH +} vad_state_t; + +typedef void* vad_handle_t; + +/** + * @brief Creates an instance to the VAD structure. + * + * @param vad_mode Sets the VAD operating mode. + * + * @param sample_rate_hz The Sampling frequency (Hz) can be 32000, 16000, 8000, default: 16000. + * + * @param one_frame_ms The length of the audio processing can be 10ms, 20ms, 30ms, default: 30. + * + * @return + * - NULL: Create failed + * - Others: The instance of VAD + */ +vad_handle_t vad_create(vad_mode_t vad_mode, int sample_rate_hz, int one_frame_ms); + +/** + * @brief Feed samples of an audio stream to the VAD and check if there is someone speaking. + * + * @param inst The instance of VAD. + * + * @param data An array of 16-bit signed audio samples. + * + * @return + * - VAD_SILENCE if no voice + * - VAD_SPEECH if voice is detected + * + */ +vad_state_t vad_process(vad_handle_t inst, int16_t *data); + +/** + * @brief Free the VAD instance + * + * @param inst The instance of VAD. + * + * @return None + * + */ +void vad_destroy(vad_handle_t inst); + +/* +* Programming Guide: +* +* @code{c} +* vad_handle_t vad_inst = vad_create(VAD_MODE_3, SAMPLE_RATE_HZ, VAD_FRAME_LENGTH_MS); // Creates an instance to the VAD structure. +* +* while (1) { +* //Use buffer to receive the audio data from MIC. +* vad_state_t vad_state = vad_process(vad_inst, buffer); // Feed samples to the VAD process and get the result. +* } +* +* vad_destroy(vad_inst); // Free the VAD instance at the end of whole VAD process +* +* @endcode +*/ + +#ifdef __cplusplus +} +#endif + +#endif //_ESP_VAD_H_ diff --git a/include/esp_wn_iface.h b/include/esp32s3/esp_wn_iface.h similarity index 100% rename from include/esp_wn_iface.h rename to include/esp32s3/esp_wn_iface.h diff --git a/include/esp32s3/esp_wn_models.h b/include/esp32s3/esp_wn_models.h new file mode 100644 index 0000000..225456f --- /dev/null +++ b/include/esp32s3/esp_wn_models.h @@ -0,0 +1,127 @@ +#pragma once +#include "esp_wn_iface.h" + +//Contains declarations of all available speech recognion models. Pair this up with the right coefficients and you have a model that can recognize +//a specific phrase or word. + +extern const esp_wn_iface_t esp_sr_wakenet5_quantized; +extern const esp_wn_iface_t esp_sr_wakenet7_quantized; +extern const esp_wn_iface_t esp_sr_wakenet7_quantized8; +extern const esp_wn_iface_t esp_sr_wakenet8_quantized; +extern const esp_wn_iface_t esp_sr_wakenet8_quantized8; +/* + Configure network to use based on what's selected in menuconfig. +*/ +#if defined CONFIG_USE_WAKENET +#if CONFIG_SR_WN_MODEL_WN5_QUANT +#define WAKENET_MODEL esp_sr_wakenet5_quantized +#elif CONFIG_SR_WN_MODEL_WN7_QUANT +#define WAKENET_MODEL esp_sr_wakenet7_quantized +#elif CONFIG_SR_WN_MODEL_WN7_QUANT8 +#define WAKENET_MODEL esp_sr_wakenet7_quantized8 +#elif CONFIG_SR_WN_MODEL_WN8_QUANT +#define WAKENET_MODEL esp_sr_wakenet8_quantized +#elif CONFIG_SR_WN_MODEL_WN8_QUANT8 +#define WAKENET_MODEL esp_sr_wakenet8_quantized8 +#else +#error No valid neural network model selected. +#endif + +/* + Configure wake word to use based on what's selected in menuconfig. +*/ +#if CONFIG_SR_WN_WN5_HILEXIN & CONFIG_SR_WN_MODEL_WN5_QUANT +#include "hilexin_wn5.h" +#define WAKENET_COEFF get_coeff_hilexin_wn5 + +#elif CONFIG_SR_WN_WN5X2_HILEXIN & CONFIG_SR_WN_MODEL_WN5_QUANT +#include "hilexin_wn5X2.h" +#define WAKENET_COEFF get_coeff_hilexin_wn5X2 + +#elif CONFIG_SR_WN_WN5X3_HILEXIN & CONFIG_SR_WN_MODEL_WN5_QUANT +#include "hilexin_wn5X3.h" +#define WAKENET_COEFF get_coeff_hilexin_wn5X3 + +#elif CONFIG_SR_WN_WN5_NIHAOXIAOZHI & CONFIG_SR_WN_MODEL_WN5_QUANT +#include "nihaoxiaozhi_wn5.h" +#define WAKENET_COEFF get_coeff_nihaoxiaozhi_wn5 + +#elif CONFIG_SR_WN_WN5X2_NIHAOXIAOZHI & CONFIG_SR_WN_MODEL_WN5_QUANT +#include "nihaoxiaozhi_wn5X2.h" +#define WAKENET_COEFF get_coeff_nihaoxiaozhi_wn5X2 + +#elif CONFIG_SR_WN_WN5X3_NIHAOXIAOZHI & CONFIG_SR_WN_MODEL_WN5_QUANT +#include "nihaoxiaozhi_wn5X3.h" +#define WAKENET_COEFF get_coeff_nihaoxiaozhi_wn5X3 + +#elif CONFIG_SR_WN_WN5X3_NIHAOXIAOXIN & CONFIG_SR_WN_MODEL_WN5_QUANT +#include "nihaoxiaoxin_wn5X3.h" +#define WAKENET_COEFF get_coeff_nihaoxiaoxin_wn5X3 + +#elif CONFIG_SR_WN_WN5X3_HIJESON & CONFIG_SR_WN_MODEL_WN5_QUANT +#include "hijeson_wn5X3.h" +#define WAKENET_COEFF get_coeff_hijeson_wn5X3 + +#elif CONFIG_SR_WN_WN5_CUSTOMIZED_WORD +#include "customized_word_wn5.h" +#define WAKENET_COEFF get_coeff_customized_word_wn5 + +#elif CONFIG_SR_WN_WN7_CUSTOMIZED_WORD +#define WAKENET_COEFF "custom7" + +#elif CONFIG_SR_WN_WN7_XIAOAITONGXUE & CONFIG_SR_WN_MODEL_WN7_QUANT +#define WAKENET_COEFF "xiaoaitongxue7" + +#elif CONFIG_SR_WN_WN7_XIAOAITONGXUE & CONFIG_SR_WN_MODEL_WN7_QUANT8 +#define WAKENET_COEFF "xiaoaitongxue7q8" + +#elif CONFIG_SR_WN_WN7_HILEXIN & CONFIG_SR_WN_MODEL_WN7_QUANT +#define WAKENET_COEFF "hilexin7" + +#elif CONFIG_SR_WN_WN7_HILEXIN & CONFIG_SR_WN_MODEL_WN7_QUANT8 +#define WAKENET_COEFF "hilexin7q8" + +#elif CONFIG_SR_WN_WN7_ALEXA & CONFIG_SR_WN_MODEL_WN7_QUANT +#define WAKENET_COEFF "alexa7" + +#elif CONFIG_SR_WN_WN8_ALEXA & CONFIG_SR_WN_MODEL_WN8_QUANT +#define WAKENET_COEFF "alexa8" + +#elif CONFIG_SR_WN_WN7_ALEXA & CONFIG_SR_WN_MODEL_WN7_QUANT8 +#define WAKENET_COEFF "alexa7q8" + +#elif CONFIG_SR_WN_WN8_HIESP & CONFIG_SR_WN_MODEL_WN8_QUANT +#define WAKENET_COEFF "hiesp8" + +#elif CONFIG_SR_WN_WN8_HIESP & CONFIG_SR_WN_MODEL_WN8_QUANT8 +#define WAKENET_COEFF "hiesp8q8" + +#else +#error No valid wake word selected. +#endif +#else +#define WAKENET_MODEL "NULL" +#define WAKENET_COEFF "NULL" +#endif +/* example + +static const sr_model_iface_t *model = &WAKENET_MODEL; + +//Initialize wakeNet model data +static model_iface_data_t *model_data=model->create(DET_MODE_90); + +//Set parameters of buffer +int audio_chunksize=model->get_samp_chunksize(model_data); +int frequency = model->get_samp_rate(model_data); +int16_t *buffer=malloc(audio_chunksize*sizeof(int16_t)); + +//Detect +int r=model->detect(model_data, buffer); +if (r>0) { + printf("Detection triggered output %d.\n", r); +} + +//Destroy model +model->destroy(model_data) + +*/ diff --git a/include/esp32s3/hijeson_wn5X3.h b/include/esp32s3/hijeson_wn5X3.h new file mode 100644 index 0000000..c2e3438 --- /dev/null +++ b/include/esp32s3/hijeson_wn5X3.h @@ -0,0 +1,8 @@ +//Generated by mkmodel +#pragma once +#include +#include "dl_lib_coefgetter_if.h" +#include "dl_lib_matrix.h" +#include "dl_lib_matrixq.h" + +extern const model_coeff_getter_t get_coeff_hijeson_wn5X3; diff --git a/include/esp32s3/hilexin_wn5.h b/include/esp32s3/hilexin_wn5.h new file mode 100644 index 0000000..d922a6a --- /dev/null +++ b/include/esp32s3/hilexin_wn5.h @@ -0,0 +1,8 @@ +//Generated by mkmodel +#pragma once +#include +#include "dl_lib_coefgetter_if.h" +#include "dl_lib_matrix.h" +#include "dl_lib_matrixq.h" + +extern const model_coeff_getter_t get_coeff_hilexin_wn5; diff --git a/include/esp32s3/hilexin_wn5X2.h b/include/esp32s3/hilexin_wn5X2.h new file mode 100644 index 0000000..5ca6bbc --- /dev/null +++ b/include/esp32s3/hilexin_wn5X2.h @@ -0,0 +1,8 @@ +//Generated by mkmodel +#pragma once +#include +#include "dl_lib_coefgetter_if.h" +#include "dl_lib_matrix.h" +#include "dl_lib_matrixq.h" + +extern const model_coeff_getter_t get_coeff_hilexin_wn5X2; diff --git a/include/esp32s3/hilexin_wn5X3.h b/include/esp32s3/hilexin_wn5X3.h new file mode 100644 index 0000000..c78a64d --- /dev/null +++ b/include/esp32s3/hilexin_wn5X3.h @@ -0,0 +1,8 @@ +//Generated by mkmodel +#pragma once +#include +#include "dl_lib_coefgetter_if.h" +#include "dl_lib_matrix.h" +#include "dl_lib_matrixq.h" + +extern const model_coeff_getter_t get_coeff_hilexin_wn5X3; diff --git a/include/esp32s3/mn_process_commands.h b/include/esp32s3/mn_process_commands.h new file mode 100644 index 0000000..692137a --- /dev/null +++ b/include/esp32s3/mn_process_commands.h @@ -0,0 +1,408 @@ +#pragma once +#include "esp_mn_iface.h" +#define SPEECH_COMMANDS_NUM 99 +#if CONFIG_SR_MN_CHINESE +#define MN_SPEECH_COMMAND_ID0 CONFIG_CN_SPEECH_COMMAND_ID0 +#define MN_SPEECH_COMMAND_ID1 CONFIG_CN_SPEECH_COMMAND_ID1 +#define MN_SPEECH_COMMAND_ID2 CONFIG_CN_SPEECH_COMMAND_ID2 +#define MN_SPEECH_COMMAND_ID3 CONFIG_CN_SPEECH_COMMAND_ID3 +#define MN_SPEECH_COMMAND_ID4 CONFIG_CN_SPEECH_COMMAND_ID4 +#define MN_SPEECH_COMMAND_ID5 CONFIG_CN_SPEECH_COMMAND_ID5 +#define MN_SPEECH_COMMAND_ID6 CONFIG_CN_SPEECH_COMMAND_ID6 +#define MN_SPEECH_COMMAND_ID7 CONFIG_CN_SPEECH_COMMAND_ID7 +#define MN_SPEECH_COMMAND_ID8 CONFIG_CN_SPEECH_COMMAND_ID8 +#define MN_SPEECH_COMMAND_ID9 CONFIG_CN_SPEECH_COMMAND_ID9 +#define MN_SPEECH_COMMAND_ID10 CONFIG_CN_SPEECH_COMMAND_ID10 +#define MN_SPEECH_COMMAND_ID11 CONFIG_CN_SPEECH_COMMAND_ID11 +#define MN_SPEECH_COMMAND_ID12 CONFIG_CN_SPEECH_COMMAND_ID12 +#define MN_SPEECH_COMMAND_ID13 CONFIG_CN_SPEECH_COMMAND_ID13 +#define MN_SPEECH_COMMAND_ID14 CONFIG_CN_SPEECH_COMMAND_ID14 +#define MN_SPEECH_COMMAND_ID15 CONFIG_CN_SPEECH_COMMAND_ID15 +#define MN_SPEECH_COMMAND_ID16 CONFIG_CN_SPEECH_COMMAND_ID16 +#define MN_SPEECH_COMMAND_ID17 CONFIG_CN_SPEECH_COMMAND_ID17 +#define MN_SPEECH_COMMAND_ID18 CONFIG_CN_SPEECH_COMMAND_ID18 +#define MN_SPEECH_COMMAND_ID19 CONFIG_CN_SPEECH_COMMAND_ID19 +#define MN_SPEECH_COMMAND_ID20 CONFIG_CN_SPEECH_COMMAND_ID20 +#define MN_SPEECH_COMMAND_ID21 CONFIG_CN_SPEECH_COMMAND_ID21 +#define MN_SPEECH_COMMAND_ID22 CONFIG_CN_SPEECH_COMMAND_ID22 +#define MN_SPEECH_COMMAND_ID23 CONFIG_CN_SPEECH_COMMAND_ID23 +#define MN_SPEECH_COMMAND_ID24 CONFIG_CN_SPEECH_COMMAND_ID24 +#define MN_SPEECH_COMMAND_ID25 CONFIG_CN_SPEECH_COMMAND_ID25 +#define MN_SPEECH_COMMAND_ID26 CONFIG_CN_SPEECH_COMMAND_ID26 +#define MN_SPEECH_COMMAND_ID27 CONFIG_CN_SPEECH_COMMAND_ID27 +#define MN_SPEECH_COMMAND_ID28 CONFIG_CN_SPEECH_COMMAND_ID28 +#define MN_SPEECH_COMMAND_ID29 CONFIG_CN_SPEECH_COMMAND_ID29 +#define MN_SPEECH_COMMAND_ID30 CONFIG_CN_SPEECH_COMMAND_ID30 +#define MN_SPEECH_COMMAND_ID31 CONFIG_CN_SPEECH_COMMAND_ID31 +#define MN_SPEECH_COMMAND_ID32 CONFIG_CN_SPEECH_COMMAND_ID32 +#define MN_SPEECH_COMMAND_ID33 CONFIG_CN_SPEECH_COMMAND_ID33 +#define MN_SPEECH_COMMAND_ID34 CONFIG_CN_SPEECH_COMMAND_ID34 +#define MN_SPEECH_COMMAND_ID35 CONFIG_CN_SPEECH_COMMAND_ID35 +#define MN_SPEECH_COMMAND_ID36 CONFIG_CN_SPEECH_COMMAND_ID36 +#define MN_SPEECH_COMMAND_ID37 CONFIG_CN_SPEECH_COMMAND_ID37 +#define MN_SPEECH_COMMAND_ID38 CONFIG_CN_SPEECH_COMMAND_ID38 +#define MN_SPEECH_COMMAND_ID39 CONFIG_CN_SPEECH_COMMAND_ID39 +#define MN_SPEECH_COMMAND_ID40 CONFIG_CN_SPEECH_COMMAND_ID40 +#define MN_SPEECH_COMMAND_ID41 CONFIG_CN_SPEECH_COMMAND_ID41 +#define MN_SPEECH_COMMAND_ID42 CONFIG_CN_SPEECH_COMMAND_ID42 +#define MN_SPEECH_COMMAND_ID43 CONFIG_CN_SPEECH_COMMAND_ID43 +#define MN_SPEECH_COMMAND_ID44 CONFIG_CN_SPEECH_COMMAND_ID44 +#define MN_SPEECH_COMMAND_ID45 CONFIG_CN_SPEECH_COMMAND_ID45 +#define MN_SPEECH_COMMAND_ID46 CONFIG_CN_SPEECH_COMMAND_ID46 +#define MN_SPEECH_COMMAND_ID47 CONFIG_CN_SPEECH_COMMAND_ID47 +#define MN_SPEECH_COMMAND_ID48 CONFIG_CN_SPEECH_COMMAND_ID48 +#define MN_SPEECH_COMMAND_ID49 CONFIG_CN_SPEECH_COMMAND_ID49 +#define MN_SPEECH_COMMAND_ID50 CONFIG_CN_SPEECH_COMMAND_ID50 +#define MN_SPEECH_COMMAND_ID51 CONFIG_CN_SPEECH_COMMAND_ID51 +#define MN_SPEECH_COMMAND_ID52 CONFIG_CN_SPEECH_COMMAND_ID52 +#define MN_SPEECH_COMMAND_ID53 CONFIG_CN_SPEECH_COMMAND_ID53 +#define MN_SPEECH_COMMAND_ID54 CONFIG_CN_SPEECH_COMMAND_ID54 +#define MN_SPEECH_COMMAND_ID55 CONFIG_CN_SPEECH_COMMAND_ID55 +#define MN_SPEECH_COMMAND_ID56 CONFIG_CN_SPEECH_COMMAND_ID56 +#define MN_SPEECH_COMMAND_ID57 CONFIG_CN_SPEECH_COMMAND_ID57 +#define MN_SPEECH_COMMAND_ID58 CONFIG_CN_SPEECH_COMMAND_ID58 +#define MN_SPEECH_COMMAND_ID59 CONFIG_CN_SPEECH_COMMAND_ID59 +#define MN_SPEECH_COMMAND_ID60 CONFIG_CN_SPEECH_COMMAND_ID60 +#define MN_SPEECH_COMMAND_ID61 CONFIG_CN_SPEECH_COMMAND_ID61 +#define MN_SPEECH_COMMAND_ID62 CONFIG_CN_SPEECH_COMMAND_ID62 +#define MN_SPEECH_COMMAND_ID63 CONFIG_CN_SPEECH_COMMAND_ID63 +#define MN_SPEECH_COMMAND_ID64 CONFIG_CN_SPEECH_COMMAND_ID64 +#define MN_SPEECH_COMMAND_ID65 CONFIG_CN_SPEECH_COMMAND_ID65 +#define MN_SPEECH_COMMAND_ID66 CONFIG_CN_SPEECH_COMMAND_ID66 +#define MN_SPEECH_COMMAND_ID67 CONFIG_CN_SPEECH_COMMAND_ID67 +#define MN_SPEECH_COMMAND_ID68 CONFIG_CN_SPEECH_COMMAND_ID68 +#define MN_SPEECH_COMMAND_ID69 CONFIG_CN_SPEECH_COMMAND_ID69 +#define MN_SPEECH_COMMAND_ID70 CONFIG_CN_SPEECH_COMMAND_ID70 +#define MN_SPEECH_COMMAND_ID71 CONFIG_CN_SPEECH_COMMAND_ID71 +#define MN_SPEECH_COMMAND_ID72 CONFIG_CN_SPEECH_COMMAND_ID72 +#define MN_SPEECH_COMMAND_ID73 CONFIG_CN_SPEECH_COMMAND_ID73 +#define MN_SPEECH_COMMAND_ID74 CONFIG_CN_SPEECH_COMMAND_ID74 +#define MN_SPEECH_COMMAND_ID75 CONFIG_CN_SPEECH_COMMAND_ID75 +#define MN_SPEECH_COMMAND_ID76 CONFIG_CN_SPEECH_COMMAND_ID76 +#define MN_SPEECH_COMMAND_ID77 CONFIG_CN_SPEECH_COMMAND_ID77 +#define MN_SPEECH_COMMAND_ID78 CONFIG_CN_SPEECH_COMMAND_ID78 +#define MN_SPEECH_COMMAND_ID79 CONFIG_CN_SPEECH_COMMAND_ID79 +#define MN_SPEECH_COMMAND_ID80 CONFIG_CN_SPEECH_COMMAND_ID80 +#define MN_SPEECH_COMMAND_ID81 CONFIG_CN_SPEECH_COMMAND_ID81 +#define MN_SPEECH_COMMAND_ID82 CONFIG_CN_SPEECH_COMMAND_ID82 +#define MN_SPEECH_COMMAND_ID83 CONFIG_CN_SPEECH_COMMAND_ID83 +#define MN_SPEECH_COMMAND_ID84 CONFIG_CN_SPEECH_COMMAND_ID84 +#define MN_SPEECH_COMMAND_ID85 CONFIG_CN_SPEECH_COMMAND_ID85 +#define MN_SPEECH_COMMAND_ID86 CONFIG_CN_SPEECH_COMMAND_ID86 +#define MN_SPEECH_COMMAND_ID87 CONFIG_CN_SPEECH_COMMAND_ID87 +#define MN_SPEECH_COMMAND_ID88 CONFIG_CN_SPEECH_COMMAND_ID88 +#define MN_SPEECH_COMMAND_ID89 CONFIG_CN_SPEECH_COMMAND_ID89 +#define MN_SPEECH_COMMAND_ID90 CONFIG_CN_SPEECH_COMMAND_ID90 +#define MN_SPEECH_COMMAND_ID91 CONFIG_CN_SPEECH_COMMAND_ID91 +#define MN_SPEECH_COMMAND_ID92 CONFIG_CN_SPEECH_COMMAND_ID92 +#define MN_SPEECH_COMMAND_ID93 CONFIG_CN_SPEECH_COMMAND_ID93 +#define MN_SPEECH_COMMAND_ID94 CONFIG_CN_SPEECH_COMMAND_ID94 +#define MN_SPEECH_COMMAND_ID95 CONFIG_CN_SPEECH_COMMAND_ID95 +#define MN_SPEECH_COMMAND_ID96 CONFIG_CN_SPEECH_COMMAND_ID96 +#define MN_SPEECH_COMMAND_ID97 CONFIG_CN_SPEECH_COMMAND_ID97 +#define MN_SPEECH_COMMAND_ID98 CONFIG_CN_SPEECH_COMMAND_ID98 +#define MN_SPEECH_COMMAND_ID99 CONFIG_CN_SPEECH_COMMAND_ID99 +#define MN_SPEECH_COMMAND_ID100 CONFIG_CN_SPEECH_COMMAND_ID100 +#define MN_SPEECH_COMMAND_ID101 CONFIG_CN_SPEECH_COMMAND_ID101 +#define MN_SPEECH_COMMAND_ID102 CONFIG_CN_SPEECH_COMMAND_ID102 +#define MN_SPEECH_COMMAND_ID103 CONFIG_CN_SPEECH_COMMAND_ID103 +#define MN_SPEECH_COMMAND_ID104 CONFIG_CN_SPEECH_COMMAND_ID104 +#define MN_SPEECH_COMMAND_ID105 CONFIG_CN_SPEECH_COMMAND_ID105 +#define MN_SPEECH_COMMAND_ID106 CONFIG_CN_SPEECH_COMMAND_ID106 +#define MN_SPEECH_COMMAND_ID107 CONFIG_CN_SPEECH_COMMAND_ID107 +#define MN_SPEECH_COMMAND_ID108 CONFIG_CN_SPEECH_COMMAND_ID108 +#define MN_SPEECH_COMMAND_ID109 CONFIG_CN_SPEECH_COMMAND_ID109 +#define MN_SPEECH_COMMAND_ID110 CONFIG_CN_SPEECH_COMMAND_ID110 +#define MN_SPEECH_COMMAND_ID111 CONFIG_CN_SPEECH_COMMAND_ID111 +#define MN_SPEECH_COMMAND_ID112 CONFIG_CN_SPEECH_COMMAND_ID112 +#define MN_SPEECH_COMMAND_ID113 CONFIG_CN_SPEECH_COMMAND_ID113 +#define MN_SPEECH_COMMAND_ID114 CONFIG_CN_SPEECH_COMMAND_ID114 +#define MN_SPEECH_COMMAND_ID115 CONFIG_CN_SPEECH_COMMAND_ID115 +#define MN_SPEECH_COMMAND_ID116 CONFIG_CN_SPEECH_COMMAND_ID116 +#define MN_SPEECH_COMMAND_ID117 CONFIG_CN_SPEECH_COMMAND_ID117 +#define MN_SPEECH_COMMAND_ID118 CONFIG_CN_SPEECH_COMMAND_ID118 +#define MN_SPEECH_COMMAND_ID119 CONFIG_CN_SPEECH_COMMAND_ID119 +#define MN_SPEECH_COMMAND_ID120 CONFIG_CN_SPEECH_COMMAND_ID120 +#define MN_SPEECH_COMMAND_ID121 CONFIG_CN_SPEECH_COMMAND_ID121 +#define MN_SPEECH_COMMAND_ID122 CONFIG_CN_SPEECH_COMMAND_ID122 +#define MN_SPEECH_COMMAND_ID123 CONFIG_CN_SPEECH_COMMAND_ID123 +#define MN_SPEECH_COMMAND_ID124 CONFIG_CN_SPEECH_COMMAND_ID124 +#define MN_SPEECH_COMMAND_ID125 CONFIG_CN_SPEECH_COMMAND_ID125 +#define MN_SPEECH_COMMAND_ID126 CONFIG_CN_SPEECH_COMMAND_ID126 +#define MN_SPEECH_COMMAND_ID127 CONFIG_CN_SPEECH_COMMAND_ID127 +#define MN_SPEECH_COMMAND_ID128 CONFIG_CN_SPEECH_COMMAND_ID128 +#define MN_SPEECH_COMMAND_ID129 CONFIG_CN_SPEECH_COMMAND_ID129 +#define MN_SPEECH_COMMAND_ID130 CONFIG_CN_SPEECH_COMMAND_ID130 +#define MN_SPEECH_COMMAND_ID131 CONFIG_CN_SPEECH_COMMAND_ID131 +#define MN_SPEECH_COMMAND_ID132 CONFIG_CN_SPEECH_COMMAND_ID132 +#define MN_SPEECH_COMMAND_ID133 CONFIG_CN_SPEECH_COMMAND_ID133 +#define MN_SPEECH_COMMAND_ID134 CONFIG_CN_SPEECH_COMMAND_ID134 +#define MN_SPEECH_COMMAND_ID135 CONFIG_CN_SPEECH_COMMAND_ID135 +#define MN_SPEECH_COMMAND_ID136 CONFIG_CN_SPEECH_COMMAND_ID136 +#define MN_SPEECH_COMMAND_ID137 CONFIG_CN_SPEECH_COMMAND_ID137 +#define MN_SPEECH_COMMAND_ID138 CONFIG_CN_SPEECH_COMMAND_ID138 +#define MN_SPEECH_COMMAND_ID139 CONFIG_CN_SPEECH_COMMAND_ID139 +#define MN_SPEECH_COMMAND_ID140 CONFIG_CN_SPEECH_COMMAND_ID140 +#define MN_SPEECH_COMMAND_ID141 CONFIG_CN_SPEECH_COMMAND_ID141 +#define MN_SPEECH_COMMAND_ID142 CONFIG_CN_SPEECH_COMMAND_ID142 +#define MN_SPEECH_COMMAND_ID143 CONFIG_CN_SPEECH_COMMAND_ID143 +#define MN_SPEECH_COMMAND_ID144 CONFIG_CN_SPEECH_COMMAND_ID144 +#define MN_SPEECH_COMMAND_ID145 CONFIG_CN_SPEECH_COMMAND_ID145 +#define MN_SPEECH_COMMAND_ID146 CONFIG_CN_SPEECH_COMMAND_ID146 +#define MN_SPEECH_COMMAND_ID147 CONFIG_CN_SPEECH_COMMAND_ID147 +#define MN_SPEECH_COMMAND_ID148 CONFIG_CN_SPEECH_COMMAND_ID148 +#define MN_SPEECH_COMMAND_ID149 CONFIG_CN_SPEECH_COMMAND_ID149 +#define MN_SPEECH_COMMAND_ID150 CONFIG_CN_SPEECH_COMMAND_ID150 +#define MN_SPEECH_COMMAND_ID151 CONFIG_CN_SPEECH_COMMAND_ID151 +#define MN_SPEECH_COMMAND_ID152 CONFIG_CN_SPEECH_COMMAND_ID152 +#define MN_SPEECH_COMMAND_ID153 CONFIG_CN_SPEECH_COMMAND_ID153 +#define MN_SPEECH_COMMAND_ID154 CONFIG_CN_SPEECH_COMMAND_ID154 +#define MN_SPEECH_COMMAND_ID155 CONFIG_CN_SPEECH_COMMAND_ID155 +#define MN_SPEECH_COMMAND_ID156 CONFIG_CN_SPEECH_COMMAND_ID156 +#define MN_SPEECH_COMMAND_ID157 CONFIG_CN_SPEECH_COMMAND_ID157 +#define MN_SPEECH_COMMAND_ID158 CONFIG_CN_SPEECH_COMMAND_ID158 +#define MN_SPEECH_COMMAND_ID159 CONFIG_CN_SPEECH_COMMAND_ID159 +#define MN_SPEECH_COMMAND_ID160 CONFIG_CN_SPEECH_COMMAND_ID160 +#define MN_SPEECH_COMMAND_ID161 CONFIG_CN_SPEECH_COMMAND_ID161 +#define MN_SPEECH_COMMAND_ID162 CONFIG_CN_SPEECH_COMMAND_ID162 +#define MN_SPEECH_COMMAND_ID163 CONFIG_CN_SPEECH_COMMAND_ID163 +#define MN_SPEECH_COMMAND_ID164 CONFIG_CN_SPEECH_COMMAND_ID164 +#define MN_SPEECH_COMMAND_ID165 CONFIG_CN_SPEECH_COMMAND_ID165 +#define MN_SPEECH_COMMAND_ID166 CONFIG_CN_SPEECH_COMMAND_ID166 +#define MN_SPEECH_COMMAND_ID167 CONFIG_CN_SPEECH_COMMAND_ID167 +#define MN_SPEECH_COMMAND_ID168 CONFIG_CN_SPEECH_COMMAND_ID168 +#define MN_SPEECH_COMMAND_ID169 CONFIG_CN_SPEECH_COMMAND_ID169 +#define MN_SPEECH_COMMAND_ID170 CONFIG_CN_SPEECH_COMMAND_ID170 +#define MN_SPEECH_COMMAND_ID171 CONFIG_CN_SPEECH_COMMAND_ID171 +#define MN_SPEECH_COMMAND_ID172 CONFIG_CN_SPEECH_COMMAND_ID172 +#define MN_SPEECH_COMMAND_ID173 CONFIG_CN_SPEECH_COMMAND_ID173 +#define MN_SPEECH_COMMAND_ID174 CONFIG_CN_SPEECH_COMMAND_ID174 +#define MN_SPEECH_COMMAND_ID175 CONFIG_CN_SPEECH_COMMAND_ID175 +#define MN_SPEECH_COMMAND_ID176 CONFIG_CN_SPEECH_COMMAND_ID176 +#define MN_SPEECH_COMMAND_ID177 CONFIG_CN_SPEECH_COMMAND_ID177 +#define MN_SPEECH_COMMAND_ID178 CONFIG_CN_SPEECH_COMMAND_ID178 +#define MN_SPEECH_COMMAND_ID179 CONFIG_CN_SPEECH_COMMAND_ID179 +#define MN_SPEECH_COMMAND_ID180 CONFIG_CN_SPEECH_COMMAND_ID180 +#define MN_SPEECH_COMMAND_ID181 CONFIG_CN_SPEECH_COMMAND_ID181 +#define MN_SPEECH_COMMAND_ID182 CONFIG_CN_SPEECH_COMMAND_ID182 +#define MN_SPEECH_COMMAND_ID183 CONFIG_CN_SPEECH_COMMAND_ID183 +#define MN_SPEECH_COMMAND_ID184 CONFIG_CN_SPEECH_COMMAND_ID184 +#define MN_SPEECH_COMMAND_ID185 CONFIG_CN_SPEECH_COMMAND_ID185 +#define MN_SPEECH_COMMAND_ID186 CONFIG_CN_SPEECH_COMMAND_ID186 +#define MN_SPEECH_COMMAND_ID187 CONFIG_CN_SPEECH_COMMAND_ID187 +#define MN_SPEECH_COMMAND_ID188 CONFIG_CN_SPEECH_COMMAND_ID188 +#define MN_SPEECH_COMMAND_ID189 CONFIG_CN_SPEECH_COMMAND_ID189 +#define MN_SPEECH_COMMAND_ID190 CONFIG_CN_SPEECH_COMMAND_ID190 +#define MN_SPEECH_COMMAND_ID191 CONFIG_CN_SPEECH_COMMAND_ID191 +#define MN_SPEECH_COMMAND_ID192 CONFIG_CN_SPEECH_COMMAND_ID192 +#define MN_SPEECH_COMMAND_ID193 CONFIG_CN_SPEECH_COMMAND_ID193 +#define MN_SPEECH_COMMAND_ID194 CONFIG_CN_SPEECH_COMMAND_ID194 +#define MN_SPEECH_COMMAND_ID195 CONFIG_CN_SPEECH_COMMAND_ID195 +#define MN_SPEECH_COMMAND_ID196 CONFIG_CN_SPEECH_COMMAND_ID196 +#define MN_SPEECH_COMMAND_ID197 CONFIG_CN_SPEECH_COMMAND_ID197 +#define MN_SPEECH_COMMAND_ID198 CONFIG_CN_SPEECH_COMMAND_ID198 +#define MN_SPEECH_COMMAND_ID199 CONFIG_CN_SPEECH_COMMAND_ID199 +#elif CONFIG_SR_MN_ENGLISH +#define MN_SPEECH_COMMAND_ID0 CONFIG_EN_SPEECH_COMMAND_ID0 +#define MN_SPEECH_COMMAND_ID1 CONFIG_EN_SPEECH_COMMAND_ID1 +#define MN_SPEECH_COMMAND_ID2 CONFIG_EN_SPEECH_COMMAND_ID2 +#define MN_SPEECH_COMMAND_ID3 CONFIG_EN_SPEECH_COMMAND_ID3 +#define MN_SPEECH_COMMAND_ID4 CONFIG_EN_SPEECH_COMMAND_ID4 +#define MN_SPEECH_COMMAND_ID5 CONFIG_EN_SPEECH_COMMAND_ID5 +#define MN_SPEECH_COMMAND_ID6 CONFIG_EN_SPEECH_COMMAND_ID6 +#define MN_SPEECH_COMMAND_ID7 CONFIG_EN_SPEECH_COMMAND_ID7 +#define MN_SPEECH_COMMAND_ID8 CONFIG_EN_SPEECH_COMMAND_ID8 +#define MN_SPEECH_COMMAND_ID9 CONFIG_EN_SPEECH_COMMAND_ID9 +#define MN_SPEECH_COMMAND_ID10 CONFIG_EN_SPEECH_COMMAND_ID10 +#define MN_SPEECH_COMMAND_ID11 CONFIG_EN_SPEECH_COMMAND_ID11 +#define MN_SPEECH_COMMAND_ID12 CONFIG_EN_SPEECH_COMMAND_ID12 +#define MN_SPEECH_COMMAND_ID13 CONFIG_EN_SPEECH_COMMAND_ID13 +#define MN_SPEECH_COMMAND_ID14 CONFIG_EN_SPEECH_COMMAND_ID14 +#define MN_SPEECH_COMMAND_ID15 CONFIG_EN_SPEECH_COMMAND_ID15 +#define MN_SPEECH_COMMAND_ID16 CONFIG_EN_SPEECH_COMMAND_ID16 +#define MN_SPEECH_COMMAND_ID17 CONFIG_EN_SPEECH_COMMAND_ID17 +#define MN_SPEECH_COMMAND_ID18 CONFIG_EN_SPEECH_COMMAND_ID18 +#define MN_SPEECH_COMMAND_ID19 CONFIG_EN_SPEECH_COMMAND_ID19 +#define MN_SPEECH_COMMAND_ID20 CONFIG_EN_SPEECH_COMMAND_ID20 +#define MN_SPEECH_COMMAND_ID21 CONFIG_EN_SPEECH_COMMAND_ID21 +#define MN_SPEECH_COMMAND_ID22 CONFIG_EN_SPEECH_COMMAND_ID22 +#define MN_SPEECH_COMMAND_ID23 CONFIG_EN_SPEECH_COMMAND_ID23 +#define MN_SPEECH_COMMAND_ID24 CONFIG_EN_SPEECH_COMMAND_ID24 +#define MN_SPEECH_COMMAND_ID25 CONFIG_EN_SPEECH_COMMAND_ID25 +#define MN_SPEECH_COMMAND_ID26 CONFIG_EN_SPEECH_COMMAND_ID26 +#define MN_SPEECH_COMMAND_ID27 CONFIG_EN_SPEECH_COMMAND_ID27 +#define MN_SPEECH_COMMAND_ID28 CONFIG_EN_SPEECH_COMMAND_ID28 +#define MN_SPEECH_COMMAND_ID29 CONFIG_EN_SPEECH_COMMAND_ID29 +#define MN_SPEECH_COMMAND_ID30 CONFIG_EN_SPEECH_COMMAND_ID30 +#define MN_SPEECH_COMMAND_ID31 CONFIG_EN_SPEECH_COMMAND_ID31 +#define MN_SPEECH_COMMAND_ID32 CONFIG_EN_SPEECH_COMMAND_ID32 +#define MN_SPEECH_COMMAND_ID33 CONFIG_EN_SPEECH_COMMAND_ID33 +#define MN_SPEECH_COMMAND_ID34 CONFIG_EN_SPEECH_COMMAND_ID34 +#define MN_SPEECH_COMMAND_ID35 CONFIG_EN_SPEECH_COMMAND_ID35 +#define MN_SPEECH_COMMAND_ID36 CONFIG_EN_SPEECH_COMMAND_ID36 +#define MN_SPEECH_COMMAND_ID37 CONFIG_EN_SPEECH_COMMAND_ID37 +#define MN_SPEECH_COMMAND_ID38 CONFIG_EN_SPEECH_COMMAND_ID38 +#define MN_SPEECH_COMMAND_ID39 CONFIG_EN_SPEECH_COMMAND_ID39 +#define MN_SPEECH_COMMAND_ID40 CONFIG_EN_SPEECH_COMMAND_ID40 +#define MN_SPEECH_COMMAND_ID41 CONFIG_EN_SPEECH_COMMAND_ID41 +#define MN_SPEECH_COMMAND_ID42 CONFIG_EN_SPEECH_COMMAND_ID42 +#define MN_SPEECH_COMMAND_ID43 CONFIG_EN_SPEECH_COMMAND_ID43 +#define MN_SPEECH_COMMAND_ID44 CONFIG_EN_SPEECH_COMMAND_ID44 +#define MN_SPEECH_COMMAND_ID45 CONFIG_EN_SPEECH_COMMAND_ID45 +#define MN_SPEECH_COMMAND_ID46 CONFIG_EN_SPEECH_COMMAND_ID46 +#define MN_SPEECH_COMMAND_ID47 CONFIG_EN_SPEECH_COMMAND_ID47 +#define MN_SPEECH_COMMAND_ID48 CONFIG_EN_SPEECH_COMMAND_ID48 +#define MN_SPEECH_COMMAND_ID49 CONFIG_EN_SPEECH_COMMAND_ID49 +#define MN_SPEECH_COMMAND_ID50 CONFIG_EN_SPEECH_COMMAND_ID50 +#define MN_SPEECH_COMMAND_ID51 CONFIG_EN_SPEECH_COMMAND_ID51 +#define MN_SPEECH_COMMAND_ID52 CONFIG_EN_SPEECH_COMMAND_ID52 +#define MN_SPEECH_COMMAND_ID53 CONFIG_EN_SPEECH_COMMAND_ID53 +#define MN_SPEECH_COMMAND_ID54 CONFIG_EN_SPEECH_COMMAND_ID54 +#define MN_SPEECH_COMMAND_ID55 CONFIG_EN_SPEECH_COMMAND_ID55 +#define MN_SPEECH_COMMAND_ID56 CONFIG_EN_SPEECH_COMMAND_ID56 +#define MN_SPEECH_COMMAND_ID57 CONFIG_EN_SPEECH_COMMAND_ID57 +#define MN_SPEECH_COMMAND_ID58 CONFIG_EN_SPEECH_COMMAND_ID58 +#define MN_SPEECH_COMMAND_ID59 CONFIG_EN_SPEECH_COMMAND_ID59 +#define MN_SPEECH_COMMAND_ID60 CONFIG_EN_SPEECH_COMMAND_ID60 +#define MN_SPEECH_COMMAND_ID61 CONFIG_EN_SPEECH_COMMAND_ID61 +#define MN_SPEECH_COMMAND_ID62 CONFIG_EN_SPEECH_COMMAND_ID62 +#define MN_SPEECH_COMMAND_ID63 CONFIG_EN_SPEECH_COMMAND_ID63 +#define MN_SPEECH_COMMAND_ID64 CONFIG_EN_SPEECH_COMMAND_ID64 +#define MN_SPEECH_COMMAND_ID65 CONFIG_EN_SPEECH_COMMAND_ID65 +#define MN_SPEECH_COMMAND_ID66 CONFIG_EN_SPEECH_COMMAND_ID66 +#define MN_SPEECH_COMMAND_ID67 CONFIG_EN_SPEECH_COMMAND_ID67 +#define MN_SPEECH_COMMAND_ID68 CONFIG_EN_SPEECH_COMMAND_ID68 +#define MN_SPEECH_COMMAND_ID69 CONFIG_EN_SPEECH_COMMAND_ID69 +#define MN_SPEECH_COMMAND_ID70 CONFIG_EN_SPEECH_COMMAND_ID70 +#define MN_SPEECH_COMMAND_ID71 CONFIG_EN_SPEECH_COMMAND_ID71 +#define MN_SPEECH_COMMAND_ID72 CONFIG_EN_SPEECH_COMMAND_ID72 +#define MN_SPEECH_COMMAND_ID73 CONFIG_EN_SPEECH_COMMAND_ID73 +#define MN_SPEECH_COMMAND_ID74 CONFIG_EN_SPEECH_COMMAND_ID74 +#define MN_SPEECH_COMMAND_ID75 CONFIG_EN_SPEECH_COMMAND_ID75 +#define MN_SPEECH_COMMAND_ID76 CONFIG_EN_SPEECH_COMMAND_ID76 +#define MN_SPEECH_COMMAND_ID77 CONFIG_EN_SPEECH_COMMAND_ID77 +#define MN_SPEECH_COMMAND_ID78 CONFIG_EN_SPEECH_COMMAND_ID78 +#define MN_SPEECH_COMMAND_ID79 CONFIG_EN_SPEECH_COMMAND_ID79 +#define MN_SPEECH_COMMAND_ID80 CONFIG_EN_SPEECH_COMMAND_ID80 +#define MN_SPEECH_COMMAND_ID81 CONFIG_EN_SPEECH_COMMAND_ID81 +#define MN_SPEECH_COMMAND_ID82 CONFIG_EN_SPEECH_COMMAND_ID82 +#define MN_SPEECH_COMMAND_ID83 CONFIG_EN_SPEECH_COMMAND_ID83 +#define MN_SPEECH_COMMAND_ID84 CONFIG_EN_SPEECH_COMMAND_ID84 +#define MN_SPEECH_COMMAND_ID85 CONFIG_EN_SPEECH_COMMAND_ID85 +#define MN_SPEECH_COMMAND_ID86 CONFIG_EN_SPEECH_COMMAND_ID86 +#define MN_SPEECH_COMMAND_ID87 CONFIG_EN_SPEECH_COMMAND_ID87 +#define MN_SPEECH_COMMAND_ID88 CONFIG_EN_SPEECH_COMMAND_ID88 +#define MN_SPEECH_COMMAND_ID89 CONFIG_EN_SPEECH_COMMAND_ID89 +#define MN_SPEECH_COMMAND_ID90 CONFIG_EN_SPEECH_COMMAND_ID90 +#define MN_SPEECH_COMMAND_ID91 CONFIG_EN_SPEECH_COMMAND_ID91 +#define MN_SPEECH_COMMAND_ID92 CONFIG_EN_SPEECH_COMMAND_ID92 +#define MN_SPEECH_COMMAND_ID93 CONFIG_EN_SPEECH_COMMAND_ID93 +#define MN_SPEECH_COMMAND_ID94 CONFIG_EN_SPEECH_COMMAND_ID94 +#define MN_SPEECH_COMMAND_ID95 CONFIG_EN_SPEECH_COMMAND_ID95 +#define MN_SPEECH_COMMAND_ID96 CONFIG_EN_SPEECH_COMMAND_ID96 +#define MN_SPEECH_COMMAND_ID97 CONFIG_EN_SPEECH_COMMAND_ID97 +#define MN_SPEECH_COMMAND_ID98 CONFIG_EN_SPEECH_COMMAND_ID98 +#define MN_SPEECH_COMMAND_ID99 CONFIG_EN_SPEECH_COMMAND_ID99 +#define MN_SPEECH_COMMAND_ID100 CONFIG_EN_SPEECH_COMMAND_ID100 +#define MN_SPEECH_COMMAND_ID101 CONFIG_EN_SPEECH_COMMAND_ID101 +#define MN_SPEECH_COMMAND_ID102 CONFIG_EN_SPEECH_COMMAND_ID102 +#define MN_SPEECH_COMMAND_ID103 CONFIG_EN_SPEECH_COMMAND_ID103 +#define MN_SPEECH_COMMAND_ID104 CONFIG_EN_SPEECH_COMMAND_ID104 +#define MN_SPEECH_COMMAND_ID105 CONFIG_EN_SPEECH_COMMAND_ID105 +#define MN_SPEECH_COMMAND_ID106 CONFIG_EN_SPEECH_COMMAND_ID106 +#define MN_SPEECH_COMMAND_ID107 CONFIG_EN_SPEECH_COMMAND_ID107 +#define MN_SPEECH_COMMAND_ID108 CONFIG_EN_SPEECH_COMMAND_ID108 +#define MN_SPEECH_COMMAND_ID109 CONFIG_EN_SPEECH_COMMAND_ID109 +#define MN_SPEECH_COMMAND_ID110 CONFIG_EN_SPEECH_COMMAND_ID110 +#define MN_SPEECH_COMMAND_ID111 CONFIG_EN_SPEECH_COMMAND_ID111 +#define MN_SPEECH_COMMAND_ID112 CONFIG_EN_SPEECH_COMMAND_ID112 +#define MN_SPEECH_COMMAND_ID113 CONFIG_EN_SPEECH_COMMAND_ID113 +#define MN_SPEECH_COMMAND_ID114 CONFIG_EN_SPEECH_COMMAND_ID114 +#define MN_SPEECH_COMMAND_ID115 CONFIG_EN_SPEECH_COMMAND_ID115 +#define MN_SPEECH_COMMAND_ID116 CONFIG_EN_SPEECH_COMMAND_ID116 +#define MN_SPEECH_COMMAND_ID117 CONFIG_EN_SPEECH_COMMAND_ID117 +#define MN_SPEECH_COMMAND_ID118 CONFIG_EN_SPEECH_COMMAND_ID118 +#define MN_SPEECH_COMMAND_ID119 CONFIG_EN_SPEECH_COMMAND_ID119 +#define MN_SPEECH_COMMAND_ID120 CONFIG_EN_SPEECH_COMMAND_ID120 +#define MN_SPEECH_COMMAND_ID121 CONFIG_EN_SPEECH_COMMAND_ID121 +#define MN_SPEECH_COMMAND_ID122 CONFIG_EN_SPEECH_COMMAND_ID122 +#define MN_SPEECH_COMMAND_ID123 CONFIG_EN_SPEECH_COMMAND_ID123 +#define MN_SPEECH_COMMAND_ID124 CONFIG_EN_SPEECH_COMMAND_ID124 +#define MN_SPEECH_COMMAND_ID125 CONFIG_EN_SPEECH_COMMAND_ID125 +#define MN_SPEECH_COMMAND_ID126 CONFIG_EN_SPEECH_COMMAND_ID126 +#define MN_SPEECH_COMMAND_ID127 CONFIG_EN_SPEECH_COMMAND_ID127 +#define MN_SPEECH_COMMAND_ID128 CONFIG_EN_SPEECH_COMMAND_ID128 +#define MN_SPEECH_COMMAND_ID129 CONFIG_EN_SPEECH_COMMAND_ID129 +#define MN_SPEECH_COMMAND_ID130 CONFIG_EN_SPEECH_COMMAND_ID130 +#define MN_SPEECH_COMMAND_ID131 CONFIG_EN_SPEECH_COMMAND_ID131 +#define MN_SPEECH_COMMAND_ID132 CONFIG_EN_SPEECH_COMMAND_ID132 +#define MN_SPEECH_COMMAND_ID133 CONFIG_EN_SPEECH_COMMAND_ID133 +#define MN_SPEECH_COMMAND_ID134 CONFIG_EN_SPEECH_COMMAND_ID134 +#define MN_SPEECH_COMMAND_ID135 CONFIG_EN_SPEECH_COMMAND_ID135 +#define MN_SPEECH_COMMAND_ID136 CONFIG_EN_SPEECH_COMMAND_ID136 +#define MN_SPEECH_COMMAND_ID137 CONFIG_EN_SPEECH_COMMAND_ID137 +#define MN_SPEECH_COMMAND_ID138 CONFIG_EN_SPEECH_COMMAND_ID138 +#define MN_SPEECH_COMMAND_ID139 CONFIG_EN_SPEECH_COMMAND_ID139 +#define MN_SPEECH_COMMAND_ID140 CONFIG_EN_SPEECH_COMMAND_ID140 +#define MN_SPEECH_COMMAND_ID141 CONFIG_EN_SPEECH_COMMAND_ID141 +#define MN_SPEECH_COMMAND_ID142 CONFIG_EN_SPEECH_COMMAND_ID142 +#define MN_SPEECH_COMMAND_ID143 CONFIG_EN_SPEECH_COMMAND_ID143 +#define MN_SPEECH_COMMAND_ID144 CONFIG_EN_SPEECH_COMMAND_ID144 +#define MN_SPEECH_COMMAND_ID145 CONFIG_EN_SPEECH_COMMAND_ID145 +#define MN_SPEECH_COMMAND_ID146 CONFIG_EN_SPEECH_COMMAND_ID146 +#define MN_SPEECH_COMMAND_ID147 CONFIG_EN_SPEECH_COMMAND_ID147 +#define MN_SPEECH_COMMAND_ID148 CONFIG_EN_SPEECH_COMMAND_ID148 +#define MN_SPEECH_COMMAND_ID149 CONFIG_EN_SPEECH_COMMAND_ID149 +#define MN_SPEECH_COMMAND_ID150 CONFIG_EN_SPEECH_COMMAND_ID150 +#define MN_SPEECH_COMMAND_ID151 CONFIG_EN_SPEECH_COMMAND_ID151 +#define MN_SPEECH_COMMAND_ID152 CONFIG_EN_SPEECH_COMMAND_ID152 +#define MN_SPEECH_COMMAND_ID153 CONFIG_EN_SPEECH_COMMAND_ID153 +#define MN_SPEECH_COMMAND_ID154 CONFIG_EN_SPEECH_COMMAND_ID154 +#define MN_SPEECH_COMMAND_ID155 CONFIG_EN_SPEECH_COMMAND_ID155 +#define MN_SPEECH_COMMAND_ID156 CONFIG_EN_SPEECH_COMMAND_ID156 +#define MN_SPEECH_COMMAND_ID157 CONFIG_EN_SPEECH_COMMAND_ID157 +#define MN_SPEECH_COMMAND_ID158 CONFIG_EN_SPEECH_COMMAND_ID158 +#define MN_SPEECH_COMMAND_ID159 CONFIG_EN_SPEECH_COMMAND_ID159 +#define MN_SPEECH_COMMAND_ID160 CONFIG_EN_SPEECH_COMMAND_ID160 +#define MN_SPEECH_COMMAND_ID161 CONFIG_EN_SPEECH_COMMAND_ID161 +#define MN_SPEECH_COMMAND_ID162 CONFIG_EN_SPEECH_COMMAND_ID162 +#define MN_SPEECH_COMMAND_ID163 CONFIG_EN_SPEECH_COMMAND_ID163 +#define MN_SPEECH_COMMAND_ID164 CONFIG_EN_SPEECH_COMMAND_ID164 +#define MN_SPEECH_COMMAND_ID165 CONFIG_EN_SPEECH_COMMAND_ID165 +#define MN_SPEECH_COMMAND_ID166 CONFIG_EN_SPEECH_COMMAND_ID166 +#define MN_SPEECH_COMMAND_ID167 CONFIG_EN_SPEECH_COMMAND_ID167 +#define MN_SPEECH_COMMAND_ID168 CONFIG_EN_SPEECH_COMMAND_ID168 +#define MN_SPEECH_COMMAND_ID169 CONFIG_EN_SPEECH_COMMAND_ID169 +#define MN_SPEECH_COMMAND_ID170 CONFIG_EN_SPEECH_COMMAND_ID170 +#define MN_SPEECH_COMMAND_ID171 CONFIG_EN_SPEECH_COMMAND_ID171 +#define MN_SPEECH_COMMAND_ID172 CONFIG_EN_SPEECH_COMMAND_ID172 +#define MN_SPEECH_COMMAND_ID173 CONFIG_EN_SPEECH_COMMAND_ID173 +#define MN_SPEECH_COMMAND_ID174 CONFIG_EN_SPEECH_COMMAND_ID174 +#define MN_SPEECH_COMMAND_ID175 CONFIG_EN_SPEECH_COMMAND_ID175 +#define MN_SPEECH_COMMAND_ID176 CONFIG_EN_SPEECH_COMMAND_ID176 +#define MN_SPEECH_COMMAND_ID177 CONFIG_EN_SPEECH_COMMAND_ID177 +#define MN_SPEECH_COMMAND_ID178 CONFIG_EN_SPEECH_COMMAND_ID178 +#define MN_SPEECH_COMMAND_ID179 CONFIG_EN_SPEECH_COMMAND_ID179 +#define MN_SPEECH_COMMAND_ID180 CONFIG_EN_SPEECH_COMMAND_ID180 +#define MN_SPEECH_COMMAND_ID181 CONFIG_EN_SPEECH_COMMAND_ID181 +#define MN_SPEECH_COMMAND_ID182 CONFIG_EN_SPEECH_COMMAND_ID182 +#define MN_SPEECH_COMMAND_ID183 CONFIG_EN_SPEECH_COMMAND_ID183 +#define MN_SPEECH_COMMAND_ID184 CONFIG_EN_SPEECH_COMMAND_ID184 +#define MN_SPEECH_COMMAND_ID185 CONFIG_EN_SPEECH_COMMAND_ID185 +#define MN_SPEECH_COMMAND_ID186 CONFIG_EN_SPEECH_COMMAND_ID186 +#define MN_SPEECH_COMMAND_ID187 CONFIG_EN_SPEECH_COMMAND_ID187 +#define MN_SPEECH_COMMAND_ID188 CONFIG_EN_SPEECH_COMMAND_ID188 +#define MN_SPEECH_COMMAND_ID189 CONFIG_EN_SPEECH_COMMAND_ID189 +#define MN_SPEECH_COMMAND_ID190 CONFIG_EN_SPEECH_COMMAND_ID190 +#define MN_SPEECH_COMMAND_ID191 CONFIG_EN_SPEECH_COMMAND_ID191 +#define MN_SPEECH_COMMAND_ID192 CONFIG_EN_SPEECH_COMMAND_ID192 +#define MN_SPEECH_COMMAND_ID193 CONFIG_EN_SPEECH_COMMAND_ID193 +#define MN_SPEECH_COMMAND_ID194 CONFIG_EN_SPEECH_COMMAND_ID194 +#define MN_SPEECH_COMMAND_ID195 CONFIG_EN_SPEECH_COMMAND_ID195 +#define MN_SPEECH_COMMAND_ID196 CONFIG_EN_SPEECH_COMMAND_ID196 +#define MN_SPEECH_COMMAND_ID197 CONFIG_EN_SPEECH_COMMAND_ID197 +#define MN_SPEECH_COMMAND_ID198 CONFIG_EN_SPEECH_COMMAND_ID198 +#define MN_SPEECH_COMMAND_ID199 CONFIG_EN_SPEECH_COMMAND_ID199 +#endif +char *get_id_name(int i); +void reset_speech_commands(model_iface_data_t *model_data, char* command_str, char *err_phrase_id); \ No newline at end of file diff --git a/include/esp32s3/model_path.h b/include/esp32s3/model_path.h new file mode 100644 index 0000000..b9cdc30 --- /dev/null +++ b/include/esp32s3/model_path.h @@ -0,0 +1,3 @@ +#pragma once +char *get_model_base_path(void); +void srmodel_spiffs_init(void); \ No newline at end of file diff --git a/include/esp32s3/multinet2_ch.h b/include/esp32s3/multinet2_ch.h new file mode 100644 index 0000000..2cee215 --- /dev/null +++ b/include/esp32s3/multinet2_ch.h @@ -0,0 +1,9 @@ +//Generated by mkmodel_py +#pragma once +#include +#include "dl_lib_coefgetter_if.h" +#include "dl_lib_matrix.h" +#include "dl_lib_matrixq.h" +#include "dl_lib_matrixq8.h" + +extern const model_coeff_getter_t get_coeff_multinet2_ch; \ No newline at end of file diff --git a/include/esp32s3/nihaoxiaoxin_wn5X3.h b/include/esp32s3/nihaoxiaoxin_wn5X3.h new file mode 100644 index 0000000..b767bfc --- /dev/null +++ b/include/esp32s3/nihaoxiaoxin_wn5X3.h @@ -0,0 +1,8 @@ +//Generated by mkmodel +#pragma once +#include +#include "dl_lib_coefgetter_if.h" +#include "dl_lib_matrix.h" +#include "dl_lib_matrixq.h" + +extern const model_coeff_getter_t get_coeff_nihaoxiaoxin_wn5X3; diff --git a/include/esp32s3/nihaoxiaoxin_wn6.h b/include/esp32s3/nihaoxiaoxin_wn6.h new file mode 100644 index 0000000..c365e6d --- /dev/null +++ b/include/esp32s3/nihaoxiaoxin_wn6.h @@ -0,0 +1,8 @@ +//Generated by mkmodel +#pragma once +#include +#include "dl_lib_coefgetter_if.h" +#include "dl_lib_matrix.h" +#include "dl_lib_matrixq.h" + +extern const model_coeff_getter_t get_coeff_nihaoxiaoxin_wn6; diff --git a/include/esp32s3/nihaoxiaozhi_wn5.h b/include/esp32s3/nihaoxiaozhi_wn5.h new file mode 100644 index 0000000..04fa268 --- /dev/null +++ b/include/esp32s3/nihaoxiaozhi_wn5.h @@ -0,0 +1,8 @@ +//Generated by mkmodel +#pragma once +#include +#include "dl_lib_coefgetter_if.h" +#include "dl_lib_matrix.h" +#include "dl_lib_matrixq.h" + +extern const model_coeff_getter_t get_coeff_nihaoxiaozhi_wn5; diff --git a/include/esp32s3/nihaoxiaozhi_wn5X2.h b/include/esp32s3/nihaoxiaozhi_wn5X2.h new file mode 100644 index 0000000..6c5f2b3 --- /dev/null +++ b/include/esp32s3/nihaoxiaozhi_wn5X2.h @@ -0,0 +1,8 @@ +//Generated by mkmodel +#pragma once +#include +#include "dl_lib_coefgetter_if.h" +#include "dl_lib_matrix.h" +#include "dl_lib_matrixq.h" + +extern const model_coeff_getter_t get_coeff_nihaoxiaozhi_wn5X2; diff --git a/include/esp32s3/nihaoxiaozhi_wn5X3.h b/include/esp32s3/nihaoxiaozhi_wn5X3.h new file mode 100644 index 0000000..190556e --- /dev/null +++ b/include/esp32s3/nihaoxiaozhi_wn5X3.h @@ -0,0 +1,8 @@ +//Generated by mkmodel +#pragma once +#include +#include "dl_lib_coefgetter_if.h" +#include "dl_lib_matrix.h" +#include "dl_lib_matrixq.h" + +extern const model_coeff_getter_t get_coeff_nihaoxiaozhi_wn5X3; diff --git a/include/esp32s3/sr_flash.h b/include/esp32s3/sr_flash.h new file mode 100644 index 0000000..6c97e51 --- /dev/null +++ b/include/esp32s3/sr_flash.h @@ -0,0 +1,12 @@ +#pragma once + +#define SR_FLASH_TYPE 32 +#define SR_FLASH_SUBTYPE 32 +#define SR_FLASH_PARTITION_NAME "fr" +#define SR_FLASH_INFO_FLAG 12138 + +int8_t speech_command_flash_init(void); +int8_t enroll_speech_command_to_flash_with_id(char *phrase, int mn_command_id); +int get_use_flag_from_flash(); +int get_enroll_num_from_flash(); +char *read_speech_command_from_flash(int i); \ No newline at end of file