Function ref_conv_uint8

executor/operator/ref/kernel/convolution/ref_conv_uint8.c:2–124

static int ref_conv_uint8(const uint8_t* input, uint8_t* output, const uint8_t* kernel, const int* bias, op_data* param)
{
    int batch = param->batch;
    int group = param->group;
    int input_c = param->in_shape[0] / group;
    int input_h = param->in_shape[1];
    int input_w = param->in_shape[2];
    int output_c = param->out_shape[0] / group;
    int output_h = param->out_shape[1];
    int output_w = param->out_shape[2];

    int kernel_size = input_c * param->kernels[0] * param->kernels[1];

    /* dequant input  */
    int input_size = batch * group * input_c * input_h * input_w;
    float* input_buf = ( float* )malloc(sizeof(float) * input_size);
    for(int i = 0; i < input_size; i++)
        input_buf[i] = (input[i] - param->zero[0]) * param->scale[0];

    /* dequant kernel  */
    int kernel_total = group * output_c * kernel_size;
    float* kernel_buf = ( float* )malloc(sizeof(float) * kernel_total);
    for(int i = 0; i < kernel_total; i++)
        kernel_buf[i] = (kernel[i] - param->zero[1]) * param->k_scale[0];

    /* dequant biases  */
    int bias_size = group * output_c;

    float* bias_buf = NULL;
    if(bias != NULL)
    {
        bias_buf = ( float* )malloc(sizeof(float) * bias_size);
        for(int i = 0; i < bias_size; i++)
            bias_buf[i] = bias[i] * param->scale[0] * param->k_scale[0];
    }

    int n, g, c, h, w, kc, kh, kw;
    int input_offset = 0;
    int kernel_offset = 0;
    int output_offset = 0;
    for(n = 0; n < batch; ++n)
    {
        for(g = 0; g < group; ++g)
        {
            for(c = 0; c < output_c; ++c)
            {
                for(h = 0; h < output_h; ++h)
                {
                    for(w = 0; w < output_w; ++w)
                    {
                        const int h_start = (h * param->strides[0]) - param->pads[0];
                        const int w_start = (w * param->strides[1]) - param->pads[1];
                        float total = 0.f;
                        if(param->layout == 0)
                        {
                            output_offset = n * group * output_c * output_h * output_w +
                                            g * output_c * output_h * output_w + c * output_h * output_w +
                                            h * output_w + w;
                        }