Function im2col_nhwc

tests/validation/reference/Im2Col.cpp:107–174

template <typename T>
void im2col_nhwc(const SimpleTensor<T> &src,
                 SimpleTensor<T>       &dst,
                 const Size2D          &kernel_dims,
                 const PadStrideInfo   &conv_info,
                 bool                   has_bias,
                 unsigned int           channel_pad_right)
{
    // Zero initialize the dst tensor for test cases involving padding
    if (is_data_type_quantized(src.data_type()))
    {
        memset(static_cast<void *>(dst.data()), src.quantization_info().uniform().offset, dst.size());
    }
    else
    {
        memset(static_cast<void *>(dst.data()), 0, dst.size());
    }

    ARM_COMPUTE_ERROR_ON(src.data_layout() != DataLayout::NHWC);
    const int stride_x      = conv_info.stride().first;
    const int stride_y      = conv_info.stride().second;
    const int kernel_width  = kernel_dims.width;
    const int kernel_height = kernel_dims.height;
    const int pad_x         = conv_info.pad().first;
    const int pad_y         = conv_info.pad().second;
    const int src_width     = src.shape().y();
    const int src_height    = src.shape().z();
    const int src_channels  = src.shape().x();
    const int batches       = src.shape().total_size_upper(3);
    const int dst_width     = has_bias ? dst.shape().x() - 1 : dst.shape().x();
    const int dst_height    = dst.shape().y();
    const int pad_val =
        is_data_type_quantized_asymmetric(src.data_type()) ? src.quantization_info().uniform().offset : 0;

    // Compute width and height of the convolved tensors
    std::pair<unsigned int, unsigned int> convolved_dims =
        scaled_dimensions(src_width, src_height, kernel_dims.width, kernel_dims.height, conv_info);
#if defined(_OPENMP)
#pragma omp parallel for schedule(dynamic, 1) collapse(2)
#endif /* _OPENMP */
    for (int b = 0; b < batches; ++b)
    {
        for (int yo = 0; yo < dst_height; ++yo)
        {
            // Compute input spatial coordinates
            const int xi = (yo % convolved_dims.first) * stride_x;
            const int yi = (yo / convolved_dims.first) * stride_y;

            for (int ci = 0; ci < src_channels; ++ci)
            {
                for (int yk = 0; yk < kernel_height; ++yk)
                {
                    for (int xk = 0; xk < kernel_width; ++xk)
                    {
                        dst[ci + (xk + yk * kernel_width) * (src_channels + channel_pad_right) + yo * dst.shape().x() +
                            b * dst.shape().x() * dst.shape().y()] =
                            tensor_elem_at(src, Coordinates(ci, xi + xk - pad_x, yi + yk - pad_y, b),
                                           BorderMode::CONSTANT, static_cast<T>(pad_val));
                    }