#pragma once

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <assert.h>

#if CONFIG_SPIRAM_SUPPORT || CONFIG_ESP32_SPIRAM_SUPPORT
#include "freertos/FreeRTOS.h"
#define DL_SPIRAM_SUPPORT 1
#else
#define DL_SPIRAM_SUPPORT 0
#endif


#ifndef max
#define max(x, y) (((x) < (y)) ? (y) : (x))
#endif

#ifndef min
#define min(x, y) (((x) < (y)) ? (x) : (y))
#endif

typedef float fptp_t;
typedef uint8_t uc_t;

typedef enum
{
    DL_SUCCESS = 0,
    DL_FAIL = 1,
} dl_error_type;

typedef enum
{
    PADDING_VALID = 0,                   /*!< Valid padding */
    PADDING_SAME = 1,                    /*!< Same padding, from right to left, free input */
    PADDING_SAME_DONT_FREE_INPUT = 2,    /*!< Same padding, from right to left, do not free input */
    PADDING_SAME_MXNET = 3,              /*!< Same padding, from left to right */
} dl_padding_type;

typedef enum
{
    DL_POOLING_MAX = 0,        /*!< Max pooling */
    DL_POOLING_AVG = 1,        /*!< Average pooling */
} dl_pooling_type; 
/*
 * Matrix for 3d
 * @Warning: the sequence of variables is fixed, cannot be modified, otherwise there will be errors in esp_dsp_dot_float
 */
typedef struct
{
    int w;        /*!< Width */
    int h;        /*!< Height */
    int c;        /*!< Channel */
    int n;        /*!< Number of filter, input and output must be 1 */
    int stride;   /*!< Step between lines */
    fptp_t *item; /*!< Data */
} dl_matrix3d_t;

typedef struct
{
    int w;      /*!< Width */
    int h;      /*!< Height */
    int c;      /*!< Channel */
    int n;      /*!< Number of filter, input and output must be 1 */
    int stride; /*!< Step between lines */
    uc_t *item; /*!< Data */
} dl_matrix3du_t;

typedef enum
{
    UPSAMPLE_NEAREST_NEIGHBOR = 0, /*!< Use nearest neighbor interpolation as the upsample method*/
    UPSAMPLE_BILINEAR = 1,        /*!< Use nearest bilinear interpolation as the upsample method*/
} dl_upsample_type;

typedef struct
{
    int stride_x;                    /*!< Strides of width */
    int stride_y;                    /*!< Strides of height */
    dl_padding_type padding;         /*!< Padding type */
} dl_matrix3d_mobilenet_config_t;

/*
 * @brief Allocate a zero-initialized space. Must use 'dl_lib_free' to free the memory.
 *
 * @param cnt  Count of units.
 * @param size Size of unit.
 * @param align Align of memory. If not required, set 0.
 * @return Pointer of allocated memory. Null for failed.
 */
static void *dl_lib_calloc(int cnt, int size, int align)
{
    int total_size = cnt * size + align + sizeof(void *);
    void *res = malloc(total_size);
    if (NULL == res)
    {
#if DL_SPIRAM_SUPPORT
        res = heap_caps_malloc(total_size, MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM);
    }
    if (NULL == res)
    {
        printf("Item psram alloc failed. Size: %d x %d\n", cnt, size);
#else
        printf("Item alloc failed. Size: %d x %d, SPIRAM_FLAG: %d\n", cnt, size, DL_SPIRAM_SUPPORT);
#endif
        return NULL;
    }
    bzero(res, total_size);
    void **data = (void **)res + 1;
    void **aligned;
    if (align)
        aligned = (void **)(((size_t)data + (align - 1)) & -align);
    else
        aligned = data;

    aligned[-1] = res;
    return (void *)aligned;
}

/**
 * @brief Free the memory space allocated by 'dl_lib_calloc'
 * 
 */
static inline void dl_lib_free(void *d)
{
    if (NULL == d)
        return;

    free(((void **)d)[-1]);
}

/*
 * @brief Allocate a 3D matrix with float items, the access sequence is NHWC
 *
 * @param n     Number of matrix3d, for filters it is out channels, for others it is 1
 * @param w     Width of matrix3d
 * @param h     Height of matrix3d
 * @param c     Channel of matrix3d
 * @return      3d matrix
 */
