Project import generated by Copybara.

GitOrigin-RevId: 03b457556bea85f6792ea9685cd4cea61e62f251

.bazelrc

@@ -14,6 +14,7 @@ build --copt='-Wno-unused-local-typedefs'
 build --copt='-Wno-ignored-attributes'
 # Temporarily set the incompatiblity flag for Bazel 0.27.0 and above
 build --incompatible_disable_deprecated_attr_params=false
+build --incompatible_depset_is_not_iterable=false
 
 # Sets the default Apple platform to macOS.
 build --apple_platform_type=macos

Dockerfile

@@ -24,6 +24,7 @@ ENV DEBIAN_FRONTEND=noninteractive
 RUN apt-get update && apt-get install -y --no-install-recommends \
         build-essential \
         ca-certificates \
+        curl \
         git \
         wget \
         unzip \
@@ -35,7 +36,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
         libopencv-video-dev \
         software-properties-common && \
     add-apt-repository -y ppa:openjdk-r/ppa && \
-    apt-get update && apt-get install -y openjdk-11-jdk && \
+    apt-get update && apt-get install -y openjdk-8-jdk && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
 

README.md

@@ -5,6 +5,18 @@
 
 ![Real-time Face Detection](mediapipe/docs/images/realtime_face_detection.gif)
 
+## ML Solutions in MediaPipe
+
+* [Hand Tracking](mediapipe/docs/hand_tracking_mobile_gpu.md)
+* [Face Detection](mediapipe/docs/face_detection_mobile_gpu.md)
+* [Hair Segmentation](mediapipe/docs/hair_segmentation_mobile_gpu.md)
+* [Object Detection](mediapipe/docs/object_detection_mobile_gpu.md)
+
+![hand_tracking](mediapipe/docs/images/mobile/hand_tracking_3d_android_gpu_small.gif)
+![face_detection](mediapipe/docs/images/mobile/face_detection_android_gpu_small.gif)
+![hair_segmentation](mediapipe/docs/images/mobile/hair_segmentation_android_gpu_small.gif)
+![object_detection](mediapipe/docs/images/mobile/object_detection_android_gpu_small.gif)
+
 ## Installation
 Follow these [instructions](mediapipe/docs/install.md).
 

WORKSPACE

@@ -10,7 +10,7 @@ http_archive(
     sha256 = "2ef429f5d7ce7111263289644d233707dba35e39696377ebab8b0bc701f7818e",
 )
 load("@bazel_skylib//lib:versions.bzl", "versions")
