chore: import upstream snapshot with attribution

tensorflow/lite/delegates/gpu/gl/converters/BUILD

@@ -0,0 +1,116 @@
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_cc//cc:cc_test.bzl", "cc_test")
+load(
+    "//tensorflow/core/platform:build_config_root.bzl",
+    "tf_gpu_tests_tags",
+)
+load("//tensorflow/lite:special_rules.bzl", "tflite_portable_test_suite")
+
+package(
+    # copybara:uncomment default_applicable_licenses = ["//tensorflow:LICENSE"],
+    default_visibility = ["//visibility:public"],
+    licenses = ["notice"],
+)
+
+cc_library(
+    name = "util",
+    hdrs = ["util.h"],
+    deps = [
+        "//tensorflow/lite/delegates/gpu/common:shape",
+        "//tensorflow/lite/delegates/gpu/common:types",
+        "//tensorflow/lite/delegates/gpu/common:util",
+        "@com_google_absl//absl/strings",
+    ],
+)
+
+cc_library(
+    name = "bhwc_to_phwc4",
+    srcs = ["bhwc_to_phwc4.cc"],
+    hdrs = ["bhwc_to_phwc4.h"],
+    deps = [
+        ":util",
+        "//tensorflow/lite/delegates/gpu/common:shape",
+        "//tensorflow/lite/delegates/gpu/common:status",
+        "//tensorflow/lite/delegates/gpu/common:types",
+        "//tensorflow/lite/delegates/gpu/common:util",
+        "//tensorflow/lite/delegates/gpu/gl:command_queue",
+        "//tensorflow/lite/delegates/gpu/gl:gl_buffer",
+        "//tensorflow/lite/delegates/gpu/gl:gl_program",
+        "//tensorflow/lite/delegates/gpu/gl:gl_shader",
+        "//tensorflow/lite/delegates/gpu/gl:variable",
+    ],
+)
+
+cc_test(
+    name = "bhwc_to_phwc4_test",
+    size = "small",
+    srcs = ["bhwc_to_phwc4_test.cc"],
+    linkopts = [
+        "-lEGL",
+        "-lGLESv2",
+    ],
+    tags = tf_gpu_tests_tags() + [
+        "local",
+        "nobuilder",
+        "notap",
+        "tflite_not_portable_ios",
+    ],
+    deps = [
+        ":bhwc_to_phwc4",
+        "//tensorflow/lite/delegates/gpu/common:convert",
+        "//tensorflow/lite/delegates/gpu/common:shape",
+        "//tensorflow/lite/delegates/gpu/common:status",
+        "//tensorflow/lite/delegates/gpu/gl:egl_environment",
+        "//tensorflow/lite/delegates/gpu/gl:gl_buffer",
+        "//tensorflow/lite/delegates/gpu/gl:portable",
+        "@com_google_absl//absl/types:span",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_library(
+    name = "phwc4_to_bhwc",
+    srcs = ["phwc4_to_bhwc.cc"],
+    hdrs = ["phwc4_to_bhwc.h"],
+    deps = [
+        ":util",
+        "//tensorflow/lite/delegates/gpu/common:shape",
+        "//tensorflow/lite/delegates/gpu/common:status",
+        "//tensorflow/lite/delegates/gpu/common:types",
+        "//tensorflow/lite/delegates/gpu/common:util",
+        "//tensorflow/lite/delegates/gpu/gl:command_queue",
+        "//tensorflow/lite/delegates/gpu/gl:gl_buffer",
+        "//tensorflow/lite/delegates/gpu/gl:gl_program",
+        "//tensorflow/lite/delegates/gpu/gl:gl_shader",
+        "//tensorflow/lite/delegates/gpu/gl:variable",
+    ],
+)
+
+cc_test(
+    name = "phwc4_to_bhwc_test",
+    size = "small",
+    srcs = ["phwc4_to_bhwc_test.cc"],
+    linkopts = [
+        "-lEGL",
+        "-lGLESv2",
+    ],
+    tags = tf_gpu_tests_tags() + [
+        "local",
+        "nobuilder",
+        "notap",
+        "tflite_not_portable_ios",
+    ],
+    deps = [
+        ":phwc4_to_bhwc",
+        "//tensorflow/lite/delegates/gpu/common:convert",
+        "//tensorflow/lite/delegates/gpu/common:shape",
+        "//tensorflow/lite/delegates/gpu/common:status",
+        "//tensorflow/lite/delegates/gpu/gl:egl_environment",
+        "//tensorflow/lite/delegates/gpu/gl:gl_buffer",
+        "//tensorflow/lite/delegates/gpu/gl:portable",
+        "@com_google_absl//absl/types:span",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+tflite_portable_test_suite()

tensorflow/lite/delegates/gpu/gl/converters/bhwc_to_phwc4.cc

@@ -0,0 +1,108 @@
+/* Copyright 2019 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 "tensorflow/lite/delegates/gpu/gl/converters/bhwc_to_phwc4.h"
+
+#include <cstdint>
+#include <string>
+#include <utility>
+
+#include "tensorflow/lite/delegates/gpu/common/status.h"
+#include "tensorflow/lite/delegates/gpu/common/types.h"
+#include "tensorflow/lite/delegates/gpu/common/util.h"
+#include "tensorflow/lite/delegates/gpu/gl/converters/util.h"
+#include "tensorflow/lite/delegates/gpu/gl/gl_program.h"
+#include "tensorflow/lite/delegates/gpu/gl/gl_shader.h"
+#include "tensorflow/lite/delegates/gpu/gl/variable.h"
+
+namespace tflite {
+namespace gpu {
+namespace gl {
+
+absl::Status ConverterBhwcToPhwc4::Create(ConverterBhwcToPhwc4* converter) {
+  uint3 workgroup_size = uint3(4, 4, 4);
+  std::string shader_source = GetShaderHeader(workgroup_size) + R"(
+    layout(std430) buffer;
+
+    precision highp float;
+
+    layout(binding = 0) readonly buffer B0 {
+      float elements[];
+    } input_data;
+
+    layout(binding = 1) writeonly buffer B1 {
+      vec4 elements[];
+    } output_data;
+
+    uniform ivec4 sizes_;
+
+    void main() {
+      ivec3 gid = ivec3(gl_GlobalInvocationID.xyz);
+      if (gid.x >= sizes_.x || gid.y >= sizes_.y || gid.z >= sizes_.z) {
+        return;
+      }
+      vec4 v = vec4(0);
+      int dst_channel = gid.z * 4;
+      int index = (gid.y * sizes_.x + gid.x) * sizes_.w + dst_channel;
+      for (int i = 0; i < 4; ++i, ++index, ++dst_channel) {
+        if (dst_channel >= sizes_.w) break;
+        v[i] = input_data.elements[index];
+      }
+      output_data.elements[(gid.z * sizes_.y + gid.y) * sizes_.x + gid.x] = v;
+    })";
+
+  GlShader shader;
+  RETURN_IF_ERROR(
+      GlShader::CompileShader(GL_COMPUTE_SHADER, shader_source, &shader));
+  GlProgram program;
+  RETURN_IF_ERROR(GlProgram::CreateWithShader(shader, &program));
+  *converter = ConverterBhwcToPhwc4(std::move(program), workgroup_size);
+  return absl::OkStatus();
+}
+
+absl::Status ConverterBhwcToPhwc4::Convert(const BHWC& shape,
+                                           const GlBuffer& source,
+                                           CommandQueue* command_queue,
+                                           GlBuffer* destination) {
+  if (source.bytes_size() < BytesForBHWC(shape)) {
+    return absl::InvalidArgumentError(
+        "BhwcToPhwc4: Input data size does not match expected size.");
+  }
+  if (destination->bytes_size() < BytesForPHWC4(shape)) {
+    return absl::InvalidArgumentError(
+        "BhwcToPhwc4: output data size does not match expected size.");
+  }
+  if (shape.b != 1) {
+    return absl::UnimplementedError(
+        "BhwcToPhwc4: Batch size is not equal to 1.");
+  }
+  uint3 workload = uint3(shape.w, shape.h, DivideRoundUp(shape.c, 4));
+  uint3 num_workgroups = DivideRoundUp(workload, workgroup_size_);
+
+  RETURN_IF_ERROR(program_.SetParameter(
+      {"sizes_",
+       int4(static_cast<int32_t>(workload.x), static_cast<int32_t>(workload.y),
+            static_cast<int32_t>(workload.z), static_cast<int32_t>(shape.c))}));
+  RETURN_IF_ERROR(source.BindToIndex(0));
+  RETURN_IF_ERROR(destination->BindToIndex(1));
+  if (command_queue) {
+    return command_queue->Dispatch(program_, num_workgroups);
+  }
+  return program_.Dispatch(num_workgroups);
+}
+
+}  // namespace gl
+}  // namespace gpu
+}  // namespace tflite

tensorflow/lite/delegates/gpu/gl/converters/bhwc_to_phwc4.h

@@ -0,0 +1,55 @@
+/* Copyright 2019 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_LITE_DELEGATES_GPU_GL_CONVERTERS_BHWC_TO_PHWC4_H_
+#define TENSORFLOW_LITE_DELEGATES_GPU_GL_CONVERTERS_BHWC_TO_PHWC4_H_
+
+#include <utility>
+
+#include "tensorflow/lite/delegates/gpu/common/shape.h"
+#include "tensorflow/lite/delegates/gpu/common/status.h"
+#include "tensorflow/lite/delegates/gpu/common/types.h"
+#include "tensorflow/lite/delegates/gpu/gl/command_queue.h"
+#include "tensorflow/lite/delegates/gpu/gl/gl_buffer.h"
+#include "tensorflow/lite/delegates/gpu/gl/gl_program.h"
+
+namespace tflite {
+namespace gpu {
+namespace gl {
+
+class ConverterBhwcToPhwc4 {
+ public:
+  // Creates invalid object.
+  ConverterBhwcToPhwc4() : program_(), workgroup_size_() {}
+
+  static absl::Status Create(ConverterBhwcToPhwc4* converter);
+
+  absl::Status Convert(const BHWC& shape, const GlBuffer& source,
+                       CommandQueue* command_queue /* optional */,
+                       GlBuffer* destination);
+
+ private:
+  explicit ConverterBhwcToPhwc4(GlProgram program, const uint3& workgroup_size)
+      : program_(std::move(program)), workgroup_size_(workgroup_size) {}
+
+  GlProgram program_;
+  uint3 workgroup_size_;
+};
+
+}  // namespace gl
+}  // namespace gpu
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_DELEGATES_GPU_GL_CONVERTERS_BHWC_TO_PHWC4_H_