static inline dl_matrix3d_t *dl_matrix3d_alloc(int n, int w, int h, int c)
{
    dl_matrix3d_t *r = (dl_matrix3d_t *)dl_lib_calloc(1, sizeof(dl_matrix3d_t), 0);
    if (NULL == r)
    {
        printf("internal r failed.\n");
        return NULL;
    }
    fptp_t *items = (fptp_t *)dl_lib_calloc(n * w * h * c, sizeof(fptp_t), 0);
    if (NULL == items)
    {
        printf("matrix3d item alloc failed.\n");
        dl_lib_free(r);
        return NULL;
    }

    r->w = w;
    r->h = h;
    r->c = c;
    r->n = n;
    r->stride = w * c;
    r->item = items;

    return r;
}

/*
 * @brief Allocate a 3D matrix with 8-bits items, the access sequence is NHWC
 *
 * @param n     Number of matrix3d, for filters it is out channels, for others it is 1
 * @param w     Width of matrix3d
 * @param h     Height of matrix3d
 * @param c     Channel of matrix3d
 * @return      3d matrix
 */
static inline dl_matrix3du_t *dl_matrix3du_alloc(int n, int w, int h, int c)
{
    dl_matrix3du_t *r = (dl_matrix3du_t *)dl_lib_calloc(1, sizeof(dl_matrix3du_t), 0);
    if (NULL == r)
    {
        printf("internal r failed.\n");
        return NULL;
    }
    uc_t *items = (uc_t *)dl_lib_calloc(n * w * h * c, sizeof(uc_t), 0);
    if (NULL == items)
    {
        printf("matrix3du item alloc failed.\n");
        dl_lib_free(r);
        return NULL;
    }

    r->w = w;
    r->h = h;
    r->c = c;
    r->n = n;
    r->stride = w * c;
    r->item = items;

    return r;
}

/*
 * @brief Free a matrix3d
 *
 * @param m matrix3d with float items
 */
static inline void dl_matrix3d_free(dl_matrix3d_t *m)
{
    if (NULL == m)
        return;
    if (NULL == m->item)
    {
        dl_lib_free(m);
        return;
    }
    dl_lib_free(m->item);
    dl_lib_free(m);
}

/*
 * @brief Free a matrix3d
 *
 * @param m matrix3d with 8-bits items
 */
static inline void dl_matrix3du_free(dl_matrix3du_t *m)
{
    if (NULL == m)
        return;
    if (NULL == m->item)
    {
        dl_lib_free(m);
        return;
    }
    dl_lib_free(m->item);
    dl_lib_free(m);
}


/*
 * @brief Dot product with a vector and matrix
 *
 * @param out   Space to put the result
 * @param in    input vector
 * @param f     filter matrix
 */
void dl_matrix3dff_dot_product(dl_matrix3d_t *out, dl_matrix3d_t *in, dl_matrix3d_t *f);

/**
 * @brief Do a softmax operation on a matrix3d
 *
 * @param in        Input matrix3d
 */
void dl_matrix3d_softmax(dl_matrix3d_t *m);

/**
 * @brief Copy a range of float items from an existing matrix to a preallocated matrix
 *
 * @param dst   The destination slice matrix
 * @param src   The source matrix to slice
 * @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
 */
void dl_matrix3d_slice_copy(dl_matrix3d_t *dst,
                            dl_matrix3d_t *src,
                            int x,
                            int y,
                            int w,
                            int h);

/**
 * @brief Copy a range of 8-bits items from an existing matrix to a preallocated matrix
 *
 * @param dst   The destination slice matrix
 * @param src   The source matrix to slice
 * @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
 */
void dl_matrix3du_slice_copy(dl_matrix3du_t *dst,
                             dl_matrix3du_t *src,
                             int x,
                             int y,
                             int w,
                             int h);

/**
 * @brief Transform a sliced matrix block from nhwc to nchw, the block needs to be memory continous.
 *
 * @param out  The destination sliced matrix in nchw
 * @param in   The source sliced matrix in nhwc
 */
void dl_matrix3d_sliced_transform_nchw(dl_matrix3d_t *out,
                                       dl_matrix3d_t *in);

