Pad.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
 * Copyright (C) 2017 The Android Open Source Project
 * Copyright 2017 The TensorFlow Authors. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#include "Pad.h"
#include "Assert.h"
#include "Logging.h"
 
#include "internal/Dims.h"
 
#include <vector>
#include <cstring> // For 'memset'
 
bool padPrepare(const Shape& input, const int32_t* paddingsData,  const Shape& paddingsShape,
                Shape* output)
{
  // Currently only 4D tensors are supported.
  uint32_t numInputDims = getNumberOfDimensions(input);
  ASSERT(numInputDims == 4);
 
  // paddings need to be provided as a 2-D int32 tensor.
  ASSERT(paddingsShape.type == OperandType::TENSOR_INT32);
  ASSERT(getNumberOfDimensions(paddingsShape) == 2);
  ASSERT(getSizeOfDimension(paddingsShape, 0) == numInputDims);
  ASSERT(getSizeOfDimension(paddingsShape, 1) == 2);
 
  std::vector<uint32_t> outDims(numInputDims);
  for (uint32_t i = 0; i < numInputDims; ++i)
  {
    int32_t beforePadding = *paddingsData++;
    int32_t afterPadding = *paddingsData++;
    // Pad value has to be greater than equal to 0.
    ASSERT(beforePadding >= 0 && afterPadding >= 0);
    outDims[i] = beforePadding + getSizeOfDimension(input, i) + afterPadding;
  }
  output->type = input.type;
  output->dimensions = outDims;
  output->offset = input.offset;
  output->scale = input.scale;
 
  return true;
}
 
namespace
{
 
// From optimized_ops.h in TensorFlow Lite
template <typename T>
inline void Pad(const T* input_data, const Dims<4>& input_dims,
                const std::vector<int>& left_paddings,
                const std::vector<int>& right_paddings, T* output_data,
                const Dims<4>& output_dims) {
  const int output_batch = ArraySize(output_dims, 3);
  const int output_height = ArraySize(output_dims, 2);
  const int output_width = ArraySize(output_dims, 1);
  const int output_depth = ArraySize(output_dims, 0);
 
  const int left_b_padding = left_paddings[3];
  const int left_h_padding = left_paddings[2];
  const int left_w_padding = left_paddings[1];
  const int left_d_padding = left_paddings[0];
 
  const int right_b_padding = right_paddings[3];
  const int right_h_padding = right_paddings[2];
  const int right_w_padding = right_paddings[1];
  const int right_d_padding = right_paddings[0];
 
  const int input_depth = ArraySize(input_dims, 0);
 
  if (left_b_padding != 0)
  {
    memset(output_data, 0, left_b_padding * output_height * output_width * output_depth *
           sizeof(T));
  }
  for (int out_b = left_b_padding; out_b < output_batch - right_b_padding; ++out_b)
  {
    if (left_h_padding != 0)
    {
      memset(output_data + Offset(output_dims, 0, 0, 0, out_b), 0,
             left_h_padding * output_width * output_depth * sizeof(T));
    }
    for (int out_h = left_h_padding; out_h < output_height - right_h_padding; ++out_h)
    {
      if (left_w_padding != 0)
      {
        memset(output_data + Offset(output_dims, 0, 0, out_h, out_b), 0,
               left_w_padding * output_depth * sizeof(T));
      }
      for (int out_w = left_w_padding; out_w < output_width - right_w_padding; ++out_w)
      {
        if (left_d_padding != 0)
        {
          memset(output_data + Offset(output_dims, 0, out_w, out_h, out_b), 0,
                 left_d_padding * sizeof(T));
        }
 
        T* out = output_data +
                 Offset(output_dims, left_d_padding, out_w, out_h, out_b);
        const T* in =
            input_data + Offset(input_dims, 0, out_w - left_w_padding,
                                out_h - left_h_padding, out_b - left_b_padding);
        memcpy(out, in, input_depth * sizeof(T));
 
        if (right_d_padding != 0)
        {
          memset(
              output_data + Offset(output_dims, output_depth - right_d_padding,
                                   out_w, out_h, out_b),
              0, right_d_padding * sizeof(T));
        }
      }
      if (right_w_padding != 0)
      {
        memset(
            output_data + Offset(output_dims, 0, output_width - right_w_padding,
                                 out_h, out_b),
            0, right_w_padding * output_depth * sizeof(T));
      }
    }
    if (right_h_padding != 0)
    {
      memset(output_data + Offset(output_dims, 0, 0,
                                  output_height - right_h_padding, out_b),
             0, right_h_padding * output_width * output_depth * sizeof(T));
    }
  }
  if (right_b_padding != 0)
  {
    memset(output_data +
               Offset(output_dims, 0, 0, 0, output_batch - right_b_padding),
           0,
           right_b_padding * output_height * output_width * output_depth *
               sizeof(T));
  }
}
 
} // namespace
 
bool padGeneric(const uint8_t* inputData, const Shape& inputShape, const int32_t* paddings,
                uint8_t* outputData, const Shape& outputShape)
{
  int32_t numInputDims = static_cast<int32_t>(getNumberOfDimensions(inputShape));
 
  std::vector<int> beforePadding;
  std::vector<int> afterPadding;
  // The lower level implementation expects the paddings in the reverse order.
  for (int32_t i = numInputDims - 1; i >= 0; --i)
  {
    beforePadding.push_back(paddings[i * 2]);
    afterPadding.push_back(paddings[i * 2 + 1]);
  }
 
  if (inputShape.type == OperandType::TENSOR_FLOAT32)
  {
    ::Pad(reinterpret_cast<const float*>(inputData),
          convertShapeToDims(inputShape),
          beforePadding, afterPadding,
          reinterpret_cast<float*>(outputData),
          convertShapeToDims(outputShape));
  }
  else if (inputShape.type == OperandType::TENSOR_QUANT8_ASYMM)
  {
    ::Pad(reinterpret_cast<const uint8_t*>(inputData),
          convertShapeToDims(inputShape),
          beforePadding, afterPadding,
          reinterpret_cast<uint8_t*>(outputData),
          convertShapeToDims(outputShape));
  }
  else
  {
    LOG(ERROR) << "Unsupported data type";
    return false;
  }
  return true;
}