tensorflow/lite/delegates/gpu/gl/converters/bhwc_to_phwc4_test.cc

@@ -0,0 +1,94 @@
+/* Copyright 2019 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 "tensorflow/lite/delegates/gpu/gl/converters/bhwc_to_phwc4.h"
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "absl/types/span.h"
+#include "tensorflow/lite/delegates/gpu/common/convert.h"
+#include "tensorflow/lite/delegates/gpu/common/shape.h"
+#include "tensorflow/lite/delegates/gpu/common/status.h"
+#include "tensorflow/lite/delegates/gpu/gl/egl_environment.h"
+#include "tensorflow/lite/delegates/gpu/gl/gl_buffer.h"
+#include "tensorflow/lite/delegates/gpu/gl/portable_gl31.h"
+
+namespace tflite {
+namespace gpu {
+namespace gl {
+namespace {
+
+inline std::vector<float> GenerateFloats(float multiplier, int size) {
+  std::vector<float> v(size);
+  for (int i = 0; i < size; ++i) {
+    v[i] = multiplier * i * (i % 2 == 0 ? -1 : 1);
+  }
+  return v;
+}
+
+absl::Status RunTest(const BHWC& shape) {
+  // Create random input and calculate expected output for it.
+  std::vector<float> input = GenerateFloats(0.01, shape.DimensionsProduct());
+  std::vector<float> output(GetElementsSizeForPHWC4(shape), 0);
+  RETURN_IF_ERROR(
+      ConvertToPHWC4(absl::MakeConstSpan(input.data(), input.size()), shape,
+                     absl::MakeSpan(output.data(), output.size())));
+
+  std::unique_ptr<EglEnvironment> env;
+  RETURN_IF_ERROR(EglEnvironment::NewEglEnvironment(&env));
+
+  // Create input and output buffers
+  GlBuffer input_buffer;
+  RETURN_IF_ERROR(CreateReadOnlyShaderStorageBuffer(
+      absl::MakeConstSpan(input.data(), input.size()), &input_buffer));
+
+  GlBuffer output_buffer;
+  RETURN_IF_ERROR(CreateReadWriteShaderStorageBuffer<float>(
+      GetElementsSizeForPHWC4(shape), &output_buffer));
+
+  // Create converter and run it.
+  ConverterBhwcToPhwc4 converter;
+  RETURN_IF_ERROR(ConverterBhwcToPhwc4::Create(&converter));
+  RETURN_IF_ERROR(
+      converter.Convert(shape, input_buffer, nullptr, &output_buffer));
+
+  std::vector<float> converted_output(output.size(), 0);
+  RETURN_IF_ERROR(output_buffer.Read(
+      absl::MakeSpan(converted_output.data(), converted_output.size())));
+  if (output != converted_output) {
+    return absl::InternalError("Outputs don't match");
+  }
+  return absl::OkStatus();
+}
+
+TEST(HwcToPhwc4, Smoke) {
+  for (int32_t h : {1, 2, 3, 7, 20}) {
+    for (int32_t w : {1, 2, 4, 5, 11}) {
+      for (int32_t c : {1, 2, 4, 5, 8, 9}) {
+        BHWC shape(1, h, w, c);
+        EXPECT_TRUE(RunTest(shape).ok())
+            << shape.h << " " << shape.w << " " << shape.c;
+      }
+    }
+  }
+}
+
+}  // namespace
+}  // namespace gl
+}  // namespace gpu
+}  // namespace tflite

tensorflow/lite/delegates/gpu/gl/converters/phwc4_to_bhwc.cc

@@ -0,0 +1,104 @@
+/* Copyright 2019 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 "tensorflow/lite/delegates/gpu/gl/converters/phwc4_to_bhwc.h"
+
+#include <cstdint>
+#include <string>
+#include <utility>
+
+#include "tensorflow/lite/delegates/gpu/common/status.h"
+#include "tensorflow/lite/delegates/gpu/common/types.h"
+#include "tensorflow/lite/delegates/gpu/common/util.h"
+#include "tensorflow/lite/delegates/gpu/gl/converters/util.h"
+#include "tensorflow/lite/delegates/gpu/gl/gl_program.h"
+#include "tensorflow/lite/delegates/gpu/gl/gl_shader.h"
+#include "tensorflow/lite/delegates/gpu/gl/variable.h"
+
+namespace tflite {
+namespace gpu {
+namespace gl {
+
+absl::Status ConverterPhwc4ToBhwc::Create(ConverterPhwc4ToBhwc* converter) {
+  uint3 workgroup_size = uint3(4, 4, 4);
+  std::string shader_source = GetShaderHeader(workgroup_size) + R"(
+    layout(std430) buffer;
+
+    precision highp float;
+
+    layout(binding = 0) readonly buffer B0 {
+      vec4 elements[];
+    } input_data;
+
+    layout(binding = 1) writeonly buffer B1 {
+      float elements[];
+    } output_data;
+
+    uniform ivec4 sizes_;
+
+    void main() {
+      ivec3 gid = ivec3(gl_GlobalInvocationID.xyz);
+      if (gid.x >= sizes_.x || gid.y >= sizes_.y || gid.z >= sizes_.z) {
+        return;
+      }
+      output_data.elements[(gid.y * sizes_.x + gid.x) * sizes_.z + gid.z] = input_data.elements[(gid.z / 4 * sizes_.y + gid.y) * sizes_.x + gid.x][gid.z % 4];
+    })";
+
+  GlShader shader;
+  RETURN_IF_ERROR(
+      GlShader::CompileShader(GL_COMPUTE_SHADER, shader_source, &shader));
+  GlProgram program;
+  RETURN_IF_ERROR(GlProgram::CreateWithShader(shader, &program));
+  *converter = ConverterPhwc4ToBhwc(std::move(program), workgroup_size);
+  return absl::OkStatus();
+}
+
+absl::Status ConverterPhwc4ToBhwc::Convert(const BHWC& shape,
+                                           const GlBuffer& source,
+                                           CommandQueue* command_queue,
+                                           GlBuffer* destination) {
+  if (source.bytes_size() < BytesForPHWC4(shape)) {
+    return absl::InvalidArgumentError(
+        "Phwc4ToBhwc: Input data size does not match expected size.");
+  }
+  if (destination->bytes_size() < BytesForBHWC(shape)) {
+    return absl::InvalidArgumentError(
+        "Phwc4ToBhwc: output data size does not match expected size.");
+  }
+  if (shape.b != 1) {
+    return absl::UnimplementedError(
+        "Phwc4ToBhwc: Batch size is not equal to 1.");
+  }
+
+  uint3 workload = uint3(shape.w, shape.h, shape.c);
+  uint3 num_workgroups = DivideRoundUp(workload, workgroup_size_);
+
+  // TODO(akulik): simply pass workload as soon as UniformParameter
+  // supports uint3
+  RETURN_IF_ERROR(program_.SetParameter(
+      {"sizes_",
+       int4(static_cast<int32_t>(workload.x), static_cast<int32_t>(workload.y),
+            static_cast<int32_t>(workload.z), 0)}));
+  RETURN_IF_ERROR(source.BindToIndex(0));
+  RETURN_IF_ERROR(destination->BindToIndex(1));
+  if (command_queue) {
+    return command_queue->Dispatch(program_, num_workgroups);
+  }
+  return program_.Dispatch(num_workgroups);
+}
+
+}  // namespace gl
+}  // namespace gpu
+}  // namespace tflite

tensorflow/lite/delegates/gpu/gl/converters/phwc4_to_bhwc.h

@@ -0,0 +1,55 @@
+/* Copyright 2019 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_LITE_DELEGATES_GPU_GL_CONVERTERS_PHWC4_TO_BHWC_H_
+#define TENSORFLOW_LITE_DELEGATES_GPU_GL_CONVERTERS_PHWC4_TO_BHWC_H_
+
+#include <utility>
+
+#include "tensorflow/lite/delegates/gpu/common/shape.h"
+#include "tensorflow/lite/delegates/gpu/common/status.h"
+#include "tensorflow/lite/delegates/gpu/common/types.h"
+#include "tensorflow/lite/delegates/gpu/gl/command_queue.h"
+#include "tensorflow/lite/delegates/gpu/gl/gl_buffer.h"
+#include "tensorflow/lite/delegates/gpu/gl/gl_program.h"
+
+namespace tflite {
+namespace gpu {
+namespace gl {
+
+class ConverterPhwc4ToBhwc {
+ public:
+  // Creates invalid object.
+  ConverterPhwc4ToBhwc() : program_(), workgroup_size_() {}
+
+  static absl::Status Create(ConverterPhwc4ToBhwc* converter);
+
+  absl::Status Convert(const BHWC& shape, const GlBuffer& source,
+                       CommandQueue* command_queue /* optional */,
+                       GlBuffer* destination);
+
+ private:
+  explicit ConverterPhwc4ToBhwc(GlProgram program, const uint3& workgroup_size)
+      : program_(std::move(program)), workgroup_size_(workgroup_size) {}
+
+  GlProgram program_;
+  uint3 workgroup_size_;
+};
+
+}  // namespace gl
+}  // namespace gpu
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_DELEGATES_GPU_GL_CONVERTERS_PHWC4_TO_BHWC_H_

