src/core/NEON/kernels/NERemapKernel.cpp

   1 /*
   2  * Copyright (c) 2017 ARM Limited.
   3  *
   4  * SPDX-License-Identifier: MIT
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to
   8  * deal in the Software without restriction, including without limitation the
   9  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  10  * sell copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in all
  14  * copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24 #include "arm_compute/core/NEON/kernels/NERemapKernel.h"
  25
  26 #include "arm_compute/core/AccessWindowStatic.h"
  27 #include "arm_compute/core/Error.h"
  28 #include "arm_compute/core/Helpers.h"
  29 #include "arm_compute/core/ITensor.h"
  30 #include "arm_compute/core/TensorInfo.h"
  31 #include "arm_compute/core/Validate.h"
  32 #include "arm_compute/core/Window.h"
  33
  34 #include <arm_neon.h>
  35 #include <cstddef>
  36 #include <cstdint>
  37
  38 using namespace arm_compute;
  39
  40 namespace arm_compute
  41 {
  42 class Coordinates;
  43 } // namespace arm_compute
  44
  45 namespace
  46 {
  47 inline int32x4_t offset_nearest_interpolation(const float *mapx_ptr, const float *mapy_ptr, const float32x4_t &width, const float32x4_t &height, const int32x4_t &stride)
  48 {
  49     static const float32x4_t lowerxy = vdupq_n_f32(-1.0f);
  50
  51     float32x4_t x = vld1q_f32(mapx_ptr);
  52     float32x4_t y = vld1q_f32(mapy_ptr);
  53
  54     // Clamp x coordinates
  55     x = vmaxq_f32(lowerxy, vminq_f32(x, width));
  56     y = vmaxq_f32(lowerxy, vminq_f32(y, height));
  57
  58     const int32x4_t x_s32 = vcvtq_s32_f32(x);
  59     const int32x4_t y_s32 = vcvtq_s32_f32(y);
  60
  61     return vmlaq_s32(x_s32, y_s32, stride);
  62 }
  63
  64 } // namespace
  65
  66 NERemapKernel::NERemapKernel()
  67     : _func(nullptr), _input(nullptr), _output(nullptr), _map_x(nullptr), _map_y(nullptr)
  68 {
  69 }
  70
  71 void NERemapKernel::configure(const ITensor *input, const ITensor *map_x, const ITensor *map_y, ITensor *output, InterpolationPolicy policy)
  72 {
  73     ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::U8);
  74     ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(output, 1, DataType::U8);
  75     ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(map_x, 1, DataType::F32);
  76     ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(map_y, 1, DataType::F32);
  77
  78     _input  = input;
  79     _output = output;
  80     _map_x  = map_x;
  81     _map_y  = map_y;
  82
  83     switch(policy)
  84     {
  85         case InterpolationPolicy::NEAREST_NEIGHBOR:
  86         {
  87             _func = &NERemapKernel::remap_nearest;
  88             break;
  89         }
  90         case InterpolationPolicy::BILINEAR:
  91         {
  92             _func = &NERemapKernel::remap_bilinear;
  93             break;
  94         }
  95         default:
  96             ARM_COMPUTE_ERROR("Unsupported interpolation mode");
  97             break;
  98     }
  99
 100     const unsigned int num_elems_processed_per_iteration = 16;
 101
 102     // Configure kernel window
 103     Window win = calculate_max_window(*output->info(), Steps(num_elems_processed_per_iteration));
 104
 105     AccessWindowStatic output_access(output->info(), 0, 0, output->info()->dimension(0), output->info()->dimension(1));
 106
 107     update_window_and_padding(win,
 108                               AccessWindowRectangle(input->info(), 0, 0, num_elems_processed_per_iteration, 1),
 109                               AccessWindowRectangle(map_x->info(), 0, 0, num_elems_processed_per_iteration, 1),
 110                               AccessWindowRectangle(map_y->info(), 0, 0, num_elems_processed_per_iteration, 1),
 111                               output_access);
 112
 113     output_access.set_valid_region(win, ValidRegion(Coordinates(0, 0), output->info()->tensor_shape()));
 114
 115     INEKernel::configure(win);
 116 }
 117
 118 void NERemapKernel::remap_nearest(const Window &window)
 119 {
 120     // Don't increment in X and Y direction for the input tensor
 121     // A pointer to the start of this plane is needed as base for the precomputed offsets
 122     Window win_in(window);
 123     win_in.set(Window::DimX, Window::Dimension(0, 0, 0));
 124     win_in.set(Window::DimY, Window::Dimension(0, 0, 0));
 125
 126     Iterator in(_input, win_in);
 127     Iterator out(_output, window);
 128     Iterator mapx(_map_x, window);
 129     Iterator mapy(_map_y, window);
 130
 131     const float32x4_t width     = vdupq_n_f32(static_cast<float>(_input->info()->dimension(0)));
 132     const float32x4_t height    = vdupq_n_f32(static_cast<float>(_input->info()->dimension(1)));
 133     const int32x4_t   in_stride = vdupq_n_s32(static_cast<int32_t>(_input->info()->strides_in_bytes()[1]));
 134
 135     execute_window_loop(window, [&](const Coordinates & id)
 136     {
 137         const auto     mapx_ptr = reinterpret_cast<const float *>(mapx.ptr());
 138         const auto     mapy_ptr = reinterpret_cast<const float *>(mapy.ptr());
 139         const uint8_t *in_ptr   = in.ptr();
 140
 141         const int32x4_t offset0 = offset_nearest_interpolation(mapx_ptr + 0, mapy_ptr + 0, width, height, in_stride);
 142         const int32x4_t offset1 = offset_nearest_interpolation(mapx_ptr + 4, mapy_ptr + 4, width, height, in_stride);
 143         const int32x4_t offset2 = offset_nearest_interpolation(mapx_ptr + 8, mapy_ptr + 8, width, height, in_stride);
 144         const int32x4_t offset3 = offset_nearest_interpolation(mapx_ptr + 12, mapy_ptr + 12, width, height, in_stride);
 145
 146         uint8x8_t tmp0 = vdup_n_u8(0);
 147         tmp0           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset0, 0)], tmp0, 0);
 148         tmp0           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset0, 1)], tmp0, 1);
 149         tmp0           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset0, 2)], tmp0, 2);
 150         tmp0           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset0, 3)], tmp0, 3);
 151         tmp0           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset1, 0)], tmp0, 4);
 152         tmp0           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset1, 1)], tmp0, 5);
 153         tmp0           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset1, 2)], tmp0, 6);
 154         tmp0           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset1, 3)], tmp0, 7);
 155
 156         uint8x8_t tmp1 = vdup_n_u8(0);
 157         tmp1           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset2, 0)], tmp1, 0);
 158         tmp1           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset2, 1)], tmp1, 1);
 159         tmp1           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset2, 2)], tmp1, 2);
 160         tmp1           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset2, 3)], tmp1, 3);
 161         tmp1           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset3, 0)], tmp1, 4);
 162         tmp1           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset3, 1)], tmp1, 5);
 163         tmp1           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset3, 2)], tmp1, 6);
 164         tmp1           = vset_lane_u8(in_ptr[vgetq_lane_s32(offset3, 3)], tmp1, 7);
 165
 166         vst1q_u8(out.ptr(), vcombine_u8(tmp0, tmp1));
 167     },
 168     in, out, mapx, mapy);
 169 }
 170
 171 void NERemapKernel::remap_bilinear(const Window &window)
 172 {
 173     // Don't increment in X and Y direction for the input tensor
 174     // A pointer to the start of this plane is needed as base for the precomputed offsets
 175     Window win_in(window);
 176     win_in.set(Window::DimX, Window::Dimension(0, 0, 0));
 177     win_in.set(Window::DimY, Window::Dimension(0, 0, 0));
 178
 179     Iterator in(_input, win_in);
 180     Iterator out(_output, window);
 181     Iterator mapx(_map_x, window);
 182     Iterator mapy(_map_y, window);
 183
 184     const size_t width     = _input->info()->dimension(0);
 185     const size_t height    = _input->info()->dimension(1);
 186     const size_t in_stride = _input->info()->strides_in_bytes()[1];
 187
 188     execute_window_loop(window, [&](const Coordinates & id)
 189     {
 190         const auto     mapx_ptr = reinterpret_cast<float *>(mapx.ptr());
 191         const auto     mapy_ptr = reinterpret_cast<float *>(mapy.ptr());
 192         const uint8_t *in_ptr   = in.ptr();
 193
 194         uint8x8_t tmp0 = vdup_n_u8(0);
 195         tmp0           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[0], mapy_ptr[0]), tmp0, 0);
 196         tmp0           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[1], mapy_ptr[1]), tmp0, 1);
 197         tmp0           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[2], mapy_ptr[2]), tmp0, 2);
 198         tmp0           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[3], mapy_ptr[3]), tmp0, 3);
 199         tmp0           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[4], mapy_ptr[4]), tmp0, 4);
 200         tmp0           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[5], mapy_ptr[5]), tmp0, 5);
 201         tmp0           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[6], mapy_ptr[6]), tmp0, 6);
 202         tmp0           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[7], mapy_ptr[7]), tmp0, 7);
 203
 204         uint8x8_t tmp1 = vdup_n_u8(0);
 205         tmp1           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[8], mapy_ptr[8]), tmp1, 0);
 206         tmp1           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[9], mapy_ptr[9]), tmp1, 1);
 207         tmp1           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[10], mapy_ptr[10]), tmp1, 2);
 208         tmp1           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[11], mapy_ptr[11]), tmp1, 3);
 209         tmp1           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[12], mapy_ptr[12]), tmp1, 4);
 210         tmp1           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[13], mapy_ptr[13]), tmp1, 5);
 211         tmp1           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[14], mapy_ptr[14]), tmp1, 6);
 212         tmp1           = vset_lane_u8(pixel_bilinear_c1u8_clamp(in_ptr, in_stride, width, height, mapx_ptr[15], mapy_ptr[15]), tmp1, 7);
 213
 214         vst1q_u8(out.ptr(), vcombine_u8(tmp0, tmp1));
 215     },
 216     in, out, mapx, mapy);
 217 }
 218
 219 void NERemapKernel::run(const Window &window)
 220 {
 221     ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
 222     ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(INEKernel::window(), window);
 223     ARM_COMPUTE_ERROR_ON(_func == nullptr);
 224
 225     (this->*_func)(window);
 226 }