/**
 * @brief Do a general CNN layer pass, dimension is (number, width, height, channel)
 *
 * @param in               Input matrix3d
 * @param filter           Weights of the neurons
 * @param bias             Bias for the CNN layer
 * @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 padding          One of VALID or SAME
 * @param mode             Do convolution using C implement or xtensa implement, 0 or 1, with respect
 *                         If ESP_PLATFORM is not defined, this value is not used. Default is 0
 * @return dl_matrix3d_t*  The result of CNN layer
 */
dl_matrix3d_t *dl_matrix3d_conv(dl_matrix3d_t *in,
                                dl_matrix3d_t *filter,
                                dl_matrix3d_t *bias,
                                int stride_x,
                                int stride_y,
                                int padding,
                                int mode);

/**
 * @brief Do a global average pooling layer pass, dimension is (number, width, height, channel)
 *
 * @param in             Input matrix3d
 *
 * @return               The result of global average pooling layer
 */
dl_matrix3d_t *dl_matrix3d_global_pool(dl_matrix3d_t *in);

/**
 * @brief Calculate pooling layer of a feature map
 *
 * @param in               Input matrix, size (1, w, h, c)
 * @param f_w              Window width
 * @param f_h              Window height 
 * @param stride_x         Stride in horizontal direction
 * @param stride_y         Stride in vertical direction
 * @param padding          Padding type: PADDING_VALID and PADDING_SAME
 * @param pooling_type     Pooling type: DL_POOLING_MAX and POOLING_AVG
 * @return dl_matrix3d_t*  Resulting matrix, size (1, w', h', c)
 */
dl_matrix3d_t *dl_matrix3d_pooling(dl_matrix3d_t *in,
                                   int f_w,
                                   int f_h,
                                   int stride_x,
                                   int stride_y,
                                   dl_padding_type padding,
                                   dl_pooling_type pooling_type);
/**
 * @brief Do a batch normalization operation, update the input matrix3d: input = input * scale + offset
 *
 * @param m              Input matrix3d
 * @param scale          scale matrix3d,  scale = gamma/((moving_variance+sigma)^(1/2))
 * @param Offset         Offset matrix3d, offset = beta-(moving_mean*gamma/((moving_variance+sigma)^(1/2)))
 */
void dl_matrix3d_batch_normalize(dl_matrix3d_t *m,
                                 dl_matrix3d_t *scale,
                                 dl_matrix3d_t *offset);

/**
 * @brief Add a pair of matrix3d item-by-item: res=in_1+in_2
 *
 * @param in_1             First Floating point input matrix3d
 * @param in_2             Second Floating point input matrix3d
 *
 * @return dl_matrix3d_t*  Added data
 */
dl_matrix3d_t *dl_matrix3d_add(dl_matrix3d_t *in_1, dl_matrix3d_t *in_2);

/**
 * @brief Concatenate the channels of two matrix3ds into a new matrix3d
 *
 * @param in_1             First Floating point input matrix3d
 * @param in_2             Second Floating point input matrix3d
 *
 * @return dl_matrix3d_t*  A newly allocated matrix3d with as avlues in_1|in_2
 */
dl_matrix3d_t *dl_matrix3d_concat(dl_matrix3d_t *in_1, dl_matrix3d_t *in_2);

/**
 * @brief Concatenate the channels of four matrix3ds into a new matrix3d
 *
 * @param in_1           First Floating point input matrix3d
 * @param in_2           Second Floating point input matrix3d
 * @param in_3           Third Floating point input matrix3d
 * @param in_4           Fourth Floating point input matrix3d
 *
 * @return               A newly allocated matrix3d with as avlues in_1|in_2|in_3|in_4
 */
dl_matrix3d_t *dl_matrix3d_concat_4(dl_matrix3d_t *in_1,
                                    dl_matrix3d_t *in_2,
                                    dl_matrix3d_t *in_3,
                                    dl_matrix3d_t *in_4);

/**
 * @brief Concatenate the channels of eight matrix3ds into a new matrix3d
 *
 * @param in_1           First Floating point input matrix3d
 * @param in_2           Second Floating point input matrix3d
 * @param in_3           Third Floating point input matrix3d
 * @param in_4           Fourth Floating point input matrix3d
 * @param in_5           Fifth Floating point input matrix3d
 * @param in_6           Sixth Floating point input matrix3d
 * @param in_7           Seventh Floating point input matrix3d
 * @param in_8           eighth Floating point input matrix3d
 *
 * @return               A newly allocated matrix3d with as avlues in_1|in_2|in_3|in_4|in_5|in_6|in_7|in_8
 */
