src/core/Validate.cpp

   1 /*
   2  * Copyright (c) 2016-2018 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/Validate.h"
  25
  26 arm_compute::Status arm_compute::error_on_mismatching_windows(const char *function, const char *file, const int line,
  27                                                               const arm_compute::Window &full, const arm_compute::Window &win)
  28 {
  29     full.validate();
  30     win.validate();
  31
  32     for(size_t i = 0; i < arm_compute::Coordinates::num_max_dimensions; ++i)
  33     {
  34         ARM_COMPUTE_RETURN_ERROR_ON_LOC(full[i].start() != win[i].start(), function, file, line);
  35         ARM_COMPUTE_RETURN_ERROR_ON_LOC(full[i].end() != win[i].end(), function, file, line);
  36         ARM_COMPUTE_RETURN_ERROR_ON_LOC(full[i].step() != win[i].step(), function, file, line);
  37     }
  38     return arm_compute::Status{};
  39 }
  40
  41 arm_compute::Status arm_compute::error_on_invalid_subwindow(const char *function, const char *file, const int line,
  42                                                             const arm_compute::Window &full, const arm_compute::Window &sub)
  43 {
  44     full.validate();
  45     sub.validate();
  46
  47     for(size_t i = 0; i < arm_compute::Coordinates::num_max_dimensions; ++i)
  48     {
  49         ARM_COMPUTE_RETURN_ERROR_ON_LOC(full[i].start() > sub[i].start(), function, file, line);
  50         ARM_COMPUTE_RETURN_ERROR_ON_LOC(full[i].end() < sub[i].end(), function, file, line);
  51         ARM_COMPUTE_RETURN_ERROR_ON_LOC(full[i].step() != sub[i].step(), function, file, line);
  52         ARM_COMPUTE_RETURN_ERROR_ON_LOC((sub[i].start() - full[i].start()) % sub[i].step(), function, file, line);
  53     }
  54     return arm_compute::Status{};
  55 }
  56
  57 arm_compute::Status arm_compute::error_on_window_not_collapsable_at_dimension(const char *function, const char *file, const int line,
  58                                                                               const arm_compute::Window &full, const arm_compute::Window &window, const int dim)
  59 {
  60     full.validate();
  61     window.validate();
  62
  63     ARM_COMPUTE_RETURN_ERROR_ON_LOC(window[dim].start() != 0, function, file, line);
  64     ARM_COMPUTE_RETURN_ERROR_ON_LOC(window[dim].start() != full[dim].start(), function, file, line);
  65     ARM_COMPUTE_RETURN_ERROR_ON_LOC(full[dim].end() != window[dim].end(), function, file, line);
  66
  67     return arm_compute::Status{};
  68 }
  69
  70 arm_compute::Status arm_compute::error_on_coordinates_dimensions_gte(const char *function, const char *file, const int line,
  71                                                                      const arm_compute::Coordinates &pos, unsigned int max_dim)
  72 {
  73     for(unsigned int i = max_dim; i < arm_compute::Coordinates::num_max_dimensions; ++i)
  74     {
  75         ARM_COMPUTE_RETURN_ERROR_ON_LOC(pos[i] != 0, function, file, line);
  76     }
  77     return arm_compute::Status{};
  78 }
  79
  80 arm_compute::Status arm_compute::error_on_window_dimensions_gte(const char *function, const char *file, const int line,
  81                                                                 const arm_compute::Window &win, unsigned int max_dim)
  82 {
  83     for(unsigned int i = max_dim; i < arm_compute::Coordinates::num_max_dimensions; ++i)
  84     {
  85         ARM_COMPUTE_RETURN_ERROR_ON_LOC_MSG((win[i].start() != 0) || (win[i].end() != win[i].step()),
  86                                             function, file, line,
  87                                             "Maximum number of dimensions expected %u but dimension %u is not empty", max_dim, i);
  88     }
  89     return arm_compute::Status{};
  90 }
  91
  92 arm_compute::Status arm_compute::error_on_tensor_not_2d(const char *function, const char *file, const int line,
  93                                                         const arm_compute::ITensor *tensor)
  94 {
  95     ARM_COMPUTE_RETURN_ERROR_ON_LOC(tensor == nullptr, function, file, line);
  96     ARM_COMPUTE_RETURN_ERROR_ON_LOC(tensor->info() == nullptr, function, file, line);
  97     ARM_COMPUTE_RETURN_ERROR_ON_LOC_MSG(tensor->info()->num_dimensions() != 2,
  98                                         function, file, line,
  99                                         "Only 2D Tensors are supported by this kernel (%d passed)", tensor->info()->num_dimensions());
 100     return arm_compute::Status{};
 101 }
 102
 103 arm_compute::Status arm_compute::error_on_channel_not_in_known_format(const char *function, const char *file, const int line,
 104                                                                       arm_compute::Format fmt, arm_compute::Channel cn)
 105 {
 106     ARM_COMPUTE_RETURN_ERROR_ON_LOC(fmt == arm_compute::Format::UNKNOWN, function, file, line);
 107     ARM_COMPUTE_RETURN_ERROR_ON_LOC(cn == arm_compute::Channel::UNKNOWN, function, file, line);
 108
 109     switch(fmt)
 110     {
 111         case arm_compute::Format::RGB888:
 112             arm_compute::error_on_channel_not_in(function, file, line, cn, arm_compute::Channel::R, arm_compute::Channel::G, arm_compute::Channel::B);
 113             break;
 114         case arm_compute::Format::RGBA8888:
 115             arm_compute::error_on_channel_not_in(function, file, line, cn, arm_compute::Channel::R, arm_compute::Channel::G, arm_compute::Channel::B, arm_compute::Channel::A);
 116             break;
 117         case arm_compute::Format::UV88:
 118             arm_compute::error_on_channel_not_in(function, file, line, cn, arm_compute::Channel::U, arm_compute::Channel::V);
 119             break;
 120         case arm_compute::Format::IYUV:
 121         case arm_compute::Format::UYVY422:
 122         case arm_compute::Format::YUYV422:
 123         case arm_compute::Format::NV12:
 124         case arm_compute::Format::NV21:
 125         case arm_compute::Format::YUV444:
 126             arm_compute::error_on_channel_not_in(function, file, line, cn, arm_compute::Channel::Y, arm_compute::Channel::U, arm_compute::Channel::V);
 127             break;
 128         default:
 129             ARM_COMPUTE_ERROR_LOC(function, file, line, "Not supported format.");
 130     }
 131     return arm_compute::Status{};
 132 }
 133
 134 arm_compute::Status arm_compute::error_on_invalid_multi_hog(const char *function, const char *file, const int line,
 135                                                             const arm_compute::IMultiHOG *multi_hog)
 136 {
 137     ARM_COMPUTE_RETURN_ERROR_ON_LOC(nullptr == multi_hog, function, file, line);
 138     ARM_COMPUTE_RETURN_ERROR_ON_LOC(0 == multi_hog->num_models(), function, file, line);
 139
 140     for(size_t i = 1; i < multi_hog->num_models(); ++i)
 141     {
 142         ARM_COMPUTE_RETURN_ERROR_ON_LOC_MSG(multi_hog->model(0)->info()->phase_type() != multi_hog->model(i)->info()->phase_type(),
 143                                             function, file, line,
 144                                             "All HOG parameters must have the same phase type");
 145         ARM_COMPUTE_RETURN_ERROR_ON_LOC_MSG(multi_hog->model(0)->info()->normalization_type() != multi_hog->model(i)->info()->normalization_type(),
 146                                             function, file, line,
 147                                             "All HOG parameters must have the same normalization type");
 148         ARM_COMPUTE_RETURN_ERROR_ON_LOC_MSG((multi_hog->model(0)->info()->l2_hyst_threshold() != multi_hog->model(i)->info()->l2_hyst_threshold())
 149                                             && (multi_hog->model(0)->info()->normalization_type() == arm_compute::HOGNormType::L2HYS_NORM),
 150                                             function, file, line,
 151                                             "All HOG parameters must have the same l2 hysteresis threshold if you use L2 hysteresis normalization type");
 152     }
 153     return arm_compute::Status{};
 154 }
 155
 156 arm_compute::Status arm_compute::error_on_unconfigured_kernel(const char *function, const char *file, const int line,
 157                                                               const arm_compute::IKernel *kernel)
 158 {
 159     ARM_COMPUTE_RETURN_ERROR_ON_LOC(kernel == nullptr, function, file, line);
 160     ARM_COMPUTE_RETURN_ERROR_ON_LOC_MSG((kernel->window().x().start() == kernel->window().x().end()) && (kernel->window().x().end() == 0) && (kernel->window().x().step() == 0),
 161                                         function, file, line,
 162                                         "This kernel hasn't been configured.");
 163     return arm_compute::Status{};
 164 }
 165
 166 arm_compute::Status arm_compute::error_on_invalid_subtensor(const char *function, const char *file, const int line,
 167                                                             const TensorShape &parent_shape, const Coordinates &coords, const TensorShape &shape)
 168 {
 169     // Subtensor should not index in x, y dimensions.
 170     ARM_COMPUTE_RETURN_ERROR_ON_LOC(((coords.x() != 0) && (coords.y() != 0)), function, file, line);
 171     // Subtensor shape should match parent tensor in x, y dimensions.
 172     ARM_COMPUTE_RETURN_ERROR_ON_LOC(((parent_shape.x() != shape.x()) && (parent_shape.y() != parent_shape.y())), function, file, line);
 173
 174     // Check dimensions
 175     for(unsigned int i = 0; i < TensorShape::num_max_dimensions; ++i)
 176     {
 177         ARM_COMPUTE_RETURN_ERROR_ON_LOC(((coords[i] >= static_cast<int>(parent_shape[i])) || (coords[i] + static_cast<int>(shape[i]) > static_cast<int>(parent_shape[i]))),
 178                                         function, file, line);
 179     }
 180     return arm_compute::Status{};
 181 }
 182
 183 arm_compute::Status arm_compute::error_on_invalid_subtensor_valid_region(const char *function, const char *file, const int line,
 184                                                                          const ValidRegion &parent_valid_region, const ValidRegion &valid_region)
 185 {
 186     // Check valid regions
 187     for(unsigned int d = 0; d < TensorShape::num_max_dimensions; ++d)
 188     {
 189         ARM_COMPUTE_RETURN_ERROR_ON_LOC((parent_valid_region.anchor[d] > valid_region.anchor[d]), function, file, line);
 190         ARM_COMPUTE_RETURN_ERROR_ON_LOC((parent_valid_region.anchor[d] + static_cast<int>(parent_valid_region.shape[d])) < (valid_region.anchor[d] + static_cast<int>(valid_region.shape[d])),
 191                                         function, file, line);
 192     }
 193
 194     return arm_compute::Status{};
 195 }