Pad.h File Reference

#include "Shape.h"
#include <cstdint>

Go to the source code of this file.

Functions
bool	padPrepare (const Shape &input, const int32_t *paddingsData, const Shape &paddingsShape, Shape *output)
bool	padGeneric (const uint8_t *inputData, const Shape &inputShape, const int32_t *paddings, uint8_t *outputData, const Shape &outputShape)

Function Documentation

padGeneric()

bool padGeneric	(	const uint8_t *	inputData,
		const Shape &	inputShape,
		const int32_t *	paddings,
		uint8_t *	outputData,
		const Shape &	outputShape
	)

Definition at line 153 of file Pad.cpp.

{
  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;
}

References convertShapeToDims(), getNumberOfDimensions(), LOG, and Shape::type.

padPrepare()

bool padPrepare	(	const Shape &	input,
		const int32_t *	paddingsData,
		const Shape &	paddingsShape,
		Shape *	output
	)

Definition at line 28 of file Pad.cpp.

{
  // 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;
}

References ASSERT, getNumberOfDimensions(), getSizeOfDimension(), and Shape::type.