| /* |
| * Copyright (c) 2017-2021 Arm Limited. |
| * |
| * SPDX-License-Identifier: MIT |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in all |
| * copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| * SOFTWARE. |
| */ |
| #ifndef ARM_COMPUTE_TEST_VALIDATION_COLOR_CONVERT_H |
| #define ARM_COMPUTE_TEST_VALIDATION_COLOR_CONVERT_H |
| |
| #include "Utils.h" |
| |
| namespace arm_compute |
| { |
| namespace test |
| { |
| namespace colorconvert_helper |
| { |
| namespace detail |
| { |
| constexpr float red_coef_bt709 = 1.5748F; |
| constexpr float green_coef_bt709 = -0.1873f; |
| constexpr float green_coef2_bt709 = -0.4681f; |
| constexpr float blue_coef_bt709 = 1.8556f; |
| |
| constexpr float rgb2yuv_bt709_kr = 0.2126f; |
| constexpr float rgb2yuv_bt709_kb = 0.0722f; |
| // K_g = 1 - K_r - K_b |
| constexpr float rgb2yuv_bt709_kg = 0.7152f; |
| // C_u = 1 / (2 * (1 - K_b)) |
| constexpr float rgb2yuv_bt709_cu = 0.5389f; |
| // C_v = 1 / (2 * (1 - K_r)) |
| constexpr float rgb2yuv_bt709_cv = 0.6350f; |
| |
| constexpr float rgb2u8_red_coef = 0.2126f; |
| constexpr float rgb2u8_green_coef = 0.7152f; |
| constexpr float rgb2u8_blue_coef = 0.0722f; |
| |
| template <typename T> |
| inline void store_rgb_from_src(const SimpleTensor<T> src, SimpleTensor<T> &rvec, SimpleTensor<T> &gvec, SimpleTensor<T> &bvec) |
| { |
| int width = src.shape().x(); |
| int height = src.shape().y(); |
| |
| for(int y = 0; y < height; ++y) |
| { |
| for(int x = 0; x < width; ++x) |
| { |
| const Coordinates src_coord{ x, y }; |
| const Coordinates vec_coord{ x, y }; |
| |
| const auto *src_pixel = reinterpret_cast<const T *>(src(src_coord)); |
| auto *rvec_pixel = reinterpret_cast<T *>(rvec(vec_coord)); |
| auto *gvec_pixel = reinterpret_cast<T *>(gvec(vec_coord)); |
| auto *bvec_pixel = reinterpret_cast<T *>(bvec(vec_coord)); |
| |
| rvec_pixel[0] = src_pixel[0]; // NOLINT |
| gvec_pixel[0] = src_pixel[1]; |
| bvec_pixel[0] = src_pixel[2]; |
| } |
| } |
| } |
| |
| template <typename T> |
| inline void rgb_to_yuv_calculation(const SimpleTensor<T> rvec, const SimpleTensor<T> gvec, const SimpleTensor<T> bvec, SimpleTensor<T> &yvec, SimpleTensor<T> &uvec_top, SimpleTensor<T> &uvec_bottom, |
| SimpleTensor<T> &vvec_top, SimpleTensor<T> &vvec_bottom) |
| { |
| int width = rvec.shape().x(); |
| int height = rvec.shape().y(); |
| |
| int uvec_coord_x = 0; |
| int uvec_coord_y = 0; |
| Coordinates uvec_coord{ uvec_coord_x, uvec_coord_y }; |
| |
| for(int y = 0; y < height; ++y) |
| { |
| for(int x = 0; x < width; x += 2) |
| { |
| Coordinates coord{ x, y }; |
| auto *yvec_pixel = reinterpret_cast<T *>(yvec(coord)); |
| auto *uvec_top_pixel = reinterpret_cast<T *>(uvec_top(uvec_coord)); |
| auto *uvec_bottom_pixel = reinterpret_cast<T *>(uvec_bottom(uvec_coord)); |
| auto *vvec_top_pixel = reinterpret_cast<T *>(vvec_top(uvec_coord)); |
| auto *vvec_bottom_pixel = reinterpret_cast<T *>(vvec_bottom(uvec_coord)); |
| |
| T border_value(0); |
| int rvec_val = validation::tensor_elem_at(rvec, coord, BorderMode::CONSTANT, border_value); |
| int gvec_val = validation::tensor_elem_at(gvec, coord, BorderMode::CONSTANT, border_value); |
| int bvec_val = validation::tensor_elem_at(bvec, coord, BorderMode::CONSTANT, border_value); |
| float result = rvec_val * rgb2yuv_bt709_kr + gvec_val * rgb2yuv_bt709_kg + bvec_val * rgb2yuv_bt709_kb; |
| |
| yvec_pixel[0] = result; |
| uvec_top_pixel[0] = (bvec_val - result) * rgb2yuv_bt709_cu + 128.f; |
| vvec_top_pixel[0] = (rvec_val - result) * rgb2yuv_bt709_cv + 128.f; |
| |
| coord.set(0, x + 1); |
| rvec_val = validation::tensor_elem_at(rvec, coord, BorderMode::CONSTANT, border_value); |
| gvec_val = validation::tensor_elem_at(gvec, coord, BorderMode::CONSTANT, border_value); |
| bvec_val = validation::tensor_elem_at(bvec, coord, BorderMode::CONSTANT, border_value); |
| result = rvec_val * rgb2yuv_bt709_kr + gvec_val * rgb2yuv_bt709_kg + bvec_val * rgb2yuv_bt709_kb; |
| |
| yvec_pixel[1] = result; |
| uvec_bottom_pixel[0] = (bvec_val - result) * rgb2yuv_bt709_cu + 128.f; |
| vvec_bottom_pixel[0] = (rvec_val - result) * rgb2yuv_bt709_cv + 128.f; |
| |
| uvec_coord.set(0, ++uvec_coord_x); |
| } |
| } |
| } |
| inline float compute_rgb_value(int y_value, int v_value, int u_value, unsigned char channel_idx) |
| { |
| float result = 0.f; |
| switch(channel_idx) |
| { |
| case 0: |
| { |
| const float red = (v_value - 128.f) * red_coef_bt709; |
| result = y_value + red; |
| break; |
| } |
| case 1: |
| { |
| const float green = (u_value - 128.f) * green_coef_bt709 + (v_value - 128.f) * green_coef2_bt709; |
| result = y_value + green; |
| break; |
| } |
| case 2: |
| { |
| const float blue = (u_value - 128.f) * blue_coef_bt709; |
| result = y_value + blue; |
| break; |
| } |
| default: |
| { |
| //Assuming Alpha channel |
| return 255; |
| } |
| } |
| return std::min(std::max(0.f, result), 255.f); |
| } |
| |
| template <typename T> |
| inline void yuyv_to_rgb_calculation(const SimpleTensor<T> yvec, const SimpleTensor<T> vvec, const SimpleTensor<T> yyvec, const SimpleTensor<T> uvec, SimpleTensor<T> &dst) |
| { |
| const int dst_width = dst.shape().x(); |
| const int dst_height = dst.shape().y(); |
| for(int y = 0; y < dst_height; ++y) |
| { |
| int x_coord = 0; |
| for(int x = 0; x < dst_width; x += 2, ++x_coord) |
| { |
| const Coordinates dst_coord{ x, y }; |
| auto *dst_pixel = reinterpret_cast<T *>(dst(dst_coord)); |
| const T border_value(0); |
| const int yvec_val = validation::tensor_elem_at(yvec, { x_coord, y }, BorderMode::CONSTANT, border_value); |
| const int vvec_val = validation::tensor_elem_at(vvec, { x_coord, y }, BorderMode::CONSTANT, border_value); |
| const int yyvec_val = validation::tensor_elem_at(yyvec, { x_coord, y }, BorderMode::CONSTANT, border_value); |
| const int uvec_val = validation::tensor_elem_at(uvec, { x_coord, y }, BorderMode::CONSTANT, border_value); |
| //Compute first RGB value using Y plane |
| for(int channel_idx = 0; channel_idx < dst.num_channels(); ++channel_idx) |
| { |
| const float channel_value = compute_rgb_value(yvec_val, vvec_val, uvec_val, channel_idx); |
| dst_pixel[channel_idx] = channel_value; |
| } |
| //Compute second RGB value using YY plane |
| const Coordinates dst_coord2 |
| { |
| x + 1, y |
| }; |
| dst_pixel = reinterpret_cast<T *>(dst(dst_coord2)); |
| for(int channel_idx = 0; channel_idx < dst.num_channels(); ++channel_idx) |
| { |
| const float channel_value = compute_rgb_value(yyvec_val, vvec_val, uvec_val, channel_idx); |
| dst_pixel[channel_idx] = channel_value; |
| } |
| } |
| } |
| } |
| |
| template <typename T> |
| inline void colorconvert_rgb_to_rgbx(const SimpleTensor<T> src, SimpleTensor<T> &dst) |
| { |
| for(int channel_idx = 0; channel_idx < dst.num_channels(); ++channel_idx) |
| { |
| const int width = dst.shape().x(); |
| const int height = dst.shape().y(); |
| |
| for(int y = 0; y < height; ++y) |
| { |
| for(int x = 0; x < width; ++x) |
| { |
| const Coordinates src_coord{ x, y }; |
| const Coordinates dst_coord{ x, y }; |
| |
| const auto *src_pixel = reinterpret_cast<const T *>(src(src_coord)); |
| auto *dst_pixel = reinterpret_cast<T *>(dst(dst_coord)); |
| if(channel_idx == 3) |
| { |
| dst_pixel[channel_idx] = 255; |
| continue; |
| } |
| |
| dst_pixel[channel_idx] = src_pixel[channel_idx]; |
| } |
| } |
| } |
| } |
| |
| template <typename T> |
| inline void colorconvert_rgb_to_u8(const SimpleTensor<T> src, SimpleTensor<T> &dst) |
| { |
| const int width = dst.shape().x(); |
| const int height = dst.shape().y(); |
| |
| for(int y = 0; y < height; ++y) |
| { |
| for(int x = 0; x < width; ++x) |
| { |
| const Coordinates src_coord{ x, y }; |
| const Coordinates dst_coord{ x, y }; |
| |
| const auto *src_pixel = reinterpret_cast<const T *>(src(src_coord)); |
| auto *dst_pixel = reinterpret_cast<T *>(dst(dst_coord)); |
| |
| const float result = rgb2u8_red_coef * src_pixel[0] + rgb2u8_green_coef * src_pixel[1] + rgb2u8_blue_coef * src_pixel[2]; |
| |
| dst_pixel[0] = utility::clamp<float>(result, 0, 255); |
| } |
| } |
| } |
| |
| template <typename T> |
| inline void colorconvert_rgbx_to_rgb(const SimpleTensor<T> src, SimpleTensor<T> &dst) |
| { |
| for(int channel_idx = 0; channel_idx < dst.num_channels(); ++channel_idx) |
| { |
| const int width = dst.shape().x(); |
| const int height = dst.shape().y(); |
| |
| for(int y = 0; y < height; ++y) |
| { |
| for(int x = 0; x < width; ++x) |
| { |
| const Coordinates src_coord{ x, y }; |
| const Coordinates dst_coord{ x, y }; |
| |
| const auto *src_pixel = reinterpret_cast<const T *>(src(src_coord)); |
| auto *dst_pixel = reinterpret_cast<T *>(dst(dst_coord)); |
| |
| dst_pixel[channel_idx] = src_pixel[channel_idx]; |
| } |
| } |
| } |
| } |
| |
| template <typename T> |
| inline void colorconvert_yuyv_to_rgb(const SimpleTensor<T> src, const Format format, SimpleTensor<T> &dst) |
| { |
| SimpleTensor<T> yvec(TensorShape{ src.shape().x() / 2, src.shape().y() }, Format::U8); |
| SimpleTensor<T> uvec(TensorShape{ src.shape().x() / 2, src.shape().y() }, Format::U8); |
| SimpleTensor<T> yyvec(TensorShape{ src.shape().x() / 2, src.shape().y() }, Format::U8); |
| SimpleTensor<T> vvec(TensorShape{ src.shape().x() / 2, src.shape().y() }, Format::U8); |
| |
| const int step_x = (Format::YUYV422 == format || Format::UYVY422 == format) ? 2 : 1; |
| const int offset = (Format::YUYV422 == format) ? 0 : 1; |
| |
| Coordinates elem_coord{ 0, 0 }; |
| const int width = yvec.shape().x(); |
| const int height = yvec.shape().y(); |
| |
| for(int y = 0; y < height; ++y) |
| { |
| for(int x = 0; x < width; ++x) |
| { |
| const Coordinates src_coord{ x * step_x, y }; |
| const auto *src_pixel = reinterpret_cast<const T *>(src(src_coord)); |
| auto *yvec_pixel = reinterpret_cast<T *>(yvec(elem_coord)); |
| auto *uvec_pixel = reinterpret_cast<T *>(uvec(elem_coord)); |
| auto *yyvec_pixel = reinterpret_cast<T *>(yyvec(elem_coord)); |
| auto *vvec_pixel = reinterpret_cast<T *>(vvec(elem_coord)); |
| yvec_pixel[x] = src_pixel[0 + offset]; |
| uvec_pixel[x] = src_pixel[1 - offset]; |
| yyvec_pixel[x] = src_pixel[2 + offset]; |
| vvec_pixel[x] = src_pixel[3 - offset]; |
| } |
| elem_coord.set(1, y + 1); |
| } |
| |
| yuyv_to_rgb_calculation(yvec, vvec, yyvec, uvec, dst); |
| } |
| |
| template <typename T> |
| inline void colorconvert_iyuv_to_rgb(const std::vector<SimpleTensor<T>> &tensor_planes, SimpleTensor<T> &dst) |
| { |
| SimpleTensor<T> yvec(TensorShape{ tensor_planes[0].shape().x() / 2, tensor_planes[0].shape().y() }, Format::U8); |
| SimpleTensor<T> uvec(TensorShape{ tensor_planes[0].shape().x() / 2, tensor_planes[0].shape().y() }, Format::U8); |
| SimpleTensor<T> yyvec(TensorShape{ tensor_planes[0].shape().x() / 2, tensor_planes[0].shape().y() }, Format::U8); |
| SimpleTensor<T> vvec(TensorShape{ tensor_planes[0].shape().x() / 2, tensor_planes[0].shape().y() }, Format::U8); |
| |
| Coordinates elem_coord{ 0, 0 }; |
| const int yvec_width = yvec.shape().x(); |
| const int yvec_height = yvec.shape().y(); |
| |
| for(int y = 0; y < yvec_height; ++y) |
| { |
| for(int x = 0; x < yvec_width; ++x) |
| { |
| const Coordinates src_coord{ x, y }; |
| const auto *src_pixel = reinterpret_cast<const T *>(tensor_planes[0](src_coord)); |
| auto *yvec_pixel = reinterpret_cast<T *>(yvec(elem_coord)); |
| auto *yyvec_pixel = reinterpret_cast<T *>(yyvec(elem_coord)); |
| yvec_pixel[x] = src_pixel[x]; |
| yyvec_pixel[x] = src_pixel[x + 1]; |
| } |
| elem_coord.set(1, y + 1); |
| } |
| |
| const int uvec_width = uvec.shape().x(); |
| const int uvec_height = uvec.shape().y(); |
| |
| Coordinates top_elem_coord{ 0, 0 }; |
| Coordinates bottom_elem_coord{ 0, 1 }; |
| for(int y = 0; y < uvec_height; y += 2) |
| { |
| for(int x = 0; x < uvec_width; ++x) |
| { |
| const Coordinates src_coord{ x, y / 2 }; |
| const auto *u_pixel = reinterpret_cast<const T *>(tensor_planes[1](src_coord)); |
| const auto *v_pixel = reinterpret_cast<const T *>(tensor_planes[2](src_coord)); |
| auto *uvec_pixel_top = reinterpret_cast<T *>(uvec(top_elem_coord)); |
| auto *vvec_pixel_top = reinterpret_cast<T *>(vvec(top_elem_coord)); |
| |
| auto *uvec_pixel_bottom = reinterpret_cast<T *>(uvec(bottom_elem_coord)); |
| auto *vvec_pixel_bottom = reinterpret_cast<T *>(vvec(bottom_elem_coord)); |
| uvec_pixel_top[x] = u_pixel[0]; |
| vvec_pixel_top[x] = v_pixel[0]; |
| uvec_pixel_bottom[x] = u_pixel[0]; |
| vvec_pixel_bottom[x] = v_pixel[0]; |
| } |
| top_elem_coord.set(1, y + 2); |
| bottom_elem_coord.set(1, top_elem_coord.y() + 1); |
| } |
| |
| yuyv_to_rgb_calculation(yvec, vvec, yyvec, uvec, dst); |
| } |
| |
| template <typename T> |
| inline void colorconvert_nv12_to_rgb(const Format format, const std::vector<SimpleTensor<T>> &tensor_planes, SimpleTensor<T> &dst) |
| { |
| SimpleTensor<T> yvec(TensorShape{ tensor_planes[0].shape().x() / 2, tensor_planes[0].shape().y() }, Format::U8); |
| SimpleTensor<T> uvec(TensorShape{ tensor_planes[0].shape().x() / 2, tensor_planes[0].shape().y() }, Format::U8); |
| SimpleTensor<T> yyvec(TensorShape{ tensor_planes[0].shape().x() / 2, tensor_planes[0].shape().y() }, Format::U8); |
| SimpleTensor<T> vvec(TensorShape{ tensor_planes[0].shape().x() / 2, tensor_planes[0].shape().y() }, Format::U8); |
| |
| const int offset = (Format::NV12 == format) ? 0 : 1; |
| |
| Coordinates elem_coord{ 0, 0 }; |
| const int yvec_width = yvec.shape().x(); |
| const int yvec_height = yvec.shape().y(); |
| |
| for(int y = 0; y < yvec_height; ++y) |
| { |
| for(int x = 0; x < yvec_width; ++x) |
| { |
| const Coordinates src_coord{ x, y }; |
| const auto *src_pixel = reinterpret_cast<const T *>(tensor_planes[0](src_coord)); |
| auto *yvec_pixel = reinterpret_cast<T *>(yvec(elem_coord)); |
| auto *yyvec_pixel = reinterpret_cast<T *>(yyvec(elem_coord)); |
| yvec_pixel[x] = src_pixel[x]; |
| yyvec_pixel[x] = src_pixel[x + 1]; |
| } |
| elem_coord.set(1, y + 1); |
| } |
| |
| const int uvec_width = uvec.shape().x(); |
| const int uvec_height = uvec.shape().y(); |
| |
| Coordinates top_elem_coord{ 0, 0 }; |
| Coordinates bottom_elem_coord{ 0, 1 }; |
| for(int y = 0; y < uvec_height; y += 2) |
| { |
| for(int x = 0; x < uvec_width; ++x) |
| { |
| const Coordinates src_coord{ x, y / 2 }; |
| const auto *src_pixel = reinterpret_cast<const T *>(tensor_planes[1](src_coord)); |
| auto *uvec_pixel_top = reinterpret_cast<T *>(uvec(top_elem_coord)); |
| auto *vvec_pixel_top = reinterpret_cast<T *>(vvec(top_elem_coord)); |
| |
| auto *uvec_pixel_bottom = reinterpret_cast<T *>(uvec(bottom_elem_coord)); |
| auto *vvec_pixel_bottom = reinterpret_cast<T *>(vvec(bottom_elem_coord)); |
| uvec_pixel_top[x] = src_pixel[0 + offset]; |
| vvec_pixel_top[x] = src_pixel[1 - offset]; |
| uvec_pixel_bottom[x] = src_pixel[0 + offset]; |
| vvec_pixel_bottom[x] = src_pixel[1 - offset]; |
| } |
| top_elem_coord.set(1, y + 2); |
| bottom_elem_coord.set(1, top_elem_coord.y() + 1); |
| } |
| |
| yuyv_to_rgb_calculation(yvec, vvec, yyvec, uvec, dst); |
| } |
| |
| template <typename T> |
| inline void colorconvert_rgb_to_nv12(const SimpleTensor<T> src, std::vector<SimpleTensor<T>> &dst) |
| { |
| SimpleTensor<T> rvec(TensorShape{ dst[0].shape().x(), dst[0].shape().y() }, Format::U8); |
| SimpleTensor<T> gvec(TensorShape{ dst[0].shape().x(), dst[0].shape().y() }, Format::U8); |
| SimpleTensor<T> bvec(TensorShape{ dst[0].shape().x(), dst[0].shape().y() }, Format::U8); |
| SimpleTensor<T> yvec(TensorShape{ dst[0].shape().x(), dst[0].shape().y() }, Format::U8); |
| |
| int vec_shape_x = src.shape().x() * src.shape().y(); |
| |
| SimpleTensor<T> uvec_top(TensorShape{ vec_shape_x, 1U }, Format::U8); |
| SimpleTensor<T> uvec_bottom(TensorShape{ vec_shape_x, 1U }, Format::U8); |
| SimpleTensor<T> vvec_top(TensorShape{ vec_shape_x, 1U }, Format::U8); |
| SimpleTensor<T> vvec_bottom(TensorShape{ vec_shape_x, 1U }, Format::U8); |
| |
| store_rgb_from_src(src, rvec, gvec, bvec); |
| rgb_to_yuv_calculation(rvec, gvec, bvec, dst[0], uvec_top, uvec_bottom, vvec_top, vvec_bottom); |
| |
| SimpleTensor<T> utmp(TensorShape{ src.shape().x() / 2, src.shape().y() }, Format::U8); |
| SimpleTensor<T> vtmp(TensorShape{ src.shape().x() / 2, src.shape().y() }, Format::U8); |
| |
| uint32_t utmp_width = utmp.shape().x(); |
| uint32_t utmp_height = utmp.shape().y(); |
| |
| uint32_t uvec_coord_x = 0; |
| uint32_t uvec_coord_y = 0; |
| Coordinates uvec_coord{ uvec_coord_x, uvec_coord_y }; |
| for(uint32_t y = 0; y < utmp_height; y++) |
| { |
| for(uint32_t x = 0; x < utmp_width; x++) |
| { |
| Coordinates coord{ x, y }; |
| auto *utmp_pixel = reinterpret_cast<T *>(utmp(coord)); |
| auto *vtmp_pixel = reinterpret_cast<T *>(vtmp(coord)); |
| |
| T border_value(0); |
| int uvec_top_val = validation::tensor_elem_at(uvec_top, uvec_coord, BorderMode::CONSTANT, border_value); |
| int uvec_bottom_val = validation::tensor_elem_at(uvec_bottom, uvec_coord, BorderMode::CONSTANT, border_value); |
| int vvec_top_val = validation::tensor_elem_at(vvec_top, uvec_coord, BorderMode::CONSTANT, border_value); |
| int vvec_bottom_val = validation::tensor_elem_at(vvec_bottom, uvec_coord, BorderMode::CONSTANT, border_value); |
| |
| utmp_pixel[0] = std::ceil(float(uvec_top_val + uvec_bottom_val) / 2); |
| vtmp_pixel[0] = std::ceil(float(vvec_top_val + vvec_bottom_val) / 2); |
| |
| uvec_coord.set(0, ++uvec_coord_x); |
| } |
| } |
| |
| uint32_t second_plane_x = dst[1].shape().x(); |
| uint32_t second_plane_y = dst[1].shape().y(); |
| |
| uint32_t utmp_coord_x = 0; |
| uint32_t utmp_coord_y = 0; |
| |
| for(uint32_t y = 0; y < second_plane_y; y++) |
| { |
| for(uint32_t x = 0; x < second_plane_x; x++) |
| { |
| Coordinates coord{ x, y }; |
| Coordinates utmp_top_coord{ utmp_coord_x, utmp_coord_y }; |
| Coordinates utmp_bottom_coord{ utmp_coord_x, utmp_coord_y + 1 }; |
| |
| auto *dst_pixel = reinterpret_cast<T *>(dst[1](coord)); |
| |
| T border_value(0); |
| int utmp_top_val = validation::tensor_elem_at(utmp, utmp_top_coord, BorderMode::CONSTANT, border_value); |
| int utmp_bottom_val = validation::tensor_elem_at(utmp, utmp_bottom_coord, BorderMode::CONSTANT, border_value); |
| |
| int result = (utmp_top_val + utmp_bottom_val) / 2; |
| dst_pixel[0] = result; |
| |
| int vtmp_top_val = validation::tensor_elem_at(vtmp, utmp_top_coord, BorderMode::CONSTANT, border_value); |
| int vtmp_bottom_val = validation::tensor_elem_at(vtmp, utmp_bottom_coord, BorderMode::CONSTANT, border_value); |
| |
| result = (vtmp_top_val + vtmp_bottom_val) / 2; |
| dst_pixel[1] = result; |
| |
| utmp_coord_x++; |
| |
| if(utmp_coord_x >= utmp_width) |
| { |
| utmp_coord_x = 0; |
| utmp_coord_y += 2; |
| } |
| } |
| } |
| } |
| |
| template <typename T> |
| inline void colorconvert_rgb_to_iyuv(const SimpleTensor<T> src, std::vector<SimpleTensor<T>> &dst) |
| { |
| SimpleTensor<T> rvec(TensorShape{ dst[0].shape().x(), dst[0].shape().y() }, Format::U8); |
| SimpleTensor<T> gvec(TensorShape{ dst[0].shape().x(), dst[0].shape().y() }, Format::U8); |
| SimpleTensor<T> bvec(TensorShape{ dst[0].shape().x(), dst[0].shape().y() }, Format::U8); |
| SimpleTensor<T> yvec(TensorShape{ dst[0].shape().x(), dst[0].shape().y() }, Format::U8); |
| |
| int vec_shape_x = src.shape().x() * src.shape().y(); |
| |
| SimpleTensor<T> uvec_top(TensorShape{ vec_shape_x, 1U }, Format::U8); |
| SimpleTensor<T> uvec_bottom(TensorShape{ vec_shape_x, 1U }, Format::U8); |
| SimpleTensor<T> vvec_top(TensorShape{ vec_shape_x, 1U }, Format::U8); |
| SimpleTensor<T> vvec_bottom(TensorShape{ vec_shape_x, 1U }, Format::U8); |
| |
| store_rgb_from_src(src, rvec, gvec, bvec); |
| rgb_to_yuv_calculation(rvec, gvec, bvec, dst[0], uvec_top, uvec_bottom, vvec_top, vvec_bottom); |
| |
| SimpleTensor<T> utmp(TensorShape{ src.shape().x() / 2, src.shape().y() }, Format::U8); |
| SimpleTensor<T> vtmp(TensorShape{ src.shape().x() / 2, src.shape().y() }, Format::U8); |
| uint32_t utmp_width = utmp.shape().x(); |
| uint32_t utmp_height = utmp.shape().y(); |
| |
| uint32_t uvec_coord_x = 0; |
| uint32_t uvec_coord_y = 0; |
| Coordinates uvec_coord{ uvec_coord_x, uvec_coord_y }; |
| for(uint32_t y = 0; y < utmp_height; y++) |
| { |
| for(uint32_t x = 0; x < utmp_width; x++) |
| { |
| Coordinates coord{ x, y }; |
| auto *utmp_pixel = reinterpret_cast<T *>(utmp(coord)); |
| auto *vtmp_pixel = reinterpret_cast<T *>(vtmp(coord)); |
| |
| T border_value(0); |
| int uvec_top_val = validation::tensor_elem_at(uvec_top, uvec_coord, BorderMode::CONSTANT, border_value); |
| int uvec_bottom_val = validation::tensor_elem_at(uvec_bottom, uvec_coord, BorderMode::CONSTANT, border_value); |
| int vvec_top_val = validation::tensor_elem_at(vvec_top, uvec_coord, BorderMode::CONSTANT, border_value); |
| int vvec_bottom_val = validation::tensor_elem_at(vvec_bottom, uvec_coord, BorderMode::CONSTANT, border_value); |
| |
| utmp_pixel[0] = std::ceil(float(uvec_top_val + uvec_bottom_val) / 2); |
| vtmp_pixel[0] = std::ceil(float(vvec_top_val + vvec_bottom_val) / 2); |
| |
| uvec_coord.set(0, ++uvec_coord_x); |
| } |
| } |
| |
| uint32_t second_plane_x = dst[1].shape().x(); |
| uint32_t second_plane_y = dst[1].shape().y(); |
| |
| uint32_t utmp_coord_x = 0; |
| uint32_t utmp_coord_y = 0; |
| |
| for(uint32_t y = 0; y < second_plane_y; y++) |
| { |
| for(uint32_t x = 0; x < second_plane_x; x++) |
| { |
| Coordinates coord{ x, y }; |
| Coordinates utmp_top_coord{ utmp_coord_x, utmp_coord_y }; |
| Coordinates utmp_bottom_coord{ utmp_coord_x, utmp_coord_y + 1 }; |
| |
| auto *u_pixel = reinterpret_cast<T *>(dst[1](coord)); |
| auto *v_pixel = reinterpret_cast<T *>(dst[2](coord)); |
| |
| T border_value(0); |
| int utmp_top_val = validation::tensor_elem_at(utmp, utmp_top_coord, BorderMode::CONSTANT, border_value); |
| int utmp_bottom_val = validation::tensor_elem_at(utmp, utmp_bottom_coord, BorderMode::CONSTANT, border_value); |
| |
| int result = (utmp_top_val + utmp_bottom_val) / 2; |
| u_pixel[0] = result; |
| |
| int vtmp_top_val = validation::tensor_elem_at(vtmp, utmp_top_coord, BorderMode::CONSTANT, border_value); |
| int vtmp_bottom_val = validation::tensor_elem_at(vtmp, utmp_bottom_coord, BorderMode::CONSTANT, border_value); |
| |
| result = (vtmp_top_val + vtmp_bottom_val) / 2; |
| v_pixel[0] = result; |
| |
| utmp_coord_x++; |
| |
| if(utmp_coord_x >= utmp_width) |
| { |
| utmp_coord_x = 0; |
| utmp_coord_y += 2; |
| } |
| } |
| } |
| } |
| |
| template <typename T> |
| inline void colorconvert_rgb_to_yuv4(const SimpleTensor<T> src, std::vector<SimpleTensor<T>> &dst) |
| { |
| SimpleTensor<T> rvec(TensorShape{ dst[0].shape().x(), dst[0].shape().y() }, Format::U8); |
| SimpleTensor<T> gvec(TensorShape{ dst[0].shape().x(), dst[0].shape().y() }, Format::U8); |
| SimpleTensor<T> bvec(TensorShape{ dst[0].shape().x(), dst[0].shape().y() }, Format::U8); |
| SimpleTensor<T> yvec(TensorShape{ dst[0].shape().x(), dst[0].shape().y() }, Format::U8); |
| |
| int vec_shape_x = src.shape().x() * src.shape().y(); |
| |
| SimpleTensor<T> uvec_top(TensorShape{ vec_shape_x, 1U }, Format::U8); |
| SimpleTensor<T> uvec_bottom(TensorShape{ vec_shape_x, 1U }, Format::U8); |
| SimpleTensor<T> vvec_top(TensorShape{ vec_shape_x, 1U }, Format::U8); |
| SimpleTensor<T> vvec_bottom(TensorShape{ vec_shape_x, 1U }, Format::U8); |
| |
| int width = src.shape().x(); |
| int height = src.shape().y(); |
| |
| store_rgb_from_src(src, rvec, gvec, bvec); |
| |
| rgb_to_yuv_calculation(rvec, gvec, bvec, dst[0], uvec_top, uvec_bottom, vvec_top, vvec_bottom); |
| |
| Coordinates uvec_coord{ 0, 0 }; |
| for(int y = 0; y < height; y++) |
| { |
| for(int x = 0; x < width; x += 2) |
| { |
| Coordinates coord{ x, y }; |
| auto *plane_1_pixel = reinterpret_cast<T *>(dst[1](coord)); |
| auto *plane_2_pixel = reinterpret_cast<T *>(dst[2](coord)); |
| |
| T border_value(0); |
| int uvec_top_val = validation::tensor_elem_at(uvec_top, uvec_coord, BorderMode::CONSTANT, border_value); |
| int uvec_bottom_val = validation::tensor_elem_at(uvec_bottom, uvec_coord, BorderMode::CONSTANT, border_value); |
| |
| plane_1_pixel[0] = uvec_top_val; |
| plane_1_pixel[1] = uvec_bottom_val; |
| |
| int vvec_top_val = validation::tensor_elem_at(vvec_top, uvec_coord, BorderMode::CONSTANT, border_value); |
| int vvec_bottom_val = validation::tensor_elem_at(vvec_bottom, uvec_coord, BorderMode::CONSTANT, border_value); |
| |
| plane_2_pixel[0] = vvec_top_val; |
| plane_2_pixel[1] = vvec_bottom_val; |
| |
| uvec_coord.increment(0); |
| } |
| } |
| } |
| |
| template <typename T> |
| inline void colorconvert_yuyv_to_nv12(const SimpleTensor<T> src, const Format format, std::vector<SimpleTensor<T>> &dst) |
| { |
| SimpleTensor<T> uvvec_top(TensorShape{ dst[0].shape().x(), dst[0].shape().y() / 2 }, Format::U8); |
| SimpleTensor<T> uvvec_bottom(TensorShape{ dst[0].shape().x(), dst[0].shape().y() / 2 }, Format::U8); |
| |
| const int offset = (Format::YUYV422 == format) ? 0 : 1; |
| |
| int width = dst[0].shape().x(); |
| int height = dst[0].shape().y(); |
| |
| for(int y = 0; y < height; ++y) |
| { |
| for(int x = 0; x < width; x++) |
| { |
| const Coordinates dst_coord{ x, y }; |
| const Coordinates uv_coord{ x, y / 2 }; |
| |
| const auto *src_pixel = reinterpret_cast<const T *>(src(dst_coord)); |
| auto *y_pixel = reinterpret_cast<T *>(dst[0](dst_coord)); |
| auto *uvvec_top_pixel = reinterpret_cast<T *>(uvvec_top(uv_coord)); |
| auto *uvvec_bottom_pixel = reinterpret_cast<T *>(uvvec_bottom(uv_coord)); |
| |
| y_pixel[0] = src_pixel[0 + offset]; |
| |
| if(y % 2 == 0) |
| { |
| uvvec_top_pixel[0] = src_pixel[1 - offset]; |
| } |
| else |
| { |
| uvvec_bottom_pixel[0] = src_pixel[1 - offset]; |
| } |
| } |
| } |
| |
| width = dst[1].shape().x(); |
| height = dst[1].shape().y(); |
| |
| int uv_coord_x = 0; |
| int uv_coord_y = 0; |
| |
| for(int y = 0; y < height; ++y) |
| { |
| for(int x = 0; x < width; x++) |
| { |
| const Coordinates dst_coord{ x, y }; |
| const Coordinates uv_coord{ uv_coord_x, uv_coord_y }; |
| |
| auto *uv_pixel = reinterpret_cast<T *>(dst[1](dst_coord)); |
| const auto *uvvec_top_pixel = reinterpret_cast<T *>(uvvec_top(uv_coord)); |
| const auto *uvvec_bottom_pixel = reinterpret_cast<T *>(uvvec_bottom(uv_coord)); |
| |
| uv_pixel[0] = (uvvec_top_pixel[0] + uvvec_bottom_pixel[0]) / 2; |
| uv_pixel[1] = (uvvec_top_pixel[1] + uvvec_bottom_pixel[1]) / 2; |
| uv_coord_x += 2; |
| } |
| uv_coord_x = 0; |
| uv_coord_y++; |
| } |
| } |
| |
| template <typename T> |
| inline void colorconvert_yuyv_to_iyuv(const SimpleTensor<T> src, const Format format, std::vector<SimpleTensor<T>> &dst) |
| { |
| SimpleTensor<T> uvvec_top(TensorShape{ dst[0].shape().x(), dst[0].shape().y() / 2 }, Format::U8); |
| SimpleTensor<T> uvvec_bottom(TensorShape{ dst[0].shape().x(), dst[0].shape().y() / 2 }, Format::U8); |
| |
| const int offset = (Format::YUYV422 == format) ? 0 : 1; |
| |
| int width = dst[0].shape().x(); |
| int height = dst[0].shape().y(); |
| |
| for(int y = 0; y < height; ++y) |
| { |
| for(int x = 0; x < width; x++) |
| { |
| const Coordinates dst_coord{ x, y }; |
| const Coordinates uv_coord{ x, y / 2 }; |
| |
| const auto *src_pixel = reinterpret_cast<const T *>(src(dst_coord)); |
| auto *y_pixel = reinterpret_cast<T *>(dst[0](dst_coord)); |
| auto *uvvec_top_pixel = reinterpret_cast<T *>(uvvec_top(uv_coord)); |
| auto *uvvec_bottom_pixel = reinterpret_cast<T *>(uvvec_bottom(uv_coord)); |
| |
| y_pixel[0] = src_pixel[0 + offset]; |
| |
| if(y % 2 == 0) |
| { |
| uvvec_top_pixel[0] = src_pixel[1 - offset]; |
| } |
| else |
| { |
| uvvec_bottom_pixel[0] = src_pixel[1 - offset]; |
| } |
| } |
| } |
| |
| width = dst[1].shape().x(); |
| height = dst[1].shape().y(); |
| |
| int uv_coord_x = 0; |
| int uv_coord_y = 0; |
| |
| for(int y = 0; y < height; ++y) |
| { |
| for(int x = 0; x < width; x++) |
| { |
| const Coordinates dst_coord{ x, y }; |
| const Coordinates uv_coord{ uv_coord_x, uv_coord_y }; |
| |
| auto *u_pixel = reinterpret_cast<T *>(dst[1](dst_coord)); |
| auto *v_pixel = reinterpret_cast<T *>(dst[2](dst_coord)); |
| const auto *uvvec_top_pixel = reinterpret_cast<T *>(uvvec_top(uv_coord)); |
| const auto *uvvec_bottom_pixel = reinterpret_cast<T *>(uvvec_bottom(uv_coord)); |
| |
| u_pixel[0] = (uvvec_top_pixel[0] + uvvec_bottom_pixel[0]) / 2; |
| v_pixel[0] = (uvvec_top_pixel[1] + uvvec_bottom_pixel[1]) / 2; |
| uv_coord_x += 2; |
| } |
| uv_coord_x = 0; |
| uv_coord_y++; |
| } |
| } |
| |
| template <typename T> |
| inline void nv_to_iyuv(const SimpleTensor<T> src, const Format src_format, SimpleTensor<T> &nv1, SimpleTensor<T> &nv2) |
| { |
| int width = src.shape().x(); |
| int height = src.shape().y(); |
| |
| const int offset = (Format::NV12 == src_format) ? 1 : 0; |
| |
| for(int y = 0; y < height; ++y) |
| { |
| for(int x = 0; x < width; x++) |
| { |
| const Coordinates src_coord{ x, y }; |
| const auto *src_pixel = reinterpret_cast<const T *>(src(src_coord)); |
| auto *u_pixel = reinterpret_cast<T *>(nv1(src_coord)); |
| auto *v_pixel = reinterpret_cast<T *>(nv2(src_coord)); |
| |
| u_pixel[0] = src_pixel[1 - offset]; |
| v_pixel[0] = src_pixel[0 + offset]; |
| } |
| } |
| } |
| |
| template <typename T> |
| inline void nv_to_yuv4(const SimpleTensor<T> src, const Format src_format, SimpleTensor<T> &nv1, SimpleTensor<T> &nv2) |
| { |
| int width = src.shape().x(); |
| int height = src.shape().y(); |
| |
| const int offset = (Format::NV12 == src_format) ? 1 : 0; |
| |
| for(int y = 0; y < height; ++y) |
| { |
| for(int x = 0; x < width; x++) |
| { |
| const Coordinates src_coord{ x, y }; |
| Coordinates dst_coord{ x * 2, y * 2 }; |
| const auto *src_pixel = reinterpret_cast<const T *>(src(src_coord)); |
| auto *u_pixel = reinterpret_cast<T *>(nv1(dst_coord)); |
| auto *v_pixel = reinterpret_cast<T *>(nv2(dst_coord)); |
| |
| u_pixel[0] = src_pixel[1 - offset]; |
| u_pixel[1] = src_pixel[1 - offset]; |
| |
| v_pixel[0] = src_pixel[0 + offset]; |
| v_pixel[1] = src_pixel[0 + offset]; |
| |
| dst_coord.set(1, y * 2 + 1); |
| u_pixel = reinterpret_cast<T *>(nv1(dst_coord)); |
| v_pixel = reinterpret_cast<T *>(nv2(dst_coord)); |
| u_pixel[0] = src_pixel[1 - offset]; |
| u_pixel[1] = src_pixel[1 - offset]; |
| |
| v_pixel[0] = src_pixel[0 + offset]; |
| v_pixel[1] = src_pixel[0 + offset]; |
| } |
| } |
| } |
| |
| template <typename T> |
| inline void colorconvert_nv_to_iyuv(const std::vector<SimpleTensor<T>> src, const Format src_format, std::vector<SimpleTensor<T>> &dst) |
| { |
| int width = dst[0].shape().x(); |
| int height = dst[0].shape().y(); |
| |
| for(int y = 0; y < height; ++y) |
| { |
| for(int x = 0; x < width; ++x) |
| { |
| const Coordinates dst_coord{ x, y }; |
| |
| const auto *src_pixel = reinterpret_cast<const T *>(src[0](dst_coord)); |
| auto *y_pixel = reinterpret_cast<T *>(dst[0](dst_coord)); |
| |
| y_pixel[0] = src_pixel[0]; |
| } |
| } |
| |
| nv_to_iyuv(src[1], src_format, dst[1], dst[2]); |
| } |
| |
| template <typename T> |
| inline void colorconvert_nv_to_yuv4(const std::vector<SimpleTensor<T>> src, const Format src_format, std::vector<SimpleTensor<T>> &dst) |
| { |
| int width = dst[0].shape().x(); |
| int height = dst[0].shape().y(); |
| |
| for(int y = 0; y < height; ++y) |
| { |
| for(int x = 0; x < width; ++x) |
| { |
| const Coordinates dst_coord{ x, y }; |
| |
| const auto *src_pixel = reinterpret_cast<const T *>(src[0](dst_coord)); |
| auto *y_pixel = reinterpret_cast<T *>(dst[0](dst_coord)); |
| |
| y_pixel[0] = src_pixel[0]; |
| } |
| } |
| |
| nv_to_yuv4(src[1], src_format, dst[1], dst[2]); |
| } |
| |
| } // namespace detail |
| } // color_convert_helper |
| } // namespace test |
| } // namespace arm_compute |
| #endif /*ARM_COMPUTE_TEST_VALIDATION_COLOR_CONVERT_H */ |
