Remove gflags dependency for event_log_visualizer and activity_metric

webrtc/tools/agc/activity_metric.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include <algorithm>
 #include <memory>
 
-#include "gflags/gflags.h"
+#include "webrtc/base/flags.h"
 #include "webrtc/modules/audio_processing/agc/agc.h"
 #include "webrtc/modules/audio_processing/agc/loudness_histogram.h"
 #include "webrtc/modules/audio_processing/agc/utility.h"
 #include "webrtc/modules/audio_processing/vad/common.h"
 #include "webrtc/modules/audio_processing/vad/pitch_based_vad.h"
 #include "webrtc/modules/audio_processing/vad/standalone_vad.h"
 #include "webrtc/modules/audio_processing/vad/vad_audio_proc.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/test/gtest.h"
 
 static const int kAgcAnalWindowSamples = 100;
-static const double kDefaultActivityThreshold = 0.3;
+static const float kDefaultActivityThreshold = 0.3f;
 
 DEFINE_bool(standalone_vad, true, "enable stand-alone VAD");
 DEFINE_string(true_vad, "", "name of a file containing true VAD in 'int'"
               " format");
 DEFINE_string(video_vad, "", "name of a file containing video VAD (activity"
               " probabilities) in double format. One activity per 10ms is"
               " required. If no file is given the video information is not"
               " incorporated. Negative activity is interpreted as video is"
               " not adapted and the statistics are not computed during"
               " the learning phase. Note that the negative video activities"
               " are ONLY allowed at the beginning.");
 DEFINE_string(result, "", "name of a file to write the results. The results"
               " will be appended to the end of the file. This is optional.");
 DEFINE_string(audio_content, "", "name of a file where audio content is written"
               " to, in double format.");