dl_matrix3d_t *dl_matrix3d_concat_8(dl_matrix3d_t *in_1,
                                    dl_matrix3d_t *in_2,
                                    dl_matrix3d_t *in_3,
                                    dl_matrix3d_t *in_4,
                                    dl_matrix3d_t *in_5,
                                    dl_matrix3d_t *in_6,
                                    dl_matrix3d_t *in_7,
                                    dl_matrix3d_t *in_8);

/**
 * @brief Do a mobilefacenet block forward, dimension is (number, width, height, channel)
 *
 * @param in                    Input matrix3d
 * @param pw                    Weights of the pointwise conv layer
 * @param pw_bn_scale           The scale params of the batch_normalize layer after the pointwise conv layer
 * @param pw_bn_offset          The offset params of the batch_normalize layer after the pointwise conv layer
 * @param dw                    Weights of the depthwise conv layer
 * @param dw_bn_scale           The scale params of the batch_normalize layer after the depthwise conv layer
 * @param dw_bn_offset          The offset params of the batch_normalize layer after the depthwise conv layer
 * @param pw_linear             Weights of the pointwise linear conv layer
 * @param pw_linear_bn_scale    The scale params of the batch_normalize layer after the pointwise linear conv layer
 * @param pw_linear_bn_offset   The offset params of the batch_normalize layer after the pointwise linear conv layer
 * @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 padding               One of VALID or SAME
 * @param mode                  Do convolution using C implement or xtensa implement, 0 or 1, with respect
 *                              If ESP_PLATFORM is not defined, this value is not used. Default is 0
 * @return                      The result of a mobilefacenet block
 */
dl_matrix3d_t *dl_matrix3d_mobilefaceblock(dl_matrix3d_t *in,
                                           dl_matrix3d_t *pw,
                                           dl_matrix3d_t *pw_bn_scale,
                                           dl_matrix3d_t *pw_bn_offset,
                                           dl_matrix3d_t *dw,
                                           dl_matrix3d_t *dw_bn_scale,
                                           dl_matrix3d_t *dw_bn_offset,
                                           dl_matrix3d_t *pw_linear,
                                           dl_matrix3d_t *pw_linear_bn_scale,
                                           dl_matrix3d_t *pw_linear_bn_offset,
                                           int stride_x,
                                           int stride_y,
                                           int padding,
                                           int mode,
                                           int shortcut);

/**
 * @brief Do a mobilefacenet block forward with 1x1 split conv, dimension is (number, width, height, channel)
 *
 * @param in                    Input matrix3d
 * @param pw_1                  Weights of the pointwise conv layer 1
 * @param pw_2                  Weights of the pointwise conv layer 2
 * @param pw_bn_scale           The scale params of the batch_normalize layer after the pointwise conv layer
 * @param pw_bn_offset          The offset params of the batch_normalize layer after the pointwise conv layer
 * @param dw                    Weights of the depthwise conv layer
 * @param dw_bn_scale           The scale params of the batch_normalize layer after the depthwise conv layer
 * @param dw_bn_offset          The offset params of the batch_normalize layer after the depthwise conv layer
 * @param pw_linear_1           Weights of the pointwise linear conv layer 1
 * @param pw_linear_2           Weights of the pointwise linear conv layer 2
 * @param pw_linear_bn_scale    The scale params of the batch_normalize layer after the pointwise linear conv layer
 * @param pw_linear_bn_offset   The offset params of the batch_normalize layer after the pointwise linear conv layer
 * @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 padding               One of VALID or SAME
 * @param mode                  Do convolution using C implement or xtensa implement, 0 or 1, with respect
 *                              If ESP_PLATFORM is not defined, this value is not used. Default is 0
 * @return                      The result of a mobilefacenet block
 */
