diff options
Diffstat (limited to 'third_party/libwebrtc/modules/remote_bitrate_estimator/test')
-rw-r--r-- | third_party/libwebrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.cc | 262 | ||||
-rw-r--r-- | third_party/libwebrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h | 360 |
2 files changed, 622 insertions, 0 deletions
diff --git a/third_party/libwebrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.cc b/third_party/libwebrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.cc new file mode 100644 index 0000000000..c8f6faa127 --- /dev/null +++ b/third_party/libwebrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.cc @@ -0,0 +1,262 @@ +/* + * Copyright (c) 2013 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 "modules/remote_bitrate_estimator/test/bwe_test_logging.h" + +#if BWE_TEST_LOGGING_COMPILE_TIME_ENABLE + +#include <inttypes.h> +#include <stdarg.h> +#include <stdio.h> + +#include <algorithm> + +#include "rtc_base/checks.h" +#include "rtc_base/platform_thread.h" +#include "rtc_base/strings/string_builder.h" + +namespace webrtc { +namespace testing { +namespace bwe { + +static std::string ToString(uint32_t v) { + rtc::StringBuilder ss; + ss << v; + return ss.Release(); +} + +Logging::ThreadState::ThreadState() = default; +Logging::ThreadState::~ThreadState() = default; + +Logging::Context::Context(uint32_t name, int64_t timestamp_ms, bool enabled) { + Logging::GetInstance()->PushState(ToString(name), timestamp_ms, enabled); +} + +Logging::Context::Context(const std::string& name, + int64_t timestamp_ms, + bool enabled) { + Logging::GetInstance()->PushState(name, timestamp_ms, enabled); +} + +Logging::Context::Context(const char* name, + int64_t timestamp_ms, + bool enabled) { + Logging::GetInstance()->PushState(name, timestamp_ms, enabled); +} + +Logging::Context::~Context() { + Logging::GetInstance()->PopState(); +} + +Logging* Logging::GetInstance() { + static Logging* logging = new Logging(); + return logging; +} + +void Logging::SetGlobalContext(uint32_t name) { + MutexLock lock(&mutex_); + thread_map_[rtc::CurrentThreadId()].global_state.tag = ToString(name); +} + +void Logging::SetGlobalContext(const std::string& name) { + MutexLock lock(&mutex_); + thread_map_[rtc::CurrentThreadId()].global_state.tag = name; +} + +void Logging::SetGlobalContext(const char* name) { + MutexLock lock(&mutex_); + thread_map_[rtc::CurrentThreadId()].global_state.tag = name; +} + +void Logging::SetGlobalEnable(bool enabled) { + MutexLock lock(&mutex_); + thread_map_[rtc::CurrentThreadId()].global_state.enabled = enabled; +} + +void Logging::Log(const char format[], ...) { + MutexLock lock(&mutex_); + ThreadMap::iterator it = thread_map_.find(rtc::CurrentThreadId()); + RTC_DCHECK(it != thread_map_.end()); + const State& state = it->second.stack.top(); + if (state.enabled) { + printf("%s\t", state.tag.c_str()); + va_list args; + va_start(args, format); + vprintf(format, args); + va_end(args); + printf("\n"); + } +} + +void Logging::Plot(int figure, const std::string& name, double value) { + Plot(figure, name, value, 0, "-"); +} + +void Logging::Plot(int figure, + const std::string& name, + double value, + uint32_t ssrc) { + Plot(figure, name, value, ssrc, "-"); +} + +void Logging::Plot(int figure, + const std::string& name, + double value, + const std::string& alg_name) { + Plot(figure, name, value, 0, alg_name); +} + +void Logging::Plot(int figure, + const std::string& name, + double value, + uint32_t ssrc, + const std::string& alg_name) { + MutexLock lock(&mutex_); + ThreadMap::iterator it = thread_map_.find(rtc::CurrentThreadId()); + RTC_DCHECK(it != thread_map_.end()); + const State& state = it->second.stack.top(); + if (state.enabled) { + printf("PLOT\t%d\t%s:%" PRIu32 "@%s\t%f\t%f\n", figure, name.c_str(), ssrc, + alg_name.c_str(), state.timestamp_ms * 0.001, value); + } +} + +void Logging::PlotBar(int figure, + const std::string& name, + double value, + int flow_id) { + MutexLock lock(&mutex_); + ThreadMap::iterator it = thread_map_.find(rtc::CurrentThreadId()); + RTC_DCHECK(it != thread_map_.end()); + const State& state = it->second.stack.top(); + if (state.enabled) { + printf("BAR\t%d\t%s_%d\t%f\n", figure, name.c_str(), flow_id, value); + } +} + +void Logging::PlotBaselineBar(int figure, + const std::string& name, + double value, + int flow_id) { + MutexLock lock(&mutex_); + ThreadMap::iterator it = thread_map_.find(rtc::CurrentThreadId()); + RTC_DCHECK(it != thread_map_.end()); + const State& state = it->second.stack.top(); + if (state.enabled) { + printf("BASELINE\t%d\t%s_%d\t%f\n", figure, name.c_str(), flow_id, value); + } +} + +void Logging::PlotErrorBar(int figure, + const std::string& name, + double value, + double ylow, + double yhigh, + const std::string& error_title, + int flow_id) { + MutexLock lock(&mutex_); + ThreadMap::iterator it = thread_map_.find(rtc::CurrentThreadId()); + RTC_DCHECK(it != thread_map_.end()); + const State& state = it->second.stack.top(); + if (state.enabled) { + printf("ERRORBAR\t%d\t%s_%d\t%f\t%f\t%f\t%s\n", figure, name.c_str(), + flow_id, value, ylow, yhigh, error_title.c_str()); + } +} + +void Logging::PlotLimitErrorBar(int figure, + const std::string& name, + double value, + double ylow, + double yhigh, + const std::string& error_title, + double ymax, + const std::string& limit_title, + int flow_id) { + MutexLock lock(&mutex_); + ThreadMap::iterator it = thread_map_.find(rtc::CurrentThreadId()); + RTC_DCHECK(it != thread_map_.end()); + const State& state = it->second.stack.top(); + if (state.enabled) { + printf("LIMITERRORBAR\t%d\t%s_%d\t%f\t%f\t%f\t%s\t%f\t%s\n", figure, + name.c_str(), flow_id, value, ylow, yhigh, error_title.c_str(), ymax, + limit_title.c_str()); + } +} + +void Logging::PlotLabel(int figure, + const std::string& title, + const std::string& y_label, + int num_flows) { + MutexLock lock(&mutex_); + ThreadMap::iterator it = thread_map_.find(rtc::CurrentThreadId()); + RTC_DCHECK(it != thread_map_.end()); + const State& state = it->second.stack.top(); + if (state.enabled) { + printf("LABEL\t%d\t%s\t%s\t%d\n", figure, title.c_str(), y_label.c_str(), + num_flows); + } +} + +Logging::Logging() : thread_map_() {} + +Logging::~Logging() = default; + +Logging::State::State() : tag(""), timestamp_ms(0), enabled(true) {} + +Logging::State::State(const std::string& tag, + int64_t timestamp_ms, + bool enabled) + : tag(tag), timestamp_ms(timestamp_ms), enabled(enabled) {} + +void Logging::State::MergePrevious(const State& previous) { + if (tag.empty()) { + tag = previous.tag; + } else if (!previous.tag.empty()) { + tag = previous.tag + "_" + tag; + } + timestamp_ms = std::max(previous.timestamp_ms, timestamp_ms); + enabled = previous.enabled && enabled; +} + +void Logging::PushState(const std::string& append_to_tag, + int64_t timestamp_ms, + bool enabled) { + MutexLock lock(&mutex_); + State new_state(append_to_tag, timestamp_ms, enabled); + ThreadState* thread_state = &thread_map_[rtc::CurrentThreadId()]; + std::stack<State>* stack = &thread_state->stack; + if (stack->empty()) { + new_state.MergePrevious(thread_state->global_state); + } else { + new_state.MergePrevious(stack->top()); + } + stack->push(new_state); +} + +void Logging::PopState() { + MutexLock lock(&mutex_); + ThreadMap::iterator it = thread_map_.find(rtc::CurrentThreadId()); + RTC_DCHECK(it != thread_map_.end()); + std::stack<State>* stack = &it->second.stack; + int64_t newest_timestamp_ms = stack->top().timestamp_ms; + stack->pop(); + if (!stack->empty()) { + State* state = &stack->top(); + // Update time so that next log/plot will use the latest time seen so far + // in this call tree. + state->timestamp_ms = std::max(state->timestamp_ms, newest_timestamp_ms); + } +} +} // namespace bwe +} // namespace testing +} // namespace webrtc + +#endif // BWE_TEST_LOGGING_COMPILE_TIME_ENABLE diff --git a/third_party/libwebrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h b/third_party/libwebrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h new file mode 100644 index 0000000000..49e1e716b2 --- /dev/null +++ b/third_party/libwebrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h @@ -0,0 +1,360 @@ +/* + * Copyright (c) 2013 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. + */ + +#ifndef MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_BWE_TEST_LOGGING_H_ +#define MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_BWE_TEST_LOGGING_H_ + +// To enable BWE logging, run this command from trunk/ : +// build/gyp_chromium --depth=. webrtc/modules/modules.gyp +// -Denable_bwe_test_logging=1 +#ifndef BWE_TEST_LOGGING_COMPILE_TIME_ENABLE +#define BWE_TEST_LOGGING_COMPILE_TIME_ENABLE 0 +#endif // BWE_TEST_LOGGING_COMPILE_TIME_ENABLE + +// BWE logging allows you to insert dynamically named log/plot points in the +// call tree. E.g. the function: +// void f1() { +// BWE_TEST_LOGGING_TIME(clock_->TimeInMilliseconds()); +// BWE_TEST_LOGGING_CONTEXT("stream"); +// for (uint32_t i=0; i<4; ++i) { +// BWE_TEST_LOGGING_ENABLE(i & 1); +// BWE_TEST_LOGGING_CONTEXT(i); +// BWE_TEST_LOGGING_LOG1("weight", "%f tonnes", weights_[i]); +// for (float j=0.0f; j<1.0; j+=0.4f) { +// BWE_TEST_LOGGING_PLOT(0, "bps", -1, j); +// } +// } +// } +// +// Might produce the output: +// stream_00000001_weight 13.000000 tonnes +// PLOT stream_00000001_bps 1.000000 0.000000 +// PLOT stream_00000001_bps 1.000000 0.400000 +// PLOT stream_00000001_bps 1.000000 0.800000 +// stream_00000003_weight 39.000000 tonnes +// PLOT stream_00000003_bps 1.000000 0.000000 +// PLOT stream_00000003_bps 1.000000 0.400000 +// PLOT stream_00000003_bps 1.000000 0.800000 +// +// Log *contexts* are names concatenated with '_' between them, with the name +// of the logged/plotted string/value last. Plot *time* is inherited down the +// tree. A branch is enabled by default but can be *disabled* to reduce output. +// The difference between the RTC_LOG and PLOT macros is that PLOT prefixes the +// line so it can be easily filtered, plus it outputs the current time. + +#if !(BWE_TEST_LOGGING_COMPILE_TIME_ENABLE) + +// Set a thread-global base logging context. This name will be prepended to all +// hierarchical contexts. +// `name` is a char*, std::string or uint32_t to name the context. +#define BWE_TEST_LOGGING_GLOBAL_CONTEXT(name) + +// Thread-globally allow/disallow logging. +// `enable` is expected to be a bool. +#define BWE_TEST_LOGGING_GLOBAL_ENABLE(enabled) + +// Insert a (hierarchical) logging context. +// `name` is a char*, std::string or uint32_t to name the context. +#define BWE_TEST_LOGGING_CONTEXT(name) + +// Allow/disallow logging down the call tree from this point. Logging must be +// enabled all the way to the root of the call tree to take place. +// `enable` is expected to be a bool. +#define BWE_TEST_LOGGING_ENABLE(enabled) + +// Set current time (only affects PLOT output). Down the call tree, the latest +// time set always takes precedence. +// `time` is an int64_t time in ms, or -1 to inherit time from previous context. +#define BWE_TEST_LOGGING_TIME(time) + +// Print to stdout, e.g.: +// Context1_Context2_Name printf-formated-string +// `name` is a char*, std::string or uint32_t to name the log line. +// `format` is a printf format string. +// |_1...| are arguments for printf. +#define BWE_TEST_LOGGING_LOG1(name, format, _1) +#define BWE_TEST_LOGGING_LOG2(name, format, _1, _2) +#define BWE_TEST_LOGGING_LOG3(name, format, _1, _2, _3) +#define BWE_TEST_LOGGING_LOG4(name, format, _1, _2, _3, _4) +#define BWE_TEST_LOGGING_LOG5(name, format, _1, _2, _3, _4, _5) + +// Print to stdout in tab-separated format suitable for plotting, e.g.: +// PLOT figure Context1_Context2_Name time value +// `figure` is a figure id. Different figures are plotted in different windows. +// `name` is a char*, std::string or uint32_t to name the plotted value. +// `time` is an int64_t time in ms, or -1 to inherit time from previous context. +// `value` is a double precision float to be plotted. +// `ssrc` identifies the source of a stream +// `alg_name` is an optional argument, a string +#define BWE_TEST_LOGGING_PLOT(figure, name, time, value) +#define BWE_TEST_LOGGING_PLOT_WITH_NAME(figure, name, time, value, alg_name) +#define BWE_TEST_LOGGING_PLOT_WITH_SSRC(figure, name, time, value, ssrc) +#define BWE_TEST_LOGGING_PLOT_WITH_NAME_AND_SSRC(figure, name, time, value, \ + ssrc, alg_name) + +// Print to stdout in tab-separated format suitable for plotting, e.g.: +// BAR figure Context1_Context2_Name x_left width value +// `figure` is a figure id. Different figures are plotted in different windows. +// `name` is a char*, std::string or uint32_t to name the plotted value. +// `value` is a double precision float to be plotted. +// `ylow` and `yhigh` are double precision float for the error line. +// `title` is a string and refers to the error label. +// `ymax` is a double precision float for the limit horizontal line. +// `limit_title` is a string and refers to the limit label. +#define BWE_TEST_LOGGING_BAR(figure, name, value, flow_id) +#define BWE_TEST_LOGGING_ERRORBAR(figure, name, value, ylow, yhigh, \ + error_title, flow_id) +#define BWE_TEST_LOGGING_LIMITERRORBAR( \ + figure, name, value, ylow, yhigh, error_title, ymax, limit_title, flow_id) + +#define BWE_TEST_LOGGING_BASELINEBAR(figure, name, value, flow_id) + +// `num_flows` is an integer refering to the number of RMCAT flows in the +// scenario. +// Define `x_label` and `y_label` for plots. +#define BWE_TEST_LOGGING_LABEL(figure, x_label, y_label, num_flows) + +#else // BWE_TEST_LOGGING_COMPILE_TIME_ENABLE + +#include <map> +#include <memory> +#include <stack> +#include <string> + +#include "rtc_base/synchronization/mutex.h" + +#define BWE_TEST_LOGGING_GLOBAL_CONTEXT(name) \ + do { \ + webrtc::testing::bwe::Logging::GetInstance()->SetGlobalContext(name); \ + } while (0) + +#define BWE_TEST_LOGGING_GLOBAL_ENABLE(enabled) \ + do { \ + webrtc::testing::bwe::Logging::GetInstance()->SetGlobalEnable(enabled); \ + } while (0) + +#define __BWE_TEST_LOGGING_CONTEXT_NAME(ctx, line) ctx##line +#define __BWE_TEST_LOGGING_CONTEXT_DECLARE(ctx, line, name, time, enabled) \ + webrtc::testing::bwe::Logging::Context __BWE_TEST_LOGGING_CONTEXT_NAME( \ + ctx, line)(name, time, enabled) + +#define BWE_TEST_LOGGING_CONTEXT(name) \ + __BWE_TEST_LOGGING_CONTEXT_DECLARE(__bwe_log_, __LINE__, name, -1, true) +#define BWE_TEST_LOGGING_ENABLE(enabled) \ + __BWE_TEST_LOGGING_CONTEXT_DECLARE(__bwe_log_, __LINE__, "", -1, \ + static_cast<bool>(enabled)) +#define BWE_TEST_LOGGING_TIME(time) \ + __BWE_TEST_LOGGING_CONTEXT_DECLARE(__bwe_log_, __LINE__, "", \ + static_cast<int64_t>(time), true) + +#define BWE_TEST_LOGGING_LOG1(name, format, _1) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->Log(format, _1); \ + } while (0) +#define BWE_TEST_LOGGING_LOG2(name, format, _1, _2) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->Log(format, _1, _2); \ + } while (0) +#define BWE_TEST_LOGGING_LOG3(name, format, _1, _2, _3) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->Log(format, _1, _2, _3); \ + } while (0) +#define BWE_TEST_LOGGING_LOG4(name, format, _1, _2, _3, _4) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->Log(format, _1, _2, _3, _4); \ + } while (0) +#define BWE_TEST_LOGGING_LOG5(name, format, _1, _2, _3, _4, _5) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->Log(format, _1, _2, _3, _4, \ + _5); \ + } while (0) + +#define BWE_TEST_LOGGING_PLOT(figure, name, time, value) \ + do { \ + __BWE_TEST_LOGGING_CONTEXT_DECLARE(__bwe_log_, __PLOT__, name, \ + static_cast<int64_t>(time), true); \ + webrtc::testing::bwe::Logging::GetInstance()->Plot(figure, name, value); \ + } while (0) + +#define BWE_TEST_LOGGING_PLOT_WITH_NAME(figure, name, time, value, alg_name) \ + do { \ + __BWE_TEST_LOGGING_CONTEXT_DECLARE(__bwe_log_, __PLOT__, name, \ + static_cast<int64_t>(time), true); \ + webrtc::testing::bwe::Logging::GetInstance()->Plot(figure, name, value, \ + alg_name); \ + } while (0) + +#define BWE_TEST_LOGGING_PLOT_WITH_SSRC(figure, name, time, value, ssrc) \ + do { \ + __BWE_TEST_LOGGING_CONTEXT_DECLARE(__bwe_log_, __PLOT__, name, \ + static_cast<int64_t>(time), true); \ + webrtc::testing::bwe::Logging::GetInstance()->Plot(figure, name, value, \ + ssrc); \ + } while (0) + +#define BWE_TEST_LOGGING_PLOT_WITH_NAME_AND_SSRC(figure, name, time, value, \ + ssrc, alg_name) \ + do { \ + __BWE_TEST_LOGGING_CONTEXT_DECLARE(__bwe_log_, __PLOT__, name, \ + static_cast<int64_t>(time), true); \ + webrtc::testing::bwe::Logging::GetInstance()->Plot(figure, name, value, \ + ssrc, alg_name); \ + } while (0) + +#define BWE_TEST_LOGGING_BAR(figure, name, value, flow_id) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->PlotBar(figure, name, value, \ + flow_id); \ + } while (0) + +#define BWE_TEST_LOGGING_BASELINEBAR(figure, name, value, flow_id) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->PlotBaselineBar( \ + figure, name, value, flow_id); \ + } while (0) + +#define BWE_TEST_LOGGING_ERRORBAR(figure, name, value, ylow, yhigh, title, \ + flow_id) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->PlotErrorBar( \ + figure, name, value, ylow, yhigh, title, flow_id); \ + } while (0) + +#define BWE_TEST_LOGGING_LIMITERRORBAR( \ + figure, name, value, ylow, yhigh, error_title, ymax, limit_title, flow_id) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(name); \ + webrtc::testing::bwe::Logging::GetInstance()->PlotLimitErrorBar( \ + figure, name, value, ylow, yhigh, error_title, ymax, limit_title, \ + flow_id); \ + } while (0) + +#define BWE_TEST_LOGGING_LABEL(figure, title, y_label, num_flows) \ + do { \ + BWE_TEST_LOGGING_CONTEXT(title); \ + webrtc::testing::bwe::Logging::GetInstance()->PlotLabel( \ + figure, title, y_label, num_flows); \ + } while (0) + +namespace webrtc { +namespace testing { +namespace bwe { + +class Logging { + public: + class Context { + public: + Context(uint32_t name, int64_t timestamp_ms, bool enabled); + Context(const std::string& name, int64_t timestamp_ms, bool enabled); + Context(const char* name, int64_t timestamp_ms, bool enabled); + + Context() = delete; + Context(const Context&) = delete; + Context& operator=(const Context&) = delete; + ~Context(); + }; + + static Logging* GetInstance(); + + void SetGlobalContext(uint32_t name); + void SetGlobalContext(const std::string& name); + void SetGlobalContext(const char* name); + void SetGlobalEnable(bool enabled); + +#if defined(__GNUC__) + // Note: Implicit `this` argument counts as the first argument. + __attribute__((__format__(__printf__, 2, 3))) +#endif + void + Log(const char format[], ...); + void Plot(int figure, const std::string& name, double value); + void Plot(int figure, + const std::string& name, + double value, + const std::string& alg_name); + void Plot(int figure, const std::string& name, double value, uint32_t ssrc); + void Plot(int figure, + const std::string& name, + double value, + uint32_t ssrc, + const std::string& alg_name); + void PlotBar(int figure, const std::string& name, double value, int flow_id); + void PlotBaselineBar(int figure, + const std::string& name, + double value, + int flow_id); + void PlotErrorBar(int figure, + const std::string& name, + double value, + double ylow, + double yhigh, + const std::string& error_title, + int flow_id); + + void PlotLimitErrorBar(int figure, + const std::string& name, + double value, + double ylow, + double yhigh, + const std::string& error_title, + double ymax, + const std::string& limit_title, + int flow_id); + void PlotLabel(int figure, + const std::string& title, + const std::string& y_label, + int num_flows); + + private: + struct State { + State(); + State(const std::string& new_tag, int64_t timestamp_ms, bool enabled); + void MergePrevious(const State& previous); + + std::string tag; + int64_t timestamp_ms; + bool enabled; + }; + struct ThreadState { + ThreadState(); + ~ThreadState(); + State global_state; + std::stack<State> stack; + }; + typedef std::map<uint32_t, ThreadState> ThreadMap; + + Logging(); + ~Logging(); + + Logging(const Logging&) = delete; + Logging& operator=(const Logging&) = delete; + + void PushState(const std::string& append_to_tag, + int64_t timestamp_ms, + bool enabled); + void PopState(); + + Mutex mutex_; + ThreadMap thread_map_; +}; +} // namespace bwe +} // namespace testing +} // namespace webrtc + +#endif // BWE_TEST_LOGGING_COMPILE_TIME_ENABLE +#endif // MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_BWE_TEST_LOGGING_H_ |