tensorflow/lite/delegates/gpu/gl/converters/phwc4_to_bhwc_test.cc

@@ -0,0 +1,95 @@
+/* Copyright 2019 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 "tensorflow/lite/delegates/gpu/gl/converters/phwc4_to_bhwc.h"
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "absl/types/span.h"
+#include "tensorflow/lite/delegates/gpu/common/convert.h"
+#include "tensorflow/lite/delegates/gpu/common/shape.h"
+#include "tensorflow/lite/delegates/gpu/common/status.h"
+#include "tensorflow/lite/delegates/gpu/gl/egl_environment.h"
+#include "tensorflow/lite/delegates/gpu/gl/gl_buffer.h"
+#include "tensorflow/lite/delegates/gpu/gl/portable_gl31.h"
+
+namespace tflite {
+namespace gpu {
+namespace gl {
+namespace {
+
+inline std::vector<float> GenerateFloats(float multiplier, int size) {
+  std::vector<float> v(size);
+  for (int i = 0; i < size; ++i) {
+    v[i] = multiplier * i * (i % 2 == 0 ? -1 : 1);
+  }
+  return v;
+}
+
+absl::Status RunTest(const BHWC& shape) {
+  // Create random input and calculate expected output for it.
+  std::vector<float> input =
+      GenerateFloats(0.01, GetElementsSizeForPHWC4(shape));
+  std::vector<float> output(shape.DimensionsProduct(), 0);
+  RETURN_IF_ERROR(
+      ConvertFromPHWC4(absl::MakeConstSpan(input.data(), input.size()), shape,
+                       absl::MakeSpan(output.data(), output.size())));
+
+  std::unique_ptr<EglEnvironment> env;
+  RETURN_IF_ERROR(EglEnvironment::NewEglEnvironment(&env));
+
+  // Create input and output buffers
+  GlBuffer input_buffer;
+  RETURN_IF_ERROR(CreateReadOnlyShaderStorageBuffer(
+      absl::MakeConstSpan(input.data(), input.size()), &input_buffer));
+
+  GlBuffer output_buffer;
+  RETURN_IF_ERROR(CreateReadWriteShaderStorageBuffer<float>(
+      shape.DimensionsProduct(), &output_buffer));
+
+  // Create converter and run it.
+  ConverterPhwc4ToBhwc converter;
+  RETURN_IF_ERROR(ConverterPhwc4ToBhwc::Create(&converter));
+  RETURN_IF_ERROR(
+      converter.Convert(shape, input_buffer, nullptr, &output_buffer));
+
+  std::vector<float> converted_output(output.size(), 0);
+  RETURN_IF_ERROR(output_buffer.Read(
+      absl::MakeSpan(converted_output.data(), converted_output.size())));
+  if (output != converted_output) {
+    return absl::InternalError("Outputs don't match");
+  }
+  return absl::OkStatus();
+}
+
+TEST(Phwc4ToHwc, Smoke) {
+  for (int32_t h : {1, 2, 3, 7, 20}) {
+    for (int32_t w : {1, 2, 4, 5, 11}) {
+      for (int32_t c : {1, 2, 4, 5, 8, 9}) {
+        BHWC shape(1, h, w, c);
+        EXPECT_TRUE(RunTest(shape).ok())
+            << shape.h << " " << shape.w << " " << shape.c;
+      }
+    }
+  }
+}
+
+}  // namespace
+}  // namespace gl
+}  // namespace gpu
+}  // namespace tflite

tensorflow/lite/delegates/gpu/gl/converters/util.h

@@ -0,0 +1,51 @@
+/* Copyright 2019 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_LITE_DELEGATES_GPU_GL_CONVERTERS_UTIL_H_
+#define TENSORFLOW_LITE_DELEGATES_GPU_GL_CONVERTERS_UTIL_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+#include "absl/strings/str_cat.h"
+#include "tensorflow/lite/delegates/gpu/common/shape.h"
+#include "tensorflow/lite/delegates/gpu/common/types.h"
+#include "tensorflow/lite/delegates/gpu/common/util.h"
+
+namespace tflite {
+namespace gpu {
+namespace gl {
+
+inline std::string GetShaderHeader(const uint3& localsize) {
+  return absl::StrCat("#version 310 es\nlayout(local_size_x = ", localsize.x,
+                      ", local_size_y = ", localsize.y,
+                      ", local_size_z = ", localsize.z, ") in;\n");
+}
+
+inline size_t BytesForPHWC4(const BHWC& shape) {
+  return static_cast<size_t>(shape.b) * shape.h * shape.w *
+         AlignByN(shape.c, 4) * sizeof(float);
+}
+
+inline size_t BytesForBHWC(const BHWC& shape) {
+  return static_cast<size_t>(shape.DimensionsProduct()) * sizeof(float);
+}
+
+}  // namespace gl
+}  // namespace gpu
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_DELEGATES_GPU_GL_CONVERTERS_UTIL_H_