Method ReadDataBHWC

tensorflow/lite/delegates/gpu/cl/tensor.cc:144–187

}

Status Tensor::ReadDataBHWC(absl::Span<float> out,
                            CLCommandQueue* queue) const {
  if (out.size() != channels_ * width_ * height_) {
    return InvalidArgumentError("Output 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();
  } else {
    data_h.resize(elements_count);
    data_ptr = data_h.data();
  }

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

  if (data_type_ == DataType::FLOAT32) {
    DataToBHWC(absl::MakeConstSpan(data_f.data(), data_f.size()), out);
  } else {
    DataToBHWC(absl::MakeConstSpan(data_h.data(), data_h.size()), out);
  }

  return OkStatus();
}

Status Tensor::ReadData(CLCommandQueue* queue, TensorFloat32* dst) const {
  RETURN_IF_ERROR(IsValid(dst->shape));