Project import generated by Copybara.

GitOrigin-RevId: d073f8e21be2fcc0e503cb97c6695078b6b75310

mediapipe/calculators/image/BUILD

@@ -21,9 +21,7 @@ package(default_visibility = ["//visibility:private"])
 mediapipe_proto_library(
     name = "opencv_image_encoder_calculator_proto",
     srcs = ["opencv_image_encoder_calculator.proto"],
-    visibility = [
-        "//visibility:public",
-    ],
+    visibility = ["//visibility:public"],
     deps = [
         "//mediapipe/framework:calculator_options_proto",
         "//mediapipe/framework:calculator_proto",
@@ -64,9 +62,7 @@ mediapipe_proto_library(
 mediapipe_proto_library(
     name = "bilateral_filter_calculator_proto",
     srcs = ["bilateral_filter_calculator.proto"],
-    visibility = [
-        "//visibility:public",
-    ],
+    visibility = ["//visibility:public"],
     deps = [
         "//mediapipe/framework:calculator_options_proto",
         "//mediapipe/framework:calculator_proto",
@@ -87,9 +83,7 @@ mediapipe_proto_library(
 cc_library(
     name = "color_convert_calculator",
     srcs = ["color_convert_calculator.cc"],
-    visibility = [
-        "//visibility:public",
-    ],
+    visibility = ["//visibility:public"],
     deps = [
         "//mediapipe/framework:calculator_framework",
         "//mediapipe/framework:timestamp",
@@ -123,9 +117,7 @@ cc_library(
 cc_library(
     name = "opencv_image_encoder_calculator",
     srcs = ["opencv_image_encoder_calculator.cc"],
-    visibility = [
-        "//visibility:public",
-    ],
+    visibility = ["//visibility:public"],
     deps = [
         ":opencv_image_encoder_calculator_cc_proto",
         "//mediapipe/framework:calculator_framework",
@@ -181,9 +173,7 @@ cc_library(
 cc_library(
     name = "bilateral_filter_calculator",
     srcs = ["bilateral_filter_calculator.cc"],
-    visibility = [
-        "//visibility:public",
-    ],
+    visibility = ["//visibility:public"],
     deps = [
         ":bilateral_filter_calculator_cc_proto",
         "//mediapipe/framework:calculator_options_cc_proto",
@@ -448,7 +438,6 @@ cc_test(
         "//mediapipe/framework/port:opencv_imgcodecs",
         "//mediapipe/framework/port:opencv_imgproc",
         "//mediapipe/framework/port:parse_text_proto",
-        "//mediapipe/framework/port:status",
     ],
 )
 
@@ -467,7 +456,6 @@ cc_test(
         "//mediapipe/framework/port:opencv_imgcodecs",
         "//mediapipe/framework/port:opencv_imgproc",
         "//mediapipe/framework/port:parse_text_proto",
-        "//mediapipe/framework/port:status",
     ],
 )
 
@@ -503,6 +491,7 @@ mediapipe_proto_library(
 mediapipe_proto_library(
     name = "feature_detector_calculator_proto",
     srcs = ["feature_detector_calculator.proto"],
+    visibility = ["//visibility:public"],
     deps = [
         "//mediapipe/framework:calculator_options_proto",
         "//mediapipe/framework:calculator_proto",
@@ -528,7 +517,7 @@ cc_library(
 cc_library(
     name = "feature_detector_calculator",
     srcs = ["feature_detector_calculator.cc"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [
         ":feature_detector_calculator_cc_proto",
         "//mediapipe/framework:calculator_framework",
@@ -579,6 +568,5 @@ cc_test(
         "//mediapipe/framework/port:file_helpers",
         "//mediapipe/framework/port:gtest_main",
         "//mediapipe/framework/port:parse_text_proto",
-        "//mediapipe/framework/port:status",
     ],
 )

mediapipe/calculators/image/bilateral_filter_calculator.cc

@@ -28,11 +28,11 @@
 #include "mediapipe/framework/port/status.h"
 #include "mediapipe/framework/port/vector.h"
 
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
 #include "mediapipe/gpu/gl_calculator_helper.h"
 #include "mediapipe/gpu/gl_simple_shaders.h"
 #include "mediapipe/gpu/shader_util.h"
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
 namespace mediapipe {
 
@@ -82,18 +82,18 @@ class BilateralFilterCalculator : public CalculatorBase {
   BilateralFilterCalculator() = default;
   ~BilateralFilterCalculator() override = default;
 
-  static mediapipe::Status GetContract(CalculatorContract* cc);
+  static absl::Status GetContract(CalculatorContract* cc);
 
   // From Calculator.
-  mediapipe::Status Open(CalculatorContext* cc) override;
-  mediapipe::Status Process(CalculatorContext* cc) override;
-  mediapipe::Status Close(CalculatorContext* cc) override;
+  absl::Status Open(CalculatorContext* cc) override;
+  absl::Status Process(CalculatorContext* cc) override;
+  absl::Status Close(CalculatorContext* cc) override;
 
  private:
-  mediapipe::Status RenderGpu(CalculatorContext* cc);
-  mediapipe::Status RenderCpu(CalculatorContext* cc);
+  absl::Status RenderGpu(CalculatorContext* cc);
+  absl::Status RenderCpu(CalculatorContext* cc);
 
-  mediapipe::Status GlSetup(CalculatorContext* cc);
+  absl::Status GlSetup(CalculatorContext* cc);
   void GlRender(CalculatorContext* cc);
 
   mediapipe::BilateralFilterCalculatorOptions options_;
@@ -102,7 +102,7 @@ class BilateralFilterCalculator : public CalculatorBase {
 
   bool use_gpu_ = false;
   bool gpu_initialized_ = false;
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   mediapipe::GlCalculatorHelper gpu_helper_;
   GLuint program_ = 0;
   GLuint vao_;
@@ -111,71 +111,70 @@ class BilateralFilterCalculator : public CalculatorBase {
 };
 REGISTER_CALCULATOR(BilateralFilterCalculator);
 
-mediapipe::Status BilateralFilterCalculator::GetContract(
-    CalculatorContract* cc) {
+absl::Status BilateralFilterCalculator::GetContract(CalculatorContract* cc) {
   CHECK_GE(cc->Inputs().NumEntries(), 1);
 
   if (cc->Inputs().HasTag(kInputFrameTag) &&
       cc->Inputs().HasTag(kInputFrameTagGpu)) {
-    return mediapipe::InternalError("Cannot have multiple input images.");
+    return absl::InternalError("Cannot have multiple input images.");
   }
   if (cc->Inputs().HasTag(kInputFrameTagGpu) !=
       cc->Outputs().HasTag(kOutputFrameTagGpu)) {
-    return mediapipe::InternalError("GPU output must have GPU input.");
+    return absl::InternalError("GPU output must have GPU input.");
   }
 
   bool use_gpu = false;
 
   // Input image to filter.
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   if (cc->Inputs().HasTag(kInputFrameTagGpu)) {
     cc->Inputs().Tag(kInputFrameTagGpu).Set<mediapipe::GpuBuffer>();
     use_gpu |= true;
   }
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   if (cc->Inputs().HasTag(kInputFrameTag)) {
     cc->Inputs().Tag(kInputFrameTag).Set<ImageFrame>();
   }
 
   // Input guide image mask (optional)
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   if (cc->Inputs().HasTag(kInputGuideTagGpu)) {
     cc->Inputs().Tag(kInputGuideTagGpu).Set<mediapipe::GpuBuffer>();
     use_gpu |= true;
   }
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   if (cc->Inputs().HasTag(kInputGuideTag)) {
     cc->Inputs().Tag(kInputGuideTag).Set<ImageFrame>();
   }
 
   // Output image.
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   if (cc->Outputs().HasTag(kOutputFrameTagGpu)) {
     cc->Outputs().Tag(kOutputFrameTagGpu).Set<mediapipe::GpuBuffer>();
     use_gpu |= true;
   }
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   if (cc->Outputs().HasTag(kOutputFrameTag)) {
     cc->Outputs().Tag(kOutputFrameTag).Set<ImageFrame>();
   }
 
   if (use_gpu) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     MP_RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status BilateralFilterCalculator::Open(CalculatorContext* cc) {
+absl::Status BilateralFilterCalculator::Open(CalculatorContext* cc) {
   cc->SetOffset(TimestampDiff(0));
 
   options_ = cc->Options<mediapipe::BilateralFilterCalculatorOptions>();
 
   if (cc->Inputs().HasTag(kInputFrameTagGpu) &&
       cc->Outputs().HasTag(kOutputFrameTagGpu)) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     use_gpu_ = true;
 #else
     RET_CHECK_FAIL() << "GPU processing not enabled.";
@@ -189,36 +188,35 @@ mediapipe::Status BilateralFilterCalculator::Open(CalculatorContext* cc) {
   if (!use_gpu_) sigma_color_ *= 255.0;
 
   if (use_gpu_) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     MP_RETURN_IF_ERROR(gpu_helper_.Open(cc));
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status BilateralFilterCalculator::Process(CalculatorContext* cc) {
+absl::Status BilateralFilterCalculator::Process(CalculatorContext* cc) {
   if (use_gpu_) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
-    MP_RETURN_IF_ERROR(
-        gpu_helper_.RunInGlContext([this, cc]() -> mediapipe::Status {
-          if (!gpu_initialized_) {
-            MP_RETURN_IF_ERROR(GlSetup(cc));
-            gpu_initialized_ = true;
-          }
-          MP_RETURN_IF_ERROR(RenderGpu(cc));
-          return mediapipe::OkStatus();
-        }));
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#if !MEDIAPIPE_DISABLE_GPU
+    MP_RETURN_IF_ERROR(gpu_helper_.RunInGlContext([this, cc]() -> absl::Status {
+      if (!gpu_initialized_) {
+        MP_RETURN_IF_ERROR(GlSetup(cc));
+        gpu_initialized_ = true;
+      }
+      MP_RETURN_IF_ERROR(RenderGpu(cc));
+      return absl::OkStatus();
+    }));
+#endif  // !MEDIAPIPE_DISABLE_GPU
   } else {
     MP_RETURN_IF_ERROR(RenderCpu(cc));
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status BilateralFilterCalculator::Close(CalculatorContext* cc) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+absl::Status BilateralFilterCalculator::Close(CalculatorContext* cc) {
+#if !MEDIAPIPE_DISABLE_GPU
   gpu_helper_.RunInGlContext([this] {
     if (program_) glDeleteProgram(program_);
     if (vao_) glDeleteVertexArrays(1, &vao_);
@@ -228,14 +226,14 @@ mediapipe::Status BilateralFilterCalculator::Close(CalculatorContext* cc) {
     vbo_[0] = 0;
     vbo_[1] = 0;
   });
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status BilateralFilterCalculator::RenderCpu(CalculatorContext* cc) {
+absl::Status BilateralFilterCalculator::RenderCpu(CalculatorContext* cc) {
   if (cc->Inputs().Tag(kInputFrameTag).IsEmpty()) {
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
 
   const auto& input_frame = cc->Inputs().Tag(kInputFrameTag).Get<ImageFrame>();
@@ -243,7 +241,7 @@ mediapipe::Status BilateralFilterCalculator::RenderCpu(CalculatorContext* cc) {
 
   // Only 1 or 3 channel images supported by OpenCV.
   if ((input_mat.channels() == 1 || input_mat.channels() == 3)) {
-    return mediapipe::InternalError(
+    return absl::InternalError(
         "CPU filtering supports only 1 or 3 channel input images.");
   }
 
@@ -254,7 +252,7 @@ mediapipe::Status BilateralFilterCalculator::RenderCpu(CalculatorContext* cc) {
 
   if (has_guide_image) {
     // cv::jointBilateralFilter() is in contrib module 'ximgproc'.
-    return mediapipe::UnimplementedError(
+    return absl::UnimplementedError(
         "CPU joint filtering support is not implemented yet.");
   } else {
     auto output_mat = mediapipe::formats::MatView(output_frame.get());
@@ -266,14 +264,14 @@ mediapipe::Status BilateralFilterCalculator::RenderCpu(CalculatorContext* cc) {
   cc->Outputs()
       .Tag(kOutputFrameTag)
       .Add(output_frame.release(), cc->InputTimestamp());
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status BilateralFilterCalculator::RenderGpu(CalculatorContext* cc) {
+absl::Status BilateralFilterCalculator::RenderGpu(CalculatorContext* cc) {
   if (cc->Inputs().Tag(kInputFrameTagGpu).IsEmpty()) {
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   const auto& input_frame =
       cc->Inputs().Tag(kInputFrameTagGpu).Get<mediapipe::GpuBuffer>();
   auto input_texture = gpu_helper_.CreateSourceTexture(input_frame);
@@ -283,8 +281,7 @@ mediapipe::Status BilateralFilterCalculator::RenderGpu(CalculatorContext* cc) {
 
   // Setup textures and Update image in GPU shader.
   if (has_guide_image) {
-    if (cc->Inputs().Tag(kInputGuideTagGpu).IsEmpty())
-      return mediapipe::OkStatus();
+    if (cc->Inputs().Tag(kInputGuideTagGpu).IsEmpty()) return absl::OkStatus();
     // joint bilateral filter
     glUseProgram(program_);
     const auto& guide_image =
@@ -330,13 +327,13 @@ mediapipe::Status BilateralFilterCalculator::RenderGpu(CalculatorContext* cc) {
   // Cleanup
   input_texture.Release();
   output_texture.Release();
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 void BilateralFilterCalculator::GlRender(CalculatorContext* cc) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   // bring back vao and vbo
   glBindVertexArray(vao_);
 
@@ -345,11 +342,11 @@ void BilateralFilterCalculator::GlRender(CalculatorContext* cc) {
 
   // cleanup
   glBindVertexArray(0);
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 }
 
-mediapipe::Status BilateralFilterCalculator::GlSetup(CalculatorContext* cc) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+absl::Status BilateralFilterCalculator::GlSetup(CalculatorContext* cc) {
+#if !MEDIAPIPE_DISABLE_GPU
   const GLint attr_location[NUM_ATTRIBUTES] = {
       ATTRIB_VERTEX,
       ATTRIB_TEXTURE_POSITION,
@@ -513,9 +510,9 @@ mediapipe::Status BilateralFilterCalculator::GlSetup(CalculatorContext* cc) {
   glBindBuffer(GL_ARRAY_BUFFER, 0);
   glBindVertexArray(0);
 
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 }  // namespace mediapipe

mediapipe/calculators/image/color_convert_calculator.cc

@@ -78,12 +78,12 @@ constexpr char kGrayOutTag[] = "GRAY_OUT";
 class ColorConvertCalculator : public CalculatorBase {
  public:
   ~ColorConvertCalculator() override = default;
-  static mediapipe::Status GetContract(CalculatorContract* cc);
-  mediapipe::Status Process(CalculatorContext* cc) override;
+  static absl::Status GetContract(CalculatorContract* cc);
+  absl::Status Process(CalculatorContext* cc) override;
 
-  mediapipe::Status Open(CalculatorContext* cc) override {
+  absl::Status Open(CalculatorContext* cc) override {
     cc->SetOffset(TimestampDiff(0));
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
 
  private:
@@ -91,16 +91,16 @@ class ColorConvertCalculator : public CalculatorBase {
   // conversion. The ImageFrame on input_tag is converted using the
   // open_cv_convert_code provided and then output on the output_tag stream.
   // Note that the output_format must match the destination conversion code.
-  mediapipe::Status ConvertAndOutput(const std::string& input_tag,
-                                     const std::string& output_tag,
-                                     ImageFormat::Format output_format,
-                                     int open_cv_convert_code,
-                                     CalculatorContext* cc);
+  absl::Status ConvertAndOutput(const std::string& input_tag,
+                                const std::string& output_tag,
+                                ImageFormat::Format output_format,
+                                int open_cv_convert_code,
+                                CalculatorContext* cc);
 };
 
 REGISTER_CALCULATOR(ColorConvertCalculator);
 
-mediapipe::Status ColorConvertCalculator::GetContract(CalculatorContract* cc) {
+absl::Status ColorConvertCalculator::GetContract(CalculatorContract* cc) {
   RET_CHECK_EQ(cc->Inputs().NumEntries(), 1)
       << "Only one input stream is allowed.";
   RET_CHECK_EQ(cc->Outputs().NumEntries(), 1)
@@ -138,10 +138,10 @@ mediapipe::Status ColorConvertCalculator::GetContract(CalculatorContract* cc) {
     cc->Outputs().Tag(kBgraOutTag).Set<ImageFrame>();
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ColorConvertCalculator::ConvertAndOutput(
+absl::Status ColorConvertCalculator::ConvertAndOutput(
     const std::string& input_tag, const std::string& output_tag,
     ImageFormat::Format output_format, int open_cv_convert_code,
     CalculatorContext* cc) {
@@ -160,10 +160,10 @@ mediapipe::Status ColorConvertCalculator::ConvertAndOutput(
   cc->Outputs()
       .Tag(output_tag)
       .Add(output_frame.release(), cc->InputTimestamp());
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ColorConvertCalculator::Process(CalculatorContext* cc) {
+absl::Status ColorConvertCalculator::Process(CalculatorContext* cc) {
   // RGBA -> RGB
   if (cc->Inputs().HasTag(kRgbaInTag) && cc->Outputs().HasTag(kRgbOutTag)) {
     return ConvertAndOutput(kRgbaInTag, kRgbOutTag, ImageFormat::SRGB,

mediapipe/calculators/image/feature_detector_calculator.cc

@@ -50,10 +50,10 @@ class FeatureDetectorCalculator : public CalculatorBase {
  public:
   ~FeatureDetectorCalculator() override = default;
 
-  static mediapipe::Status GetContract(CalculatorContract* cc);
+  static absl::Status GetContract(CalculatorContract* cc);
 
-  mediapipe::Status Open(CalculatorContext* cc) override;
-  mediapipe::Status Process(CalculatorContext* cc) override;
+  absl::Status Open(CalculatorContext* cc) override;
+  absl::Status Process(CalculatorContext* cc) override;
 
  private:
   FeatureDetectorCalculatorOptions options_;
@@ -71,8 +71,7 @@ class FeatureDetectorCalculator : public CalculatorBase {
 
 REGISTER_CALCULATOR(FeatureDetectorCalculator);
 
-mediapipe::Status FeatureDetectorCalculator::GetContract(
-    CalculatorContract* cc) {
+absl::Status FeatureDetectorCalculator::GetContract(CalculatorContract* cc) {
   if (cc->Inputs().HasTag("IMAGE")) {
     cc->Inputs().Tag("IMAGE").Set<ImageFrame>();
   }
@@ -85,10 +84,10 @@ mediapipe::Status FeatureDetectorCalculator::GetContract(
   if (cc->Outputs().HasTag("PATCHES")) {
     cc->Outputs().Tag("PATCHES").Set<std::vector<TfLiteTensor>>();
   }
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status FeatureDetectorCalculator::Open(CalculatorContext* cc) {
+absl::Status FeatureDetectorCalculator::Open(CalculatorContext* cc) {
   options_ =
       tool::RetrieveOptions(cc->Options(), cc->InputSidePackets(), kOptionsTag)
           .GetExtension(FeatureDetectorCalculatorOptions::ext);
@@ -97,14 +96,14 @@ mediapipe::Status FeatureDetectorCalculator::Open(CalculatorContext* cc) {
       options_.pyramid_level(), kPatchSize - 1, 0, 2, cv::ORB::FAST_SCORE);
   pool_ = absl::make_unique<mediapipe::ThreadPool>("ThreadPool", kNumThreads);
   pool_->StartWorkers();
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status FeatureDetectorCalculator::Process(CalculatorContext* cc) {
+absl::Status FeatureDetectorCalculator::Process(CalculatorContext* cc) {
   const Timestamp& timestamp = cc->InputTimestamp();
   if (timestamp == Timestamp::PreStream()) {
     // Indicator packet.
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
   InputStream* input_frame = &(cc->Inputs().Tag("IMAGE"));
   cv::Mat input_view = formats::MatView(&input_frame->Get<ImageFrame>());
@@ -176,7 +175,7 @@ mediapipe::Status FeatureDetectorCalculator::Process(CalculatorContext* cc) {
     cc->Outputs().Tag("PATCHES").Add(patches.release(), timestamp);
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 void FeatureDetectorCalculator::ComputeImagePyramid(

mediapipe/calculators/image/image_cropping_calculator.cc

@@ -24,11 +24,11 @@
 #include "mediapipe/framework/port/ret_check.h"
 #include "mediapipe/framework/port/status.h"
 
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
 #include "mediapipe/gpu/gl_simple_shaders.h"
 #include "mediapipe/gpu/gpu_buffer.h"
 #include "mediapipe/gpu/shader_util.h"
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
 namespace {
 enum { ATTRIB_VERTEX, ATTRIB_TEXTURE_POSITION, NUM_ATTRIBUTES };
@@ -38,9 +38,9 @@ namespace mediapipe {
 
 namespace {
 
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
 
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
 constexpr char kRectTag[] = "RECT";
 constexpr char kNormRectTag[] = "NORM_RECT";
@@ -53,7 +53,7 @@ constexpr char kWidthTag[] = "WIDTH";
 
 REGISTER_CALCULATOR(ImageCroppingCalculator);
 
-mediapipe::Status ImageCroppingCalculator::GetContract(CalculatorContract* cc) {
+absl::Status ImageCroppingCalculator::GetContract(CalculatorContract* cc) {
   RET_CHECK(cc->Inputs().HasTag(kImageTag) ^ cc->Inputs().HasTag(kImageGpuTag));
   RET_CHECK(cc->Outputs().HasTag(kImageTag) ^
             cc->Outputs().HasTag(kImageGpuTag));
@@ -65,14 +65,14 @@ mediapipe::Status ImageCroppingCalculator::GetContract(CalculatorContract* cc) {
     cc->Inputs().Tag(kImageTag).Set<ImageFrame>();
     cc->Outputs().Tag(kImageTag).Set<ImageFrame>();
   }
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   if (cc->Inputs().HasTag(kImageGpuTag)) {
     RET_CHECK(cc->Outputs().HasTag(kImageGpuTag));
     cc->Inputs().Tag(kImageGpuTag).Set<GpuBuffer>();
     cc->Outputs().Tag(kImageGpuTag).Set<GpuBuffer>();
     use_gpu |= true;
   }
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
   int flags = 0;
   if (cc->Inputs().HasTag(kRectTag)) {
@@ -110,15 +110,15 @@ mediapipe::Status ImageCroppingCalculator::GetContract(CalculatorContract* cc) {
   }
 
   if (use_gpu) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     MP_RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ImageCroppingCalculator::Open(CalculatorContext* cc) {
+absl::Status ImageCroppingCalculator::Open(CalculatorContext* cc) {
   cc->SetOffset(TimestampDiff(0));
 
   if (cc->Inputs().HasTag(kImageGpuTag)) {
@@ -132,11 +132,11 @@ mediapipe::Status ImageCroppingCalculator::Open(CalculatorContext* cc) {
       options_.has_output_max_height() ? options_.output_max_height() : FLT_MAX;
 
   if (use_gpu_) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     MP_RETURN_IF_ERROR(gpu_helper_.Open(cc));
 #else
     RET_CHECK_FAIL() << "GPU processing is for Android and iOS only.";
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   }
 
   // Validate border mode.
@@ -146,56 +146,55 @@ mediapipe::Status ImageCroppingCalculator::Open(CalculatorContext* cc) {
     MP_RETURN_IF_ERROR(ValidateBorderModeForCPU(cc));
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ImageCroppingCalculator::Process(CalculatorContext* cc) {
+absl::Status ImageCroppingCalculator::Process(CalculatorContext* cc) {
   if (cc->Inputs().HasTag(kRectTag) && cc->Inputs().Tag(kRectTag).IsEmpty()) {
     VLOG(1) << "RECT is empty for timestamp: " << cc->InputTimestamp();
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
   if (cc->Inputs().HasTag(kNormRectTag) &&
       cc->Inputs().Tag(kNormRectTag).IsEmpty()) {
     VLOG(1) << "NORM_RECT is empty for timestamp: " << cc->InputTimestamp();
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
   if (use_gpu_) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
-    MP_RETURN_IF_ERROR(
-        gpu_helper_.RunInGlContext([this, cc]() -> mediapipe::Status {
-          if (!gpu_initialized_) {
-            MP_RETURN_IF_ERROR(InitGpu(cc));
-            gpu_initialized_ = true;
-          }
-          MP_RETURN_IF_ERROR(RenderGpu(cc));
-          return mediapipe::OkStatus();
-        }));
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#if !MEDIAPIPE_DISABLE_GPU
+    MP_RETURN_IF_ERROR(gpu_helper_.RunInGlContext([this, cc]() -> absl::Status {
+      if (!gpu_initialized_) {
+        MP_RETURN_IF_ERROR(InitGpu(cc));
+        gpu_initialized_ = true;
+      }
+      MP_RETURN_IF_ERROR(RenderGpu(cc));
+      return absl::OkStatus();
+    }));
+#endif  // !MEDIAPIPE_DISABLE_GPU
   } else {
     MP_RETURN_IF_ERROR(RenderCpu(cc));
   }
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ImageCroppingCalculator::Close(CalculatorContext* cc) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+absl::Status ImageCroppingCalculator::Close(CalculatorContext* cc) {
+#if !MEDIAPIPE_DISABLE_GPU
   gpu_helper_.RunInGlContext([this] {
     if (program_) glDeleteProgram(program_);
     program_ = 0;
   });
   gpu_initialized_ = false;
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ImageCroppingCalculator::ValidateBorderModeForCPU(
+absl::Status ImageCroppingCalculator::ValidateBorderModeForCPU(
     CalculatorContext* cc) {
   int border_mode;
   return GetBorderModeForOpenCV(cc, &border_mode);
 }
 
-mediapipe::Status ImageCroppingCalculator::ValidateBorderModeForGPU(
+absl::Status ImageCroppingCalculator::ValidateBorderModeForGPU(
     CalculatorContext* cc) {
   mediapipe::ImageCroppingCalculatorOptions options =
       cc->Options<mediapipe::ImageCroppingCalculatorOptions>();
@@ -212,12 +211,12 @@ mediapipe::Status ImageCroppingCalculator::ValidateBorderModeForGPU(
                        << options.border_mode();
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ImageCroppingCalculator::RenderCpu(CalculatorContext* cc) {
+absl::Status ImageCroppingCalculator::RenderCpu(CalculatorContext* cc) {
   if (cc->Inputs().Tag(kImageTag).IsEmpty()) {
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
   const auto& input_img = cc->Inputs().Tag(kImageTag).Get<ImageFrame>();
   cv::Mat input_mat = formats::MatView(&input_img);
@@ -267,14 +266,14 @@ mediapipe::Status ImageCroppingCalculator::RenderCpu(CalculatorContext* cc) {
   cropped_image.copyTo(output_mat);
   cc->Outputs().Tag(kImageTag).Add(output_frame.release(),
                                    cc->InputTimestamp());
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ImageCroppingCalculator::RenderGpu(CalculatorContext* cc) {
+absl::Status ImageCroppingCalculator::RenderGpu(CalculatorContext* cc) {
   if (cc->Inputs().Tag(kImageGpuTag).IsEmpty()) {
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   const Packet& input_packet = cc->Inputs().Tag(kImageGpuTag).Value();
   const auto& input_buffer = input_packet.Get<mediapipe::GpuBuffer>();
   auto src_tex = gpu_helper_.CreateSourceTexture(input_buffer);
@@ -305,13 +304,13 @@ mediapipe::Status ImageCroppingCalculator::RenderGpu(CalculatorContext* cc) {
   // Cleanup
   src_tex.Release();
   dst_tex.Release();
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 void ImageCroppingCalculator::GlRender() {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   static const GLfloat square_vertices[] = {
       -1.0f, -1.0f,  // bottom left
       1.0f,  -1.0f,  // bottom right
@@ -355,11 +354,11 @@ void ImageCroppingCalculator::GlRender() {
   glDeleteVertexArrays(1, &vao);
   glDeleteBuffers(2, vbo);
 
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 }
 
-mediapipe::Status ImageCroppingCalculator::InitGpu(CalculatorContext* cc) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+absl::Status ImageCroppingCalculator::InitGpu(CalculatorContext* cc) {
+#if !MEDIAPIPE_DISABLE_GPU
   const GLint attr_location[NUM_ATTRIBUTES] = {
       ATTRIB_VERTEX,
       ATTRIB_TEXTURE_POSITION,
@@ -405,9 +404,9 @@ mediapipe::Status ImageCroppingCalculator::InitGpu(CalculatorContext* cc) {
   // Parameters
   glUseProgram(program_);
   glUniform1i(glGetUniformLocation(program_, "input_frame"), 1);
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 // For GPU only.
@@ -533,7 +532,7 @@ RectSpec ImageCroppingCalculator::GetCropSpecs(const CalculatorContext* cc,
   return {crop_width, crop_height, x_center, y_center, rotation};
 }
 
-mediapipe::Status ImageCroppingCalculator::GetBorderModeForOpenCV(
+absl::Status ImageCroppingCalculator::GetBorderModeForOpenCV(
     CalculatorContext* cc, int* border_mode) {
   mediapipe::ImageCroppingCalculatorOptions options =
       cc->Options<mediapipe::ImageCroppingCalculatorOptions>();
@@ -550,7 +549,7 @@ mediapipe::Status ImageCroppingCalculator::GetBorderModeForOpenCV(
                        << options.border_mode();
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 }  // namespace mediapipe

mediapipe/calculators/image/image_cropping_calculator.h

@@ -6,9 +6,9 @@
 #include "mediapipe/calculators/image/image_cropping_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
 
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
 #include "mediapipe/gpu/gl_calculator_helper.h"
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
 // Crops the input texture to the given rectangle region. The rectangle can
 // be at arbitrary location on the image with rotation. If there's rotation, the
@@ -58,24 +58,23 @@ class ImageCroppingCalculator : public CalculatorBase {
   ImageCroppingCalculator() = default;
   ~ImageCroppingCalculator() override = default;
 
-  static mediapipe::Status GetContract(CalculatorContract* cc);
-  mediapipe::Status Open(CalculatorContext* cc) override;
-  mediapipe::Status Process(CalculatorContext* cc) override;
-  mediapipe::Status Close(CalculatorContext* cc) override;
+  static absl::Status GetContract(CalculatorContract* cc);
+  absl::Status Open(CalculatorContext* cc) override;
+  absl::Status Process(CalculatorContext* cc) override;
+  absl::Status Close(CalculatorContext* cc) override;
   static RectSpec GetCropSpecs(const CalculatorContext* cc, int src_width,
                                int src_height);
 
  private:
-  mediapipe::Status ValidateBorderModeForCPU(CalculatorContext* cc);
-  mediapipe::Status ValidateBorderModeForGPU(CalculatorContext* cc);
-  mediapipe::Status RenderCpu(CalculatorContext* cc);
-  mediapipe::Status RenderGpu(CalculatorContext* cc);
-  mediapipe::Status InitGpu(CalculatorContext* cc);
+  absl::Status ValidateBorderModeForCPU(CalculatorContext* cc);
+  absl::Status ValidateBorderModeForGPU(CalculatorContext* cc);
+  absl::Status RenderCpu(CalculatorContext* cc);
+  absl::Status RenderGpu(CalculatorContext* cc);
+  absl::Status InitGpu(CalculatorContext* cc);
   void GlRender();
   void GetOutputDimensions(CalculatorContext* cc, int src_width, int src_height,
                            int* dst_width, int* dst_height);
-  mediapipe::Status GetBorderModeForOpenCV(CalculatorContext* cc,
-                                           int* border_mode);
+  absl::Status GetBorderModeForOpenCV(CalculatorContext* cc, int* border_mode);
 
   mediapipe::ImageCroppingCalculatorOptions options_;
 
@@ -84,11 +83,11 @@ class ImageCroppingCalculator : public CalculatorBase {
   float transformed_points_[8];
   float output_max_width_ = FLT_MAX;
   float output_max_height_ = FLT_MAX;
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   bool gpu_initialized_ = false;
   mediapipe::GlCalculatorHelper gpu_helper_;
   GLuint program_ = 0;
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 };
 
 }  // namespace mediapipe

mediapipe/calculators/image/image_cropping_calculator_test.cc

@@ -59,8 +59,8 @@ TEST(ImageCroppingCalculatorTest, GetCroppingDimensionsNormal) {
   auto calculator_state = absl::make_unique<CalculatorState>(
       "Node", 0, "Calculator", calculator_node, nullptr);
   auto cc = absl::make_unique<CalculatorContext>(
-      calculator_state.get(), tool::CreateTagMap({}).ValueOrDie(),
-      tool::CreateTagMap({}).ValueOrDie());
+      calculator_state.get(), tool::CreateTagMap({}).value(),
+      tool::CreateTagMap({}).value());
 
   RectSpec expectRect = {
       .width = 60,
@@ -99,8 +99,8 @@ TEST(ImageCroppingCalculatorTest, RedundantSpecInOptions) {
   auto calculator_state = absl::make_unique<CalculatorState>(
       "Node", 0, "Calculator", calculator_node, nullptr);
   auto cc = absl::make_unique<CalculatorContext>(
-      calculator_state.get(), tool::CreateTagMap({}).ValueOrDie(),
-      tool::CreateTagMap({}).ValueOrDie());
+      calculator_state.get(), tool::CreateTagMap({}).value(),
+      tool::CreateTagMap({}).value());
   RectSpec expectRect = {
       .width = 50,
       .height = 50,
@@ -144,9 +144,9 @@ TEST(ImageCroppingCalculatorTest, RedundantSpectWithInputStream) {
                                           "HEIGHT:0:crop_height",
                                           "WIDTH:0:crop_width",
                                       })
-                       .ValueOrDie();
+                       .value();
   auto cc = absl::make_unique<CalculatorContext>(
-      calculator_state.get(), inputTags, tool::CreateTagMap({}).ValueOrDie());
+      calculator_state.get(), inputTags, tool::CreateTagMap({}).value());
   auto& inputs = cc->Inputs();
   inputs.Tag(kHeightTag).Value() = MakePacket<int>(1);
   inputs.Tag(kWidthTag).Value() = MakePacket<int>(1);
@@ -191,9 +191,9 @@ TEST(ImageCroppingCalculatorTest, RedundantSpecWithInputStream) {
   auto inputTags = tool::CreateTagMap({
                                           "RECT:0:rect",
                                       })
-                       .ValueOrDie();
+                       .value();
   auto cc = absl::make_unique<CalculatorContext>(
-      calculator_state.get(), inputTags, tool::CreateTagMap({}).ValueOrDie());
+      calculator_state.get(), inputTags, tool::CreateTagMap({}).value());
   auto& inputs = cc->Inputs();
   mediapipe::Rect rect = ParseTextProtoOrDie<mediapipe::Rect>(
       R"(

mediapipe/calculators/image/image_file_properties_calculator.cc

@@ -28,24 +28,24 @@ namespace {
 // sqrt(36^2 + 24^2).
 static const double SENSOR_DIAGONAL_35MM = std::sqrt(1872.0);
 
-mediapipe::StatusOr<double> ComputeFocalLengthInPixels(int image_width,
-                                                       int image_height,
-                                                       double focal_length_35mm,
-                                                       double focal_length_mm) {
+absl::StatusOr<double> ComputeFocalLengthInPixels(int image_width,
+                                                  int image_height,
+                                                  double focal_length_35mm,
+                                                  double focal_length_mm) {
   // TODO: Allow returning image file properties even when focal length
   // computation is not possible.
   if (image_width == 0 || image_height == 0) {
-    return mediapipe::InternalError(
+    return absl::InternalError(
         "Image dimensions should be non-zero to compute focal length in "
         "pixels.");
   }
   if (focal_length_mm == 0) {
-    return mediapipe::InternalError(
+    return absl::InternalError(
         "Focal length in mm should be non-zero to compute focal length in "
         "pixels.");
   }
   if (focal_length_35mm == 0) {
-    return mediapipe::InternalError(
+    return absl::InternalError(
         "Focal length in 35 mm should be non-zero to compute focal length in "
         "pixels.");
   }
@@ -77,13 +77,13 @@ mediapipe::StatusOr<double> ComputeFocalLengthInPixels(int image_width,
   return focal_length_pixels;
 }
 
-mediapipe::StatusOr<ImageFileProperties> GetImageFileProperites(
+absl::StatusOr<ImageFileProperties> GetImageFileProperites(
     const std::string& image_bytes) {
   easyexif::EXIFInfo result;
   int code = result.parseFrom(image_bytes);
   if (code) {
-    return mediapipe::InternalError("Error parsing EXIF, code: " +
-                                    std::to_string(code));
+    return absl::InternalError("Error parsing EXIF, code: " +
+                               std::to_string(code));
   }
 
   ImageFileProperties properties;
@@ -126,7 +126,7 @@ mediapipe::StatusOr<ImageFileProperties> GetImageFileProperites(
 // }
 class ImageFilePropertiesCalculator : public CalculatorBase {
  public:
-  static mediapipe::Status GetContract(CalculatorContract* cc) {
+  static absl::Status GetContract(CalculatorContract* cc) {
     if (cc->Inputs().NumEntries() != 0) {
       RET_CHECK(cc->Inputs().NumEntries() == 1);
       cc->Inputs().Index(0).Set<std::string>();
@@ -142,10 +142,10 @@ class ImageFilePropertiesCalculator : public CalculatorBase {
       cc->OutputSidePackets().Index(0).Set<::mediapipe::ImageFileProperties>();
     }
 
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
 
-  mediapipe::Status Open(CalculatorContext* cc) override {
+  absl::Status Open(CalculatorContext* cc) override {
     cc->SetOffset(TimestampDiff(0));
 
     if (cc->InputSidePackets().NumEntries() == 1) {
@@ -160,13 +160,13 @@ class ImageFilePropertiesCalculator : public CalculatorBase {
           MakePacket<ImageFileProperties>(properties_));
     }
 
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
 
-  mediapipe::Status Process(CalculatorContext* cc) override {
+  absl::Status Process(CalculatorContext* cc) override {
     if (cc->Inputs().NumEntries() == 1) {
       if (cc->Inputs().Index(0).IsEmpty()) {
-        return mediapipe::OkStatus();
+        return absl::OkStatus();
       }
       const std::string& image_bytes = cc->Inputs().Index(0).Get<std::string>();
       ASSIGN_OR_RETURN(properties_, GetImageFileProperites(image_bytes));
@@ -184,7 +184,7 @@ class ImageFilePropertiesCalculator : public CalculatorBase {
       }
     }
 
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
 
  private:

mediapipe/calculators/image/image_properties_calculator.cc

@@ -15,9 +15,9 @@
 #include "mediapipe/framework/calculator_framework.h"
 #include "mediapipe/framework/formats/image_frame.h"
 
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
 #include "mediapipe/gpu/gpu_buffer.h"
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
 namespace {
 constexpr char kImageFrameTag[] = "IMAGE";
@@ -44,31 +44,31 @@ namespace mediapipe {
 // }
 class ImagePropertiesCalculator : public CalculatorBase {
  public:
-  static mediapipe::Status GetContract(CalculatorContract* cc) {
+  static absl::Status GetContract(CalculatorContract* cc) {
     RET_CHECK(cc->Inputs().HasTag(kImageFrameTag) ^
               cc->Inputs().HasTag(kGpuBufferTag));
     if (cc->Inputs().HasTag(kImageFrameTag)) {
       cc->Inputs().Tag(kImageFrameTag).Set<ImageFrame>();
     }
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     if (cc->Inputs().HasTag(kGpuBufferTag)) {
       cc->Inputs().Tag(kGpuBufferTag).Set<::mediapipe::GpuBuffer>();
     }
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
     if (cc->Outputs().HasTag("SIZE")) {
       cc->Outputs().Tag("SIZE").Set<std::pair<int, int>>();
     }
 
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
 
-  mediapipe::Status Open(CalculatorContext* cc) override {
+  absl::Status Open(CalculatorContext* cc) override {
     cc->SetOffset(TimestampDiff(0));
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
 
-  mediapipe::Status Process(CalculatorContext* cc) override {
+  absl::Status Process(CalculatorContext* cc) override {
     int width;
     int height;
 
@@ -78,7 +78,7 @@ class ImagePropertiesCalculator : public CalculatorBase {
       width = image.Width();
       height = image.Height();
     }
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     if (cc->Inputs().HasTag(kGpuBufferTag) &&
         !cc->Inputs().Tag(kGpuBufferTag).IsEmpty()) {
       const auto& image =
@@ -86,13 +86,13 @@ class ImagePropertiesCalculator : public CalculatorBase {
       width = image.width();
       height = image.height();
     }
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
     cc->Outputs().Tag("SIZE").AddPacket(
         MakePacket<std::pair<int, int>>(width, height)
             .At(cc->InputTimestamp()));
 
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
 };
 REGISTER_CALCULATOR(ImagePropertiesCalculator);

mediapipe/calculators/image/image_transformation_calculator.cc

@@ -22,12 +22,12 @@
 #include "mediapipe/framework/port/status.h"
 #include "mediapipe/gpu/scale_mode.pb.h"
 
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
 #include "mediapipe/gpu/gl_calculator_helper.h"
 #include "mediapipe/gpu/gl_quad_renderer.h"
 #include "mediapipe/gpu/gl_simple_shaders.h"
 #include "mediapipe/gpu/shader_util.h"
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
 #if defined(__ANDROID__)
 // The size of Java arrays is dynamic, which makes it difficult to
@@ -42,9 +42,9 @@ typedef int DimensionsPacketType[2];
 
 namespace mediapipe {
 
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
 
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
 namespace {
 constexpr char kImageFrameTag[] = "IMAGE";
@@ -163,16 +163,16 @@ class ImageTransformationCalculator : public CalculatorBase {
   ImageTransformationCalculator() = default;
   ~ImageTransformationCalculator() override = default;
 
-  static mediapipe::Status GetContract(CalculatorContract* cc);
+  static absl::Status GetContract(CalculatorContract* cc);
 
-  mediapipe::Status Open(CalculatorContext* cc) override;
-  mediapipe::Status Process(CalculatorContext* cc) override;
-  mediapipe::Status Close(CalculatorContext* cc) override;
+  absl::Status Open(CalculatorContext* cc) override;
+  absl::Status Process(CalculatorContext* cc) override;
+  absl::Status Close(CalculatorContext* cc) override;
 
  private:
-  mediapipe::Status RenderCpu(CalculatorContext* cc);
-  mediapipe::Status RenderGpu(CalculatorContext* cc);
-  mediapipe::Status GlSetup();
+  absl::Status RenderCpu(CalculatorContext* cc);
+  absl::Status RenderGpu(CalculatorContext* cc);
+  absl::Status GlSetup();
 
   void ComputeOutputDimensions(int input_width, int input_height,
                                int* output_width, int* output_height);
@@ -189,17 +189,17 @@ class ImageTransformationCalculator : public CalculatorBase {
   bool flip_vertically_ = false;
 
   bool use_gpu_ = false;
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   GlCalculatorHelper gpu_helper_;
   std::unique_ptr<QuadRenderer> rgb_renderer_;
   std::unique_ptr<QuadRenderer> yuv_renderer_;
   std::unique_ptr<QuadRenderer> ext_rgb_renderer_;
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 };
 REGISTER_CALCULATOR(ImageTransformationCalculator);
 
 // static
-mediapipe::Status ImageTransformationCalculator::GetContract(
+absl::Status ImageTransformationCalculator::GetContract(
     CalculatorContract* cc) {
   // Only one input can be set, and the output type must match.
   RET_CHECK(cc->Inputs().HasTag(kImageFrameTag) ^
@@ -212,14 +212,14 @@ mediapipe::Status ImageTransformationCalculator::GetContract(
     cc->Inputs().Tag(kImageFrameTag).Set<ImageFrame>();
     cc->Outputs().Tag(kImageFrameTag).Set<ImageFrame>();
   }
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   if (cc->Inputs().HasTag(kGpuBufferTag)) {
     RET_CHECK(cc->Outputs().HasTag(kGpuBufferTag));
     cc->Inputs().Tag(kGpuBufferTag).Set<GpuBuffer>();
     cc->Outputs().Tag(kGpuBufferTag).Set<GpuBuffer>();
     use_gpu |= true;
   }
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
   if (cc->Inputs().HasTag("ROTATION_DEGREES")) {
     cc->Inputs().Tag("ROTATION_DEGREES").Set<int>();
@@ -249,15 +249,15 @@ mediapipe::Status ImageTransformationCalculator::GetContract(
   }
 
   if (use_gpu) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     MP_RETURN_IF_ERROR(GlCalculatorHelper::UpdateContract(cc));
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ImageTransformationCalculator::Open(CalculatorContext* cc) {
+absl::Status ImageTransformationCalculator::Open(CalculatorContext* cc) {
   // Inform the framework that we always output at the same timestamp
   // as we receive a packet at.
   cc->SetOffset(TimestampDiff(0));
@@ -303,19 +303,18 @@ mediapipe::Status ImageTransformationCalculator::Open(CalculatorContext* cc) {
   scale_mode_ = ParseScaleMode(options_.scale_mode(), DEFAULT_SCALE_MODE);
 
   if (use_gpu_) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     // Let the helper access the GL context information.
     MP_RETURN_IF_ERROR(gpu_helper_.Open(cc));
 #else
     RET_CHECK_FAIL() << "GPU processing not enabled.";
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ImageTransformationCalculator::Process(
-    CalculatorContext* cc) {
+absl::Status ImageTransformationCalculator::Process(CalculatorContext* cc) {
   // Override values if specified so.
   if (cc->Inputs().HasTag("ROTATION_DEGREES") &&
       !cc->Inputs().Tag("ROTATION_DEGREES").IsEmpty()) {
@@ -332,25 +331,25 @@ mediapipe::Status ImageTransformationCalculator::Process(
   }
 
   if (use_gpu_) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     if (cc->Inputs().Tag(kGpuBufferTag).IsEmpty()) {
-      return mediapipe::OkStatus();
+      return absl::OkStatus();
     }
     return gpu_helper_.RunInGlContext(
-        [this, cc]() -> mediapipe::Status { return RenderGpu(cc); });
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+        [this, cc]() -> absl::Status { return RenderGpu(cc); });
+#endif  // !MEDIAPIPE_DISABLE_GPU
   } else {
     if (cc->Inputs().Tag(kImageFrameTag).IsEmpty()) {
-      return mediapipe::OkStatus();
+      return absl::OkStatus();
     }
     return RenderCpu(cc);
   }
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ImageTransformationCalculator::Close(CalculatorContext* cc) {
+absl::Status ImageTransformationCalculator::Close(CalculatorContext* cc) {
   if (use_gpu_) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     QuadRenderer* rgb_renderer = rgb_renderer_.release();
     QuadRenderer* yuv_renderer = yuv_renderer_.release();
     QuadRenderer* ext_rgb_renderer = ext_rgb_renderer_.release();
@@ -368,14 +367,13 @@ mediapipe::Status ImageTransformationCalculator::Close(CalculatorContext* cc) {
         delete yuv_renderer;
       }
     });
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ImageTransformationCalculator::RenderCpu(
-    CalculatorContext* cc) {
+absl::Status ImageTransformationCalculator::RenderCpu(CalculatorContext* cc) {
   cv::Mat input_mat;
   mediapipe::ImageFormat::Format format;
 
@@ -479,12 +477,11 @@ mediapipe::Status ImageTransformationCalculator::RenderCpu(
       .Tag(kImageFrameTag)
       .Add(output_frame.release(), cc->InputTimestamp());
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ImageTransformationCalculator::RenderGpu(
-    CalculatorContext* cc) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+absl::Status ImageTransformationCalculator::RenderGpu(CalculatorContext* cc) {
+#if !MEDIAPIPE_DISABLE_GPU
   const auto& input = cc->Inputs().Tag(kGpuBufferTag).Get<GpuBuffer>();
   const int input_width = input.width();
   const int input_height = input.height();
@@ -567,9 +564,9 @@ mediapipe::Status ImageTransformationCalculator::RenderGpu(
   auto output = dst.template GetFrame<GpuBuffer>();
   cc->Outputs().Tag(kGpuBufferTag).Add(output.release(), cc->InputTimestamp());
 
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 void ImageTransformationCalculator::ComputeOutputDimensions(

mediapipe/calculators/image/luminance_calculator.cc

@@ -26,10 +26,9 @@ namespace mediapipe {
 // See GlSimpleCalculatorBase for inputs, outputs and input side packets.
 class LuminanceCalculator : public GlSimpleCalculator {
  public:
-  mediapipe::Status GlSetup() override;
-  mediapipe::Status GlRender(const GlTexture& src,
-                             const GlTexture& dst) override;
-  mediapipe::Status GlTeardown() override;
+  absl::Status GlSetup() override;
+  absl::Status GlRender(const GlTexture& src, const GlTexture& dst) override;
+  absl::Status GlTeardown() override;
 
  private:
   GLuint program_ = 0;
@@ -37,7 +36,7 @@ class LuminanceCalculator : public GlSimpleCalculator {
 };
 REGISTER_CALCULATOR(LuminanceCalculator);
 
-mediapipe::Status LuminanceCalculator::GlSetup() {
+absl::Status LuminanceCalculator::GlSetup() {
   // Load vertex and fragment shaders
   const GLint attr_location[NUM_ATTRIBUTES] = {
       ATTRIB_VERTEX,
@@ -83,11 +82,11 @@ mediapipe::Status LuminanceCalculator::GlSetup() {
                    (const GLchar**)&attr_name[0], attr_location, &program_);
   RET_CHECK(program_) << "Problem initializing the program.";
   frame_ = glGetUniformLocation(program_, "video_frame");
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status LuminanceCalculator::GlRender(const GlTexture& src,
-                                                const GlTexture& dst) {
+absl::Status LuminanceCalculator::GlRender(const GlTexture& src,
+                                           const GlTexture& dst) {
   static const GLfloat square_vertices[] = {
       -1.0f, -1.0f,  // bottom left
       1.0f,  -1.0f,  // bottom right
@@ -137,15 +136,15 @@ mediapipe::Status LuminanceCalculator::GlRender(const GlTexture& src,
   glDeleteVertexArrays(1, &vao);
   glDeleteBuffers(2, vbo);
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status LuminanceCalculator::GlTeardown() {
+absl::Status LuminanceCalculator::GlTeardown() {
   if (program_) {
     glDeleteProgram(program_);
     program_ = 0;
   }
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 }  // namespace mediapipe

mediapipe/calculators/image/mask_overlay_calculator.cc

@@ -52,14 +52,14 @@ class MaskOverlayCalculator : public CalculatorBase {
   MaskOverlayCalculator() {}
   ~MaskOverlayCalculator();
 
-  static mediapipe::Status GetContract(CalculatorContract* cc);
+  static absl::Status GetContract(CalculatorContract* cc);
 
-  mediapipe::Status Open(CalculatorContext* cc) override;
-  mediapipe::Status Process(CalculatorContext* cc) override;
+  absl::Status Open(CalculatorContext* cc) override;
+  absl::Status Process(CalculatorContext* cc) override;
 
-  mediapipe::Status GlSetup(
+  absl::Status GlSetup(
       const MaskOverlayCalculatorOptions::MaskChannel mask_channel);
-  mediapipe::Status GlRender(const float mask_const);
+  absl::Status GlRender(const float mask_const);
 
  private:
   GlCalculatorHelper helper_;
@@ -73,7 +73,7 @@ class MaskOverlayCalculator : public CalculatorBase {
 REGISTER_CALCULATOR(MaskOverlayCalculator);
 
 // static
-mediapipe::Status MaskOverlayCalculator::GetContract(CalculatorContract* cc) {
+absl::Status MaskOverlayCalculator::GetContract(CalculatorContract* cc) {
   MP_RETURN_IF_ERROR(GlCalculatorHelper::UpdateContract(cc));
   cc->Inputs().Get("VIDEO", 0).Set<GpuBuffer>();
   cc->Inputs().Get("VIDEO", 1).Set<GpuBuffer>();
@@ -82,13 +82,13 @@ mediapipe::Status MaskOverlayCalculator::GetContract(CalculatorContract* cc) {
   else if (cc->Inputs().HasTag("CONST_MASK"))
     cc->Inputs().Tag("CONST_MASK").Set<float>();
   else
-    return mediapipe::Status(mediapipe::StatusCode::kNotFound,
-                             "At least one mask input stream must be present.");
+    return absl::Status(absl::StatusCode::kNotFound,
+                        "At least one mask input stream must be present.");
   cc->Outputs().Tag("OUTPUT").Set<GpuBuffer>();
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status MaskOverlayCalculator::Open(CalculatorContext* cc) {
+absl::Status MaskOverlayCalculator::Open(CalculatorContext* cc) {
   cc->SetOffset(TimestampDiff(0));
   if (cc->Inputs().HasTag("MASK")) {
     use_mask_tex_ = true;
@@ -96,8 +96,8 @@ mediapipe::Status MaskOverlayCalculator::Open(CalculatorContext* cc) {
   return helper_.Open(cc);
 }
 
-mediapipe::Status MaskOverlayCalculator::Process(CalculatorContext* cc) {
-  return helper_.RunInGlContext([this, &cc]() -> mediapipe::Status {
+absl::Status MaskOverlayCalculator::Process(CalculatorContext* cc) {
+  return helper_.RunInGlContext([this, &cc]() -> absl::Status {
     if (!initialized_) {
       const auto& options = cc->Options<MaskOverlayCalculatorOptions>();
       const auto mask_channel = options.mask_channel();
@@ -115,7 +115,7 @@ mediapipe::Status MaskOverlayCalculator::Process(CalculatorContext* cc) {
 
     if (mask_packet.IsEmpty()) {
       cc->Outputs().Tag("OUTPUT").AddPacket(input1_packet);
-      return mediapipe::OkStatus();
+      return absl::OkStatus();
     }
 
     const auto& input0_buffer = cc->Inputs().Get("VIDEO", 0).Get<GpuBuffer>();
@@ -172,11 +172,11 @@ mediapipe::Status MaskOverlayCalculator::Process(CalculatorContext* cc) {
     dst.Release();
 
     cc->Outputs().Tag("OUTPUT").Add(output.release(), cc->InputTimestamp());
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   });
 }
 
-mediapipe::Status MaskOverlayCalculator::GlSetup(
+absl::Status MaskOverlayCalculator::GlSetup(
     const MaskOverlayCalculatorOptions::MaskChannel mask_channel) {
   // Load vertex and fragment shaders
   const GLint attr_location[NUM_ATTRIBUTES] = {
@@ -247,10 +247,10 @@ mediapipe::Status MaskOverlayCalculator::GlSetup(
   unif_frame1_ = glGetUniformLocation(program_, "frame1");
   unif_frame2_ = glGetUniformLocation(program_, "frame2");
   unif_mask_ = glGetUniformLocation(program_, "mask");
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status MaskOverlayCalculator::GlRender(const float mask_const) {
+absl::Status MaskOverlayCalculator::GlRender(const float mask_const) {
   glUseProgram(program_);
   glVertexAttribPointer(ATTRIB_VERTEX, 2, GL_FLOAT, 0, 0, kBasicSquareVertices);
   glEnableVertexAttribArray(ATTRIB_VERTEX);
@@ -266,7 +266,7 @@ mediapipe::Status MaskOverlayCalculator::GlRender(const float mask_const) {
     glUniform1f(unif_mask_, mask_const);
 
   glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 MaskOverlayCalculator::~MaskOverlayCalculator() {

mediapipe/calculators/image/opencv_encoded_image_to_image_frame_calculator.cc

@@ -34,29 +34,29 @@ namespace mediapipe {
 // }
 class OpenCvEncodedImageToImageFrameCalculator : public CalculatorBase {
  public:
-  static mediapipe::Status GetContract(CalculatorContract* cc);
-  mediapipe::Status Open(CalculatorContext* cc) override;
-  mediapipe::Status Process(CalculatorContext* cc) override;
+  static absl::Status GetContract(CalculatorContract* cc);
+  absl::Status Open(CalculatorContext* cc) override;
+  absl::Status Process(CalculatorContext* cc) override;
 
  private:
   mediapipe::OpenCvEncodedImageToImageFrameCalculatorOptions options_;
 };
 
-mediapipe::Status OpenCvEncodedImageToImageFrameCalculator::GetContract(
+absl::Status OpenCvEncodedImageToImageFrameCalculator::GetContract(
     CalculatorContract* cc) {
   cc->Inputs().Index(0).Set<std::string>();
   cc->Outputs().Index(0).Set<ImageFrame>();
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status OpenCvEncodedImageToImageFrameCalculator::Open(
+absl::Status OpenCvEncodedImageToImageFrameCalculator::Open(
     CalculatorContext* cc) {
   options_ =
       cc->Options<mediapipe::OpenCvEncodedImageToImageFrameCalculatorOptions>();
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status OpenCvEncodedImageToImageFrameCalculator::Process(
+absl::Status OpenCvEncodedImageToImageFrameCalculator::Process(
     CalculatorContext* cc) {
   const std::string& contents = cc->Inputs().Index(0).Get<std::string>();
   const std::vector<char> contents_vector(contents.begin(), contents.end());
@@ -84,8 +84,9 @@ mediapipe::Status OpenCvEncodedImageToImageFrameCalculator::Process(
       cv::cvtColor(decoded_mat, output_mat, cv::COLOR_BGR2RGB);
       break;
     case 4:
-      return mediapipe::UnimplementedErrorBuilder(MEDIAPIPE_LOC)
-             << "4-channel image isn't supported yet";
+      image_format = ImageFormat::SRGBA;
+      cv::cvtColor(decoded_mat, output_mat, cv::COLOR_BGR2RGBA);
+      break;
     default:
       return mediapipe::FailedPreconditionErrorBuilder(MEDIAPIPE_LOC)
              << "Unsupported number of channels: " << decoded_mat.channels();
@@ -95,7 +96,7 @@ mediapipe::Status OpenCvEncodedImageToImageFrameCalculator::Process(
       ImageFrame::kGlDefaultAlignmentBoundary);
   output_mat.copyTo(formats::MatView(output_frame.get()));
   cc->Outputs().Index(0).Add(output_frame.release(), cc->InputTimestamp());
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 REGISTER_CALCULATOR(OpenCvEncodedImageToImageFrameCalculator);

mediapipe/calculators/image/opencv_image_encoder_calculator.cc

@@ -38,29 +38,28 @@ namespace mediapipe {
 // }
 class OpenCvImageEncoderCalculator : public CalculatorBase {
  public:
-  static mediapipe::Status GetContract(CalculatorContract* cc);
-  mediapipe::Status Open(CalculatorContext* cc) override;
-  mediapipe::Status Process(CalculatorContext* cc) override;
-  mediapipe::Status Close(CalculatorContext* cc) override;
+  static absl::Status GetContract(CalculatorContract* cc);
+  absl::Status Open(CalculatorContext* cc) override;
+  absl::Status Process(CalculatorContext* cc) override;
+  absl::Status Close(CalculatorContext* cc) override;
 
  private:
   int encoding_quality_;
 };
 
-mediapipe::Status OpenCvImageEncoderCalculator::GetContract(
-    CalculatorContract* cc) {
+absl::Status OpenCvImageEncoderCalculator::GetContract(CalculatorContract* cc) {
   cc->Inputs().Index(0).Set<ImageFrame>();
   cc->Outputs().Index(0).Set<OpenCvImageEncoderCalculatorResults>();
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status OpenCvImageEncoderCalculator::Open(CalculatorContext* cc) {
+absl::Status OpenCvImageEncoderCalculator::Open(CalculatorContext* cc) {
   auto options = cc->Options<OpenCvImageEncoderCalculatorOptions>();
   encoding_quality_ = options.quality();
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status OpenCvImageEncoderCalculator::Process(CalculatorContext* cc) {
+absl::Status OpenCvImageEncoderCalculator::Process(CalculatorContext* cc) {
   const ImageFrame& image_frame = cc->Inputs().Index(0).Get<ImageFrame>();
   CHECK_EQ(1, image_frame.ByteDepth());
 
@@ -104,15 +103,14 @@ mediapipe::Status OpenCvImageEncoderCalculator::Process(CalculatorContext* cc) {
            << "Fail to encode the image to be jpeg format.";
   }
 
-  encoded_result->set_encoded_image(std::string(absl::string_view(
-      reinterpret_cast<const char*>(&encode_buffer[0]), encode_buffer.size())));
+  encoded_result->set_encoded_image(&encode_buffer[0], encode_buffer.size());
 
   cc->Outputs().Index(0).Add(encoded_result.release(), cc->InputTimestamp());
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status OpenCvImageEncoderCalculator::Close(CalculatorContext* cc) {
-  return mediapipe::OkStatus();
+absl::Status OpenCvImageEncoderCalculator::Close(CalculatorContext* cc) {
+  return absl::OkStatus();
 }
 
 REGISTER_CALCULATOR(OpenCvImageEncoderCalculator);

mediapipe/calculators/image/opencv_image_encoder_calculator.proto

@@ -29,11 +29,13 @@ message OpenCvImageEncoderCalculatorOptions {
 
 // TODO: Consider renaming it to EncodedImage.
 message OpenCvImageEncoderCalculatorResults {
-  // Encoded image
-  optional string encoded_image = 1;
+  // Pixel data encoded as JPEG.
+  optional bytes encoded_image = 1;
 
-  // Dimensions of the encoded image
+  // Height of the image data under #1 once decoded.
   optional int32 height = 2;
+
+  // Width of the image data under #1 once decoded.
   optional int32 width = 3;
 
   enum ColorSpace {

mediapipe/calculators/image/opencv_put_text_calculator.cc

@@ -32,17 +32,17 @@ namespace mediapipe {
 // TODO: Generalize the calculator for other text use cases.
 class OpenCvPutTextCalculator : public CalculatorBase {
  public:
-  static mediapipe::Status GetContract(CalculatorContract* cc);
-  mediapipe::Status Process(CalculatorContext* cc) override;
+  static absl::Status GetContract(CalculatorContract* cc);
+  absl::Status Process(CalculatorContext* cc) override;
 };
 
-mediapipe::Status OpenCvPutTextCalculator::GetContract(CalculatorContract* cc) {
+absl::Status OpenCvPutTextCalculator::GetContract(CalculatorContract* cc) {
   cc->Inputs().Index(0).Set<std::string>();
   cc->Outputs().Index(0).Set<ImageFrame>();
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status OpenCvPutTextCalculator::Process(CalculatorContext* cc) {
+absl::Status OpenCvPutTextCalculator::Process(CalculatorContext* cc) {
   const std::string& text_content = cc->Inputs().Index(0).Get<std::string>();
   cv::Mat mat = cv::Mat::zeros(640, 640, CV_8UC4);
   cv::putText(mat, text_content, cv::Point(15, 70), cv::FONT_HERSHEY_PLAIN, 3,
@@ -51,7 +51,7 @@ mediapipe::Status OpenCvPutTextCalculator::Process(CalculatorContext* cc) {
       ImageFormat::SRGBA, mat.size().width, mat.size().height);
   mat.copyTo(formats::MatView(output_frame.get()));
   cc->Outputs().Index(0).Add(output_frame.release(), cc->InputTimestamp());
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 REGISTER_CALCULATOR(OpenCvPutTextCalculator);

mediapipe/calculators/image/recolor_calculator.cc

@@ -24,11 +24,11 @@
 #include "mediapipe/framework/port/status.h"
 #include "mediapipe/util/color.pb.h"
 
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
 #include "mediapipe/gpu/gl_calculator_helper.h"
 #include "mediapipe/gpu/gl_simple_shaders.h"
 #include "mediapipe/gpu/shader_util.h"
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
 namespace {
 enum { ATTRIB_VERTEX, ATTRIB_TEXTURE_POSITION, NUM_ATTRIBUTES };
@@ -84,17 +84,17 @@ class RecolorCalculator : public CalculatorBase {
   RecolorCalculator() = default;
   ~RecolorCalculator() override = default;
 
-  static mediapipe::Status GetContract(CalculatorContract* cc);
+  static absl::Status GetContract(CalculatorContract* cc);
 
-  mediapipe::Status Open(CalculatorContext* cc) override;
-  mediapipe::Status Process(CalculatorContext* cc) override;
-  mediapipe::Status Close(CalculatorContext* cc) override;
+  absl::Status Open(CalculatorContext* cc) override;
+  absl::Status Process(CalculatorContext* cc) override;
+  absl::Status Close(CalculatorContext* cc) override;
 
  private:
-  mediapipe::Status LoadOptions(CalculatorContext* cc);
-  mediapipe::Status InitGpu(CalculatorContext* cc);
-  mediapipe::Status RenderGpu(CalculatorContext* cc);
-  mediapipe::Status RenderCpu(CalculatorContext* cc);
+  absl::Status LoadOptions(CalculatorContext* cc);
+  absl::Status InitGpu(CalculatorContext* cc);
+  absl::Status RenderGpu(CalculatorContext* cc);
+  absl::Status RenderCpu(CalculatorContext* cc);
   void GlRender();
 
   bool initialized_ = false;
@@ -102,46 +102,46 @@ class RecolorCalculator : public CalculatorBase {
   mediapipe::RecolorCalculatorOptions::MaskChannel mask_channel_;
 
   bool use_gpu_ = false;
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   mediapipe::GlCalculatorHelper gpu_helper_;
   GLuint program_ = 0;
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 };
 REGISTER_CALCULATOR(RecolorCalculator);
 
 // static
-mediapipe::Status RecolorCalculator::GetContract(CalculatorContract* cc) {
+absl::Status RecolorCalculator::GetContract(CalculatorContract* cc) {
   RET_CHECK(!cc->Inputs().GetTags().empty());
   RET_CHECK(!cc->Outputs().GetTags().empty());
 
   bool use_gpu = false;
 
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   if (cc->Inputs().HasTag(kGpuBufferTag)) {
     cc->Inputs().Tag(kGpuBufferTag).Set<mediapipe::GpuBuffer>();
     use_gpu |= true;
   }
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   if (cc->Inputs().HasTag(kImageFrameTag)) {
     cc->Inputs().Tag(kImageFrameTag).Set<ImageFrame>();
   }
 
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   if (cc->Inputs().HasTag(kMaskGpuTag)) {
     cc->Inputs().Tag(kMaskGpuTag).Set<mediapipe::GpuBuffer>();
     use_gpu |= true;
   }
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   if (cc->Inputs().HasTag(kMaskCpuTag)) {
     cc->Inputs().Tag(kMaskCpuTag).Set<ImageFrame>();
   }
 
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   if (cc->Outputs().HasTag(kGpuBufferTag)) {
     cc->Outputs().Tag(kGpuBufferTag).Set<mediapipe::GpuBuffer>();
     use_gpu |= true;
   }
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   if (cc->Outputs().HasTag(kImageFrameTag)) {
     cc->Outputs().Tag(kImageFrameTag).Set<ImageFrame>();
   }
@@ -154,62 +154,62 @@ mediapipe::Status RecolorCalculator::GetContract(CalculatorContract* cc) {
             cc->Outputs().HasTag(kGpuBufferTag));
 
   if (use_gpu) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     MP_RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status RecolorCalculator::Open(CalculatorContext* cc) {
+absl::Status RecolorCalculator::Open(CalculatorContext* cc) {
   cc->SetOffset(TimestampDiff(0));
 
   if (cc->Inputs().HasTag(kGpuBufferTag)) {
     use_gpu_ = true;
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     MP_RETURN_IF_ERROR(gpu_helper_.Open(cc));
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   }
 
   MP_RETURN_IF_ERROR(LoadOptions(cc));
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status RecolorCalculator::Process(CalculatorContext* cc) {
+absl::Status RecolorCalculator::Process(CalculatorContext* cc) {
   if (use_gpu_) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     MP_RETURN_IF_ERROR(
-        gpu_helper_.RunInGlContext([this, &cc]() -> mediapipe::Status {
+        gpu_helper_.RunInGlContext([this, &cc]() -> absl::Status {
           if (!initialized_) {
             MP_RETURN_IF_ERROR(InitGpu(cc));
             initialized_ = true;
           }
           MP_RETURN_IF_ERROR(RenderGpu(cc));
-          return mediapipe::OkStatus();
+          return absl::OkStatus();
         }));
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   } else {
     MP_RETURN_IF_ERROR(RenderCpu(cc));
   }
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status RecolorCalculator::Close(CalculatorContext* cc) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+absl::Status RecolorCalculator::Close(CalculatorContext* cc) {
+#if !MEDIAPIPE_DISABLE_GPU
   gpu_helper_.RunInGlContext([this] {
     if (program_) glDeleteProgram(program_);
     program_ = 0;
   });
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status RecolorCalculator::RenderCpu(CalculatorContext* cc) {
+absl::Status RecolorCalculator::RenderCpu(CalculatorContext* cc) {
   if (cc->Inputs().Tag(kMaskCpuTag).IsEmpty()) {
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
   // Get inputs and setup output.
   const auto& input_img = cc->Inputs().Tag(kImageFrameTag).Get<ImageFrame>();
@@ -265,14 +265,14 @@ mediapipe::Status RecolorCalculator::RenderCpu(CalculatorContext* cc) {
       .Tag(kImageFrameTag)
       .Add(output_img.release(), cc->InputTimestamp());
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status RecolorCalculator::RenderGpu(CalculatorContext* cc) {
+absl::Status RecolorCalculator::RenderGpu(CalculatorContext* cc) {
   if (cc->Inputs().Tag(kMaskGpuTag).IsEmpty()) {
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   // Get inputs and setup output.
   const Packet& input_packet = cc->Inputs().Tag(kGpuBufferTag).Value();
   const Packet& mask_packet = cc->Inputs().Tag(kMaskGpuTag).Value();
@@ -311,13 +311,13 @@ mediapipe::Status RecolorCalculator::RenderGpu(CalculatorContext* cc) {
   img_tex.Release();
   mask_tex.Release();
   dst_tex.Release();
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 void RecolorCalculator::GlRender() {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   static const GLfloat square_vertices[] = {
       -1.0f, -1.0f,  // bottom left
       1.0f,  -1.0f,  // bottom right
@@ -365,10 +365,10 @@ void RecolorCalculator::GlRender() {
   glBindVertexArray(0);
   glDeleteVertexArrays(1, &vao);
   glDeleteBuffers(2, vbo);
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 }
 
-mediapipe::Status RecolorCalculator::LoadOptions(CalculatorContext* cc) {
+absl::Status RecolorCalculator::LoadOptions(CalculatorContext* cc) {
   const auto& options = cc->Options<mediapipe::RecolorCalculatorOptions>();
 
   mask_channel_ = options.mask_channel();
@@ -379,11 +379,11 @@ mediapipe::Status RecolorCalculator::LoadOptions(CalculatorContext* cc) {
   color_.push_back(options.color().g());
   color_.push_back(options.color().b());
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status RecolorCalculator::InitGpu(CalculatorContext* cc) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+absl::Status RecolorCalculator::InitGpu(CalculatorContext* cc) {
+#if !MEDIAPIPE_DISABLE_GPU
   const GLint attr_location[NUM_ATTRIBUTES] = {
       ATTRIB_VERTEX,
       ATTRIB_TEXTURE_POSITION,
@@ -452,9 +452,9 @@ mediapipe::Status RecolorCalculator::InitGpu(CalculatorContext* cc) {
   glUniform1i(glGetUniformLocation(program_, "mask"), 2);
   glUniform3f(glGetUniformLocation(program_, "recolor"), color_[0] / 255.0,
               color_[1] / 255.0, color_[2] / 255.0);
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 }  // namespace mediapipe

mediapipe/calculators/image/scale_image_calculator.cc

@@ -44,7 +44,7 @@ namespace {
 
 // Given an upscaling algorithm, determine which OpenCV interpolation algorithm
 // to use.
-mediapipe::Status FindInterpolationAlgorithm(
+absl::Status FindInterpolationAlgorithm(
     ScaleImageCalculatorOptions::ScaleAlgorithm upscaling_algorithm,
     int* interpolation_algorithm) {
   switch (upscaling_algorithm) {
@@ -70,7 +70,7 @@ mediapipe::Status FindInterpolationAlgorithm(
       RET_CHECK_FAIL() << absl::Substitute("Unknown upscaling algorithm: $0",
                                            upscaling_algorithm);
   }
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 void CropImageFrame(const ImageFrame& original, int col_start, int row_start,
@@ -147,7 +147,7 @@ class ScaleImageCalculator : public CalculatorBase {
   ScaleImageCalculator();
   ~ScaleImageCalculator() override;
 
-  static mediapipe::Status GetContract(CalculatorContract* cc) {
+  static absl::Status GetContract(CalculatorContract* cc) {
     ScaleImageCalculatorOptions options =
         cc->Options<ScaleImageCalculatorOptions>();
 
@@ -184,35 +184,35 @@ class ScaleImageCalculator : public CalculatorBase {
     if (cc->Inputs().HasTag("OVERRIDE_OPTIONS")) {
       cc->Inputs().Tag("OVERRIDE_OPTIONS").Set<ScaleImageCalculatorOptions>();
     }
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
 
   // From Calculator.
-  mediapipe::Status Open(CalculatorContext* cc) override;
-  mediapipe::Status Process(CalculatorContext* cc) override;
+  absl::Status Open(CalculatorContext* cc) override;
+  absl::Status Process(CalculatorContext* cc) override;
 
  private:
   // Initialize some data members from options_. This can be called either from
   // Open or Process depending on whether OVERRIDE_OPTIONS is used.
-  mediapipe::Status InitializeFromOptions();
+  absl::Status InitializeFromOptions();
   // Initialize crop and output parameters based on set member variable
   // values.  This function will also send the header information on
   // the VIDEO_HEADER stream if it hasn't been done yet.
-  mediapipe::Status InitializeFrameInfo(CalculatorContext* cc);
+  absl::Status InitializeFrameInfo(CalculatorContext* cc);
   // Validate that input_format_ and output_format_ are supported image
   // formats.
-  mediapipe::Status ValidateImageFormats() const;
+  absl::Status ValidateImageFormats() const;
   // Validate that the image frame has the proper format and dimensions.
   // If the dimensions and format weren't initialized by the header,
   // then the first frame on which this function is called is used
   // to initialize.
-  mediapipe::Status ValidateImageFrame(CalculatorContext* cc,
-                                       const ImageFrame& image_frame);
+  absl::Status ValidateImageFrame(CalculatorContext* cc,
+                                  const ImageFrame& image_frame);
   // Validate that the YUV image has the proper dimensions. If the
   // dimensions weren't initialized by the header, then the first image
   // on which this function is called is used to initialize.
-  mediapipe::Status ValidateYUVImage(CalculatorContext* cc,
-                                     const YUVImage& yuv_image);
+  absl::Status ValidateYUVImage(CalculatorContext* cc,
+                                const YUVImage& yuv_image);
 
   bool has_header_;  // True if the input stream has a header.
   int input_width_;
@@ -251,8 +251,7 @@ ScaleImageCalculator::ScaleImageCalculator() {}
 
 ScaleImageCalculator::~ScaleImageCalculator() {}
 
-mediapipe::Status ScaleImageCalculator::InitializeFrameInfo(
-    CalculatorContext* cc) {
+absl::Status ScaleImageCalculator::InitializeFrameInfo(CalculatorContext* cc) {
   MP_RETURN_IF_ERROR(
       scale_image::FindCropDimensions(input_width_, input_height_,  //
                                       options_.min_aspect_ratio(),  //
@@ -299,10 +298,10 @@ mediapipe::Status ScaleImageCalculator::InitializeFrameInfo(
         .Add(header.release(), Timestamp::PreStream());
     cc->Outputs().Tag("VIDEO_HEADER").Close();
   }
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ScaleImageCalculator::Open(CalculatorContext* cc) {
+absl::Status ScaleImageCalculator::Open(CalculatorContext* cc) {
   options_ = cc->Options<ScaleImageCalculatorOptions>();
 
   input_data_id_ = cc->Inputs().GetId("FRAMES", 0);
@@ -339,7 +338,7 @@ mediapipe::Status ScaleImageCalculator::Open(CalculatorContext* cc) {
       // has a header. At this point in the code, the ScaleImageCalculator
       // config may be changed by the new options at PreStream, so the output
       // header can't be determined.
-      return mediapipe::InvalidArgumentError(
+      return absl::InvalidArgumentError(
           "OVERRIDE_OPTIONS stream can't be used when the main input stream "
           "has a header.");
     }
@@ -406,10 +405,10 @@ mediapipe::Status ScaleImageCalculator::Open(CalculatorContext* cc) {
     }
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ScaleImageCalculator::InitializeFromOptions() {
+absl::Status ScaleImageCalculator::InitializeFromOptions() {
   if (options_.has_input_format()) {
     input_format_ = options_.input_format();
   } else {
@@ -423,10 +422,10 @@ mediapipe::Status ScaleImageCalculator::InitializeFromOptions() {
 
   downscaler_.reset(new ImageResizer(options_.post_sharpening_coefficient()));
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ScaleImageCalculator::ValidateImageFormats() const {
+absl::Status ScaleImageCalculator::ValidateImageFormats() const {
   RET_CHECK_NE(input_format_, ImageFormat::UNKNOWN)
       << "The input image format was UNKNOWN.";
   RET_CHECK_NE(output_format_, ImageFormat::UNKNOWN)
@@ -440,10 +439,10 @@ mediapipe::Status ScaleImageCalculator::ValidateImageFormats() const {
             input_format_ == ImageFormat::YCBCR420P)
       << "Conversion of the color space (except from "
          "YCbCr420P to SRGB) is not yet supported.";
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ScaleImageCalculator::ValidateImageFrame(
+absl::Status ScaleImageCalculator::ValidateImageFrame(
     CalculatorContext* cc, const ImageFrame& image_frame) {
   if (!has_header_) {
     if (input_width_ != image_frame.Width() ||
@@ -494,11 +493,11 @@ mediapipe::Status ScaleImageCalculator::ValidateImageFrame(
           image_frame_format_desc, " but expected ", input_format_desc));
     }
   }
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ScaleImageCalculator::ValidateYUVImage(
-    CalculatorContext* cc, const YUVImage& yuv_image) {
+absl::Status ScaleImageCalculator::ValidateYUVImage(CalculatorContext* cc,
+                                                    const YUVImage& yuv_image) {
   CHECK_EQ(input_format_, ImageFormat::YCBCR420P);
   if (!has_header_) {
     if (input_width_ != yuv_image.width() ||
@@ -528,14 +527,14 @@ mediapipe::Status ScaleImageCalculator::ValidateYUVImage(
           input_width_, "x", input_height_));
     }
   }
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status ScaleImageCalculator::Process(CalculatorContext* cc) {
+absl::Status ScaleImageCalculator::Process(CalculatorContext* cc) {
   if (cc->InputTimestamp() == Timestamp::PreStream()) {
     if (cc->Inputs().HasTag("OVERRIDE_OPTIONS")) {
       if (cc->Inputs().Tag("OVERRIDE_OPTIONS").IsEmpty()) {
-        return mediapipe::InvalidArgumentError(
+        return absl::InvalidArgumentError(
             "The OVERRIDE_OPTIONS input stream must be non-empty at PreStream "
             "time if used.");
       }
@@ -549,7 +548,7 @@ mediapipe::Status ScaleImageCalculator::Process(CalculatorContext* cc) {
       input_video_header_ = cc->Inputs().Tag("VIDEO_HEADER").Get<VideoHeader>();
     }
     if (cc->Inputs().Get(input_data_id_).IsEmpty()) {
-      return mediapipe::OkStatus();
+      return absl::OkStatus();
     }
   }
 
@@ -603,7 +602,7 @@ mediapipe::Status ScaleImageCalculator::Process(CalculatorContext* cc) {
       cc->Outputs()
           .Get(output_data_id_)
           .Add(output_image.release(), cc->InputTimestamp());
-      return mediapipe::OkStatus();
+      return absl::OkStatus();
     }
   } else {
     image_frame = &cc->Inputs().Get(input_data_id_).Get<ImageFrame>();
@@ -664,7 +663,7 @@ mediapipe::Status ScaleImageCalculator::Process(CalculatorContext* cc) {
             .Add(output_frame.release(), cc->InputTimestamp());
       }
     }
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
 
   // Rescale the image frame.
@@ -698,7 +697,7 @@ mediapipe::Status ScaleImageCalculator::Process(CalculatorContext* cc) {
   cc->Outputs()
       .Get(output_data_id_)
       .Add(output_frame.release(), cc->InputTimestamp());
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 }  // namespace mediapipe

mediapipe/calculators/image/scale_image_utils.cc

@@ -35,11 +35,11 @@ double ParseRational(const std::string& rational) {
 }
 }  // namespace
 
-mediapipe::Status FindCropDimensions(int input_width, int input_height,    //
-                                     const std::string& min_aspect_ratio,  //
-                                     const std::string& max_aspect_ratio,  //
-                                     int* crop_width, int* crop_height,    //
-                                     int* col_start, int* row_start) {
+absl::Status FindCropDimensions(int input_width, int input_height,    //
+                                const std::string& min_aspect_ratio,  //
+                                const std::string& max_aspect_ratio,  //
+                                int* crop_width, int* crop_height,    //
+                                int* col_start, int* row_start) {
   CHECK(crop_width);
   CHECK(crop_height);
   CHECK(col_start);
@@ -85,16 +85,16 @@ mediapipe::Status FindCropDimensions(int input_width, int input_height,    //
 
   CHECK_LE(*crop_width, input_width);
   CHECK_LE(*crop_height, input_height);
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status FindOutputDimensions(int input_width,             //
-                                       int input_height,            //
-                                       int target_width,            //
-                                       int target_height,           //
-                                       bool preserve_aspect_ratio,  //
-                                       int scale_to_multiple_of,    //
-                                       int* output_width, int* output_height) {
+absl::Status FindOutputDimensions(int input_width,             //
+                                  int input_height,            //
+                                  int target_width,            //
+                                  int target_height,           //
+                                  bool preserve_aspect_ratio,  //
+                                  int scale_to_multiple_of,    //
+                                  int* output_width, int* output_height) {
   CHECK(output_width);
   CHECK(output_height);
 
@@ -122,7 +122,7 @@ mediapipe::Status FindOutputDimensions(int input_width,             //
     *output_width = target_width;
     *output_height = target_height;
 
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
 
   if (target_width > 0) {
@@ -139,7 +139,7 @@ mediapipe::Status FindOutputDimensions(int input_width,             //
       // was within the image, so use these dimensions.
       *output_width = try_width;
       *output_height = try_height;
-      return mediapipe::OkStatus();
+      return absl::OkStatus();
     }
   }
 
@@ -157,7 +157,7 @@ mediapipe::Status FindOutputDimensions(int input_width,             //
       // was within the image, so use these dimensions.
       *output_width = try_width;
       *output_height = try_height;
-      return mediapipe::OkStatus();
+      return absl::OkStatus();
     }
   }
   RET_CHECK_FAIL()

mediapipe/calculators/image/scale_image_utils.h

@@ -28,11 +28,11 @@ namespace scale_image {
 // is a centered, cropped portion of the image that falls within the min
 // and max aspect ratio.  If either the min or max aspect ratio argument
 // is empty or has a 0 in the numerator or denominator then it is ignored.
-mediapipe::Status FindCropDimensions(int input_width, int input_height,    //
-                                     const std::string& min_aspect_ratio,  //
-                                     const std::string& max_aspect_ratio,  //
-                                     int* crop_width, int* crop_height,    //
-                                     int* col_start, int* row_start);
+absl::Status FindCropDimensions(int input_width, int input_height,    //
+                                const std::string& min_aspect_ratio,  //
+                                const std::string& max_aspect_ratio,  //
+                                int* crop_width, int* crop_height,    //
+                                int* col_start, int* row_start);
 
 // Given an input width and height, a target width and height, whether to
 // preserve the aspect ratio, and whether to round-down to the multiple of a
@@ -43,12 +43,12 @@ mediapipe::Status FindCropDimensions(int input_width, int input_height,    //
 // output_height will be reduced as necessary to preserve_aspect_ratio if the
 // option is specified. If preserving the aspect ratio is desired, you must set
 // scale_to_multiple_of to 2.
-mediapipe::Status FindOutputDimensions(int input_width, int input_height,  //
-                                       int target_width,
-                                       int target_height,           //
-                                       bool preserve_aspect_ratio,  //
-                                       int scale_to_multiple_of,    //
-                                       int* output_width, int* output_height);
+absl::Status FindOutputDimensions(int input_width, int input_height,  //
+                                  int target_width,
+                                  int target_height,           //
+                                  bool preserve_aspect_ratio,  //
+                                  int scale_to_multiple_of,    //
+                                  int* output_width, int* output_height);
 
 }  // namespace scale_image
 }  // namespace mediapipe

mediapipe/calculators/image/set_alpha_calculator.cc

@@ -25,11 +25,11 @@
 #include "mediapipe/framework/port/status.h"
 #include "mediapipe/framework/port/vector.h"
 
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
 #include "mediapipe/gpu/gl_calculator_helper.h"
 #include "mediapipe/gpu/gl_simple_shaders.h"
 #include "mediapipe/gpu/shader_util.h"
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
 namespace mediapipe {
 
@@ -87,18 +87,18 @@ class SetAlphaCalculator : public CalculatorBase {
   SetAlphaCalculator() = default;
   ~SetAlphaCalculator() override = default;
 
-  static mediapipe::Status GetContract(CalculatorContract* cc);
+  static absl::Status GetContract(CalculatorContract* cc);
 
   // From Calculator.
-  mediapipe::Status Open(CalculatorContext* cc) override;
-  mediapipe::Status Process(CalculatorContext* cc) override;
-  mediapipe::Status Close(CalculatorContext* cc) override;
+  absl::Status Open(CalculatorContext* cc) override;
+  absl::Status Process(CalculatorContext* cc) override;
+  absl::Status Close(CalculatorContext* cc) override;
 
  private:
-  mediapipe::Status RenderGpu(CalculatorContext* cc);
-  mediapipe::Status RenderCpu(CalculatorContext* cc);
+  absl::Status RenderGpu(CalculatorContext* cc);
+  absl::Status RenderCpu(CalculatorContext* cc);
 
-  mediapipe::Status GlSetup(CalculatorContext* cc);
+  absl::Status GlSetup(CalculatorContext* cc);
   void GlRender(CalculatorContext* cc);
 
   mediapipe::SetAlphaCalculatorOptions options_;
@@ -106,81 +106,81 @@ class SetAlphaCalculator : public CalculatorBase {
 
   bool use_gpu_ = false;
   bool gpu_initialized_ = false;
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   mediapipe::GlCalculatorHelper gpu_helper_;
   GLuint program_ = 0;
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 };
 REGISTER_CALCULATOR(SetAlphaCalculator);
 
-mediapipe::Status SetAlphaCalculator::GetContract(CalculatorContract* cc) {
+absl::Status SetAlphaCalculator::GetContract(CalculatorContract* cc) {
   CHECK_GE(cc->Inputs().NumEntries(), 1);
 
   bool use_gpu = false;
 
   if (cc->Inputs().HasTag(kInputFrameTag) &&
       cc->Inputs().HasTag(kInputFrameTagGpu)) {
-    return mediapipe::InternalError("Cannot have multiple input images.");
+    return absl::InternalError("Cannot have multiple input images.");
   }
   if (cc->Inputs().HasTag(kInputFrameTagGpu) !=
       cc->Outputs().HasTag(kOutputFrameTagGpu)) {
-    return mediapipe::InternalError("GPU output must have GPU input.");
+    return absl::InternalError("GPU output must have GPU input.");
   }
 
   // Input image to add/edit alpha channel.
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   if (cc->Inputs().HasTag(kInputFrameTagGpu)) {
     cc->Inputs().Tag(kInputFrameTagGpu).Set<mediapipe::GpuBuffer>();
     use_gpu |= true;
   }
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   if (cc->Inputs().HasTag(kInputFrameTag)) {
     cc->Inputs().Tag(kInputFrameTag).Set<ImageFrame>();
   }
 
   // Input alpha image mask (optional)
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   if (cc->Inputs().HasTag(kInputAlphaTagGpu)) {
     cc->Inputs().Tag(kInputAlphaTagGpu).Set<mediapipe::GpuBuffer>();
     use_gpu |= true;
   }
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   if (cc->Inputs().HasTag(kInputAlphaTag)) {
     cc->Inputs().Tag(kInputAlphaTag).Set<ImageFrame>();
   }
 
   // RGBA output image.
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   if (cc->Outputs().HasTag(kOutputFrameTagGpu)) {
     cc->Outputs().Tag(kOutputFrameTagGpu).Set<mediapipe::GpuBuffer>();
     use_gpu |= true;
   }
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   if (cc->Outputs().HasTag(kOutputFrameTag)) {
     cc->Outputs().Tag(kOutputFrameTag).Set<ImageFrame>();
   }
 
   if (use_gpu) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     MP_RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status SetAlphaCalculator::Open(CalculatorContext* cc) {
+absl::Status SetAlphaCalculator::Open(CalculatorContext* cc) {
   cc->SetOffset(TimestampDiff(0));
 
   options_ = cc->Options<mediapipe::SetAlphaCalculatorOptions>();
 
   if (cc->Inputs().HasTag(kInputFrameTagGpu) &&
       cc->Outputs().HasTag(kOutputFrameTagGpu)) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     use_gpu_ = true;
 #else
     RET_CHECK_FAIL() << "GPU processing not enabled.";
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
   }
 
   // Get global value from options (-1 if not set).
@@ -193,48 +193,47 @@ mediapipe::Status SetAlphaCalculator::Open(CalculatorContext* cc) {
     RET_CHECK_FAIL() << "Must use either image mask or options alpha value.";
 
   if (use_gpu_) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
     MP_RETURN_IF_ERROR(gpu_helper_.Open(cc));
 #endif
   }  //  !MEDIAPIPE_DISABLE_GPU
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status SetAlphaCalculator::Process(CalculatorContext* cc) {
+absl::Status SetAlphaCalculator::Process(CalculatorContext* cc) {
   if (use_gpu_) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
-    MP_RETURN_IF_ERROR(
-        gpu_helper_.RunInGlContext([this, cc]() -> mediapipe::Status {
-          if (!gpu_initialized_) {
-            MP_RETURN_IF_ERROR(GlSetup(cc));
-            gpu_initialized_ = true;
-          }
-          MP_RETURN_IF_ERROR(RenderGpu(cc));
-          return mediapipe::OkStatus();
-        }));
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#if !MEDIAPIPE_DISABLE_GPU
+    MP_RETURN_IF_ERROR(gpu_helper_.RunInGlContext([this, cc]() -> absl::Status {
+      if (!gpu_initialized_) {
+        MP_RETURN_IF_ERROR(GlSetup(cc));
+        gpu_initialized_ = true;
+      }
+      MP_RETURN_IF_ERROR(RenderGpu(cc));
+      return absl::OkStatus();
+    }));
+#endif  // !MEDIAPIPE_DISABLE_GPU
   } else {
     MP_RETURN_IF_ERROR(RenderCpu(cc));
   }
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status SetAlphaCalculator::Close(CalculatorContext* cc) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+absl::Status SetAlphaCalculator::Close(CalculatorContext* cc) {
+#if !MEDIAPIPE_DISABLE_GPU
   gpu_helper_.RunInGlContext([this] {
     if (program_) glDeleteProgram(program_);
     program_ = 0;
   });
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status SetAlphaCalculator::RenderCpu(CalculatorContext* cc) {
+absl::Status SetAlphaCalculator::RenderCpu(CalculatorContext* cc) {
   if (cc->Inputs().Tag(kInputFrameTag).IsEmpty()) {
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
 
   // Setup source image
@@ -294,14 +293,14 @@ mediapipe::Status SetAlphaCalculator::RenderCpu(CalculatorContext* cc) {
       .Tag(kOutputFrameTag)
       .Add(output_frame.release(), cc->InputTimestamp());
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status SetAlphaCalculator::RenderGpu(CalculatorContext* cc) {
+absl::Status SetAlphaCalculator::RenderGpu(CalculatorContext* cc) {
   if (cc->Inputs().Tag(kInputFrameTagGpu).IsEmpty()) {
-    return mediapipe::OkStatus();
+    return absl::OkStatus();
   }
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   // Setup source texture.
   const auto& input_frame =
       cc->Inputs().Tag(kInputFrameTagGpu).Get<mediapipe::GpuBuffer>();
@@ -354,13 +353,13 @@ mediapipe::Status SetAlphaCalculator::RenderGpu(CalculatorContext* cc) {
   // Cleanup
   input_texture.Release();
   output_texture.Release();
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 void SetAlphaCalculator::GlRender(CalculatorContext* cc) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+#if !MEDIAPIPE_DISABLE_GPU
   static const GLfloat square_vertices[] = {
       -1.0f, -1.0f,  // bottom left
       1.0f,  -1.0f,  // bottom right
@@ -409,11 +408,11 @@ void SetAlphaCalculator::GlRender(CalculatorContext* cc) {
   glDeleteVertexArrays(1, &vao);
   glDeleteBuffers(2, vbo);
 
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 }
 
-mediapipe::Status SetAlphaCalculator::GlSetup(CalculatorContext* cc) {
-#if !defined(MEDIAPIPE_DISABLE_GPU)
+absl::Status SetAlphaCalculator::GlSetup(CalculatorContext* cc) {
+#if !MEDIAPIPE_DISABLE_GPU
   const GLint attr_location[NUM_ATTRIBUTES] = {
       ATTRIB_VERTEX,
       ATTRIB_TEXTURE_POSITION,
@@ -466,9 +465,9 @@ mediapipe::Status SetAlphaCalculator::GlSetup(CalculatorContext* cc) {
   glUniform1i(glGetUniformLocation(program_, "alpha_mask"), 2);
   glUniform1f(glGetUniformLocation(program_, "alpha_value"), alpha_value_);
 
-#endif  //  !MEDIAPIPE_DISABLE_GPU
+#endif  // !MEDIAPIPE_DISABLE_GPU
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 }  // namespace mediapipe

mediapipe/calculators/image/sobel_edges_calculator.cc

@@ -27,10 +27,9 @@ namespace mediapipe {
 // See GlSimpleCalculatorBase for inputs, outputs and input side packets.
 class SobelEdgesCalculator : public GlSimpleCalculator {
  public:
-  mediapipe::Status GlSetup() override;
-  mediapipe::Status GlRender(const GlTexture& src,
-                             const GlTexture& dst) override;
-  mediapipe::Status GlTeardown() override;
+  absl::Status GlSetup() override;
+  absl::Status GlRender(const GlTexture& src, const GlTexture& dst) override;
+  absl::Status GlTeardown() override;
 
  private:
   GLuint program_ = 0;
@@ -40,7 +39,7 @@ class SobelEdgesCalculator : public GlSimpleCalculator {
 };
 REGISTER_CALCULATOR(SobelEdgesCalculator);
 
-mediapipe::Status SobelEdgesCalculator::GlSetup() {
+absl::Status SobelEdgesCalculator::GlSetup() {
   // Load vertex and fragment shaders
   const GLint attr_location[NUM_ATTRIBUTES] = {
       ATTRIB_VERTEX,
@@ -166,11 +165,11 @@ mediapipe::Status SobelEdgesCalculator::GlSetup() {
   frame_ = glGetUniformLocation(program_, "inputImage");
   pixel_w_ = glGetUniformLocation(program_, "pixelW");
   pixel_h_ = glGetUniformLocation(program_, "pixelH");
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status SobelEdgesCalculator::GlRender(const GlTexture& src,
-                                                 const GlTexture& dst) {
+absl::Status SobelEdgesCalculator::GlRender(const GlTexture& src,
+                                            const GlTexture& dst) {
   static const GLfloat square_vertices[] = {
       -1.0f, -1.0f,  // bottom left
       1.0f,  -1.0f,  // bottom right
@@ -225,15 +224,15 @@ mediapipe::Status SobelEdgesCalculator::GlRender(const GlTexture& src,
   glDeleteVertexArrays(1, &vao);
   glDeleteBuffers(2, vbo);
 
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
-mediapipe::Status SobelEdgesCalculator::GlTeardown() {
+absl::Status SobelEdgesCalculator::GlTeardown() {
   if (program_) {
     glDeleteProgram(program_);
     program_ = 0;
   }
-  return mediapipe::OkStatus();
+  return absl::OkStatus();
 }
 
 }  // namespace mediapipe