From 12fa8f444c0e7dec42c37caee457b2f02b0e95aa Mon Sep 17 00:00:00 2001 From: kjellander Date: Wed, 17 May 2017 11:19:58 -0700 Subject: [PATCH] Remove gflags dependency for screenshare_loopback BUG=webrtc:7644 NOTRY=True Review-Url: https://codereview.webrtc.org/2888643003 Cr-Commit-Position: refs/heads/master@{#18186} --- webrtc/video/BUILD.gn | 1 - webrtc/video/screenshare_loopback.cc | 149 ++++++++++++++------------- 2 files changed, 78 insertions(+), 72 deletions(-) diff --git a/webrtc/video/BUILD.gn b/webrtc/video/BUILD.gn index 61d628ad74..3c3b17e2d2 100644 --- a/webrtc/video/BUILD.gn +++ b/webrtc/video/BUILD.gn @@ -181,7 +181,6 @@ if (rtc_include_tests) { "../test:test_common", "../test:test_renderer", "../test:test_support", - "//third_party/gflags", ] if (!build_with_chromium && is_clang) { # Suppress warnings from Chrome's Clang plugins. diff --git a/webrtc/video/screenshare_loopback.cc b/webrtc/video/screenshare_loopback.cc index 09a7d73110..46f662a45d 100644 --- a/webrtc/video/screenshare_loopback.cc +++ b/webrtc/video/screenshare_loopback.cc @@ -10,7 +10,7 @@ #include -#include "gflags/gflags.h" +#include "webrtc/base/flags.h" #include "webrtc/base/stringencode.h" #include "webrtc/test/field_trial.h" #include "webrtc/test/gtest.h" @@ -21,155 +21,155 @@ namespace webrtc { namespace flags { // Flags common with video loopback, with different default values. -DEFINE_int32(width, 1850, "Video width (crops source)."); +DEFINE_int(width, 1850, "Video width (crops source)."); size_t Width() { - return static_cast(FLAGS_width); + return static_cast(FLAG_width); } -DEFINE_int32(height, 1110, "Video height (crops source)."); +DEFINE_int(height, 1110, "Video height (crops source)."); size_t Height() { - return static_cast(FLAGS_height); + return static_cast(FLAG_height); } -DEFINE_int32(fps, 5, "Frames per second."); +DEFINE_int(fps, 5, "Frames per second."); int Fps() { - return static_cast(FLAGS_fps); + return static_cast(FLAG_fps); } -DEFINE_int32(min_bitrate, 50, "Call and stream min bitrate in kbps."); +DEFINE_int(min_bitrate, 50, "Call and stream min bitrate in kbps."); int MinBitrateKbps() { - return static_cast(FLAGS_min_bitrate); + return static_cast(FLAG_min_bitrate); } -DEFINE_int32(start_bitrate, - Call::Config::kDefaultStartBitrateBps / 1000, - "Call start bitrate in kbps."); +DEFINE_int(start_bitrate, + Call::Config::kDefaultStartBitrateBps / 1000, + "Call start bitrate in kbps."); int StartBitrateKbps() { - return static_cast(FLAGS_start_bitrate); + return static_cast(FLAG_start_bitrate); } -DEFINE_int32(target_bitrate, 200, "Stream target bitrate in kbps."); +DEFINE_int(target_bitrate, 200, "Stream target bitrate in kbps."); int TargetBitrateKbps() { - return static_cast(FLAGS_target_bitrate); + return static_cast(FLAG_target_bitrate); } -DEFINE_int32(max_bitrate, 2000, "Call and stream max bitrate in kbps."); +DEFINE_int(max_bitrate, 2000, "Call and stream max bitrate in kbps."); int MaxBitrateKbps() { - return static_cast(FLAGS_max_bitrate); + return static_cast(FLAG_max_bitrate); } -DEFINE_int32(num_temporal_layers, 2, "Number of temporal layers to use."); +DEFINE_int(num_temporal_layers, 2, "Number of temporal layers to use."); int NumTemporalLayers() { - return static_cast(FLAGS_num_temporal_layers); + return static_cast(FLAG_num_temporal_layers); } // Flags common with video loopback, with equal default values. DEFINE_string(codec, "VP8", "Video codec to use."); std::string Codec() { - return static_cast(FLAGS_codec); + return static_cast(FLAG_codec); } -DEFINE_int32(selected_tl, - -1, - "Temporal layer to show or analyze. -1 to disable filtering."); +DEFINE_int(selected_tl, + -1, + "Temporal layer to show or analyze. -1 to disable filtering."); int SelectedTL() { - return static_cast(FLAGS_selected_tl); + return static_cast(FLAG_selected_tl); } -DEFINE_int32( +DEFINE_int( duration, 0, "Duration of the test in seconds. If 0, rendered will be shown instead."); int DurationSecs() { - return static_cast(FLAGS_duration); + return static_cast(FLAG_duration); } DEFINE_string(output_filename, "", "Target graph data filename."); std::string OutputFilename() { - return static_cast(FLAGS_output_filename); + return static_cast(FLAG_output_filename); } DEFINE_string(graph_title, "", "If empty, title will be generated automatically."); std::string GraphTitle() { - return static_cast(FLAGS_graph_title); + return static_cast(FLAG_graph_title); } -DEFINE_int32(loss_percent, 0, "Percentage of packets randomly lost."); +DEFINE_int(loss_percent, 0, "Percentage of packets randomly lost."); int LossPercent() { - return static_cast(FLAGS_loss_percent); + return static_cast(FLAG_loss_percent); } -DEFINE_int32(link_capacity, - 0, - "Capacity (kbps) of the fake link. 0 means infinite."); +DEFINE_int(link_capacity, + 0, + "Capacity (kbps) of the fake link. 0 means infinite."); int LinkCapacityKbps() { - return static_cast(FLAGS_link_capacity); + return static_cast(FLAG_link_capacity); } -DEFINE_int32(queue_size, 0, "Size of the bottleneck link queue in packets."); +DEFINE_int(queue_size, 0, "Size of the bottleneck link queue in packets."); int QueueSize() { - return static_cast(FLAGS_queue_size); + return static_cast(FLAG_queue_size); } -DEFINE_int32(avg_propagation_delay_ms, - 0, - "Average link propagation delay in ms."); +DEFINE_int(avg_propagation_delay_ms, + 0, + "Average link propagation delay in ms."); int AvgPropagationDelayMs() { - return static_cast(FLAGS_avg_propagation_delay_ms); + return static_cast(FLAG_avg_propagation_delay_ms); } -DEFINE_int32(std_propagation_delay_ms, - 0, - "Link propagation delay standard deviation in ms."); +DEFINE_int(std_propagation_delay_ms, + 0, + "Link propagation delay standard deviation in ms."); int StdPropagationDelayMs() { - return static_cast(FLAGS_std_propagation_delay_ms); + return static_cast(FLAG_std_propagation_delay_ms); } -DEFINE_int32(selected_stream, 0, "ID of the stream to show or analyze."); +DEFINE_int(selected_stream, 0, "ID of the stream to show or analyze."); int SelectedStream() { - return static_cast(FLAGS_selected_stream); + return static_cast(FLAG_selected_stream); } -DEFINE_int32(num_spatial_layers, 1, "Number of spatial layers to use."); +DEFINE_int(num_spatial_layers, 1, "Number of spatial layers to use."); int NumSpatialLayers() { - return static_cast(FLAGS_num_spatial_layers); + return static_cast(FLAG_num_spatial_layers); } -DEFINE_int32(selected_sl, - -1, - "Spatial layer to show or analyze. -1 to disable filtering."); +DEFINE_int(selected_sl, + -1, + "Spatial layer to show or analyze. -1 to disable filtering."); int SelectedSL() { - return static_cast(FLAGS_selected_sl); + return static_cast(FLAG_selected_sl); } DEFINE_string(stream0, "", "Comma separated values describing VideoStream for stream #0."); std::string Stream0() { - return static_cast(FLAGS_stream0); + return static_cast(FLAG_stream0); } DEFINE_string(stream1, "", "Comma separated values describing VideoStream for stream #1."); std::string Stream1() { - return static_cast(FLAGS_stream1); + return static_cast(FLAG_stream1); } DEFINE_string(sl0, "", "Comma separated values describing SpatialLayer for layer #0."); std::string SL0() { - return static_cast(FLAGS_sl0); + return static_cast(FLAG_sl0); } DEFINE_string(sl1, "", "Comma separated values describing SpatialLayer for layer #1."); std::string SL1() { - return static_cast(FLAGS_sl1); + return static_cast(FLAG_sl1); } DEFINE_string(encoded_frame_path, @@ -177,7 +177,7 @@ DEFINE_string(encoded_frame_path, "The base path for encoded frame logs. Created files will have " "the form ..(recv|send.).ivf"); std::string EncodedFramePath() { - return static_cast(FLAGS_encoded_frame_path); + return static_cast(FLAG_encoded_frame_path); } DEFINE_bool(logs, false, "print logs to stderr"); @@ -195,24 +195,24 @@ DEFINE_string( "trials are separated by \"/\""); // Screenshare-specific flags. -DEFINE_int32(min_transmit_bitrate, 400, "Min transmit bitrate incl. padding."); +DEFINE_int(min_transmit_bitrate, 400, "Min transmit bitrate incl. padding."); int MinTransmitBitrateKbps() { - return FLAGS_min_transmit_bitrate; + return FLAG_min_transmit_bitrate; } -DEFINE_int32(slide_change_interval, - 10, - "Interval (in seconds) between simulated slide changes."); +DEFINE_int(slide_change_interval, + 10, + "Interval (in seconds) between simulated slide changes."); int SlideChangeInterval() { - return static_cast(FLAGS_slide_change_interval); + return static_cast(FLAG_slide_change_interval); } -DEFINE_int32( +DEFINE_int( scroll_duration, 0, "Duration (in seconds) during which a slide will be scrolled into place."); int ScrollDuration() { - return static_cast(FLAGS_scroll_duration); + return static_cast(FLAG_scroll_duration); } DEFINE_string(slides, @@ -220,11 +220,13 @@ DEFINE_string(slides, "Comma-separated list of *.yuv files to display as slides."); std::vector Slides() { std::vector slides; - std::string slides_list = FLAGS_slides; + std::string slides_list = FLAG_slides; rtc::tokenize(slides_list, ',', &slides); return slides; } +DEFINE_bool(help, false, "prints this message"); + } // namespace flags void Loopback() { @@ -234,7 +236,7 @@ void Loopback() { pipe_config.queue_length_packets = flags::QueueSize(); pipe_config.queue_delay_ms = flags::AvgPropagationDelayMs(); pipe_config.delay_standard_deviation_ms = flags::StdPropagationDelayMs(); - pipe_config.allow_reordering = flags::FLAGS_allow_reordering; + pipe_config.allow_reordering = flags::FLAG_allow_reordering; Call::Config::BitrateConfig call_bitrate_config; call_bitrate_config.min_bitrate_bps = flags::MinBitrateKbps() * 1000; @@ -242,7 +244,7 @@ void Loopback() { call_bitrate_config.max_bitrate_bps = flags::MaxBitrateKbps() * 1000; VideoQualityTest::Params params; - params.call = {flags::FLAGS_send_side_bwe, call_bitrate_config}; + params.call = {flags::FLAG_send_side_bwe, call_bitrate_config}; params.video = {true, flags::Width(), flags::Height(), @@ -264,7 +266,7 @@ void Loopback() { params.analyzer = {"screenshare", 0.0, 0.0, flags::DurationSecs(), flags::OutputFilename(), flags::GraphTitle()}; params.pipe = pipe_config; - params.logs = flags::FLAGS_logs; + params.logs = flags::FLAG_logs; std::vector stream_descriptors; stream_descriptors.push_back(flags::Stream0()); @@ -287,9 +289,14 @@ void Loopback() { int main(int argc, char* argv[]) { ::testing::InitGoogleTest(&argc, argv); - google::ParseCommandLineFlags(&argc, &argv, true); + rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, true); + if (webrtc::flags::FLAG_help) { + rtc::FlagList::Print(nullptr, false); + return 0; + } + webrtc::test::InitFieldTrialsFromString( - webrtc::flags::FLAGS_force_fieldtrials); + webrtc::flags::FLAG_force_fieldtrials); webrtc::test::RunTest(webrtc::Loopback); return 0; }