dl_matrix3d_t *dl_matrix3d_mobilefaceblock_split(dl_matrix3d_t *in,
                                                 dl_matrix3d_t *pw_1,
                                                 dl_matrix3d_t *pw_2,
                                                 dl_matrix3d_t *pw_bn_scale,
                                                 dl_matrix3d_t *pw_bn_offset,
                                                 dl_matrix3d_t *dw,
                                                 dl_matrix3d_t *dw_bn_scale,
                                                 dl_matrix3d_t *dw_bn_offset,
                                                 dl_matrix3d_t *pw_linear_1,
                                                 dl_matrix3d_t *pw_linear_2,
                                                 dl_matrix3d_t *pw_linear_bn_scale,
                                                 dl_matrix3d_t *pw_linear_bn_offset,
                                                 int stride_x,
                                                 int stride_y,
                                                 int padding,
                                                 int mode,
                                                 int shortcut);

/**
 * @brief           Initialize the matrix3d feature map to bias
 * 
 * @param out       The matrix3d feature map needs to be initialized
 * @param bias      The bias of a convlotion operation
 */
void dl_matrix3d_init_bias(dl_matrix3d_t *out, dl_matrix3d_t *bias);

/**
 * @brief  Do a elementwise multiplication of two matrix3ds
 * 
 * @param out  Preallocated matrix3d, size (n, w, h, c)
 * @param in1  Input matrix 1, size (n, w, h, c)
 * @param in2  Input matrix 2, size (n, w, h, c)
 */
void dl_matrix3d_multiply(dl_matrix3d_t *out, dl_matrix3d_t *in1, dl_matrix3d_t *in2);

//
// Activation
//

/**
 * @brief Do a standard relu operation, update the input matrix3d
 *
 * @param m        Floating point input matrix3d
 */
void dl_matrix3d_relu(dl_matrix3d_t *m);

/**
 * @brief Do a relu (Rectifier Linear Unit) operation, update the input matrix3d
 *
 * @param in        Floating point input matrix3d
 * @param clip      If value is higher than this, it will be clipped to this value
 */
void dl_matrix3d_relu_clip(dl_matrix3d_t *m, fptp_t clip);

/**
 * @brief Do a Prelu (Rectifier Linear Unit) operation, update the input matrix3d
 *
 * @param in        Floating point input matrix3d
 * @param alpha     If value is less than zero, it will be updated by multiplying this factor
 */
void dl_matrix3d_p_relu(dl_matrix3d_t *in, dl_matrix3d_t *alpha);

/**
 * @brief Do a leaky relu (Rectifier Linear Unit) operation, update the input matrix3d
 *
 * @param in        Floating point input matrix3d
 * @param alpha     If value is less than zero, it will be updated by multiplying this factor
 */
void dl_matrix3d_leaky_relu(dl_matrix3d_t *m, fptp_t alpha);

//
// Conv 1x1
//
/**
 * @brief Do 1x1 convolution with a matrix3d
 * 
 * @param out        Preallocated matrix3d, size (1, w, h, n)
 * @param in         Input matrix, size (1, w, h, c)
 * @param filter     1x1 filter, size (n, 1, 1, c)
 */
void dl_matrix3dff_conv_1x1(dl_matrix3d_t *out,
                            dl_matrix3d_t *in,
                            dl_matrix3d_t *filter);

/**
 * @brief Do 1x1 convolution with a matrix3d, with bias adding
 * 
 * @param out        Preallocated matrix3d, size (1, w, h, n)
 * @param in         Input matrix, size (1, w, h, c)
 * @param filter     1x1 filter, size (n, 1, 1, c)
 * @param bias       Bias, size (1, 1, 1, n)
 */
void dl_matrix3dff_conv_1x1_with_bias(dl_matrix3d_t *out,
                                      dl_matrix3d_t *in,
                                      dl_matrix3d_t *filter,
                                      dl_matrix3d_t *bias);

/**
 * @brief Do 1x1 convolution with an 8-bit fixed point matrix
 * 
 * @param out        Preallocated matrix3d, size (1, w, h, n)
 * @param in         Input matrix, size (1, w, h, c)
 * @param filter     1x1 filter, size (n, 1, 1, c)
 */
void dl_matrix3duf_conv_1x1(dl_matrix3d_t *out,
                            dl_matrix3du_t *in,
                            dl_matrix3d_t *filter);

/**
 * @brief Do 1x1 convolution with an 8-bit fixed point matrix, with bias adding
 * 
 * @param out        Preallocated matrix3d, size (1, w, h, n)  
 * @param in         Input matrix, size (1, w, h, c)
 * @param filter     1x1 filter, size (n, 1, 1, c)
 * @param bias       Bias, size (1, 1, 1, n)
 */