-DEFINE_double(activity_threshold, kDefaultActivityThreshold,
+DEFINE_float(activity_threshold, kDefaultActivityThreshold,
               "Activity threshold");
+DEFINE_bool(help, false, "prints this message");
 
 namespace webrtc {
 
 // TODO(turajs) A new CL will be committed soon where ExtractFeatures will
 // notify the caller of "silence" input, instead of bailing out. We would not
 // need the following function when such a change is made.
 
 // Add some dither to quiet frames. This avoids the ExtractFeatures skip a
 // silence frame. Otherwise true VAD would drift with respect to the audio.
 // We only consider mono inputs.
@@ skipping 39 matching lines @@
                int* combined_vad) {
     if (frame.num_channels_ != 1 ||
         frame.samples_per_channel_ !=
             kSampleRateHz / 100 ||
             frame.sample_rate_hz_ != kSampleRateHz)
       return -1;
     video_vad_[video_index_++] = p_video;
     AudioFeatures features;
     audio_processing_->ExtractFeatures(
         frame.data_, frame.samples_per_channel_, &features);
-    if (FLAGS_standalone_vad) {
+    if (FLAG_standalone_vad) {
       standalone_vad_->AddAudio(frame.data_,
                                 frame.samples_per_channel_);
     }
     if (features.num_frames > 0) {
       double p[kMaxNumFrames] = {0.5, 0.5, 0.5, 0.5};
-      if (FLAGS_standalone_vad) {
+      if (FLAG_standalone_vad) {
         standalone_vad_->GetActivity(p, kMaxNumFrames);
       }
       // TODO(turajs) combining and limiting are used in the source files as
       // well they can be moved to utility.
       // Combine Video and stand-alone VAD.
       for (size_t n = 0; n < features.num_frames; n++) {
         double p_active = p[n] * video_vad_[n];
         double p_passive = (1 - p[n]) * (1 - video_vad_[n]);
         p[n]  = p_active / (p_active + p_passive);
         // Limit probabilities.
@@ skipping 43 matching lines @@
   webrtc::AgcStat agc_stat;
 
   FILE* pcm_fid = fopen(argv[1], "rb");
   ASSERT_TRUE(pcm_fid != NULL) << "Cannot open PCM file " << argv[1];
 
   if (argc < 2) {
     fprintf(stderr, "\nNot Enough arguments\n");
   }
 
   FILE* true_vad_fid = NULL;
-  ASSERT_GT(FLAGS_true_vad.size(), 0u) << "Specify the file containing true "
+  ASSERT_GT(strlen(FLAG_true_vad), 0u) << "Specify the file containing true "
       "VADs using --true_vad flag.";
-  true_vad_fid = fopen(FLAGS_true_vad.c_str(), "rb");
+  true_vad_fid = fopen(FLAG_true_vad, "rb");
   ASSERT_TRUE(true_vad_fid != NULL) << "Cannot open the active list " <<
-      FLAGS_true_vad;
+      FLAG_true_vad;
 
   FILE* results_fid = NULL;
-  if (FLAGS_result.size() > 0) {
+  if (strlen(FLAG_result) > 0) {
     // True if this is the first time writing to this function and we add a
     // header to the beginning of the file.
     bool write_header;
     // Open in the read mode. If it fails, the file doesn't exist and has to
     // write a header for it. Otherwise no need to write a header.
-    results_fid = fopen(FLAGS_result.c_str(), "r");
+    results_fid = fopen(FLAG_result, "r");
     if (results_fid == NULL) {
       write_header = true;
     } else {
       fclose(results_fid);
       write_header = false;
     }
     // Open in append mode.
-    results_fid = fopen(FLAGS_result.c_str(), "a");
+    results_fid = fopen(FLAG_result, "a");
     ASSERT_TRUE(results_fid != NULL) << "Cannot open the file, " <<
-              FLAGS_result << ", to write the results.";
+              FLAG_result << ", to write the results.";
     // Write the header if required.
     if (write_header) {
       fprintf(results_fid, "%% Total Active,  Misdetection,  "
               "Total inactive,  False Positive,  On-sets,  Missed segments,  "
               "Average response\n");
     }
   }
 
   FILE* video_vad_fid = NULL;
-  if (FLAGS_video_vad.size() > 0) {
-    video_vad_fid = fopen(FLAGS_video_vad.c_str(), "rb");
+  if (strlen(FLAG_video_vad) > 0) {
+    video_vad_fid = fopen(FLAG_video_vad, "rb");
     ASSERT_TRUE(video_vad_fid != NULL) <<  "Cannot open the file, " <<
-              FLAGS_video_vad << " to read video-based VAD decisions.\n";
+              FLAG_video_vad << " to read video-based VAD decisions.\n";
   }
 
   // AgsStat will be the owner of this file and will close it at its
   // destructor.
   FILE* audio_content_fid = NULL;
-  if (FLAGS_audio_content.size() > 0) {
-    audio_content_fid = fopen(FLAGS_audio_content.c_str(), "wb");
+  if (strlen(FLAG_audio_content) > 0) {
+    audio_content_fid = fopen(FLAG_audio_content, "wb");
     ASSERT_TRUE(audio_content_fid != NULL) << "Cannot open file, " <<
-              FLAGS_audio_content << " to write audio-content.\n";
+              FLAG_audio_content << " to write audio-content.\n";
     agc_stat.set_audio_content_file(audio_content_fid);
   }
 
   webrtc::AudioFrame frame;
   frame.num_channels_ = 1;
   frame.sample_rate_hz_ = 16000;
   frame.samples_per_channel_ = frame.sample_rate_hz_ / 100;
   const size_t kSamplesToRead = frame.num_channels_ *
       frame.samples_per_channel_;
 
-  agc_stat.SetActivityThreshold(FLAGS_activity_threshold);
+  agc_stat.SetActivityThreshold(FLAG_activity_threshold);
 
   int ret_val = 0;
   int num_frames = 0;
   int agc_vad[kMaxNumFrames];
   uint8_t true_vad[kMaxNumFrames];
   double p_video = 0.5;
   int total_active = 0;
   int total_passive = 0;
   int total_false_positive = 0;
   int total_missed_detection = 0;
@@ skipping 117 matching lines @@
     fclose(video_vad_fid);
   }
   if (results_fid != NULL) {
     fclose(results_fid);
   }
 }
 
 }  // namespace webrtc
 
 int main(int argc, char* argv[]) {
-  char kUsage[] =
+  if (argc == 1) {
+    // Print usage information.
+    std::cout <<
       "\nCompute the number of misdetected and false-positive frames. Not\n"
       " that for each frame of audio (10 ms) there should be one true\n"
       " activity. If any video-based activity is given, there should also be\n"
       " one probability per frame.\n"
+      "Run with --help for more details on available flags.\n"
       "\nUsage:\n\n"
       "activity_metric input_pcm [options]\n"
       "where 'input_pcm' is the input audio sampled at 16 kHz in 16 bits "
       "format.\n\n";
-  google::SetUsageMessage(kUsage);
-  google::ParseCommandLineFlags(&argc, &argv, true);
+    return 0;
+  }
+  rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, true);
+  if (FLAG_help) {
+    rtc::FlagList::Print(nullptr, false);
+    return 0;
+  }
   webrtc::void_main(argc, argv);
   return 0;
 }