-versions.check(minimum_bazel_version = "0.23.0")
+versions.check(minimum_bazel_version = "0.24.1")
 
 # ABSL cpp library.
 http_archive(
@@ -25,6 +25,12 @@ http_archive(
     strip_prefix = "abseil-cpp-a02f62f456f2c4a7ecf2be3104fe0c6e16fbad9a",
 )
 
+http_archive(
+    name = "rules_cc",
+    strip_prefix = "rules_cc-master",
+    urls = ["https://github.com/bazelbuild/rules_cc/archive/master.zip"],
+)
+
 # GoogleTest/GoogleMock framework. Used by most unit-tests.
 http_archive(
      name = "com_google_googletest",
@@ -114,7 +120,9 @@ http_archive(
 load("@org_tensorflow//tensorflow:workspace.bzl", "tf_workspace")
 tf_workspace(tf_repo_name = "org_tensorflow")
 
-# Please run $ sudo apt-get install libopencv-dev
+# Please run
+# $ sudo apt-get install libopencv-core-dev libopencv-highgui-dev \
+#                        libopencv-imgproc-dev libopencv-video-dev
 new_local_repository(
     name = "linux_opencv",
     build_file = "@//third_party:opencv_linux.BUILD",
@@ -127,7 +135,7 @@ new_local_repository(
     path = "/usr"
 )
 
-# Please run $ brew install opencv
+# Please run $ brew install opencv@3
 new_local_repository(
     name = "macos_opencv",
     build_file = "@//third_party:opencv_macos.BUILD",

mediapipe/calculators/audio/BUILD

@@ -67,6 +67,23 @@ mediapipe_cc_proto_library(
     deps = [":spectrogram_calculator_proto"],
 )
 
+proto_library(
+    name = "stabilized_log_calculator_proto",
+    srcs = ["stabilized_log_calculator.proto"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//mediapipe/framework:calculator_proto",
+    ],
+)
+
+mediapipe_cc_proto_library(
+    name = "stabilized_log_calculator_cc_proto",
+    srcs = ["stabilized_log_calculator.proto"],
+    cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
+    visibility = ["//visibility:public"],
+    deps = [":stabilized_log_calculator_proto"],
+)
+
 proto_library(
     name = "time_series_framer_calculator_proto",
     srcs = ["time_series_framer_calculator.proto"],
@@ -156,6 +173,22 @@ cc_library(
     alwayslink = 1,
 )
 
+cc_library(
+    name = "stabilized_log_calculator",
+    srcs = ["stabilized_log_calculator.cc"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":stabilized_log_calculator_cc_proto",
+        "//mediapipe/framework:calculator_framework",
+        "//mediapipe/framework/formats:matrix",
+        "//mediapipe/framework/formats:time_series_header_cc_proto",
+        "//mediapipe/framework/port:core_proto",
+        "//mediapipe/framework/port:status",
+        "//mediapipe/util:time_series_util",
+    ],
+    alwayslink = 1,
+)
+
 cc_library(
     name = "spectrogram_calculator",
     srcs = ["spectrogram_calculator.cc"],
@@ -266,6 +299,24 @@ cc_test(
     ],
 )
 
+cc_test(
+    name = "stabilized_log_calculator_test",
+    srcs = ["stabilized_log_calculator_test.cc"],
+    deps = [
+        ":stabilized_log_calculator",
+        ":stabilized_log_calculator_cc_proto",
+        "//mediapipe/framework:calculator_framework",
+        "//mediapipe/framework:calculator_runner",
+        "//mediapipe/framework/formats:matrix",
+        "//mediapipe/framework/formats:time_series_header_cc_proto",
+        "//mediapipe/framework/port:gtest_main",
+        "//mediapipe/framework/port:integral_types",
+        "//mediapipe/framework/port:status",
+        "//mediapipe/util:time_series_test_util",
+        "@eigen_archive//:eigen",
+    ],
+)
+
 cc_test(
     name = "time_series_framer_calculator_test",
     srcs = ["time_series_framer_calculator_test.cc"],

mediapipe/calculators/audio/audio_decoder_calculator.cc

@@ -64,7 +64,7 @@ class AudioDecoderCalculator : public CalculatorBase {
 
   cc->Outputs().Tag("AUDIO").Set<Matrix>();
   if (cc->Outputs().HasTag("AUDIO_HEADER")) {
-    cc->Outputs().Tag("AUDIO_HEADER").Set<mediapipe::TimeSeriesHeader>();
+    cc->Outputs().Tag("AUDIO_HEADER").SetNone();
   }
   return ::mediapipe::OkStatus();
 }
@@ -74,7 +74,7 @@ class AudioDecoderCalculator : public CalculatorBase {
       cc->InputSidePackets().Tag("INPUT_FILE_PATH").Get<std::string>();
   const auto& decoder_options = cc->Options<mediapipe::AudioDecoderOptions>();
   decoder_ = absl::make_unique<AudioDecoder>();
-  RETURN_IF_ERROR(decoder_->Initialize(input_file_path, decoder_options));
+  MP_RETURN_IF_ERROR(decoder_->Initialize(input_file_path, decoder_options));
   std::unique_ptr<mediapipe::TimeSeriesHeader> header =
       absl::make_unique<mediapipe::TimeSeriesHeader>();
   if (decoder_->FillAudioHeader(decoder_options.audio_stream(0), header.get())

mediapipe/calculators/audio/audio_decoder_calculator_test.cc

@@ -39,11 +39,10 @@ TEST(AudioDecoderCalculatorTest, TestWAV) {
       file::JoinPath("./",
                      "/mediapipe/calculators/audio/"
                      "testdata/sine_wave_1k_44100_mono_2_sec_wav.audio"));
-  MEDIAPIPE_ASSERT_OK(runner.Run());
-  MEDIAPIPE_EXPECT_OK(
-      runner.Outputs()
-          .Tag("AUDIO_HEADER")
-          .header.ValidateAsType<mediapipe::TimeSeriesHeader>());
+  MP_ASSERT_OK(runner.Run());
+  MP_EXPECT_OK(runner.Outputs()
+                   .Tag("AUDIO_HEADER")
+                   .header.ValidateAsType<mediapipe::TimeSeriesHeader>());
   const mediapipe::TimeSeriesHeader& header =
       runner.Outputs()
           .Tag("AUDIO_HEADER")
@@ -71,11 +70,10 @@ TEST(AudioDecoderCalculatorTest, Test48KWAV) {
       file::JoinPath("./",
                      "/mediapipe/calculators/audio/"
                      "testdata/sine_wave_1k_48000_stereo_2_sec_wav.audio"));
-  MEDIAPIPE_ASSERT_OK(runner.Run());
-  MEDIAPIPE_EXPECT_OK(
-      runner.Outputs()
-          .Tag("AUDIO_HEADER")
-          .header.ValidateAsType<mediapipe::TimeSeriesHeader>());
+  MP_ASSERT_OK(runner.Run());
+  MP_EXPECT_OK(runner.Outputs()
+                   .Tag("AUDIO_HEADER")
+                   .header.ValidateAsType<mediapipe::TimeSeriesHeader>());
   const mediapipe::TimeSeriesHeader& header =
       runner.Outputs()
           .Tag("AUDIO_HEADER")
@@ -103,11 +101,10 @@ TEST(AudioDecoderCalculatorTest, TestMP3) {
       file::JoinPath("./",
                      "/mediapipe/calculators/audio/"
                      "testdata/sine_wave_1k_44100_stereo_2_sec_mp3.audio"));
-  MEDIAPIPE_ASSERT_OK(runner.Run());
-  MEDIAPIPE_EXPECT_OK(
-      runner.Outputs()
-          .Tag("AUDIO_HEADER")
-          .header.ValidateAsType<mediapipe::TimeSeriesHeader>());
+  MP_ASSERT_OK(runner.Run());
+  MP_EXPECT_OK(runner.Outputs()
+                   .Tag("AUDIO_HEADER")
+                   .header.ValidateAsType<mediapipe::TimeSeriesHeader>());
   const mediapipe::TimeSeriesHeader& header =
       runner.Outputs()
           .Tag("AUDIO_HEADER")
@@ -135,11 +132,10 @@ TEST(AudioDecoderCalculatorTest, TestAAC) {
       file::JoinPath("./",
                      "/mediapipe/calculators/audio/"
                      "testdata/sine_wave_1k_44100_stereo_2_sec_aac.audio"));
-  MEDIAPIPE_ASSERT_OK(runner.Run());
-  MEDIAPIPE_EXPECT_OK(
-      runner.Outputs()
-          .Tag("AUDIO_HEADER")
-          .header.ValidateAsType<mediapipe::TimeSeriesHeader>());
+  MP_ASSERT_OK(runner.Run());
+  MP_EXPECT_OK(runner.Outputs()
+                   .Tag("AUDIO_HEADER")
+                   .header.ValidateAsType<mediapipe::TimeSeriesHeader>());
   const mediapipe::TimeSeriesHeader& header =
       runner.Outputs()
           .Tag("AUDIO_HEADER")

mediapipe/calculators/audio/basic_time_series_calculators.cc

@@ -51,11 +51,11 @@ static bool SafeMultiply(int x, int y, int* result) {
 
 ::mediapipe::Status BasicTimeSeriesCalculatorBase::Open(CalculatorContext* cc) {
   TimeSeriesHeader input_header;
-  RETURN_IF_ERROR(time_series_util::FillTimeSeriesHeaderIfValid(
+  MP_RETURN_IF_ERROR(time_series_util::FillTimeSeriesHeaderIfValid(
       cc->Inputs().Index(0).Header(), &input_header));
 
   auto output_header = new TimeSeriesHeader(input_header);
-  RETURN_IF_ERROR(MutateHeader(output_header));
+  MP_RETURN_IF_ERROR(MutateHeader(output_header));
   cc->Outputs().Index(0).SetHeader(Adopt(output_header));
   return ::mediapipe::OkStatus();
 }
@@ -63,11 +63,11 @@ static bool SafeMultiply(int x, int y, int* result) {
 ::mediapipe::Status BasicTimeSeriesCalculatorBase::Process(
     CalculatorContext* cc) {
   const Matrix& input = cc->Inputs().Index(0).Get<Matrix>();
-  RETURN_IF_ERROR(time_series_util::IsMatrixShapeConsistentWithHeader(
+  MP_RETURN_IF_ERROR(time_series_util::IsMatrixShapeConsistentWithHeader(
       input, cc->Inputs().Index(0).Header().Get<TimeSeriesHeader>()));
 
   std::unique_ptr<Matrix> output(new Matrix(ProcessMatrix(input)));
-  RETURN_IF_ERROR(time_series_util::IsMatrixShapeConsistentWithHeader(
+  MP_RETURN_IF_ERROR(time_series_util::IsMatrixShapeConsistentWithHeader(
       *output, cc->Outputs().Index(0).Header().Get<TimeSeriesHeader>()));
 
   cc->Outputs().Index(0).Add(output.release(), cc->InputTimestamp());

mediapipe/calculators/audio/mfcc_mel_calculators.cc

@@ -90,8 +90,8 @@ class FramewiseTransformCalculatorBase : public CalculatorBase {
  private:
   // Takes header and options, and sets up state including calling
   // set_num_output_channels() on the base object.
-  virtual ::mediapipe::Status ConfigureTransform(
-      const TimeSeriesHeader& header, const CalculatorOptions& options) = 0;
+  virtual ::mediapipe::Status ConfigureTransform(const TimeSeriesHeader& header,
+                                                 CalculatorContext* cc) = 0;
 
   // Takes a vector<double> corresponding to an input frame, and
   // perform the specific transformation to produce an output frame.
@@ -105,10 +105,10 @@ class FramewiseTransformCalculatorBase : public CalculatorBase {
 ::mediapipe::Status FramewiseTransformCalculatorBase::Open(
     CalculatorContext* cc) {
   TimeSeriesHeader input_header;
-  RETURN_IF_ERROR(time_series_util::FillTimeSeriesHeaderIfValid(
+  MP_RETURN_IF_ERROR(time_series_util::FillTimeSeriesHeaderIfValid(
       cc->Inputs().Index(0).Header(), &input_header));
 
-  ::mediapipe::Status status = ConfigureTransform(input_header, cc->Options());
+  ::mediapipe::Status status = ConfigureTransform(input_header, cc);
 
   auto output_header = new TimeSeriesHeader(input_header);
   output_header->set_num_channels(num_output_channels_);
@@ -175,11 +175,9 @@ class MfccCalculator : public FramewiseTransformCalculatorBase {
   }
 
  private:
-  ::mediapipe::Status ConfigureTransform(
-      const TimeSeriesHeader& header,
-      const CalculatorOptions& options) override {
-    MfccCalculatorOptions mfcc_options;
-    time_series_util::FillOptionsExtensionOrDie(options, &mfcc_options);
+  ::mediapipe::Status ConfigureTransform(const TimeSeriesHeader& header,
+                                         CalculatorContext* cc) override {
+    MfccCalculatorOptions mfcc_options = cc->Options<MfccCalculatorOptions>();
     mfcc_.reset(new audio_dsp::Mfcc());
     int input_length = header.num_channels();
     // Set up the parameters to the Mfcc object.
@@ -235,11 +233,10 @@ class MelSpectrumCalculator : public FramewiseTransformCalculatorBase {
   }
 
  private:
-  ::mediapipe::Status ConfigureTransform(
-      const TimeSeriesHeader& header,
-      const CalculatorOptions& options) override {
-    MelSpectrumCalculatorOptions mel_spectrum_options;
-    time_series_util::FillOptionsExtensionOrDie(options, &mel_spectrum_options);
+  ::mediapipe::Status ConfigureTransform(const TimeSeriesHeader& header,
+                                         CalculatorContext* cc) override {
+    MelSpectrumCalculatorOptions mel_spectrum_options =
+        cc->Options<MelSpectrumCalculatorOptions>();
     mel_filterbank_.reset(new audio_dsp::MelFilterbank());
     int input_length = header.num_channels();
     set_num_output_channels(mel_spectrum_options.channel_count());

mediapipe/calculators/audio/mfcc_mel_calculators_test.cc

@@ -112,7 +112,7 @@ TEST_F(MfccCalculatorTest, AudioSampleRateFromInputHeader) {
   SetupGraphAndHeader();
   SetupRandomInputPackets();
 
-  MEDIAPIPE_EXPECT_OK(Run());
+  MP_EXPECT_OK(Run());
 
   CheckResults(options_.mfcc_count());
 }
@@ -134,7 +134,7 @@ TEST_F(MelSpectrumCalculatorTest, AudioSampleRateFromInputHeader) {
   SetupGraphAndHeader();
   SetupRandomInputPackets();
 
-  MEDIAPIPE_EXPECT_OK(Run());
+  MP_EXPECT_OK(Run());
 
   CheckResults(options_.channel_count());
 }

mediapipe/calculators/audio/rational_factor_resample_calculator.cc

@@ -64,8 +64,8 @@ void CopyVectorToChannel(const std::vector<float>& vec, Matrix* matrix,
 
 ::mediapipe::Status RationalFactorResampleCalculator::Open(
     CalculatorContext* cc) {
-  RationalFactorResampleCalculatorOptions resample_options;
-  time_series_util::FillOptionsExtensionOrDie(cc->Options(), &resample_options);
+  RationalFactorResampleCalculatorOptions resample_options =
+      cc->Options<RationalFactorResampleCalculatorOptions>();
 
   if (!resample_options.has_target_sample_rate()) {
     return tool::StatusInvalid(
@@ -74,7 +74,7 @@ void CopyVectorToChannel(const std::vector<float>& vec, Matrix* matrix,
   target_sample_rate_ = resample_options.target_sample_rate();
 
   TimeSeriesHeader input_header;
-  RETURN_IF_ERROR(time_series_util::FillTimeSeriesHeaderIfValid(
+  MP_RETURN_IF_ERROR(time_series_util::FillTimeSeriesHeaderIfValid(
       cc->Inputs().Index(0).Header(), &input_header));
 
   source_sample_rate_ = input_header.sample_rate();

mediapipe/calculators/audio/rational_factor_resample_calculator_test.cc

@@ -209,25 +209,25 @@ class RationalFactorResampleCalculatorTest
 
 TEST_F(RationalFactorResampleCalculatorTest, Upsample) {
   const double kUpsampleRate = input_sample_rate_ * 1.9;
-  MEDIAPIPE_ASSERT_OK(Run(kUpsampleRate));
+  MP_ASSERT_OK(Run(kUpsampleRate));
   CheckOutput(kUpsampleRate);
 }
 
 TEST_F(RationalFactorResampleCalculatorTest, Downsample) {
   const double kDownsampleRate = input_sample_rate_ / 1.9;
-  MEDIAPIPE_ASSERT_OK(Run(kDownsampleRate));
+  MP_ASSERT_OK(Run(kDownsampleRate));
   CheckOutput(kDownsampleRate);
 }
 
 TEST_F(RationalFactorResampleCalculatorTest, UsesRationalFactorResampler) {
   const double kUpsampleRate = input_sample_rate_ * 2;
-  MEDIAPIPE_ASSERT_OK(Run(kUpsampleRate));
+  MP_ASSERT_OK(Run(kUpsampleRate));
   CheckOutput(kUpsampleRate);
 }
 
 TEST_F(RationalFactorResampleCalculatorTest, PassthroughIfSampleRateUnchanged) {
   const double kUpsampleRate = input_sample_rate_;
-  MEDIAPIPE_ASSERT_OK(Run(kUpsampleRate));
+  MP_ASSERT_OK(Run(kUpsampleRate));
   CheckOutputUnchanged();
 }
 
@@ -239,7 +239,7 @@ TEST_F(RationalFactorResampleCalculatorTest, DoesNotDieOnEmptyInput) {
   options_.set_target_sample_rate(input_sample_rate_);
   InitializeGraph();
   FillInputHeader();
-  MEDIAPIPE_ASSERT_OK(RunGraph());
+  MP_ASSERT_OK(RunGraph());
   EXPECT_TRUE(output().packets.empty());
 }
 

mediapipe/calculators/audio/spectrogram_calculator.cc

@@ -71,10 +71,8 @@ class SpectrogramCalculator : public CalculatorBase {
         // Input stream with TimeSeriesHeader.
     );
 
-    SpectrogramCalculatorOptions spectrogram_options;
-    time_series_util::FillOptionsExtensionOrDie(cc->Options(),
-                                                &spectrogram_options);
-
+    SpectrogramCalculatorOptions spectrogram_options =
+        cc->Options<SpectrogramCalculatorOptions>();
     if (!spectrogram_options.allow_multichannel_input()) {
       if (spectrogram_options.output_type() ==
           SpectrogramCalculatorOptions::COMPLEX) {
@@ -172,9 +170,8 @@ REGISTER_CALCULATOR(SpectrogramCalculator);
 const float SpectrogramCalculator::kLnPowerToDb = 4.342944819032518;
 
 ::mediapipe::Status SpectrogramCalculator::Open(CalculatorContext* cc) {
-  SpectrogramCalculatorOptions spectrogram_options;
-  time_series_util::FillOptionsExtensionOrDie(cc->Options(),
-                                              &spectrogram_options);
+  SpectrogramCalculatorOptions spectrogram_options =
+      cc->Options<SpectrogramCalculatorOptions>();
 
   if (spectrogram_options.frame_duration_seconds() <= 0.0) {
     ::mediapipe::InvalidArgumentErrorBuilder(MEDIAPIPE_LOC)
@@ -197,7 +194,7 @@ const float SpectrogramCalculator::kLnPowerToDb = 4.342944819032518;
   }
 
   TimeSeriesHeader input_header;
-  RETURN_IF_ERROR(time_series_util::FillTimeSeriesHeaderIfValid(
+  MP_RETURN_IF_ERROR(time_series_util::FillTimeSeriesHeaderIfValid(
       cc->Inputs().Index(0).Header(), &input_header));
 
   input_sample_rate_ = input_header.sample_rate();
@@ -223,6 +220,10 @@ const float SpectrogramCalculator::kLnPowerToDb = 4.342944819032518;
 
   std::vector<double> window;
   switch (spectrogram_options.window_type()) {
+    case SpectrogramCalculatorOptions::COSINE:
+      audio_dsp::CosineWindow().GetPeriodicSamples(frame_duration_samples_,
+                                                   &window);
+      break;
     case SpectrogramCalculatorOptions::HANN:
       audio_dsp::HannWindow().GetPeriodicSamples(frame_duration_samples_,
                                                  &window);

mediapipe/calculators/audio/spectrogram_calculator.proto

@@ -58,6 +58,7 @@ message SpectrogramCalculatorOptions {
   enum WindowType {
     HANN = 0;
     HAMMING = 1;
+    COSINE = 2;
   }
   optional WindowType window_type = 6 [default = HANN];
 

mediapipe/calculators/audio/spectrogram_calculator_test.cc

@@ -303,7 +303,7 @@ TEST_F(SpectrogramCalculatorTest, IntegerFrameDurationNoOverlap) {
   FillInputHeader();
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_EQ(OutputFramesPerPacket(), expected_output_packet_sizes);
@@ -324,7 +324,7 @@ TEST_F(SpectrogramCalculatorTest, IntegerFrameDurationSomeOverlap) {
   FillInputHeader();
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_EQ(OutputFramesPerPacket(), expected_output_packet_sizes);
@@ -344,7 +344,7 @@ TEST_F(SpectrogramCalculatorTest, NonintegerFrameDurationAndOverlap) {
   FillInputHeader();
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_EQ(OutputFramesPerPacket(), expected_output_packet_sizes);
@@ -365,7 +365,7 @@ TEST_F(SpectrogramCalculatorTest, ShortInitialPacketNoOverlap) {
   FillInputHeader();
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_EQ(OutputFramesPerPacket(), expected_output_packet_sizes);
@@ -382,7 +382,7 @@ TEST_F(SpectrogramCalculatorTest, TrailingSamplesNoPad) {
   FillInputHeader();
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_EQ(OutputFramesPerPacket(), expected_output_packet_sizes);
@@ -399,7 +399,7 @@ TEST_F(SpectrogramCalculatorTest, NoTrailingSamplesWithPad) {
   FillInputHeader();
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_EQ(OutputFramesPerPacket(), expected_output_packet_sizes);
@@ -418,7 +418,7 @@ TEST_F(SpectrogramCalculatorTest, TrailingSamplesWithPad) {
   FillInputHeader();
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_EQ(OutputFramesPerPacket(), expected_output_packet_sizes);
@@ -435,7 +435,7 @@ TEST_F(SpectrogramCalculatorTest, VeryShortInputWillPad) {
   FillInputHeader();
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_EQ(OutputFramesPerPacket(), expected_output_packet_sizes);
@@ -452,7 +452,7 @@ TEST_F(SpectrogramCalculatorTest, VeryShortInputZeroOutputFramesIfNoPad) {
   FillInputHeader();
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_EQ(OutputFramesPerPacket(), expected_output_packet_sizes);
@@ -468,7 +468,7 @@ TEST_F(SpectrogramCalculatorTest, DCSignalIsPeakBin) {
   // Setup packets with DC input (non-zero constant value).
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   const float dc_frequency_hz = 0.0;
@@ -486,7 +486,7 @@ TEST_F(SpectrogramCalculatorTest, A440ToneIsPeakBin) {
   const float tone_frequency_hz = 440.0;
   SetupCosineInputPackets(input_packet_sizes, tone_frequency_hz);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   int num_output_frames = output().packets[0].Get<Matrix>().cols();
@@ -507,7 +507,7 @@ TEST_F(SpectrogramCalculatorTest, SquaredMagnitudeOutputLooksRight) {
   // Setup packets with DC input (non-zero constant value).
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_FLOAT_EQ(output().packets[0].Get<Matrix>()(0, 0),
@@ -525,7 +525,7 @@ TEST_F(SpectrogramCalculatorTest, DefaultOutputIsSquaredMagnitude) {
   // Setup packets with DC input (non-zero constant value).
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_FLOAT_EQ(output().packets[0].Get<Matrix>()(0, 0),
@@ -543,7 +543,7 @@ TEST_F(SpectrogramCalculatorTest, LinearMagnitudeOutputLooksRight) {
   // Setup packets with DC input (non-zero constant value).
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_FLOAT_EQ(output().packets[0].Get<Matrix>()(0, 0),
@@ -561,7 +561,7 @@ TEST_F(SpectrogramCalculatorTest, DbMagnitudeOutputLooksRight) {
   // Setup packets with DC input (non-zero constant value).
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_FLOAT_EQ(output().packets[0].Get<Matrix>()(0, 0),
@@ -581,7 +581,7 @@ TEST_F(SpectrogramCalculatorTest, OutputScalingLooksRight) {
   // Setup packets with DC input (non-zero constant value).
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_FLOAT_EQ(
@@ -600,7 +600,7 @@ TEST_F(SpectrogramCalculatorTest, ComplexOutputLooksRight) {
   // Setup packets with DC input (non-zero constant value).
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_FLOAT_EQ(std::norm(output().packets[0].Get<Eigen::MatrixXcf>()(0, 0)),
@@ -623,7 +623,7 @@ TEST_F(SpectrogramCalculatorTest, ComplexOutputLooksRightForImpulses) {
   // Make two impulse packets offset one sample from each other
   SetupImpulseInputPackets(input_packet_sizes, input_packet_impulse_offsets);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   const int num_buckets =
@@ -671,7 +671,7 @@ TEST_F(SpectrogramCalculatorTest, SquaredMagnitudeOutputLooksRightForNonDC) {
   const float tone_frequency_hz = target_bin * (input_sample_rate_ / fft_size);
   SetupCosineInputPackets(input_packet_sizes, tone_frequency_hz);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   // For a non-DC bin, the magnitude will be split between positive and
@@ -696,7 +696,7 @@ TEST_F(SpectrogramCalculatorTest, ZeroOutputsForZeroInputsWithPaddingEnabled) {
   FillInputHeader();
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_EQ(OutputFramesPerPacket(), expected_output_packet_sizes);
@@ -713,7 +713,7 @@ TEST_F(SpectrogramCalculatorTest, NumChannelsIsRight) {
   FillInputHeader();
   const float tone_frequency_hz = 440.0;
   SetupCosineInputPackets(input_packet_sizes, tone_frequency_hz);
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   EXPECT_EQ(output().packets[0].Get<std::vector<Matrix>>().size(),
@@ -732,7 +732,7 @@ TEST_F(SpectrogramCalculatorTest, NumSamplesAndPacketRateAreCleared) {
   FillInputHeader();
   SetupConstantInputPackets(input_packet_sizes);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   const TimeSeriesHeader& output_header =
       output().header.Get<TimeSeriesHeader>();
@@ -751,7 +751,7 @@ TEST_F(SpectrogramCalculatorTest, MultichannelSpectrogramSizesAreRight) {
   FillInputHeader();
   const float tone_frequency_hz = 440.0;
   SetupCosineInputPackets(input_packet_sizes, tone_frequency_hz);
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   auto spectrograms = output().packets[0].Get<std::vector<Matrix>>();
@@ -776,7 +776,7 @@ TEST_F(SpectrogramCalculatorTest, MultichannelSpectrogramValuesAreRight) {
   const float tone_frequency_hz = 440.0;
   SetupMultichannelInputPackets(input_packet_sizes, tone_frequency_hz);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   auto spectrograms = output().packets[0].Get<std::vector<Matrix>>();
@@ -805,7 +805,7 @@ TEST_F(SpectrogramCalculatorTest, MultichannelHandlesShortInitialPacket) {
   FillInputHeader();
   const float tone_frequency_hz = 440.0;
   SetupCosineInputPackets(input_packet_sizes, tone_frequency_hz);
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   auto spectrograms = output().packets[0].Get<std::vector<Matrix>>();
@@ -833,7 +833,7 @@ TEST_F(SpectrogramCalculatorTest,
   FillInputHeader();
   const float tone_frequency_hz = 440.0;
   SetupCosineInputPackets(input_packet_sizes, tone_frequency_hz);
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
 
   CheckOutputHeadersAndTimestamps();
   auto spectrograms = output().packets[0].Get<std::vector<Eigen::MatrixXcf>>();

mediapipe/calculators/audio/stabilized_log_calculator.cc

@@ -0,0 +1,94 @@
+// Copyright 2019 The MediaPipe Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Defines StabilizedLogCalculator.
+
+#include <cmath>
+#include <memory>
+#include <string>
+
+#include "mediapipe/calculators/audio/stabilized_log_calculator.pb.h"
+#include "mediapipe/framework/calculator_framework.h"
+#include "mediapipe/framework/formats/matrix.h"
+#include "mediapipe/framework/formats/time_series_header.pb.h"
+#include "mediapipe/framework/port/proto_ns.h"
+#include "mediapipe/util/time_series_util.h"
+
+namespace mediapipe {
+
+// Example config:
+// node {
+//   calculator: "StabilizedLogCalculator"
+//   input_stream: "input_time_series"
+//   output_stream: "stabilized_log_time_series"
+//   options {
+//     [mediapipe.StabilizedLogCalculatorOptions.ext] {
+//       stabilizer: .00001
+//       check_nonnegativity: true
+//     }
+//   }
+// }
+class StabilizedLogCalculator : public CalculatorBase {
+ public:
+  static ::mediapipe::Status GetContract(CalculatorContract* cc) {
+    cc->Inputs().Index(0).Set<Matrix>(
+        // Input stream with TimeSeriesHeader.
+    );
+    cc->Outputs().Index(0).Set<Matrix>(
+        // Output stabilized log stream with TimeSeriesHeader.
+    );
+    return ::mediapipe::OkStatus();
+  }
+
+  ::mediapipe::Status Open(CalculatorContext* cc) override {
+    StabilizedLogCalculatorOptions stabilized_log_calculator_options =
+        cc->Options<StabilizedLogCalculatorOptions>();
+
+    stabilizer_ = stabilized_log_calculator_options.stabilizer();
+    output_scale_ = stabilized_log_calculator_options.output_scale();
+    check_nonnegativity_ =
+        stabilized_log_calculator_options.check_nonnegativity();
+    CHECK_GE(stabilizer_, 0.0)
+        << "stabilizer must be >= 0.0, received a value of " << stabilizer_;
+
+    // If the input packets have a header, propagate the header to the output.
+    if (!cc->Inputs().Index(0).Header().IsEmpty()) {
+      TimeSeriesHeader input_header;
+      MP_RETURN_IF_ERROR(time_series_util::FillTimeSeriesHeaderIfValid(
+          cc->Inputs().Index(0).Header(), &input_header));
+      cc->Outputs().Index(0).SetHeader(
+          Adopt(new TimeSeriesHeader(input_header)));
+    }
+    return ::mediapipe::OkStatus();
+  }
+
+  ::mediapipe::Status Process(CalculatorContext* cc) override {
+    auto input_matrix = cc->Inputs().Index(0).Get<Matrix>();
+    if (check_nonnegativity_) {
+      CHECK_GE(input_matrix.minCoeff(), 0);
+    }
+    std::unique_ptr<Matrix> output_frame(new Matrix(
+        output_scale_ * (input_matrix.array() + stabilizer_).log().matrix()));
+    cc->Outputs().Index(0).Add(output_frame.release(), cc->InputTimestamp());
+    return ::mediapipe::OkStatus();
+  }
+
+ private:
+  float stabilizer_;
+  bool check_nonnegativity_;
+  double output_scale_;
+};
+REGISTER_CALCULATOR(StabilizedLogCalculator);
+
+}  // namespace mediapipe

mediapipe/calculators/audio/stabilized_log_calculator.proto

@@ -0,0 +1,37 @@
+// Copyright 2019 The MediaPipe Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto2";
+
+package mediapipe;
+
+import "mediapipe/framework/calculator.proto";
+
+message StabilizedLogCalculatorOptions {
+  extend CalculatorOptions {
+    optional StabilizedLogCalculatorOptions ext = 101978339;
+  }
+
+  // The calculator computes log(x + stabilizer). stabilizer must be >=
+  // 0, with 0 indicating a lack of stabilization.
+  optional float stabilizer = 1 [default = .00001];
+
+  // If true, CHECK that all input values in are >= 0. If false, the
+  // code will take the log of the potentially negative input values
+  // plus the stabilizer.
+  optional bool check_nonnegativity = 2 [default = true];
+
+  // Support a fixed multiplicative scaling of the output.
+  optional double output_scale = 3 [default = 1.0];
+}

mediapipe/calculators/audio/stabilized_log_calculator_test.cc

@@ -0,0 +1,131 @@
+// Copyright 2019 The MediaPipe Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Eigen/Core"
+#include "mediapipe/calculators/audio/stabilized_log_calculator.pb.h"
+#include "mediapipe/framework/calculator_framework.h"
+#include "mediapipe/framework/calculator_runner.h"
+#include "mediapipe/framework/formats/matrix.h"
+#include "mediapipe/framework/formats/time_series_header.pb.h"
+#include "mediapipe/framework/port/gmock.h"
+#include "mediapipe/framework/port/gtest.h"
+#include "mediapipe/framework/port/integral_types.h"
+#include "mediapipe/framework/port/status_matchers.h"
+#include "mediapipe/util/time_series_test_util.h"
+
+namespace mediapipe {
+
+const float kStabilizer = 0.1;
+const int kNumChannels = 3;
+const int kNumSamples = 10;
+
+class StabilizedLogCalculatorTest
+    : public TimeSeriesCalculatorTest<StabilizedLogCalculatorOptions> {
+ protected:
+  void SetUp() override {
+    calculator_name_ = "StabilizedLogCalculator";
+    options_.set_stabilizer(kStabilizer);
+
+    input_sample_rate_ = 8000.0;
+    num_input_channels_ = kNumChannels;
+    num_input_samples_ = kNumSamples;
+  }
+
+  void RunGraphNoReturn() { MP_ASSERT_OK(RunGraph()); }
+};
+
+TEST_F(StabilizedLogCalculatorTest, BasicOperation) {
+  const int kNumPackets = 5;
+
+  InitializeGraph();
+  FillInputHeader();
+
+  std::vector<Matrix> input_data_matrices;
+  for (int input_packet = 0; input_packet < kNumPackets; ++input_packet) {
+    const int64 timestamp = input_packet * Timestamp::kTimestampUnitsPerSecond;
+    Matrix input_data_matrix =
+        Matrix::Random(kNumChannels, kNumSamples).array().abs();
+    input_data_matrices.push_back(input_data_matrix);
+    AppendInputPacket(new Matrix(input_data_matrix), timestamp);
+  }
+
+  MP_ASSERT_OK(RunGraph());
+  ExpectOutputHeaderEqualsInputHeader();
+  for (int output_packet = 0; output_packet < kNumPackets; ++output_packet) {
+    ExpectApproximatelyEqual(
+        (input_data_matrices[output_packet].array() + kStabilizer).log(),
+        runner_->Outputs().Index(0).packets[output_packet].Get<Matrix>());
+  }
+}
+
+TEST_F(StabilizedLogCalculatorTest, OutputScaleWorks) {
+  const int kNumPackets = 5;
+  double output_scale = 2.5;
+  options_.set_output_scale(output_scale);
+
+  InitializeGraph();
+  FillInputHeader();
+
+  std::vector<Matrix> input_data_matrices;
+  for (int input_packet = 0; input_packet < kNumPackets; ++input_packet) {
+    const int64 timestamp = input_packet * Timestamp::kTimestampUnitsPerSecond;
+    Matrix input_data_matrix =
+        Matrix::Random(kNumChannels, kNumSamples).array().abs();
+    input_data_matrices.push_back(input_data_matrix);
+    AppendInputPacket(new Matrix(input_data_matrix), timestamp);
+  }
+
+  MP_ASSERT_OK(RunGraph());
+  ExpectOutputHeaderEqualsInputHeader();
+  for (int output_packet = 0; output_packet < kNumPackets; ++output_packet) {
+    ExpectApproximatelyEqual(
+        output_scale *
+            ((input_data_matrices[output_packet].array() + kStabilizer).log()),
+        runner_->Outputs().Index(0).packets[output_packet].Get<Matrix>());
+  }
+}
+
+TEST_F(StabilizedLogCalculatorTest, ZerosAreStabilized) {
+  InitializeGraph();
+  FillInputHeader();
+  AppendInputPacket(new Matrix(Matrix::Zero(kNumChannels, kNumSamples)),
+                    0 /* timestamp */);
+  MP_ASSERT_OK(RunGraph());
+  ExpectOutputHeaderEqualsInputHeader();
+  ExpectApproximatelyEqual(
+      Matrix::Constant(kNumChannels, kNumSamples, kStabilizer).array().log(),
+      runner_->Outputs().Index(0).packets[0].Get<Matrix>());
+}
+
+TEST_F(StabilizedLogCalculatorTest, NegativeValuesCheckFail) {
+  InitializeGraph();
+  FillInputHeader();
+  AppendInputPacket(
+      new Matrix(Matrix::Constant(kNumChannels, kNumSamples, -1.0)),
+      0 /* timestamp */);
+  ASSERT_DEATH(RunGraphNoReturn(), "");
+}
+
+TEST_F(StabilizedLogCalculatorTest, NegativeValuesDoNotCheckFailIfCheckIsOff) {
+  options_.set_check_nonnegativity(false);
+  InitializeGraph();
+  FillInputHeader();
+  AppendInputPacket(
+      new Matrix(Matrix::Constant(kNumChannels, kNumSamples, -1.0)),
+      0 /* timestamp */);
+  MP_ASSERT_OK(RunGraph());
+  // Results are undefined.
+}
+
+}  // namespace mediapipe

mediapipe/calculators/audio/time_series_framer_calculator.cc

@@ -206,8 +206,8 @@ void TimeSeriesFramerCalculator::FrameOutput(CalculatorContext* cc) {
 }
 
 ::mediapipe::Status TimeSeriesFramerCalculator::Open(CalculatorContext* cc) {
-  TimeSeriesFramerCalculatorOptions framer_options;
-  time_series_util::FillOptionsExtensionOrDie(cc->Options(), &framer_options);
+  TimeSeriesFramerCalculatorOptions framer_options =
+      cc->Options<TimeSeriesFramerCalculatorOptions>();
 
   RET_CHECK_GT(framer_options.frame_duration_seconds(), 0.0)
       << "Invalid or missing frame_duration_seconds. "
@@ -219,7 +219,7 @@ void TimeSeriesFramerCalculator::FrameOutput(CalculatorContext* cc) {
       << framer_options.frame_overlap_seconds();
 
   TimeSeriesHeader input_header;
-  RETURN_IF_ERROR(time_series_util::FillTimeSeriesHeaderIfValid(
+  MP_RETURN_IF_ERROR(time_series_util::FillTimeSeriesHeaderIfValid(
       cc->Inputs().Index(0).Header(), &input_header));
 
   sample_rate_ = input_header.sample_rate();

mediapipe/calculators/audio/time_series_framer_calculator_test.cc

@@ -226,7 +226,7 @@ class TimeSeriesFramerCalculatorTest
 
 TEST_F(TimeSeriesFramerCalculatorTest, IntegerSampleDurationNoOverlap) {
   options_.set_frame_duration_seconds(100.0 / input_sample_rate_);
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
   CheckOutput();
 }
 
@@ -234,7 +234,7 @@ TEST_F(TimeSeriesFramerCalculatorTest,
        IntegerSampleDurationNoOverlapHammingWindow) {
   options_.set_frame_duration_seconds(100.0 / input_sample_rate_);
   options_.set_window_function(TimeSeriesFramerCalculatorOptions::HAMMING);
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
   CheckOutput();
 }
 
@@ -242,14 +242,14 @@ TEST_F(TimeSeriesFramerCalculatorTest,
        IntegerSampleDurationNoOverlapHannWindow) {
   options_.set_frame_duration_seconds(100.0 / input_sample_rate_);
   options_.set_window_function(TimeSeriesFramerCalculatorOptions::HANN);
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
   CheckOutput();
 }
 
 TEST_F(TimeSeriesFramerCalculatorTest, IntegerSampleDurationAndOverlap) {
   options_.set_frame_duration_seconds(100.0 / input_sample_rate_);
   options_.set_frame_overlap_seconds(40.0 / input_sample_rate_);
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
   CheckOutput();
 }
 
@@ -257,7 +257,7 @@ TEST_F(TimeSeriesFramerCalculatorTest, NonintegerSampleDurationAndOverlap) {
   options_.set_frame_duration_seconds(98.5 / input_sample_rate_);
   options_.set_frame_overlap_seconds(38.4 / input_sample_rate_);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
   CheckOutput();
 }
 
@@ -267,7 +267,7 @@ TEST_F(TimeSeriesFramerCalculatorTest, NegativeOverlapExactFrames) {
   // the 1100 input samples.
   options_.set_frame_duration_seconds(100.0 / input_sample_rate_);
   options_.set_frame_overlap_seconds(-10.0 / input_sample_rate_);
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
   EXPECT_EQ(output().packets.size(), 10);
   CheckOutput();
 }
@@ -277,7 +277,7 @@ TEST_F(TimeSeriesFramerCalculatorTest, NegativeOverlapExactFramesLessSkip) {
   // the 1100 input samples.
   options_.set_frame_duration_seconds(100.0 / input_sample_rate_);
   options_.set_frame_overlap_seconds(-100.0 / input_sample_rate_);
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
   EXPECT_EQ(output().packets.size(), 6);
   CheckOutput();
 }
@@ -287,7 +287,7 @@ TEST_F(TimeSeriesFramerCalculatorTest, NegativeOverlapWithPadding) {
   // on the sixth and last frame given 1100 sample input.
   options_.set_frame_duration_seconds(100.0 / input_sample_rate_);
   options_.set_frame_overlap_seconds(-100.0 / input_sample_rate_);
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
   EXPECT_EQ(output().packets.size(), 6);
   CheckOutput();
 }
@@ -297,7 +297,7 @@ TEST_F(TimeSeriesFramerCalculatorTest, FixedFrameOverlap) {
   // results in ceil((1100 - 30) / 11) + 1 = 99 packets.
   options_.set_frame_duration_seconds(30 / input_sample_rate_);
   options_.set_frame_overlap_seconds((30.0 - 11.4) / input_sample_rate_);
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
   EXPECT_EQ(output().packets.size(), 99);
   CheckOutput();
 }
@@ -308,7 +308,7 @@ TEST_F(TimeSeriesFramerCalculatorTest, VariableFrameOverlap) {
   options_.set_frame_duration_seconds(30 / input_sample_rate_);
   options_.set_frame_overlap_seconds((30 - 11.4) / input_sample_rate_);
   options_.set_emulate_fractional_frame_overlap(true);
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
   EXPECT_EQ(output().packets.size(), 95);
   CheckOutput();
 }
@@ -319,7 +319,7 @@ TEST_F(TimeSeriesFramerCalculatorTest, VariableFrameSkip) {
   options_.set_frame_duration_seconds(30 / input_sample_rate_);
   options_.set_frame_overlap_seconds((30 - 41.4) / input_sample_rate_);
   options_.set_emulate_fractional_frame_overlap(true);
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
   EXPECT_EQ(output().packets.size(), 27);
   CheckOutput();
 }
@@ -328,7 +328,7 @@ TEST_F(TimeSeriesFramerCalculatorTest, NoFinalPacketPadding) {
   options_.set_frame_duration_seconds(98.5 / input_sample_rate_);
   options_.set_pad_final_packet(false);
 
-  MEDIAPIPE_ASSERT_OK(Run());
+  MP_ASSERT_OK(Run());
   CheckOutput();
 }
 
@@ -369,7 +369,7 @@ class TimeSeriesFramerCalculatorWindowingSanityTest
     FillInputHeader();
     AppendInputPacket(new Matrix(Matrix::Ones(1, FrameDurationSamples())),
                       kInitialTimestampOffsetMicroseconds);
-    MEDIAPIPE_ASSERT_OK(RunGraph());
+    MP_ASSERT_OK(RunGraph());
     ASSERT_EQ(1, output().packets.size());
     ASSERT_NEAR(expected_average * FrameDurationSamples(),
                 output().packets[0].Get<Matrix>().sum(), 1e-5);

mediapipe/calculators/core/BUILD

@@ -76,7 +76,7 @@ mediapipe_cc_proto_library(
     name = "packet_cloner_calculator_cc_proto",
     srcs = ["packet_cloner_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":packet_cloner_calculator_proto"],
 )
 
@@ -84,7 +84,7 @@ mediapipe_cc_proto_library(
     name = "packet_resampler_calculator_cc_proto",
     srcs = ["packet_resampler_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":packet_resampler_calculator_proto"],
 )
 
@@ -92,7 +92,7 @@ mediapipe_cc_proto_library(
     name = "split_vector_calculator_cc_proto",
     srcs = ["split_vector_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":split_vector_calculator_proto"],
 )
 
@@ -108,7 +108,7 @@ mediapipe_cc_proto_library(
     name = "quantize_float_vector_calculator_cc_proto",
     srcs = ["quantize_float_vector_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":quantize_float_vector_calculator_proto"],
 )
 
@@ -116,7 +116,7 @@ mediapipe_cc_proto_library(
     name = "sequence_shift_calculator_cc_proto",
     srcs = ["sequence_shift_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":sequence_shift_calculator_proto"],
 )
 
@@ -124,7 +124,7 @@ mediapipe_cc_proto_library(
     name = "gate_calculator_cc_proto",
     srcs = ["gate_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":gate_calculator_proto"],
 )
 
@@ -162,6 +162,7 @@ cc_library(
     deps = [
         ":concatenate_vector_calculator_cc_proto",
         "//mediapipe/framework:calculator_framework",
+        "//mediapipe/framework/formats:landmark_cc_proto",
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
         "@org_tensorflow//tensorflow/lite:framework",
@@ -523,6 +524,7 @@ cc_library(
     deps = [
         ":split_vector_calculator_cc_proto",
         "//mediapipe/framework:calculator_framework",
+        "//mediapipe/framework/formats:landmark_cc_proto",
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
         "//mediapipe/util:resource_util",
@@ -627,6 +629,41 @@ cc_test(
     ],
 )
 
+cc_library(
+    name = "matrix_to_vector_calculator",
+    srcs = ["matrix_to_vector_calculator.cc"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//mediapipe/framework:calculator_framework",
+        "//mediapipe/framework/formats:matrix",
+        "//mediapipe/framework/port:integral_types",
+        "//mediapipe/framework/port:logging",
+        "//mediapipe/framework/port:parse_text_proto",
+        "//mediapipe/framework/tool:status_util",
+        "//mediapipe/util:time_series_util",
+        "@com_google_absl//absl/memory",
+        "@eigen_archive//:eigen",
+    ],
+    alwayslink = 1,
+)
+
+cc_test(
+    name = "matrix_to_vector_calculator_test",
+    srcs = ["matrix_to_vector_calculator_test.cc"],
+    deps = [
+        ":matrix_to_vector_calculator",
+        "//mediapipe/framework:calculator_runner",
+        "//mediapipe/framework/formats:matrix",
+        "//mediapipe/framework/port:gtest_main",
+        "//mediapipe/framework/port:integral_types",
+        "//mediapipe/framework/port:parse_text_proto",
+        "//mediapipe/framework/port:status",
+        "//mediapipe/framework/tool:validate_type",
+        "//mediapipe/util:time_series_test_util",
+        "//mediapipe/util:time_series_util",
+    ],
+)
+
 cc_library(
     name = "merge_calculator",
     srcs = ["merge_calculator.cc"],

mediapipe/calculators/core/add_header_calculator_test.cc

@@ -42,7 +42,7 @@ TEST_F(AddHeaderCalculatorTest, Works) {
   }
 
   // Run calculator.
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
 
   ASSERT_EQ(1, runner.Outputs().NumEntries());
 
@@ -69,7 +69,7 @@ TEST_F(AddHeaderCalculatorTest, HandlesEmptyHeaderStream) {
 
   // No header and no packets.
   // Run calculator.
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   EXPECT_TRUE(runner.Outputs().Index(0).header.IsEmpty());
 }
 

mediapipe/calculators/core/concatenate_vector_calculator.cc

@@ -16,6 +16,7 @@
 
 #include <vector>
 
+#include "mediapipe/framework/formats/landmark.pb.h"
 #include "tensorflow/lite/interpreter.h"
 
 namespace mediapipe {
@@ -41,4 +42,7 @@ typedef ConcatenateVectorCalculator<TfLiteTensor>
     ConcatenateTfLiteTensorVectorCalculator;
 REGISTER_CALCULATOR(ConcatenateTfLiteTensorVectorCalculator);
 
+typedef ConcatenateVectorCalculator<::mediapipe::NormalizedLandmark>
+    ConcatenateLandmarkVectorCalculator;
+REGISTER_CALCULATOR(ConcatenateLandmarkVectorCalculator);
 }  // namespace mediapipe

mediapipe/calculators/core/concatenate_vector_calculator_test.cc

@@ -45,7 +45,7 @@ TEST(TestConcatenateIntVectorCalculatorTest, EmptyVectorInputs) {
 
   std::vector<std::vector<int>> inputs = {{}, {}, {}};
   AddInputVectors(inputs, /*timestamp=*/1, &runner);
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
 
   const std::vector<Packet>& outputs = runner.Outputs().Index(0).packets;
   EXPECT_EQ(1, outputs.size());
@@ -60,7 +60,7 @@ TEST(TestConcatenateIntVectorCalculatorTest, OneTimestamp) {
 
   std::vector<std::vector<int>> inputs = {{1, 2, 3}, {4}, {5, 6}};
   AddInputVectors(inputs, /*timestamp=*/1, &runner);
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
 
   const std::vector<Packet>& outputs = runner.Outputs().Index(0).packets;
   EXPECT_EQ(1, outputs.size());
@@ -81,7 +81,7 @@ TEST(TestConcatenateIntVectorCalculatorTest, TwoInputsAtTwoTimestamps) {
     std::vector<std::vector<int>> inputs = {{0, 2}, {1}, {3, 5}};
     AddInputVectors(inputs, /*timestamp=*/2, &runner);
   }
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
 
   const std::vector<Packet>& outputs = runner.Outputs().Index(0).packets;
   EXPECT_EQ(2, outputs.size());
@@ -106,7 +106,7 @@ TEST(TestConcatenateIntVectorCalculatorTest, OneEmptyStreamStillOutput) {
 
   std::vector<std::vector<int>> inputs = {{1, 2, 3}};
   AddInputVectors(inputs, /*timestamp=*/1, &runner);
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
 
   const std::vector<Packet>& outputs = runner.Outputs().Index(0).packets;
   EXPECT_EQ(1, outputs.size());
@@ -125,7 +125,7 @@ TEST(TestConcatenateIntVectorCalculatorTest, OneEmptyStreamNoOutput) {
 
   std::vector<std::vector<int>> inputs = {{1, 2, 3}};
   AddInputVectors(inputs, /*timestamp=*/1, &runner);
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
 
   const std::vector<Packet>& outputs = runner.Outputs().Index(0).packets;
   EXPECT_EQ(0, outputs.size());
@@ -146,7 +146,7 @@ TEST(ConcatenateFloatVectorCalculatorTest, EmptyVectorInputs) {
 
   std::vector<std::vector<float>> inputs = {{}, {}, {}};
   AddInputVectors(inputs, /*timestamp=*/1, &runner);
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
 
   const std::vector<Packet>& outputs = runner.Outputs().Index(0).packets;
   EXPECT_EQ(1, outputs.size());
@@ -162,7 +162,7 @@ TEST(ConcatenateFloatVectorCalculatorTest, OneTimestamp) {
   std::vector<std::vector<float>> inputs = {
       {1.0f, 2.0f, 3.0f}, {4.0f}, {5.0f, 6.0f}};
   AddInputVectors(inputs, /*timestamp=*/1, &runner);
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
 
   const std::vector<Packet>& outputs = runner.Outputs().Index(0).packets;
   EXPECT_EQ(1, outputs.size());
@@ -185,7 +185,7 @@ TEST(ConcatenateFloatVectorCalculatorTest, TwoInputsAtTwoTimestamps) {
         {0.0f, 2.0f}, {1.0f}, {3.0f, 5.0f}};
     AddInputVectors(inputs, /*timestamp=*/2, &runner);
   }
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
 
   const std::vector<Packet>& outputs = runner.Outputs().Index(0).packets;
   EXPECT_EQ(2, outputs.size());
@@ -210,7 +210,7 @@ TEST(ConcatenateFloatVectorCalculatorTest, OneEmptyStreamStillOutput) {
 
   std::vector<std::vector<float>> inputs = {{1.0f, 2.0f, 3.0f}};
   AddInputVectors(inputs, /*timestamp=*/1, &runner);
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
 
   const std::vector<Packet>& outputs = runner.Outputs().Index(0).packets;
   EXPECT_EQ(1, outputs.size());
@@ -229,7 +229,7 @@ TEST(ConcatenateFloatVectorCalculatorTest, OneEmptyStreamNoOutput) {
 
   std::vector<std::vector<float>> inputs = {{1.0f, 2.0f, 3.0f}};
   AddInputVectors(inputs, /*timestamp=*/1, &runner);
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
 
   const std::vector<Packet>& outputs = runner.Outputs().Index(0).packets;
   EXPECT_EQ(0, outputs.size());

mediapipe/calculators/core/flow_limiter_calculator_test.cc

@@ -91,7 +91,7 @@ TEST(FlowLimiterCalculator, OneOutputTest) {
   }
 
   // Run the calculator.
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& frame_output_packets =
       runner.Outputs().Index(0).packets;
 
@@ -117,7 +117,7 @@ TEST(FlowLimiterCalculator, BasicTest) {
   }
 
   // Run the calculator.
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& frame_output_packets =
       runner.Outputs().Index(0).packets;
 
@@ -198,7 +198,7 @@ class FlowLimiterCalculatorTest : public testing::Test {
       close_count_++;
       return ::mediapipe::OkStatus();
     };
-    MEDIAPIPE_ASSERT_OK(graph_.Initialize(
+    MP_ASSERT_OK(graph_.Initialize(
         graph_config_, {
                            {"max_in_flight", MakePacket<int>(max_in_flight)},
                            {"callback_0", Adopt(new auto(semaphore_0_func))},
@@ -209,7 +209,7 @@ class FlowLimiterCalculatorTest : public testing::Test {
 
   // Adds a packet to a graph input stream.
   void AddPacket(const std::string& input_name, int value) {
-    MEDIAPIPE_EXPECT_OK(graph_.AddPacketToInputStream(
+    MP_EXPECT_OK(graph_.AddPacketToInputStream(
         input_name, MakePacket<int>(value).At(Timestamp(value))));
   }
 
@@ -277,10 +277,10 @@ class FlowLimiterCalculatorTest : public testing::Test {
 //
 TEST_F(FlowLimiterCalculatorTest, BackEdgeCloses) {
   InitializeGraph(1);
-  MEDIAPIPE_ASSERT_OK(graph_.StartRun({}));
+  MP_ASSERT_OK(graph_.StartRun({}));
 
   auto send_packet = [this](const std::string& input_name, int64 n) {
-    MEDIAPIPE_EXPECT_OK(graph_.AddPacketToInputStream(
+    MP_EXPECT_OK(graph_.AddPacketToInputStream(
         input_name, MakePacket<int64>(n).At(Timestamp(n))));
   };
 
@@ -288,14 +288,14 @@ TEST_F(FlowLimiterCalculatorTest, BackEdgeCloses) {
     send_packet("in_1", i * 10);
     // This next input should be dropped.
     send_packet("in_1", i * 10 + 5);
-    MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+    MP_EXPECT_OK(graph_.WaitUntilIdle());
     send_packet("in_2", i * 10);
     exit_semaphore_.Release(1);
-    MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+    MP_EXPECT_OK(graph_.WaitUntilIdle());
   }
-  MEDIAPIPE_EXPECT_OK(graph_.CloseInputStream("in_1"));
-  MEDIAPIPE_EXPECT_OK(graph_.CloseInputStream("in_2"));
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+  MP_EXPECT_OK(graph_.CloseInputStream("in_1"));
+  MP_EXPECT_OK(graph_.CloseInputStream("in_2"));
+  MP_EXPECT_OK(graph_.WaitUntilIdle());
 
   // All output streams are closed and all output packets are delivered,
   // with stream "in_1" and stream "in_2" closed.
@@ -321,17 +321,17 @@ TEST_F(FlowLimiterCalculatorTest, BackEdgeCloses) {
 // input streams are closed after the last input packet has been processed.
 TEST_F(FlowLimiterCalculatorTest, AllStreamsClose) {
   InitializeGraph(1);
-  MEDIAPIPE_ASSERT_OK(graph_.StartRun({}));
+  MP_ASSERT_OK(graph_.StartRun({}));
 
   exit_semaphore_.Release(10);
   for (int i = 0; i < 10; i++) {
     AddPacket("in_1", i);
-    MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+    MP_EXPECT_OK(graph_.WaitUntilIdle());
     AddPacket("in_2", i);
-    MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+    MP_EXPECT_OK(graph_.WaitUntilIdle());
   }
-  MEDIAPIPE_EXPECT_OK(graph_.CloseAllInputStreams());
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+  MP_EXPECT_OK(graph_.CloseAllInputStreams());
+  MP_EXPECT_OK(graph_.WaitUntilIdle());
 
   EXPECT_EQ(TimestampValues(out_1_packets_), TimestampValues(out_2_packets_));
   EXPECT_EQ(TimestampValues(out_1_packets_),
@@ -371,7 +371,7 @@ TEST(FlowLimiterCalculator, TwoStreams) {
   };
 
   CalculatorGraph graph_;
-  MEDIAPIPE_EXPECT_OK(graph_.Initialize(
+  MP_EXPECT_OK(graph_.Initialize(
       graph_config_,
       {
           {"max_in_flight", MakePacket<int>(1)},
@@ -379,63 +379,63 @@ TEST(FlowLimiterCalculator, TwoStreams) {
            MakePacket<std::function<void(const Packet&)>>(allow_cb)},
       }));
 
-  MEDIAPIPE_EXPECT_OK(graph_.StartRun({}));
+  MP_EXPECT_OK(graph_.StartRun({}));
 
   auto send_packet = [&graph_](const std::string& input_name, int n) {
-    MEDIAPIPE_EXPECT_OK(graph_.AddPacketToInputStream(
+    MP_EXPECT_OK(graph_.AddPacketToInputStream(
         input_name, MakePacket<int>(n).At(Timestamp(n))));
   };
   send_packet("in_a", 1);
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+  MP_EXPECT_OK(graph_.WaitUntilIdle());
   EXPECT_EQ(allow, false);
   EXPECT_EQ(TimestampValues(a_passed), (std::vector<int64>{1}));
   EXPECT_EQ(TimestampValues(b_passed), (std::vector<int64>{}));
 
   send_packet("in_a", 2);
   send_packet("in_b", 1);
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+  MP_EXPECT_OK(graph_.WaitUntilIdle());
   EXPECT_EQ(TimestampValues(a_passed), (std::vector<int64>{1}));
   EXPECT_EQ(TimestampValues(b_passed), (std::vector<int64>{1}));
   EXPECT_EQ(allow, false);
 
   send_packet("finished", 1);
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+  MP_EXPECT_OK(graph_.WaitUntilIdle());
   EXPECT_EQ(TimestampValues(a_passed), (std::vector<int64>{1}));
   EXPECT_EQ(TimestampValues(b_passed), (std::vector<int64>{1}));
   EXPECT_EQ(allow, true);
 
   send_packet("in_b", 2);
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+  MP_EXPECT_OK(graph_.WaitUntilIdle());
   EXPECT_EQ(TimestampValues(a_passed), (std::vector<int64>{1}));
   EXPECT_EQ(TimestampValues(b_passed), (std::vector<int64>{1}));
   EXPECT_EQ(allow, true);
 
   send_packet("in_b", 3);
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+  MP_EXPECT_OK(graph_.WaitUntilIdle());
   EXPECT_EQ(TimestampValues(a_passed), (std::vector<int64>{1}));
   EXPECT_EQ(TimestampValues(b_passed), (std::vector<int64>{1, 3}));
   EXPECT_EQ(allow, false);
 
   send_packet("in_b", 4);
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+  MP_EXPECT_OK(graph_.WaitUntilIdle());
   EXPECT_EQ(TimestampValues(a_passed), (std::vector<int64>{1}));
   EXPECT_EQ(TimestampValues(b_passed), (std::vector<int64>{1, 3}));
   EXPECT_EQ(allow, false);
 
   send_packet("in_a", 3);
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+  MP_EXPECT_OK(graph_.WaitUntilIdle());
   EXPECT_EQ(TimestampValues(a_passed), (std::vector<int64>{1, 3}));
   EXPECT_EQ(TimestampValues(b_passed), (std::vector<int64>{1, 3}));
   EXPECT_EQ(allow, false);
 
   send_packet("finished", 3);
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+  MP_EXPECT_OK(graph_.WaitUntilIdle());
   EXPECT_EQ(TimestampValues(a_passed), (std::vector<int64>{1, 3}));
   EXPECT_EQ(TimestampValues(b_passed), (std::vector<int64>{1, 3}));
   EXPECT_EQ(allow, true);
 
-  MEDIAPIPE_EXPECT_OK(graph_.CloseAllInputStreams());
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilDone());
+  MP_EXPECT_OK(graph_.CloseAllInputStreams());
+  MP_EXPECT_OK(graph_.WaitUntilDone());
 }
 
 TEST(FlowLimiterCalculator, CanConsume) {
@@ -465,7 +465,7 @@ TEST(FlowLimiterCalculator, CanConsume) {
   };
 
   CalculatorGraph graph_;
-  MEDIAPIPE_EXPECT_OK(graph_.Initialize(
+  MP_EXPECT_OK(graph_.Initialize(
       graph_config_,
       {
           {"max_in_flight", MakePacket<int>(1)},
@@ -473,21 +473,21 @@ TEST(FlowLimiterCalculator, CanConsume) {
            MakePacket<std::function<void(const Packet&)>>(allow_cb)},
       }));
 
-  MEDIAPIPE_EXPECT_OK(graph_.StartRun({}));
+  MP_EXPECT_OK(graph_.StartRun({}));
 
   auto send_packet = [&graph_](const std::string& input_name, int n) {
-    MEDIAPIPE_EXPECT_OK(graph_.AddPacketToInputStream(
+    MP_EXPECT_OK(graph_.AddPacketToInputStream(
         input_name, MakePacket<int>(n).At(Timestamp(n))));
   };
   send_packet("in", 1);
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+  MP_EXPECT_OK(graph_.WaitUntilIdle());
   EXPECT_EQ(allow, false);
   EXPECT_EQ(TimestampValues(in_sampled_packets_), (std::vector<int64>{1}));
 
-  MEDIAPIPE_EXPECT_OK(in_sampled_packets_[0].Consume<int>());
+  MP_EXPECT_OK(in_sampled_packets_[0].Consume<int>());
 
-  MEDIAPIPE_EXPECT_OK(graph_.CloseAllInputStreams());
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilDone());
+  MP_EXPECT_OK(graph_.CloseAllInputStreams());
+  MP_EXPECT_OK(graph_.WaitUntilDone());
 }
 
 }  // anonymous namespace

mediapipe/calculators/core/gate_calculator_test.cc

@@ -32,7 +32,7 @@ class GateCalculatorTest : public ::testing::Test {
         ->Tag(control_tag)
         .packets.push_back(MakePacket<bool>(control).At(Timestamp(timestamp)));
 
-    MEDIAPIPE_ASSERT_OK(runner_->Run()) << "Calculator execution failed.";
+    MP_ASSERT_OK(runner_->Run()) << "Calculator execution failed.";
   }
 
   void SetRunner(const std::string& proto) {

mediapipe/calculators/core/immediate_mux_calculator_test.cc

@@ -217,23 +217,23 @@ class ImmediateMuxCalculatorTest : public ::testing::Test {
 
     // Start running the graph.
     CalculatorGraph graph;
-    MEDIAPIPE_ASSERT_OK(graph.Initialize(graph_config_));
-    MEDIAPIPE_ASSERT_OK(graph.StartRun({}));
+    MP_ASSERT_OK(graph.Initialize(graph_config_));
+    MP_ASSERT_OK(graph.StartRun({}));
 
     // Send each packet to the graph in the specified order.
     for (int t = 0; t < input_sets.size(); t++) {
       const std::vector<Packet>& input_set = input_sets[t];
-      MEDIAPIPE_EXPECT_OK(graph.WaitUntilIdle());
+      MP_EXPECT_OK(graph.WaitUntilIdle());
       for (int i = 0; i < input_set.size(); i++) {
         const Packet& packet = input_set[i];
         if (!IsNone(packet)) {
-          MEDIAPIPE_EXPECT_OK(graph.AddPacketToInputStream(
+          MP_EXPECT_OK(graph.AddPacketToInputStream(
               absl::StrCat("input_packets_", i), packet));
         }
       }
     }
-    MEDIAPIPE_ASSERT_OK(graph.CloseAllInputStreams());
-    MEDIAPIPE_ASSERT_OK(graph.WaitUntilDone());
+    MP_ASSERT_OK(graph.CloseAllInputStreams());
+    MP_ASSERT_OK(graph.WaitUntilDone());
   }
 
   CalculatorGraphConfig graph_config_;
@@ -335,22 +335,22 @@ TEST_F(ImmediateMuxCalculatorTest, Demux) {
 
   // Start the graph and add five input packets.
   CalculatorGraph graph;
-  MEDIAPIPE_ASSERT_OK(graph.Initialize(
-      graph_config_, {
-                         {"callback_0", Adopt(new auto(wait_0))},
-                         {"callback_1", Adopt(new auto(wait_1))},
-                     }));
-  MEDIAPIPE_ASSERT_OK(graph.ObserveOutputStream("output_packets_0", out_cb));
-  MEDIAPIPE_ASSERT_OK(graph.StartRun({}));
-  MEDIAPIPE_EXPECT_OK(
+  MP_ASSERT_OK(graph.Initialize(graph_config_,
+                                {
+                                    {"callback_0", Adopt(new auto(wait_0))},
+                                    {"callback_1", Adopt(new auto(wait_1))},
+                                }));
+  MP_ASSERT_OK(graph.ObserveOutputStream("output_packets_0", out_cb));
+  MP_ASSERT_OK(graph.StartRun({}));
+  MP_EXPECT_OK(
       graph.AddPacketToInputStream("input_packets_0", PacketAt(10000)));
-  MEDIAPIPE_EXPECT_OK(
+  MP_EXPECT_OK(
       graph.AddPacketToInputStream("input_packets_0", PacketAt(20000)));
-  MEDIAPIPE_EXPECT_OK(
+  MP_EXPECT_OK(
       graph.AddPacketToInputStream("input_packets_0", PacketAt(30000)));
-  MEDIAPIPE_EXPECT_OK(
+  MP_EXPECT_OK(
       graph.AddPacketToInputStream("input_packets_0", PacketAt(40000)));
-  MEDIAPIPE_EXPECT_OK(
+  MP_EXPECT_OK(
       graph.AddPacketToInputStream("input_packets_0", PacketAt(50000)));
 
   // Release the outputs in order 20000, 10000, 30000, 50000, 40000.
@@ -362,8 +362,8 @@ TEST_F(ImmediateMuxCalculatorTest, Demux) {
   semaphore_0.Release(1);  // 50000
   wait_for([&] { return out_packets.size() >= 3; });
   semaphore_1.Release(1);  // 40000
-  MEDIAPIPE_ASSERT_OK(graph.CloseAllInputStreams());
-  MEDIAPIPE_ASSERT_OK(graph.WaitUntilDone());
+  MP_ASSERT_OK(graph.CloseAllInputStreams());
+  MP_ASSERT_OK(graph.WaitUntilDone());
 
   // Output packets 10000 and 40000 are superseded and dropped.
   EXPECT_THAT(TimestampValues(out_packets), ElementsAre(20000, 30000, 50000));

mediapipe/calculators/core/matrix_multiply_calculator_test.cc

@@ -219,7 +219,7 @@ TEST(MatrixMultiplyCalculatorTest, Multiply) {
         Adopt(sample).At(Timestamp(i)));
   }
 
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   EXPECT_EQ(runner.MutableInputs()->Index(0).packets.size(),
             runner.Outputs().Index(0).packets.size());
 

mediapipe/calculators/core/matrix_subtract_calculator_test.cc

@@ -112,7 +112,7 @@ TEST(MatrixSubtractCalculatorTest, SubtractFromInput) {
   runner.MutableInputs()->Tag("MINUEND").packets.push_back(
       Adopt(input_matrix).At(Timestamp(0)));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   EXPECT_EQ(1, runner.Outputs().Index(0).packets.size());
 
   EXPECT_EQ(Timestamp(0), runner.Outputs().Index(0).packets[0].Timestamp());
@@ -142,7 +142,7 @@ TEST(MatrixSubtractCalculatorTest, SubtractFromSideMatrix) {
       ->Tag("SUBTRAHEND")
       .packets.push_back(Adopt(input_matrix).At(Timestamp(0)));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   EXPECT_EQ(1, runner.Outputs().Index(0).packets.size());
 
   EXPECT_EQ(Timestamp(0), runner.Outputs().Index(0).packets[0].Timestamp());

mediapipe/calculators/core/matrix_to_vector_calculator.cc

@@ -0,0 +1,83 @@
+// Copyright 2019 The MediaPipe Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Defines MatrixToVectorCalculator.
+#include <math.h>
+
+#include <deque>
+#include <memory>
+#include <string>
+
+#include "Eigen/Core"
+#include "absl/memory/memory.h"
+#include "mediapipe/framework/calculator_framework.h"
+#include "mediapipe/framework/formats/matrix.h"
+#include "mediapipe/framework/port/integral_types.h"
+#include "mediapipe/framework/port/logging.h"
+#include "mediapipe/framework/port/parse_text_proto.h"
+#include "mediapipe/framework/tool/status_util.h"
+#include "mediapipe/util/time_series_util.h"
+
+namespace mediapipe {
+
+// A calculator that converts a Matrix M to a vector containing all the
+// entries of M in column-major order.
+//
+// Example config:
+// node {
+//   calculator: "MatrixToVectorCalculator"
+//   input_stream: "input_matrix"
+//   output_stream: "column_major_vector"
+// }
+class MatrixToVectorCalculator : public CalculatorBase {
+ public:
+  static ::mediapipe::Status GetContract(CalculatorContract* cc) {
+    cc->Inputs().Index(0).Set<Matrix>(
+        // Input Packet containing a Matrix.
+    );
+    cc->Outputs().Index(0).Set<std::vector<float>>(
+        // Output Packet containing a vector, one for each input Packet.
+    );
+    return ::mediapipe::OkStatus();
+  }
+
+  ::mediapipe::Status Open(CalculatorContext* cc) override;
+
+  // Outputs a packet containing a vector for each input packet.
+  ::mediapipe::Status Process(CalculatorContext* cc) override;
+};
+REGISTER_CALCULATOR(MatrixToVectorCalculator);
+
+::mediapipe::Status MatrixToVectorCalculator::Open(CalculatorContext* cc) {
+  // Inform the framework that we don't alter timestamps.
+  cc->SetOffset(mediapipe::TimestampDiff(0));
+  return ::mediapipe::OkStatus();
+}
+
+::mediapipe::Status MatrixToVectorCalculator::Process(CalculatorContext* cc) {
+  const Matrix& input = cc->Inputs().Index(0).Get<Matrix>();
+  auto output = absl::make_unique<std::vector<float>>();
+
+  // The following lines work to convert the Matrix to a vector because Matrix
+  // is an Eigen::MatrixXf and Eigen uses column-major layout by default.
+  output->resize(input.rows() * input.cols());
+  auto output_as_matrix =
+      Eigen::Map<Matrix>(output->data(), input.rows(), input.cols());
+  output_as_matrix = input;
+
+  cc->Outputs().Index(0).Add(output.release(), cc->InputTimestamp());
+  return ::mediapipe::OkStatus();
+}
+
+}  // namespace mediapipe

mediapipe/calculators/core/matrix_to_vector_calculator_test.cc

@@ -0,0 +1,88 @@
+// Copyright 2019 The MediaPipe Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "mediapipe/framework/calculator_runner.h"
+#include "mediapipe/framework/formats/matrix.h"
+#include "mediapipe/framework/port/gmock.h"
+#include "mediapipe/framework/port/gtest.h"
+#include "mediapipe/framework/port/integral_types.h"
+#include "mediapipe/framework/port/status_matchers.h"
+#include "mediapipe/framework/tool/validate_type.h"
+#include "mediapipe/util/time_series_test_util.h"
+#include "mediapipe/util/time_series_util.h"
+
+namespace mediapipe {
+namespace {
+
+class MatrixToVectorCalculatorTest
+    : public mediapipe::TimeSeriesCalculatorTest<mediapipe::NoOptions> {
+ protected:
+  void SetUp() override { calculator_name_ = "MatrixToVectorCalculator"; }
+
+  void AppendInput(const std::vector<float>& column_major_data,
+                   int64 timestamp) {
+    ASSERT_EQ(num_input_samples_ * num_input_channels_,
+              column_major_data.size());
+    Eigen::Map<const Matrix> data_map(&column_major_data[0],
+                                      num_input_channels_, num_input_samples_);
+    AppendInputPacket(new Matrix(data_map), timestamp);
+  }
+
+  void SetInputStreamParameters(int num_channels, int num_samples) {
+    num_input_channels_ = num_channels;
+    num_input_samples_ = num_samples;
+    input_sample_rate_ = 100;
+    input_packet_rate_ = 20.0;
+  }
+
+  void SetInputHeader(int num_channels, int num_samples) {
+    SetInputStreamParameters(num_channels, num_samples);
+    FillInputHeader();
+  }
+
+  void CheckOutputPacket(int packet, std::vector<float> expected_vector) {
+    const auto& actual_vector =
+        runner_->Outputs().Index(0).packets[packet].Get<std::vector<float>>();
+    EXPECT_THAT(actual_vector, testing::ContainerEq(expected_vector));
+  }
+};
+
+TEST_F(MatrixToVectorCalculatorTest, SingleRow) {
+  InitializeGraph();
+  SetInputHeader(1, 4);  // 1 channel x 4 samples
+  const std::vector<float>& data_vector = {1.0, 2.0, 3.0, 4.0};
+  AppendInput(data_vector, 0);
+  MP_ASSERT_OK(RunGraph());
+  CheckOutputPacket(0, data_vector);
+}
+
+TEST_F(MatrixToVectorCalculatorTest, RegularMatrix) {
+  InitializeGraph();
+  SetInputHeader(4, 2);  // 4 channels x 2 samples
+  // Actual data matrix is the transpose of the appearance below.
+  const std::vector<float>& data_vector = {1.0, 2.0, 3.0, 4.0,
+                                           5.0, 6.0, 7.0, 8.0};
+  AppendInput(data_vector, 0);
+
+  MP_ASSERT_OK(RunGraph());
+  CheckOutputPacket(0, data_vector);
+}
+
+}  // namespace
+
+}  // namespace mediapipe

mediapipe/calculators/core/merge_calculator_test.cc

@@ -78,7 +78,7 @@ TEST(MediaPipeDetectionToSoapboxDetectionCalculatorTest,
   runner.MutableInputs()->Index(1).packets.push_back(
       Adopt(new float(35.5)).At(Timestamp(35)));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
 
   // Expected combined_output: 5.5, 10, 20, 30, 35.5 at times 5, 10, 20, 30, 35.
   const std::vector<Packet>& actual_output = runner.Outputs().Index(0).packets;
@@ -120,7 +120,7 @@ TEST(MediaPipeDetectionToSoapboxDetectionCalculatorTest,
   runner.MutableInputs()->Index(2).packets.push_back(
       Adopt(new char('c')).At(Timestamp(10)));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
 
   // Expected combined_output: 'c', 20.5, 30 at times 10, 20, 30.
   const std::vector<Packet>& actual_output = runner.Outputs().Index(0).packets;

mediapipe/calculators/core/packet_inner_join_calculator_test.cc

@@ -37,7 +37,7 @@ TEST(PacketInnerJoinCalculatorTest, AllMatching) {
   for (int packet_load : packets_on_stream2) {
     runner.MutableInputs()->Index(1).packets.push_back(PacketFrom(packet_load));
   }
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   // Check.
   const std::vector<int> expected = {0, 1, 2, 3};
   ASSERT_EQ(expected.size(), runner.Outputs().Index(0).packets.size());
@@ -64,7 +64,7 @@ TEST(PacketInnerJoinCalculatorTest, NoneMatching) {
   for (int packet_load : packets_on_stream2) {
     runner.MutableInputs()->Index(1).packets.push_back(PacketFrom(packet_load));
   }
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   // Check.
   EXPECT_TRUE(runner.Outputs().Index(0).packets.empty());
   EXPECT_TRUE(runner.Outputs().Index(1).packets.empty());
@@ -82,7 +82,7 @@ TEST(PacketInnerJoinCalculatorTest, SomeMatching) {
   for (int packet_load : packets_on_stream2) {
     runner.MutableInputs()->Index(1).packets.push_back(PacketFrom(packet_load));
   }
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   // Check.
   const std::vector<int> expected = {0, 2, 4, 6};
   ASSERT_EQ(expected.size(), runner.Outputs().Index(0).packets.size());

mediapipe/calculators/core/packet_resampler_calculator.cc

@@ -287,9 +287,9 @@ TimestampDiff TimestampDiffFromSeconds(double seconds) {
     }
   }
   if (jitter_ != 0.0 && random_ != nullptr) {
-    RETURN_IF_ERROR(ProcessWithJitter(cc));
+    MP_RETURN_IF_ERROR(ProcessWithJitter(cc));
   } else {
-    RETURN_IF_ERROR(ProcessWithoutJitter(cc));
+    MP_RETURN_IF_ERROR(ProcessWithoutJitter(cc));
   }
   last_packet_ = cc->Inputs().Get(input_data_id_).Value();
   return ::mediapipe::OkStatus();

mediapipe/calculators/core/packet_resampler_calculator_test.cc

@@ -103,7 +103,7 @@ TEST(PacketResamplerCalculatorTest, NoPacketsInStream) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
   }
 }
 
@@ -114,7 +114,7 @@ TEST(PacketResamplerCalculatorTest, SinglePacketInStream) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({0});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({0}, {0});
   }
 
@@ -124,7 +124,7 @@ TEST(PacketResamplerCalculatorTest, SinglePacketInStream) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({1000});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({1000}, {1000});
   }
 
@@ -134,7 +134,7 @@ TEST(PacketResamplerCalculatorTest, SinglePacketInStream) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({16668});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({16668}, {16668});
   }
 }
@@ -146,7 +146,7 @@ TEST(PacketResamplerCalculatorTest, TwoPacketsInStream) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({0, 16666});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({0}, {0});
   }
 
@@ -156,7 +156,7 @@ TEST(PacketResamplerCalculatorTest, TwoPacketsInStream) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({0, 16667});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({0, 16667}, {0, 33333});
   }
 
@@ -166,7 +166,7 @@ TEST(PacketResamplerCalculatorTest, TwoPacketsInStream) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({0, 49999});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({0, 49999}, {0, 33333});
   }
 
@@ -176,7 +176,7 @@ TEST(PacketResamplerCalculatorTest, TwoPacketsInStream) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({0, 50000});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({0, 0, 50000}, {0, 33333, 66667});
   }
 
@@ -186,7 +186,7 @@ TEST(PacketResamplerCalculatorTest, TwoPacketsInStream) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({2000, 118666});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({2000, 2000, 2000, 118666},
                                  {2000, 35333, 68667, 102000});
   }
@@ -197,7 +197,7 @@ TEST(PacketResamplerCalculatorTest, InputAtExactFrequencyMiddlepoints) {
       "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
       "{frame_rate:30}");
   runner.SetInput({0, 33333, 66667, 100000, 133333, 166667, 200000});
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   runner.CheckOutputTimestamps(
       {0, 33333, 66667, 100000, 133333, 166667, 200000},
       {0, 33333, 66667, 100000, 133333, 166667, 200000});
@@ -210,7 +210,7 @@ TEST(PacketResamplerCalculatorTest, MultiplePacketsForPeriods) {
       "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
       "{frame_rate:30}");
   runner.SetInput({0, 16666, 16667, 20000, 33300, 49999, 50000, 66600});
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   runner.CheckOutputTimestamps({0, 33300, 66600}, {0, 33333, 66667});
 }
 
@@ -222,7 +222,7 @@ TEST(PacketResamplerCalculatorTest, FillPeriodsWithLatestPacket) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({0, 5000, 16666, 83334});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({0, 16666, 16666, 83334},
                                  {0, 33333, 66667, 100000});
   }
@@ -232,7 +232,7 @@ TEST(PacketResamplerCalculatorTest, FillPeriodsWithLatestPacket) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({0, 16666, 16667, 25000, 33000, 35000, 135000});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({0, 33000, 35000, 35000, 135000},
                                  {0, 33333, 66667, 100000, 133333});
   }
@@ -242,7 +242,7 @@ TEST(PacketResamplerCalculatorTest, FillPeriodsWithLatestPacket) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({0, 15000, 32000, 49999, 150000});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({0, 32000, 49999, 49999, 49999, 150000},
                                  {0, 33333, 66667, 100000, 133333, 166667});
   }
@@ -255,7 +255,7 @@ TEST(PacketResamplerCalculatorTest, SuperHighFrameRate) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:500000}");
     runner.SetInput({0, 10, 13});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({0, 0, 0, 0, 0, 10, 10, 13},
                                  {0, 2, 4, 6, 8, 10, 12, 14});
   }
@@ -266,7 +266,7 @@ TEST(PacketResamplerCalculatorTest, SuperHighFrameRate) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:1000000}");
     runner.SetInput({0, 10, 13});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps(
         {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10, 13},
         {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13});
@@ -280,7 +280,7 @@ TEST(PacketResamplerCalculatorTest, NegativeTimestampTest) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({-200, -20, 16466});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({-200}, {-200});
   }
 
@@ -290,7 +290,7 @@ TEST(PacketResamplerCalculatorTest, NegativeTimestampTest) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({-200, -20, 16467});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({-200, 16467}, {-200, 33133});
   }
 
@@ -300,7 +300,7 @@ TEST(PacketResamplerCalculatorTest, NegativeTimestampTest) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({-500, 66667});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({-500, -500, 66667}, {-500, 32833, 66167});
   }
 
@@ -310,7 +310,7 @@ TEST(PacketResamplerCalculatorTest, NegativeTimestampTest) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({-50000, -33334, 33334});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({-50000, -33334, -33334, 33334},
                                  {-50000, -16667, 16667, 50000});
   }
@@ -323,7 +323,7 @@ TEST(PacketResamplerCalculatorTest, ExactFramesPerSecond) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:50}");
     runner.SetInput({0, 9999, 29999});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({0, 29999}, {0, 20000});
   }
 
@@ -333,7 +333,7 @@ TEST(PacketResamplerCalculatorTest, ExactFramesPerSecond) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:50}");
     runner.SetInput({0, 10000, 50000});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({0, 10000, 10000, 50000},
                                  {0, 20000, 40000, 60000});
   }
@@ -347,7 +347,7 @@ TEST(PacketResamplerCalculatorTest, FrameRateTest) {
         "{frame_rate:50, output_header:UPDATE_VIDEO_HEADER}");
     runner.SetInput({0, 10000, 30000, 50000, 60000});
     runner.SetVideoHeader(50.0);
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({0, 10000, 30000, 60000},
                                  {0, 20000, 40000, 60000});
     runner.CheckVideoHeader(50.0);
@@ -360,7 +360,7 @@ TEST(PacketResamplerCalculatorTest, FrameRateTest) {
         "{frame_rate:50, output_header:UPDATE_VIDEO_HEADER}");
     runner.SetInput({0, 5000, 10010, 15001, 19990});
     runner.SetVideoHeader(200.0);
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({0, 19990}, {0, 20000});
     runner.CheckVideoHeader(50.0);
   }
@@ -372,7 +372,7 @@ TEST(PacketResamplerCalculatorTest, FrameRateTest) {
         "{frame_rate:50, output_header:PASS_HEADER}");
     runner.SetInput({0, 5000, 10010, 15001, 19990});
     runner.SetVideoHeader(200.0);
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({0, 19990}, {0, 20000});
     runner.CheckVideoHeader(200.0);
   }
@@ -404,7 +404,7 @@ TEST(PacketResamplerCalculatorTest, SetVideoHeader) {
       ->Tag("VIDEO_HEADER")
       .packets.push_back(
           Adopt(new VideoHeader(video_header_in)).At(Timestamp::PreStream()));
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
 
   ASSERT_EQ(1, runner.Outputs().Tag("VIDEO_HEADER").packets.size());
   EXPECT_EQ(Timestamp::PreStream(),
@@ -424,7 +424,7 @@ TEST(PacketResamplerCalculatorTest, FlushLastPacketWithoutRound) {
         frame_rate: 1
       })");
   runner.SetInput({0, 333333, 666667, 1000000, 1333333});
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   // 1333333 is not emitted as 2000000, because it does not round to 2000000.
   runner.CheckOutputTimestamps({0, 1000000}, {0, 1000000});
 }
@@ -435,7 +435,7 @@ TEST(PacketResamplerCalculatorTest, FlushLastPacketWithRound) {
         frame_rate: 1
       })");
   runner.SetInput({0, 333333, 666667, 1000000, 1333333, 1666667});
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   // 1666667 is emitted as 2000000, because it rounds to 2000000.
   runner.CheckOutputTimestamps({0, 1000000, 1666667}, {0, 1000000, 2000000});
 }
@@ -447,7 +447,7 @@ TEST(PacketResamplerCalculatorTest, DoNotFlushLastPacketWithoutRound) {
         flush_last_packet: false
       })");
   runner.SetInput({0, 333333, 666667, 1000000, 1333333});
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   // 1333333 is not emitted no matter what; see FlushLastPacketWithoutRound.
   runner.CheckOutputTimestamps({0, 1000000}, {0, 1000000});
 }
@@ -459,7 +459,7 @@ TEST(PacketResamplerCalculatorTest, DoNotFlushLastPacketWithRound) {
         flush_last_packet: false
       })");
   runner.SetInput({0, 333333, 666667, 1000000, 1333333, 1666667});
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   // 1666667 is not emitted due to flush_last_packet: false.
   runner.CheckOutputTimestamps({0, 1000000}, {0, 1000000});
 }
@@ -473,7 +473,7 @@ TEST(PacketResamplerCalculatorTest, InputAtExactFrequencyMiddlepointsAligned) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({33111, 66667, 100000, 133333, 166667, 200000});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({33111, 66667, 100000, 133333, 166667, 200000},
                                  {33111, 66444, 99778, 133111, 166444, 199778});
   }
@@ -484,7 +484,7 @@ TEST(PacketResamplerCalculatorTest, InputAtExactFrequencyMiddlepointsAligned) {
         "{frame_rate:30 "
         "base_timestamp:0}");
     runner.SetInput({33111, 66667, 100000, 133333, 166667, 200000});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps(
         {33111, 66667, 100000, 133333, 166667, 200000},
         {33333, 66666, 100000, 133333, 166666, 200000});
@@ -499,7 +499,7 @@ TEST(PacketResamplerCalculatorTest, MultiplePacketsForPeriodsAligned) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({-222, 16666, 16667, 20000, 33300, 49999, 50000, 66600});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({-222, 33300, 66600}, {-222, 33111, 66445});
   }
   {
@@ -509,7 +509,7 @@ TEST(PacketResamplerCalculatorTest, MultiplePacketsForPeriodsAligned) {
         "{frame_rate:30 "
         "base_timestamp:900011}");
     runner.SetInput({-222, 16666, 16667, 20000, 33300, 49999, 50000, 66600});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({-222, 33300, 66600}, {11, 33344, 66678});
   }
   {
@@ -521,7 +521,7 @@ TEST(PacketResamplerCalculatorTest, MultiplePacketsForPeriodsAligned) {
         "base_timestamp:11}");
     runner.SetInput(
         {899888, 916666, 916667, 920000, 933300, 949999, 950000, 966600});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({899888, 933300, 966600},
                                  {900011, 933344, 966678});
   }
@@ -536,7 +536,7 @@ TEST(PacketResamplerCalculatorTest, FillPeriodsWithLatestPacketAligned) {
         "[mediapipe.PacketResamplerCalculatorOptions.ext]: "
         "{frame_rate:30}");
     runner.SetInput({-222, 15000, 32000, 49999, 150000});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({-222, 32000, 49999, 49999, 49999, 150000},
                                  {-222, 33111, 66445, 99778, 133111, 166445});
   }
@@ -547,7 +547,7 @@ TEST(PacketResamplerCalculatorTest, FillPeriodsWithLatestPacketAligned) {
         "{frame_rate:30 "
         "base_timestamp:0}");
     runner.SetInput({-222, 15000, 32000, 49999, 150000});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({-222, 32000, 49999, 49999, 49999, 150000},
                                  {0, 33333, 66667, 100000, 133333, 166667});
   }
@@ -565,7 +565,7 @@ TEST(PacketResamplerCalculatorTest, FirstInputAfterMiddlepointAligned) {
         "{frame_rate:30 "
         "base_timestamp:0}");
     runner.SetInput({66667, 100020, 133333, 166667});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({66667, 100020, 133333, 166667},
                                  {66667, 100000, 133334, 166667});
   }
@@ -582,7 +582,7 @@ TEST(PacketResamplerCalculatorTest, FirstInputAfterMiddlepointAligned) {
         "{frame_rate:30 "
         "base_timestamp:0}");
     runner.SetInput({100020, 133333, 166667});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({100020, 133333, 166667},
                                  {100000, 133333, 166667});
   }
@@ -596,7 +596,7 @@ TEST(PacketResamplerCalculatorTest, OutputTimestampRangeAligned) {
         "{frame_rate:30 "
         "base_timestamp:0}");
     runner.SetInput({-222, 15000, 32000, 49999, 150000});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({-222, 32000, 49999, 49999, 49999, 150000},
                                  {0, 33333, 66667, 100000, 133333, 166667});
   }
@@ -609,7 +609,7 @@ TEST(PacketResamplerCalculatorTest, OutputTimestampRangeAligned) {
         "start_time:40000 "
         "end_time:160000}");
     runner.SetInput({-222, 15000, 32000, 49999, 150000});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({49999, 49999, 49999},
                                  {66667, 100000, 133333});
   }
@@ -624,7 +624,7 @@ TEST(PacketResamplerCalculatorTest, OutputTimestampRangeAligned) {
         "end_time:160000 "
         "round_limits:true}");
     runner.SetInput({-222, 15000, 32000, 49999, 150000});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     runner.CheckOutputTimestamps({32000, 49999, 49999, 49999, 150000},
                                  {33333, 66667, 100000, 133333, 166667});
   }
@@ -654,7 +654,7 @@ TEST(PacketResamplerCalculatorTest, OptionsSidePacket) {
               })"));
     runner.MutableSidePackets()->Tag("OPTIONS") = Adopt(options);
     runner.SetInput({-222, 15000, 32000, 49999, 150000});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     EXPECT_EQ(6, runner.Outputs().Index(0).packets.size());
   }
   {
@@ -670,7 +670,7 @@ TEST(PacketResamplerCalculatorTest, OptionsSidePacket) {
     runner.MutableSidePackets()->Tag("OPTIONS") = Adopt(options);
 
     runner.SetInput({-222, 15000, 32000, 49999, 150000});
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     EXPECT_EQ(6, runner.Outputs().Index(0).packets.size());
   }
 }

mediapipe/calculators/core/previous_loopback_calculator_test.cc

@@ -74,11 +74,11 @@ TEST(PreviousLoopbackCalculator, CorrectTimestamps) {
   tool::AddVectorSink("pair", &graph_config_, &in_prev);
 
   CalculatorGraph graph_;
-  MEDIAPIPE_ASSERT_OK(graph_.Initialize(graph_config_, {}));
-  MEDIAPIPE_ASSERT_OK(graph_.StartRun({}));
+  MP_ASSERT_OK(graph_.Initialize(graph_config_, {}));
+  MP_ASSERT_OK(graph_.StartRun({}));
 
   auto send_packet = [&graph_](const std::string& input_name, int n) {
-    MEDIAPIPE_EXPECT_OK(graph_.AddPacketToInputStream(
+    MP_EXPECT_OK(graph_.AddPacketToInputStream(
         input_name, MakePacket<int>(n).At(Timestamp(n))));
   };
   auto pair_values = [](const Packet& packet) {
@@ -89,22 +89,22 @@ TEST(PreviousLoopbackCalculator, CorrectTimestamps) {
   };
 
   send_packet("in", 1);
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+  MP_EXPECT_OK(graph_.WaitUntilIdle());
   EXPECT_EQ(TimestampValues(in_prev), (std::vector<int64>{1}));
   EXPECT_EQ(pair_values(in_prev.back()), std::make_pair(1, -1));
 
   send_packet("in", 5);
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+  MP_EXPECT_OK(graph_.WaitUntilIdle());
   EXPECT_EQ(TimestampValues(in_prev), (std::vector<int64>{1, 5}));
   EXPECT_EQ(pair_values(in_prev.back()), std::make_pair(5, 1));
 
   send_packet("in", 15);
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilIdle());
+  MP_EXPECT_OK(graph_.WaitUntilIdle());
   EXPECT_EQ(TimestampValues(in_prev), (std::vector<int64>{1, 5, 15}));
   EXPECT_EQ(pair_values(in_prev.back()), std::make_pair(15, 5));
 
-  MEDIAPIPE_EXPECT_OK(graph_.CloseAllInputStreams());
-  MEDIAPIPE_EXPECT_OK(graph_.WaitUntilDone());
+  MP_EXPECT_OK(graph_.CloseAllInputStreams());
+  MP_EXPECT_OK(graph_.WaitUntilDone());
 }
 
 }  // anonymous namespace

mediapipe/calculators/core/quantize_float_vector_calculator_test.cc

@@ -124,7 +124,7 @@ TEST(QuantizeFloatVectorCalculatorTest, TestEmptyVector) {
       ->Tag("FLOAT_VECTOR")
       .packets.push_back(
           MakePacket<std::vector<float>>(empty_vector).At(Timestamp(0)));
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   const std::vector<Packet>& outputs = runner.Outputs().Tag("ENCODED").packets;
   EXPECT_EQ(1, outputs.size());
   EXPECT_TRUE(outputs[0].Get<std::string>().empty());
@@ -150,7 +150,7 @@ TEST(QuantizeFloatVectorCalculatorTest, TestNonEmptyVector) {
       ->Tag("FLOAT_VECTOR")
       .packets.push_back(
           MakePacket<std::vector<float>>(vector).At(Timestamp(0)));
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   const std::vector<Packet>& outputs = runner.Outputs().Tag("ENCODED").packets;
   EXPECT_EQ(1, outputs.size());
   const std::string& result = outputs[0].Get<std::string>();
@@ -188,7 +188,7 @@ TEST(QuantizeFloatVectorCalculatorTest, TestSaturation) {
       ->Tag("FLOAT_VECTOR")
       .packets.push_back(
           MakePacket<std::vector<float>>(vector).At(Timestamp(0)));
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   const std::vector<Packet>& outputs = runner.Outputs().Tag("ENCODED").packets;
   EXPECT_EQ(1, outputs.size());
   const std::string& result = outputs[0].Get<std::string>();

mediapipe/calculators/core/sequence_shift_calculator_test.cc

@@ -38,7 +38,7 @@ TEST(SequenceShiftCalculatorTest, ZeroShift) {
       "[mediapipe.SequenceShiftCalculatorOptions.ext]: { packet_offset: 0 }", 1,
       1, 0);
   AddPackets(&runner);
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   const std::vector<Packet>& input_packets =
       runner.MutableInputs()->Index(0).packets;
   const std::vector<Packet>& output_packets = runner.Outputs().Index(0).packets;
@@ -59,7 +59,7 @@ TEST(SequenceShiftCalculatorTest, PositiveShift) {
       "[mediapipe.SequenceShiftCalculatorOptions.ext]: { packet_offset: 3 }", 1,
       1, 0);
   AddPackets(&runner);
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   const std::vector<Packet>& input_packets =
       runner.MutableInputs()->Index(0).packets;
   const std::vector<Packet>& output_packets = runner.Outputs().Index(0).packets;
@@ -83,7 +83,7 @@ TEST(SequenceShiftCalculatorTest, NegativeShift) {
       "[mediapipe.SequenceShiftCalculatorOptions.ext]: { packet_offset: -2 }",
       1, 1, 0);
   AddPackets(&runner);
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   const std::vector<Packet>& input_packets =
       runner.MutableInputs()->Index(0).packets;
   const std::vector<Packet>& output_packets = runner.Outputs().Index(0).packets;

mediapipe/calculators/core/split_vector_calculator.cc

@@ -16,6 +16,7 @@
 
 #include <vector>
 
+#include "mediapipe/framework/formats/landmark.pb.h"
 #include "tensorflow/lite/interpreter.h"
 
 namespace mediapipe {
@@ -37,4 +38,7 @@ namespace mediapipe {
 typedef SplitVectorCalculator<TfLiteTensor> SplitTfLiteTensorVectorCalculator;
 REGISTER_CALCULATOR(SplitTfLiteTensorVectorCalculator);
 
+typedef SplitVectorCalculator<::mediapipe::NormalizedLandmark>
+    SplitLandmarkVectorCalculator;
+REGISTER_CALCULATOR(SplitLandmarkVectorCalculator);
 }  // namespace mediapipe

mediapipe/calculators/core/split_vector_calculator_test.cc

@@ -161,12 +161,12 @@ TEST_F(SplitTfLiteTensorVectorCalculatorTest, SmokeTest) {
 
   // Run the graph.
   CalculatorGraph graph;
-  MEDIAPIPE_ASSERT_OK(graph.Initialize(graph_config));
-  MEDIAPIPE_ASSERT_OK(graph.StartRun({}));
-  MEDIAPIPE_ASSERT_OK(graph.AddPacketToInputStream(
+  MP_ASSERT_OK(graph.Initialize(graph_config));
+  MP_ASSERT_OK(graph.StartRun({}));
+  MP_ASSERT_OK(graph.AddPacketToInputStream(
       "tensor_in", Adopt(input_vec_.release()).At(Timestamp(0))));
   // Wait until the calculator finishes processing.
-  MEDIAPIPE_ASSERT_OK(graph.WaitUntilIdle());
+  MP_ASSERT_OK(graph.WaitUntilIdle());
 
   ValidateVectorOutput(range_0_packets, /*expected_elements=*/1,
                        /*input_begin_index=*/0);
@@ -176,8 +176,8 @@ TEST_F(SplitTfLiteTensorVectorCalculatorTest, SmokeTest) {
                        /*input_begin_index=*/4);
 
   // Fully close the graph at the end.
-  MEDIAPIPE_ASSERT_OK(graph.CloseInputStream("tensor_in"));
-  MEDIAPIPE_ASSERT_OK(graph.WaitUntilDone());
+  MP_ASSERT_OK(graph.CloseInputStream("tensor_in"));
+  MP_ASSERT_OK(graph.WaitUntilDone());
 }
 
 TEST_F(SplitTfLiteTensorVectorCalculatorTest, InvalidRangeTest) {
@@ -270,12 +270,12 @@ TEST_F(SplitTfLiteTensorVectorCalculatorTest, SmokeTestElementOnly) {
 
   // Run the graph.
   CalculatorGraph graph;
-  MEDIAPIPE_ASSERT_OK(graph.Initialize(graph_config));
-  MEDIAPIPE_ASSERT_OK(graph.StartRun({}));
-  MEDIAPIPE_ASSERT_OK(graph.AddPacketToInputStream(
+  MP_ASSERT_OK(graph.Initialize(graph_config));
+  MP_ASSERT_OK(graph.StartRun({}));
+  MP_ASSERT_OK(graph.AddPacketToInputStream(
       "tensor_in", Adopt(input_vec_.release()).At(Timestamp(0))));
   // Wait until the calculator finishes processing.
-  MEDIAPIPE_ASSERT_OK(graph.WaitUntilIdle());
+  MP_ASSERT_OK(graph.WaitUntilIdle());
 
   ValidateElementOutput(range_0_packets,
                         /*input_begin_index=*/0);
@@ -285,8 +285,8 @@ TEST_F(SplitTfLiteTensorVectorCalculatorTest, SmokeTestElementOnly) {
                         /*input_begin_index=*/4);
 
   // Fully close the graph at the end.
-  MEDIAPIPE_ASSERT_OK(graph.CloseInputStream("tensor_in"));
-  MEDIAPIPE_ASSERT_OK(graph.WaitUntilDone());
+  MP_ASSERT_OK(graph.CloseInputStream("tensor_in"));
+  MP_ASSERT_OK(graph.WaitUntilDone());
 }
 
 TEST_F(SplitTfLiteTensorVectorCalculatorTest,

mediapipe/calculators/image/BUILD

@@ -81,7 +81,7 @@ mediapipe_cc_proto_library(
     name = "opencv_image_encoder_calculator_cc_proto",
     srcs = ["opencv_image_encoder_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":opencv_image_encoder_calculator_proto"],
 )
 
@@ -89,7 +89,7 @@ mediapipe_cc_proto_library(
     name = "mask_overlay_calculator_cc_proto",
     srcs = ["mask_overlay_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":mask_overlay_calculator_proto"],
 )
 
@@ -100,7 +100,7 @@ mediapipe_cc_proto_library(
         "//mediapipe/framework:calculator_cc_proto",
         "//mediapipe/framework/formats:image_format_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":scale_image_calculator_proto"],
 )
 
@@ -110,7 +110,7 @@ mediapipe_cc_proto_library(
     cc_deps = [
         "//mediapipe/framework:calculator_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":set_alpha_calculator_proto"],
 )
 
@@ -120,17 +120,17 @@ mediapipe_cc_proto_library(
     cc_deps = [
         "//mediapipe/framework:calculator_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":image_cropping_calculator_proto"],
 )
 
 mediapipe_cc_proto_library(
     name = "bilateral_filter_calculator_cc_proto",
     srcs = ["bilateral_filter_calculator.proto"],
-    cc_deps = [
-        "//mediapipe/framework:calculator_cc_proto",
+    cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
+    visibility = [
+        "//visibility:public",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
     deps = [":bilateral_filter_calculator_proto"],
 )
 
@@ -141,7 +141,7 @@ mediapipe_cc_proto_library(
         "//mediapipe/framework:calculator_cc_proto",
         "//mediapipe/util:color_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":recolor_calculator_proto"],
 )
 
@@ -291,7 +291,7 @@ mediapipe_cc_proto_library(
         "//mediapipe/framework:calculator_cc_proto",
         "//mediapipe/gpu:scale_mode_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":image_transformation_calculator_proto"],
 )
 

mediapipe/calculators/image/bilateral_filter_calculator.cc

@@ -153,7 +153,7 @@ REGISTER_CALCULATOR(BilateralFilterCalculator);
   }
 
 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__)
-  RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
+  MP_RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
 #endif  // __ANDROID__ || __EMSCRIPTEN__
 
   return ::mediapipe::OkStatus();
@@ -181,7 +181,7 @@ REGISTER_CALCULATOR(BilateralFilterCalculator);
 
   if (use_gpu_) {
 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__)
-    RETURN_IF_ERROR(gpu_helper_.Open(cc));
+    MP_RETURN_IF_ERROR(gpu_helper_.Open(cc));
 #endif
   }
 
@@ -191,18 +191,18 @@ REGISTER_CALCULATOR(BilateralFilterCalculator);
 ::mediapipe::Status BilateralFilterCalculator::Process(CalculatorContext* cc) {
   if (use_gpu_) {
 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__)
-    RETURN_IF_ERROR(
+    MP_RETURN_IF_ERROR(
         gpu_helper_.RunInGlContext([this, cc]() -> ::mediapipe::Status {
           if (!gpu_initialized_) {
-            RETURN_IF_ERROR(GlSetup(cc));
+            MP_RETURN_IF_ERROR(GlSetup(cc));
             gpu_initialized_ = true;
           }
-          RETURN_IF_ERROR(RenderGpu(cc));
+          MP_RETURN_IF_ERROR(RenderGpu(cc));
           return ::mediapipe::OkStatus();
         }));
 #endif  // __ANDROID__ || __EMSCRIPTEN__
   } else {
-    RETURN_IF_ERROR(RenderCpu(cc));
+    MP_RETURN_IF_ERROR(RenderCpu(cc));
   }
 
   return ::mediapipe::OkStatus();

mediapipe/calculators/image/image_cropping_calculator.cc

@@ -131,7 +131,7 @@ REGISTER_CALCULATOR(ImageCroppingCalculator);
   }
 
 #if defined(__ANDROID__) || (defined(__APPLE__) && !TARGET_OS_OSX)
-  RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
+  MP_RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
 #endif  // __ANDROID__ or iOS
 
   return ::mediapipe::OkStatus();
@@ -148,7 +148,7 @@ REGISTER_CALCULATOR(ImageCroppingCalculator);
 
   if (use_gpu_) {
 #if defined(__ANDROID__) || (defined(__APPLE__) && !TARGET_OS_OSX)
-    RETURN_IF_ERROR(gpu_helper_.Open(cc));
+    MP_RETURN_IF_ERROR(gpu_helper_.Open(cc));
 #else
     RET_CHECK_FAIL() << "GPU processing is for Android and iOS only.";
 #endif  // __ANDROID__ or iOS
@@ -160,18 +160,18 @@ REGISTER_CALCULATOR(ImageCroppingCalculator);
 ::mediapipe::Status ImageCroppingCalculator::Process(CalculatorContext* cc) {
   if (use_gpu_) {
 #if defined(__ANDROID__) || (defined(__APPLE__) && !TARGET_OS_OSX)
-    RETURN_IF_ERROR(
+    MP_RETURN_IF_ERROR(
         gpu_helper_.RunInGlContext([this, cc]() -> ::mediapipe::Status {
           if (!gpu_initialized_) {
-            RETURN_IF_ERROR(InitGpu(cc));
+            MP_RETURN_IF_ERROR(InitGpu(cc));
             gpu_initialized_ = true;
           }
-          RETURN_IF_ERROR(RenderGpu(cc));
+          MP_RETURN_IF_ERROR(RenderGpu(cc));
           return ::mediapipe::OkStatus();
         }));
 #endif  // __ANDROID__ or iOS
   } else {
-    RETURN_IF_ERROR(RenderCpu(cc));
+    MP_RETURN_IF_ERROR(RenderCpu(cc));
   }
   return ::mediapipe::OkStatus();
 }

mediapipe/calculators/image/image_transformation_calculator.cc

@@ -213,7 +213,7 @@ REGISTER_CALCULATOR(ImageTransformationCalculator);
   }
 
 #if defined(__ANDROID__) || defined(__APPLE__) && !TARGET_OS_OSX
-  RETURN_IF_ERROR(GlCalculatorHelper::UpdateContract(cc));
+  MP_RETURN_IF_ERROR(GlCalculatorHelper::UpdateContract(cc));
 #endif  // __ANDROID__ || iOS
 
   return ::mediapipe::OkStatus();
@@ -244,7 +244,7 @@ REGISTER_CALCULATOR(ImageTransformationCalculator);
     rotation_ = DegreesToRotationMode(
         cc->InputSidePackets().Tag("ROTATION_DEGREES").Get<int>());
   } else {
-    rotation_ = DegreesToRotationMode(options_.rotation_mode());
+    rotation_ = options_.rotation_mode();
   }
 
   scale_mode_ = ParseScaleMode(options_.scale_mode(), DEFAULT_SCALE_MODE);
@@ -252,7 +252,7 @@ REGISTER_CALCULATOR(ImageTransformationCalculator);
   if (use_gpu_) {
 #if defined(__ANDROID__) || defined(__APPLE__) && !TARGET_OS_OSX
     // Let the helper access the GL context information.
-    RETURN_IF_ERROR(helper_.Open(cc));
+    MP_RETURN_IF_ERROR(helper_.Open(cc));
 #else
     RET_CHECK_FAIL() << "GPU processing is for Android and iOS only.";
 #endif  // __ANDROID__ || iOS
@@ -398,7 +398,7 @@ REGISTER_CALCULATOR(ImageTransformationCalculator);
       input.format() == GpuBufferFormat::kBiPlanar420YpCbCr8FullRange) {
     if (!yuv_renderer_) {
       yuv_renderer_ = absl::make_unique<QuadRenderer>();
-      RETURN_IF_ERROR(
+      MP_RETURN_IF_ERROR(
           yuv_renderer_->GlSetup(::mediapipe::kYUV2TexToRGBFragmentShader,
                                  {"video_frame_y", "video_frame_uv"}));
     }
@@ -412,7 +412,7 @@ REGISTER_CALCULATOR(ImageTransformationCalculator);
     if (src1.target() == GL_TEXTURE_EXTERNAL_OES) {
       if (!ext_rgb_renderer_) {
         ext_rgb_renderer_ = absl::make_unique<QuadRenderer>();
-        RETURN_IF_ERROR(ext_rgb_renderer_->GlSetup(
+        MP_RETURN_IF_ERROR(ext_rgb_renderer_->GlSetup(
             ::mediapipe::kBasicTexturedFragmentShaderOES, {"video_frame"}));
       }
       renderer = ext_rgb_renderer_.get();
@@ -421,7 +421,7 @@ REGISTER_CALCULATOR(ImageTransformationCalculator);
     {
       if (!rgb_renderer_) {
         rgb_renderer_ = absl::make_unique<QuadRenderer>();
-        RETURN_IF_ERROR(rgb_renderer_->GlSetup());
+        MP_RETURN_IF_ERROR(rgb_renderer_->GlSetup());
       }
       renderer = rgb_renderer_.get();
     }
@@ -446,7 +446,7 @@ REGISTER_CALCULATOR(ImageTransformationCalculator);
   glActiveTexture(GL_TEXTURE1);
   glBindTexture(src1.target(), src1.name());
 
-  RETURN_IF_ERROR(renderer->GlRender(
+  MP_RETURN_IF_ERROR(renderer->GlRender(
       src1.width(), src1.height(), dst.width(), dst.height(), scale_mode,
       rotation, options_.flip_horizontally(), options_.flip_vertically(),
       /*flip_texture=*/false));

mediapipe/calculators/image/mask_overlay_calculator.cc

@@ -74,7 +74,7 @@ REGISTER_CALCULATOR(MaskOverlayCalculator);
 
 // static
 ::mediapipe::Status MaskOverlayCalculator::GetContract(CalculatorContract* cc) {
-  RETURN_IF_ERROR(GlCalculatorHelper::UpdateContract(cc));
+  MP_RETURN_IF_ERROR(GlCalculatorHelper::UpdateContract(cc));
   cc->Inputs().Get("VIDEO", 0).Set<GpuBuffer>();
   cc->Inputs().Get("VIDEO", 1).Set<GpuBuffer>();
   if (cc->Inputs().HasTag("MASK"))
@@ -103,7 +103,7 @@ REGISTER_CALCULATOR(MaskOverlayCalculator);
       const auto& options = cc->Options<MaskOverlayCalculatorOptions>();
       const auto mask_channel = options.mask_channel();
 
-      RETURN_IF_ERROR(GlSetup(mask_channel));
+      MP_RETURN_IF_ERROR(GlSetup(mask_channel));
       initialized_ = true;
     }
 
@@ -147,7 +147,7 @@ REGISTER_CALCULATOR(MaskOverlayCalculator);
       glActiveTexture(GL_TEXTURE3);
       glBindTexture(mask_tex.target(), mask_tex.name());
 
-      RETURN_IF_ERROR(GlRender(mask_const));
+      MP_RETURN_IF_ERROR(GlRender(mask_const));
 
       glActiveTexture(GL_TEXTURE3);
       glBindTexture(mask_tex.target(), 0);
@@ -155,7 +155,7 @@ REGISTER_CALCULATOR(MaskOverlayCalculator);
     } else {
       const float mask_const = mask_packet.Get<float>();
 
-      RETURN_IF_ERROR(GlRender(mask_const));
+      MP_RETURN_IF_ERROR(GlRender(mask_const));
     }
 
     glActiveTexture(GL_TEXTURE2);

mediapipe/calculators/image/opencv_encoded_image_to_image_frame_calculator_test.cc

@@ -30,7 +30,7 @@ namespace {
 
 TEST(OpenCvEncodedImageToImageFrameCalculatorTest, TestRgbJpeg) {
   std::string contents;
-  MEDIAPIPE_ASSERT_OK(file::GetContents(
+  MP_ASSERT_OK(file::GetContents(
       file::JoinPath("./", "/mediapipe/calculators/image/testdata/dino.jpg"),
       &contents));
   Packet input_packet = MakePacket<std::string>(contents);
@@ -44,7 +44,7 @@ TEST(OpenCvEncodedImageToImageFrameCalculatorTest, TestRgbJpeg) {
   CalculatorRunner runner(node_config);
   runner.MutableInputs()->Index(0).packets.push_back(
       input_packet.At(Timestamp(0)));
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   const auto& outputs = runner.Outputs();
   ASSERT_EQ(1, outputs.NumEntries());
   const std::vector<Packet>& packets = outputs.Index(0).packets;
@@ -87,7 +87,7 @@ TEST(OpenCvEncodedImageToImageFrameCalculatorTest, TestGrayscaleJpeg) {
   CalculatorRunner runner(node_config);
   runner.MutableInputs()->Index(0).packets.push_back(
       input_packet.At(Timestamp(0)));
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   const auto& outputs = runner.Outputs();
   ASSERT_EQ(1, outputs.NumEntries());
   const std::vector<Packet>& packets = outputs.Index(0).packets;

mediapipe/calculators/image/opencv_image_encoder_calculator_test.cc

@@ -55,7 +55,7 @@ TEST(OpenCvImageEncoderCalculatorTest, TestJpegWithQualities) {
     CalculatorRunner runner(node_config);
     runner.MutableInputs()->Index(0).packets.push_back(
         input_packet.At(Timestamp(0)));
-    MEDIAPIPE_ASSERT_OK(runner.Run());
+    MP_ASSERT_OK(runner.Run());
     const auto& outputs = runner.Outputs();
     ASSERT_EQ(1, outputs.NumEntries());
     const std::vector<Packet>& packets = outputs.Index(0).packets;

mediapipe/calculators/image/recolor_calculator.cc

@@ -135,7 +135,7 @@ REGISTER_CALCULATOR(RecolorCalculator);
   }
 
 #if defined(__ANDROID__) || (defined(__APPLE__) && !TARGET_OS_OSX)
-  RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
+  MP_RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
 #endif  // __ANDROID__ or iOS
 
   return ::mediapipe::OkStatus();
@@ -147,11 +147,11 @@ REGISTER_CALCULATOR(RecolorCalculator);
   if (cc->Inputs().HasTag("IMAGE_GPU")) {
     use_gpu_ = true;
 #if defined(__ANDROID__) || (defined(__APPLE__) && !TARGET_OS_OSX)
-    RETURN_IF_ERROR(gpu_helper_.Open(cc));
+    MP_RETURN_IF_ERROR(gpu_helper_.Open(cc));
 #endif  // __ANDROID__ or iOS
   }
 
-  RETURN_IF_ERROR(LoadOptions(cc));
+  MP_RETURN_IF_ERROR(LoadOptions(cc));
 
   return ::mediapipe::OkStatus();
 }
@@ -159,18 +159,18 @@ REGISTER_CALCULATOR(RecolorCalculator);
 ::mediapipe::Status RecolorCalculator::Process(CalculatorContext* cc) {
   if (use_gpu_) {
 #if defined(__ANDROID__) || (defined(__APPLE__) && !TARGET_OS_OSX)
-    RETURN_IF_ERROR(
+    MP_RETURN_IF_ERROR(
         gpu_helper_.RunInGlContext([this, &cc]() -> ::mediapipe::Status {
           if (!initialized_) {
-            RETURN_IF_ERROR(InitGpu(cc));
+            MP_RETURN_IF_ERROR(InitGpu(cc));
             initialized_ = true;
           }
-          RETURN_IF_ERROR(RenderGpu(cc));
+          MP_RETURN_IF_ERROR(RenderGpu(cc));
           return ::mediapipe::OkStatus();
         }));
 #endif  // __ANDROID__ or iOS
   } else {
-    RETURN_IF_ERROR(RenderCpu(cc));
+    MP_RETURN_IF_ERROR(RenderCpu(cc));
   }
   return ::mediapipe::OkStatus();
 }

mediapipe/calculators/image/scale_image_calculator.cc

@@ -253,21 +253,21 @@ ScaleImageCalculator::~ScaleImageCalculator() {}
 
 ::mediapipe::Status ScaleImageCalculator::InitializeFrameInfo(
     CalculatorContext* cc) {
-  RETURN_IF_ERROR(
+  MP_RETURN_IF_ERROR(
       scale_image::FindCropDimensions(input_width_, input_height_,  //
                                       options_.min_aspect_ratio(),  //
                                       options_.max_aspect_ratio(),  //
                                       &crop_width_, &crop_height_,  //
                                       &col_start_, &row_start_));
-  RETURN_IF_ERROR(
+  MP_RETURN_IF_ERROR(
       scale_image::FindOutputDimensions(crop_width_, crop_height_,            //
                                         options_.target_width(),              //
                                         options_.target_height(),             //
                                         options_.preserve_aspect_ratio(),     //
                                         options_.scale_to_multiple_of_two(),  //
                                         &output_width_, &output_height_));
-  RETURN_IF_ERROR(FindInterpolationAlgorithm(options_.algorithm(),
-                                             &interpolation_algorithm_));
+  MP_RETURN_IF_ERROR(FindInterpolationAlgorithm(options_.algorithm(),
+                                                &interpolation_algorithm_));
   if (interpolation_algorithm_ == -1 &&
       (output_width_ > crop_width_ || output_height_ > crop_height_)) {
     output_width_ = crop_width_;
@@ -327,7 +327,7 @@ ScaleImageCalculator::~ScaleImageCalculator() {}
   bool has_override_options = cc->Inputs().HasTag("OVERRIDE_OPTIONS");
 
   if (!has_override_options) {
-    RETURN_IF_ERROR(InitializeFromOptions());
+    MP_RETURN_IF_ERROR(InitializeFromOptions());
   }
 
   if (!cc->Inputs().Get(input_data_id_).Header().IsEmpty()) {
@@ -377,8 +377,8 @@ ScaleImageCalculator::~ScaleImageCalculator() {}
     if (input_width_ > 0 && input_height_ > 0 &&
         input_format_ != ImageFormat::UNKNOWN &&
         output_format_ != ImageFormat::UNKNOWN) {
-      RETURN_IF_ERROR(ValidateImageFormats());
-      RETURN_IF_ERROR(InitializeFrameInfo(cc));
+      MP_RETURN_IF_ERROR(ValidateImageFormats());
+      MP_RETURN_IF_ERROR(InitializeFrameInfo(cc));
       std::unique_ptr<VideoHeader> output_header(new VideoHeader());
       *output_header = input_video_header_;
       output_header->format = output_format_;
@@ -461,9 +461,9 @@ ScaleImageCalculator::~ScaleImageCalculator() {}
       } else {
         output_format_ = input_format_;
       }
-      RETURN_IF_ERROR(InitializeFrameInfo(cc));
+      MP_RETURN_IF_ERROR(InitializeFrameInfo(cc));
     }
-    RETURN_IF_ERROR(ValidateImageFormats());
+    MP_RETURN_IF_ERROR(ValidateImageFormats());
   } else {
     if (input_width_ != image_frame.Width() ||
         input_height_ != image_frame.Height()) {
@@ -503,9 +503,9 @@ ScaleImageCalculator::~ScaleImageCalculator() {}
       } else {
         output_format_ = input_format_;
       }
-      RETURN_IF_ERROR(InitializeFrameInfo(cc));
+      MP_RETURN_IF_ERROR(InitializeFrameInfo(cc));
     }
-    RETURN_IF_ERROR(ValidateImageFormats());
+    MP_RETURN_IF_ERROR(ValidateImageFormats());
   } else {
     if (input_width_ != yuv_image.width() ||
         input_height_ != yuv_image.height()) {
@@ -531,7 +531,7 @@ ScaleImageCalculator::~ScaleImageCalculator() {}
       options_.MergeFrom(cc->Inputs()
                              .Tag("OVERRIDE_OPTIONS")
                              .Get<ScaleImageCalculatorOptions>());
-      RETURN_IF_ERROR(InitializeFromOptions());
+      MP_RETURN_IF_ERROR(InitializeFromOptions());
     }
     if (cc->Inputs().UsesTags() && cc->Inputs().HasTag("VIDEO_HEADER") &&
         !cc->Inputs().Tag("VIDEO_HEADER").IsEmpty()) {
@@ -548,7 +548,7 @@ ScaleImageCalculator::~ScaleImageCalculator() {}
   if (input_format_ == ImageFormat::YCBCR420P) {
     const YUVImage* yuv_image =
         &cc->Inputs().Get(input_data_id_).Get<YUVImage>();
-    RETURN_IF_ERROR(ValidateYUVImage(cc, *yuv_image));
+    MP_RETURN_IF_ERROR(ValidateYUVImage(cc, *yuv_image));
 
     if (output_format_ == ImageFormat::SRGB) {
       // TODO: For ease of implementation, YUVImage is converted to
@@ -596,7 +596,7 @@ ScaleImageCalculator::~ScaleImageCalculator() {}
     }
   } else {
     image_frame = &cc->Inputs().Get(input_data_id_).Get<ImageFrame>();
-    RETURN_IF_ERROR(ValidateImageFrame(cc, *image_frame));
+    MP_RETURN_IF_ERROR(ValidateImageFrame(cc, *image_frame));
   }
 
   std::unique_ptr<ImageFrame> cropped_image;

mediapipe/calculators/image/scale_image_utils_test.cc

@@ -28,8 +28,8 @@ TEST(ScaleImageUtilsTest, FindCropDimensions) {
   int col_start;
   int row_start;
   // No cropping because aspect ratios should be ignored.
-  MEDIAPIPE_ASSERT_OK(FindCropDimensions(50, 100, "0/1", "1/0", &crop_width,
-                                         &crop_height, &col_start, &row_start));
+  MP_ASSERT_OK(FindCropDimensions(50, 100, "0/1", "1/0", &crop_width,
+                                  &crop_height, &col_start, &row_start));
   EXPECT_EQ(50, crop_width);
   EXPECT_EQ(100, crop_height);
   EXPECT_EQ(0, row_start);
@@ -37,39 +37,38 @@ TEST(ScaleImageUtilsTest, FindCropDimensions) {
 
   // Tests proto examples.
   // 16:9 aspect ratio, should be unchanged.
-  MEDIAPIPE_ASSERT_OK(FindCropDimensions(1920, 1080, "9/16", "16/9",
-                                         &crop_width, &crop_height, &col_start,
-                                         &row_start));
+  MP_ASSERT_OK(FindCropDimensions(1920, 1080, "9/16", "16/9", &crop_width,
+                                  &crop_height, &col_start, &row_start));
   EXPECT_EQ(0, col_start);
   EXPECT_EQ(1920, crop_width);
   EXPECT_EQ(0, row_start);
   EXPECT_EQ(1080, crop_height);
   // 10:16 aspect ratio, should be unchanged.
-  MEDIAPIPE_ASSERT_OK(FindCropDimensions(640, 1024, "9/16", "16/9", &crop_width,
-                                         &crop_height, &col_start, &row_start));
+  MP_ASSERT_OK(FindCropDimensions(640, 1024, "9/16", "16/9", &crop_width,
+                                  &crop_height, &col_start, &row_start));
   EXPECT_EQ(0, col_start);
   EXPECT_EQ(640, crop_width);
   EXPECT_EQ(0, row_start);
   EXPECT_EQ(1024, crop_height);
 
   // 2:1 aspect ratio, width is cropped.
-  MEDIAPIPE_ASSERT_OK(FindCropDimensions(640, 320, "9/16", "16/9", &crop_width,
-                                         &crop_height, &col_start, &row_start));
+  MP_ASSERT_OK(FindCropDimensions(640, 320, "9/16", "16/9", &crop_width,
+                                  &crop_height, &col_start, &row_start));
   EXPECT_EQ(36, col_start);
   EXPECT_EQ(568, crop_width);
   EXPECT_EQ(0, row_start);
   EXPECT_EQ(320, crop_height);
   // 1:5 aspect ratio, height is cropped.
-  MEDIAPIPE_ASSERT_OK(FindCropDimensions(96, 480, "9/16", "16/9", &crop_width,
-                                         &crop_height, &col_start, &row_start));
+  MP_ASSERT_OK(FindCropDimensions(96, 480, "9/16", "16/9", &crop_width,
+                                  &crop_height, &col_start, &row_start));
   EXPECT_EQ(0, col_start);
   EXPECT_EQ(96, crop_width);
   EXPECT_EQ(155, row_start);
   EXPECT_EQ(170, crop_height);
 
   // Tests min = max, crops width.
-  MEDIAPIPE_ASSERT_OK(FindCropDimensions(200, 100, "1/1", "1/1", &crop_width,
-                                         &crop_height, &col_start, &row_start));
+  MP_ASSERT_OK(FindCropDimensions(200, 100, "1/1", "1/1", &crop_width,
+                                  &crop_height, &col_start, &row_start));
   EXPECT_EQ(50, col_start);
   EXPECT_EQ(100, crop_width);
   EXPECT_EQ(0, row_start);
@@ -80,49 +79,49 @@ TEST(ScaleImageUtilsTest, FindOutputDimensionsPreserveRatio) {
   int output_width;
   int output_height;
   // Not scale.
-  MEDIAPIPE_ASSERT_OK(FindOutputDimensions(200, 100, -1, -1, true, true,
-                                           &output_width, &output_height));
+  MP_ASSERT_OK(FindOutputDimensions(200, 100, -1, -1, true, true, &output_width,
+                                    &output_height));
   EXPECT_EQ(200, output_width);
   EXPECT_EQ(100, output_height);
   // Not scale with odd input size.
-  MEDIAPIPE_ASSERT_OK(FindOutputDimensions(201, 101, -1, -1, false, false,
-                                           &output_width, &output_height));
+  MP_ASSERT_OK(FindOutputDimensions(201, 101, -1, -1, false, false,
+                                    &output_width, &output_height));
   EXPECT_EQ(201, output_width);
   EXPECT_EQ(101, output_height);
   // Scale down by 1/2.
-  MEDIAPIPE_ASSERT_OK(FindOutputDimensions(200, 100, 100, -1, true, true,
-                                           &output_width, &output_height));
+  MP_ASSERT_OK(FindOutputDimensions(200, 100, 100, -1, true, true,
+                                    &output_width, &output_height));
   EXPECT_EQ(100, output_width);
   EXPECT_EQ(50, output_height);
   // Scale up, doubling dimensions.
-  MEDIAPIPE_ASSERT_OK(FindOutputDimensions(200, 100, -1, 200, true, true,
-                                           &output_width, &output_height));
+  MP_ASSERT_OK(FindOutputDimensions(200, 100, -1, 200, true, true,
+                                    &output_width, &output_height));
   EXPECT_EQ(400, output_width);
   EXPECT_EQ(200, output_height);
   // Fits a 2:1 image into a 150 x 150 box. Output dimensions are always
   // visible by 2.
-  MEDIAPIPE_ASSERT_OK(FindOutputDimensions(200, 100, 150, 150, true, true,
-                                           &output_width, &output_height));
+  MP_ASSERT_OK(FindOutputDimensions(200, 100, 150, 150, true, true,
+                                    &output_width, &output_height));
   EXPECT_EQ(150, output_width);
   EXPECT_EQ(74, output_height);
   // Fits a 2:1 image into a 400 x 50 box.
-  MEDIAPIPE_ASSERT_OK(FindOutputDimensions(200, 100, 400, 50, true, true,
-                                           &output_width, &output_height));
+  MP_ASSERT_OK(FindOutputDimensions(200, 100, 400, 50, true, true,
+                                    &output_width, &output_height));
   EXPECT_EQ(100, output_width);
   EXPECT_EQ(50, output_height);
   // Scale to multiple number with odd targe size.
-  MEDIAPIPE_ASSERT_OK(FindOutputDimensions(200, 100, 101, -1, true, true,
-                                           &output_width, &output_height));
+  MP_ASSERT_OK(FindOutputDimensions(200, 100, 101, -1, true, true,
+                                    &output_width, &output_height));
   EXPECT_EQ(100, output_width);
   EXPECT_EQ(50, output_height);
   // Scale to multiple number with odd targe size.
-  MEDIAPIPE_ASSERT_OK(FindOutputDimensions(200, 100, 101, -1, true, false,
-                                           &output_width, &output_height));
+  MP_ASSERT_OK(FindOutputDimensions(200, 100, 101, -1, true, false,
+                                    &output_width, &output_height));
   EXPECT_EQ(100, output_width);
   EXPECT_EQ(50, output_height);
   // Scale to odd size.
-  MEDIAPIPE_ASSERT_OK(FindOutputDimensions(200, 100, 151, 101, false, false,
-                                           &output_width, &output_height));
+  MP_ASSERT_OK(FindOutputDimensions(200, 100, 151, 101, false, false,
+                                    &output_width, &output_height));
   EXPECT_EQ(151, output_width);
   EXPECT_EQ(101, output_height);
 }
@@ -132,18 +131,18 @@ TEST(ScaleImageUtilsTest, FindOutputDimensionsNoAspectRatio) {
   int output_width;
   int output_height;
   // Scale width only.
-  MEDIAPIPE_ASSERT_OK(FindOutputDimensions(200, 100, 100, -1, false, true,
-                                           &output_width, &output_height));
+  MP_ASSERT_OK(FindOutputDimensions(200, 100, 100, -1, false, true,
+                                    &output_width, &output_height));
   EXPECT_EQ(100, output_width);
   EXPECT_EQ(100, output_height);
   // Scale height only.
-  MEDIAPIPE_ASSERT_OK(FindOutputDimensions(200, 100, -1, 200, false, true,
-                                           &output_width, &output_height));
+  MP_ASSERT_OK(FindOutputDimensions(200, 100, -1, 200, false, true,
+                                    &output_width, &output_height));
   EXPECT_EQ(200, output_width);
   EXPECT_EQ(200, output_height);
   // Scale both dimensions.
-  MEDIAPIPE_ASSERT_OK(FindOutputDimensions(200, 100, 150, 200, false, true,
-                                           &output_width, &output_height));
+  MP_ASSERT_OK(FindOutputDimensions(200, 100, 150, 200, false, true,
+                                    &output_width, &output_height));
   EXPECT_EQ(150, output_width);
   EXPECT_EQ(200, output_height);
 }

mediapipe/calculators/image/set_alpha_calculator.cc

@@ -157,7 +157,7 @@ REGISTER_CALCULATOR(SetAlphaCalculator);
   }
 
 #if defined(__ANDROID__) || (defined(__APPLE__) && !TARGET_OS_OSX)
-  RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
+  MP_RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
 #endif  // __ANDROID__ or iOS
 
   return ::mediapipe::OkStatus();
@@ -188,7 +188,7 @@ REGISTER_CALCULATOR(SetAlphaCalculator);
 
   if (use_gpu_) {
 #if defined(__ANDROID__) || (defined(__APPLE__) && !TARGET_OS_OSX)
-    RETURN_IF_ERROR(gpu_helper_.Open(cc));
+    MP_RETURN_IF_ERROR(gpu_helper_.Open(cc));
 #endif
   }
 
@@ -198,18 +198,18 @@ REGISTER_CALCULATOR(SetAlphaCalculator);
 ::mediapipe::Status SetAlphaCalculator::Process(CalculatorContext* cc) {
   if (use_gpu_) {
 #if defined(__ANDROID__) || (defined(__APPLE__) && !TARGET_OS_OSX)
-    RETURN_IF_ERROR(
+    MP_RETURN_IF_ERROR(
         gpu_helper_.RunInGlContext([this, cc]() -> ::mediapipe::Status {
           if (!gpu_initialized_) {
-            RETURN_IF_ERROR(GlSetup(cc));
+            MP_RETURN_IF_ERROR(GlSetup(cc));
             gpu_initialized_ = true;
           }
-          RETURN_IF_ERROR(RenderGpu(cc));
+          MP_RETURN_IF_ERROR(RenderGpu(cc));
           return ::mediapipe::OkStatus();
         }));
 #endif  // __ANDROID__ or iOS
   } else {
-    RETURN_IF_ERROR(RenderCpu(cc));
+    MP_RETURN_IF_ERROR(RenderCpu(cc));
   }
 
   return ::mediapipe::OkStatus();

mediapipe/calculators/internal/BUILD

@@ -29,7 +29,7 @@ mediapipe_cc_proto_library(
     name = "callback_packet_calculator_cc_proto",
     srcs = ["callback_packet_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe/framework:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":callback_packet_calculator_proto"],
 )
 

mediapipe/calculators/tensorflow/BUILD

@@ -22,7 +22,7 @@ load("//mediapipe/framework/port:build_config.bzl", "mediapipe_cc_proto_library"
 proto_library(
     name = "graph_tensors_packet_generator_proto",
     srcs = ["graph_tensors_packet_generator.proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [
         "//mediapipe/framework:calculator_proto",
         "//mediapipe/framework:packet_generator_proto",
@@ -118,7 +118,7 @@ mediapipe_cc_proto_library(
         "//mediapipe/framework:calculator_cc_proto",
         "//mediapipe/framework:packet_generator_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":graph_tensors_packet_generator_proto"],
 )
 
@@ -129,7 +129,7 @@ mediapipe_cc_proto_library(
         "//mediapipe/framework:calculator_cc_proto",
         "@org_tensorflow//tensorflow/core:protos_all_cc",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":image_frame_to_tensor_calculator_proto"],
 )
 
@@ -137,7 +137,7 @@ mediapipe_cc_proto_library(
     name = "matrix_to_tensor_calculator_options_cc_proto",
     srcs = ["matrix_to_tensor_calculator_options.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":matrix_to_tensor_calculator_options_proto"],
 )
 
@@ -145,7 +145,7 @@ mediapipe_cc_proto_library(
     name = "lapped_tensor_buffer_calculator_cc_proto",
     srcs = ["lapped_tensor_buffer_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":lapped_tensor_buffer_calculator_proto"],
 )
 
@@ -153,7 +153,7 @@ mediapipe_cc_proto_library(
     name = "object_detection_tensors_to_detections_calculator_cc_proto",
     srcs = ["object_detection_tensors_to_detections_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":object_detection_tensors_to_detections_calculator_proto"],
 )
 
@@ -164,7 +164,7 @@ mediapipe_cc_proto_library(
         "//mediapipe/framework:calculator_cc_proto",
         "@org_tensorflow//tensorflow/core:protos_all_cc",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":pack_media_sequence_calculator_proto"],
 )
 
@@ -172,7 +172,7 @@ mediapipe_cc_proto_library(
     name = "tensorflow_inference_calculator_cc_proto",
     srcs = ["tensorflow_inference_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":tensorflow_inference_calculator_proto"],
 )
 
@@ -183,15 +183,26 @@ mediapipe_cc_proto_library(
         "//mediapipe/framework:packet_generator_cc_proto",
         "@org_tensorflow//tensorflow/core:protos_all_cc",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":tensorflow_session_from_frozen_graph_generator_proto"],
 )
 
+mediapipe_cc_proto_library(
+    name = "tensorflow_session_from_frozen_graph_calculator_cc_proto",
+    srcs = ["tensorflow_session_from_frozen_graph_calculator.proto"],
+    cc_deps = [
+        "//mediapipe/framework:calculator_cc_proto",
+        "@org_tensorflow//tensorflow/core:protos_all_cc",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [":tensorflow_session_from_frozen_graph_calculator_proto"],
+)
+
 mediapipe_cc_proto_library(
     name = "tensorflow_session_from_saved_model_generator_cc_proto",
     srcs = ["tensorflow_session_from_saved_model_generator.proto"],
     cc_deps = ["//mediapipe/framework:packet_generator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":tensorflow_session_from_saved_model_generator_proto"],
 )
 
@@ -199,7 +210,7 @@ mediapipe_cc_proto_library(
     name = "tensorflow_session_from_saved_model_calculator_cc_proto",
     srcs = ["tensorflow_session_from_saved_model_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":tensorflow_session_from_saved_model_calculator_proto"],
 )
 
@@ -207,7 +218,7 @@ mediapipe_cc_proto_library(
     name = "tensor_squeeze_dimensions_calculator_cc_proto",
     srcs = ["tensor_squeeze_dimensions_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":tensor_squeeze_dimensions_calculator_proto"],
 )
 
@@ -215,7 +226,7 @@ mediapipe_cc_proto_library(
     name = "tensor_to_image_frame_calculator_cc_proto",
     srcs = ["tensor_to_image_frame_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":tensor_to_image_frame_calculator_proto"],
 )
 
@@ -226,7 +237,7 @@ mediapipe_cc_proto_library(
         "//mediapipe/framework:calculator_cc_proto",
         "//mediapipe/framework/formats:time_series_header_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":tensor_to_matrix_calculator_proto"],
 )
 
@@ -234,7 +245,7 @@ mediapipe_cc_proto_library(
     name = "tensor_to_vector_float_calculator_options_cc_proto",
     srcs = ["tensor_to_vector_float_calculator_options.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":tensor_to_vector_float_calculator_options_proto"],
 )
 
@@ -245,7 +256,7 @@ mediapipe_cc_proto_library(
         "//mediapipe/calculators/core:packet_resampler_calculator_cc_proto",
         "//mediapipe/framework:calculator_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":unpack_media_sequence_calculator_proto"],
 )
 
@@ -253,7 +264,7 @@ mediapipe_cc_proto_library(
     name = "vector_float_to_tensor_calculator_options_cc_proto",
     srcs = ["vector_float_to_tensor_calculator_options.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":vector_float_to_tensor_calculator_options_proto"],
 )
 
@@ -444,6 +455,35 @@ cc_library(
     }),
 )
 
+cc_library(
+    name = "tensorflow_session_from_frozen_graph_calculator",
+    srcs = ["tensorflow_session_from_frozen_graph_calculator.cc"],
+    features = ["no_layering_check"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":tensorflow_session",
+        "//mediapipe/calculators/tensorflow:tensorflow_session_from_frozen_graph_calculator_cc_proto",
+        "//mediapipe/framework:calculator_framework",
+        "//mediapipe/framework/tool:status_util",
+        "//mediapipe/framework/port:status",
+        "//mediapipe/framework/port:ret_check",
+    ] + select({
+        "//conditions:default": [
+            "//mediapipe/framework/port:file_helpers",
+            "@org_tensorflow//tensorflow/core:core",
+        ],
+        "//mediapipe:android": [
+            "@org_tensorflow//tensorflow/core:android_tensorflow_lib_lite_nortti_lite_protos",
+            "//mediapipe/android/file/base",
+        ],
+        "//mediapipe:ios": [
+            "@org_tensorflow//tensorflow/core:ios_tensorflow_lib",
+            "//mediapipe/android/file/base",
+        ],
+    }),
+    alwayslink = 1,
+)
+
 cc_library(
     name = "tensorflow_session_from_frozen_graph_generator",
     srcs = ["tensorflow_session_from_frozen_graph_generator.cc"],
@@ -737,6 +777,36 @@ cc_test(
     ],
 )
 
+cc_test(
+    name = "tensorflow_session_from_frozen_graph_calculator_test",
+    srcs = ["tensorflow_session_from_frozen_graph_calculator_test.cc"],
+    data = [":test_frozen_graph"],
+    linkstatic = 1,
+    deps = [
+        ":tensorflow_inference_calculator",
+        ":tensorflow_session",
+        ":tensorflow_session_from_frozen_graph_calculator",
+        "//mediapipe/calculators/tensorflow:tensorflow_session_from_frozen_graph_calculator_cc_proto",
+        "//mediapipe/framework:calculator_framework",
+        "//mediapipe/framework:calculator_runner",
+        "//mediapipe/framework:packet",
+        "//mediapipe/framework/deps:file_path",
+        "//mediapipe/framework/port:file_helpers",
+        "//mediapipe/framework/port:gtest_main",
+        "//mediapipe/framework/port:parse_text_proto",
+        "//mediapipe/framework/port:status",
+        "//mediapipe/framework/tool:tag_map_helper",
+        "//mediapipe/framework/tool:validate_type",
+        "@com_google_absl//absl/strings",
+        "@org_tensorflow//tensorflow/core:direct_session",
+        "@org_tensorflow//tensorflow/core:framework",
+        "@org_tensorflow//tensorflow/core:protos_all_cc",
+        "@org_tensorflow//tensorflow/core:testlib",
+        "@org_tensorflow//tensorflow/core/kernels:conv_ops",
+        "@org_tensorflow//tensorflow/core/kernels:math",
+    ],
+)
+
 cc_test(
     name = "tensorflow_session_from_frozen_graph_generator_test",
     srcs = ["tensorflow_session_from_frozen_graph_generator_test.cc"],

mediapipe/calculators/tensorflow/graph_tensors_packet_generator_test.cc

@@ -74,7 +74,7 @@ TEST_F(GraphTensorsPacketGeneratorTest, VerifyTensorSizeShapeAndValue) {
 
   ::mediapipe::Status run_status = tool::RunGenerateAndValidateTypes(
       "GraphTensorsPacketGenerator", extendable_options_, inputs, &outputs);
-  MEDIAPIPE_EXPECT_OK(run_status) << run_status.message();
+  MP_EXPECT_OK(run_status) << run_status.message();
   VerifyTensorMap(&outputs);
 }
 

mediapipe/calculators/tensorflow/image_frame_to_tensor_calculator_test.cc

@@ -171,7 +171,7 @@ TEST_F(ImageFrameToTensorCalculatorTest, SolidRedRGBFrame) {
     runner_ = ::absl::make_unique<CalculatorRunner>(
         "ImageFrameToTensorCalculator", "", 1, 1, 0);
     AddRGBFrame(width, height);
-    MEDIAPIPE_ASSERT_OK(runner_->Run());
+    MP_ASSERT_OK(runner_->Run());
     const std::vector<Packet>& output_packets =
         runner_->Outputs().Index(0).packets;
     ASSERT_EQ(1, output_packets.size());
@@ -212,7 +212,7 @@ TEST_F(ImageFrameToTensorCalculatorTest, SolidRedRGBAFrame) {
     runner_.reset(
         new CalculatorRunner("ImageFrameToTensorCalculator", "", 1, 1, 0));
     AddRGBAFrame(width, height);
-    MEDIAPIPE_ASSERT_OK(runner_->Run());
+    MP_ASSERT_OK(runner_->Run());
     const std::vector<Packet>& output_packets =
         runner_->Outputs().Index(0).packets;
     ASSERT_EQ(1, output_packets.size());
@@ -254,7 +254,7 @@ TEST_F(ImageFrameToTensorCalculatorTest, SolidGray8Frame) {
     runner_.reset(
         new CalculatorRunner("ImageFrameToTensorCalculator", "", 1, 1, 0));
     AddGray8Frame(width, height);
-    MEDIAPIPE_ASSERT_OK(runner_->Run());
+    MP_ASSERT_OK(runner_->Run());
     const std::vector<Packet>& output_packets =
         runner_->Outputs().Index(0).packets;
     ASSERT_EQ(1, output_packets.size());
@@ -293,7 +293,7 @@ TEST_F(ImageFrameToTensorCalculatorTest, SolidGray16Frame) {
     runner_.reset(
         new CalculatorRunner("ImageFrameToTensorCalculator", "", 1, 1, 0));
     AddGray16Frame(width, height);
-    MEDIAPIPE_ASSERT_OK(runner_->Run());
+    MP_ASSERT_OK(runner_->Run());
     const std::vector<Packet>& output_packets =
         runner_->Outputs().Index(0).packets;
     ASSERT_EQ(1, output_packets.size());
@@ -332,7 +332,7 @@ TEST_F(ImageFrameToTensorCalculatorTest, SolidFloatFrame) {
     runner_.reset(
         new CalculatorRunner("ImageFrameToTensorCalculator", "", 1, 1, 0));
     AddFloatFrame(width, height);
-    MEDIAPIPE_ASSERT_OK(runner_->Run());
+    MP_ASSERT_OK(runner_->Run());
     const std::vector<Packet>& output_packets =
         runner_->Outputs().Index(0).packets;
     ASSERT_EQ(1, output_packets.size());
@@ -363,7 +363,7 @@ TEST_F(ImageFrameToTensorCalculatorTest, FixedNoiseRGBFrame) {
   runner_.reset(
       new CalculatorRunner("ImageFrameToTensorCalculator", "", 1, 1, 0));
   AddFixedNoiseRGBFrame();
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Index(0).packets;
   ASSERT_EQ(1, output_packets.size());
@@ -396,7 +396,7 @@ TEST_F(ImageFrameToTensorCalculatorTest, RandomRGBFrame) {
     runner_.reset(
         new CalculatorRunner("ImageFrameToTensorCalculator", "", 1, 1, 0));
     AddRandomRGBFrame(width, height, seed);
-    MEDIAPIPE_ASSERT_OK(runner_->Run());
+    MP_ASSERT_OK(runner_->Run());
     const std::vector<Packet>& output_packets =
         runner_->Outputs().Index(0).packets;
     ASSERT_EQ(1, output_packets.size());
@@ -440,7 +440,7 @@ TEST_F(ImageFrameToTensorCalculatorTest, FixedRGBFrameWithMeanAndStddev) {
 
   runner_->MutableInputs()->Index(0).packets.push_back(
       Adopt(image_frame.release()).At(Timestamp(0)));
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const auto& tensor = runner_->Outputs().Index(0).packets[0].Get<tf::Tensor>();
   EXPECT_EQ(tensor.dtype(), tf::DT_FLOAT);

mediapipe/calculators/tensorflow/matrix_to_tensor_calculator_test.cc

@@ -74,7 +74,7 @@ TEST_F(MatrixToTensorCalculatorTest, RandomMatrix) {
     runner_ = ::absl::make_unique<CalculatorRunner>("MatrixToTensorCalculator",
                                                     "", 1, 1, 0);
     AddRandomMatrix(num_rows, num_columns, kSeed);
-    MEDIAPIPE_ASSERT_OK(runner_->Run());
+    MP_ASSERT_OK(runner_->Run());
     const std::vector<Packet>& output_packets =
         runner_->Outputs().Index(0).packets;
     ASSERT_EQ(1, output_packets.size());
@@ -106,7 +106,7 @@ TEST_F(MatrixToTensorCalculatorTest, RandomMatrixTranspose) {
     runner_ = ::absl::make_unique<CalculatorRunner>(
         "MatrixToTensorCalculator", kTransposeOptionsString, 1, 1, 0);
     AddRandomMatrix(num_rows, num_columns, kSeed);
-    MEDIAPIPE_ASSERT_OK(runner_->Run());
+    MP_ASSERT_OK(runner_->Run());
     const std::vector<Packet>& output_packets =
         runner_->Outputs().Index(0).packets;
     ASSERT_EQ(1, output_packets.size());
@@ -138,7 +138,7 @@ TEST_F(MatrixToTensorCalculatorTest, RandomMatrixAddDimension) {
     runner_ = ::absl::make_unique<CalculatorRunner>(
         "MatrixToTensorCalculator", kAddDimensionOptionsString, 1, 1, 0);
     AddRandomMatrix(num_rows, num_columns, kSeed);
-    MEDIAPIPE_ASSERT_OK(runner_->Run());
+    MP_ASSERT_OK(runner_->Run());
     const std::vector<Packet>& output_packets =
         runner_->Outputs().Index(0).packets;
     ASSERT_EQ(1, output_packets.size());

mediapipe/calculators/tensorflow/object_detection_tensors_to_detections_calculator_test.cc

@@ -134,7 +134,7 @@ class ObjectDetectionTensorsToDetectionsCalculatorTest
     runner_->MutableInputs()->Tag(kClasses).packets.push_back(
         PointToForeign(&input_classes_).At(Timestamp::PostStream()));
 
-    MEDIAPIPE_ASSERT_OK(runner_->Run());
+    MP_ASSERT_OK(runner_->Run());
     ASSERT_EQ(1, runner_->Outputs().Tag(kDetections).packets.size());
   }
 
@@ -146,7 +146,7 @@ class ObjectDetectionTensorsToDetectionsCalculatorTest
         PointToForeign(&input_scores_for_all_classes_)
             .At(Timestamp::PostStream()));
 
-    MEDIAPIPE_ASSERT_OK(runner_->Run());
+    MP_ASSERT_OK(runner_->Run());
     ASSERT_EQ(1, runner_->Outputs().Tag(kDetections).packets.size());
   }
 
@@ -167,7 +167,7 @@ class ObjectDetectionTensorsToDetectionsCalculatorTest
         .packets.push_back(
             PointToForeign(&input_keypoints_).At(Timestamp::PostStream()));
 
-    MEDIAPIPE_ASSERT_OK(runner_->Run());
+    MP_ASSERT_OK(runner_->Run());
     ASSERT_EQ(1, runner_->Outputs().Tag(kDetections).packets.size());
   }
 
@@ -201,7 +201,7 @@ class ObjectDetectionTensorsToDetectionsCalculatorTest
     runner_->MutableInputs()->Tag(kClasses).packets.push_back(
         PointToForeign(&input_classes_).At(Timestamp::PostStream()));
 
-    MEDIAPIPE_ASSERT_OK(runner_->Run());
+    MP_ASSERT_OK(runner_->Run());
     ASSERT_EQ(1, runner_->Outputs().Tag(kDetections).packets.size());
   }
 

mediapipe/calculators/tensorflow/pack_media_sequence_calculator_test.cc

@@ -87,7 +87,7 @@ TEST_F(PackMediaSequenceCalculatorTest, PacksTwoImages) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("SEQUENCE_EXAMPLE").packets;
@@ -131,7 +131,7 @@ TEST_F(PackMediaSequenceCalculatorTest, PacksTwoPrefixedImages) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("SEQUENCE_EXAMPLE").packets;
@@ -169,7 +169,7 @@ TEST_F(PackMediaSequenceCalculatorTest, PacksTwoFloatLists) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("SEQUENCE_EXAMPLE").packets;
@@ -214,7 +214,7 @@ TEST_F(PackMediaSequenceCalculatorTest, PacksAdditionalContext) {
   runner_->MutableInputs()->Tag("IMAGE").packets.push_back(
       Adopt(image_ptr.release()).At(Timestamp(0)));
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("SEQUENCE_EXAMPLE").packets;
@@ -257,7 +257,7 @@ TEST_F(PackMediaSequenceCalculatorTest, PacksTwoForwardFlowEncodeds) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("SEQUENCE_EXAMPLE").packets;
@@ -321,7 +321,7 @@ TEST_F(PackMediaSequenceCalculatorTest, PacksTwoBBoxDetections) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("SEQUENCE_EXAMPLE").packets;
@@ -374,7 +374,7 @@ TEST_F(PackMediaSequenceCalculatorTest, PacksTwoKeypoints) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("SEQUENCE_EXAMPLE").packets;
@@ -424,7 +424,7 @@ TEST_F(PackMediaSequenceCalculatorTest, PacksTwoMaskDetections) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("SEQUENCE_EXAMPLE").packets;
@@ -473,7 +473,7 @@ TEST_F(PackMediaSequenceCalculatorTest, MissingStreamOK) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("SEQUENCE_EXAMPLE").packets;
@@ -536,7 +536,7 @@ TEST_F(PackMediaSequenceCalculatorTest, TestReplacingImages) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("SEQUENCE_EXAMPLE").packets;
@@ -562,7 +562,7 @@ TEST_F(PackMediaSequenceCalculatorTest, TestReplacingFlowImages) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("SEQUENCE_EXAMPLE").packets;
@@ -599,7 +599,7 @@ TEST_F(PackMediaSequenceCalculatorTest, TestReplacingFloatVectors) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("SEQUENCE_EXAMPLE").packets;
@@ -643,7 +643,7 @@ TEST_F(PackMediaSequenceCalculatorTest, TestReconcilingAnnotations) {
 
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("SEQUENCE_EXAMPLE").packets;
   ASSERT_EQ(1, output_packets.size());

mediapipe/calculators/tensorflow/tensorflow_inference_calculator.cc

@@ -34,6 +34,10 @@
 #include "tensorflow/core/framework/tensor_shape.h"
 #include "tensorflow/core/framework/tensor_util.h"
 
+#if !defined(__ANDROID__) && !defined(__APPLE__)
+#include "tensorflow/core/profiler/lib/traceme.h"
+#endif
+
 namespace tf = ::tensorflow;
 
 namespace mediapipe {
@@ -361,14 +365,14 @@ class TensorFlowInferenceCalculator : public CalculatorBase {
     }
 
     if (batch_timestamps_.size() == options_.batch_size()) {
-      RETURN_IF_ERROR(OutputBatch(cc));
+      MP_RETURN_IF_ERROR(OutputBatch(cc));
     }
     return ::mediapipe::OkStatus();
   }
 
   ::mediapipe::Status Close(CalculatorContext* cc) override {
     if (!batch_timestamps_.empty()) {
-      RETURN_IF_ERROR(OutputBatch(cc));
+      MP_RETURN_IF_ERROR(OutputBatch(cc));
     }
     return ::mediapipe::OkStatus();
   }
@@ -435,9 +439,15 @@ class TensorFlowInferenceCalculator : public CalculatorBase {
       session_run_throttle->Acquire(1);
     }
     const int64 run_start_time = absl::ToUnixMicros(clock_->TimeNow());
-    const tf::Status tf_status =
-        session_->Run(input_tensors, output_tensor_names,
-                      {} /* target_node_names */, &outputs);
+    tf::Status tf_status;
+    {
+#if !defined(__ANDROID__) && !defined(__APPLE__)
+      tensorflow::profiler::TraceMe trace(absl::string_view(cc->NodeName()));
+#endif
+      tf_status = session_->Run(input_tensors, output_tensor_names,
+                                {} /* target_node_names */, &outputs);
+    }
+
     if (session_run_throttle != nullptr) {
       session_run_throttle->Release(1);
     }

mediapipe/calculators/tensorflow/tensorflow_inference_calculator_test.cc

@@ -122,7 +122,7 @@ TEST_F(TensorflowInferenceCalculatorTest, GetConstants) {
   runner_ = absl::make_unique<CalculatorRunner>(config);
   AddSessionInputSidePacket();
   AddVectorToInputsAsTensor({0, 0, 0}, "A", 0);
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets_b =
       runner_->Outputs().Tag("B").packets;
@@ -163,7 +163,7 @@ TEST_F(TensorflowInferenceCalculatorTest, GetComputed) {
   AddSessionInputSidePacket();
   AddVectorToInputsAsTensor({2, 2, 2}, "A", 0);
   AddVectorToInputsAsTensor({3, 4, 5}, "B", 0);
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets_mult =
       runner_->Outputs().Tag("MULTIPLIED").packets;
@@ -217,7 +217,7 @@ TEST_F(TensorflowInferenceCalculatorTest, GetMultiBatchComputed) {
   AddVectorToInputsAsTensor({3, 4, 5}, "B", 0);
   AddVectorToInputsAsTensor({3, 3, 3}, "A", 1);
   AddVectorToInputsAsTensor({3, 4, 5}, "B", 1);
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets_mult =
       runner_->Outputs().Tag("MULTIPLIED").packets;
@@ -255,7 +255,7 @@ TEST_F(TensorflowInferenceCalculatorTest, GetSingleBatchComputed) {
   AddVectorToInputsAsTensor({3, 4, 5}, "B", 0);
   AddVectorToInputsAsTensor({3, 3, 3}, "A", 1);
   AddVectorToInputsAsTensor({3, 4, 5}, "B", 1);
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets_mult =
       runner_->Outputs().Tag("MULTIPLIED").packets;
@@ -293,7 +293,7 @@ TEST_F(TensorflowInferenceCalculatorTest, GetCloseBatchComputed) {
   AddVectorToInputsAsTensor({3, 4, 5}, "B", 0);
   AddVectorToInputsAsTensor({3, 3, 3}, "A", 1);
   AddVectorToInputsAsTensor({3, 4, 5}, "B", 1);
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets_mult =
       runner_->Outputs().Tag("MULTIPLIED").packets;
@@ -331,7 +331,7 @@ TEST_F(TensorflowInferenceCalculatorTest, TestRecurrentStates) {
   AddSessionInputSidePacket();
   AddVectorToInputsAsTensor({3, 4, 5}, "B", 0);
   AddVectorToInputsAsTensor({3, 4, 5}, "B", 1);
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets_mult =
       runner_->Outputs().Tag("MULTIPLIED").packets;
@@ -372,7 +372,7 @@ TEST_F(TensorflowInferenceCalculatorTest, TestRecurrentStateOverride) {
   AddVectorToInputsAsTensor({3, 4, 5}, "B", 0);
   AddVectorToInputsAsTensor({1, 1, 1}, "A", 1);
   AddVectorToInputsAsTensor({3, 4, 5}, "B", 1);
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets_mult =
       runner_->Outputs().Tag("MULTIPLIED").packets;
@@ -409,7 +409,7 @@ TEST_F(TensorflowInferenceCalculatorTest, DISABLED_CheckTiming) {
   runner_ = absl::make_unique<CalculatorRunner>(config);
   AddSessionInputSidePacket();
   AddVectorToInputsAsTensor({0, 0, 0}, "A", 0);
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   EXPECT_EQ(1, runner_
                    ->GetCounter(
@@ -465,7 +465,7 @@ TEST_F(TensorflowInferenceCalculatorTest, MissingInputFeature_Skip) {
   runner_ = absl::make_unique<CalculatorRunner>(config);
   AddSessionInputSidePacket();
   AddVectorToInputsAsTensor({2, 2, 2}, "A", 0);
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets_mult =
       runner_->Outputs().Tag("MULTIPLIED").packets;
@@ -494,7 +494,7 @@ TEST_F(TensorflowInferenceCalculatorTest,
   AddVectorToInputsAsTensor({2, 2, 2}, "A", 0);
   AddVectorToInputsAsTensor({3, 3, 3}, "A", 1);
   AddVectorToInputsAsTensor({3, 4, 5}, "B", 1);
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets_mult =
       runner_->Outputs().Tag("MULTIPLIED").packets;

mediapipe/calculators/tensorflow/tensorflow_session_from_frozen_graph_calculator.cc

@@ -0,0 +1,136 @@
+// Copyright 2019 The MediaPipe Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Reads serialized GraphDef proto. There are three ways to load a model:
+// 1. Specify the path to a graph.pb in the calculator options.
+// 2. Specify the path to the graph.pb through the
+// input_side_packet:STRING_MODEL_FILE_PATH
+// 3. Provide a serialized GraphDef through input_side_packet:STRING_MODEL,
+// typically provided by EmbeddingFilePacketFactory.
+//
+// Produces a SessionBundle that TensorFlowInferenceCalculator can use.
+
+#include <string>
+
+#include "mediapipe/calculators/tensorflow/tensorflow_session.h"
+#include "mediapipe/calculators/tensorflow/tensorflow_session_from_frozen_graph_calculator.pb.h"
+#include "mediapipe/framework/calculator_framework.h"
+#include "mediapipe/framework/port/ret_check.h"
+#include "mediapipe/framework/port/status.h"
+#include "mediapipe/framework/tool/status_util.h"
+#include "tensorflow/core/public/session_options.h"
+
+#if defined(MEDIAPIPE_LITE) || defined(__ANDROID__) || \
+    defined(__APPLE__) && !TARGET_OS_OSX
+#include "mediapipe/util/android/file/base/helpers.h"
+#else
+#include "mediapipe/framework/port/file_helpers.h"
+#endif
+
+namespace mediapipe {
+
+namespace tf = ::tensorflow;
+
+class TensorFlowSessionFromFrozenGraphCalculator : public CalculatorBase {
+ public:
+  static ::mediapipe::Status GetContract(CalculatorContract* cc) {
+    const auto& options =
+        cc->Options<TensorFlowSessionFromFrozenGraphCalculatorOptions>();
+    bool has_exactly_one_model =
+        !options.graph_proto_path().empty()
+            ? !(cc->InputSidePackets().HasTag("STRING_MODEL") |
+                cc->InputSidePackets().HasTag("STRING_MODEL_FILE_PATH"))
+            : (cc->InputSidePackets().HasTag("STRING_MODEL") ^
+               cc->InputSidePackets().HasTag("STRING_MODEL_FILE_PATH"));
+    RET_CHECK(has_exactly_one_model)
+        << "Must have exactly one of graph_proto_path in options or "
+           "input_side_packets STRING_MODEL or STRING_MODEL_FILE_PATH";
+    if (cc->InputSidePackets().HasTag("STRING_MODEL")) {
+      cc->InputSidePackets()
+          .Tag("STRING_MODEL")
+          .Set<std::string>(
+              // String model from embedded path
+          );
+    } else if (cc->InputSidePackets().HasTag("STRING_MODEL_FILE_PATH")) {
+      cc->InputSidePackets()
+          .Tag("STRING_MODEL_FILE_PATH")
+          .Set<std::string>(
+              // Filename of std::string model.
+          );
+    }
+    cc->OutputSidePackets().Tag("SESSION").Set<TensorFlowSession>(
+        // A TensorFlow model loaded and ready for use along with
+        // a map from tags to tensor names.
+    );
+    RET_CHECK_GT(options.tag_to_tensor_names().size(), 0);
+    return ::mediapipe::OkStatus();
+  }
+
+  ::mediapipe::Status Open(CalculatorContext* cc) override {
+    const auto& options =
+        cc->Options<TensorFlowSessionFromFrozenGraphCalculatorOptions>();
+    // Output bundle packet.
+    auto session = ::absl::make_unique<TensorFlowSession>();
+
+    tf::SessionOptions session_options;
+    session_options.config.CopyFrom(options.config());
+    std::vector<mediapipe::ProtoString> initialization_op_names;
+    initialization_op_names.reserve(options.initialization_op_names_size());
+    for (int i = 0; i < options.initialization_op_names_size(); ++i) {
+      initialization_op_names.emplace_back(options.initialization_op_names(i));
+    }
+    session->session.reset(tf::NewSession(session_options));
+
+    std::string graph_def_serialized;
+    if (cc->InputSidePackets().HasTag("STRING_MODEL")) {
+      graph_def_serialized =
+          cc->InputSidePackets().Tag("STRING_MODEL").Get<std::string>();
+    } else if (cc->InputSidePackets().HasTag("STRING_MODEL_FILE_PATH")) {
+      const std::string& frozen_graph = cc->InputSidePackets()
+                                            .Tag("STRING_MODEL_FILE_PATH")
+                                            .Get<std::string>();
+      RET_CHECK_OK(
+          mediapipe::file::GetContents(frozen_graph, &graph_def_serialized));
+    } else {
+      RET_CHECK_OK(mediapipe::file::GetContents(options.graph_proto_path(),
+                                                &graph_def_serialized));
+    }
+    tensorflow::GraphDef graph_def;
+
+    RET_CHECK(graph_def.ParseFromString(graph_def_serialized));
+    const tf::Status tf_status = session->session->Create(graph_def);
+    RET_CHECK(tf_status.ok()) << "Create failed: " << tf_status.error_message();
+
+    for (const auto& key_value : options.tag_to_tensor_names()) {
+      session->tag_to_tensor_map[key_value.first] = key_value.second;
+    }
+    if (!initialization_op_names.empty()) {
+      const tf::Status tf_status =
+          session->session->Run({}, {}, initialization_op_names, {});
+      // RET_CHECK on the tf::Status object itself in order to print an
+      // informative error message.
+      RET_CHECK(tf_status.ok()) << "Run failed: " << tf_status.error_message();
+    }
+
+    cc->OutputSidePackets().Tag("SESSION").Set(Adopt(session.release()));
+    return ::mediapipe::OkStatus();
+  }
+
+  ::mediapipe::Status Process(CalculatorContext* cc) override {
+    return ::mediapipe::OkStatus();
+  }
+};
+REGISTER_CALCULATOR(TensorFlowSessionFromFrozenGraphCalculator);
+
+}  // namespace mediapipe

mediapipe/calculators/tensorflow/tensorflow_session_from_frozen_graph_calculator.proto

@@ -0,0 +1,72 @@
+// Copyright 2019 The MediaPipe Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto2";
+
+package mediapipe;
+
+import "mediapipe/framework/calculator.proto";
+import "tensorflow/core/protobuf/config.proto";
+
+message TensorFlowSessionFromFrozenGraphCalculatorOptions {
+  extend mediapipe.CalculatorOptions {
+    optional TensorFlowSessionFromFrozenGraphCalculatorOptions ext = 266997877;
+  }
+
+  // Path to file containing serialized proto of type tensorflow::GraphDef.
+  optional string graph_proto_path = 1;
+
+  // To run inference with MediaPipe inputs MediaPipe streams need to be mapped
+  // to TensorFlow tensors. This map defines the which streams are fed into
+  // which tensors in the model. The MediaPipe tag of the stream is the map key.
+  // Tags must be capitalized, matching regex [A-Z0-9_]+. Examples: "JPG_STRING"
+  // and "SOFTMAX". Then, those tags can be used as the MediaPipe tags of
+  // input_stream or output_stream of the TensorflowInferenceCalculator
+  // consuming the packet produced by this calculator. The tensor names must
+  // match the tensor names in the graph that you want to feed or fetch into or
+  // out of. Examples:  "DecodeJpeg/contents:0" or "softmax:0". For example, a
+  // mediapipe graph can include the nodes:
+  //
+  // node {
+  //   calculator: "TensorFlowSessionFromFrozenGraphCalculator"
+  //   output_side_packet: "SESSION:session"
+  //   options {
+  //     [mediapipe.TensorFlowSessionFromFrozenGraphCalculatorOptions.ext]: {
+  //       graph_proto_path: "[PATH]"
+  //       tag_to_tensor_names {
+  //         key: "JPG_STRING"
+  //         value: "input:0"
+  //       }
+  //       tag_to_tensor_names {
+  //         key: "SOFTMAX"
+  //         value: "softmax:0"
+  //       }
+  //     }
+  //   }
+  // }
+  // node {
+  //   calculator: "TensorflowInferenceCalculator"
+  //   input_side_packet: "SESSION:graph_with_bindings"
+  //   input_stream: "JPG_STRING:jpg_string_tensor"
+  //   output_stream: "SOFTMAX:softmax_tensor"
+  // }
+  map<string, string> tag_to_tensor_names = 2;
+
+  // Tensorflow session config options.
+  optional tensorflow.ConfigProto config = 3;
+
+  // Graph nodes to run to initialize the model. Any output of these ops is
+  // ignored.
+  repeated string initialization_op_names = 4;
+}

mediapipe/calculators/tensorflow/tensorflow_session_from_frozen_graph_calculator_test.cc

@@ -0,0 +1,316 @@
+// Copyright 2019 The MediaPipe Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/substitute.h"
+#include "mediapipe/calculators/tensorflow/tensorflow_session.h"
+#include "mediapipe/calculators/tensorflow/tensorflow_session_from_frozen_graph_calculator.pb.h"
+#include "mediapipe/framework/calculator_framework.h"
+#include "mediapipe/framework/calculator_runner.h"
+#include "mediapipe/framework/deps/file_path.h"
+#include "mediapipe/framework/packet.h"
+#include "mediapipe/framework/port/file_helpers.h"
+#include "mediapipe/framework/port/gmock.h"
+#include "mediapipe/framework/port/gtest.h"
+#include "mediapipe/framework/port/parse_text_proto.h"
+#include "mediapipe/framework/port/status.h"
+#include "mediapipe/framework/port/status_matchers.h"
+#include "mediapipe/framework/tool/tag_map_helper.h"
+#include "mediapipe/framework/tool/validate_type.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+
+namespace mediapipe {
+
+namespace {
+
+namespace tf = ::tensorflow;
+
+std::string GetGraphDefPath() {
+  return mediapipe::file::JoinPath("./",
+                                   "mediapipe/calculators/tensorflow/"
+                                   "testdata/frozen_graph_def.pb");
+}
+
+// Helper function that creates Tensor INT32 matrix with size 1x3.
+tf::Tensor TensorMatrix1x3(const int v1, const int v2, const int v3) {
+  tf::Tensor tensor(tf::DT_INT32,
+                    tf::TensorShape(std::vector<tf::int64>({1, 3})));
+  auto matrix = tensor.matrix<int32>();
+  matrix(0, 0) = v1;
+  matrix(0, 1) = v2;
+  matrix(0, 2) = v3;
+  return tensor;
+}
+
+class TensorFlowSessionFromFrozenGraphCalculatorTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    extendable_options_.Clear();
+    calculator_options_ = extendable_options_.MutableExtension(
+        TensorFlowSessionFromFrozenGraphCalculatorOptions::ext);
+    calculator_options_->set_graph_proto_path(GetGraphDefPath());
+    (*calculator_options_->mutable_tag_to_tensor_names())["MULTIPLIED"] =
+        "multiplied:0";
+    (*calculator_options_->mutable_tag_to_tensor_names())["A"] = "a:0";
+    (*calculator_options_->mutable_tag_to_tensor_names())["B"] = "b:0";
+    calculator_options_->mutable_config()->set_intra_op_parallelism_threads(1);
+    calculator_options_->mutable_config()->set_inter_op_parallelism_threads(2);
+  }
+
+  void VerifySignatureMap(const TensorFlowSession& session) {
+    // Session must be set.
+    ASSERT_NE(session.session, nullptr);
+
+    // Bindings are inserted.
+    EXPECT_EQ(session.tag_to_tensor_map.size(), 3);
+
+    // For some reason, EXPECT_EQ and EXPECT_NE are not working with iterators.
+    EXPECT_FALSE(session.tag_to_tensor_map.find("A") ==
+                 session.tag_to_tensor_map.end());
+    EXPECT_FALSE(session.tag_to_tensor_map.find("B") ==
+                 session.tag_to_tensor_map.end());
+    EXPECT_FALSE(session.tag_to_tensor_map.find("MULTIPLIED") ==
+                 session.tag_to_tensor_map.end());
+    // Sanity: find() actually returns a reference to end() if element not
+    // found.
+    EXPECT_TRUE(session.tag_to_tensor_map.find("Z") ==
+                session.tag_to_tensor_map.end());
+
+    EXPECT_EQ(session.tag_to_tensor_map.at("A"), "a:0");
+    EXPECT_EQ(session.tag_to_tensor_map.at("B"), "b:0");
+    EXPECT_EQ(session.tag_to_tensor_map.at("MULTIPLIED"), "multiplied:0");
+  }
+
+  CalculatorOptions extendable_options_;
+  TensorFlowSessionFromFrozenGraphCalculatorOptions* calculator_options_;
+};
+
+TEST_F(TensorFlowSessionFromFrozenGraphCalculatorTest,
+       CreatesPacketWithGraphAndBindings) {
+  CalculatorRunner runner(absl::Substitute(R"(
+        calculator: "TensorFlowSessionFromFrozenGraphCalculator"
+        output_side_packet: "SESSION:tf_model"
+        options {
+          [mediapipe.TensorFlowSessionFromFrozenGraphCalculatorOptions.ext]: {
+            $0
+          }
+        })",
+                                           calculator_options_->DebugString()));
+
+  MP_ASSERT_OK(runner.Run());
+  const TensorFlowSession& session =
+      runner.OutputSidePackets().Tag("SESSION").Get<TensorFlowSession>();
+  VerifySignatureMap(session);
+}
+
+// Integration test. Verifies that TensorFlowInferenceCalculator correctly
+// consumes the Packet emitted by this calculator.
+TEST_F(TensorFlowSessionFromFrozenGraphCalculatorTest,
+       ProducesPacketUsableByTensorFlowInferenceCalculator) {
+  CalculatorGraphConfig config =
+      ::mediapipe::ParseTextProtoOrDie<CalculatorGraphConfig>(
+          absl::Substitute(R"(
+      node {
+        calculator: "TensorFlowInferenceCalculator"
+        input_side_packet: "SESSION:session"
+        input_stream: "A:a_tensor"
+        output_stream: "MULTIPLIED:multiplied_tensor"
+        options {
+          [mediapipe.TensorFlowInferenceCalculatorOptions.ext] {
+            batch_size: 5
+            add_batch_dim_to_tensors: false
+          }
+        }
+      }
+
+      node {
+        calculator: "TensorFlowSessionFromFrozenGraphCalculator"
+        output_side_packet: "SESSION:session"
+        options {
+          [mediapipe.TensorFlowSessionFromFrozenGraphCalculatorOptions.ext]: {
+            $0
+          }
+        }
+      }
+      input_stream: "a_tensor"
+  )",
+                           calculator_options_->DebugString()));
+
+  CalculatorGraph graph;
+  MP_ASSERT_OK(graph.Initialize(config));
+  StatusOrPoller status_or_poller =
+      graph.AddOutputStreamPoller("multiplied_tensor");
+  ASSERT_TRUE(status_or_poller.ok());
+  OutputStreamPoller poller = std::move(status_or_poller.ValueOrDie());
+
+  MP_ASSERT_OK(graph.StartRun({}));
+  MP_ASSERT_OK(graph.AddPacketToInputStream(
+      "a_tensor",
+      Adopt(new auto(TensorMatrix1x3(1, -1, 10))).At(Timestamp(0))));
+  MP_ASSERT_OK(graph.CloseInputStream("a_tensor"));
+
+  Packet packet;
+  ASSERT_TRUE(poller.Next(&packet));
+  // input tensor gets multiplied by [[3, 2, 1]]. Expected output:
+  tf::Tensor expected_multiplication = TensorMatrix1x3(3, -2, 10);
+  EXPECT_EQ(expected_multiplication.DebugString(),
+            packet.Get<tf::Tensor>().DebugString());
+
+  ASSERT_FALSE(poller.Next(&packet));
+  MP_ASSERT_OK(graph.WaitUntilDone());
+}
+
+TEST_F(TensorFlowSessionFromFrozenGraphCalculatorTest,
+       CreatesPacketWithGraphAndBindingsFromInputSidePacket) {
+  calculator_options_->clear_graph_proto_path();
+  CalculatorRunner runner(absl::Substitute(R"(
+        calculator: "TensorFlowSessionFromFrozenGraphCalculator"
+        input_side_packet: "STRING_MODEL:model"
+        output_side_packet: "SESSION:session"
+        options {
+          [mediapipe.TensorFlowSessionFromFrozenGraphCalculatorOptions.ext]: {
+            $0
+          }
+        })",
+                                           calculator_options_->DebugString()));
+
+  std::string serialized_graph_contents;
+  MP_EXPECT_OK(mediapipe::file::GetContents(GetGraphDefPath(),
+                                            &serialized_graph_contents));
+  runner.MutableSidePackets()->Tag("STRING_MODEL") =
+      Adopt(new std::string(serialized_graph_contents));
+  MP_ASSERT_OK(runner.Run());
+
+  const TensorFlowSession& session =
+      runner.OutputSidePackets().Tag("SESSION").Get<TensorFlowSession>();
+  VerifySignatureMap(session);
+}
+
+TEST_F(
+    TensorFlowSessionFromFrozenGraphCalculatorTest,
+    CreatesPacketWithGraphAndBindingsFromInputSidePacketStringModelFilePath) {
+  calculator_options_->clear_graph_proto_path();
+  CalculatorRunner runner(absl::Substitute(R"(
+        calculator: "TensorFlowSessionFromFrozenGraphCalculator"
+        input_side_packet: "STRING_MODEL_FILE_PATH:file_path"
+        output_side_packet: "SESSION:session"
+        options {
+          [mediapipe.TensorFlowSessionFromFrozenGraphCalculatorOptions.ext]: {
+            $0
+          }
+        })",
+                                           calculator_options_->DebugString()));
+  runner.MutableSidePackets()->Tag("STRING_MODEL_FILE_PATH") =
+      Adopt(new std::string(GetGraphDefPath()));
+  MP_ASSERT_OK(runner.Run());
+
+  const TensorFlowSession& session =
+      runner.OutputSidePackets().Tag("SESSION").Get<TensorFlowSession>();
+  VerifySignatureMap(session);
+}
+
+TEST_F(TensorFlowSessionFromFrozenGraphCalculatorTest,
+       CheckFailureForOptionsAndInputsProvideGraphDefProto) {
+  CalculatorRunner runner(absl::Substitute(R"(
+        calculator: "TensorFlowSessionFromFrozenGraphCalculator"
+        input_side_packet: "STRING_MODEL_FILE_PATH:file_path"
+        output_side_packet: "SESSION:session"
+        options {
+          [mediapipe.TensorFlowSessionFromFrozenGraphCalculatorOptions.ext]: {
+            $0
+          }
+        })",
+                                           calculator_options_->DebugString()));
+  runner.MutableSidePackets()->Tag("STRING_MODEL_FILE_PATH") =
+      Adopt(new std::string(GetGraphDefPath()));
+  auto run_status = runner.Run();
+  EXPECT_THAT(
+      run_status.message(),
+      ::testing::HasSubstr("Must have exactly one of graph_proto_path"));
+}
+
+TEST_F(TensorFlowSessionFromFrozenGraphCalculatorTest,
+       CheckFailureForAllInputsProvideGraphDefProto) {
+  CalculatorRunner runner(absl::Substitute(R"(
+        calculator: "TensorFlowSessionFromFrozenGraphCalculator"
+        input_side_packet: "STRING_MODEL_FILE_PATH:file_path"
+        input_side_packet: "STRING_MODEL:model"
+        output_side_packet: "SESSION:session"
+        options {
+          [mediapipe.TensorFlowSessionFromFrozenGraphCalculatorOptions.ext]: {
+            $0
+          }
+        })",
+                                           calculator_options_->DebugString()));
+  runner.MutableSidePackets()->Tag("STRING_MODEL_FILE_PATH") =
+      Adopt(new std::string(GetGraphDefPath()));
+  std::string serialized_graph_contents;
+  MP_EXPECT_OK(mediapipe::file::GetContents(GetGraphDefPath(),
+                                            &serialized_graph_contents));
+  runner.MutableSidePackets()->Tag("STRING_MODEL") =
+      Adopt(new std::string(serialized_graph_contents));
+  auto run_status = runner.Run();
+  EXPECT_THAT(
+      run_status.message(),
+      ::testing::HasSubstr("Must have exactly one of graph_proto_path"));
+}
+
+TEST_F(TensorFlowSessionFromFrozenGraphCalculatorTest,
+       CheckFailureForOnlyBothInputSidePacketsProvideGraphDefProto) {
+  calculator_options_->clear_graph_proto_path();
+  CalculatorRunner runner(absl::Substitute(R"(
+        calculator: "TensorFlowSessionFromFrozenGraphCalculator"
+        input_side_packet: "STRING_MODEL_FILE_PATH:file_path"
+        input_side_packet: "STRING_MODEL:model"
+        output_side_packet: "SESSION:session"
+        options {
+          [mediapipe.TensorFlowSessionFromFrozenGraphCalculatorOptions.ext]: {
+            $0
+          }
+        })",
+                                           calculator_options_->DebugString()));
+  runner.MutableSidePackets()->Tag("STRING_MODEL_FILE_PATH") =
+      Adopt(new std::string(GetGraphDefPath()));
+  std::string serialized_graph_contents;
+  MP_EXPECT_OK(mediapipe::file::GetContents(GetGraphDefPath(),
+                                            &serialized_graph_contents));
+  runner.MutableSidePackets()->Tag("STRING_MODEL") =
+      Adopt(new std::string(serialized_graph_contents));
+  auto run_status = runner.Run();
+  EXPECT_THAT(
+      run_status.message(),
+      ::testing::HasSubstr("Must have exactly one of graph_proto_path"));
+}
+
+TEST_F(TensorFlowSessionFromFrozenGraphCalculatorTest,
+       CheckInitializationOpName) {
+  calculator_options_->add_initialization_op_names("multiplied:0");
+  CalculatorRunner runner(absl::Substitute(R"(
+        calculator: "TensorFlowSessionFromFrozenGraphCalculator"
+        output_side_packet: "SESSION:session"
+        options {
+          [mediapipe.TensorFlowSessionFromFrozenGraphCalculatorOptions.ext]: {
+            $0
+          }
+        })",
+                                           calculator_options_->DebugString()));
+  MP_ASSERT_OK(runner.Run());
+
+  const TensorFlowSession& session =
+      runner.OutputSidePackets().Tag("SESSION").Get<TensorFlowSession>();
+  VerifySignatureMap(session);
+}
+
+}  // namespace
+}  // namespace mediapipe

mediapipe/calculators/tensorflow/tensorflow_session_from_frozen_graph_generator_test.cc

@@ -106,7 +106,7 @@ TEST_F(TensorFlowSessionFromFrozenGraphGeneratorTest,
   ::mediapipe::Status run_status = tool::RunGenerateAndValidateTypes(
       "TensorFlowSessionFromFrozenGraphGenerator", extendable_options_,
       input_side_packets, &output_side_packets);
-  MEDIAPIPE_EXPECT_OK(run_status) << run_status.message();
+  MP_EXPECT_OK(run_status) << run_status.message();
   VerifySignatureMap(&output_side_packets);
 }
 
@@ -144,17 +144,17 @@ TEST_F(TensorFlowSessionFromFrozenGraphGeneratorTest,
                            generator_options_->DebugString()));
 
   CalculatorGraph graph;
-  MEDIAPIPE_ASSERT_OK(graph.Initialize(config));
+  MP_ASSERT_OK(graph.Initialize(config));
   StatusOrPoller status_or_poller =
       graph.AddOutputStreamPoller("multiplied_tensor");
   ASSERT_TRUE(status_or_poller.ok());
   OutputStreamPoller poller = std::move(status_or_poller.ValueOrDie());
 
-  MEDIAPIPE_ASSERT_OK(graph.StartRun({}));
-  MEDIAPIPE_ASSERT_OK(graph.AddPacketToInputStream(
+  MP_ASSERT_OK(graph.StartRun({}));
+  MP_ASSERT_OK(graph.AddPacketToInputStream(
       "a_tensor",
       Adopt(new auto(TensorMatrix1x3(1, -1, 10))).At(Timestamp(0))));
-  MEDIAPIPE_ASSERT_OK(graph.CloseInputStream("a_tensor"));
+  MP_ASSERT_OK(graph.CloseInputStream("a_tensor"));
 
   Packet packet;
   ASSERT_TRUE(poller.Next(&packet));
@@ -164,7 +164,7 @@ TEST_F(TensorFlowSessionFromFrozenGraphGeneratorTest,
             packet.Get<tf::Tensor>().DebugString());
 
   ASSERT_FALSE(poller.Next(&packet));
-  MEDIAPIPE_ASSERT_OK(graph.WaitUntilDone());
+  MP_ASSERT_OK(graph.WaitUntilDone());
 }
 
 TEST_F(TensorFlowSessionFromFrozenGraphGeneratorTest,
@@ -174,15 +174,15 @@ TEST_F(TensorFlowSessionFromFrozenGraphGeneratorTest,
   PacketSet output_side_packets(
       tool::CreateTagMap({"SESSION:session"}).ValueOrDie());
   std::string serialized_graph_contents;
-  MEDIAPIPE_EXPECT_OK(mediapipe::file::GetContents(GetGraphDefPath(),
-                                                   &serialized_graph_contents));
+  MP_EXPECT_OK(mediapipe::file::GetContents(GetGraphDefPath(),
+                                            &serialized_graph_contents));
   generator_options_->clear_graph_proto_path();
   input_side_packets.Tag("STRING_MODEL") =
       Adopt(new std::string(serialized_graph_contents));
   ::mediapipe::Status run_status = tool::RunGenerateAndValidateTypes(
       "TensorFlowSessionFromFrozenGraphGenerator", extendable_options_,
       input_side_packets, &output_side_packets);
-  MEDIAPIPE_EXPECT_OK(run_status) << run_status.message();
+  MP_EXPECT_OK(run_status) << run_status.message();
   VerifySignatureMap(&output_side_packets);
 }
 
@@ -199,7 +199,7 @@ TEST_F(
   ::mediapipe::Status run_status = tool::RunGenerateAndValidateTypes(
       "TensorFlowSessionFromFrozenGraphGenerator", extendable_options_,
       input_side_packets, &output_side_packets);
-  MEDIAPIPE_EXPECT_OK(run_status) << run_status.message();
+  MP_EXPECT_OK(run_status) << run_status.message();
   VerifySignatureMap(&output_side_packets);
 }
 
@@ -229,8 +229,8 @@ TEST_F(TensorFlowSessionFromFrozenGraphGeneratorTest,
   PacketSet output_side_packets(
       tool::CreateTagMap({"SESSION:session"}).ValueOrDie());
   std::string serialized_graph_contents;
-  MEDIAPIPE_EXPECT_OK(mediapipe::file::GetContents(GetGraphDefPath(),
-                                                   &serialized_graph_contents));
+  MP_EXPECT_OK(mediapipe::file::GetContents(GetGraphDefPath(),
+                                            &serialized_graph_contents));
   input_side_packets.Tag("STRING_MODEL") =
       Adopt(new std::string(serialized_graph_contents));
   input_side_packets.Tag("STRING_MODEL_FILE_PATH") =
@@ -254,8 +254,8 @@ TEST_F(TensorFlowSessionFromFrozenGraphGeneratorTest,
   PacketSet output_side_packets(
       tool::CreateTagMap({"SESSION:session"}).ValueOrDie());
   std::string serialized_graph_contents;
-  EXPECT_OK(mediapipe::file::GetContents(GetGraphDefPath(),
-                                         &serialized_graph_contents));
+  MP_EXPECT_OK(mediapipe::file::GetContents(GetGraphDefPath(),
+                                            &serialized_graph_contents));
   input_side_packets.Tag("STRING_MODEL") =
       Adopt(new std::string(serialized_graph_contents));
   input_side_packets.Tag("STRING_MODEL_FILE_PATH") =
@@ -280,7 +280,7 @@ TEST_F(TensorFlowSessionFromFrozenGraphGeneratorTest,
   ::mediapipe::Status run_status = tool::RunGenerateAndValidateTypes(
       "TensorFlowSessionFromFrozenGraphGenerator", extendable_options_,
       input_side_packets, &output_side_packets);
-  MEDIAPIPE_EXPECT_OK(run_status);
+  MP_EXPECT_OK(run_status);
   VerifySignatureMap(&output_side_packets);
 }
 

mediapipe/calculators/tensorflow/tensorflow_session_from_saved_model_calculator.cc

@@ -14,10 +14,6 @@
 
 #include <algorithm>
 
-#if defined(MEDIAPIPE_TPU_SUPPORT)
-#include "learning/brain/google/xla/global_tpu_init.h"
-#include "tensorflow/core/protobuf/tpu/topology.pb.h"
-#endif
 #if !defined(__ANDROID__)
 #include "mediapipe/framework/port/file_helpers.h"
 #endif

mediapipe/calculators/tensorflow/tensorflow_session_from_saved_model_calculator_test.cc

@@ -75,7 +75,7 @@ TEST_F(TensorFlowSessionFromSavedModelCalculatorTest,
           }
         })",
                                            options_->DebugString()));
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   const TensorFlowSession& session =
       runner.OutputSidePackets().Tag("SESSION").Get<TensorFlowSession>();
   // Session must be set.
@@ -119,7 +119,7 @@ TEST_F(TensorFlowSessionFromSavedModelCalculatorTest,
                                            options_->DebugString()));
   runner.MutableSidePackets()->Tag("STRING_SAVED_MODEL_PATH") =
       MakePacket<std::string>(GetSavedModelDir());
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   const TensorFlowSession& session =
       runner.OutputSidePackets().Tag("SESSION").Get<TensorFlowSession>();
   // Session must be set.
@@ -159,17 +159,17 @@ TEST_F(TensorFlowSessionFromSavedModelCalculatorTest,
                            options_->DebugString()));
 
   CalculatorGraph graph;
-  MEDIAPIPE_ASSERT_OK(graph.Initialize(graph_config));
+  MP_ASSERT_OK(graph.Initialize(graph_config));
   StatusOrPoller status_or_poller =
       graph.AddOutputStreamPoller("multiplied_tensor");
   ASSERT_TRUE(status_or_poller.ok());
   OutputStreamPoller poller = std::move(status_or_poller.ValueOrDie());
 
-  MEDIAPIPE_ASSERT_OK(graph.StartRun({}));
-  MEDIAPIPE_ASSERT_OK(graph.AddPacketToInputStream(
+  MP_ASSERT_OK(graph.StartRun({}));
+  MP_ASSERT_OK(graph.AddPacketToInputStream(
       "a_tensor",
       Adopt(new auto(TensorMatrix1x3(1, -1, 10))).At(Timestamp(0))));
-  MEDIAPIPE_ASSERT_OK(graph.CloseInputStream("a_tensor"));
+  MP_ASSERT_OK(graph.CloseInputStream("a_tensor"));
 
   Packet packet;
   ASSERT_TRUE(poller.Next(&packet));
@@ -179,7 +179,7 @@ TEST_F(TensorFlowSessionFromSavedModelCalculatorTest,
             packet.Get<tf::Tensor>().DebugString());
 
   ASSERT_FALSE(poller.Next(&packet));
-  MEDIAPIPE_ASSERT_OK(graph.WaitUntilDone());
+  MP_ASSERT_OK(graph.WaitUntilDone());
 }
 
 TEST_F(TensorFlowSessionFromSavedModelCalculatorTest,
@@ -197,7 +197,7 @@ TEST_F(TensorFlowSessionFromSavedModelCalculatorTest,
           }
         })",
                                            options_->DebugString()));
-  MEDIAPIPE_ASSERT_OK(runner.Run());
+  MP_ASSERT_OK(runner.Run());
   const TensorFlowSession& session =
       runner.OutputSidePackets().Tag("SESSION").Get<TensorFlowSession>();
   // Session must be set.

mediapipe/calculators/tensorflow/tensorflow_session_from_saved_model_generator.cc

@@ -14,10 +14,6 @@
 
 #include <algorithm>
 
-#if defined(MEDIAPIPE_TPU_SUPPORT)
-#include "learning/brain/google/xla/global_tpu_init.h"
-#include "tensorflow/core/protobuf/tpu/topology.pb.h"
-#endif
 #if !defined(__ANDROID__)
 #include "mediapipe/framework/port/file_helpers.h"
 #endif

mediapipe/calculators/tensorflow/tensorflow_session_from_saved_model_generator_test.cc

@@ -71,7 +71,7 @@ TEST_F(TensorFlowSessionFromSavedModelGeneratorTest,
   ::mediapipe::Status run_status = tool::RunGenerateAndValidateTypes(
       "TensorFlowSessionFromSavedModelGenerator", extendable_options_,
       input_side_packets, &output_side_packets);
-  MEDIAPIPE_EXPECT_OK(run_status) << run_status.message();
+  MP_EXPECT_OK(run_status) << run_status.message();
   const TensorFlowSession& session =
       output_side_packets.Tag("SESSION").Get<TensorFlowSession>();
   // Session must be set.
@@ -113,7 +113,7 @@ TEST_F(TensorFlowSessionFromSavedModelGeneratorTest,
   ::mediapipe::Status run_status = tool::RunGenerateAndValidateTypes(
       "TensorFlowSessionFromSavedModelGenerator", extendable_options_,
       input_side_packets, &output_side_packets);
-  MEDIAPIPE_EXPECT_OK(run_status) << run_status.message();
+  MP_EXPECT_OK(run_status) << run_status.message();
   const TensorFlowSession& session =
       output_side_packets.Tag("SESSION").Get<TensorFlowSession>();
   // Session must be set.
@@ -154,17 +154,17 @@ TEST_F(TensorFlowSessionFromSavedModelGeneratorTest,
                            generator_options_->DebugString()));
 
   CalculatorGraph graph;
-  MEDIAPIPE_ASSERT_OK(graph.Initialize(graph_config));
+  MP_ASSERT_OK(graph.Initialize(graph_config));
   StatusOrPoller status_or_poller =
       graph.AddOutputStreamPoller("multiplied_tensor");
   ASSERT_TRUE(status_or_poller.ok());
   OutputStreamPoller poller = std::move(status_or_poller.ValueOrDie());
 
-  MEDIAPIPE_ASSERT_OK(graph.StartRun({}));
-  MEDIAPIPE_ASSERT_OK(graph.AddPacketToInputStream(
+  MP_ASSERT_OK(graph.StartRun({}));
+  MP_ASSERT_OK(graph.AddPacketToInputStream(
       "a_tensor",
       Adopt(new auto(TensorMatrix1x3(1, -1, 10))).At(Timestamp(0))));
-  MEDIAPIPE_ASSERT_OK(graph.CloseInputStream("a_tensor"));
+  MP_ASSERT_OK(graph.CloseInputStream("a_tensor"));
 
   Packet packet;
   ASSERT_TRUE(poller.Next(&packet));
@@ -174,7 +174,7 @@ TEST_F(TensorFlowSessionFromSavedModelGeneratorTest,
             packet.Get<tf::Tensor>().DebugString());
 
   ASSERT_FALSE(poller.Next(&packet));
-  MEDIAPIPE_ASSERT_OK(graph.WaitUntilDone());
+  MP_ASSERT_OK(graph.WaitUntilDone());
 }
 
 TEST_F(TensorFlowSessionFromSavedModelGeneratorTest,
@@ -189,7 +189,7 @@ TEST_F(TensorFlowSessionFromSavedModelGeneratorTest,
   ::mediapipe::Status run_status = tool::RunGenerateAndValidateTypes(
       "TensorFlowSessionFromSavedModelGenerator", extendable_options_,
       input_side_packets, &output_side_packets);
-  MEDIAPIPE_EXPECT_OK(run_status) << run_status.message();
+  MP_EXPECT_OK(run_status) << run_status.message();
   const TensorFlowSession& session =
       output_side_packets.Tag("SESSION").Get<TensorFlowSession>();
   // Session must be set.

mediapipe/calculators/tensorflow/unpack_media_sequence_calculator_test.cc

@@ -97,7 +97,7 @@ TEST_F(UnpackMediaSequenceCalculatorTest, UnpacksOneImage) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("IMAGE").packets;
@@ -126,7 +126,7 @@ TEST_F(UnpackMediaSequenceCalculatorTest, UnpacksTwoImages) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("IMAGE").packets;
@@ -156,7 +156,7 @@ TEST_F(UnpackMediaSequenceCalculatorTest, UnpacksTwoPrefixedImages) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("IMAGE_PREFIX").packets;
@@ -183,7 +183,7 @@ TEST_F(UnpackMediaSequenceCalculatorTest, UnpacksOneForwardFlowImage) {
 
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("FORWARD_FLOW_ENCODED").packets;
@@ -212,7 +212,7 @@ TEST_F(UnpackMediaSequenceCalculatorTest, UnpacksTwoForwardFlowImages) {
 
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("FORWARD_FLOW_ENCODED").packets;
@@ -242,7 +242,7 @@ TEST_F(UnpackMediaSequenceCalculatorTest, UnpacksBBoxes) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("BBOX").packets;
@@ -276,7 +276,7 @@ TEST_F(UnpackMediaSequenceCalculatorTest, UnpacksPrefixedBBoxes) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("BBOX_PREFIX").packets;
@@ -308,7 +308,7 @@ TEST_F(UnpackMediaSequenceCalculatorTest, UnpacksTwoFloatLists) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("FLOAT_FEATURE_TEST").packets;
@@ -353,7 +353,7 @@ TEST_F(UnpackMediaSequenceCalculatorTest, UnpacksNonOverlappingTimestamps) {
 
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& output_packets =
       runner_->Outputs().Tag("IMAGE").packets;
@@ -390,7 +390,7 @@ TEST_F(UnpackMediaSequenceCalculatorTest, UnpacksTwoPostStreamFloatLists) {
 
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(input_sequence.release());
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
   const std::vector<Packet>& fdense_avg_packets =
       runner_->Outputs().Tag("FLOAT_FEATURE_FDENSE_AVG").packets;
@@ -419,11 +419,11 @@ TEST_F(UnpackMediaSequenceCalculatorTest, GetDatasetFromPacket) {
 
   std::string root = "test_root";
   runner_->MutableSidePackets()->Tag("DATASET_ROOT") = PointToForeign(&root);
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
-  MEDIAPIPE_ASSERT_OK(runner_->OutputSidePackets()
-                          .Tag("DATA_PATH")
-                          .ValidateAsType<std::string>());
+  MP_ASSERT_OK(runner_->OutputSidePackets()
+                   .Tag("DATA_PATH")
+                   .ValidateAsType<std::string>());
   ASSERT_EQ(runner_->OutputSidePackets().Tag("DATA_PATH").Get<std::string>(),
             root + "/" + data_path_);
 }
@@ -437,11 +437,11 @@ TEST_F(UnpackMediaSequenceCalculatorTest, GetDatasetFromOptions) {
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(sequence_.release());
 
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
-  MEDIAPIPE_ASSERT_OK(runner_->OutputSidePackets()
-                          .Tag("DATA_PATH")
-                          .ValidateAsType<std::string>());
+  MP_ASSERT_OK(runner_->OutputSidePackets()
+                   .Tag("DATA_PATH")
+                   .ValidateAsType<std::string>());
   ASSERT_EQ(runner_->OutputSidePackets().Tag("DATA_PATH").Get<std::string>(),
             root + "/" + data_path_);
 }
@@ -450,11 +450,11 @@ TEST_F(UnpackMediaSequenceCalculatorTest, GetDatasetFromExample) {
   SetUpCalculator({}, {"DATA_PATH:data_path"});
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(sequence_.release());
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
-  MEDIAPIPE_ASSERT_OK(runner_->OutputSidePackets()
-                          .Tag("DATA_PATH")
-                          .ValidateAsType<std::string>());
+  MP_ASSERT_OK(runner_->OutputSidePackets()
+                   .Tag("DATA_PATH")
+                   .ValidateAsType<std::string>());
   ASSERT_EQ(runner_->OutputSidePackets().Tag("DATA_PATH").Get<std::string>(),
             data_path_);
 }
@@ -473,11 +473,11 @@ TEST_F(UnpackMediaSequenceCalculatorTest, GetPacketResamplingOptions) {
   SetUpCalculator({}, {"RESAMPLER_OPTIONS:resampler_options"}, {}, &options);
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(sequence_.release());
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
+  MP_ASSERT_OK(runner_->Run());
 
-  MEDIAPIPE_EXPECT_OK(runner_->OutputSidePackets()
-                          .Tag("RESAMPLER_OPTIONS")
-                          .ValidateAsType<CalculatorOptions>());
+  MP_EXPECT_OK(runner_->OutputSidePackets()
+                   .Tag("RESAMPLER_OPTIONS")
+                   .ValidateAsType<CalculatorOptions>());
   EXPECT_NEAR(runner_->OutputSidePackets()
                   .Tag("RESAMPLER_OPTIONS")
                   .Get<CalculatorOptions>()
@@ -502,10 +502,10 @@ TEST_F(UnpackMediaSequenceCalculatorTest, GetFrameRateFromExample) {
   SetUpCalculator({}, {"IMAGE_FRAME_RATE:frame_rate"});
   runner_->MutableSidePackets()->Tag("SEQUENCE_EXAMPLE") =
       Adopt(sequence_.release());
-  MEDIAPIPE_ASSERT_OK(runner_->Run());
-  MEDIAPIPE_EXPECT_OK(runner_->OutputSidePackets()
-                          .Tag("IMAGE_FRAME_RATE")
-                          .ValidateAsType<double>());
+  MP_ASSERT_OK(runner_->Run());
+  MP_EXPECT_OK(runner_->OutputSidePackets()
+                   .Tag("IMAGE_FRAME_RATE")
+                   .ValidateAsType<double>());
   EXPECT_EQ(runner_->OutputSidePackets().Tag("IMAGE_FRAME_RATE").Get<double>(),
             image_frame_rate_);
 }

mediapipe/calculators/tflite/BUILD

@@ -61,6 +61,13 @@ proto_library(
     deps = ["//mediapipe/framework:calculator_proto"],
 )
 
+proto_library(
+    name = "tflite_tensors_to_classification_calculator_proto",
+    srcs = ["tflite_tensors_to_classification_calculator.proto"],
+    visibility = ["//visibility:public"],
+    deps = ["//mediapipe/framework:calculator_proto"],
+)
+
 proto_library(
     name = "tflite_tensors_to_landmarks_calculator_proto",
     srcs = ["tflite_tensors_to_landmarks_calculator.proto"],
@@ -72,7 +79,7 @@ mediapipe_cc_proto_library(
     name = "ssd_anchors_calculator_cc_proto",
     srcs = ["ssd_anchors_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":ssd_anchors_calculator_proto"],
 )
 
@@ -80,7 +87,7 @@ mediapipe_cc_proto_library(
     name = "tflite_custom_op_resolver_calculator_cc_proto",
     srcs = ["tflite_custom_op_resolver_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":tflite_custom_op_resolver_calculator_proto"],
 )
 
@@ -88,7 +95,7 @@ mediapipe_cc_proto_library(
     name = "tflite_converter_calculator_cc_proto",
     srcs = ["tflite_converter_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":tflite_converter_calculator_proto"],
 )
 
@@ -96,7 +103,7 @@ mediapipe_cc_proto_library(
     name = "tflite_tensors_to_segmentation_calculator_cc_proto",
     srcs = ["tflite_tensors_to_segmentation_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":tflite_tensors_to_segmentation_calculator_proto"],
 )
 
@@ -104,7 +111,7 @@ mediapipe_cc_proto_library(
     name = "tflite_inference_calculator_cc_proto",
     srcs = ["tflite_inference_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":tflite_inference_calculator_proto"],
 )
 
@@ -112,15 +119,23 @@ mediapipe_cc_proto_library(
     name = "tflite_tensors_to_detections_calculator_cc_proto",
     srcs = ["tflite_tensors_to_detections_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":tflite_tensors_to_detections_calculator_proto"],
 )
 
+mediapipe_cc_proto_library(
+    name = "tflite_tensors_to_classification_calculator_cc_proto",
+    srcs = ["tflite_tensors_to_classification_calculator.proto"],
+    cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
+    visibility = ["//visibility:public"],
+    deps = [":tflite_tensors_to_classification_calculator_proto"],
+)
+
 mediapipe_cc_proto_library(
     name = "tflite_tensors_to_landmarks_calculator_cc_proto",
     srcs = ["tflite_tensors_to_landmarks_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":tflite_tensors_to_landmarks_calculator_proto"],
 )
 
@@ -185,7 +200,6 @@ cc_library(
     srcs = ["tflite_inference_calculator.cc"],
     copts = select({
         "//mediapipe:ios": [
-            "-std=c++11",
             "-x objective-c++",
             "-fobjc-arc",  # enable reference-counting
         ],
@@ -231,7 +245,6 @@ cc_library(
     srcs = ["tflite_converter_calculator.cc"],
     copts = select({
         "//mediapipe:ios": [
-            "-std=c++11",
             "-x objective-c++",
             "-fobjc-arc",  # enable reference-counting
         ],
@@ -311,6 +324,25 @@ cc_library(
     alwayslink = 1,
 )
 
+cc_test(
+    name = "tflite_tensors_to_classification_calculator_test",
+    srcs = ["tflite_tensors_to_classification_calculator_test.cc"],
+    data = ["testdata/labelmap.txt"],
+    deps = [
+        ":tflite_tensors_to_classification_calculator",
+        ":tflite_tensors_to_classification_calculator_cc_proto",
+        "//mediapipe/framework:calculator_cc_proto",
+        "//mediapipe/framework:calculator_framework",
+        "//mediapipe/framework:calculator_runner",
+        "//mediapipe/framework/formats:classification_cc_proto",
+        "//mediapipe/framework/port:gtest_main",
+        "//mediapipe/framework/port:parse_text_proto",
+        "@com_google_absl//absl/memory",
+        "@com_google_googletest//:gtest_main",
+        "@org_tensorflow//tensorflow/lite:framework",
+    ],
+)
+
 cc_library(
     name = "tflite_tensors_to_detections_calculator",
     srcs = ["tflite_tensors_to_detections_calculator.cc"],
@@ -339,6 +371,37 @@ cc_library(
     alwayslink = 1,
 )
 
+cc_library(
+    name = "tflite_tensors_to_classification_calculator",
+    srcs = ["tflite_tensors_to_classification_calculator.cc"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":tflite_tensors_to_classification_calculator_cc_proto",
+        "@com_google_absl//absl/strings:str_format",
+        "@com_google_absl//absl/types:span",
+        "//mediapipe/framework/formats:classification_cc_proto",
+        "//mediapipe/framework:calculator_framework",
+        "//mediapipe/framework/formats:location",
+        "//mediapipe/framework/port:ret_check",
+        "//mediapipe/util:resource_util",
+        "@org_tensorflow//tensorflow/lite:framework",
+    ] + select({
+        "//mediapipe:android": [
+            "//mediapipe/util/android/file/base",
+        ],
+        "//mediapipe:apple": [
+            "//mediapipe/util/android/file/base",
+        ],
+        "//mediapipe:macos": [
+            "//mediapipe/framework/port:file_helpers",
+        ],
+        "//conditions:default": [
+            "//mediapipe/framework/port:file_helpers",
+        ],
+    }),
+    alwayslink = 1,
+)
+
 cc_library(
     name = "tflite_tensors_to_landmarks_calculator",
     srcs = ["tflite_tensors_to_landmarks_calculator.cc"],

mediapipe/calculators/tflite/ssd_anchors_calculator.cc

@@ -79,7 +79,7 @@ class SsdAnchorsCalculator : public CalculatorBase {
         cc->Options<SsdAnchorsCalculatorOptions>();
 
     auto anchors = absl::make_unique<std::vector<Anchor>>();
-    RETURN_IF_ERROR(GenerateAnchors(anchors.get(), options));
+    MP_RETURN_IF_ERROR(GenerateAnchors(anchors.get(), options));
     cc->OutputSidePackets().Index(0).Set(Adopt(anchors.release()));
     return ::mediapipe::OkStatus();
   }

mediapipe/calculators/tflite/ssd_anchors_calculator_test.cc

@@ -90,12 +90,12 @@ TEST(SsdAnchorCalculatorTest, FaceDetectionConfig) {
     }
   )"));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
 
   const auto& anchors =
       runner.OutputSidePackets().Index(0).Get<std::vector<Anchor>>();
   std::string anchors_string;
-  MEDIAPIPE_EXPECT_OK(mediapipe::file::GetContents(
+  MP_EXPECT_OK(mediapipe::file::GetContents(
       GetGoldenFilePath("anchor_golden_file_0.txt"), &anchors_string));
 
   std::vector<Anchor> anchors_golden;
@@ -133,12 +133,12 @@ TEST(SsdAnchorCalculatorTest, MobileSSDConfig) {
     }
   )"));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const auto& anchors =
       runner.OutputSidePackets().Index(0).Get<std::vector<Anchor>>();
 
   std::string anchors_string;
-  MEDIAPIPE_EXPECT_OK(mediapipe::file::GetContents(
+  MP_EXPECT_OK(mediapipe::file::GetContents(
       GetGoldenFilePath("anchor_golden_file_1.txt"), &anchors_string));
 
   std::vector<Anchor> anchors_golden;

mediapipe/calculators/tflite/testdata/labelmap.txt

@@ -0,0 +1,3 @@
+classA
+classB
+classC

mediapipe/calculators/tflite/tflite_converter_calculator.cc

@@ -190,9 +190,9 @@ REGISTER_CALCULATOR(TfLiteConverterCalculator);
 #endif
 
 #if defined(__ANDROID__)
-  RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
+  MP_RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
 #elif defined(__APPLE__) && !TARGET_OS_OSX  // iOS
-  RETURN_IF_ERROR([MPPMetalHelper updateContract:cc]);
+  MP_RETURN_IF_ERROR([MPPMetalHelper updateContract:cc]);
 #endif
 
   // Assign this calculator's default InputStreamHandler.
@@ -204,7 +204,7 @@ REGISTER_CALCULATOR(TfLiteConverterCalculator);
 ::mediapipe::Status TfLiteConverterCalculator::Open(CalculatorContext* cc) {
   cc->SetOffset(TimestampDiff(0));
 
-  RETURN_IF_ERROR(LoadOptions(cc));
+  MP_RETURN_IF_ERROR(LoadOptions(cc));
 
   if (cc->Inputs().HasTag("IMAGE_GPU") ||
       cc->Outputs().HasTag("IMAGE_OUT_GPU")) {
@@ -222,7 +222,7 @@ REGISTER_CALCULATOR(TfLiteConverterCalculator);
     // Cannot use quantization.
     use_quantized_tensors_ = false;
 #if defined(__ANDROID__)
-    RETURN_IF_ERROR(gpu_helper_.Open(cc));
+    MP_RETURN_IF_ERROR(gpu_helper_.Open(cc));
 #elif defined(__APPLE__) && !TARGET_OS_OSX  // iOS
     gpu_helper_ = [[MPPMetalHelper alloc] initWithCalculatorContext:cc];
     RET_CHECK(gpu_helper_);
@@ -239,14 +239,14 @@ REGISTER_CALCULATOR(TfLiteConverterCalculator);
 ::mediapipe::Status TfLiteConverterCalculator::Process(CalculatorContext* cc) {
   if (use_gpu_) {
     if (!initialized_) {
-      RETURN_IF_ERROR(InitGpu(cc));
+      MP_RETURN_IF_ERROR(InitGpu(cc));
       initialized_ = true;
     }
     // Convert to GPU tensors type.
-    RETURN_IF_ERROR(ProcessGPU(cc));
+    MP_RETURN_IF_ERROR(ProcessGPU(cc));
   } else {
     // Convert to CPU tensors or Matrix type.
-    RETURN_IF_ERROR(ProcessCPU(cc));
+    MP_RETURN_IF_ERROR(ProcessCPU(cc));
   }
 
   return ::mediapipe::OkStatus();
@@ -321,11 +321,11 @@ REGISTER_CALCULATOR(TfLiteConverterCalculator);
       float* tensor_buffer = tensor->data.f;
       RET_CHECK(tensor_buffer);
       if (image_frame.ByteDepth() == 1) {
-        RETURN_IF_ERROR(NormalizeImage<uint8>(image_frame, zero_center_,
-                                              flip_vertically_, tensor_buffer));
+        MP_RETURN_IF_ERROR(NormalizeImage<uint8>(
+            image_frame, zero_center_, flip_vertically_, tensor_buffer));
       } else if (image_frame.ByteDepth() == 4) {
-        RETURN_IF_ERROR(NormalizeImage<float>(image_frame, zero_center_,
-                                              flip_vertically_, tensor_buffer));
+        MP_RETURN_IF_ERROR(NormalizeImage<float>(
+            image_frame, zero_center_, flip_vertically_, tensor_buffer));
       } else {
         return ::mediapipe::InternalError(
             "Only byte-based (8 bit) and float (32 bit) images supported.");
@@ -359,7 +359,7 @@ REGISTER_CALCULATOR(TfLiteConverterCalculator);
     float* tensor_buffer = tensor->data.f;
     RET_CHECK(tensor_buffer);
 
-    RETURN_IF_ERROR(CopyMatrixToTensor(matrix, tensor_buffer));
+    MP_RETURN_IF_ERROR(CopyMatrixToTensor(matrix, tensor_buffer));
 
     auto output_tensors = absl::make_unique<std::vector<TfLiteTensor>>();
     output_tensors->emplace_back(*tensor);
@@ -375,7 +375,7 @@ REGISTER_CALCULATOR(TfLiteConverterCalculator);
 #if defined(__ANDROID__)
   // GpuBuffer to tflite::gpu::GlBuffer conversion.
   const auto& input = cc->Inputs().Tag("IMAGE_GPU").Get<mediapipe::GpuBuffer>();
-  RETURN_IF_ERROR(
+  MP_RETURN_IF_ERROR(
       gpu_helper_.RunInGlContext([this, &input]() -> ::mediapipe::Status {
         // Convert GL texture into TfLite GlBuffer (SSBO).
         auto src = gpu_helper_.CreateSourceTexture(input);

mediapipe/calculators/tflite/tflite_converter_calculator_test.cc

@@ -67,7 +67,7 @@ class TfLiteConverterCalculatorTest : public ::testing::Test {
         }
       }
     }
-    MEDIAPIPE_ASSERT_OK(graph_->AddPacketToInputStream(
+    MP_ASSERT_OK(graph_->AddPacketToInputStream(
         "matrix", Adopt(matrix.release()).At(Timestamp(0))));
   }
 
@@ -99,14 +99,14 @@ TEST_F(TfLiteConverterCalculatorTest, RandomMatrixColMajor) {
 
     // Run the graph.
     graph_ = absl::make_unique<CalculatorGraph>();
-    MEDIAPIPE_ASSERT_OK(graph_->Initialize(graph_config));
-    MEDIAPIPE_ASSERT_OK(graph_->StartRun({}));
+    MP_ASSERT_OK(graph_->Initialize(graph_config));
+    MP_ASSERT_OK(graph_->StartRun({}));
 
     // Push the tensor into the graph.
     AddRandomMatrix(num_rows, num_columns, kSeed, /*row_major_matrix=*/false);
 
     // Wait until the calculator done processing.
-    MEDIAPIPE_ASSERT_OK(graph_->WaitUntilIdle());
+    MP_ASSERT_OK(graph_->WaitUntilIdle());
     EXPECT_EQ(1, output_packets.size());
 
     // Get and process results.
@@ -128,8 +128,8 @@ TEST_F(TfLiteConverterCalculatorTest, RandomMatrixColMajor) {
 
     // Fully close graph at end, otherwise calculator+tensors are destroyed
     // after calling WaitUntilDone().
-    MEDIAPIPE_ASSERT_OK(graph_->CloseInputStream("matrix"));
-    MEDIAPIPE_ASSERT_OK(graph_->WaitUntilDone());
+    MP_ASSERT_OK(graph_->CloseInputStream("matrix"));
+    MP_ASSERT_OK(graph_->WaitUntilDone());
 
     graph_.reset();
   }
@@ -160,14 +160,14 @@ TEST_F(TfLiteConverterCalculatorTest, RandomMatrixRowMajor) {
 
     // Run the graph.
     graph_ = absl::make_unique<CalculatorGraph>();
-    MEDIAPIPE_ASSERT_OK(graph_->Initialize(graph_config));
-    MEDIAPIPE_ASSERT_OK(graph_->StartRun({}));
+    MP_ASSERT_OK(graph_->Initialize(graph_config));
+    MP_ASSERT_OK(graph_->StartRun({}));
 
     // Push the tensor into the graph.
     AddRandomMatrix(num_rows, num_columns, kSeed, /*row_major_matrix=*/true);
 
     // Wait until the calculator done processing.
-    MEDIAPIPE_ASSERT_OK(graph_->WaitUntilIdle());
+    MP_ASSERT_OK(graph_->WaitUntilIdle());
     EXPECT_EQ(1, output_packets.size());
 
     // Get and process results.
@@ -189,8 +189,8 @@ TEST_F(TfLiteConverterCalculatorTest, RandomMatrixRowMajor) {
 
     // Fully close graph at end, otherwise calculator+tensors are destroyed
     // after calling WaitUntilDone().
-    MEDIAPIPE_ASSERT_OK(graph_->CloseInputStream("matrix"));
-    MEDIAPIPE_ASSERT_OK(graph_->WaitUntilDone());
+    MP_ASSERT_OK(graph_->CloseInputStream("matrix"));
+    MP_ASSERT_OK(graph_->WaitUntilDone());
 
     graph_.reset();
   }

mediapipe/calculators/tflite/tflite_inference_calculator.cc

@@ -182,9 +182,9 @@ REGISTER_CALCULATOR(TfLiteInferenceCalculator);
   }
 
 #if defined(__ANDROID__)
-  RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
+  MP_RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
 #elif defined(__APPLE__) && !TARGET_OS_OSX  // iOS
-  RETURN_IF_ERROR([MPPMetalHelper updateContract:cc]);
+  MP_RETURN_IF_ERROR([MPPMetalHelper updateContract:cc]);
 #endif
 
   // Assign this calculator's default InputStreamHandler.
@@ -196,7 +196,7 @@ REGISTER_CALCULATOR(TfLiteInferenceCalculator);
 ::mediapipe::Status TfLiteInferenceCalculator::Open(CalculatorContext* cc) {
   cc->SetOffset(TimestampDiff(0));
 
-  RETURN_IF_ERROR(LoadOptions(cc));
+  MP_RETURN_IF_ERROR(LoadOptions(cc));
 
   if (cc->Inputs().HasTag("TENSORS_GPU")) {
 #if defined(__ANDROID__) || (defined(__APPLE__) && !TARGET_OS_OSX)
@@ -217,17 +217,17 @@ REGISTER_CALCULATOR(TfLiteInferenceCalculator);
 #endif
   }
 
-  RETURN_IF_ERROR(LoadModel(cc));
+  MP_RETURN_IF_ERROR(LoadModel(cc));
 
   if (gpu_inference_) {
 #if defined(__ANDROID__)
-    RETURN_IF_ERROR(gpu_helper_.Open(cc));
+    MP_RETURN_IF_ERROR(gpu_helper_.Open(cc));
 #elif defined(__APPLE__) && !TARGET_OS_OSX  // iOS
     gpu_helper_ = [[MPPMetalHelper alloc] initWithCalculatorContext:cc];
     RET_CHECK(gpu_helper_);
 #endif
 
-    RETURN_IF_ERROR(LoadDelegate(cc));
+    MP_RETURN_IF_ERROR(LoadDelegate(cc));
   }
 
   return ::mediapipe::OkStatus();
@@ -241,7 +241,7 @@ REGISTER_CALCULATOR(TfLiteInferenceCalculator);
     const auto& input_tensors =
         cc->Inputs().Tag("TENSORS_GPU").Get<std::vector<GpuTensor>>();
     RET_CHECK_EQ(input_tensors.size(), 1);
-    RETURN_IF_ERROR(gpu_helper_.RunInGlContext(
+    MP_RETURN_IF_ERROR(gpu_helper_.RunInGlContext(
         [this, &input_tensors]() -> ::mediapipe::Status {
           // Explicit copy input.
           tflite::gpu::gl::CopyBuffer(input_tensors[0], gpu_data_in_->buffer);
@@ -290,10 +290,11 @@ REGISTER_CALCULATOR(TfLiteInferenceCalculator);
   // 2. Run inference.
   if (gpu_inference_) {
 #if defined(__ANDROID__)
-    RETURN_IF_ERROR(gpu_helper_.RunInGlContext([this]() -> ::mediapipe::Status {
-      RET_CHECK_EQ(interpreter_->Invoke(), kTfLiteOk);
-      return ::mediapipe::OkStatus();
-    }));
+    MP_RETURN_IF_ERROR(
+        gpu_helper_.RunInGlContext([this]() -> ::mediapipe::Status {
+          RET_CHECK_EQ(interpreter_->Invoke(), kTfLiteOk);
+          return ::mediapipe::OkStatus();
+        }));
 #elif defined(__APPLE__) && !TARGET_OS_OSX  // iOS
     RET_CHECK_EQ(interpreter_->Invoke(), kTfLiteOk);
 #endif
@@ -367,7 +368,7 @@ REGISTER_CALCULATOR(TfLiteInferenceCalculator);
 ::mediapipe::Status TfLiteInferenceCalculator::Close(CalculatorContext* cc) {
   if (delegate_) {
 #if defined(__ANDROID__)
-    RETURN_IF_ERROR(gpu_helper_.RunInGlContext([this]() -> Status {
+    MP_RETURN_IF_ERROR(gpu_helper_.RunInGlContext([this]() -> Status {
       TfLiteGpuDelegateDelete(delegate_);
       gpu_data_in_.reset();
       for (int i = 0; i < gpu_data_out_.size(); ++i) {
@@ -434,8 +435,9 @@ REGISTER_CALCULATOR(TfLiteInferenceCalculator);
     use_quantized_tensors_ = false;
   } else {
     RET_CHECK_EQ(interpreter_->AllocateTensors(), kTfLiteOk);
-    use_quantized_tensors_ = (interpreter_->tensor(0)->quantization.type ==
-                              kTfLiteAffineQuantization);
+    use_quantized_tensors_ =
+        (interpreter_->tensor(interpreter_->inputs()[0])->quantization.type ==
+         kTfLiteAffineQuantization);
     if (use_quantized_tensors_) gpu_inference_ = false;
   }
 

mediapipe/calculators/tflite/tflite_inference_calculator_test.cc

@@ -93,13 +93,13 @@ TEST_F(TfLiteInferenceCalculatorTest, SmokeTest) {
   std::vector<Packet> output_packets;
   tool::AddVectorSink("tensor_out", &graph_config, &output_packets);
   CalculatorGraph graph(graph_config);
-  MEDIAPIPE_ASSERT_OK(graph.StartRun({}));
+  MP_ASSERT_OK(graph.StartRun({}));
 
   // Push the tensor into the graph.
-  MEDIAPIPE_ASSERT_OK(graph.AddPacketToInputStream(
+  MP_ASSERT_OK(graph.AddPacketToInputStream(
       "tensor_in", Adopt(input_vec.release()).At(Timestamp(0))));
   // Wait until the calculator done processing.
-  MEDIAPIPE_ASSERT_OK(graph.WaitUntilIdle());
+  MP_ASSERT_OK(graph.WaitUntilIdle());
   ASSERT_EQ(1, output_packets.size());
 
   // Get and process results.
@@ -116,8 +116,8 @@ TEST_F(TfLiteInferenceCalculatorTest, SmokeTest) {
 
   // Fully close graph at end, otherwise calculator+tensors are destroyed
   // after calling WaitUntilDone().
-  MEDIAPIPE_ASSERT_OK(graph.CloseInputStream("tensor_in"));
-  MEDIAPIPE_ASSERT_OK(graph.WaitUntilDone());
+  MP_ASSERT_OK(graph.CloseInputStream("tensor_in"));
+  MP_ASSERT_OK(graph.WaitUntilDone());
 }
 
 }  // namespace mediapipe

mediapipe/calculators/tflite/tflite_tensors_to_classification_calculator.cc

@@ -0,0 +1,176 @@
+// Copyright 2019 The MediaPipe Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <algorithm>
+#include <unordered_map>
+#include <vector>
+
+#include "absl/strings/str_format.h"
+#include "absl/types/span.h"
+#include "mediapipe/calculators/tflite/tflite_tensors_to_classification_calculator.pb.h"
+#include "mediapipe/framework/calculator_framework.h"
+#include "mediapipe/framework/formats/classification.pb.h"
+#include "mediapipe/framework/port/ret_check.h"
+#include "mediapipe/util/resource_util.h"
+#include "tensorflow/lite/interpreter.h"
+#if defined(__ANDROID__) || (defined(__APPLE__) && !TARGET_OS_OSX)
+#include "mediapipe/util/android/file/base/file.h"
+#include "mediapipe/util/android/file/base/helpers.h"
+#else
+#include "mediapipe/framework/port/file_helpers.h"
+#endif
+
+namespace mediapipe {
+
+// Convert result TFLite tensors from classification models into MediaPipe
+// classifications.
+//
+// Input:
+//  TENSORS - Vector of TfLiteTensor of type kTfLiteFloat32 containing one
+//            tensor, the size of which must be (1, * num_classes).
+// Output:
+//  CLASSIFICATIONS - Result MediaPipe ClassificationList. The score and index
+//                    fields of each classification are set, while the label
+//                    field is only set if label_map_path is provided.
+//
+// Usage example:
+// node {
+//   calculator: "TfLiteTensorsToClassificationCalculator"
+//   input_stream: "TENSORS:tensors"
+//   output_stream: "CLASSIFICATIONS:classifications"
+//   options: {
+//     [mediapipe.TfLiteTensorsToClassificationCalculatorOptions.ext] {
+//       num_classes: 1024
+//       min_score_threshold: 0.1
+//       label_map_path: "labelmap.txt"
+//     }
+//   }
+// }
+class TfLiteTensorsToClassificationCalculator : 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;
+
+ private:
+  int top_k_ = 0;
+  double min_score_threshold_ = 0;
+  std::unordered_map<int, std::string> label_map_;
+  bool label_map_loaded_ = false;
+};
+REGISTER_CALCULATOR(TfLiteTensorsToClassificationCalculator);
+
+::mediapipe::Status TfLiteTensorsToClassificationCalculator::GetContract(
+    CalculatorContract* cc) {
+  RET_CHECK(!cc->Inputs().GetTags().empty());
+  RET_CHECK(!cc->Outputs().GetTags().empty());
+
+  if (cc->Inputs().HasTag("TENSORS")) {
+    cc->Inputs().Tag("TENSORS").Set<std::vector<TfLiteTensor>>();
+  }
+
+  if (cc->Outputs().HasTag("CLASSIFICATIONS")) {
+    cc->Outputs().Tag("CLASSIFICATIONS").Set<ClassificationList>();
+  }
+
+  return ::mediapipe::OkStatus();
+}
+
+::mediapipe::Status TfLiteTensorsToClassificationCalculator::Open(
+    CalculatorContext* cc) {
+  cc->SetOffset(TimestampDiff(0));
+
+  auto options = cc->Options<
+      ::mediapipe::TfLiteTensorsToClassificationCalculatorOptions>();
+
+  top_k_ = options.top_k();
+  min_score_threshold_ = options.min_score_threshold();
+  if (options.has_label_map_path()) {
+    std::string string_path;
+    ASSIGN_OR_RETURN(string_path,
+                     PathToResourceAsFile(options.label_map_path()));
+    std::string label_map_string;
+    MP_RETURN_IF_ERROR(file::GetContents(string_path, &label_map_string));
+
+    std::istringstream stream(label_map_string);
+    std::string line;
+    int i = 0;
+    while (std::getline(stream, line)) {
+      label_map_[i++] = line;
+    }
+    label_map_loaded_ = true;
+  }
+
+  return ::mediapipe::OkStatus();
+}
+
+::mediapipe::Status TfLiteTensorsToClassificationCalculator::Process(
+    CalculatorContext* cc) {
+  const auto& input_tensors =
+      cc->Inputs().Tag("TENSORS").Get<std::vector<TfLiteTensor>>();
+
+  RET_CHECK_EQ(input_tensors.size(), 1);
+
+  const TfLiteTensor* raw_score_tensor = &input_tensors[0];
+  RET_CHECK_EQ(raw_score_tensor->dims->size, 2);
+  RET_CHECK_EQ(raw_score_tensor->dims->data[0], 1);
+  int num_classes = raw_score_tensor->dims->data[1];
+  if (label_map_loaded_) {
+    RET_CHECK_EQ(num_classes, label_map_.size());
+  }
+  const float* raw_scores = raw_score_tensor->data.f;
+
+  auto classification_list = absl::make_unique<ClassificationList>();
+  for (int i = 0; i < num_classes; ++i) {
+    if (raw_scores[i] < min_score_threshold_) {
+      continue;
+    }
+    Classification* classification = classification_list->add_classification();
+    classification->set_index(i);
+    classification->set_score(raw_scores[i]);
+    if (label_map_loaded_) {
+      classification->set_label(label_map_[i]);
+    }
+  }
+
+  // Note that partial_sort will raise error when top_k_ >
+  // classification_list->classification_size().
+  auto raw_classification_list = classification_list->mutable_classification();
+  if (top_k_ > 0 && classification_list->classification_size() >= top_k_) {
+    std::partial_sort(raw_classification_list->begin(),
+                      raw_classification_list->begin() + top_k_,
+                      raw_classification_list->end(),
+                      [](const Classification a, const Classification b) {
+                        return a.score() > b.score();
+                      });
+
+    // Resizes the underlying list to have only top_k_ classifications.
+    raw_classification_list->DeleteSubrange(
+        top_k_, raw_classification_list->size() - top_k_);
+  }
+  cc->Outputs()
+      .Tag("CLASSIFICATIONS")
+      .Add(classification_list.release(), cc->InputTimestamp());
+
+  return ::mediapipe::OkStatus();
+}
+
+::mediapipe::Status TfLiteTensorsToClassificationCalculator::Close(
+    CalculatorContext* cc) {
+  return ::mediapipe::OkStatus();
+}
+
+}  // namespace mediapipe

mediapipe/calculators/tflite/tflite_tensors_to_classification_calculator.proto

@@ -0,0 +1,35 @@
+// Copyright 2019 The MediaPipe Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// The option proto for the TfLiteTensorsToClassificationCalculator.
+
+syntax = "proto2";
+
+package mediapipe;
+
+import "mediapipe/framework/calculator.proto";
+
+message TfLiteTensorsToClassificationCalculatorOptions {
+  extend .mediapipe.CalculatorOptions {
+    optional TfLiteTensorsToClassificationCalculatorOptions ext = 266399463;
+  }
+
+  // Score threshold for perserving the class.
+  optional float min_score_threshold = 1;
+  // Number of highest scoring labels to output.  If top_k is not positive then
+  // all labels are used.
+  optional int32 top_k = 2;
+  // Path to a label map file for getting the actual name of class ids.
+  optional string label_map_path = 3;
+}

mediapipe/calculators/tflite/tflite_tensors_to_classification_calculator_test.cc

@@ -0,0 +1,194 @@
+// Copyright 2019 The MediaPipe Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <vector>
+
+#include "absl/memory/memory.h"
+#include "mediapipe/calculators/tflite/tflite_tensors_to_classification_calculator.pb.h"
+#include "mediapipe/framework/calculator.pb.h"
+#include "mediapipe/framework/calculator_framework.h"
+#include "mediapipe/framework/calculator_runner.h"
+#include "mediapipe/framework/formats/classification.pb.h"
+#include "mediapipe/framework/port/gtest.h"
+#include "mediapipe/framework/port/parse_text_proto.h"
+#include "mediapipe/framework/port/status_matchers.h"
+#include "tensorflow/lite/interpreter.h"
+
+namespace mediapipe {
+
+using ::mediapipe::ParseTextProtoOrDie;
+using ::tflite::Interpreter;
+using Node = ::mediapipe::CalculatorGraphConfig::Node;
+
+class TfLiteTensorsToClassificationCalculatorTest : public ::testing::Test {
+ protected:
+  void BuildGraph(mediapipe::CalculatorRunner* runner,
+                  const std::vector<float>& scores) {
+    interpreter_ = absl::make_unique<Interpreter>();
+
+    std::vector<int> dims(2);
+    dims[0] = 1;
+    dims[1] = scores.size();
+
+    interpreter_->AddTensors(1);
+    interpreter_->SetInputs({0});
+    interpreter_->SetTensorParametersReadWrite(0, kTfLiteFloat32, "", dims,
+                                               TfLiteQuantization());
+
+    int t = interpreter_->inputs()[0];
+    TfLiteTensor* tensor = interpreter_->tensor(t);
+    interpreter_->ResizeInputTensor(t, dims);
+    interpreter_->AllocateTensors();
+
+    float* tensor_buffer = tensor->data.f;
+    ASSERT_NE(tensor_buffer, nullptr);
+    for (int i = 0; i < scores.size(); ++i) {
+      tensor_buffer[i] = scores[i];
+    }
+
+    auto tensors = absl::make_unique<std::vector<TfLiteTensor>>();
+    tensors->emplace_back(*tensor);
+
+    int64 stream_timestamp = 0;
+    auto& input_stream_packets =
+        runner->MutableInputs()->Tag("TENSORS").packets;
+
+    input_stream_packets.push_back(
+        mediapipe::Adopt(tensors.release())
+            .At(mediapipe::Timestamp(stream_timestamp++)));
+  }
+
+  std::unique_ptr<Interpreter> interpreter_;
+};
+
+TEST_F(TfLiteTensorsToClassificationCalculatorTest, CorrectOutput) {
+  mediapipe::CalculatorRunner runner(ParseTextProtoOrDie<Node>(R"(
+    calculator: "TfLiteTensorsToClassificationCalculator"
+    input_stream: "TENSORS:tensors"
+    output_stream: "CLASSIFICATIONS:classifications"
+    options {
+      [mediapipe.TfLiteTensorsToClassificationCalculatorOptions.ext] {}
+    }
+  )"));
+
+  BuildGraph(&runner, {0, 0.5, 1});
+  MP_ASSERT_OK(runner.Run());
+
+  const auto& output_packets_ = runner.Outputs().Tag("CLASSIFICATIONS").packets;
+
+  EXPECT_EQ(1, output_packets_.size());
+
+  const auto& classification_list =
+      output_packets_[0].Get<ClassificationList>();
+  EXPECT_EQ(3, classification_list.classification_size());
+
+  // Verify that the label_id and score fields are set correctly.
+  for (int i = 0; i < classification_list.classification_size(); ++i) {
+    EXPECT_EQ(i, classification_list.classification(i).index());
+    EXPECT_EQ(i * 0.5, classification_list.classification(i).score());
+    ASSERT_FALSE(classification_list.classification(i).has_label());
+  }
+}
+
+TEST_F(TfLiteTensorsToClassificationCalculatorTest,
+       CorrectOutputWithLabelMapPath) {
+  mediapipe::CalculatorRunner runner(ParseTextProtoOrDie<Node>(R"(
+    calculator: "TfLiteTensorsToClassificationCalculator"
+    input_stream: "TENSORS:tensors"
+    output_stream: "CLASSIFICATIONS:classifications"
+    options {
+      [mediapipe.TfLiteTensorsToClassificationCalculatorOptions.ext] {
+        label_map_path: "mediapipe/calculators/tflite/testdata/labelmap.txt"
+      }
+    }
+  )"));
+
+  BuildGraph(&runner, {0, 0.5, 1});
+  MP_ASSERT_OK(runner.Run());
+
+  const auto& output_packets_ = runner.Outputs().Tag("CLASSIFICATIONS").packets;
+
+  EXPECT_EQ(1, output_packets_.size());
+
+  const auto& classification_list =
+      output_packets_[0].Get<ClassificationList>();
+  EXPECT_EQ(3, classification_list.classification_size());
+
+  // Verify that the label field is set.
+  for (int i = 0; i < classification_list.classification_size(); ++i) {
+    EXPECT_EQ(i, classification_list.classification(i).index());
+    EXPECT_EQ(i * 0.5, classification_list.classification(i).score());
+    ASSERT_TRUE(classification_list.classification(i).has_label());
+  }
+}
+
+TEST_F(TfLiteTensorsToClassificationCalculatorTest,
+       CorrectOutputWithLabelMinScoreThreshold) {
+  mediapipe::CalculatorRunner runner(ParseTextProtoOrDie<Node>(R"(
+    calculator: "TfLiteTensorsToClassificationCalculator"
+    input_stream: "TENSORS:tensors"
+    output_stream: "CLASSIFICATIONS:classifications"
+    options {
+      [mediapipe.TfLiteTensorsToClassificationCalculatorOptions.ext] {
+        min_score_threshold: 0.6
+      }
+    }
+  )"));
+
+  BuildGraph(&runner, {0, 0.5, 1});
+  MP_ASSERT_OK(runner.Run());
+
+  const auto& output_packets_ = runner.Outputs().Tag("CLASSIFICATIONS").packets;
+
+  EXPECT_EQ(1, output_packets_.size());
+
+  const auto& classification_list =
+      output_packets_[0].Get<ClassificationList>();
+
+  // Verify that the low score labels are filtered out.
+  EXPECT_EQ(1, classification_list.classification_size());
+  EXPECT_EQ(1, classification_list.classification(0).score());
+}
+
+TEST_F(TfLiteTensorsToClassificationCalculatorTest, CorrectOutputWithTopK) {
+  mediapipe::CalculatorRunner runner(ParseTextProtoOrDie<Node>(R"(
+    calculator: "TfLiteTensorsToClassificationCalculator"
+    input_stream: "TENSORS:tensors"
+    output_stream: "CLASSIFICATIONS:classifications"
+    options {
+      [mediapipe.TfLiteTensorsToClassificationCalculatorOptions.ext] {
+        top_k: 2
+      }
+    }
+  )"));
+
+  BuildGraph(&runner, {0, 0.5, 1});
+  MP_ASSERT_OK(runner.Run());
+
+  const auto& output_packets_ = runner.Outputs().Tag("CLASSIFICATIONS").packets;
+
+  EXPECT_EQ(1, output_packets_.size());
+
+  const auto& classification_list =
+      output_packets_[0].Get<ClassificationList>();
+
+  // Verify that the only top2 labels are left.
+  EXPECT_EQ(2, classification_list.classification_size());
+  for (int i = 0; i < classification_list.classification_size(); ++i) {
+    EXPECT_EQ((classification_list.classification_size() - i) * 0.5,
+              classification_list.classification(i).score());
+  }
+}
+
+}  // namespace mediapipe

mediapipe/calculators/tflite/tflite_tensors_to_detections_calculator.cc

@@ -188,7 +188,7 @@ REGISTER_CALCULATOR(TfLiteTensorsToDetectionsCalculator);
   }
 
 #if defined(__ANDROID__)
-  RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
+  MP_RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
 #endif
 
   return ::mediapipe::OkStatus();
@@ -201,15 +201,15 @@ REGISTER_CALCULATOR(TfLiteTensorsToDetectionsCalculator);
   if (cc->Inputs().HasTag("TENSORS_GPU")) {
     gpu_input_ = true;
 #if defined(__ANDROID__)
-    RETURN_IF_ERROR(gpu_helper_.Open(cc));
+    MP_RETURN_IF_ERROR(gpu_helper_.Open(cc));
 #endif
   }
 
-  RETURN_IF_ERROR(LoadOptions(cc));
+  MP_RETURN_IF_ERROR(LoadOptions(cc));
   side_packet_anchors_ = cc->InputSidePackets().HasTag("ANCHORS");
 
   if (gpu_input_) {
-    RETURN_IF_ERROR(GlSetup(cc));
+    MP_RETURN_IF_ERROR(GlSetup(cc));
   }
 
   return ::mediapipe::OkStatus();
@@ -225,9 +225,9 @@ REGISTER_CALCULATOR(TfLiteTensorsToDetectionsCalculator);
   auto output_detections = absl::make_unique<std::vector<Detection>>();
 
   if (gpu_input_) {
-    RETURN_IF_ERROR(ProcessGPU(cc, output_detections.get()));
+    MP_RETURN_IF_ERROR(ProcessGPU(cc, output_detections.get()));
   } else {
-    RETURN_IF_ERROR(ProcessCPU(cc, output_detections.get()));
+    MP_RETURN_IF_ERROR(ProcessCPU(cc, output_detections.get()));
   }  // if gpu_input_
 
   // Output
@@ -282,7 +282,7 @@ REGISTER_CALCULATOR(TfLiteTensorsToDetectionsCalculator);
       anchors_init_ = true;
     }
     std::vector<float> boxes(num_boxes_ * num_coords_);
-    RETURN_IF_ERROR(DecodeBoxes(raw_boxes, anchors_, &boxes));
+    MP_RETURN_IF_ERROR(DecodeBoxes(raw_boxes, anchors_, &boxes));
 
     std::vector<float> detection_scores(num_boxes_);
     std::vector<int> detection_classes(num_boxes_);
@@ -316,9 +316,9 @@ REGISTER_CALCULATOR(TfLiteTensorsToDetectionsCalculator);
       detection_classes[i] = class_id;
     }
 
-    RETURN_IF_ERROR(ConvertToDetections(boxes.data(), detection_scores.data(),
-                                        detection_classes.data(),
-                                        output_detections));
+    MP_RETURN_IF_ERROR(
+        ConvertToDetections(boxes.data(), detection_scores.data(),
+                            detection_classes.data(), output_detections));
   } else {
     // Postprocessing on CPU with postprocessing op (e.g. anchor decoding and
     // non-maximum suppression) within the model.
@@ -350,9 +350,9 @@ REGISTER_CALCULATOR(TfLiteTensorsToDetectionsCalculator);
       detection_classes[i] =
           static_cast<int>(detection_classes_tensor->data.f[i]);
     }
-    RETURN_IF_ERROR(ConvertToDetections(detection_boxes, detection_scores,
-                                        detection_classes.data(),
-                                        output_detections));
+    MP_RETURN_IF_ERROR(ConvertToDetections(detection_boxes, detection_scores,
+                                           detection_classes.data(),
+                                           output_detections));
   }
   return ::mediapipe::OkStatus();
 }
@@ -381,7 +381,7 @@ REGISTER_CALCULATOR(TfLiteTensorsToDetectionsCalculator);
   }
 
   // Run shaders.
-  RETURN_IF_ERROR(gpu_helper_.RunInGlContext(
+  MP_RETURN_IF_ERROR(gpu_helper_.RunInGlContext(
       [this, &input_tensors]() -> ::mediapipe::Status {
         // Decode boxes.
         decoded_boxes_buffer_->BindToIndex(0);
@@ -419,9 +419,9 @@ REGISTER_CALCULATOR(TfLiteTensorsToDetectionsCalculator);
     detection_scores[i] = score_class_id_pairs[i * 2];
     detection_classes[i] = static_cast<int>(score_class_id_pairs[i * 2 + 1]);
   }
-  RETURN_IF_ERROR(ConvertToDetections(boxes.data(), detection_scores.data(),
-                                      detection_classes.data(),
-                                      output_detections));
+  MP_RETURN_IF_ERROR(ConvertToDetections(boxes.data(), detection_scores.data(),
+                                         detection_classes.data(),
+                                         output_detections));
 #else
   LOG(ERROR) << "GPU input on non-Android not supported yet.";
 #endif  // defined(__ANDROID__)

mediapipe/calculators/tflite/tflite_tensors_to_landmarks_calculator.cc

@@ -89,7 +89,7 @@ REGISTER_CALCULATOR(TfLiteTensorsToLandmarksCalculator);
     CalculatorContext* cc) {
   cc->SetOffset(TimestampDiff(0));
 
-  RETURN_IF_ERROR(LoadOptions(cc));
+  MP_RETURN_IF_ERROR(LoadOptions(cc));
 
   if (cc->Outputs().HasTag("NORM_LANDMARKS")) {
     RET_CHECK(options_.has_input_image_height() &&

mediapipe/calculators/tflite/tflite_tensors_to_segmentation_calculator.cc

@@ -177,7 +177,7 @@ REGISTER_CALCULATOR(TfLiteTensorsToSegmentationCalculator);
 #endif  // __ANDROID__
 
 #if defined(__ANDROID__)
-  RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
+  MP_RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
 #endif  // __ANDROID__
 
   return ::mediapipe::OkStatus();
@@ -190,17 +190,17 @@ REGISTER_CALCULATOR(TfLiteTensorsToSegmentationCalculator);
   if (cc->Inputs().HasTag("TENSORS_GPU")) {
     use_gpu_ = true;
 #if defined(__ANDROID__)
-    RETURN_IF_ERROR(gpu_helper_.Open(cc));
+    MP_RETURN_IF_ERROR(gpu_helper_.Open(cc));
 #endif  // __ANDROID__
   }
 
-  RETURN_IF_ERROR(LoadOptions(cc));
+  MP_RETURN_IF_ERROR(LoadOptions(cc));
 
   if (use_gpu_) {
 #if defined(__ANDROID__)
-    RETURN_IF_ERROR(
+    MP_RETURN_IF_ERROR(
         gpu_helper_.RunInGlContext([this, cc]() -> ::mediapipe::Status {
-          RETURN_IF_ERROR(InitGpu(cc));
+          MP_RETURN_IF_ERROR(InitGpu(cc));
           return ::mediapipe::OkStatus();
         }));
 #else
@@ -216,14 +216,14 @@ REGISTER_CALCULATOR(TfLiteTensorsToSegmentationCalculator);
     CalculatorContext* cc) {
   if (use_gpu_) {
 #if defined(__ANDROID__)
-    RETURN_IF_ERROR(
+    MP_RETURN_IF_ERROR(
         gpu_helper_.RunInGlContext([this, cc]() -> ::mediapipe::Status {
-          RETURN_IF_ERROR(ProcessGpu(cc));
+          MP_RETURN_IF_ERROR(ProcessGpu(cc));
           return ::mediapipe::OkStatus();
         }));
 #endif  // __ANDROID__
   } else {
-    RETURN_IF_ERROR(ProcessCpu(cc));
+    MP_RETURN_IF_ERROR(ProcessCpu(cc));
   }
 
   return ::mediapipe::OkStatus();

mediapipe/calculators/util/BUILD

@@ -79,7 +79,7 @@ mediapipe_cc_proto_library(
         "//mediapipe/framework:calculator_cc_proto",
         "//mediapipe/util:color_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":annotation_overlay_calculator_proto"],
 )
 
@@ -89,7 +89,7 @@ mediapipe_cc_proto_library(
     cc_deps = [
         "//mediapipe/framework:calculator_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [
         ":detection_label_id_to_text_calculator_proto",
     ],
@@ -106,7 +106,7 @@ mediapipe_cc_proto_library(
     name = "non_max_suppression_calculator_cc_proto",
     srcs = ["non_max_suppression_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":non_max_suppression_calculator_proto"],
 )
 
@@ -303,7 +303,7 @@ mediapipe_cc_proto_library(
     cc_deps = [
         "//mediapipe/framework:calculator_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":thresholding_calculator_proto"],
 )
 
@@ -326,7 +326,7 @@ mediapipe_cc_proto_library(
     cc_deps = [
         "//mediapipe/framework:calculator_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":landmarks_to_detection_calculator_proto"],
 )
 
@@ -352,7 +352,7 @@ mediapipe_cc_proto_library(
     cc_deps = [
         "//mediapipe/framework:calculator_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":detections_to_rects_calculator_proto"],
 )
 
@@ -362,7 +362,7 @@ mediapipe_cc_proto_library(
     cc_deps = [
         "//mediapipe/framework:calculator_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":landmark_projection_calculator_proto"],
 )
 
@@ -372,7 +372,7 @@ mediapipe_cc_proto_library(
     cc_deps = [
         "//mediapipe/framework:calculator_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":rect_transformation_calculator_proto"],
 )
 
@@ -517,7 +517,7 @@ mediapipe_cc_proto_library(
         "//mediapipe/util:color_cc_proto",
         "//mediapipe/util:render_data_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":rect_to_render_data_calculator_proto"],
 )
 
@@ -529,7 +529,7 @@ mediapipe_cc_proto_library(
         "//mediapipe/util:color_cc_proto",
         "//mediapipe/util:render_data_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":detections_to_render_data_calculator_proto"],
 )
 
@@ -560,7 +560,7 @@ mediapipe_cc_proto_library(
         "//mediapipe/util:color_cc_proto",
         "//mediapipe/util:render_data_cc_proto",
     ],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":landmarks_to_render_data_calculator_proto"],
 )
 

mediapipe/calculators/util/annotation_overlay_calculator.cc

@@ -200,7 +200,7 @@ REGISTER_CALCULATOR(AnnotationOverlayCalculator);
   }
 
 #if defined(__ANDROID__) || (defined(__APPLE__) && !TARGET_OS_OSX)
-  RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
+  MP_RETURN_IF_ERROR(mediapipe::GlCalculatorHelper::UpdateContract(cc));
 #endif  // __ANDROID__ or iOS
 
   return ::mediapipe::OkStatus();
@@ -247,7 +247,7 @@ REGISTER_CALCULATOR(AnnotationOverlayCalculator);
 
   if (use_gpu_) {
 #if defined(__ANDROID__) || (defined(__APPLE__) && !TARGET_OS_OSX)
-    RETURN_IF_ERROR(gpu_helper_.Open(cc));
+    MP_RETURN_IF_ERROR(gpu_helper_.Open(cc));
 #endif  // __ANDROID__ or iOS
   }
 
@@ -262,17 +262,17 @@ REGISTER_CALCULATOR(AnnotationOverlayCalculator);
   if (use_gpu_) {
 #if defined(__ANDROID__) || (defined(__APPLE__) && !TARGET_OS_OSX)
     if (!gpu_initialized_) {
-      RETURN_IF_ERROR(
+      MP_RETURN_IF_ERROR(
           gpu_helper_.RunInGlContext([this, cc]() -> ::mediapipe::Status {
-            RETURN_IF_ERROR(GlSetup(cc));
+            MP_RETURN_IF_ERROR(GlSetup(cc));
             return ::mediapipe::OkStatus();
           }));
       gpu_initialized_ = true;
     }
 #endif  // __ANDROID__ or iOS
-    RETURN_IF_ERROR(CreateRenderTargetGpu(cc, image_mat));
+    MP_RETURN_IF_ERROR(CreateRenderTargetGpu(cc, image_mat));
   } else {
-    RETURN_IF_ERROR(CreateRenderTargetCpu(cc, image_mat, &target_format));
+    MP_RETURN_IF_ERROR(CreateRenderTargetCpu(cc, image_mat, &target_format));
   }
 
   // Reset the renderer with the image_mat. No copy here.
@@ -291,16 +291,16 @@ REGISTER_CALCULATOR(AnnotationOverlayCalculator);
 #if defined(__ANDROID__) || (defined(__APPLE__) && !TARGET_OS_OSX)
     // Overlay rendered image in OpenGL, onto a copy of input.
     uchar* image_mat_ptr = image_mat->data;
-    RETURN_IF_ERROR(gpu_helper_.RunInGlContext(
+    MP_RETURN_IF_ERROR(gpu_helper_.RunInGlContext(
         [this, cc, image_mat_ptr]() -> ::mediapipe::Status {
-          RETURN_IF_ERROR(RenderToGpu(cc, image_mat_ptr));
+          MP_RETURN_IF_ERROR(RenderToGpu(cc, image_mat_ptr));
           return ::mediapipe::OkStatus();
         }));
 #endif  // __ANDROID__ or iOS
   } else {
     // Copy the rendered image to output.
     uchar* image_mat_ptr = image_mat->data;
-    RETURN_IF_ERROR(RenderToCpu(cc, target_format, image_mat_ptr));
+    MP_RETURN_IF_ERROR(RenderToCpu(cc, target_format, image_mat_ptr));
   }
 
   return ::mediapipe::OkStatus();
@@ -372,7 +372,7 @@ REGISTER_CALCULATOR(AnnotationOverlayCalculator);
     glActiveTexture(GL_TEXTURE2);
     glBindTexture(GL_TEXTURE_2D, image_mat_tex_);
 
-    RETURN_IF_ERROR(GlRender(cc));
+    MP_RETURN_IF_ERROR(GlRender(cc));
 
     glActiveTexture(GL_TEXTURE2);
     glBindTexture(GL_TEXTURE_2D, 0);

mediapipe/calculators/util/detection_label_id_to_text_calculator.cc

@@ -75,7 +75,7 @@ REGISTER_CALCULATOR(DetectionLabelIdToTextCalculator);
   std::string string_path;
   ASSIGN_OR_RETURN(string_path, PathToResourceAsFile(options.label_map_path()));
   std::string label_map_string;
-  RETURN_IF_ERROR(file::GetContents(string_path, &label_map_string));
+  MP_RETURN_IF_ERROR(file::GetContents(string_path, &label_map_string));
 
   std::istringstream stream(label_map_string);
   std::string line;

mediapipe/calculators/util/detection_letterbox_removal_calculator_test.cc

@@ -86,7 +86,7 @@ TEST(DetectionLetterboxRemovalCalculatorTest, PaddingLeftRight) {
       ->Tag("LETTERBOX_PADDING")
       .packets.push_back(Adopt(padding.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output =
       runner.Outputs().Tag("DETECTIONS").packets;
   ASSERT_EQ(1, output.size());
@@ -134,7 +134,7 @@ TEST(DetectionLetterboxRemovalCalculatorTest, PaddingTopBottom) {
       ->Tag("LETTERBOX_PADDING")
       .packets.push_back(Adopt(padding.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output =
       runner.Outputs().Tag("DETECTIONS").packets;
   ASSERT_EQ(1, output.size());

mediapipe/calculators/util/detections_to_rects_calculator.cc

@@ -245,7 +245,7 @@ REGISTER_CALCULATOR(DetectionsToRectsCalculator);
 
   if (cc->Outputs().HasTag(kRectTag)) {
     auto output_rect = absl::make_unique<Rect>();
-    RETURN_IF_ERROR(DetectionToRect(detections[0], output_rect.get()));
+    MP_RETURN_IF_ERROR(DetectionToRect(detections[0], output_rect.get()));
     if (rotate_) {
       output_rect->set_rotation(ComputeRotation(detections[0], image_size));
     }
@@ -254,7 +254,7 @@ REGISTER_CALCULATOR(DetectionsToRectsCalculator);
   }
   if (cc->Outputs().HasTag(kNormRectTag)) {
     auto output_rect = absl::make_unique<NormalizedRect>();
-    RETURN_IF_ERROR(
+    MP_RETURN_IF_ERROR(
         DetectionToNormalizedRect(detections[0], output_rect.get()));
     if (rotate_) {
       output_rect->set_rotation(ComputeRotation(detections[0], image_size));
@@ -266,7 +266,8 @@ REGISTER_CALCULATOR(DetectionsToRectsCalculator);
   if (cc->Outputs().HasTag(kRectsTag)) {
     auto output_rects = absl::make_unique<std::vector<Rect>>(detections.size());
     for (int i = 0; i < detections.size(); ++i) {
-      RETURN_IF_ERROR(DetectionToRect(detections[i], &(output_rects->at(i))));
+      MP_RETURN_IF_ERROR(
+          DetectionToRect(detections[i], &(output_rects->at(i))));
       if (rotate_) {
         output_rects->at(i).set_rotation(
             ComputeRotation(detections[i], image_size));
@@ -279,7 +280,7 @@ REGISTER_CALCULATOR(DetectionsToRectsCalculator);
     auto output_rects =
         absl::make_unique<std::vector<NormalizedRect>>(detections.size());
     for (int i = 0; i < detections.size(); ++i) {
-      RETURN_IF_ERROR(
+      MP_RETURN_IF_ERROR(
           DetectionToNormalizedRect(detections[i], &(output_rects->at(i))));
       if (rotate_) {
         output_rects->at(i).set_rotation(

mediapipe/calculators/util/detections_to_rects_calculator_test.cc

@@ -66,7 +66,7 @@ TEST(DetectionsToRectsCalculatorTest, DetectionToRect) {
       .packets.push_back(
           Adopt(detection.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output = runner.Outputs().Tag("RECT").packets;
   ASSERT_EQ(1, output.size());
   const auto& rect = output[0].Get<Rect>();
@@ -91,7 +91,7 @@ TEST(DetectionsToRectsCalculatorTest, DetectionToNormalizedRect) {
       .packets.push_back(
           Adopt(detection.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output = runner.Outputs().Tag("NORM_RECT").packets;
   ASSERT_EQ(1, output.size());
   const auto& rect = output[0].Get<NormalizedRect>();
@@ -117,7 +117,7 @@ TEST(DetectionsToRectsCalculatorTest, DetectionsToRect) {
       .packets.push_back(
           Adopt(detections.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output = runner.Outputs().Tag("RECT").packets;
   ASSERT_EQ(1, output.size());
   const auto& rect = output[0].Get<Rect>();
@@ -143,7 +143,7 @@ TEST(DetectionsToRectsCalculatorTest, DetectionsToNormalizedRect) {
       .packets.push_back(
           Adopt(detections.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output = runner.Outputs().Tag("NORM_RECT").packets;
   ASSERT_EQ(1, output.size());
   const auto& rect = output[0].Get<NormalizedRect>();
@@ -169,7 +169,7 @@ TEST(DetectionsToRectsCalculatorTest, DetectionsToRects) {
       .packets.push_back(
           Adopt(detections.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output = runner.Outputs().Tag("RECTS").packets;
   ASSERT_EQ(1, output.size());
   const auto& rects = output[0].Get<std::vector<Rect>>();
@@ -200,7 +200,7 @@ TEST(DetectionsToRectsCalculatorTest, DetectionsToNormalizedRects) {
       .packets.push_back(
           Adopt(detections.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output =
       runner.Outputs().Tag("NORM_RECTS").packets;
   ASSERT_EQ(1, output.size());
@@ -231,7 +231,7 @@ TEST(DetectionsToRectsCalculatorTest, DetectionToRects) {
       .packets.push_back(
           Adopt(detection.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output = runner.Outputs().Tag("RECTS").packets;
   ASSERT_EQ(1, output.size());
   const auto& rects = output[0].Get<std::vector<Rect>>();
@@ -257,7 +257,7 @@ TEST(DetectionsToRectsCalculatorTest, DetectionToNormalizedRects) {
       .packets.push_back(
           Adopt(detection.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output =
       runner.Outputs().Tag("NORM_RECTS").packets;
   ASSERT_EQ(1, output.size());

mediapipe/calculators/util/detections_to_render_data_calculator_test.cc

@@ -101,7 +101,7 @@ TEST(DetectionsToRenderDataCalculatorTest, OnlyDetecctionList) {
       .packets.push_back(
           Adopt(detections.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output =
       runner.Outputs().Tag("RENDER_DATA").packets;
   ASSERT_EQ(1, output.size());
@@ -135,7 +135,7 @@ TEST(DetectionsToRenderDataCalculatorTest, OnlyDetecctionVector) {
       .packets.push_back(
           Adopt(detections.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output =
       runner.Outputs().Tag("RENDER_DATA").packets;
   ASSERT_EQ(1, output.size());
@@ -178,7 +178,7 @@ TEST(DetectionsToRenderDataCalculatorTest, BothDetecctionListAndVector) {
       .packets.push_back(
           Adopt(detections.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& actual =
       runner.Outputs().Tag("RENDER_DATA").packets;
   ASSERT_EQ(1, actual.size());
@@ -218,7 +218,7 @@ TEST(DetectionsToRenderDataCalculatorTest, ProduceEmptyPacket) {
       .packets.push_back(
           Adopt(detections1.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner1.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner1.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& exact1 =
       runner1.Outputs().Tag("RENDER_DATA").packets;
   ASSERT_EQ(0, exact1.size());
@@ -248,7 +248,7 @@ TEST(DetectionsToRenderDataCalculatorTest, ProduceEmptyPacket) {
       .packets.push_back(
           Adopt(detections2.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner2.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner2.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& exact2 =
       runner2.Outputs().Tag("RENDER_DATA").packets;
   ASSERT_EQ(1, exact2.size());

mediapipe/calculators/util/landmark_letterbox_removal_calculator_test.cc

@@ -58,7 +58,7 @@ TEST(LandmarkLetterboxRemovalCalculatorTest, PaddingLeftRight) {
       ->Tag("LETTERBOX_PADDING")
       .packets.push_back(Adopt(padding.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output = runner.Outputs().Tag("LANDMARKS").packets;
   ASSERT_EQ(1, output.size());
   const auto& output_landmarks =
@@ -92,7 +92,7 @@ TEST(LandmarkLetterboxRemovalCalculatorTest, PaddingTopBottom) {
       ->Tag("LETTERBOX_PADDING")
       .packets.push_back(Adopt(padding.release()).At(Timestamp::PostStream()));
 
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output = runner.Outputs().Tag("LANDMARKS").packets;
   ASSERT_EQ(1, output.size());
   const auto& output_landmarks =

mediapipe/calculators/util/packet_frequency_calculator_test.cc

@@ -87,7 +87,7 @@ TEST(PacketFrequencyCalculatorTest, MultiPacketTest) {
       Adopt(new int).At(Timestamp(9000000)));
 
   // Run the calculator.
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output_packets = runner.Outputs().Index(0).packets;
 
   // Very first packet. So frequency is zero.
@@ -153,7 +153,7 @@ TEST(PacketFrequencyCalculatorTest, MultiStreamTest) {
       Adopt(new std::string).At(Timestamp(3000000)));
 
   // Run the calculator.
-  MEDIAPIPE_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
+  MP_ASSERT_OK(runner.Run()) << "Calculator execution failed.";
   const std::vector<Packet>& output_packets_stream_1 =
       runner.Outputs().Index(0).packets;
   const std::vector<Packet>& output_packets_stream_2 =

mediapipe/calculators/util/packet_latency_calculator_test.cc

@@ -34,7 +34,7 @@ class PacketLatencyCalculatorTest : public ::testing::Test {
   void SetupSimulationClock() {
     auto executor = std::make_shared<SimulationClockExecutor>(4);
     simulation_clock_ = executor->GetClock();
-    MEDIAPIPE_ASSERT_OK(graph_.SetExecutor("", executor));
+    MP_ASSERT_OK(graph_.SetExecutor("", executor));
   }
 
   void InitializeSingleStreamGraph() {
@@ -72,10 +72,10 @@ class PacketLatencyCalculatorTest : public ::testing::Test {
             simulation_clock_);
 
     // Start graph run.
-    MEDIAPIPE_ASSERT_OK(graph_.Initialize(graph_config_, {}));
-    MEDIAPIPE_ASSERT_OK(graph_.StartRun(side_packet));
+    MP_ASSERT_OK(graph_.Initialize(graph_config_, {}));
+    MP_ASSERT_OK(graph_.StartRun(side_packet));
     // Let Calculator::Open() calls finish before continuing.
-    MEDIAPIPE_ASSERT_OK(graph_.WaitUntilIdle());
+    MP_ASSERT_OK(graph_.WaitUntilIdle());
   }
 
   void InitializeMultipleStreamGraph() {
@@ -115,7 +115,7 @@ class PacketLatencyCalculatorTest : public ::testing::Test {
                                    &out_1_packets_);
     mediapipe::tool::AddVectorSink("packet_latency_2", &graph_config_,
                                    &out_2_packets_);
-    MEDIAPIPE_ASSERT_OK(graph_.Initialize(graph_config_, {}));
+    MP_ASSERT_OK(graph_.Initialize(graph_config_, {}));
 
     // Create the simulation clock side packet.
     simulation_clock_.reset(new SimulationClock());
@@ -125,9 +125,9 @@ class PacketLatencyCalculatorTest : public ::testing::Test {
             simulation_clock_);
 
     // Start graph run.
-    MEDIAPIPE_ASSERT_OK(graph_.StartRun(side_packet));
+    MP_ASSERT_OK(graph_.StartRun(side_packet));
     // Let Calculator::Open() calls finish before continuing.
-    MEDIAPIPE_ASSERT_OK(graph_.WaitUntilIdle());
+    MP_ASSERT_OK(graph_.WaitUntilIdle());
   }
 
   void InitializeSingleStreamGraphWithoutClock() {
@@ -163,10 +163,10 @@ class PacketLatencyCalculatorTest : public ::testing::Test {
             simulation_clock_);
 
     // Start graph run.
-    MEDIAPIPE_ASSERT_OK(graph_.Initialize(graph_config_, {}));
-    MEDIAPIPE_ASSERT_OK(graph_.StartRun(side_packet));
+    MP_ASSERT_OK(graph_.Initialize(graph_config_, {}));
+    MP_ASSERT_OK(graph_.StartRun(side_packet));
     // Let Calculator::Open() calls finish before continuing.
-    MEDIAPIPE_ASSERT_OK(graph_.WaitUntilIdle());
+    MP_ASSERT_OK(graph_.WaitUntilIdle());
   }
 
   PacketLatency CreatePacketLatency(const double latency_usec,
@@ -205,16 +205,16 @@ TEST_F(PacketLatencyCalculatorTest, DoesNotOutputUntilInputPacketReceived) {
   dynamic_cast<SimulationClock*>(&*simulation_clock_)->ThreadStart();
 
   // Send reference packets with timestamps 0, 6 and 10 usec.
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "camera_frames", Adopt(new double()).At(Timestamp(0))));
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "camera_frames", Adopt(new double()).At(Timestamp(6))));
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "camera_frames", Adopt(new double()).At(Timestamp(10))));
 
   dynamic_cast<SimulationClock*>(&*simulation_clock_)->ThreadFinish();
-  MEDIAPIPE_ASSERT_OK(graph_.CloseAllInputStreams());
-  MEDIAPIPE_ASSERT_OK(graph_.WaitUntilDone());
+  MP_ASSERT_OK(graph_.CloseAllInputStreams());
+  MP_ASSERT_OK(graph_.WaitUntilDone());
 
   // Expect zero output packets.
   ASSERT_EQ(out_0_packets_.size(), 0);
@@ -228,20 +228,20 @@ TEST_F(PacketLatencyCalculatorTest, OutputsCorrectLatencyForSingleStream) {
 
   // Send a reference packet with timestamp 10 usec at time 12 usec.
   simulation_clock_->Sleep(absl::Microseconds(12));
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "camera_frames", Adopt(new double()).At(Timestamp(10))));
 
   // Add two delayed packets with timestamp 1 and 8 resp.
   simulation_clock_->Sleep(absl::Microseconds(1));
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "delayed_packet_0", Adopt(new double()).At(Timestamp(1))));
   simulation_clock_->Sleep(absl::Microseconds(1));
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "delayed_packet_0", Adopt(new double()).At(Timestamp(8))));
 
   dynamic_cast<SimulationClock*>(&*simulation_clock_)->ThreadFinish();
-  MEDIAPIPE_ASSERT_OK(graph_.CloseAllInputStreams());
-  MEDIAPIPE_ASSERT_OK(graph_.WaitUntilDone());
+  MP_ASSERT_OK(graph_.CloseAllInputStreams());
+  MP_ASSERT_OK(graph_.WaitUntilDone());
 
   // Expect two latency packets with timestamp 1 and 8 resp.
   ASSERT_EQ(out_0_packets_.size(), 2);
@@ -270,26 +270,26 @@ TEST_F(PacketLatencyCalculatorTest, DoesNotOutputUntilReferencePacketReceived) {
   dynamic_cast<SimulationClock*>(&*simulation_clock_)->ThreadStart();
 
   // Add two packets with timestamp 1 and 2.
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "delayed_packet_0", Adopt(new double()).At(Timestamp(1))));
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "delayed_packet_0", Adopt(new double()).At(Timestamp(2))));
 
   // Send a reference packet with timestamp 10 usec.
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "camera_frames", Adopt(new double()).At(Timestamp(10))));
   simulation_clock_->Sleep(absl::Microseconds(1));
 
   // Add two delayed packets with timestamp 7 and 9 resp.
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "delayed_packet_0", Adopt(new double()).At(Timestamp(7))));
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "delayed_packet_0", Adopt(new double()).At(Timestamp(9))));
   simulation_clock_->Sleep(absl::Microseconds(1));
 
   dynamic_cast<SimulationClock*>(&*simulation_clock_)->ThreadFinish();
-  MEDIAPIPE_ASSERT_OK(graph_.CloseAllInputStreams());
-  MEDIAPIPE_ASSERT_OK(graph_.WaitUntilDone());
+  MP_ASSERT_OK(graph_.CloseAllInputStreams());
+  MP_ASSERT_OK(graph_.WaitUntilDone());
 
   // Expect two latency packets with timestamp 7 and 9 resp. The packets with
   // timestamps 1 and 2 should not have any latency associated with them since
@@ -320,18 +320,18 @@ TEST_F(PacketLatencyCalculatorTest, OutputsCorrectLatencyWhenNoClock) {
   dynamic_cast<SimulationClock*>(&*simulation_clock_)->ThreadStart();
 
   // Send a reference packet with timestamp 10 usec.
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "camera_frames", Adopt(new double()).At(Timestamp(10))));
 
   // Add two delayed packets with timestamp 5 and 10 resp.
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "delayed_packet_0", Adopt(new double()).At(Timestamp(5))));
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "delayed_packet_0", Adopt(new double()).At(Timestamp(10))));
 
   dynamic_cast<SimulationClock*>(&*simulation_clock_)->ThreadFinish();
-  MEDIAPIPE_ASSERT_OK(graph_.CloseAllInputStreams());
-  MEDIAPIPE_ASSERT_OK(graph_.WaitUntilDone());
+  MP_ASSERT_OK(graph_.CloseAllInputStreams());
+  MP_ASSERT_OK(graph_.WaitUntilDone());
 
   // Expect two latency packets with timestamp 5 and 10 resp.
   ASSERT_EQ(out_0_packets_.size(), 2);
@@ -347,18 +347,18 @@ TEST_F(PacketLatencyCalculatorTest,
   dynamic_cast<SimulationClock*>(&*simulation_clock_)->ThreadStart();
 
   // Send a reference packet with timestamp 20 usec.
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "camera_frames", Adopt(new double()).At(Timestamp(20))));
 
   // Add two delayed packets with timestamp 0 and 20 resp.
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "delayed_packet_0", Adopt(new double()).At(Timestamp(0))));
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "delayed_packet_0", Adopt(new double()).At(Timestamp(20))));
 
   dynamic_cast<SimulationClock*>(&*simulation_clock_)->ThreadFinish();
-  MEDIAPIPE_ASSERT_OK(graph_.CloseAllInputStreams());
-  MEDIAPIPE_ASSERT_OK(graph_.WaitUntilDone());
+  MP_ASSERT_OK(graph_.CloseAllInputStreams());
+  MP_ASSERT_OK(graph_.WaitUntilDone());
 
   // Expect two latency packets with timestamp 0 and 20 resp.
   ASSERT_EQ(out_0_packets_.size(), 2);
@@ -387,24 +387,24 @@ TEST_F(PacketLatencyCalculatorTest, ResetsHistogramAndAverageCorrectly) {
   dynamic_cast<SimulationClock*>(&*simulation_clock_)->ThreadStart();
 
   // Send a reference packet with timestamp 0 usec.
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "camera_frames", Adopt(new double()).At(Timestamp(0))));
 
   // Add a delayed packet with timestamp 0 usec at time 20 usec.
   simulation_clock_->Sleep(absl::Microseconds(20));
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "delayed_packet_0", Adopt(new double()).At(Timestamp(0))));
 
   // Do a long sleep so that histogram and average are reset.
   simulation_clock_->Sleep(absl::Microseconds(100));
 
   // Add a delayed packet with timestamp 115 usec at time 120 usec.
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "delayed_packet_0", Adopt(new double()).At(Timestamp(115))));
 
   dynamic_cast<SimulationClock*>(&*simulation_clock_)->ThreadFinish();
-  MEDIAPIPE_ASSERT_OK(graph_.CloseAllInputStreams());
-  MEDIAPIPE_ASSERT_OK(graph_.WaitUntilDone());
+  MP_ASSERT_OK(graph_.CloseAllInputStreams());
+  MP_ASSERT_OK(graph_.WaitUntilDone());
 
   // Expect two latency packets with timestamp 0 and 115 resp.
   ASSERT_EQ(out_0_packets_.size(), 2);
@@ -435,26 +435,26 @@ TEST_F(PacketLatencyCalculatorTest, OutputsCorrectLatencyForMultipleStreams) {
   dynamic_cast<SimulationClock*>(&*simulation_clock_)->ThreadStart();
 
   // Send a reference packet with timestamp 10 usec.
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "camera_frames", Adopt(new double()).At(Timestamp(10))));
 
   // Add delayed packets on each input stream.
 
   // Fastest stream.
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "delayed_packet_0", Adopt(new double()).At(Timestamp(10))));
 
   // Slow stream.
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "delayed_packet_1", Adopt(new double()).At(Timestamp(5))));
 
   // Slowest stream.
-  MEDIAPIPE_ASSERT_OK(graph_.AddPacketToInputStream(
+  MP_ASSERT_OK(graph_.AddPacketToInputStream(
       "delayed_packet_2", Adopt(new double()).At(Timestamp(0))));
 
   dynamic_cast<SimulationClock*>(&*simulation_clock_)->ThreadFinish();
-  MEDIAPIPE_ASSERT_OK(graph_.CloseAllInputStreams());
-  MEDIAPIPE_ASSERT_OK(graph_.WaitUntilDone());
+  MP_ASSERT_OK(graph_.CloseAllInputStreams());
+  MP_ASSERT_OK(graph_.WaitUntilDone());
 
   // Expect one latency packet on each output stream.
   ASSERT_EQ(out_0_packets_.size(), 1);

mediapipe/calculators/video/BUILD

@@ -37,7 +37,7 @@ mediapipe_cc_proto_library(
     name = "flow_to_image_calculator_cc_proto",
     srcs = ["flow_to_image_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":flow_to_image_calculator_proto"],
 )
 
@@ -45,7 +45,7 @@ mediapipe_cc_proto_library(
     name = "opencv_video_encoder_calculator_cc_proto",
     srcs = ["opencv_video_encoder_calculator.proto"],
     cc_deps = ["//mediapipe/framework:calculator_cc_proto"],
-    visibility = ["//mediapipe:__subpackages__"],
+    visibility = ["//visibility:public"],
     deps = [":opencv_video_encoder_calculator_proto"],
 )
 

mediapipe/calculators/video/opencv_video_decoder_calculator.cc

@@ -154,8 +154,14 @@ class OpenCvVideoDecoderCalculator : public CalculatorBase {
                      cv::COLOR_BGRA2RGBA);
       }
     }
-    cc->Outputs().Tag("VIDEO").Add(image_frame.release(), timestamp);
-    decoded_frames_++;
+    // If the timestamp of the current frame is not greater than the one of the
+    // previous frame, the new frame will be discarded.
+    if (prev_timestamp_ < timestamp) {
+      cc->Outputs().Tag("VIDEO").Add(image_frame.release(), timestamp);
+      prev_timestamp_ = timestamp;
+      decoded_frames_++;
+    }
+
     return ::mediapipe::OkStatus();
   }
 
@@ -178,6 +184,7 @@ class OpenCvVideoDecoderCalculator : public CalculatorBase {
   int frame_count_;
   int decoded_frames_ = 0;
   ImageFormat::Format format_;
+  Timestamp prev_timestamp_ = Timestamp::Unset();
 };
 
 REGISTER_CALCULATOR(OpenCvVideoDecoderCalculator);

mediapipe/calculators/video/opencv_video_decoder_calculator_test.cc

@@ -41,13 +41,13 @@ TEST(OpenCvVideoDecoderCalculatorTest, TestMp4Avc720pVideo) {
       file::JoinPath("./",
                      "/mediapipe/calculators/video/"
                      "testdata/format_MP4_AVC720P_AAC.video"));
-  MEDIAPIPE_EXPECT_OK(runner.Run());
+  MP_EXPECT_OK(runner.Run());
 
   EXPECT_EQ(runner.Outputs().Tag("VIDEO_PRESTREAM").packets.size(), 1);
-  MEDIAPIPE_EXPECT_OK(runner.Outputs()
-                          .Tag("VIDEO_PRESTREAM")
-                          .packets[0]
-                          .ValidateAsType<VideoHeader>());
+  MP_EXPECT_OK(runner.Outputs()
+                   .Tag("VIDEO_PRESTREAM")
+                   .packets[0]
+                   .ValidateAsType<VideoHeader>());
   const mediapipe::VideoHeader& header =
       runner.Outputs().Tag("VIDEO_PRESTREAM").packets[0].Get<VideoHeader>();
   EXPECT_EQ(ImageFormat::SRGB, header.format);
@@ -83,13 +83,13 @@ TEST(OpenCvVideoDecoderCalculatorTest, TestFlvH264Video) {
       file::JoinPath("./",
                      "/mediapipe/calculators/video/"
                      "testdata/format_FLV_H264_AAC.video"));
-  MEDIAPIPE_EXPECT_OK(runner.Run());
+  MP_EXPECT_OK(runner.Run());
 
   EXPECT_EQ(runner.Outputs().Tag("VIDEO_PRESTREAM").packets.size(), 1);
-  MEDIAPIPE_EXPECT_OK(runner.Outputs()
-                          .Tag("VIDEO_PRESTREAM")
-                          .packets[0]
-                          .ValidateAsType<VideoHeader>());
+  MP_EXPECT_OK(runner.Outputs()
+                   .Tag("VIDEO_PRESTREAM")
+                   .packets[0]
+                   .ValidateAsType<VideoHeader>());
   const mediapipe::VideoHeader& header =
       runner.Outputs().Tag("VIDEO_PRESTREAM").packets[0].Get<VideoHeader>();
   EXPECT_EQ(ImageFormat::SRGB, header.format);
@@ -127,13 +127,13 @@ TEST(OpenCvVideoDecoderCalculatorTest, TestMkvVp8Video) {
       file::JoinPath("./",
                      "/mediapipe/calculators/video/"
                      "testdata/format_MKV_VP8_VORBIS.video"));
-  MEDIAPIPE_EXPECT_OK(runner.Run());
+  MP_EXPECT_OK(runner.Run());
 
   EXPECT_EQ(runner.Outputs().Tag("VIDEO_PRESTREAM").packets.size(), 1);
-  MEDIAPIPE_EXPECT_OK(runner.Outputs()
-                          .Tag("VIDEO_PRESTREAM")
-                          .packets[0]
-                          .ValidateAsType<VideoHeader>());
+  MP_EXPECT_OK(runner.Outputs()
+                   .Tag("VIDEO_PRESTREAM")
+                   .packets[0]
+                   .ValidateAsType<VideoHeader>());
   const mediapipe::VideoHeader& header =
       runner.Outputs().Tag("VIDEO_PRESTREAM").packets[0].Get<VideoHeader>();
   EXPECT_EQ(ImageFormat::SRGB, header.format);

mediapipe/calculators/video/opencv_video_encoder_calculator_test.cc

@@ -66,17 +66,17 @@ TEST(OpenCvVideoEncoderCalculatorTest, DISABLED_TestMp4Avc720pVideo) {
   input_side_packets["output_file_path"] =
       MakePacket<std::string>(output_file_path);
   CalculatorGraph graph;
-  MEDIAPIPE_ASSERT_OK(graph.Initialize(config, input_side_packets));
+  MP_ASSERT_OK(graph.Initialize(config, input_side_packets));
   StatusOrPoller status_or_poller =
       graph.AddOutputStreamPoller("video_prestream");
   ASSERT_TRUE(status_or_poller.ok());
   OutputStreamPoller poller = std::move(status_or_poller.ValueOrDie());
 
-  MEDIAPIPE_ASSERT_OK(graph.StartRun({}));
+  MP_ASSERT_OK(graph.StartRun({}));
   Packet packet;
   while (poller.Next(&packet)) {
   }
-  MEDIAPIPE_ASSERT_OK(graph.WaitUntilDone());
+  MP_ASSERT_OK(graph.WaitUntilDone());
   const VideoHeader& video_header = packet.Get<VideoHeader>();
 
   // Checks the generated video file has the same width, height, fps, and
@@ -125,17 +125,17 @@ TEST(OpenCvVideoEncoderCalculatorTest, TestFlvH264Video) {
   input_side_packets["output_file_path"] =
       MakePacket<std::string>(output_file_path);
   CalculatorGraph graph;
-  MEDIAPIPE_ASSERT_OK(graph.Initialize(config, input_side_packets));
+  MP_ASSERT_OK(graph.Initialize(config, input_side_packets));
   StatusOrPoller status_or_poller =
       graph.AddOutputStreamPoller("video_prestream");
   ASSERT_TRUE(status_or_poller.ok());
   OutputStreamPoller poller = std::move(status_or_poller.ValueOrDie());
 
-  MEDIAPIPE_ASSERT_OK(graph.StartRun({}));
+  MP_ASSERT_OK(graph.StartRun({}));
   Packet packet;
   while (poller.Next(&packet)) {
   }
-  MEDIAPIPE_ASSERT_OK(graph.WaitUntilDone());
+  MP_ASSERT_OK(graph.WaitUntilDone());
   const VideoHeader& video_header = packet.Get<VideoHeader>();
 
   // Checks the generated video file has the same width, height, fps, and
@@ -186,17 +186,17 @@ TEST(OpenCvVideoEncoderCalculatorTest, TestMkvVp8Video) {
   input_side_packets["output_file_path"] =
       MakePacket<std::string>(output_file_path);
   CalculatorGraph graph;
-  MEDIAPIPE_ASSERT_OK(graph.Initialize(config, input_side_packets));
+  MP_ASSERT_OK(graph.Initialize(config, input_side_packets));
   StatusOrPoller status_or_poller =
       graph.AddOutputStreamPoller("video_prestream");
   ASSERT_TRUE(status_or_poller.ok());
   OutputStreamPoller poller = std::move(status_or_poller.ValueOrDie());
 
-  MEDIAPIPE_ASSERT_OK(graph.StartRun({}));
+  MP_ASSERT_OK(graph.StartRun({}));
   Packet packet;
   while (poller.Next(&packet)) {
   }
-  MEDIAPIPE_ASSERT_OK(graph.WaitUntilDone());
+  MP_ASSERT_OK(graph.WaitUntilDone());
   const VideoHeader& video_header = packet.Get<VideoHeader>();
 
   // Checks the generated video file has the same width, height, fps, and

mediapipe/calculators/video/tool/BUILD

@@ -24,6 +24,7 @@ load("//mediapipe/framework/port:build_config.bzl", "mediapipe_cc_proto_library"
 proto_library(
     name = "flow_quantizer_model_proto",
     srcs = ["flow_quantizer_model.proto"],
+    visibility = ["//mediapipe:__subpackages__"],
 )
 
 mediapipe_cc_proto_library(

mediapipe/calculators/video/tvl1_optical_flow_calculator.cc

@@ -133,16 +133,16 @@ class Tvl1OpticalFlowCalculator : public CalculatorBase {
       cc->Inputs().Tag("SECOND_FRAME").Value().Get<ImageFrame>();
   if (forward_requested_) {
     auto forward_optical_flow_field = absl::make_unique<OpticalFlowField>();
-    RETURN_IF_ERROR(CalculateOpticalFlow(first_frame, second_frame,
-                                         forward_optical_flow_field.get()));
+    MP_RETURN_IF_ERROR(CalculateOpticalFlow(first_frame, second_frame,
+                                            forward_optical_flow_field.get()));
     cc->Outputs()
         .Tag("FORWARD_FLOW")
         .Add(forward_optical_flow_field.release(), cc->InputTimestamp());
   }
   if (backward_requested_) {
     auto backward_optical_flow_field = absl::make_unique<OpticalFlowField>();
-    RETURN_IF_ERROR(CalculateOpticalFlow(second_frame, first_frame,
-                                         backward_optical_flow_field.get()));
+    MP_RETURN_IF_ERROR(CalculateOpticalFlow(second_frame, first_frame,
+                                            backward_optical_flow_field.get()));
     cc->Outputs()
         .Tag("BACKWARD_FLOW")
         .Add(backward_optical_flow_field.release(), cc->InputTimestamp());

mediapipe/calculators/video/tvl1_optical_flow_calculator_test.cc

@@ -49,12 +49,12 @@ void AddInputPackets(int num_packets, CalculatorGraph* graph) {
   }
 
   for (int i = 0; i < num_packets; ++i) {
-    MEDIAPIPE_ASSERT_OK(graph->AddPacketToInputStream(
-        "first_frames", packet1.At(Timestamp(i))));
-    MEDIAPIPE_ASSERT_OK(graph->AddPacketToInputStream(
-        "second_frames", packet2.At(Timestamp(i))));
+    MP_ASSERT_OK(graph->AddPacketToInputStream("first_frames",
+                                               packet1.At(Timestamp(i))));
+    MP_ASSERT_OK(graph->AddPacketToInputStream("second_frames",
+                                               packet2.At(Timestamp(i))));
   }
-  MEDIAPIPE_ASSERT_OK(graph->CloseAllInputStreams());
+  MP_ASSERT_OK(graph->CloseAllInputStreams());
 }
 
 void RunTest(int num_input_packets, int max_in_flight) {
@@ -74,7 +74,7 @@ void RunTest(int num_input_packets, int max_in_flight) {
   )",
                        max_in_flight));
   CalculatorGraph graph;
-  MEDIAPIPE_ASSERT_OK(graph.Initialize(config));
+  MP_ASSERT_OK(graph.Initialize(config));
   StatusOrPoller status_or_poller1 =
       graph.AddOutputStreamPoller("forward_flow");
   ASSERT_TRUE(status_or_poller1.ok());
@@ -84,7 +84,7 @@ void RunTest(int num_input_packets, int max_in_flight) {
   ASSERT_TRUE(status_or_poller2.ok());
   OutputStreamPoller poller2 = std::move(status_or_poller2.ValueOrDie());
 
-  MEDIAPIPE_ASSERT_OK(graph.StartRun({}));
+  MP_ASSERT_OK(graph.StartRun({}));
   AddInputPackets(num_input_packets, &graph);
   Packet packet;
   std::vector<Packet> forward_optical_flow_packets;
@@ -95,7 +95,7 @@ void RunTest(int num_input_packets, int max_in_flight) {
   while (poller2.Next(&packet)) {
     backward_optical_flow_packets.emplace_back(packet);
   }
-  MEDIAPIPE_ASSERT_OK(graph.WaitUntilDone());
+  MP_ASSERT_OK(graph.WaitUntilDone());
   EXPECT_EQ(num_input_packets, forward_optical_flow_packets.size());
 
   int count = 0;