void dl_matrix3duf_conv_1x1_with_bias(dl_matrix3d_t *out,
                                      dl_matrix3du_t *in,
                                      dl_matrix3d_t *filter,
                                      dl_matrix3d_t *bias);

//
// Conv 3x3
//

/**
 * @brief Do 3x3 convolution with a matrix3d, without padding
 * 
 * @param out        Preallocated matrix3d, size (1, w, h, n)
 * @param in         Input matrix, size (1, w, h, c)
 * @param f          3x3 filter, size (n, 3, 3, c)
 * @param step_x     Stride of width
 * @param step_y     Stride of height
 */
void dl_matrix3dff_conv_3x3_op(dl_matrix3d_t *out,
                               dl_matrix3d_t *in,
                               dl_matrix3d_t *f,
                               int step_x,
                               int step_y);

/**
 * @brief Do 3x3 convolution with a matrix3d, with bias adding
 * 
 * @param input             Input matrix, size (1, w, h, c)
 * @param filter            3x3 filter, size (n, 3, 3, c)
 * @param bias              Bias, size (1, 1, 1, n)
 * @param stride_x          Stride of width
 * @param stride_y          Stride of height
 * @param padding           Padding type
 * @return dl_matrix3d_t*   Resulting matrix3d
 */
dl_matrix3d_t *dl_matrix3dff_conv_3x3(dl_matrix3d_t *in,
                                      dl_matrix3d_t *filter,
                                      dl_matrix3d_t *bias,
                                      int stride_x,
                                      int stride_y,
                                      dl_padding_type padding);

//
// Conv Common
//

/**
 * @brief Do a general convolution layer pass with an 8-bit fixed point matrix, size is (number, width, height, channel)
 * 
 * @param in                Input image
 * @param filter            Weights of the neurons
 * @param bias              Bias for the CNN layer
 * @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 padding           Padding type
 * @return dl_matrix3d_t*   Resulting matrix3d
 */
dl_matrix3d_t *dl_matrix3duf_conv_common(dl_matrix3du_t *in,
                                         dl_matrix3d_t *filter,
                                         dl_matrix3d_t *bias,
                                         int stride_x,
                                         int stride_y,
                                         dl_padding_type padding);

/**
 * @brief Do a general convolution layer pass, size is (number, width, height, channel)
 * 
 * @param in                Input image
 * @param filter            Weights of the neurons
 * @param bias              Bias for the CNN layer
 * @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 padding           Padding type
 * @return dl_matrix3d_t*   Resulting matrix3d
 */
dl_matrix3d_t *dl_matrix3dff_conv_common(dl_matrix3d_t *in,
                                         dl_matrix3d_t *filter,
                                         dl_matrix3d_t *bias,
                                         int stride_x,
                                         int stride_y,
                                         dl_padding_type padding);

//
// Depthwise 3x3
//

/**
 * @brief Do 3x3 depthwise convolution with a float matrix3d
 * 
 * @param in                  Input matrix, size (1, w, h, c)
 * @param filter              3x3 filter, size (1, 3, 3, c)
 * @param stride_x            Stride of width
 * @param stride_y            Stride of height
 * @param padding             Padding type, 0: valid, 1: same
 * @return dl_matrix3d_t*     Resulting float matrix3d
 */
dl_matrix3d_t *dl_matrix3dff_depthwise_conv_3x3(dl_matrix3d_t *in,
                                                dl_matrix3d_t *filter,
                                                int stride_x,
                                                int stride_y,
                                                int padding);

/**
 * @brief Do 3x3 depthwise convolution with a 8-bit fixed point matrix
 * 
 * @param in                  Input matrix, size (1, w, h, c)
 * @param filter              3x3 filter, size (1, 3, 3, c)
 * @param stride_x            Stride of width
 * @param stride_y            Stride of height
 * @param padding             Padding type, 0: valid, 1: same
 * @return dl_matrix3d_t*     Resulting float matrix3d
 */
dl_matrix3d_t *dl_matrix3duf_depthwise_conv_3x3(dl_matrix3du_t *in,
                                                dl_matrix3d_t *filter,
                                                int stride_x,
                                                int stride_y,
                                                int padding);

