Convert CHECK macro to ABSL_CHECK.

Chrome can't use Absl's CHECK because of collisions with its own version.

PiperOrigin-RevId: 561740965

mediapipe/calculators/audio/BUILD

@@ -146,6 +146,7 @@ cc_library(
         "//mediapipe/framework/port:logging",
         "//mediapipe/framework/port:status",
         "//mediapipe/util:time_series_util",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
         "@com_google_audio_tools//audio/dsp/mfcc",
         "@eigen_archive//:eigen3",
@@ -165,6 +166,7 @@ cc_library(
         "//mediapipe/framework/formats:time_series_header_cc_proto",
         "//mediapipe/framework/port:integral_types",
         "//mediapipe/util:time_series_util",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/strings",
         "@com_google_audio_tools//audio/dsp:resampler",
@@ -186,6 +188,7 @@ cc_library(
         "//mediapipe/framework/port:core_proto",
         "//mediapipe/framework/port:status",
         "//mediapipe/util:time_series_util",
+        "@com_google_absl//absl/log:absl_check",
     ],
     alwayslink = 1,
 )
@@ -225,6 +228,7 @@ cc_library(
         "//mediapipe/framework/formats:time_series_header_cc_proto",
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/util:time_series_util",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_audio_tools//audio/dsp:window_functions",
         "@eigen_archive//:eigen3",
     ],
@@ -329,6 +333,7 @@ cc_binary(
         "//mediapipe/framework:packet",
         "//mediapipe/framework/formats:matrix",
         "//mediapipe/framework/formats:time_series_header_cc_proto",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_benchmark//:benchmark",
     ],
 )

mediapipe/calculators/audio/mfcc_mel_calculators.cc

@@ -23,6 +23,7 @@
 #include <vector>
 
 #include "Eigen/Core"
+#include "absl/log/absl_check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/substitute.h"
@@ -138,7 +139,7 @@ absl::Status FramewiseTransformCalculatorBase::Process(CalculatorContext* cc) {
     TransformFrame(input_frame, &output_frame);
 
     // Copy output from vector<float> to Eigen::Vector.
-    CHECK_EQ(output_frame.size(), num_output_channels_);
+    ABSL_CHECK_EQ(output_frame.size(), num_output_channels_);
     Eigen::Map<const Eigen::MatrixXd> output_frame_map(&output_frame[0],
                                                        output_frame.size(), 1);
     output->col(frame) = output_frame_map.cast<float>();

mediapipe/calculators/audio/rational_factor_resample_calculator.cc

@@ -16,6 +16,7 @@
 
 #include "mediapipe/calculators/audio/rational_factor_resample_calculator.h"
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "audio/dsp/resampler_q.h"
 
@@ -46,9 +47,9 @@ void CopyVectorToChannel(const std::vector<float>& vec, Matrix* matrix,
   if (matrix->cols() == 0) {
     matrix->resize(matrix->rows(), vec.size());
   } else {
-    CHECK_EQ(vec.size(), matrix->cols());
+    ABSL_CHECK_EQ(vec.size(), matrix->cols());
   }
-  CHECK_LT(channel, matrix->rows());
+  ABSL_CHECK_LT(channel, matrix->rows());
   matrix->row(channel) =
       Eigen::Map<const Eigen::ArrayXf>(vec.data(), vec.size());
 }

mediapipe/calculators/audio/stabilized_log_calculator.cc

@@ -18,6 +18,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/calculators/audio/stabilized_log_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
 #include "mediapipe/framework/formats/matrix.h"
@@ -59,7 +60,7 @@ class StabilizedLogCalculator : public CalculatorBase {
     output_scale_ = stabilized_log_calculator_options.output_scale();
     check_nonnegativity_ =
         stabilized_log_calculator_options.check_nonnegativity();
-    CHECK_GE(stabilizer_, 0.0)
+    ABSL_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.

mediapipe/calculators/audio/time_series_framer_calculator.cc

@@ -18,6 +18,7 @@
 #include <vector>
 
 #include "Eigen/Core"
+#include "absl/log/absl_check.h"
 #include "audio/dsp/window_functions.h"
 #include "mediapipe/calculators/audio/time_series_framer_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
@@ -104,7 +105,7 @@ class TimeSeriesFramerCalculator : public CalculatorBase {
     // All numbers are in input samples.
     const int64_t current_output_frame_start = static_cast<int64_t>(
         round(cumulative_output_frames_ * average_frame_step_samples_));
-    CHECK_EQ(current_output_frame_start, cumulative_completed_samples_);
+    ABSL_CHECK_EQ(current_output_frame_start, cumulative_completed_samples_);
     const int64_t next_output_frame_start = static_cast<int64_t>(
         round((cumulative_output_frames_ + 1) * average_frame_step_samples_));
     return next_output_frame_start - current_output_frame_start;

mediapipe/calculators/audio/time_series_framer_calculator_benchmark.cc

@@ -17,6 +17,7 @@
 #include <random>
 #include <vector>
 
+#include "absl/log/absl_check.h"
 #include "benchmark/benchmark.h"
 #include "mediapipe/calculators/audio/time_series_framer_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
@@ -70,7 +71,7 @@ void BM_TimeSeriesFramerCalculator(benchmark::State& state) {
     }
     // Initialize graph.
     mediapipe::CalculatorGraph graph;
-    CHECK_OK(graph.Initialize(config));
+    ABSL_CHECK_OK(graph.Initialize(config));
     // Prepare input header.
     auto header = std::make_unique<mediapipe::TimeSeriesHeader>();
     header->set_sample_rate(kSampleRate);
@@ -78,13 +79,13 @@ void BM_TimeSeriesFramerCalculator(benchmark::State& state) {
 
     state.ResumeTiming();  // Resume benchmark timing.
 
-    CHECK_OK(graph.StartRun({}, {{"input", Adopt(header.release())}}));
+    ABSL_CHECK_OK(graph.StartRun({}, {{"input", Adopt(header.release())}}));
     for (auto& packet : input_packets) {
-      CHECK_OK(graph.AddPacketToInputStream("input", packet));
+      ABSL_CHECK_OK(graph.AddPacketToInputStream("input", packet));
     }
-    CHECK(!graph.HasError());
+    ABSL_CHECK(!graph.HasError());
-    CHECK_OK(graph.CloseAllInputStreams());
+    ABSL_CHECK_OK(graph.CloseAllInputStreams());
-    CHECK_OK(graph.WaitUntilIdle());
+    ABSL_CHECK_OK(graph.WaitUntilIdle());
   }
 }
 BENCHMARK(BM_TimeSeriesFramerCalculator);

mediapipe/calculators/core/BUILD

@@ -582,6 +582,7 @@ cc_library(
         "//mediapipe/framework/port:logging",
         "//mediapipe/framework/port:status",
         "//mediapipe/framework/tool:options_util",
+        "@com_google_absl//absl/log:absl_check",
     ],
     alwayslink = 1,
 )
@@ -597,6 +598,7 @@ cc_test(
         "//mediapipe/framework/formats:video_stream_header",
         "//mediapipe/framework/port:gtest_main",
         "//mediapipe/framework/port:integral_types",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
     ],
 )
@@ -780,6 +782,7 @@ cc_library(
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
         "//mediapipe/framework/tool:options_util",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/strings",
     ],
@@ -836,6 +839,7 @@ cc_test(
         "//mediapipe/framework/port:gtest_main",
         "//mediapipe/framework/port:logging",
         "//mediapipe/framework/tool:validate_type",
+        "@com_google_absl//absl/log:absl_check",
         "@eigen_archive//:eigen3",
     ],
 )

mediapipe/calculators/core/matrix_multiply_calculator_test.cc

@@ -16,6 +16,7 @@
 #include <vector>
 
 #include "Eigen/Core"
+#include "absl/log/absl_check.h"
 #include "mediapipe/framework/calculator_framework.h"
 #include "mediapipe/framework/calculator_runner.h"
 #include "mediapipe/framework/formats/matrix.h"
