Method WriteDataBHWC

tensorflow/lite/delegates/gpu/cl/tensor.cc:96–137

}

Status Tensor::WriteDataBHWC(absl::Span<const float> in,
                             CLCommandQueue* queue) {
  if (in.size() != channels_ * width_ * height_) {
    return InvalidArgumentError("Input data size not match expected size");
  }

  void* data_ptr = nullptr;
  int channels = storage_type_ == TensorStorageType::SINGLE_TEXTURE_2D
                     ? channels_
                     : AlignByN(channels_, 4);
  const int elements_count = width_ * height_ * channels;

  const size_t data_size = elements_count * SizeOf(data_type_);
  std::vector<float> data_f;
  std::vector<half> data_h;
  if (data_type_ == DataType::FLOAT32) {
    data_f.resize(elements_count);
    data_ptr = data_f.data();
    DataFromBHWC(in, absl::MakeSpan(data_f.data(), data_f.size()));
  } else {
    data_h.resize(elements_count);
    data_ptr = data_h.data();
    DataFromBHWC(in, absl::MakeSpan(data_h.data(), data_h.size()));
  }

  switch (storage_type_) {
    case TensorStorageType::BUFFER: {
      RETURN_IF_ERROR(queue->EnqueueWriteBuffer(memory_, data_size, data_ptr));
      break;
    }
    case TensorStorageType::TEXTURE_ARRAY:
    case TensorStorageType::TEXTURE_2D:
    case TensorStorageType::SINGLE_TEXTURE_2D:
      RETURN_IF_ERROR(
          queue->EnqueueWriteImage(memory_, GetFullTensorRegion(), data_ptr));
      break;
    default:
      return InternalError("Unsupported tensor storage type");
  }

  return OkStatus();
}

Status Tensor::WriteData(CLCommandQueue* queue, const TensorFloat32& src) {
  RETURN_IF_ERROR(IsValid(src.shape));