/**
 * @brief Do 3x3 depthwise convolution with a float matrix3d, without padding
 * 
 * @param out                 Preallocated matrix3d, size (1, w, h, n)
 * @param in                  Input matrix, size (1, w, h, c)
 * @param f                   3x3 filter, size (1, 3, 3, c)
 * @param step_x              Stride of width
 * @param step_y              Stride of height
 */
void dl_matrix3dff_depthwise_conv_3x3_op(dl_matrix3d_t *out,
                                         dl_matrix3d_t *in,
                                         dl_matrix3d_t *f,
                                         int step_x,
                                         int step_y);

//
// Depthwise Common
//

/**
 * @brief Do a depthwise CNN layer pass, dimension is (number, width, height, channel)
 *
 * @param in             Input matrix3d
 * @param filter         Weights of the neurons
 * @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 padding        One of VALID or SAME
 * @param mode           Do convolution using C implement or xtensa implement, 0 or 1, with respect
 *                       If ESP_PLATFORM is not defined, this value is not used. Default is 0
 * @return               The result of depthwise CNN layer
 */
dl_matrix3d_t *dl_matrix3dff_depthwise_conv_common(dl_matrix3d_t *in,
                                                   dl_matrix3d_t *filter,
                                                   int stride_x,
                                                   int stride_y,
                                                   dl_padding_type padding);

//
// FC
//
/**
 * @brief Do a general fully connected layer pass, dimension is (number, width, height, channel)
 *
 * @param in             Input matrix3d, size is (1, w, 1, 1)
 * @param filter         Weights of the neurons, size is (1, w, h, 1)
 * @param bias           Bias for the fc layer, size is (1, 1, 1, h)
 * @return               The result of fc layer, size is (1, 1, 1, h)
 */
void dl_matrix3dff_fc(dl_matrix3d_t *out,
                      dl_matrix3d_t *in,
                      dl_matrix3d_t *filter);

/**
 * @brief Do fully connected layer forward, with bias adding
 *
 * @param out       Preallocated resulting matrix, size (1, 1, 1, h)
 * @param in        Input matrix, size (1, 1, 1, w)
 * @param filter    Filter matrix, size (1, w, h, 1)
 * @param bias      Bias matrix, size (1, 1, 1, h)
 */
void dl_matrix3dff_fc_with_bias(dl_matrix3d_t *out,
                                dl_matrix3d_t *in,
                                dl_matrix3d_t *filter,
                                dl_matrix3d_t *bias);

//
// Mobilenet
//

/**
 * @brief Do a mobilenet block forward, dimension is (number, width, height, channel)
 *
 * @param in             Input matrix3d
 * @param filter         Weights of the neurons
 * @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 padding        One of VALID or SAME
 * @param mode           Do convolution using C implement or xtensa implement, 0 or 1, with respect
 *                       If ESP_PLATFORM is not defined, this value is not used. Default is 0
 * @return               The result of depthwise CNN layer
 */
dl_matrix3d_t *dl_matrix3dff_mobilenet(dl_matrix3d_t *in,
                                       dl_matrix3d_t *dilate_filter,
                                       dl_matrix3d_t *dilate_prelu,
                                       dl_matrix3d_t *depthwise_filter,
                                       dl_matrix3d_t *depthwise_prelu,
                                       dl_matrix3d_t *compress_filter,
                                       dl_matrix3d_t *bias,
                                       dl_matrix3d_mobilenet_config_t config);

/**
 * @brief Do a mobilenet block forward, dimension is (number, width, height, channel)
 *
 * @param in             Input matrix3du
 * @param filter         Weights of the neurons
 * @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 padding        One of VALID or SAME
 * @param mode           Do convolution using C implement or xtensa implement, 0 or 1, with respect
 *                       If ESP_PLATFORM is not defined, this value is not used. Default is 0
 * @return               The result of depthwise CNN layer
 */
dl_matrix3d_t *dl_matrix3duf_mobilenet(dl_matrix3du_t *in,
                                       dl_matrix3d_t *dilate_filter,
                                       dl_matrix3d_t *dilate_prelu,
                                       dl_matrix3d_t *depthwise_filter,
                                       dl_matrix3d_t *depthwise_prelu,
                                       dl_matrix3d_t *compress_filter,
                                       dl_matrix3d_t *bias,
                                       dl_matrix3d_mobilenet_config_t config);