@@ -209,7 +210,7 @@ TEST(MatrixMultiplyCalculatorTest, Multiply) {
   MatrixFromTextProto(kSamplesText, &samples);
   Matrix expected;
   MatrixFromTextProto(kExpectedText, &expected);
-  CHECK_EQ(samples.cols(), expected.cols());
+  ABSL_CHECK_EQ(samples.cols(), expected.cols());
 
   for (int i = 0; i < samples.cols(); ++i) {
     // Take a column from samples and produce a packet with just that

mediapipe/calculators/core/packet_resampler_calculator.cc

@@ -16,6 +16,7 @@
 
 #include <memory>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 
 namespace {
@@ -202,15 +203,15 @@ PacketResamplerCalculator::GetSamplingStrategy(
 
 Timestamp PacketResamplerCalculator::PeriodIndexToTimestamp(
     int64_t index) const {
-  CHECK_EQ(jitter_, 0.0);
+  ABSL_CHECK_EQ(jitter_, 0.0);
-  CHECK_NE(first_timestamp_, Timestamp::Unset());
+  ABSL_CHECK_NE(first_timestamp_, Timestamp::Unset());
   return first_timestamp_ + TimestampDiffFromSeconds(index / frame_rate_);
 }
 
 int64_t PacketResamplerCalculator::TimestampToPeriodIndex(
     Timestamp timestamp) const {
-  CHECK_EQ(jitter_, 0.0);
+  ABSL_CHECK_EQ(jitter_, 0.0);
-  CHECK_NE(first_timestamp_, Timestamp::Unset());
+  ABSL_CHECK_NE(first_timestamp_, Timestamp::Unset());
   return MathUtil::SafeRound<int64_t, double>(
       (timestamp - first_timestamp_).Seconds() * frame_rate_);
 }
@@ -344,8 +345,8 @@ void LegacyJitterWithReflectionStrategy::UpdateNextOutputTimestampWithJitter() {
   next_output_timestamp_ = Timestamp(ReflectBetween(
       next_output_timestamp_.Value(), next_output_timestamp_min_.Value(),
       next_output_timestamp_max_.Value()));
-  CHECK_GE(next_output_timestamp_, next_output_timestamp_min_);
+  ABSL_CHECK_GE(next_output_timestamp_, next_output_timestamp_min_);
-  CHECK_LT(next_output_timestamp_, next_output_timestamp_max_);
+  ABSL_CHECK_LT(next_output_timestamp_, next_output_timestamp_max_);
 }
 
 absl::Status ReproducibleJitterWithReflectionStrategy::Open(

mediapipe/calculators/core/packet_thinner_calculator.cc

@@ -17,6 +17,7 @@
 #include <cmath>  // for ceil
 #include <memory>
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/calculators/core/packet_thinner_calculator.pb.h"
 #include "mediapipe/framework/calculator_context.h"
 #include "mediapipe/framework/calculator_framework.h"
@@ -160,7 +161,7 @@ absl::Status PacketThinnerCalculator::Open(CalculatorContext* cc) {
 
   thinner_type_ = options.thinner_type();
   // This check enables us to assume only two thinner types exist in Process()
-  CHECK(thinner_type_ == PacketThinnerCalculatorOptions::ASYNC ||
+  ABSL_CHECK(thinner_type_ == PacketThinnerCalculatorOptions::ASYNC ||
              thinner_type_ == PacketThinnerCalculatorOptions::SYNC)
       << "Unsupported thinner type.";
 
@@ -177,7 +178,8 @@ absl::Status PacketThinnerCalculator::Open(CalculatorContext* cc) {
   } else {
     period_ = TimestampDiff(options.period());
   }
-  CHECK_LT(TimestampDiff(0), period_) << "Specified period must be positive.";
+  ABSL_CHECK_LT(TimestampDiff(0), period_)
+      << "Specified period must be positive.";
 
   if (options.has_start_time()) {
     start_time_ = Timestamp(options.start_time());
@@ -189,7 +191,7 @@ absl::Status PacketThinnerCalculator::Open(CalculatorContext* cc) {
 
   end_time_ =
       options.has_end_time() ? Timestamp(options.end_time()) : Timestamp::Max();
-  CHECK_LT(start_time_, end_time_)
+  ABSL_CHECK_LT(start_time_, end_time_)
       << "Invalid PacketThinner: start_time must be earlier than end_time";
 
   sync_output_timestamps_ = options.sync_output_timestamps();
@@ -232,7 +234,7 @@ absl::Status PacketThinnerCalculator::Close(CalculatorContext* cc) {
   // Emit any saved packets before quitting.
   if (!saved_packet_.IsEmpty()) {
     // Only sync thinner should have saved packets.
-    CHECK_EQ(PacketThinnerCalculatorOptions::SYNC, thinner_type_);
+    ABSL_CHECK_EQ(PacketThinnerCalculatorOptions::SYNC, thinner_type_);
     if (sync_output_timestamps_) {
       cc->Outputs().Index(0).AddPacket(
           saved_packet_.At(NearestSyncTimestamp(saved_packet_.Timestamp())));
@@ -269,7 +271,7 @@ absl::Status PacketThinnerCalculator::SyncThinnerProcess(
     const Timestamp saved_sync = NearestSyncTimestamp(saved);
     const Timestamp now = cc->InputTimestamp();
     const Timestamp now_sync = NearestSyncTimestamp(now);
-    CHECK_LE(saved_sync, now_sync);
+    ABSL_CHECK_LE(saved_sync, now_sync);
     if (saved_sync == now_sync) {
       // Saved Packet is in same interval as current packet.
       // Replace saved packet with current if it is at least as
@@ -295,7 +297,7 @@ absl::Status PacketThinnerCalculator::SyncThinnerProcess(
 }
 
 Timestamp PacketThinnerCalculator::NearestSyncTimestamp(Timestamp now) const {
-  CHECK_NE(start_time_, Timestamp::Unset())
+  ABSL_CHECK_NE(start_time_, Timestamp::Unset())
       << "Method only valid for sync thinner calculator.";
 
   // Computation is done using int64 arithmetic.  No easy way to avoid
@@ -303,12 +305,12 @@ Timestamp PacketThinnerCalculator::NearestSyncTimestamp(Timestamp now) const {
   const int64_t now64 = now.Value();
   const int64_t start64 = start_time_.Value();
   const int64_t period64 = period_.Value();
-  CHECK_LE(0, period64);
+  ABSL_CHECK_LE(0, period64);
 
   // Round now64 to its closest interval (units of period64).
   int64_t sync64 =
       (now64 - start64 + period64 / 2) / period64 * period64 + start64;
-  CHECK_LE(abs(now64 - sync64), period64 / 2)
+  ABSL_CHECK_LE(abs(now64 - sync64), period64 / 2)
       << "start64: " << start64 << "; now64: " << now64
       << "; sync64: " << sync64;
 

mediapipe/calculators/core/packet_thinner_calculator_test.cc

@@ -16,6 +16,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/absl_check.h"
 #include "absl/strings/str_cat.h"
 #include "mediapipe/calculators/core/packet_thinner_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
@@ -70,7 +71,7 @@ class SimpleRunner : public CalculatorRunner {
   }
 
   double GetFrameRate() const {
-    CHECK(!Outputs().Index(0).header.IsEmpty());
+    ABSL_CHECK(!Outputs().Index(0).header.IsEmpty());
     return Outputs().Index(0).header.Get<VideoHeader>().frame_rate;
   }
 };

mediapipe/calculators/image/BUILD

@@ -97,6 +97,7 @@ cc_library(
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:source_location",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
     ],
     alwayslink = 1,
 )
@@ -125,6 +126,7 @@ cc_library(
         "//mediapipe/framework/port:opencv_imgcodecs",
         "//mediapipe/framework/port:opencv_imgproc",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
     ],
     alwayslink = 1,
 )
@@ -202,6 +204,7 @@ cc_library(
         "//mediapipe/framework/port:opencv_imgproc",
         "//mediapipe/framework/port:status",
         "//mediapipe/framework/port:vector",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
     ] + select({
         "//mediapipe/gpu:disable_gpu": [],
@@ -397,6 +400,7 @@ cc_library(
         "//mediapipe/framework/port:logging",
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
     ],
 )
@@ -421,6 +425,7 @@ cc_library(
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
         "//mediapipe/util:image_frame_util",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/strings",
         "@libyuv",

mediapipe/calculators/image/bilateral_filter_calculator.cc

@@ -15,6 +15,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/log/absl_check.h"
 #include "absl/strings/str_replace.h"
 #include "mediapipe/calculators/image/bilateral_filter_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
@@ -183,8 +184,8 @@ absl::Status BilateralFilterCalculator::Open(CalculatorContext* cc) {
 
   sigma_color_ = options_.sigma_color();
   sigma_space_ = options_.sigma_space();
-  CHECK_GE(sigma_color_, 0.0);
+  ABSL_CHECK_GE(sigma_color_, 0.0);
-  CHECK_GE(sigma_space_, 0.0);
+  ABSL_CHECK_GE(sigma_space_, 0.0);
   if (!use_gpu_) sigma_color_ *= 255.0;
 
   if (use_gpu_) {

mediapipe/calculators/image/color_convert_calculator.cc

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/framework/calculator_framework.h"
 #include "mediapipe/framework/formats/image_frame.h"
 #include "mediapipe/framework/formats/image_frame_opencv.h"
@@ -25,8 +26,8 @@
 namespace mediapipe {
 namespace {
 void SetColorChannel(int channel, uint8 value, cv::Mat* mat) {
-  CHECK(mat->depth() == CV_8U);
+  ABSL_CHECK(mat->depth() == CV_8U);
-  CHECK(channel < mat->channels());
+  ABSL_CHECK(channel < mat->channels());
   const int step = mat->channels();
   for (int r = 0; r < mat->rows; ++r) {
     uint8* row_ptr = mat->ptr<uint8>(r);

mediapipe/calculators/image/opencv_image_encoder_calculator.cc

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/calculators/image/opencv_image_encoder_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
 #include "mediapipe/framework/formats/image_frame_opencv.h"
@@ -61,7 +62,7 @@ absl::Status OpenCvImageEncoderCalculator::Open(CalculatorContext* cc) {
 
 absl::Status OpenCvImageEncoderCalculator::Process(CalculatorContext* cc) {
   const ImageFrame& image_frame = cc->Inputs().Index(0).Get<ImageFrame>();
-  CHECK_EQ(1, image_frame.ByteDepth());
+  ABSL_CHECK_EQ(1, image_frame.ByteDepth());
 
   std::unique_ptr<OpenCvImageEncoderCalculatorResults> encoded_result =
       absl::make_unique<OpenCvImageEncoderCalculatorResults>();

mediapipe/calculators/image/scale_image_calculator.cc

@@ -18,6 +18,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/substitute.h"
@@ -509,7 +510,7 @@ absl::Status ScaleImageCalculator::ValidateImageFrame(
 
 absl::Status ScaleImageCalculator::ValidateYUVImage(CalculatorContext* cc,
                                                     const YUVImage& yuv_image) {
-  CHECK_EQ(input_format_, ImageFormat::YCBCR420P);
+  ABSL_CHECK_EQ(input_format_, ImageFormat::YCBCR420P);
   if (!has_header_) {
     if (input_width_ != yuv_image.width() ||
         input_height_ != yuv_image.height()) {

mediapipe/calculators/image/scale_image_utils.cc

@@ -18,6 +18,7 @@
 
 #include <string>
 
+#include "absl/log/absl_check.h"
 #include "absl/strings/str_split.h"
 #include "mediapipe/framework/port/logging.h"
 #include "mediapipe/framework/port/ret_check.h"
@@ -40,10 +41,10 @@ absl::Status FindCropDimensions(int input_width, int input_height,    //
                                 const std::string& max_aspect_ratio,  //
                                 int* crop_width, int* crop_height,    //
                                 int* col_start, int* row_start) {
-  CHECK(crop_width);
+  ABSL_CHECK(crop_width);
-  CHECK(crop_height);
+  ABSL_CHECK(crop_height);
-  CHECK(col_start);
+  ABSL_CHECK(col_start);
-  CHECK(row_start);
+  ABSL_CHECK(row_start);
 
   double min_aspect_ratio_q = 0.0;
   double max_aspect_ratio_q = 0.0;
@@ -83,8 +84,8 @@ absl::Status FindCropDimensions(int input_width, int input_height,    //
     }
   }
 
-  CHECK_LE(*crop_width, input_width);
+  ABSL_CHECK_LE(*crop_width, input_width);
-  CHECK_LE(*crop_height, input_height);
+  ABSL_CHECK_LE(*crop_height, input_height);
   return absl::OkStatus();
 }
 
@@ -96,8 +97,8 @@ absl::Status FindOutputDimensions(int input_width,             //
                                   bool preserve_aspect_ratio,  //
                                   int scale_to_multiple_of,    //
                                   int* output_width, int* output_height) {
-  CHECK(output_width);
+  ABSL_CHECK(output_width);
-  CHECK(output_height);
+  ABSL_CHECK(output_height);
 
   if (target_max_area > 0 && input_width * input_height > target_max_area) {
     preserve_aspect_ratio = true;

mediapipe/calculators/tensor/BUILD

@@ -87,6 +87,7 @@ cc_library(
         "//mediapipe/framework/formats:time_series_header_cc_proto",
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/util:time_series_util",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
@@ -181,6 +182,7 @@ cc_library(
         "//mediapipe/framework:calculator_framework",
         "//mediapipe/framework/api2:node",
         "//mediapipe/framework/formats:tensor",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/status",
     ],
     alwayslink = 1,
@@ -198,6 +200,7 @@ cc_test(
         "//mediapipe/framework/formats:tensor",
         "//mediapipe/framework/port:gtest_main",
         "//mediapipe/framework/port:parse_text_proto",
+        "@com_google_absl//absl/log:absl_check",
         "@org_tensorflow//tensorflow/lite/c:common",
     ],
 )
@@ -656,6 +659,7 @@ cc_library(
         "//mediapipe/gpu:gpu_buffer_format",
         "//mediapipe/gpu:gpu_origin_cc_proto",
         "//mediapipe/util:resource_util",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings:str_format",
     ] + select({
         "//mediapipe/gpu:disable_gpu": [],
@@ -745,6 +749,7 @@ cc_library(
         "//mediapipe/framework/formats:tensor",
         "//mediapipe/framework/formats/object_detection:anchor_cc_proto",
         "//mediapipe/framework/port:ret_check",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/strings:str_format",
         "@com_google_absl//absl/types:span",
@@ -802,6 +807,7 @@ cc_library(
         "//mediapipe/framework/formats:landmark_cc_proto",
         "//mediapipe/framework/formats:tensor",
         "//mediapipe/framework/port:ret_check",
+        "@com_google_absl//absl/log:absl_check",
     ],
     alwayslink = 1,
 )
@@ -994,6 +1000,7 @@ cc_library(
         "//mediapipe/framework/port:status",
         "//mediapipe/framework/port:statusor",
         "//mediapipe/gpu:gpu_origin_cc_proto",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
     ] + select({
         "//mediapipe/gpu:disable_gpu": [],
@@ -1087,6 +1094,7 @@ cc_test(
         "//mediapipe/framework/port:parse_text_proto",
         "//mediapipe/util:image_test_utils",
         "@com_google_absl//absl/flags:flag",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/strings:str_format",

mediapipe/calculators/tensor/audio_to_tensor_calculator.cc

@@ -20,6 +20,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/absl_check.h"
 #include "absl/memory/memory.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -348,7 +349,7 @@ absl::Status AudioToTensorCalculator::Process(CalculatorContext* cc) {
     return absl::InvalidArgumentError(
         "The audio data should be stored in column-major.");
   }
-  CHECK(channels_match || mono_output);
+  ABSL_CHECK(channels_match || mono_output);
   const Matrix& input = channels_match ? input_frame
                                        // Mono mixdown.
                                        : input_frame.colwise().mean();
@@ -457,7 +458,7 @@ absl::Status AudioToTensorCalculator::SetupStreamingResampler(
 }
 
 void AudioToTensorCalculator::AppendZerosToSampleBuffer(int num_samples) {
-  CHECK_GE(num_samples, 0);  // Ensured by `UpdateContract`.
+  ABSL_CHECK_GE(num_samples, 0);  // Ensured by `UpdateContract`.
   if (num_samples == 0) {
     return;
   }

mediapipe/calculators/tensor/feedback_tensors_calculator_test.cc

@@ -18,6 +18,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/calculators/tensor/feedback_tensors_calculator.pb.h"
 #include "mediapipe/framework/calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
@@ -65,7 +66,7 @@ template <typename T>
 Tensor MakeTensor(std::initializer_list<int> shape,
                   std::initializer_list<T> values) {
   Tensor tensor(TensorElementType<T>::value, shape);
-  CHECK_EQ(values.size(), tensor.shape().num_elements())
+  ABSL_CHECK_EQ(values.size(), tensor.shape().num_elements())
       << "The size of `values` is incompatible with `shape`";
   absl::c_copy(values, tensor.GetCpuWriteView().buffer<T>());
   return tensor;

mediapipe/calculators/tensor/image_to_tensor_calculator_test.cc

@@ -18,6 +18,7 @@
 #include <vector>
 
 #include "absl/flags/flag.h"
+#include "absl/log/absl_check.h"
 #include "absl/memory/memory.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/substitute.h"
@@ -205,7 +206,7 @@ mediapipe::ImageFormat::Format GetImageFormat(int image_channels) {
   } else if (image_channels == 1) {
     return ImageFormat::GRAY8;
   }
-  CHECK(false) << "Unsupported input image channles: " << image_channels;
+  ABSL_CHECK(false) << "Unsupported input image channles: " << image_channels;
 }
 
 Packet MakeImageFramePacket(cv::Mat input) {

mediapipe/calculators/tensor/inference_calculator_test.cc

@@ -16,7 +16,7 @@
 #include <string>
 #include <vector>
 
-#include "absl/log/check.h"
+#include "absl/log/absl_check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_replace.h"
 #include "absl/strings/string_view.h"

mediapipe/calculators/tensor/tensor_converter_calculator.cc

@@ -16,6 +16,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/absl_check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
@@ -623,7 +624,7 @@ absl::Status TensorConverterCalculator::LoadOptions(CalculatorContext* cc) {
   if (options.has_output_tensor_float_range()) {
     output_range_.emplace(options.output_tensor_float_range().min(),
                           options.output_tensor_float_range().max());
-    CHECK_GT(output_range_->second, output_range_->first);
+    ABSL_CHECK_GT(output_range_->second, output_range_->first);
   }
 
   // Custom div and sub values.
@@ -641,9 +642,9 @@ absl::Status TensorConverterCalculator::LoadOptions(CalculatorContext* cc) {
 
   // Get desired way to handle input channels.
   max_num_channels_ = options.max_num_channels();
-  CHECK_GE(max_num_channels_, 1);
+  ABSL_CHECK_GE(max_num_channels_, 1);
-  CHECK_LE(max_num_channels_, 4);
+  ABSL_CHECK_LE(max_num_channels_, 4);
-  CHECK_NE(max_num_channels_, 2);
+  ABSL_CHECK_NE(max_num_channels_, 2);
   return absl::OkStatus();
 }
 

mediapipe/calculators/tensor/tensors_to_detections_calculator.cc

@@ -84,7 +84,7 @@ void ConvertRawValuesToAnchors(const float* raw_anchors, int num_boxes,
 
 void ConvertAnchorsToRawValues(const std::vector<Anchor>& anchors,
                                int num_boxes, float* raw_anchors) {
-  CHECK_EQ(anchors.size(), num_boxes);
+  ABSL_CHECK_EQ(anchors.size(), num_boxes);
   int box = 0;
   for (const auto& anchor : anchors) {
     raw_anchors[box * kNumCoordsPerBox + 0] = anchor.y_center();
@@ -704,16 +704,16 @@ absl::Status TensorsToDetectionsCalculator::LoadOptions(CalculatorContext* cc) {
   num_boxes_ = options_.num_boxes();
   num_coords_ = options_.num_coords();
   box_output_format_ = GetBoxFormat(options_);
-  CHECK_NE(options_.max_results(), 0)
+  ABSL_CHECK_NE(options_.max_results(), 0)
       << "The maximum number of the top-scored detection results must be "
          "non-zero.";
   max_results_ = options_.max_results();
 
   // Currently only support 2D when num_values_per_keypoint equals to 2.
-  CHECK_EQ(options_.num_values_per_keypoint(), 2);
+  ABSL_CHECK_EQ(options_.num_values_per_keypoint(), 2);
 
   // Check if the output size is equal to the requested boxes and keypoints.
-  CHECK_EQ(options_.num_keypoints() * options_.num_values_per_keypoint() +
+  ABSL_CHECK_EQ(options_.num_keypoints() * options_.num_values_per_keypoint() +
                     kNumCoordsPerBox,
                 num_coords_);
 
@@ -1155,11 +1155,12 @@ void main() {
     }
     // TODO support better filtering.
     if (class_index_set_.is_allowlist) {
-      CHECK_EQ(class_index_set_.values.size(),
+      ABSL_CHECK_EQ(class_index_set_.values.size(),
                     IsClassIndexAllowed(0) ? num_classes_ : num_classes_ - 1)
           << "Only all classes  >= class 0  or  >= class 1";
     } else {
-      CHECK_EQ(class_index_set_.values.size(), IsClassIndexAllowed(0) ? 0 : 1)
+      ABSL_CHECK_EQ(class_index_set_.values.size(),
+                    IsClassIndexAllowed(0) ? 0 : 1)
           << "Only ignore class 0 is allowed";
     }
 
@@ -1380,11 +1381,12 @@ kernel void scoreKernel(
 
   // TODO support better filtering.
   if (class_index_set_.is_allowlist) {
-    CHECK_EQ(class_index_set_.values.size(),
+    ABSL_CHECK_EQ(class_index_set_.values.size(),
                   IsClassIndexAllowed(0) ? num_classes_ : num_classes_ - 1)
         << "Only all classes  >= class 0  or  >= class 1";
   } else {
-    CHECK_EQ(class_index_set_.values.size(), IsClassIndexAllowed(0) ? 0 : 1)
+    ABSL_CHECK_EQ(class_index_set_.values.size(),
+                  IsClassIndexAllowed(0) ? 0 : 1)
         << "Only ignore class 0 is allowed";
   }
 

mediapipe/calculators/tensor/tensors_to_landmarks_calculator.cc

@@ -142,7 +142,7 @@ absl::Status TensorsToLandmarksCalculator::Process(CalculatorContext* cc) {
   RET_CHECK(input_tensors[0].element_type() == Tensor::ElementType::kFloat32);
   int num_values = input_tensors[0].shape().num_elements();
   const int num_dimensions = num_values / num_landmarks_;
-  CHECK_GT(num_dimensions, 0);
+  ABSL_CHECK_GT(num_dimensions, 0);
 
   auto view = input_tensors[0].GetCpuReadView();
   auto raw_landmarks = view.buffer<float>();

mediapipe/calculators/tensorflow/BUILD

@@ -315,6 +315,7 @@ cc_library(
         "//mediapipe/framework/formats:time_series_header_cc_proto",
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
     ] + select({
         "//conditions:default": [
             "@org_tensorflow//tensorflow/core:framework",
@@ -429,7 +430,7 @@ cc_library(
         "//mediapipe/framework/port:status",
         "//mediapipe/framework/tool:status_util",
         "@com_google_absl//absl/base:core_headers",
-        "@com_google_absl//absl/log:check",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/synchronization",
@@ -670,6 +671,7 @@ cc_library(
         "//mediapipe/framework/formats:image_frame",
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
         "@org_tensorflow//tensorflow/core:framework",
     ],
     alwayslink = 1,
@@ -685,6 +687,7 @@ cc_library(
         "//mediapipe/framework/formats:time_series_header_cc_proto",
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
     ] + select({
         "//conditions:default": [
             "@org_tensorflow//tensorflow/core:framework",
@@ -796,6 +799,7 @@ cc_library(
         "//mediapipe/framework:calculator_framework",
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@org_tensorflow//tensorflow/core:framework",
     ],
@@ -838,6 +842,7 @@ cc_library(
         "//mediapipe/framework:calculator_framework",
         "//mediapipe/framework:packet",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@org_tensorflow//tensorflow/core:protos_all_cc",
     ],
@@ -945,6 +950,7 @@ cc_test(
         "//mediapipe/framework/port:gtest_main",
         "//mediapipe/framework/port:opencv_imgcodecs",
         "//mediapipe/util/sequence:media_sequence",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/strings",
         "@com_google_googletest//:gtest_main",
@@ -1257,6 +1263,7 @@ cc_test(
         "//mediapipe/framework/tool:sink",
         "//mediapipe/framework/tool:validate_type",
         "@com_google_absl//absl/flags:flag",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
     ] + select({
         "//conditions:default": [

mediapipe/calculators/tensorflow/matrix_to_tensor_calculator.cc

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/calculators/tensorflow/matrix_to_tensor_calculator_options.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
 #include "mediapipe/framework/formats/matrix.h"
@@ -28,7 +29,7 @@ namespace mediapipe {
 namespace {
 absl::Status FillTimeSeriesHeaderIfValid(const Packet& header_packet,
                                          TimeSeriesHeader* header) {
-  CHECK(header);
+  ABSL_CHECK(header);
   if (header_packet.IsEmpty()) {
     return absl::UnknownError("No header found.");
   }

mediapipe/calculators/tensorflow/pack_media_sequence_calculator_test.cc

@@ -16,6 +16,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/absl_check.h"
 #include "absl/memory/memory.h"
 #include "absl/strings/str_cat.h"
 #include "mediapipe/calculators/image/opencv_image_encoder_calculator.pb.h"

mediapipe/calculators/tensorflow/tensor_to_image_frame_calculator.cc

@@ -14,6 +14,7 @@
 
 #include <iostream>
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/calculators/tensorflow/tensor_to_image_frame_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
 #include "mediapipe/framework/formats/image_frame.h"
@@ -99,7 +100,7 @@ absl::Status TensorToImageFrameCalculator::Process(CalculatorContext* cc) {
   const tf::Tensor& input_tensor = cc->Inputs().Tag(kTensor).Get<tf::Tensor>();
   int32_t depth = 1;
   if (input_tensor.dims() != 2) {  // Depth is 1 for 2D tensors.
-    CHECK(3 == input_tensor.dims())
+    ABSL_CHECK(3 == input_tensor.dims())
         << "Only 2 or 3-D Tensors can be converted to frames. Instead got: "
         << input_tensor.dims();
     depth = input_tensor.dim_size(2);

mediapipe/calculators/tensorflow/tensor_to_matrix_calculator.cc

@@ -15,6 +15,7 @@
 // Calculator converts from one-dimensional Tensor of DT_FLOAT to Matrix
 // OR from (batched) two-dimensional Tensor of DT_FLOAT to Matrix.
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/calculators/tensorflow/tensor_to_matrix_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
 #include "mediapipe/framework/formats/matrix.h"
@@ -36,7 +37,7 @@ constexpr char kReference[] = "REFERENCE";
 
 absl::Status FillTimeSeriesHeaderIfValid(const Packet& header_packet,
                                          TimeSeriesHeader* header) {
-  CHECK(header);
+  ABSL_CHECK(header);
   if (header_packet.IsEmpty()) {
     return absl::UnknownError("No header found.");
   }
@@ -191,7 +192,7 @@ absl::Status TensorToMatrixCalculator::Process(CalculatorContext* cc) {
       << "Tensor stream packet does not contain a Tensor.";
 
   const tf::Tensor& input_tensor = cc->Inputs().Tag(kTensor).Get<tf::Tensor>();
-  CHECK(1 == input_tensor.dims() || 2 == input_tensor.dims())
+  ABSL_CHECK(1 == input_tensor.dims() || 2 == input_tensor.dims())
       << "Only 1-D or 2-D Tensors can be converted to matrices.";
   const int32_t length = input_tensor.dim_size(input_tensor.dims() - 1);
   const int32_t width =

mediapipe/calculators/tensorflow/tensorflow_inference_calculator.cc

@@ -20,6 +20,7 @@
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/log/absl_check.h"
 #include "absl/memory/memory.h"
 #include "absl/strings/str_split.h"
 #include "absl/synchronization/mutex.h"
@@ -515,7 +516,7 @@ class TensorFlowInferenceCalculator : public CalculatorBase {
         tf::Tensor concated;
         const tf::Status concat_status =
             tf::tensor::Concat(keyed_tensors.second, &concated);
-        CHECK(concat_status.ok()) << concat_status.ToString();
+        ABSL_CHECK(concat_status.ok()) << concat_status.ToString();
         input_tensors.emplace_back(tag_to_tensor_map_[keyed_tensors.first],
                                    concated);
       }
@@ -597,7 +598,7 @@ class TensorFlowInferenceCalculator : public CalculatorBase {
         std::vector<tf::Tensor> split_tensors;
         const tf::Status split_status =
             tf::tensor::Split(outputs[i], split_vector, &split_tensors);
-        CHECK(split_status.ok()) << split_status.ToString();
+        ABSL_CHECK(split_status.ok()) << split_status.ToString();
         // Loop over timestamps so that we don't copy the padding.
         for (int j = 0; j < inference_state->batch_timestamps_.size(); ++j) {
           tf::Tensor output_tensor(split_tensors[j]);

mediapipe/calculators/tensorflow/tensorflow_inference_calculator_test.cc

@@ -17,6 +17,7 @@
 #include <vector>
 
 #include "absl/flags/flag.h"
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "mediapipe/calculators/tensorflow/tensorflow_inference_calculator.pb.h"
 #include "mediapipe/calculators/tensorflow/tensorflow_session_from_frozen_graph_generator.pb.h"
@@ -119,7 +120,7 @@ class TensorflowInferenceCalculatorTest : public ::testing::Test {
   // Create tensor from Vector and add as a Packet to the provided tag as input.
   void AddVectorToInputsAsPacket(const std::vector<Packet>& packets,
                                  const std::string& tag) {
-    CHECK(!packets.empty())
+    ABSL_CHECK(!packets.empty())
         << "Please specify at least some data in the packet";
     auto packets_ptr = absl::make_unique<std::vector<Packet>>(packets);
     runner_->MutableInputs()->Tag(tag).packets.push_back(

mediapipe/calculators/tensorflow/unpack_yt8m_sequence_example_calculator.cc

@@ -14,6 +14,7 @@
 
 #include <iterator>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "mediapipe/calculators/tensorflow/lapped_tensor_buffer_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
@@ -47,7 +48,7 @@ std::string GetQuantizedFeature(
                                .Get(index)
                                .bytes_list()
                                .value();
-  CHECK_EQ(1, bytes_list.size());
+  ABSL_CHECK_EQ(1, bytes_list.size());
   return bytes_list.Get(0);
 }
 }  // namespace

mediapipe/calculators/tensorflow/vector_int_to_tensor_calculator.cc

@@ -15,6 +15,7 @@
 // Converts a single int or vector<int> or vector<vector<int>> to 1D (or 2D)
 // tf::Tensor.
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "mediapipe/calculators/tensorflow/vector_int_to_tensor_calculator_options.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
@@ -114,11 +115,11 @@ absl::Status VectorIntToTensorCalculator::Process(CalculatorContext* cc) {
             .Get<std::vector<std::vector<int>>>();
 
     const int32_t rows = input.size();
-    CHECK_GE(rows, 1);
+    ABSL_CHECK_GE(rows, 1);
     const int32_t cols = input[0].size();
-    CHECK_GE(cols, 1);
+    ABSL_CHECK_GE(cols, 1);
     for (int i = 1; i < rows; ++i) {
-      CHECK_EQ(input[i].size(), cols);
+      ABSL_CHECK_EQ(input[i].size(), cols);
     }
     if (options_.transpose()) {
       tensor_shape = tf::TensorShape({cols, rows});
@@ -172,7 +173,7 @@ absl::Status VectorIntToTensorCalculator::Process(CalculatorContext* cc) {
     } else {
       input = cc->Inputs().Tag(kVectorInt).Value().Get<std::vector<int>>();
     }
-    CHECK_GE(input.size(), 1);
+    ABSL_CHECK_GE(input.size(), 1);
     const int32_t length = input.size();
     tensor_shape = tf::TensorShape({length});
     auto output = ::absl::make_unique<tf::Tensor>(options_.tensor_data_type(),

mediapipe/calculators/tflite/BUILD

@@ -103,6 +103,7 @@ cc_library(
         "//mediapipe/framework/formats/object_detection:anchor_cc_proto",
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
     ],
     alwayslink = 1,
@@ -202,6 +203,7 @@ cc_library(
         "//mediapipe/framework/stream_handler:fixed_size_input_stream_handler",
         "//mediapipe/util/tflite:config",
         "//mediapipe/util/tflite:tflite_model_loader",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/memory",
         "@org_tensorflow//tensorflow/lite:framework",
@@ -278,6 +280,7 @@ cc_library(
         "//mediapipe/framework/stream_handler:fixed_size_input_stream_handler",
         "//mediapipe/util:resource_util",
         "//mediapipe/util/tflite:config",
+        "@com_google_absl//absl/log:absl_check",
         "@org_tensorflow//tensorflow/lite:framework",
         "@org_tensorflow//tensorflow/lite/kernels:builtin_ops",
     ] + selects.with_or({
@@ -395,6 +398,7 @@ cc_library(
         "//mediapipe/framework/formats/object_detection:anchor_cc_proto",
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/util/tflite:config",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/strings:str_format",
         "@com_google_absl//absl/types:span",
@@ -432,6 +436,7 @@ cc_library(
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/util:resource_util",
         "@com_google_absl//absl/container:node_hash_map",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings:str_format",
         "@com_google_absl//absl/types:span",
         "@org_tensorflow//tensorflow/lite:framework",
@@ -460,6 +465,7 @@ cc_library(
         "//mediapipe/framework:calculator_framework",
         "//mediapipe/framework/formats:landmark_cc_proto",
         "//mediapipe/framework/port:ret_check",
+        "@com_google_absl//absl/log:absl_check",
         "@org_tensorflow//tensorflow/lite:framework",
     ],
     alwayslink = 1,

mediapipe/calculators/tflite/ssd_anchors_calculator.cc

@@ -16,6 +16,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "mediapipe/calculators/tflite/ssd_anchors_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
@@ -275,11 +276,11 @@ absl::Status SsdAnchorsCalculator::GenerateAnchors(
     if (options.strides_size()) {
       ABSL_LOG(ERROR) << "Found feature map shapes. Strides will be ignored.";
     }
-    CHECK_EQ(options.feature_map_height_size(), kNumLayers);
+    ABSL_CHECK_EQ(options.feature_map_height_size(), kNumLayers);
-    CHECK_EQ(options.feature_map_height_size(),
+    ABSL_CHECK_EQ(options.feature_map_height_size(),
                   options.feature_map_width_size());
   } else {
-    CHECK_EQ(options.strides_size(), kNumLayers);
+    ABSL_CHECK_EQ(options.strides_size(), kNumLayers);
   }
 
   if (options.multiscale_anchor_generation()) {

mediapipe/calculators/tflite/tflite_converter_calculator.cc

@@ -15,6 +15,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/calculators/tflite/tflite_converter_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
 #include "mediapipe/framework/formats/image_frame.h"
@@ -643,7 +644,7 @@ absl::Status TfLiteConverterCalculator::LoadOptions(CalculatorContext* cc) {
   if (options.has_output_tensor_float_range()) {
     output_range_.emplace(options.output_tensor_float_range().min(),
                           options.output_tensor_float_range().max());
-    CHECK_GT(output_range_->second, output_range_->first);
+    ABSL_CHECK_GT(output_range_->second, output_range_->first);
   }
 
   // Custom div and sub values.
@@ -661,9 +662,9 @@ absl::Status TfLiteConverterCalculator::LoadOptions(CalculatorContext* cc) {
 
   // Get desired way to handle input channels.
   max_num_channels_ = options.max_num_channels();
-  CHECK_GE(max_num_channels_, 1);
+  ABSL_CHECK_GE(max_num_channels_, 1);
-  CHECK_LE(max_num_channels_, 4);
+  ABSL_CHECK_LE(max_num_channels_, 4);
-  CHECK_NE(max_num_channels_, 2);
+  ABSL_CHECK_NE(max_num_channels_, 2);
 #if defined(MEDIAPIPE_IOS)
   if (cc->Inputs().HasTag(kGpuBufferTag))
     // Currently on iOS, tflite gpu input tensor must be 4 channels,

mediapipe/calculators/tflite/tflite_inference_calculator.cc

@@ -17,6 +17,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/memory/memory.h"
 #include "mediapipe/calculators/tflite/tflite_inference_calculator.pb.h"
@@ -111,7 +112,7 @@ std::unique_ptr<tflite::Interpreter> BuildEdgeTpuInterpreter(
     edgetpu::EdgeTpuContext* edgetpu_context) {
   resolver->AddCustom(edgetpu::kCustomOp, edgetpu::RegisterCustomOp());
   std::unique_ptr<tflite::Interpreter> interpreter;
-  CHECK_EQ(tflite::InterpreterBuilder(model, *resolver)(&interpreter),
+  ABSL_CHECK_EQ(tflite::InterpreterBuilder(model, *resolver)(&interpreter),
                 kTfLiteOk);
   interpreter->SetExternalContext(kTfLiteEdgeTpuContext, edgetpu_context);
   return interpreter;
@@ -413,7 +414,7 @@ absl::Status TfLiteInferenceCalculator::Open(CalculatorContext* cc) {
            "Falling back to the default TFLite API.";
     use_advanced_gpu_api_ = false;
   }
-  CHECK(!use_advanced_gpu_api_ || gpu_inference_);
+  ABSL_CHECK(!use_advanced_gpu_api_ || gpu_inference_);
 
   MP_RETURN_IF_ERROR(LoadModel(cc));
 
@@ -805,9 +806,10 @@ absl::Status TfLiteInferenceCalculator::InitTFLiteGPURunner(
       const int tensor_idx = interpreter_->inputs()[i];
       interpreter_->SetTensorParametersReadWrite(tensor_idx, kTfLiteFloat32, "",
                                                  shape, quant);
-      CHECK(interpreter_->ResizeInputTensor(tensor_idx, shape) == kTfLiteOk);
+      ABSL_CHECK(interpreter_->ResizeInputTensor(tensor_idx, shape) ==
+                 kTfLiteOk);
     }
-    CHECK(interpreter_->AllocateTensors() == kTfLiteOk);
+    ABSL_CHECK(interpreter_->AllocateTensors() == kTfLiteOk);
   }
 
   // Create and bind OpenGL buffers for outputs.

mediapipe/calculators/tflite/tflite_tensors_to_classification_calculator.cc

@@ -17,6 +17,7 @@
 #include <vector>
 
 #include "absl/container/node_hash_map.h"
+#include "absl/log/absl_check.h"
 #include "absl/strings/str_format.h"
 #include "absl/types/span.h"
 #include "mediapipe/calculators/tflite/tflite_tensors_to_classification_calculator.pb.h"
@@ -172,7 +173,7 @@ absl::Status TfLiteTensorsToClassificationCalculator::Process(
 
   // Note that partial_sort will raise error when top_k_ >
   // classification_list->classification_size().
-  CHECK_GE(classification_list->classification_size(), top_k_);
+  ABSL_CHECK_GE(classification_list->classification_size(), top_k_);
   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(),

mediapipe/calculators/tflite/tflite_tensors_to_detections_calculator.cc

@@ -15,6 +15,7 @@
 #include <unordered_map>
 #include <vector>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/strings/str_format.h"
 #include "absl/types/span.h"
@@ -94,7 +95,7 @@ void ConvertRawValuesToAnchors(const float* raw_anchors, int num_boxes,
 
 void ConvertAnchorsToRawValues(const std::vector<Anchor>& anchors,
                                int num_boxes, float* raw_anchors) {
-  CHECK_EQ(anchors.size(), num_boxes);
+  ABSL_CHECK_EQ(anchors.size(), num_boxes);
   int box = 0;
   for (const auto& anchor : anchors) {
     raw_anchors[box * kNumCoordsPerBox + 0] = anchor.y_center();
@@ -289,14 +290,14 @@ absl::Status TfLiteTensorsToDetectionsCalculator::ProcessCPU(
     const TfLiteTensor* raw_score_tensor = &input_tensors[1];
 
     // TODO: Add flexible input tensor size handling.
-    CHECK_EQ(raw_box_tensor->dims->size, 3);
+    ABSL_CHECK_EQ(raw_box_tensor->dims->size, 3);
-    CHECK_EQ(raw_box_tensor->dims->data[0], 1);
+    ABSL_CHECK_EQ(raw_box_tensor->dims->data[0], 1);
-    CHECK_EQ(raw_box_tensor->dims->data[1], num_boxes_);
+    ABSL_CHECK_EQ(raw_box_tensor->dims->data[1], num_boxes_);
-    CHECK_EQ(raw_box_tensor->dims->data[2], num_coords_);
+    ABSL_CHECK_EQ(raw_box_tensor->dims->data[2], num_coords_);
-    CHECK_EQ(raw_score_tensor->dims->size, 3);
+    ABSL_CHECK_EQ(raw_score_tensor->dims->size, 3);
-    CHECK_EQ(raw_score_tensor->dims->data[0], 1);
+    ABSL_CHECK_EQ(raw_score_tensor->dims->data[0], 1);
-    CHECK_EQ(raw_score_tensor->dims->data[1], num_boxes_);
+    ABSL_CHECK_EQ(raw_score_tensor->dims->data[1], num_boxes_);
-    CHECK_EQ(raw_score_tensor->dims->data[2], num_classes_);
+    ABSL_CHECK_EQ(raw_score_tensor->dims->data[2], num_classes_);
     const float* raw_boxes = raw_box_tensor->data.f;
     const float* raw_scores = raw_score_tensor->data.f;
 
@@ -304,13 +305,13 @@ absl::Status TfLiteTensorsToDetectionsCalculator::ProcessCPU(
     if (!anchors_init_) {
       if (input_tensors.size() == kNumInputTensorsWithAnchors) {
         const TfLiteTensor* anchor_tensor = &input_tensors[2];
-        CHECK_EQ(anchor_tensor->dims->size, 2);
+        ABSL_CHECK_EQ(anchor_tensor->dims->size, 2);
-        CHECK_EQ(anchor_tensor->dims->data[0], num_boxes_);
+        ABSL_CHECK_EQ(anchor_tensor->dims->data[0], num_boxes_);
-        CHECK_EQ(anchor_tensor->dims->data[1], kNumCoordsPerBox);
+        ABSL_CHECK_EQ(anchor_tensor->dims->data[1], kNumCoordsPerBox);
         const float* raw_anchors = anchor_tensor->data.f;
         ConvertRawValuesToAnchors(raw_anchors, num_boxes_, &anchors_);
       } else if (side_packet_anchors_) {
-        CHECK(!cc->InputSidePackets().Tag("ANCHORS").IsEmpty());
+        ABSL_CHECK(!cc->InputSidePackets().Tag("ANCHORS").IsEmpty());
         anchors_ =
             cc->InputSidePackets().Tag("ANCHORS").Get<std::vector<Anchor>>();
       } else {
@@ -410,7 +411,7 @@ absl::Status TfLiteTensorsToDetectionsCalculator::ProcessGPU(
         CopyBuffer(input_tensors[1], gpu_data_->raw_scores_buffer));
     if (!anchors_init_) {
       if (side_packet_anchors_) {
-        CHECK(!cc->InputSidePackets().Tag("ANCHORS").IsEmpty());
+        ABSL_CHECK(!cc->InputSidePackets().Tag("ANCHORS").IsEmpty());
         const auto& anchors =
             cc->InputSidePackets().Tag("ANCHORS").Get<std::vector<Anchor>>();
         std::vector<float> raw_anchors(num_boxes_ * kNumCoordsPerBox);
@@ -418,7 +419,7 @@ absl::Status TfLiteTensorsToDetectionsCalculator::ProcessGPU(
         MP_RETURN_IF_ERROR(gpu_data_->raw_anchors_buffer.Write<float>(
             absl::MakeSpan(raw_anchors)));
       } else {
-        CHECK_EQ(input_tensors.size(), kNumInputTensorsWithAnchors);
+        ABSL_CHECK_EQ(input_tensors.size(), kNumInputTensorsWithAnchors);
         MP_RETURN_IF_ERROR(
             CopyBuffer(input_tensors[2], gpu_data_->raw_anchors_buffer));
       }
@@ -478,7 +479,7 @@ absl::Status TfLiteTensorsToDetectionsCalculator::ProcessGPU(
                     commandBuffer:[gpu_helper_ commandBuffer]];
   if (!anchors_init_) {
     if (side_packet_anchors_) {
-      CHECK(!cc->InputSidePackets().Tag("ANCHORS").IsEmpty());
+      ABSL_CHECK(!cc->InputSidePackets().Tag("ANCHORS").IsEmpty());
       const auto& anchors =
           cc->InputSidePackets().Tag("ANCHORS").Get<std::vector<Anchor>>();
       std::vector<float> raw_anchors(num_boxes_ * kNumCoordsPerBox);
@@ -568,10 +569,10 @@ absl::Status TfLiteTensorsToDetectionsCalculator::LoadOptions(
   num_coords_ = options_.num_coords();
 
   // Currently only support 2D when num_values_per_keypoint equals to 2.
-  CHECK_EQ(options_.num_values_per_keypoint(), 2);
+  ABSL_CHECK_EQ(options_.num_values_per_keypoint(), 2);
 
   // Check if the output size is equal to the requested boxes and keypoints.
-  CHECK_EQ(options_.num_keypoints() * options_.num_values_per_keypoint() +
+  ABSL_CHECK_EQ(options_.num_keypoints() * options_.num_values_per_keypoint() +
                     kNumCoordsPerBox,
                 num_coords_);
 
@@ -898,10 +899,11 @@ void main() {
     int max_wg_size;  //  typically <= 1024
     glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, 1,
                     &max_wg_size);  // y-dim
-    CHECK_LT(num_classes_, max_wg_size)
+    ABSL_CHECK_LT(num_classes_, max_wg_size)
         << "# classes must be < " << max_wg_size;
     // TODO support better filtering.
-    CHECK_LE(ignore_classes_.size(), 1) << "Only ignore class 0 is allowed";
+    ABSL_CHECK_LE(ignore_classes_.size(), 1)
+        << "Only ignore class 0 is allowed";
 
     // Shader program
     GlShader score_shader;
@@ -1116,7 +1118,7 @@ kernel void scoreKernel(
       ignore_classes_.size() ? 1 : 0);
 
   // TODO support better filtering.
-  CHECK_LE(ignore_classes_.size(), 1) << "Only ignore class 0 is allowed";
+  ABSL_CHECK_LE(ignore_classes_.size(), 1) << "Only ignore class 0 is allowed";
 
   {
     // Shader program
@@ -1148,7 +1150,8 @@ kernel void scoreKernel(
                             options:MTLResourceStorageModeShared];
     // # filter classes supported is hardware dependent.
     int max_wg_size = gpu_data_->score_program.maxTotalThreadsPerThreadgroup;
-    CHECK_LT(num_classes_, max_wg_size) << "# classes must be <" << max_wg_size;
+    ABSL_CHECK_LT(num_classes_, max_wg_size)
+        << "# classes must be <" << max_wg_size;
   }
 
 #endif  // MEDIAPIPE_TFLITE_GL_INFERENCE

mediapipe/calculators/tflite/tflite_tensors_to_landmarks_calculator.cc

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/calculators/tflite/tflite_tensors_to_landmarks_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
 #include "mediapipe/framework/formats/landmark.pb.h"
@@ -199,7 +200,7 @@ absl::Status TfLiteTensorsToLandmarksCalculator::Process(
     num_values *= raw_tensor->dims->data[i];
   }
   const int num_dimensions = num_values / num_landmarks_;
-  CHECK_GT(num_dimensions, 0);
+  ABSL_CHECK_GT(num_dimensions, 0);
 
   const float* raw_landmarks = raw_tensor->data.f;
 

mediapipe/calculators/util/BUILD

@@ -378,6 +378,7 @@ cc_library(
         "//mediapipe/framework/formats:location",
         "//mediapipe/framework/port:rectangle",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
     ],
     alwayslink = 1,
@@ -677,6 +678,7 @@ cc_library(
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/util:color_cc_proto",
         "//mediapipe/util:render_data_cc_proto",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/strings",
     ],
@@ -733,6 +735,7 @@ cc_library(
         "//mediapipe/framework/port:statusor",
         "//mediapipe/util:color_cc_proto",
         "//mediapipe/util:render_data_cc_proto",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
     ],
     alwayslink = 1,
@@ -748,6 +751,7 @@ cc_library(
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/util:color_cc_proto",
         "//mediapipe/util:render_data_cc_proto",
+        "@com_google_absl//absl/log:absl_check",
     ],
     alwayslink = 1,
 )
@@ -1212,6 +1216,7 @@ cc_library(
         "//mediapipe/framework/port:rectangle",
         "//mediapipe/framework/port:status",
         "//mediapipe/util:rectangle_util",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/memory",
     ],
     alwayslink = 1,
@@ -1483,6 +1488,7 @@ cc_library(
         "//mediapipe/framework/formats:landmark_cc_proto",
         "//mediapipe/framework/port:core_proto",
         "//mediapipe/framework/port:ret_check",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/memory",
     ],
     alwayslink = 1,

mediapipe/calculators/util/association_calculator.h

@@ -18,6 +18,7 @@
 #include <memory>
 #include <vector>
 
+#include "absl/log/absl_check.h"
 #include "absl/memory/memory.h"
 #include "mediapipe/calculators/util/association_calculator.pb.h"
 #include "mediapipe/framework/calculator_context.h"
@@ -72,7 +73,7 @@ class AssociationCalculator : public CalculatorBase {
       prev_input_stream_id_ = cc->Inputs().GetId("PREV", 0);
     }
     options_ = cc->Options<::mediapipe::AssociationCalculatorOptions>();
-    CHECK_GE(options_.min_similarity_threshold(), 0);
+    ABSL_CHECK_GE(options_.min_similarity_threshold(), 0);
 
     return absl::OkStatus();
   }

mediapipe/calculators/util/detections_to_render_data_calculator.cc

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "absl/log/absl_check.h"
 #include "absl/memory/memory.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
@@ -233,13 +234,13 @@ void DetectionsToRenderDataCalculator::AddLabels(
     const Detection& detection,
     const DetectionsToRenderDataCalculatorOptions& options,
     float text_line_height, RenderData* render_data) {
-  CHECK(detection.label().empty() || detection.label_id().empty() ||
+  ABSL_CHECK(detection.label().empty() || detection.label_id().empty() ||
              detection.label_size() == detection.label_id_size())
       << "String or integer labels should be of same size. Or only one of them "
          "is present.";
   const auto num_labels =
       std::max(detection.label_size(), detection.label_id_size());
-  CHECK_EQ(detection.score_size(), num_labels)
+  ABSL_CHECK_EQ(detection.score_size(), num_labels)
       << "Number of scores and labels should match for detection.";
 
   // Extracts all "label(_id),score" for the detection.
@@ -361,7 +362,7 @@ void DetectionsToRenderDataCalculator::AddDetectionToRenderData(
     const Detection& detection,
     const DetectionsToRenderDataCalculatorOptions& options,
     RenderData* render_data) {
-  CHECK(detection.location_data().format() == LocationData::BOUNDING_BOX ||
+  ABSL_CHECK(detection.location_data().format() == LocationData::BOUNDING_BOX ||
              detection.location_data().format() ==
                  LocationData::RELATIVE_BOUNDING_BOX)
       << "Only Detection with formats of BOUNDING_BOX or RELATIVE_BOUNDING_BOX "

mediapipe/calculators/util/labels_to_render_data_calculator.cc

@@ -19,6 +19,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/absl_check.h"
 #include "absl/strings/str_cat.h"
 #include "mediapipe/calculators/util/labels_to_render_data_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
@@ -114,7 +115,8 @@ absl::Status LabelsToRenderDataCalculator::Process(CalculatorContext* cc) {
     video_height_ = video_header.height;
     return absl::OkStatus();
   } else {
-    CHECK_EQ(options_.location(), LabelsToRenderDataCalculatorOptions::TOP_LEFT)
+    ABSL_CHECK_EQ(options_.location(),
+                  LabelsToRenderDataCalculatorOptions::TOP_LEFT)
         << "Only TOP_LEFT is supported without VIDEO_PRESTREAM.";
   }
 
@@ -144,7 +146,7 @@ absl::Status LabelsToRenderDataCalculator::Process(CalculatorContext* cc) {
     if (cc->Inputs().HasTag(kScoresTag)) {
       std::vector<float> score_vector =
           cc->Inputs().Tag(kScoresTag).Get<std::vector<float>>();
-      CHECK_EQ(label_vector.size(), score_vector.size());
+      ABSL_CHECK_EQ(label_vector.size(), score_vector.size());
       scores.resize(label_vector.size());
       for (int i = 0; i < label_vector.size(); ++i) {
         scores[i] = score_vector[i];

mediapipe/calculators/util/landmarks_refinement_calculator.cc

@@ -18,6 +18,7 @@
 #include <set>
 #include <utility>
 
+#include "absl/log/absl_check.h"
 #include "absl/memory/memory.h"
 #include "mediapipe/calculators/util/landmarks_refinement_calculator.pb.h"
 #include "mediapipe/framework/api2/node.h"
@@ -102,7 +103,8 @@ void RefineZ(
           ->set_z(z_average);
     }
   } else {
-    CHECK(false) << "Z refinement is either not specified or not supported";
+    ABSL_CHECK(false)
+        << "Z refinement is either not specified or not supported";
   }
 }
 

mediapipe/calculators/util/non_max_suppression_calculator.cc

@@ -18,6 +18,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "mediapipe/calculators/util/non_max_suppression_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
@@ -47,7 +48,7 @@ bool RetainMaxScoringLabelOnly(Detection* detection) {
   if (detection->label_id_size() == 0 && detection->label_size() == 0) {
     return false;
   }
-  CHECK(detection->label_id_size() == detection->score_size() ||
+  ABSL_CHECK(detection->label_id_size() == detection->score_size() ||
              detection->label_size() == detection->score_size())
       << "Number of scores must be equal to number of detections.";
 
@@ -171,9 +172,9 @@ class NonMaxSuppressionCalculator : public CalculatorBase {
     cc->SetOffset(TimestampDiff(0));
 
     options_ = cc->Options<NonMaxSuppressionCalculatorOptions>();
-    CHECK_GT(options_.num_detection_streams(), 0)
+    ABSL_CHECK_GT(options_.num_detection_streams(), 0)
         << "At least one detection stream need to be specified.";
-    CHECK_NE(options_.max_num_detections(), 0)
+    ABSL_CHECK_NE(options_.max_num_detections(), 0)
         << "max_num_detections=0 is not a valid value. Please choose a "
         << "positive number of you want to limit the number of output "
         << "detections, or set -1 if you do not want any limit.";

mediapipe/calculators/util/rect_to_render_data_calculator.cc

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/calculators/util/rect_to_render_data_calculator.pb.h"
 #include "mediapipe/framework/calculator_framework.h"
 #include "mediapipe/framework/formats/rect.pb.h"
@@ -41,8 +42,8 @@ RenderAnnotation::Rectangle* NewRect(
   annotation->set_thickness(options.thickness());
 
   if (options.has_top_left_thickness()) {
-    CHECK(!options.oval());
+    ABSL_CHECK(!options.oval());
-    CHECK(!options.filled());
+    ABSL_CHECK(!options.filled());
     annotation->mutable_rectangle()->set_top_left_thickness(
         options.top_left_thickness());
   }

mediapipe/calculators/video/BUILD

@@ -170,6 +170,7 @@ cc_library(
         "//mediapipe/framework/formats/motion:optical_flow_field",
         "//mediapipe/framework/port:opencv_video",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/synchronization",
     ],
     alwayslink = 1,
@@ -195,6 +196,7 @@ cc_library(
         "//mediapipe/util/tracking:motion_estimation",
         "//mediapipe/util/tracking:motion_models",
         "//mediapipe/util/tracking:region_flow_cc_proto",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/strings",
     ],
@@ -211,6 +213,7 @@ cc_library(
         "//mediapipe/util/tracking:camera_motion_cc_proto",
         "//mediapipe/util/tracking:flow_packager",
         "//mediapipe/util/tracking:region_flow_cc_proto",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/strings:str_format",
@@ -238,6 +241,7 @@ cc_library(
         "@com_google_absl//absl/container:flat_hash_set",
         "@com_google_absl//absl/container:node_hash_map",
         "@com_google_absl//absl/container:node_hash_set",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/strings",
     ],
@@ -265,6 +269,7 @@ cc_library(
         "//mediapipe/util/tracking:box_tracker_cc_proto",
         "//mediapipe/util/tracking:flow_packager_cc_proto",
         "//mediapipe/util/tracking:tracking_visualization_utilities",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/strings",
@@ -451,6 +456,7 @@ cc_test(
         "//mediapipe/framework/tool:test_util",
         "//mediapipe/util/tracking:box_tracker_cc_proto",
         "//mediapipe/util/tracking:tracking_cc_proto",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
     ],
 )

mediapipe/calculators/video/box_detector_calculator.cc

@@ -17,6 +17,7 @@
 #include <memory>
 #include <unordered_set>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/memory/memory.h"
 #include "absl/strings/numbers.h"
@@ -277,7 +278,7 @@ absl::Status BoxDetectorCalculator::Process(CalculatorContext* cc) {
                                        ? &(cc->Inputs().Tag(kDescriptorsTag))
                                        : nullptr;
 
-  CHECK(track_stream != nullptr || video_stream != nullptr ||
+  ABSL_CHECK(track_stream != nullptr || video_stream != nullptr ||
              (feature_stream != nullptr && descriptor_stream != nullptr))
       << "One and only one of {tracking_data, input image frame, "
          "feature/descriptor} need to be valid.";
@@ -296,7 +297,7 @@ absl::Status BoxDetectorCalculator::Process(CalculatorContext* cc) {
 
     const TrackingData& tracking_data = track_stream->Get<TrackingData>();
 
-    CHECK(tracked_boxes_stream != nullptr) << "tracked_boxes needed.";
+    ABSL_CHECK(tracked_boxes_stream != nullptr) << "tracked_boxes needed.";
 
     const TimedBoxProtoList tracked_boxes =
         tracked_boxes_stream->Get<TimedBoxProtoList>();
@@ -360,7 +361,7 @@ absl::Status BoxDetectorCalculator::Process(CalculatorContext* cc) {
 
     const auto& descriptors = descriptor_stream->Get<std::vector<float>>();
     const int dims = options_.detector_options().descriptor_dims();
-    CHECK_GE(descriptors.size(), feature_size * dims);
+    ABSL_CHECK_GE(descriptors.size(), feature_size * dims);
     cv::Mat descriptors_mat(feature_size, dims, CV_32F);
     for (int j = 0; j < feature_size; ++j) {
       features_vec[j].Set(features[j].pt.x * inv_scale,

mediapipe/calculators/video/box_tracker_calculator.cc

@@ -22,6 +22,7 @@
 #include "absl/container/flat_hash_set.h"
 #include "absl/container/node_hash_map.h"
 #include "absl/container/node_hash_set.h"
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/strings/numbers.h"
 #include "mediapipe/calculators/video/box_tracker_calculator.pb.h"
@@ -315,16 +316,16 @@ void ConvertCoordinateForRotation(float in_top, float in_left, float in_bottom,
                                   float in_right, int rotation, float* out_top,
                                   float* out_left, float* out_bottom,
                                   float* out_right) {
-  CHECK(out_top != nullptr);
+  ABSL_CHECK(out_top != nullptr);
-  CHECK(out_left != nullptr);
+  ABSL_CHECK(out_left != nullptr);
-  CHECK(out_bottom != nullptr);
+  ABSL_CHECK(out_bottom != nullptr);
-  CHECK(out_right != nullptr);
+  ABSL_CHECK(out_right != nullptr);
   const float in_center_x = (in_left + in_right) * 0.5f;
   const float in_center_y = (in_top + in_bottom) * 0.5f;
   const float in_width = in_right - in_left;
   const float in_height = in_bottom - in_top;
-  CHECK_GT(in_width, 0);
+  ABSL_CHECK_GT(in_width, 0);
-  CHECK_GT(in_height, 0);
+  ABSL_CHECK_GT(in_height, 0);
   float out_center_x;
   float out_center_y;
   float out_width;
@@ -373,7 +374,7 @@ void ConvertCoordinateForRotation(float in_top, float in_left, float in_bottom,
 
 void AddStateToPath(const MotionBoxState& state, int64_t time_msec,
                     PathSegment* path) {
-  CHECK(path);
+  ABSL_CHECK(path);
   TimedBox result;
   TimedBoxFromMotionBoxState(state, &result);
   result.time_msec = time_msec;
@@ -651,7 +652,7 @@ absl::Status BoxTrackerCalculator::Process(CalculatorContext* cc) {
   // present at this frame.
   TimedBoxProtoList box_track_list;
 
-  CHECK(box_tracker_ || track_stream)
+  ABSL_CHECK(box_tracker_ || track_stream)
       << "Expected either batch or streaming mode";
 
   // Corresponding list of box states for rendering. For each id present at
@@ -1001,7 +1002,7 @@ void BoxTrackerCalculator::OutputRandomAccessTrack(
 
     const int init_frame = timestamp_pos - track_timestamps_.begin() +
                            track_timestamps_base_index_;
-    CHECK_GE(init_frame, 0);
+    ABSL_CHECK_GE(init_frame, 0);
 
     MotionBoxMap single_map =
         PrepareRandomAccessTrack(start, init_frame, forward_track, start_data);
@@ -1168,8 +1169,8 @@ void BoxTrackerCalculator::StreamTrack(const TrackingData& data,
                                        int64_t duration_ms, bool forward,
                                        MotionBoxMap* box_map,
                                        std::vector<int>* failed_ids) {
-  CHECK(box_map);
+  ABSL_CHECK(box_map);
-  CHECK(failed_ids);
+  ABSL_CHECK(failed_ids);
 
   // Cache the actively discarded tracked ids from the new tracking data.
   for (const int discarded_id :
@@ -1235,7 +1236,7 @@ void BoxTrackerCalculator::FastForwardStartPos(
     // Start at previous frame.
     const int init_frame = timestamp_pos - track_timestamps_.begin() +
                            track_timestamps_base_index_;
-    CHECK_GE(init_frame, 0);
+    ABSL_CHECK_GE(init_frame, 0);
 
     // Locate corresponding tracking data.
     auto start_data = std::find_if(

mediapipe/calculators/video/flow_packager_calculator.cc

@@ -17,6 +17,7 @@
 #include <fstream>
 #include <memory>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
@@ -160,7 +161,7 @@ absl::Status FlowPackagerCalculator::Process(CalculatorContext* cc) {
           timestamp.Value() / 1000 / options_.caching_chunk_size_msec();
       tracking_chunk_.set_first_chunk(true);
     }
-    CHECK_GE(chunk_idx_, 0);
+    ABSL_CHECK_GE(chunk_idx_, 0);
 
     TrackingDataChunk::Item* item = tracking_chunk_.add_item();
     item->set_frame_idx(frame_idx_);
@@ -267,7 +268,7 @@ void FlowPackagerCalculator::WriteChunk(const TrackingDataChunk& chunk) const {
 
 void FlowPackagerCalculator::PrepareCurrentForNextChunk(
     TrackingDataChunk* chunk) {
-  CHECK(chunk);
+  ABSL_CHECK(chunk);
   if (chunk->item_size() == 0) {
     ABSL_LOG(ERROR) << "Called with empty chunk. Unexpected.";
     return;

mediapipe/calculators/video/motion_analysis_calculator.cc

@@ -17,6 +17,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_split.h"
@@ -429,7 +430,7 @@ absl::Status MotionAnalysisCalculator::Process(CalculatorContext* cc) {
       selection_input_ ? &(cc->Inputs().Tag(kSelectionTag)) : nullptr;
 
   // Checked on Open.
-  CHECK(video_stream || selection_stream);
+  ABSL_CHECK(video_stream || selection_stream);
 
   // Lazy init.
   if (frame_width_ < 0 || frame_height_ < 0) {
@@ -473,7 +474,7 @@ absl::Status MotionAnalysisCalculator::Process(CalculatorContext* cc) {
   // Always use frame if selection is not activated.
   bool use_frame = !selection_input_;
   if (selection_input_) {
-    CHECK(selection_stream);
+    ABSL_CHECK(selection_stream);
 
     // Fill in timestamps we process.
     if (!selection_stream->Value().IsEmpty()) {
@@ -621,7 +622,7 @@ void MotionAnalysisCalculator::OutputMotionAnalyzedFrames(
   const int num_results = motion_analysis_->GetResults(
       flush, &features, &camera_motions, with_saliency_ ? &saliency : nullptr);
 
-  CHECK_LE(num_results, buffer_size);
+  ABSL_CHECK_LE(num_results, buffer_size);
 
   if (num_results == 0) {
     return;
@@ -696,7 +697,7 @@ void MotionAnalysisCalculator::OutputMotionAnalyzedFrames(
 
   if (hybrid_meta_analysis_) {
     hybrid_meta_offset_ -= num_results;
-    CHECK_GE(hybrid_meta_offset_, 0);
+    ABSL_CHECK_GE(hybrid_meta_offset_, 0);
   }
 
   timestamp_buffer_.erase(timestamp_buffer_.begin(),
@@ -767,7 +768,7 @@ absl::Status MotionAnalysisCalculator::InitOnProcess(
 
   // Filled by CSV file parsing.
   if (!meta_homographies_.empty()) {
-    CHECK(csv_file_input_);
+    ABSL_CHECK(csv_file_input_);
     AppendCameraMotionsFromHomographies(meta_homographies_,
                                         true,  // append identity.
                                         &meta_motions_, &meta_features_);
@@ -814,7 +815,7 @@ bool MotionAnalysisCalculator::ParseModelCSV(
 bool MotionAnalysisCalculator::HomographiesFromValues(
     const std::vector<float>& homog_values,
     std::deque<Homography>* homographies) {
-  CHECK(homographies);
+  ABSL_CHECK(homographies);
 
   // Obvious constants are obvious :D
   constexpr int kHomographyValues = 9;
@@ -856,7 +857,7 @@ bool MotionAnalysisCalculator::HomographiesFromValues(
 void MotionAnalysisCalculator::SubtractMetaMotion(
     const CameraMotion& meta_motion, RegionFlowFeatureList* features) {
   if (meta_motion.mixture_homography().model_size() > 0) {
-    CHECK(row_weights_ != nullptr);
+    ABSL_CHECK(row_weights_ != nullptr);
     RegionFlowFeatureListViaTransform(meta_motion.mixture_homography(),
                                       features, -1.0f,
                                       1.0f,  // subtract transformed.
@@ -902,7 +903,7 @@ void MotionAnalysisCalculator::AddMetaMotion(
     const CameraMotion& meta_motion, const RegionFlowFeatureList& meta_features,
     RegionFlowFeatureList* features, CameraMotion* motion) {
   // Restore old feature location.
-  CHECK_EQ(meta_features.feature_size(), features->feature_size());
+  ABSL_CHECK_EQ(meta_features.feature_size(), features->feature_size());
   for (int k = 0; k < meta_features.feature_size(); ++k) {
     auto feature = features->mutable_feature(k);
     const auto& meta_feature = meta_features.feature(k);
@@ -923,8 +924,8 @@ void MotionAnalysisCalculator::AppendCameraMotionsFromHomographies(
     const std::deque<Homography>& homographies, bool append_identity,
     std::deque<CameraMotion>* camera_motions,
     std::deque<RegionFlowFeatureList>* features) {
-  CHECK(camera_motions);
+  ABSL_CHECK(camera_motions);
-  CHECK(features);
+  ABSL_CHECK(features);
 
   CameraMotion identity;
   identity.set_frame_width(frame_width_);
@@ -948,8 +949,9 @@ void MotionAnalysisCalculator::AppendCameraMotionsFromHomographies(
   }
 
   const int models_per_frame = options_.meta_models_per_frame();
-  CHECK_GT(models_per_frame, 0) << "At least one model per frame is needed";
+  ABSL_CHECK_GT(models_per_frame, 0)
-  CHECK_EQ(0, homographies.size() % models_per_frame);
+      << "At least one model per frame is needed";
+  ABSL_CHECK_EQ(0, homographies.size() % models_per_frame);
   const int num_frames = homographies.size() / models_per_frame;
 
   // Heuristic sigma, similar to what we use for rolling shutter removal.

mediapipe/calculators/video/tool/BUILD

@@ -44,6 +44,7 @@ cc_library(
         "//mediapipe/framework/port:integral_types",
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/tool:status_util",
+        "@com_google_absl//absl/log:absl_check",
     ],
     alwayslink = 1,
 )

mediapipe/calculators/video/tool/flow_quantizer_model.cc

@@ -14,6 +14,7 @@
 
 #include "mediapipe/calculators/video/tool/flow_quantizer_model.h"
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/framework/port/ret_check.h"
 #include "mediapipe/framework/type_map.h"
 
@@ -21,7 +22,7 @@ namespace mediapipe {
 
 // Uniform normalization to 0-255.
 uint8_t FlowQuantizerModel::Apply(const float val, const int channel) const {
-  CHECK_LT(channel, model_.min_value_size());
+  ABSL_CHECK_LT(channel, model_.min_value_size());
   const auto& min_value = model_.min_value(channel);
   const auto& max_value = model_.max_value(channel);
   QCHECK_GT(max_value, min_value);
@@ -51,7 +52,7 @@ const QuantizerModelData& FlowQuantizerModel::GetModelData() const {
 // TODO: Taking the min and max over all training flow fields might be
 // sensitive to noise. We should use more robust statistics.
 void FlowQuantizerModel::AddSampleFlowField(const OpticalFlowField& flow) {
-  CHECK_EQ(model_.min_value_size(), 2);
+  ABSL_CHECK_EQ(model_.min_value_size(), 2);
   const cv::Mat_<cv::Point2f>& flow_mat = flow.flow_data();
   for (int i = 0; i != flow.width(); ++i) {
     for (int j = 0; j != flow.height(); ++j) {

mediapipe/calculators/video/tracking_graph_test.cc

@@ -19,6 +19,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "mediapipe/calculators/video/box_tracker_calculator.pb.h"
 #include "mediapipe/framework/calculator.pb.h"
@@ -298,7 +299,7 @@ std::unique_ptr<TimedBoxProtoList>
 TrackingGraphTest::CreateRandomAccessTrackingBoxList(
     const std::vector<Timestamp>& start_timestamps,
     const std::vector<Timestamp>& end_timestamps) const {
-  CHECK_EQ(start_timestamps.size(), end_timestamps.size());
+  ABSL_CHECK_EQ(start_timestamps.size(), end_timestamps.size());
   auto ra_boxes = absl::make_unique<TimedBoxProtoList>();
   for (int i = 0; i < start_timestamps.size(); ++i) {
     auto start_box_list =

mediapipe/calculators/video/tvl1_optical_flow_calculator.cc

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "absl/base/macros.h"
+#include "absl/log/absl_check.h"
 #include "absl/synchronization/mutex.h"
 #include "mediapipe/framework/calculator_framework.h"
 #include "mediapipe/framework/formats/image_frame.h"
@@ -158,7 +159,7 @@ absl::Status Tvl1OpticalFlowCalculator::Process(CalculatorContext* cc) {
 absl::Status Tvl1OpticalFlowCalculator::CalculateOpticalFlow(
     const ImageFrame& current_frame, const ImageFrame& next_frame,
     OpticalFlowField* flow) {
-  CHECK(flow);
+  ABSL_CHECK(flow);
   if (!ImageSizesMatch(current_frame, next_frame)) {
     return tool::StatusInvalid("Images are different sizes.");
   }
@@ -182,7 +183,7 @@ absl::Status Tvl1OpticalFlowCalculator::CalculateOpticalFlow(
   flow->Allocate(first.cols, first.rows);
   cv::Mat cv_flow(flow->mutable_flow_data());
   tvl1_computer->calc(first, second, cv_flow);
-  CHECK_EQ(flow->mutable_flow_data().data, cv_flow.data);
+  ABSL_CHECK_EQ(flow->mutable_flow_data().data, cv_flow.data);
   // Inserts the idle DenseOpticalFlow object back to the cache for reuse.
   {
     absl::MutexLock lock(&mutex_);

mediapipe/examples/desktop/autoflip/quality/BUILD

@@ -68,7 +68,7 @@ cc_library(
     hdrs = ["piecewise_linear_function.h"],
     deps = [
         "//mediapipe/framework/port:status",
-        "@com_google_absl//absl/log:check",
+        "@com_google_absl//absl/log:absl_check",
     ],
 )
 
@@ -237,7 +237,7 @@ cc_test(
         "//mediapipe/framework/port:gtest_main",
         "//mediapipe/framework/port:status",
         "@com_google_absl//absl/flags:flag",
-        "@com_google_absl//absl/log:check",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
     ],
 )
@@ -285,6 +285,7 @@ cc_test(
         "//mediapipe/framework/port:gtest_main",
         "//mediapipe/framework/port:opencv_core",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
     ],
 )
 

mediapipe/examples/desktop/autoflip/quality/piecewise_linear_function.cc

@@ -20,7 +20,7 @@
 #include <limits>
 #include <vector>
 
-#include "absl/log/check.h"
+#include "absl/log/absl_check.h"
 #include "mediapipe/framework/port/status.h"
 
 namespace mediapipe {
@@ -28,7 +28,7 @@ namespace autoflip {
 
 void PiecewiseLinearFunction::AddPoint(double x, double y) {
   if (!points_.empty()) {
-    CHECK_GE(x, points_.back().x)
+    ABSL_CHECK_GE(x, points_.back().x)
         << "Points must be provided in non-decreasing x order.";
   }
   points_.push_back(PiecewiseLinearFunction::Point(x, y));
@@ -46,8 +46,8 @@ PiecewiseLinearFunction::GetIntervalIterator(double input) const {
 double PiecewiseLinearFunction::Interpolate(
     const PiecewiseLinearFunction::Point& p1,
     const PiecewiseLinearFunction::Point& p2, double input) const {
-  CHECK_LT(p1.x, input);
+  ABSL_CHECK_LT(p1.x, input);
-  CHECK_GE(p2.x, input);
+  ABSL_CHECK_GE(p2.x, input);
 
   return p2.y - (p2.x - input) / (p2.x - p1.x) * (p2.y - p1.y);
 }

mediapipe/examples/desktop/autoflip/quality/polynomial_regression_path_solver_test.cc

@@ -14,6 +14,7 @@
 
 #include "mediapipe/examples/desktop/autoflip/quality/polynomial_regression_path_solver.h"
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/examples/desktop/autoflip/quality/focus_point.pb.h"
 #include "mediapipe/framework/port/gmock.h"
 #include "mediapipe/framework/port/gtest.h"
@@ -145,7 +146,7 @@ void GenerateDataPointsFromRealVideo(
     const int prior_focus_point_frames_length,
     std::vector<FocusPointFrame>* focus_point_frames,
     std::vector<FocusPointFrame>* prior_focus_point_frames) {
-  CHECK(focus_point_frames_length + prior_focus_point_frames_length <=
+  ABSL_CHECK(focus_point_frames_length + prior_focus_point_frames_length <=
              kNumObservations);
   for (int i = 0; i < prior_focus_point_frames_length; i++) {
     FocusPoint sp;

mediapipe/examples/desktop/autoflip/quality/scene_camera_motion_analyzer.h

@@ -43,7 +43,7 @@ namespace autoflip {
 //   SceneCameraMotionAnalyzer analyzer(options);
 //   SceneKeyFrameCropSummary scene_summary;
 //   std::vector<FocusPointFrame> focus_point_frames;
-//   CHECK_OK(analyzer.AnalyzeScenePopulateFocusPointFrames(
+//   ABSL_CHECK_OK(analyzer.AnalyzeScenePopulateFocusPointFrames(
 //       key_frame_crop_infos, key_frame_crop_options, key_frame_crop_results,
 //       scene_frame_width, scene_frame_height, scene_frame_timestamps,
 //       &scene_summary, &focus_point_frames));

mediapipe/examples/desktop/autoflip/quality/scene_camera_motion_analyzer_test.cc

@@ -20,7 +20,7 @@
 #include <vector>
 
 #include "absl/flags/flag.h"
-#include "absl/log/check.h"
+#include "absl/log/absl_check.h"
 #include "absl/strings/str_split.h"
 #include "mediapipe/examples/desktop/autoflip/autoflip_messages.pb.h"
 #include "mediapipe/examples/desktop/autoflip/quality/focus_point.pb.h"
@@ -745,7 +745,7 @@ TEST(SceneCameraMotionAnalyzerTest,
     std::vector<std::string> r = absl::StrSplit(line, ',');
     records.insert(records.end(), r.begin(), r.end());
   }
-  CHECK_EQ(records.size(), kNumSceneFrames * 3 + 1);
+  ABSL_CHECK_EQ(records.size(), kNumSceneFrames * 3 + 1);
 
   std::vector<FocusPointFrame> focus_point_frames;
   MP_EXPECT_OK(analyzer.PopulateFocusPointFrames(

mediapipe/examples/desktop/autoflip/quality/scene_cropper.h

@@ -41,7 +41,7 @@ namespace autoflip {
 //   SceneCropperOptions scene_cropper_options;
 //   SceneCropper scene_cropper(scene_cropper_options);
 //   std::vector<cv::Mat> cropped_frames;
-//   CHECK_OK(scene_cropper.CropFrames(
+//   ABSL_CHECK_OK(scene_cropper.CropFrames(
 //       scene_summary, scene_frames, focus_point_frames,
 //       prior_focus_point_frames, &cropped_frames));
 class SceneCropper {

mediapipe/examples/desktop/hello_world/BUILD

@@ -24,6 +24,7 @@ cc_binary(
         "//mediapipe/framework:calculator_graph",
         "//mediapipe/framework/port:parse_text_proto",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
     ],
 )

mediapipe/examples/desktop/hello_world/hello_world.cc

@@ -14,6 +14,7 @@
 //
 // A simple example to print out "Hello World!" from a MediaPipe graph.
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "mediapipe/framework/calculator_graph.h"
 #include "mediapipe/framework/port/parse_text_proto.h"
@@ -62,6 +63,6 @@ absl::Status PrintHelloWorld() {
 
 int main(int argc, char** argv) {
   google::InitGoogleLogging(argv[0]);
-  CHECK(mediapipe::PrintHelloWorld().ok());
+  ABSL_CHECK(mediapipe::PrintHelloWorld().ok());
   return 0;
 }

mediapipe/framework/BUILD

@@ -204,6 +204,7 @@ cc_library(
         ":timestamp",
         "//mediapipe/framework/port:any_proto",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
     ],
 )
 
@@ -220,6 +221,7 @@ cc_library(
         "//mediapipe/framework/port:status",
         "//mediapipe/framework/tool:tag_map",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/synchronization",
     ],
@@ -360,6 +362,7 @@ cc_library(
         "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/container:flat_hash_set",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/status",
@@ -432,6 +435,7 @@ cc_library(
         "//mediapipe/framework/tool:tag_map",
         "//mediapipe/framework/tool:validate_name",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/status",
@@ -463,6 +467,7 @@ cc_library(
         "//mediapipe/framework/port:status",
         "//mediapipe/framework/tool:sink",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/strings",
@@ -489,6 +494,7 @@ cc_library(
         "//mediapipe/framework/port:logging",
         "//mediapipe/framework/tool:options_map",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
     ],
 )
@@ -510,6 +516,7 @@ cc_library(
         "//mediapipe/framework/tool:tag_map_helper",
         "//mediapipe/framework/tool:validate_name",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/strings",
@@ -544,6 +551,7 @@ cc_library(
         "//mediapipe/framework/port:integral_types",
         "//mediapipe/framework/port:map_util",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/synchronization",
@@ -618,6 +626,7 @@ cc_library(
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/synchronization",
@@ -633,6 +642,7 @@ cc_library(
         "//mediapipe/framework/port:status",
         "//mediapipe/framework/port:statusor",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
     ],
 )
@@ -651,6 +661,7 @@ cc_library(
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
         "//mediapipe/framework/tool:fill_packet_set",
+        "@com_google_absl//absl/log:absl_check",
     ],
 )
 
@@ -689,6 +700,7 @@ cc_library(
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
         "//mediapipe/framework/tool:tag_map",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
     ],
 )
@@ -709,6 +721,7 @@ cc_library(
         "//mediapipe/framework/port:status",
         "//mediapipe/framework/tool:status_util",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/synchronization",
     ],
@@ -728,6 +741,7 @@ cc_library(
         "//mediapipe/framework/port:source_location",
         "//mediapipe/framework/port:status",
         "//mediapipe/framework/tool:status_util",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
     ],
 )
@@ -767,6 +781,7 @@ cc_library(
         "//mediapipe/framework/port:logging",
         "//mediapipe/framework/port:source_location",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
     ],
 )
 
@@ -805,6 +820,7 @@ cc_library(
         "//mediapipe/framework/port:status",
         "//mediapipe/framework/tool:tag_map",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/synchronization",
     ],
 )
@@ -823,6 +839,7 @@ cc_library(
         ":timestamp",
         "//mediapipe/framework/port:source_location",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/synchronization",
     ],
 )
@@ -833,6 +850,7 @@ cc_library(
     visibility = ["//visibility:public"],
     deps = [
         ":graph_output_stream",
+        "@com_google_absl//absl/log:absl_check",
     ],
 )
 
@@ -849,6 +867,7 @@ cc_library(
         ":timestamp",
         "//mediapipe/framework/port:source_location",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
     ],
 )
@@ -873,6 +892,7 @@ cc_library(
         "//mediapipe/framework/port:statusor",
         "//mediapipe/framework/tool:type_util",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/strings",
@@ -954,6 +974,7 @@ cc_library(
         "//mediapipe/framework/tool:type_util",
         "//mediapipe/framework/tool:validate_name",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/strings",
@@ -1031,6 +1052,7 @@ cc_library(
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/synchronization",
     ],
 )
@@ -1090,6 +1112,7 @@ cc_library(
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
         "@eigen_archive//:eigen3",
     ],
@@ -1140,6 +1163,7 @@ cc_library(
         "//mediapipe/framework/port:integral_types",
         "//mediapipe/framework/port:logging",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/strings",
     ],
@@ -1161,8 +1185,8 @@ cc_library(
         "//mediapipe/framework/tool:status_util",
         "//mediapipe/framework/tool:type_util",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
-        "@com_google_absl//absl/log:check",
         "@com_google_absl//absl/synchronization",
     ],
     alwayslink = 1,
@@ -1216,6 +1240,7 @@ cc_library(
         "//mediapipe/framework/tool:validate",
         "//mediapipe/framework/tool:validate_name",
         "@com_google_absl//absl/container:flat_hash_set",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/strings",
@@ -1304,6 +1329,7 @@ cc_test(
         "//mediapipe/framework/port:parse_text_proto",
         "//mediapipe/framework/port:status",
         "//mediapipe/framework/tool:source",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/memory",
     ],
@@ -1475,6 +1501,7 @@ cc_test(
         "//mediapipe/framework/tool:status_util",
         "//mediapipe/gpu:gpu_service",
         "@com_google_absl//absl/container:fixed_array",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/status",
@@ -1708,6 +1735,7 @@ cc_test(
         "//mediapipe/framework/port:gtest_main",
         "//mediapipe/framework/port:parse_text_proto",
         "//mediapipe/framework/tool:template_parser",
+        "@com_google_absl//absl/log:absl_check",
     ],
 )
 

mediapipe/framework/api2/BUILD

@@ -22,6 +22,7 @@ cc_library(
         "//mediapipe/framework/port:any_proto",
         "//mediapipe/framework/port:ret_check",
         "@com_google_absl//absl/container:btree",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
         "@com_google_protobuf//:protobuf",
     ],
@@ -126,6 +127,7 @@ cc_library(
         ":tuple",
         "//mediapipe/framework:packet",
         "//mediapipe/framework/port:logging",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/meta:type_traits",
     ],
 )
@@ -155,6 +157,7 @@ cc_library(
         "//mediapipe/framework:output_side_packet",
         "//mediapipe/framework/port:logging",
         "//mediapipe/framework/tool:type_util",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
     ],
 )

mediapipe/framework/api2/builder.h

@@ -11,6 +11,7 @@
 #include <vector>
 
 #include "absl/container/btree_map.h"
+#include "absl/log/absl_check.h"
 #include "absl/strings/string_view.h"
 #include "google/protobuf/message_lite.h"
 #include "mediapipe/framework/api2/port.h"
@@ -109,7 +110,7 @@ class MultiPort : public Single {
       : Single(vec), vec_(*vec) {}
 
   Single operator[](int index) {
-    CHECK_GE(index, 0);
+    ABSL_CHECK_GE(index, 0);
     return Single{&GetWithAutoGrow(&vec_, index)};
   }
 
@@ -193,7 +194,7 @@ class SourceImpl {
   template <typename U,
             typename std::enable_if<AllowConnection<U>{}, int>::type = 0>
   Src& ConnectTo(const Dst<U>& dest) {
-    CHECK(dest.base_.source == nullptr);
+    ABSL_CHECK(dest.base_.source == nullptr);
     dest.base_.source = base_;
     base_->dests_.emplace_back(&dest.base_);
     return *this;
@@ -721,14 +722,14 @@ class Graph {
       config.set_type(type_);
     }
     FixUnnamedConnections();
-    CHECK_OK(UpdateBoundaryConfig(&config));
+    ABSL_CHECK_OK(UpdateBoundaryConfig(&config));
     for (const std::unique_ptr<NodeBase>& node : nodes_) {
       auto* out_node = config.add_node();
-      CHECK_OK(UpdateNodeConfig(*node, out_node));
+      ABSL_CHECK_OK(UpdateNodeConfig(*node, out_node));
     }
     for (const std::unique_ptr<PacketGenerator>& node : packet_gens_) {
       auto* out_node = config.add_packet_generator();
-      CHECK_OK(UpdateNodeConfig(*node, out_node));
+      ABSL_CHECK_OK(UpdateNodeConfig(*node, out_node));
     }
     return config;
   }
@@ -782,7 +783,7 @@ class Graph {
     config->set_calculator(node.type_);
     node.in_streams_.Visit(
         [&](const TagIndexLocation& loc, const DestinationBase& endpoint) {
-          CHECK(endpoint.source != nullptr);
+          ABSL_CHECK(endpoint.source != nullptr);
           config->add_input_stream(TaggedName(loc, endpoint.source->name_));
         });
     node.out_streams_.Visit(
@@ -791,7 +792,7 @@ class Graph {
         });
     node.in_sides_.Visit([&](const TagIndexLocation& loc,
                              const DestinationBase& endpoint) {
-      CHECK(endpoint.source != nullptr);
+      ABSL_CHECK(endpoint.source != nullptr);
       config->add_input_side_packet(TaggedName(loc, endpoint.source->name_));
     });
     node.out_sides_.Visit(
@@ -812,7 +813,7 @@ class Graph {
     config->set_packet_generator(node.type_);
     node.in_sides_.Visit([&](const TagIndexLocation& loc,
                              const DestinationBase& endpoint) {
-      CHECK(endpoint.source != nullptr);
+      ABSL_CHECK(endpoint.source != nullptr);
       config->add_input_side_packet(TaggedName(loc, endpoint.source->name_));
     });
     node.out_sides_.Visit(
@@ -829,7 +830,7 @@ class Graph {
   absl::Status UpdateBoundaryConfig(CalculatorGraphConfig* config) {
     graph_boundary_.in_streams_.Visit(
         [&](const TagIndexLocation& loc, const DestinationBase& endpoint) {
-          CHECK(endpoint.source != nullptr);
+          ABSL_CHECK(endpoint.source != nullptr);
           config->add_output_stream(TaggedName(loc, endpoint.source->name_));
         });
     graph_boundary_.out_streams_.Visit(
@@ -838,7 +839,7 @@ class Graph {
         });
     graph_boundary_.in_sides_.Visit([&](const TagIndexLocation& loc,
                                         const DestinationBase& endpoint) {
-      CHECK(endpoint.source != nullptr);
+      ABSL_CHECK(endpoint.source != nullptr);
       config->add_output_side_packet(TaggedName(loc, endpoint.source->name_));
     });
     graph_boundary_.out_sides_.Visit(

mediapipe/framework/api2/packet.h

@@ -13,6 +13,7 @@
 #include <functional>
 #include <type_traits>
 
+#include "absl/log/absl_check.h"
 #include "absl/meta/type_traits.h"
 #include "mediapipe/framework/api2/tuple.h"
 #include "mediapipe/framework/packet.h"
@@ -102,9 +103,9 @@ mediapipe::Packet ToOldPacket(PacketBase&& p);
 
 template <typename T>
 inline const T& PacketBase::Get() const {
-  CHECK(payload_);
+  ABSL_CHECK(payload_);
   packet_internal::Holder<T>* typed_payload = payload_->As<T>();
-  CHECK(typed_payload) << absl::StrCat(
+  ABSL_CHECK(typed_payload) << absl::StrCat(
       "The Packet stores \"", payload_->DebugTypeName(), "\", but \"",
       MediaPipeTypeStringOrDemangled<T>(), "\" was requested.");
   return typed_payload->data();
@@ -134,17 +135,17 @@ namespace internal {
 template <class T>
 inline void CheckCompatibleType(const HolderBase& holder, internal::Wrap<T>) {
   const packet_internal::Holder<T>* typed_payload = holder.As<T>();
-  CHECK(typed_payload) << absl::StrCat(
+  ABSL_CHECK(typed_payload) << absl::StrCat(
       "The Packet stores \"", holder.DebugTypeName(), "\", but \"",
       MediaPipeTypeStringOrDemangled<T>(), "\" was requested.");
-  //  CHECK(payload_->has_type<T>());
+  //  ABSL_CHECK(payload_->has_type<T>());
 }
 
 template <class... T>
 inline void CheckCompatibleType(const HolderBase& holder,
                                 internal::Wrap<OneOf<T...>>) {
   bool compatible = (holder.As<T>() || ...);
-  CHECK(compatible)
+  ABSL_CHECK(compatible)
       << "The Packet stores \"" << holder.DebugTypeName() << "\", but one of "
       << absl::StrJoin(
              {absl::StrCat("\"", MediaPipeTypeStringOrDemangled<T>(), "\"")...},
@@ -211,9 +212,9 @@ class Packet : public Packet<internal::Generic> {
   Packet<T> At(Timestamp timestamp) &&;
 
   const T& Get() const {
-    CHECK(payload_);
+    ABSL_CHECK(payload_);
     packet_internal::Holder<T>* typed_payload = payload_->As<T>();
-    CHECK(typed_payload);
+    ABSL_CHECK(typed_payload);
     return typed_payload->data();
   }
   const T& operator*() const { return Get(); }
@@ -330,9 +331,9 @@ class Packet<OneOf<T...>> : public PacketBase {
 
   template <class U, class = AllowedType<U>>
   const U& Get() const {
-    CHECK(payload_);
+    ABSL_CHECK(payload_);
     packet_internal::Holder<U>* typed_payload = payload_->As<U>();
-    CHECK(typed_payload);
+    ABSL_CHECK(typed_payload);
     return typed_payload->data();
   }
 
@@ -343,7 +344,7 @@ class Packet<OneOf<T...>> : public PacketBase {
 
   template <class... F>
   auto Visit(const F&... args) const {
-    CHECK(payload_);
+    ABSL_CHECK(payload_);
     auto f = internal::Overload{args...};
     using FirstT = typename internal::First<T...>::type;
     using ResultType = absl::result_of_t<decltype(f)(const FirstT&)>;
@@ -364,7 +365,7 @@ class Packet<OneOf<T...>> : public PacketBase {
 
   template <class... F>
   auto ConsumeAndVisit(const F&... args) {
-    CHECK(payload_);
+    ABSL_CHECK(payload_);
     auto f = internal::Overload{args...};
     using FirstT = typename internal::First<T...>::type;
     using VisitorResultType =

mediapipe/framework/api2/port.h

@@ -20,6 +20,7 @@
 #include <type_traits>
 #include <utility>
 
+#include "absl/log/absl_check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "mediapipe/framework/api2/const_str.h"
@@ -243,8 +244,8 @@ class MultiplePortAccess {
   // container?
   int Count() { return count_; }
   AccessT operator[](int pos) {
-    CHECK_GE(pos, 0);
+    ABSL_CHECK_GE(pos, 0);
-    CHECK_LT(pos, count_);
+    ABSL_CHECK_LT(pos, count_);
     return SinglePortAccess<ValueT>(cc_, &first_[pos]);
   }
 

mediapipe/framework/calculator_context.cc

@@ -14,35 +14,37 @@
 
 #include "mediapipe/framework/calculator_context.h"
 
+#include "absl/log/absl_check.h"
+
 namespace mediapipe {
 
 const std::string& CalculatorContext::CalculatorType() const {
-  CHECK(calculator_state_);
+  ABSL_CHECK(calculator_state_);
   return calculator_state_->CalculatorType();
 }
 
 const CalculatorOptions& CalculatorContext::Options() const {
-  CHECK(calculator_state_);
+  ABSL_CHECK(calculator_state_);
   return calculator_state_->Options();
 }
 
 const std::string& CalculatorContext::NodeName() const {
-  CHECK(calculator_state_);
+  ABSL_CHECK(calculator_state_);
   return calculator_state_->NodeName();
 }
 
 int CalculatorContext::NodeId() const {
-  CHECK(calculator_state_);
+  ABSL_CHECK(calculator_state_);
   return calculator_state_->NodeId();
 }
 
 Counter* CalculatorContext::GetCounter(const std::string& name) {
-  CHECK(calculator_state_);
+  ABSL_CHECK(calculator_state_);
   return calculator_state_->GetCounter(name);
 }
 
 CounterFactory* CalculatorContext::GetCounterFactory() {
-  CHECK(calculator_state_);
+  ABSL_CHECK(calculator_state_);
   return calculator_state_->GetCounterFactory();
 }
 

mediapipe/framework/calculator_context.h

@@ -20,6 +20,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/framework/calculator_state.h"
 #include "mediapipe/framework/counter.h"
 #include "mediapipe/framework/graph_service.h"
@@ -147,7 +148,7 @@ class CalculatorContext {
   }
 
   void PopInputTimestamp() {
-    CHECK(!input_timestamps_.empty());
+    ABSL_CHECK(!input_timestamps_.empty());
     input_timestamps_.pop();
   }
 

mediapipe/framework/calculator_context_manager.cc

@@ -16,6 +16,7 @@
 
 #include <utility>
 
+#include "absl/log/absl_check.h"
 #include "absl/memory/memory.h"
 #include "absl/synchronization/mutex.h"
 #include "mediapipe/framework/port/logging.h"
@@ -27,7 +28,7 @@ void CalculatorContextManager::Initialize(
     std::shared_ptr<tool::TagMap> input_tag_map,
     std::shared_ptr<tool::TagMap> output_tag_map,
     bool calculator_run_in_parallel) {
-  CHECK(calculator_state);
+  ABSL_CHECK(calculator_state);
   calculator_state_ = calculator_state;
   input_tag_map_ = std::move(input_tag_map);
   output_tag_map_ = std::move(output_tag_map);
@@ -51,15 +52,15 @@ void CalculatorContextManager::CleanupAfterRun() {
 
 CalculatorContext* CalculatorContextManager::GetDefaultCalculatorContext()
     const {
-  CHECK(default_context_.get());
+  ABSL_CHECK(default_context_.get());
   return default_context_.get();
 }
 
 CalculatorContext* CalculatorContextManager::GetFrontCalculatorContext(
     Timestamp* context_input_timestamp) {
-  CHECK(calculator_run_in_parallel_);
+  ABSL_CHECK(calculator_run_in_parallel_);
   absl::MutexLock lock(&contexts_mutex_);
-  CHECK(!active_contexts_.empty());
+  ABSL_CHECK(!active_contexts_.empty());
   *context_input_timestamp = active_contexts_.begin()->first;
   return active_contexts_.begin()->second.get();
 }
@@ -70,7 +71,7 @@ CalculatorContext* CalculatorContextManager::PrepareCalculatorContext(
     return GetDefaultCalculatorContext();
   }
   absl::MutexLock lock(&contexts_mutex_);
-  CHECK(!mediapipe::ContainsKey(active_contexts_, input_timestamp))
+  ABSL_CHECK(!mediapipe::ContainsKey(active_contexts_, input_timestamp))
       << "Multiple invocations with the same timestamps are not allowed with "
          "parallel execution, input_timestamp = "
       << input_timestamp;

mediapipe/framework/calculator_context_manager.h

@@ -21,6 +21,7 @@
 #include <memory>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/log/absl_check.h"
 #include "absl/synchronization/mutex.h"
 #include "mediapipe/framework/calculator_context.h"
 #include "mediapipe/framework/calculator_state.h"
@@ -97,18 +98,18 @@ class CalculatorContextManager {
 
   void PushInputTimestampToContext(CalculatorContext* calculator_context,
                                    Timestamp input_timestamp) {
-    CHECK(calculator_context);
+    ABSL_CHECK(calculator_context);
     calculator_context->PushInputTimestamp(input_timestamp);
   }
 
   void PopInputTimestampFromContext(CalculatorContext* calculator_context) {
-    CHECK(calculator_context);
+    ABSL_CHECK(calculator_context);
     calculator_context->PopInputTimestamp();
   }
 
   void SetGraphStatusInContext(CalculatorContext* calculator_context,
                                const absl::Status& status) {
-    CHECK(calculator_context);
+    ABSL_CHECK(calculator_context);
     calculator_context->SetGraphStatus(status);
   }
 

mediapipe/framework/calculator_graph.cc

@@ -26,6 +26,7 @@
 #include <vector>
 
 #include "absl/container/flat_hash_set.h"
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/memory/memory.h"
 #include "absl/status/status.h"
@@ -172,7 +173,7 @@ absl::Status CalculatorGraph::InitializePacketGeneratorGraph(
   Executor* default_executor = nullptr;
   if (!use_application_thread_) {
     default_executor = executors_[""].get();
-    CHECK(default_executor);
+    ABSL_CHECK(default_executor);
   }
   // If default_executor is nullptr, then packet_generator_graph_ will create
   // its own DelegatingExecutor to use the application thread.
@@ -925,7 +926,7 @@ absl::Status CalculatorGraph::AddPacketToInputStreamInternal(
       "graph input stream.",
       stream_name);
   int node_id = mediapipe::FindOrDie(graph_input_stream_node_ids_, stream_name);
-  CHECK_GE(node_id, validated_graph_->CalculatorInfos().size());
+  ABSL_CHECK_GE(node_id, validated_graph_->CalculatorInfos().size());
   {
     absl::MutexLock lock(&full_input_streams_mutex_);
     if (full_input_streams_.empty()) {
@@ -1113,7 +1114,8 @@ void CalculatorGraph::CallStatusHandlers(GraphRunState graph_run_state,
     absl::StatusOr<std::unique_ptr<internal::StaticAccessToStatusHandler>>
         static_access_statusor = internal::StaticAccessToStatusHandlerRegistry::
             CreateByNameInNamespace(validated_graph_->Package(), handler_type);
-    CHECK(static_access_statusor.ok()) << handler_type << " is not registered.";
+    ABSL_CHECK(static_access_statusor.ok())
+        << handler_type << " is not registered.";
     auto static_access = std::move(static_access_statusor).value();
     absl::Status handler_result;
     if (graph_run_state == GraphRunState::PRE_RUN) {
@@ -1154,7 +1156,7 @@ void CalculatorGraph::UpdateThrottledNodes(InputStreamManager* stream,
     upstream_nodes =
         &validated_graph_->CalculatorInfos()[node_index].AncestorSources();
   }
-  CHECK(upstream_nodes);
+  ABSL_CHECK(upstream_nodes);
   std::vector<CalculatorNode*> nodes_to_schedule;
 
   {
@@ -1176,10 +1178,10 @@ void CalculatorGraph::UpdateThrottledNodes(InputStreamManager* stream,
                                 .set_stream_id(&stream->Name()));
         bool was_throttled = !full_input_streams_[node_id].empty();
         if (stream_is_full) {
-          DCHECK_EQ(full_input_streams_[node_id].count(stream), 0);
+          ABSL_DCHECK_EQ(full_input_streams_[node_id].count(stream), 0);
           full_input_streams_[node_id].insert(stream);
         } else {
-          DCHECK_EQ(full_input_streams_[node_id].count(stream), 1);
+          ABSL_DCHECK_EQ(full_input_streams_[node_id].count(stream), 1);
           full_input_streams_[node_id].erase(stream);
         }
 
@@ -1363,7 +1365,7 @@ void CalculatorGraph::CleanupAfterRun(absl::Status* status) {
     // Obtain the combined status again, so that it includes the new errors
     // added by CallStatusHandlers.
     GetCombinedErrors(status);
-    CHECK(!status->ok());
+    ABSL_CHECK(!status->ok());
   } else {
     MEDIAPIPE_CHECK_OK(*status);
   }

mediapipe/framework/calculator_graph_test.cc

@@ -29,6 +29,7 @@
 #include <vector>
 
 #include "absl/container/fixed_array.h"
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/memory/memory.h"
 #include "absl/status/status.h"
@@ -729,13 +730,13 @@ class SlowCountingSinkCalculator : public CalculatorBase {
   absl::Status Process(CalculatorContext* cc) override {
     absl::SleepFor(absl::Milliseconds(10));
     int value = cc->Inputs().Index(0).Get<int>();
-    CHECK_EQ(value, counter_);
+    ABSL_CHECK_EQ(value, counter_);
     ++counter_;
     return absl::OkStatus();
   }
 
   absl::Status Close(CalculatorContext* cc) override {
-    CHECK_EQ(10, counter_);
+    ABSL_CHECK_EQ(10, counter_);
     return absl::OkStatus();
   }
 
@@ -1018,7 +1019,7 @@ class CheckInputTimestampSourceCalculator : public CalculatorBase {
   absl::Status Close(CalculatorContext* cc) final {
     // Must use CHECK instead of RET_CHECK in Close(), because the framework
     // may call the Close() method of a source node with .IgnoreError().
-    CHECK_EQ(cc->InputTimestamp(), Timestamp::Done());
+    ABSL_CHECK_EQ(cc->InputTimestamp(), Timestamp::Done());
     return absl::OkStatus();
   }
 
@@ -1096,7 +1097,7 @@ class CheckInputTimestamp2SourceCalculator : public CalculatorBase {
   absl::Status Close(CalculatorContext* cc) final {
     // Must use CHECK instead of RET_CHECK in Close(), because the framework
     // may call the Close() method of a source node with .IgnoreError().
-    CHECK_EQ(cc->InputTimestamp(), Timestamp::Done());
+    ABSL_CHECK_EQ(cc->InputTimestamp(), Timestamp::Done());
     return absl::OkStatus();
   }
 
@@ -1246,8 +1247,8 @@ REGISTER_STATUS_HANDLER(IncrementingStatusHandler);
 class CurrentThreadExecutor : public Executor {
  public:
   ~CurrentThreadExecutor() override {
-    CHECK(!executing_);
+    ABSL_CHECK(!executing_);
-    CHECK(tasks_.empty());
+    ABSL_CHECK(tasks_.empty());
   }
 
   void Schedule(std::function<void()> task) override {
@@ -1258,7 +1259,7 @@ class CurrentThreadExecutor : public Executor {
       // running) to avoid an indefinitely-deep call stack.
       tasks_.emplace_back(std::move(task));
     } else {
-      CHECK(tasks_.empty());
+      ABSL_CHECK(tasks_.empty());
       executing_ = true;
       task();
       while (!tasks_.empty()) {
@@ -3594,7 +3595,7 @@ REGISTER_CALCULATOR(::mediapipe::nested_ns::ProcessCallbackCalculator);
 
 TEST(CalculatorGraph, CalculatorInNamepsace) {
   CalculatorGraphConfig config;
-  CHECK(proto_ns::TextFormat::ParseFromString(R"(
+  ABSL_CHECK(proto_ns::TextFormat::ParseFromString(R"(
       input_stream: 'in_a'
       node {
         calculator: 'mediapipe.nested_ns.ProcessCallbackCalculator'

mediapipe/framework/calculator_node.cc

@@ -19,6 +19,7 @@
 #include <unordered_map>
 #include <utility>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/memory/memory.h"
 #include "absl/status/status.h"
@@ -60,7 +61,7 @@ const PacketType* GetPacketType(const PacketTypeSet& packet_type_set,
   } else {
     id = packet_type_set.GetId(tag, 0);
   }
-  CHECK(id.IsValid()) << "Internal mediapipe error.";
+  ABSL_CHECK(id.IsValid()) << "Internal mediapipe error.";
   return &packet_type_set.Get(id);
 }
 
@@ -342,7 +343,7 @@ absl::Status CalculatorNode::ConnectShardsToStreams(
 
 void CalculatorNode::SetExecutor(const std::string& executor) {
   absl::MutexLock status_lock(&status_mutex_);
-  CHECK_LT(status_, kStateOpened);
+  ABSL_CHECK_LT(status_, kStateOpened);
   executor_ = executor;
 }
 
@@ -367,7 +368,7 @@ bool CalculatorNode::Closed() const {
 }
 
 void CalculatorNode::SetMaxInputStreamQueueSize(int max_queue_size) {
-  CHECK(input_stream_handler_);
+  ABSL_CHECK(input_stream_handler_);
   input_stream_handler_->SetMaxQueueSize(max_queue_size);
 }
 
@@ -540,7 +541,7 @@ absl::Status CalculatorNode::OpenNode() {
 
 void CalculatorNode::ActivateNode() {
   absl::MutexLock status_lock(&status_mutex_);
-  CHECK_EQ(status_, kStateOpened) << DebugName();
+  ABSL_CHECK_EQ(status_, kStateOpened) << DebugName();
   status_ = kStateActive;
 }
 
@@ -695,8 +696,8 @@ void CalculatorNode::InputStreamHeadersReady() {
   bool ready_for_open = false;
   {
     absl::MutexLock lock(&status_mutex_);
-    CHECK_EQ(status_, kStatePrepared) << DebugName();
+    ABSL_CHECK_EQ(status_, kStatePrepared) << DebugName();
-    CHECK(!input_stream_headers_ready_called_);
+    ABSL_CHECK(!input_stream_headers_ready_called_);
     input_stream_headers_ready_called_ = true;
     input_stream_headers_ready_ = true;
     ready_for_open = input_side_packets_ready_;
@@ -710,8 +711,8 @@ void CalculatorNode::InputSidePacketsReady() {
   bool ready_for_open = false;
   {
     absl::MutexLock lock(&status_mutex_);
-    CHECK_EQ(status_, kStatePrepared) << DebugName();
+    ABSL_CHECK_EQ(status_, kStatePrepared) << DebugName();
-    CHECK(!input_side_packets_ready_called_);
+    ABSL_CHECK(!input_side_packets_ready_called_);
     input_side_packets_ready_called_ = true;
     input_side_packets_ready_ = true;
     ready_for_open = input_stream_headers_ready_;
@@ -761,7 +762,7 @@ void CalculatorNode::EndScheduling() {
       return;
     }
     --current_in_flight_;
-    CHECK_GE(current_in_flight_, 0);
+    ABSL_CHECK_GE(current_in_flight_, 0);
 
     if (scheduling_state_ == kScheduling) {
       // Changes the state to scheduling pending if another thread is doing the
@@ -791,7 +792,7 @@ std::string CalculatorNode::DebugInputStreamNames() const {
 }
 
 std::string CalculatorNode::DebugName() const {
-  DCHECK(calculator_state_);
+  ABSL_DCHECK(calculator_state_);
   return calculator_state_->NodeName();
 }
 
@@ -894,7 +895,7 @@ absl::Status CalculatorNode::ProcessNode(
         // open input streams for Process(). So this node needs to be closed
         // too.
         // If the streams are closed, there shouldn't be more input.
-        CHECK_EQ(calculator_context_manager_.NumberOfContextTimestamps(
+        ABSL_CHECK_EQ(calculator_context_manager_.NumberOfContextTimestamps(
                           *calculator_context),
                       1);
         return CloseNode(absl::OkStatus(), /*graph_run_ended=*/false);
@@ -911,7 +912,7 @@ absl::Status CalculatorNode::ProcessNode(
 void CalculatorNode::SetQueueSizeCallbacks(
     InputStreamManager::QueueSizeCallback becomes_full_callback,
     InputStreamManager::QueueSizeCallback becomes_not_full_callback) {
-  CHECK(input_stream_handler_);
+  ABSL_CHECK(input_stream_handler_);
   input_stream_handler_->SetQueueSizeCallbacks(
       std::move(becomes_full_callback), std::move(becomes_not_full_callback));
 }

mediapipe/framework/calculator_node_test.cc

@@ -18,6 +18,7 @@
 
 #include <memory>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/memory/memory.h"
 #include "mediapipe/framework/calculator_framework.h"
@@ -104,7 +105,7 @@ class CalculatorNodeTest : public ::testing::Test {
   void ReadyForOpen(int* count) { ++(*count); }
 
   void Notification(CalculatorContext* cc, int* count) {
-    CHECK(cc);
+    ABSL_CHECK(cc);
     cc_ = cc;
     ++(*count);
   }

mediapipe/framework/calculator_runner.cc

@@ -16,6 +16,7 @@
 
 #include "mediapipe/framework/calculator_runner.h"
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/memory/memory.h"
 #include "absl/strings/str_cat.h"
@@ -139,7 +140,7 @@ CalculatorRunner::CalculatorRunner(const std::string& calculator_type,
 #if !defined(MEDIAPIPE_PROTO_LITE)
 CalculatorRunner::CalculatorRunner(const std::string& node_config_string) {
   CalculatorGraphConfig::Node node_config;
-  CHECK(
+  ABSL_CHECK(
       proto_ns::TextFormat::ParseFromString(node_config_string, &node_config));
   MEDIAPIPE_CHECK_OK(InitializeFromNodeConfig(node_config));
 }
@@ -149,8 +150,8 @@ CalculatorRunner::CalculatorRunner(const std::string& calculator_type,
                                    int num_inputs, int num_outputs,
                                    int num_side_packets) {
   node_config_.set_calculator(calculator_type);
-  CHECK(proto_ns::TextFormat::ParseFromString(options_string,
+  ABSL_CHECK(proto_ns::TextFormat::ParseFromString(
-                                              node_config_.mutable_options()));
+      options_string, node_config_.mutable_options()));
   SetNumInputs(num_inputs);
   SetNumOutputs(num_outputs);
   SetNumInputSidePackets(num_side_packets);
@@ -188,7 +189,7 @@ void CalculatorRunner::SetNumInputSidePackets(int n) {
 }
 
 void CalculatorRunner::InitializeInputs(const tool::TagAndNameInfo& info) {
-  CHECK(graph_ == nullptr);
+  ABSL_CHECK(graph_ == nullptr);
   MEDIAPIPE_CHECK_OK(
       tool::SetFromTagAndNameInfo(info, node_config_.mutable_input_stream()));
   inputs_.reset(new StreamContentsSet(info));
@@ -196,7 +197,7 @@ void CalculatorRunner::InitializeInputs(const tool::TagAndNameInfo& info) {
 }
 
 void CalculatorRunner::InitializeOutputs(const tool::TagAndNameInfo& info) {
-  CHECK(graph_ == nullptr);
+  ABSL_CHECK(graph_ == nullptr);
   MEDIAPIPE_CHECK_OK(
       tool::SetFromTagAndNameInfo(info, node_config_.mutable_output_stream()));
   outputs_.reset(new StreamContentsSet(info));
@@ -205,7 +206,7 @@ void CalculatorRunner::InitializeOutputs(const tool::TagAndNameInfo& info) {
 
 void CalculatorRunner::InitializeInputSidePackets(
     const tool::TagAndNameInfo& info) {
-  CHECK(graph_ == nullptr);
+  ABSL_CHECK(graph_ == nullptr);
   MEDIAPIPE_CHECK_OK(tool::SetFromTagAndNameInfo(
       info, node_config_.mutable_input_side_packet()));
   input_side_packets_.reset(new PacketSet(info));

mediapipe/framework/calculator_state.cc

@@ -18,6 +18,7 @@
 
 #include <string>
 
+#include "absl/log/absl_check.h"
 #include "absl/strings/str_cat.h"
 #include "mediapipe/framework/port/logging.h"
 
@@ -46,23 +47,23 @@ void CalculatorState::ResetBetweenRuns() {
 }
 
 void CalculatorState::SetInputSidePackets(const PacketSet* input_side_packets) {
-  CHECK(input_side_packets);
+  ABSL_CHECK(input_side_packets);
   input_side_packets_ = input_side_packets;
 }
 
 void CalculatorState::SetOutputSidePackets(
     OutputSidePacketSet* output_side_packets) {
-  CHECK(output_side_packets);
+  ABSL_CHECK(output_side_packets);
   output_side_packets_ = output_side_packets;
 }
 
 Counter* CalculatorState::GetCounter(const std::string& name) {
-  CHECK(counter_factory_);
+  ABSL_CHECK(counter_factory_);
   return counter_factory_->GetCounter(absl::StrCat(NodeName(), "-", name));
 }
 
 CounterFactory* CalculatorState::GetCounterFactory() {
-  CHECK(counter_factory_);
+  ABSL_CHECK(counter_factory_);
   return counter_factory_;
 }
 

mediapipe/framework/collection.h

@@ -24,6 +24,7 @@
 #include <vector>
 
 #include "absl/base/macros.h"
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/memory/memory.h"
 #include "absl/strings/str_cat.h"
@@ -413,16 +414,16 @@ bool Collection<T, storage, ErrorHandler>::UsesTags() const {
 template <typename T, CollectionStorage storage, typename ErrorHandler>
 typename Collection<T, storage, ErrorHandler>::value_type&
 Collection<T, storage, ErrorHandler>::Get(CollectionItemId id) {
-  CHECK_LE(BeginId(), id);
+  ABSL_CHECK_LE(BeginId(), id);
-  CHECK_LT(id, EndId());
+  ABSL_CHECK_LT(id, EndId());
   return begin()[id.value()];
 }
 
 template <typename T, CollectionStorage storage, typename ErrorHandler>
 const typename Collection<T, storage, ErrorHandler>::value_type&
 Collection<T, storage, ErrorHandler>::Get(CollectionItemId id) const {
-  CHECK_LE(BeginId(), id);
+  ABSL_CHECK_LE(BeginId(), id);
-  CHECK_LT(id, EndId());
+  ABSL_CHECK_LT(id, EndId());
   return begin()[id.value()];
 }
 
@@ -433,8 +434,8 @@ Collection<T, storage, ErrorHandler>::GetPtr(CollectionItemId id) {
                 "mediapipe::internal::Collection<T>::GetPtr() is only "
                 "available for collections that were defined with template "
                 "argument storage == CollectionStorage::kStorePointer.");
-  CHECK_LE(BeginId(), id);
+  ABSL_CHECK_LE(BeginId(), id);
-  CHECK_LT(id, EndId());
+  ABSL_CHECK_LT(id, EndId());
   return data_[id.value()];
 }
 
@@ -445,8 +446,8 @@ Collection<T, storage, ErrorHandler>::GetPtr(CollectionItemId id) const {
                 "mediapipe::internal::Collection<T>::GetPtr() is only "
                 "available for collections that were defined with template "
                 "argument storage == CollectionStorage::kStorePointer.");
-  CHECK_LE(BeginId(), id);
+  ABSL_CHECK_LE(BeginId(), id);
-  CHECK_LT(id, EndId());
+  ABSL_CHECK_LT(id, EndId());
   return data_[id.value()];
 }
 

mediapipe/framework/deps/BUILD

@@ -78,8 +78,8 @@ cc_library(
     visibility = ["//visibility:public"],
     deps = [
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
-        "@com_google_absl//absl/log:check",
         "@com_google_absl//absl/synchronization",
         "@com_google_absl//absl/time",
     ],
@@ -132,8 +132,8 @@ cc_library(
         "//mediapipe/framework/port",
         "//mediapipe/framework/port:integral_types",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
-        "@com_google_absl//absl/log:check",
     ],
 )
 
@@ -151,7 +151,10 @@ cc_library(
 
     # Use this library through "mediapipe/framework/port:map_util".
     visibility = ["//mediapipe/framework/port:__pkg__"],
-    deps = ["//mediapipe/framework/port:logging"],
+    deps = [
+        "//mediapipe/framework/port:logging",
+        "@com_google_absl//absl/log:absl_check",
+    ],
 )
 
 cc_library(
@@ -162,7 +165,7 @@ cc_library(
     ],
     deps = [
         "//mediapipe/framework/port:integral_types",
-        "//mediapipe/framework/port:logging",
+        "@com_google_absl//absl/log:absl_check",
     ],
 )
 
@@ -235,8 +238,8 @@ cc_library(
         "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/container:flat_hash_set",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
-        "@com_google_absl//absl/log:check",
         "@com_google_absl//absl/meta:type_traits",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/synchronization",
@@ -347,6 +350,7 @@ cc_library(
     deps = [
         ":thread_options",
         "//mediapipe/framework/port:logging",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/synchronization",
@@ -362,6 +366,7 @@ cc_library(
     visibility = ["//mediapipe/framework/port:__pkg__"],
     deps = [
         "//mediapipe/framework/port:logging",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
     ],
 )
@@ -374,7 +379,7 @@ cc_library(
     visibility = ["//mediapipe/framework/port:__pkg__"],
     deps = [
         "//mediapipe/framework/port:integral_types",
-        "//mediapipe/framework/port:logging",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/utility",
     ],
 )

mediapipe/framework/deps/map_util.h

@@ -27,6 +27,7 @@
 #include <type_traits>
 #include <utility>
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/framework/port/logging.h"
 
 namespace mediapipe {
@@ -53,7 +54,7 @@ template <typename M>
 const typename M::value_type::second_type& FindOrDie(
     const M& m, const typename M::value_type::first_type& key) {
   auto it = m.find(key);
-  CHECK(it != m.end()) << "Map key not found: " << key;
+  ABSL_CHECK(it != m.end()) << "Map key not found: " << key;
   return it->second;
 }
 
@@ -63,7 +64,7 @@ typename M::value_type::second_type& FindOrDie(
     M& m,  // NOLINT
     const typename M::value_type::first_type& key) {
   auto it = m.find(key);
-  CHECK(it != m.end()) << "Map key not found: " << key;
+  ABSL_CHECK(it != m.end()) << "Map key not found: " << key;
   return it->second;
 }
 
@@ -138,7 +139,7 @@ bool InsertIfNotPresent(M* m, const typename M::value_type::first_type& key,
 // inserted.
 template <typename M, typename ReverseM>
 bool ReverseMap(const M& m, ReverseM* reverse) {
-  CHECK(reverse != nullptr);
+  ABSL_CHECK(reverse != nullptr);
   for (const auto& kv : m) {
     if (!InsertIfNotPresent(reverse, kv.second, kv.first)) {
       return false;

mediapipe/framework/deps/mathutil.h

@@ -23,8 +23,8 @@
 #include <limits>
 #include <type_traits>
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/framework/port/integral_types.h"
-#include "mediapipe/framework/port/logging.h"
 
 namespace mediapipe {
 
@@ -354,7 +354,7 @@ class MathUtil {
   template <typename T>  // T models LessThanComparable.
   static const T& Clamp(const T& low, const T& high, const T& value) {
     // Prevents errors in ordering the arguments.
-    DCHECK(!(high < low));
+    ABSL_DCHECK(!(high < low));
     if (high < value) return high;
     if (value < low) return low;
     return value;
@@ -364,7 +364,7 @@ class MathUtil {
   // absolute margin of error.
   template <typename T>
   static bool WithinMargin(const T x, const T y, const T margin) {
-    DCHECK_GE(margin, 0);
+    ABSL_DCHECK_GE(margin, 0);
     return (std::abs(x) <= std::abs(y) + margin) &&
            (std::abs(x) >= std::abs(y) - margin);
   }

mediapipe/framework/deps/monotonic_clock.cc

@@ -16,8 +16,8 @@
 
 #include "absl/base/macros.h"
 #include "absl/base/thread_annotations.h"
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
-#include "absl/log/check.h"
 #include "absl/synchronization/mutex.h"
 #include "absl/time/time.h"
 
@@ -61,7 +61,7 @@ class MonotonicClockImpl : public MonotonicClock {
 
   // Absolve this object of responsibility for state_.
   void ReleaseState() {
-    CHECK(state_owned_);
+    ABSL_CHECK(state_owned_);
     state_owned_ = false;
   }
 
@@ -81,7 +81,7 @@ class MonotonicClockImpl : public MonotonicClock {
       absl::MutexLock m(&state_->lock);
 
       // Check consistency of internal data with state_.
-      CHECK_LE(last_raw_time_, state_->max_time)
+      ABSL_CHECK_LE(last_raw_time_, state_->max_time)
           << "non-monotonic behavior: last_raw_time_=" << last_raw_time_
           << ", max_time=" << state_->max_time;
 
@@ -108,7 +108,7 @@ class MonotonicClockImpl : public MonotonicClock {
       // First, update correction metrics.
       ++correction_count_;
       absl::Duration delta = state_->max_time - raw_time;
-      CHECK_LT(absl::ZeroDuration(), delta);
+      ABSL_CHECK_LT(absl::ZeroDuration(), delta);
       if (delta > max_correction_) {
         max_correction_ = delta;
       }

mediapipe/framework/deps/registration.h

@@ -28,8 +28,8 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
-#include "absl/log/check.h"
 #include "absl/meta/type_traits.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/str_split.h"
@@ -271,7 +271,7 @@ class FunctionRegistry {
     if (names[0].empty()) {
       names.erase(names.begin());
     } else {
-      CHECK_EQ(1u, names.size())
+      ABSL_CHECK_EQ(1u, names.size())
           << "A registered class name must be either fully qualified "
           << "with a leading :: or unqualified, got: " << name << ".";
     }

mediapipe/framework/deps/safe_int.h

@@ -44,8 +44,8 @@
 #include <limits>
 #include <type_traits>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
-#include "absl/log/check.h"
 #include "mediapipe/framework/deps/strong_int.h"
 
 namespace mediapipe {
@@ -68,17 +68,17 @@ class SafeIntStrongIntValidator {
     // Check that the underlying integral type provides a range that is
     // compatible with two's complement.
     if (std::numeric_limits<T>::is_signed) {
-      CHECK_EQ(-1,
+      ABSL_CHECK_EQ(
-               std::numeric_limits<T>::min() + std::numeric_limits<T>::max())
+          -1, std::numeric_limits<T>::min() + std::numeric_limits<T>::max())
           << "unexpected integral bounds";
     }
 
     // Check that division truncates towards 0 (implementation defined in
     // C++'03, but standard in C++'11).
-    CHECK_EQ(12, 127 / 10) << "division does not truncate towards 0";
+    ABSL_CHECK_EQ(12, 127 / 10) << "division does not truncate towards 0";
-    CHECK_EQ(-12, -127 / 10) << "division does not truncate towards 0";
+    ABSL_CHECK_EQ(-12, -127 / 10) << "division does not truncate towards 0";
-    CHECK_EQ(-12, 127 / -10) << "division does not truncate towards 0";
+    ABSL_CHECK_EQ(-12, 127 / -10) << "division does not truncate towards 0";
-    CHECK_EQ(12, -127 / -10) << "division does not truncate towards 0";
+    ABSL_CHECK_EQ(12, -127 / -10) << "division does not truncate towards 0";
   }
 
  public:

mediapipe/framework/deps/threadpool_pthread_impl.cc

@@ -18,6 +18,7 @@
 #include <sys/syscall.h>
 #include <unistd.h>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
@@ -49,7 +50,7 @@ ThreadPool::WorkerThread::WorkerThread(ThreadPool* pool,
                                        const std::string& name_prefix)
     : pool_(pool), name_prefix_(name_prefix) {
   int res = pthread_create(&thread_, nullptr, ThreadBody, this);
-  CHECK_EQ(res, 0) << "pthread_create failed";
+  ABSL_CHECK_EQ(res, 0) << "pthread_create failed";
 }
 
 ThreadPool::WorkerThread::~WorkerThread() {}

mediapipe/framework/deps/topologicalsorter.cc

@@ -16,17 +16,18 @@
 
 #include <algorithm>
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/framework/port/logging.h"
 
 namespace mediapipe {
 
 TopologicalSorter::TopologicalSorter(int num_nodes) : num_nodes_(num_nodes) {
-  CHECK_GE(num_nodes_, 0);
+  ABSL_CHECK_GE(num_nodes_, 0);
   adjacency_lists_.resize(num_nodes_);
 }
 
 void TopologicalSorter::AddEdge(int from, int to) {
-  CHECK(!traversal_started_ && from < num_nodes_ && to < num_nodes_ &&
+  ABSL_CHECK(!traversal_started_ && from < num_nodes_ && to < num_nodes_ &&
              from >= 0 && to >= 0);
   adjacency_lists_[from].push_back(to);
 }

mediapipe/framework/deps/vector.h

@@ -24,9 +24,9 @@
 #include <limits>
 #include <type_traits>
 
+#include "absl/log/absl_check.h"
 #include "absl/utility/utility.h"
 #include "mediapipe/framework/port/integral_types.h"
-#include "mediapipe/framework/port/logging.h"
 
 template <typename T>
 class Vector2;
@@ -78,13 +78,13 @@ class BasicVector {
   void Clear() { AsD() = D(); }
 
   T& operator[](int b) {
-    DCHECK_GE(b, 0);
+    ABSL_DCHECK_GE(b, 0);
-    DCHECK_LT(b, SIZE);
+    ABSL_DCHECK_LT(b, SIZE);
     return static_cast<D&>(*this).Data()[b];
   }
   T operator[](int b) const {
-    DCHECK_GE(b, 0);
+    ABSL_DCHECK_GE(b, 0);
-    DCHECK_LT(b, SIZE);
+    ABSL_DCHECK_LT(b, SIZE);
     return static_cast<const D&>(*this).Data()[b];
   }
 

mediapipe/framework/formats/BUILD

@@ -119,6 +119,7 @@ cc_library(
         "//mediapipe/framework/port:logging",
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
         "@eigen_archive//:eigen3",
     ],
 )
@@ -159,8 +160,8 @@ cc_library(
         "//mediapipe/framework/tool:type_util",
         "@com_google_absl//absl/base",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
-        "@com_google_absl//absl/log:check",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/strings",
     ] + select({
@@ -214,6 +215,7 @@ cc_library(
         "//mediapipe/framework/port:statusor",
         "//mediapipe/framework/tool:status_util",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/strings",
@@ -341,6 +343,7 @@ cc_library(
         "//mediapipe/framework/port:logging",
         "//mediapipe/gpu:gpu_buffer",
         "//mediapipe/gpu:gpu_buffer_format",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/synchronization",
     ] + select({
         "//conditions:default": [
@@ -365,6 +368,7 @@ cc_library(
         ":image_frame_pool",
         "//mediapipe/framework:port",
         "//mediapipe/framework/port:logging",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/synchronization",
     ] + select({
@@ -402,6 +406,7 @@ cc_library(
         "//mediapipe/framework/port:logging",
         "//mediapipe/framework/port:opencv_core",
         "//mediapipe/framework/port:statusor",
+        "@com_google_absl//absl/log:absl_check",
     ],
 )
 
@@ -488,6 +493,7 @@ cc_library(
     deps = [
         "//mediapipe/framework:port",
         "@com_google_absl//absl/container:flat_hash_map",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/synchronization",
@@ -522,7 +528,7 @@ cc_library(
     hdrs = ["frame_buffer.h"],
     deps = [
         "//mediapipe/framework/port:integral_types",
-        "@com_google_absl//absl/log:check",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
     ],

mediapipe/framework/formats/frame_buffer.h

@@ -18,7 +18,7 @@ limitations under the License.
 
 #include <vector>
 
-#include "absl/log/check.h"
+#include "absl/log/absl_check.h"
 #include "absl/status/statusor.h"
 #include "mediapipe/framework/port/integral_types.h"
 
@@ -147,15 +147,15 @@ class FrameBuffer {
 
   // Returns plane indexed by the input `index`.
   const Plane& plane(int index) const {
-    CHECK_GE(index, 0);
+    ABSL_CHECK_GE(index, 0);
-    CHECK_LT(static_cast<size_t>(index), planes_.size());
+    ABSL_CHECK_LT(static_cast<size_t>(index), planes_.size());
     return planes_[index];
   }
 
   // Returns mutable plane indexed by the input `index`.
   Plane mutable_plane(int index) {
-    CHECK_GE(index, 0);
+    ABSL_CHECK_GE(index, 0);
-    CHECK_LT(static_cast<size_t>(index), planes_.size());
+    ABSL_CHECK_LT(static_cast<size_t>(index), planes_.size());
     return planes_[index];
   }
 

mediapipe/framework/formats/image.cc

@@ -14,6 +14,7 @@
 
 #include "mediapipe/framework/formats/image.h"
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/framework/type_map.h"
 
 #if !MEDIAPIPE_DISABLE_GPU

mediapipe/framework/formats/image_frame.cc

@@ -23,8 +23,8 @@
 #include <algorithm>
 #include <utility>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
-#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "mediapipe/framework/formats/image_format.pb.h"
 #include "mediapipe/framework/port/aligned_malloc_and_free.h"
@@ -99,8 +99,8 @@ void ImageFrame::Reset(ImageFormat::Format format, int width, int height,
   format_ = format;
   width_ = width;
   height_ = height;
-  CHECK_NE(ImageFormat::UNKNOWN, format_);
+  ABSL_CHECK_NE(ImageFormat::UNKNOWN, format_);
-  CHECK(IsValidAlignmentNumber(alignment_boundary));
+  ABSL_CHECK(IsValidAlignmentNumber(alignment_boundary));
   width_step_ = width * NumberOfChannels() * ByteDepth();
   if (alignment_boundary == 1) {
     pixel_data_ = {new uint8_t[height * width_step_],
@@ -125,8 +125,8 @@ void ImageFrame::AdoptPixelData(ImageFormat::Format format, int width,
   height_ = height;
   width_step_ = width_step;
 
-  CHECK_NE(ImageFormat::UNKNOWN, format_);
+  ABSL_CHECK_NE(ImageFormat::UNKNOWN, format_);
-  CHECK_GE(width_step_, width * NumberOfChannels() * ByteDepth());
+  ABSL_CHECK_GE(width_step_, width * NumberOfChannels() * ByteDepth());
 
   pixel_data_ = {pixel_data, deleter};
 }
@@ -137,8 +137,8 @@ std::unique_ptr<uint8_t[], ImageFrame::Deleter> ImageFrame::Release() {
 
 void ImageFrame::InternalCopyFrom(int width, int height, int width_step,
                                   int channel_size, const uint8_t* pixel_data) {
-  CHECK_EQ(width_, width);
+  ABSL_CHECK_EQ(width_, width);
-  CHECK_EQ(height_, height);
+  ABSL_CHECK_EQ(height_, height);
   // row_bytes = channel_size * num_channels * width
   const int row_bytes = channel_size * NumberOfChannels() * width;
   if (width_step == 0) {
@@ -188,8 +188,8 @@ void ImageFrame::SetAlignmentPaddingAreas() {
   if (!pixel_data_) {
     return;
   }
-  CHECK_GE(width_, 1);
+  ABSL_CHECK_GE(width_, 1);
-  CHECK_GE(height_, 1);
+  ABSL_CHECK_GE(height_, 1);
 
   const int pixel_size = ByteDepth() * NumberOfChannels();
   const int padding_size = width_step_ - width_ * pixel_size;
@@ -223,7 +223,7 @@ bool ImageFrame::IsContiguous() const {
 }
 
 bool ImageFrame::IsAligned(uint32_t alignment_boundary) const {
-  CHECK(IsValidAlignmentNumber(alignment_boundary));
+  ABSL_CHECK(IsValidAlignmentNumber(alignment_boundary));
   if (!pixel_data_) {
     return false;
   }
@@ -360,7 +360,7 @@ void ImageFrame::CopyFrom(const ImageFrame& image_frame,
   Reset(image_frame.Format(), image_frame.Width(), image_frame.Height(),
         alignment_boundary);
 
-  CHECK_EQ(format_, image_frame.Format());
+  ABSL_CHECK_EQ(format_, image_frame.Format());
   InternalCopyFrom(image_frame.Width(), image_frame.Height(),
                    image_frame.WidthStep(), image_frame.ChannelSize(),
                    image_frame.PixelData());
@@ -383,10 +383,10 @@ void ImageFrame::CopyPixelData(ImageFormat::Format format, int width,
 }
 
 void ImageFrame::CopyToBuffer(uint8_t* buffer, int buffer_size) const {
-  CHECK(buffer);
+  ABSL_CHECK(buffer);
-  CHECK_EQ(1, ByteDepth());
+  ABSL_CHECK_EQ(1, ByteDepth());
   const int data_size = width_ * height_ * NumberOfChannels();
-  CHECK_LE(data_size, buffer_size);
+  ABSL_CHECK_LE(data_size, buffer_size);
   if (IsContiguous()) {
     // The data is stored contiguously, we can just copy.
     const uint8_t* src = reinterpret_cast<const uint8_t*>(pixel_data_.get());
@@ -398,10 +398,10 @@ void ImageFrame::CopyToBuffer(uint8_t* buffer, int buffer_size) const {
 }
 
 void ImageFrame::CopyToBuffer(uint16_t* buffer, int buffer_size) const {
-  CHECK(buffer);
+  ABSL_CHECK(buffer);
-  CHECK_EQ(2, ByteDepth());
+  ABSL_CHECK_EQ(2, ByteDepth());
   const int data_size = width_ * height_ * NumberOfChannels();
-  CHECK_LE(data_size, buffer_size);
+  ABSL_CHECK_LE(data_size, buffer_size);
   if (IsContiguous()) {
     // The data is stored contiguously, we can just copy.
     const uint16_t* src = reinterpret_cast<const uint16_t*>(pixel_data_.get());
@@ -413,10 +413,10 @@ void ImageFrame::CopyToBuffer(uint16_t* buffer, int buffer_size) const {
 }
 
 void ImageFrame::CopyToBuffer(float* buffer, int buffer_size) const {
-  CHECK(buffer);
+  ABSL_CHECK(buffer);
-  CHECK_EQ(4, ByteDepth());
+  ABSL_CHECK_EQ(4, ByteDepth());
   const int data_size = width_ * height_ * NumberOfChannels();
-  CHECK_LE(data_size, buffer_size);
+  ABSL_CHECK_LE(data_size, buffer_size);
   if (IsContiguous()) {
     // The data is stored contiguously, we can just copy.
     const float* src = reinterpret_cast<float*>(pixel_data_.get());

mediapipe/framework/formats/image_multi_pool.cc

@@ -16,6 +16,7 @@
 
 #include <tuple>
 
+#include "absl/log/absl_check.h"
 #include "absl/memory/memory.h"
 #include "absl/synchronization/mutex.h"
 #include "mediapipe/framework/port/logging.h"
@@ -43,7 +44,7 @@ ImageMultiPool::SimplePoolGpu ImageMultiPool::MakeSimplePoolGpu(
     IBufferSpec spec) {
   OSType cv_format = mediapipe::CVPixelFormatForGpuBufferFormat(
       GpuBufferFormatForImageFormat(spec.format));
-  CHECK_NE(cv_format, -1) << "unsupported pixel format";
+  ABSL_CHECK_NE(cv_format, -1) << "unsupported pixel format";
   return MakeCFHolderAdopting(mediapipe::CreateCVPixelBufferPool(
       spec.width, spec.height, cv_format, kKeepCount,
       0.1 /* max age in seconds */));
@@ -61,11 +62,11 @@ Image ImageMultiPool::GetBufferFromSimplePool(
   // pool to give us contiguous data.
   OSType cv_format = mediapipe::CVPixelFormatForGpuBufferFormat(
       mediapipe::GpuBufferFormatForImageFormat(spec.format));
-  CHECK_NE(cv_format, -1) << "unsupported pixel format";
+  ABSL_CHECK_NE(cv_format, -1) << "unsupported pixel format";
   CVPixelBufferRef buffer;
   CVReturn err = mediapipe::CreateCVPixelBufferWithoutPool(
       spec.width, spec.height, cv_format, &buffer);
-  CHECK(!err) << "Error creating pixel buffer: " << err;
+  ABSL_CHECK(!err) << "Error creating pixel buffer: " << err;
   return Image(MakeCFHolderAdopting(buffer));
 #else
   CVPixelBufferRef buffer;
@@ -87,7 +88,7 @@ Image ImageMultiPool::GetBufferFromSimplePool(
         }
       },
       &buffer);
-  CHECK(!err) << "Error creating pixel buffer: " << err;
+  ABSL_CHECK(!err) << "Error creating pixel buffer: " << err;
   return Image(MakeCFHolderAdopting(buffer));
 #endif  // TARGET_IPHONE_SIMULATOR
 }
@@ -188,7 +189,7 @@ Image ImageMultiPool::GetBuffer(int width, int height, bool use_gpu,
 ImageMultiPool::~ImageMultiPool() {
 #if !MEDIAPIPE_DISABLE_GPU
 #ifdef __APPLE__
-  CHECK_EQ(texture_caches_.size(), 0)
+  ABSL_CHECK_EQ(texture_caches_.size(), 0)
       << "Failed to unregister texture caches before deleting pool";
 #endif  // defined(__APPLE__)
 #endif  // !MEDIAPIPE_DISABLE_GPU
@@ -199,7 +200,7 @@ ImageMultiPool::~ImageMultiPool() {
 void ImageMultiPool::RegisterTextureCache(mediapipe::CVTextureCacheType cache) {
   absl::MutexLock lock(&mutex_gpu_);
 
-  CHECK(std::find(texture_caches_.begin(), texture_caches_.end(), cache) ==
+  ABSL_CHECK(std::find(texture_caches_.begin(), texture_caches_.end(), cache) ==
              texture_caches_.end())
       << "Attempting to register a texture cache twice";
   texture_caches_.emplace_back(cache);
@@ -210,7 +211,7 @@ void ImageMultiPool::UnregisterTextureCache(
   absl::MutexLock lock(&mutex_gpu_);
 
   auto it = std::find(texture_caches_.begin(), texture_caches_.end(), cache);
-  CHECK(it != texture_caches_.end())
+  ABSL_CHECK(it != texture_caches_.end())
       << "Attempting to unregister an unknown texture cache";
   texture_caches_.erase(it);
 }

mediapipe/framework/formats/image_opencv.cc

@@ -14,6 +14,7 @@
 
 #include "mediapipe/framework/formats/image_opencv.h"
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/framework/formats/image_format.pb.h"
 #include "mediapipe/framework/port/logging.h"
 
@@ -100,7 +101,7 @@ std::shared_ptr<cv::Mat> MatView(const mediapipe::Image* image) {
   auto owner =
       std::make_shared<MatWithPixelLock>(const_cast<mediapipe::Image*>(image));
   uint8_t* data_ptr = owner->lock.Pixels();
-  CHECK(data_ptr != nullptr);
+  ABSL_CHECK(data_ptr != nullptr);
   // Use Image to initialize in-place. Image still owns memory.
   if (steps[0] == sizes[1] * image->channels() *
                       ImageFrame::ByteDepthForFormat(image->image_format())) {

mediapipe/framework/formats/location.cc

@@ -18,6 +18,7 @@
 #include <cmath>
 #include <memory>
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/memory/memory.h"
 #include "absl/strings/substitute.h"
@@ -39,7 +40,7 @@ namespace {
 // the location_data, the tightest bounding box, that contains all pixels
 // encoded in the rasterizations.
 Rectangle_i MaskToRectangle(const LocationData& location_data) {
-  CHECK(location_data.mask().has_rasterization());
+  ABSL_CHECK(location_data.mask().has_rasterization());
   const auto& rasterization = location_data.mask().rasterization();
   if (rasterization.interval_size() == 0) {
     return Rectangle_i(0, 0, 0, 0);
@@ -63,7 +64,7 @@ Location::Location() {}
 
 Location::Location(const LocationData& location_data)
     : location_data_(location_data) {
-  CHECK(IsValidLocationData(location_data_));
+  ABSL_CHECK(IsValidLocationData(location_data_));
 }
 
 Location Location::CreateGlobalLocation() {
@@ -152,15 +153,15 @@ bool Location::IsValidLocationData(const LocationData& location_data) {
 
 template <>
 Rectangle_i Location::GetBBox<Rectangle_i>() const {
-  CHECK_EQ(LocationData::BOUNDING_BOX, location_data_.format());
+  ABSL_CHECK_EQ(LocationData::BOUNDING_BOX, location_data_.format());
   const auto& box = location_data_.bounding_box();
   return Rectangle_i(box.xmin(), box.ymin(), box.width(), box.height());
 }
 
 Location& Location::Scale(const float scale) {
-  CHECK(!location_data_.has_mask())
+  ABSL_CHECK(!location_data_.has_mask())
       << "Location mask scaling is not implemented.";
-  CHECK_GT(scale, 0.0f);
+  ABSL_CHECK_GT(scale, 0.0f);
   switch (location_data_.format()) {
     case LocationData::GLOBAL: {
       // Do nothing.
@@ -249,7 +250,7 @@ namespace {
 // This function is inteded to shift boundaries of intervals such that they
 // best fit within an image.
 float BestShift(float min_value, float max_value, float range) {
-  CHECK_LE(min_value, max_value);
+  ABSL_CHECK_LE(min_value, max_value);
   const float value_range = max_value - min_value;
   if (value_range > range) {
     return 0.5f * (range - min_value - max_value);
@@ -296,8 +297,8 @@ Location& Location::ShiftToFitBestIntoImage(int image_width, int image_height) {
       const float y_shift = BestShift(mask_bounding_box.xmin(),
                                       mask_bounding_box.xmax(), image_height);
       auto* mask = location_data_.mutable_mask();
-      CHECK_EQ(image_width, mask->width());
+      ABSL_CHECK_EQ(image_width, mask->width());
-      CHECK_EQ(image_height, mask->height());
+      ABSL_CHECK_EQ(image_height, mask->height());
       for (auto& interval :
            *mask->mutable_rasterization()->mutable_interval()) {
         interval.set_y(interval.y() + y_shift);
@@ -421,7 +422,7 @@ Rectangle_i Location::ConvertToBBox<Rectangle_i>(int image_width,
 }
 
 Rectangle_f Location::GetRelativeBBox() const {
-  CHECK_EQ(LocationData::RELATIVE_BOUNDING_BOX, location_data_.format());
+  ABSL_CHECK_EQ(LocationData::RELATIVE_BOUNDING_BOX, location_data_.format());
   const auto& box = location_data_.relative_bounding_box();
   return Rectangle_f(box.xmin(), box.ymin(), box.width(), box.height());
 }
@@ -460,7 +461,7 @@ Rectangle_f Location::ConvertToRelativeBBox(int image_width,
 
 template <>
 ::mediapipe::BoundingBox Location::GetBBox<::mediapipe::BoundingBox>() const {
-  CHECK_EQ(LocationData::BOUNDING_BOX, location_data_.format());
+  ABSL_CHECK_EQ(LocationData::BOUNDING_BOX, location_data_.format());
   const auto& box = location_data_.bounding_box();
   ::mediapipe::BoundingBox bounding_box;
   bounding_box.set_left_x(box.xmin());
@@ -483,7 +484,7 @@ template <>
 }
 
 std::vector<Point2_f> Location::GetRelativeKeypoints() const {
-  CHECK_EQ(LocationData::RELATIVE_BOUNDING_BOX, location_data_.format());
+  ABSL_CHECK_EQ(LocationData::RELATIVE_BOUNDING_BOX, location_data_.format());
   std::vector<Point2_f> keypoints;
   for (const auto& keypoint : location_data_.relative_keypoints()) {
     keypoints.emplace_back(Point2_f(keypoint.x(), keypoint.y()));

mediapipe/framework/formats/location_opencv.cc

@@ -14,6 +14,7 @@
 
 #include "mediapipe/framework/formats/location_opencv.h"
 
+#include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/memory/memory.h"
 #include "absl/strings/substitute.h"
@@ -26,7 +27,7 @@ namespace mediapipe {
 
 namespace {
 Rectangle_i MaskToRectangle(const LocationData& location_data) {
-  CHECK(location_data.mask().has_rasterization());
+  ABSL_CHECK(location_data.mask().has_rasterization());
   const auto& rasterization = location_data.mask().rasterization();
   if (rasterization.interval_size() == 0) {
     return Rectangle_i(0, 0, 0, 0);
@@ -85,7 +86,7 @@ Location CreateBBoxLocation(const cv::Rect& rect) {
 
 std::unique_ptr<cv::Mat> GetCvMask(const Location& location) {
   const auto location_data = location.ConvertToProto();
-  CHECK_EQ(LocationData::MASK, location_data.format());
+  ABSL_CHECK_EQ(LocationData::MASK, location_data.format());
   const auto& mask = location_data.mask();
   std::unique_ptr<cv::Mat> mat(
       new cv::Mat(mask.height(), mask.width(), CV_8UC1, cv::Scalar(0)));
@@ -128,7 +129,7 @@ std::unique_ptr<cv::Mat> ConvertToCvMask(const Location& location,
 }
 
 void EnlargeLocation(Location& location, const float factor) {
-  CHECK_GT(factor, 0.0f);
+  ABSL_CHECK_GT(factor, 0.0f);
   if (factor == 1.0f) return;
   auto location_data = location.ConvertToProto();
   switch (location_data.format()) {
@@ -183,7 +184,7 @@ void EnlargeLocation(Location& location, const float factor) {
 
 template <typename T>
 Location CreateCvMaskLocation(const cv::Mat_<T>& mask) {
-  CHECK_EQ(1, mask.channels())
+  ABSL_CHECK_EQ(1, mask.channels())
       << "The specified cv::Mat mask should be single-channel.";
 
   LocationData location_data;

mediapipe/framework/formats/matrix.cc

@@ -15,6 +15,7 @@
 
 #include <algorithm>
 
+#include "absl/log/absl_check.h"
 #include "mediapipe/framework/port/core_proto_inc.h"
 #include "mediapipe/framework/port/logging.h"
 #include "mediapipe/framework/port/proto_ns.h"
@@ -33,7 +34,7 @@ void MatrixDataProtoFromMatrix(const Matrix& matrix, MatrixData* matrix_data) {
 }
 
 void MatrixFromMatrixDataProto(const MatrixData& matrix_data, Matrix* matrix) {
-  CHECK_EQ(matrix_data.rows() * matrix_data.cols(),
+  ABSL_CHECK_EQ(matrix_data.rows() * matrix_data.cols(),
                 matrix_data.packed_data_size());
   if (matrix_data.layout() == MatrixData::ROW_MAJOR) {
     matrix->resize(matrix_data.cols(), matrix_data.rows());
@@ -56,9 +57,9 @@ std::string MatrixAsTextProto(const Matrix& matrix) {
 }
 
 void MatrixFromTextProto(const std::string& text_proto, Matrix* matrix) {
-  CHECK(matrix);
+  ABSL_CHECK(matrix);
   MatrixData matrix_data;
-  CHECK(proto_ns::TextFormat::ParseFromString(text_proto, &matrix_data));
+  ABSL_CHECK(proto_ns::TextFormat::ParseFromString(text_proto, &matrix_data));
   MatrixFromMatrixDataProto(matrix_data, matrix);
 }
 #endif  // !defined(MEDIAPIPE_MOBILE) && !defined(MEDIAPIPE_LITE)

mediapipe/framework/formats/motion/BUILD

@@ -43,6 +43,7 @@ cc_library(
         "//mediapipe/framework/port:point",
         "//mediapipe/framework/port:ret_check",
         "//mediapipe/framework/port:status",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/strings",
         "@org_tensorflow//tensorflow/core:framework",
@@ -62,6 +63,7 @@ cc_test(
         "//mediapipe/framework/port:gtest_main",
         "//mediapipe/framework/port:integral_types",
         "@com_google_absl//absl/flags:flag",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@org_tensorflow//tensorflow/core:framework",
     ],