generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add libjingle-style stream-style logging.

Browse Source 
Add a highly stripped-down version of libjingle's base/logging.h. It is
a thin wrapper around WEBRTC_TRACE, maintaining the libjingle log
semantics to ease a transition to that format.

Also add some helper macros for easy API and function failure logging.

Review URL: https://webrtc-codereview.appspot.com/931010

git-svn-id: http://webrtc.googlecode.com/svn/trunk@3099 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
andrew@webrtc.org 2012-11-14 19:07:54 +00:00
parent 1786436eb2
commit 50419b0777
12 changed files with 388 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
webrtc/build/common.gypi
View File

@ -91,6 +91,8 @@
# Disable the use of protocol buffers in production code.
'enable_protobuf%': 0,
'enable_tracing%': 0,
}, { # Settings for the standalone (not-in-Chromium) build.
'include_pulse_audio%': 1,
'include_internal_audio_device%': 1,
@ -98,6 +100,7 @@
'include_internal_video_render%': 1,
'include_video_engine_file_api%': 1,
'enable_protobuf%': 1,
'enable_tracing%': 1,
'include_tests%': 1,
# TODO(andrew): For now, disable the Chrome plugins, which causes a

1
webrtc/common_types.h
View File

@ -57,6 +57,7 @@ protected:
enum TraceModule
{
kTraceUndefined = 0,
// not a module, triggered from the engine code
kTraceVoice = 0x0001,
// not a module, triggered from the engine code

166
webrtc/system_wrappers/interface/logging.h Normal file
View File

@ -0,0 +1,166 @@
/*
* 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.
*/
// This is a highly stripped-down version of libjingle's talk/base/logging.h.
// It is a thin wrapper around WEBRTC_TRACE, maintaining the libjingle log
// semantics to ease a transition to that format.
// LOG(...) an ostream target that can be used to send formatted
// output to a variety of logging targets, such as debugger console, stderr,
// file, or any StreamInterface.
// The severity level passed as the first argument to the LOGging
// functions is used as a filter, to limit the verbosity of the logging.
// Static members of LogMessage documented below are used to control the
// verbosity and target of the output.
// There are several variations on the LOG macro which facilitate logging
// of common error conditions, detailed below.
// LOG(sev) logs the given stream at severity "sev", which must be a
// compile-time constant of the LoggingSeverity type, without the namespace
// prefix.
// LOG_V(sev) Like LOG(), but sev is a run-time variable of the LoggingSeverity
// type (basically, it just doesn't prepend the namespace).
// LOG_F(sev) Like LOG(), but includes the name of the current function.
// Additional helper macros added by WebRTC:
// LOG_API is a shortcut for API call logging. Pass in the input parameters of
// the method. For example:
// Foo(int bar, int baz) {
// LOG_API2(bar, baz);
// }
//
// LOG_FERR is a shortcut for logging a failed function call. For example:
// if (!Foo(bar)) {
// LOG_FERR1(WARNING, Foo, bar);
// }
#ifndef WEBRTC_SYSTEM_WRAPPERS_INTERFACE_LOGGING_H_
#define WEBRTC_SYSTEM_WRAPPERS_INTERFACE_LOGGING_H_
#include <sstream>
namespace webrtc {
//////////////////////////////////////////////////////////////////////
// Note that the non-standard LoggingSeverity aliases exist because they are
// still in broad use. The meanings of the levels are:
// LS_SENSITIVE: Information which should only be logged with the consent
// of the user, due to privacy concerns.
// LS_VERBOSE: This level is for data which we do not want to appear in the
// normal debug log, but should appear in diagnostic logs.
// LS_INFO: Chatty level used in debugging for all sorts of things, the default
// in debug builds.
// LS_WARNING: Something that may warrant investigation.
// LS_ERROR: Something that should not have occurred.
enum LoggingSeverity { LS_SENSITIVE, LS_VERBOSE, LS_INFO, LS_WARNING, LS_ERROR,
INFO = LS_INFO,
WARNING = LS_WARNING,
LERROR = LS_ERROR };
class LogMessage {
public:
LogMessage(const char* file, int line, LoggingSeverity sev);
~LogMessage();
std::ostream& stream() { return print_stream_; }
private:
// These assist in formatting some parts of the debug output.
static const char* DescribeFile(const char* file);
// The ostream that buffers the formatted message before output
std::ostringstream print_stream_;
// The severity level of this message
LoggingSeverity severity_;
};
//////////////////////////////////////////////////////////////////////
// Macros which automatically disable logging when LOGGING == 0
//////////////////////////////////////////////////////////////////////
// If LOGGING is not explicitly defined, default to enabled in debug mode
// TODO(andrew): We explictly enable here; handle in gyp instead.
#define LOGGING 1
#if !defined(LOGGING)
#if defined(_DEBUG) && !defined(NDEBUG)
#define LOGGING 1
#else
#define LOGGING 0
#endif
#endif // !defined(LOGGING)
#ifndef LOG
#if LOGGING
// The following non-obvious technique for implementation of a
// conditional log stream was stolen from google3/base/logging.h.
// This class is used to explicitly ignore values in the conditional
// logging macros. This avoids compiler warnings like "value computed
// is not used" and "statement has no effect".
class LogMessageVoidify {
public:
LogMessageVoidify() { }
// This has to be an operator with a precedence lower than << but
// higher than ?:
void operator&(std::ostream&) { }
};
#define LOG(sev) \
webrtc::LogMessage(__FILE__, __LINE__, webrtc::sev).stream()
// The _V version is for when a variable is passed in. It doesn't do the
// namespace concatination.
#define LOG_V(sev) \
webrtc::LogMessage(__FILE__, __LINE__, sev).stream()
// The _F version prefixes the message with the current function name.
#if (defined(__GNUC__) && defined(_DEBUG)) || defined(WANT_PRETTY_LOG_F)
#define LOG_F(sev) LOG(sev) << __PRETTY_FUNCTION__ << ": "
#else
#define LOG_F(sev) LOG(sev) << __FUNCTION__ << ": "
#endif
#else // !LOGGING
// Hopefully, the compiler will optimize away some of this code.
// Note: syntax of "1 ? (void)0 : LogMessage" was causing errors in g++,
// converted to "while (false)"
#define LOG(sev) \
while (false)webrtc::LogMessage(NULL, 0, webrtc::sev).stream()
#define LOG_V(sev) \
while (false) webrtc::LogMessage(NULL, 0, sev).stream()
#define LOG_F(sev) LOG(sev) << __FUNCTION__ << ": "
#endif // !LOGGING
#define LOG_API0() LOG_F(LS_INFO)
#define LOG_API1(v1) LOG_API0() << #v1 << "=" << v1
#define LOG_API2(v1, v2) LOG_API1(v1) \
<< ", " << #v2 << "=" << v2
#define LOG_API3(v1, v2, v3) LOG_API2(v1, v2) \
<< ", " << #v3 << "=" << v3
#define LOG_FERR0(sev, func) LOG(sev) << #func << " failed"
#define LOG_FERR1(sev, func, v1) LOG_FERR0(sev, func) \
<< ": " << #v1 << "=" << v1
#define LOG_FERR2(sev, func, v1, v2) LOG_FERR1(sev, func, v1) \
<< ", " << #v2 << "=" << v2
#define LOG_FERR3(sev, func, v1, v2, v3) LOG_FERR2(sev, func, v1, v2) \
<< ", " << #v3 << "=" << v3
#endif // LOG
} // namespace webrtc
#endif // WEBRTC_SYSTEM_WRAPPERS_INTERFACE_LOGGING_H_

13
webrtc/system_wrappers/interface/trace.h
View File

@ -8,9 +8,9 @@
* be found in the AUTHORS file in the root of the source tree.
*/
// System independant wrapper for logging runtime information to file.
// System independent wrapper for logging runtime information to file.
// Note: All log messages will be written to the same trace file.
// Note: If to many messages are written to file there will be a build up of
// Note: If too many messages are written to file there will be a build up of
// messages. Apply filtering to avoid that.
#ifndef WEBRTC_SYSTEM_WRAPPERS_INTERFACE_TRACE_H_
#define WEBRTC_SYSTEM_WRAPPERS_INTERFACE_TRACE_H_
@ -35,7 +35,7 @@ public:
// Specifies what type of messages should be written to the trace file. The
// filter parameter is a bitmask where each message type is enumerated by
// the TraceLevel enumerator. TODO (hellner) why is the
// the TraceLevel enumerator. TODO(hellner): why is the
// TraceLevel enumerator not defined in this file?
static WebRtc_Word32 SetLevelFilter(const WebRtc_UWord32 filter);
@ -59,17 +59,18 @@ public:
// Adds a trace message for writing to file. The message is put in a queue
// for writing to file whenever possible for performance reasons. I.e. there
// is a crash it is possible that the last, vital logs are not logged yet.
// level is the the type of message to log. If that type of messages is
// level is the type of message to log. If that type of messages is
// filtered it will not be written to file. module is an identifier for what
// part of the code the message is comming.
// part of the code the message is coming.
// id is an identifier that should be unique for that set of classes that
// are associated (e.g. all instances owned by an engine).
// msg and the elipsis are the same as e.g. sprintf.
// msg and the ellipsis are the same as e.g. sprintf.
// TODO (hellner) Why is TraceModule not defined in this file?
static void Add(const TraceLevel level,
const TraceModule module,
const WebRtc_Word32 id,
const char* msg, ...);
};
} // namespace webrtc
#endif // WEBRTC_SYSTEM_WRAPPERS_INTERFACE_TRACE_H_

14
webrtc/system_wrappers/source/condition_variable_unittest.cc
View File

@ -24,8 +24,6 @@ const int kLogTrace = false; // Set to true to enable debug logging to stdout.
const int kLongWaitMs = 100 * 1000; // A long time in testing terms
const int kShortWaitMs = 2 * 1000; // Long enough for process switches to happen
#define LOG(...) WEBRTC_TRACE(kTraceStateInfo, kTraceUtility, -1, __VA_ARGS__);
// A Baton is one possible control structure one can build using
// conditional variables.
// A Baton is always held by one and only one active thread - unlike
@ -53,15 +51,12 @@ class Baton {
// Only one process can pass at the same time; this property is
// ensured by the |giver_sect_| lock.
bool Pass(WebRtc_UWord32 max_msecs) {
LOG("Locking giver_sect");
CriticalSectionScoped cs_giver(giver_sect_);
LOG("Locked giver_sect, locking crit_sect");
CriticalSectionScoped cs(crit_sect_);
SignalBatonAvailable();
const bool result = TakeBatonIfStillFree(max_msecs);
if (result) {
++pass_count_;
LOG("Pass count is %d", pass_count_);
}
return result;
}
@ -87,9 +82,7 @@ class Baton {
// These functions must be called with crit_sect_ held.
bool WaitUntilBatonOffered(int timeout_ms) {
while (!being_passed_) {
LOG("Wait waiting");
if (!cond_var_->SleepCS(*crit_sect_, timeout_ms)) {
LOG("Wait timeout");
return false;
}
}
@ -101,7 +94,6 @@ class Baton {
void SignalBatonAvailable() {
assert(!being_passed_);
being_passed_ = true;
LOG("Signal waking");
cond_var_->Wake();
}
@ -114,7 +106,6 @@ class Baton {
bool TakeBatonIfStillFree(int timeout_ms) {
bool not_timeout = true;
while (being_passed_ && not_timeout) {
LOG("Takeback waiting");
not_timeout = cond_var_->SleepCS(*crit_sect_, timeout_ms);
// If we're woken up while variable is still held, we may have
// gotten a wakeup destined for a grabber thread.
@ -123,7 +114,6 @@ class Baton {
if (!being_passed_) {
return true;
} else {
LOG("Takeback grab");
assert(!not_timeout);
being_passed_ = false;
return false;
@ -145,10 +135,8 @@ class Baton {
// Function that waits on a Baton, and passes it right back.
// We expect these calls never to time out.
bool WaitingRunFunction(void* obj) {
Baton* the_baton = static_cast<Baton*>(obj);
LOG("Thread waiting");
Baton* the_baton = static_cast<Baton*> (obj);
EXPECT_TRUE(the_baton->Grab(kLongWaitMs));
LOG("Thread waking parent");
EXPECT_TRUE(the_baton->Pass(kLongWaitMs));
return true;
}

10
webrtc/system_wrappers/source/critical_section_unittest.cc
View File

@ -30,8 +30,6 @@ namespace {
const bool kLogTrace = false; // Set to true to enable debug logging to stdout.
#define LOG(...) WEBRTC_TRACE(kTraceStateInfo, kTraceUtility, -1, __VA_ARGS__);
// Cause a process switch. Needed to avoid depending on
// busy-wait in tests.
static void SwitchProcess() {
@ -50,7 +48,6 @@ class ProtectedCount {
void Increment() {
CriticalSectionScoped cs(crit_sect_);
++count_;
LOG("Inc to %d", count_);
}
int Count() const {
@ -79,7 +76,6 @@ class CritSectTest : public ::testing::Test {
++loop_counter;
SwitchProcess();
}
LOG("Test looped %d times\n", loop_counter);
return (count->Count() >= target);
}
@ -88,11 +84,8 @@ class CritSectTest : public ::testing::Test {
};
bool LockUnlockThenStopRunFunction(void* obj) {
LOG("Wait starting");
ProtectedCount* the_count = static_cast<ProtectedCount*> (obj);
LOG("Wait incrementing");
the_count->Increment();
LOG("Wait returning");
return false;
}
@ -119,12 +112,9 @@ TEST_F(CritSectTest, ThreadWakesOnce) {
}
bool LockUnlockRunFunction(void* obj) {
LOG("Wait starting");
ProtectedCount* the_count = static_cast<ProtectedCount*> (obj);
LOG("Wait incrementing");
the_count->Increment();
SwitchProcess();
LOG("Wait returning");
return true;
}

52
webrtc/system_wrappers/source/logging.cc Normal file
View File

@ -0,0 +1,52 @@
/*
* 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 "webrtc/system_wrappers/interface/logging.h"
#include <string.h>
#include <iostream>
#include "webrtc/common_types.h"
#include "webrtc/system_wrappers/interface/trace.h"
namespace webrtc {
static TraceLevel WebRtcSeverity(LoggingSeverity sev) {
switch (sev) {
// TODO(andrew): SENSITIVE doesn't have a corresponding webrtc level.
case LS_SENSITIVE: return kTraceInfo;
case LS_VERBOSE: return kTraceDebug;
case LS_INFO: return kTraceInfo;
case LS_WARNING: return kTraceWarning;
case LS_ERROR: return kTraceError;
default: return kTraceNone;
}
}
LogMessage::LogMessage(const char* file, int line, LoggingSeverity sev)
: severity_(sev) {
print_stream_ << "(" << DescribeFile(file) << ":" << line << "): ";
}
LogMessage::~LogMessage() {
const std::string& str = print_stream_.str();
WEBRTC_TRACE(WebRtcSeverity(severity_), kTraceUndefined, 0, str.c_str());
}
const char* LogMessage::DescribeFile(const char* file) {
const char* end1 = ::strrchr(file, '/');
const char* end2 = ::strrchr(file, '\\');
if (!end1 && !end2)
return file;
else
return (end1 > end2) ? end1 + 1 : end2 + 1;
}
} // namespace webrtc

96
webrtc/system_wrappers/source/logging_unittest.cc Normal file
View File

@ -0,0 +1,96 @@
/*
* 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 "webrtc/system_wrappers/interface/logging.h"
#include "gtest/gtest.h"
#include "webrtc/system_wrappers/interface/condition_variable_wrapper.h"
#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
#include "webrtc/system_wrappers/interface/sleep.h"
#include "webrtc/system_wrappers/interface/trace.h"
namespace webrtc {
namespace {
const size_t kBoilerplateLength = 71;
class LoggingTest : public ::testing::Test, public TraceCallback {
public:
virtual void Print(const TraceLevel level,
const char* msg,
const int length) {
CriticalSectionScoped cs(crit_.get());
// We test the length here to ensure (with high likelihood) that only our
// traces will be tested.
if (level_ != kTraceNone &&
expected_log_.str().size() == length - kBoilerplateLength - 1) {
EXPECT_EQ(level_, level);
EXPECT_EQ(expected_log_.str(), &msg[kBoilerplateLength]);
level_ = kTraceNone;
cv_->Wake();
}
}
protected:
LoggingTest()
: crit_(CriticalSectionWrapper::CreateCriticalSection()),
cv_(ConditionVariableWrapper::CreateConditionVariable()),
level_(kTraceNone),
expected_log_() {
}
void SetUp() {
Trace::CreateTrace();
Trace::SetTraceCallback(this);
// Reduce the chance that spurious traces will ruin the test.
Trace::SetLevelFilter(kTraceWarning | kTraceError);
}
void TearDown() {
CriticalSectionScoped cs(crit_.get());
Trace::SetTraceCallback(NULL);
Trace::ReturnTrace();
ASSERT_EQ(kTraceNone, level_) << "Print() was not called";
}
scoped_ptr<CriticalSectionWrapper> crit_;
scoped_ptr<ConditionVariableWrapper> cv_;
TraceLevel level_;
int length_;
std::ostringstream expected_log_;
};
TEST_F(LoggingTest, LogStream) {
{
CriticalSectionScoped cs(crit_.get());
level_ = kTraceWarning;
std::string msg = "Important message";
expected_log_ << "(logging_unittest.cc:" << __LINE__ + 1 << "): " << msg;
LOG(WARNING) << msg;
cv_->SleepCS(*crit_.get());
}
}
TEST_F(LoggingTest, LogFunctionError) {
{
CriticalSectionScoped cs(crit_.get());
int bar = 42;
int baz = 99;
level_ = kTraceError;
expected_log_ << "(logging_unittest.cc:" << __LINE__ + 2
<< "): Foo failed: bar=" << bar << ", baz=" << baz;
LOG_FERR2(LS_ERROR, Foo, bar, baz);
cv_->SleepCS(*crit_.get());
}
}
} // namespace
} // namespace webrtc

28
webrtc/system_wrappers/source/system_wrappers.gyp
View File

@ -37,6 +37,7 @@
'../interface/file_wrapper.h',
'../interface/fix_interlocked_exchange_pointer_win.h',
'../interface/list_wrapper.h',
'../interface/logging.h',
'../interface/map_wrapper.h',
'../interface/ref_count.h',
'../interface/rw_lock_wrapper.h',
@ -83,6 +84,7 @@
'file_impl.cc',
'file_impl.h',
'list_no_stl.cc',
'logging.cc',
'map.cc',
'rw_lock.cc',
'rw_lock_generic.cc',
@ -111,9 +113,23 @@
'conditions': [
['enable_data_logging==1', {
'sources!': [ 'data_log_no_op.cc', ],
},{
}, {
'sources!': [ 'data_log.cc', ],
},],
['enable_tracing==1', {
'sources!': [
'trace_impl_no_op.cc',
],
}, {
'sources!': [
'trace_impl.cc',
'trace_impl.h',
'trace_posix.cc',
'trace_posix.h',
'trace_win.cc',
'trace_win.h',
],
}],
['OS=="android"', {
'dependencies': [ 'cpu_features_android', ],
}],
@ -141,19 +157,12 @@
'cpu_linux.h',
'cpu_mac.h',
'cpu_win.h',
'trace_impl.cc',
'trace_impl.h',
'trace_posix.cc',
'trace_posix.h',
'trace_win.cc',
'trace_win.h',
],
}, {
'sources!': [
'cpu_no_op.cc',
'trace_impl_no_op.cc',
],
}]
}],
], # conditions
'target_conditions': [
# We need to do this in a target_conditions block to override the
@ -210,6 +219,7 @@
'cpu_measurement_harness.cc',
'critical_section_unittest.cc',
'list_unittest.cc',
'logging_unittest.cc',
'map_unittest.cc',
'data_log_unittest.cc',
'data_log_unittest_disabled.cc',

32
webrtc/system_wrappers/source/trace_impl.cc
View File

@ -199,6 +199,7 @@ WebRtc_Word32 TraceImpl::AddModuleAndId(char* traceMessage,
// TODO (hellner): is this actually a problem? If so, it should be better to
// clean up WebRtc_Word32
const long int idl = id;
const int kMessageLength = 25;
if(idl != -1)
{
const unsigned long int idEngine = id>>16;
@ -206,6 +207,10 @@ WebRtc_Word32 TraceImpl::AddModuleAndId(char* traceMessage,
switch (module)
{
case kTraceUndefined:
// Add the appropriate amount of whitespace.
memset(traceMessage, ' ', kMessageLength);
break;
case kTraceVoice:
sprintf(traceMessage, " VOICE:%5ld %5ld;", idEngine,
idChannel);
@ -279,6 +284,10 @@ WebRtc_Word32 TraceImpl::AddModuleAndId(char* traceMessage,
} else {
switch (module)
{
case kTraceUndefined:
// Add the appropriate amount of whitespace.
memset(traceMessage, ' ', kMessageLength);
break;
case kTraceVoice:
sprintf (traceMessage, " VOICE:%11ld;", idl);
break;
@ -332,8 +341,7 @@ WebRtc_Word32 TraceImpl::AddModuleAndId(char* traceMessage,
break;
}
}
// All messages are 25 characters.
return 25;
return kMessageLength;
}
WebRtc_Word32 TraceImpl::SetTraceFileImpl(const char* fileNameUTF8,
@ -605,44 +613,44 @@ void TraceImpl::AddImpl(const TraceLevel level, const TraceModule module,
if (TraceCheck(level))
{
char traceMessage[WEBRTC_TRACE_MAX_MESSAGE_SIZE];
char* meassagePtr = traceMessage;
char* messagePtr = traceMessage;
WebRtc_Word32 len = 0;
WebRtc_Word32 ackLen = 0;
len = AddLevel(meassagePtr, level);
len = AddLevel(messagePtr, level);
if(len == -1)
{
return;
}
meassagePtr += len;
messagePtr += len;
ackLen += len;
len = AddTime(meassagePtr, level);
len = AddTime(messagePtr, level);
if(len == -1)
{
return;
}
meassagePtr += len;
messagePtr += len;
ackLen += len;
len = AddModuleAndId(meassagePtr, module, id);
len = AddModuleAndId(messagePtr, module, id);
if(len == -1)
{
return;
}
meassagePtr += len;
messagePtr += len;
ackLen += len;
len = AddThreadId(meassagePtr);
len = AddThreadId(messagePtr);
if(len < 0)
{
return;
}
meassagePtr += len;
messagePtr += len;
ackLen += len;
len = AddMessage(meassagePtr, msg, (WebRtc_UWord16)ackLen);
len = AddMessage(messagePtr, msg, (WebRtc_UWord16)ackLen);
if(len == -1)
{
return;

51
webrtc/voice_engine/channel.cc
View File

@ -14,6 +14,7 @@
#include "audio_frame_operations.h"
#include "audio_processing.h"
#include "critical_section_wrapper.h"
#include "logging.h"
#include "output_mixer.h"
#include "process_thread.h"
#include "rtp_dump.h"
@ -29,11 +30,8 @@
#include <Qos.h>
#endif
namespace webrtc
{
namespace voe
{
namespace webrtc {
namespace voe {
WebRtc_Word32
Channel::SendData(FrameType frameType,
@ -6615,36 +6613,21 @@ Channel::RegisterReceiveCodecsToRTPModule()
}
}
int
Channel::ApmProcessRx(AudioFrame& audioFrame)
{
WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
"Channel::ApmProcessRx()");
// Register the (possibly new) frame parameters.
if (_rxAudioProcessingModulePtr->set_sample_rate_hz(
audioFrame.sample_rate_hz_) != 0)
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId,-1),
"AudioProcessingModule::set_sample_rate_hz(%u) => error",
audioFrame.sample_rate_hz_);
}
if (_rxAudioProcessingModulePtr->set_num_channels(audioFrame.num_channels_,
audioFrame.num_channels_) != 0)
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId,-1),
"AudioProcessingModule::set_num_channels(%u, %u) => error",
audioFrame.num_channels_, audioFrame.num_channels_);
}
if (_rxAudioProcessingModulePtr->ProcessStream(&audioFrame) != 0)
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId,-1),
"AudioProcessingModule::ProcessStream() => error");
}
return 0;
int Channel::ApmProcessRx(AudioFrame& frame) {
AudioProcessing* audioproc = _rxAudioProcessingModulePtr;
// Register the (possibly new) frame parameters.
if (audioproc->set_sample_rate_hz(frame.sample_rate_hz_) != 0) {
LOG_FERR1(WARNING, set_sample_rate_hz, frame.sample_rate_hz_);
}
if (audioproc->set_num_channels(frame.num_channels_,
frame.num_channels_) != 0) {
LOG_FERR1(WARNING, set_num_channels, frame.num_channels_);
}
if (audioproc->ProcessStream(&frame) != 0) {
LOG_FERR0(WARNING, ProcessStream);
}
return 0;
}
} // namespace voe
} // namespace webrtc

21
webrtc/voice_engine/voe_audio_processing_impl.cc
View File

@ -13,18 +13,13 @@
#include "audio_processing.h"
#include "channel.h"
#include "critical_section_wrapper.h"
#include "logging.h"
#include "trace.h"
#include "transmit_mixer.h"
#include "voe_errors.h"
#include "voice_engine_impl.h"
// TODO(andrew): move to a common place.
#define WEBRTC_TRACE_VOICE_API() \
do { \
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, \
VoEId(_shared->instance_id(), -1), __FUNCTION__); \
} while (0)
#define WEBRTC_VOICE_INIT_CHECK() \
do { \
if (!_shared->statistics().Initialized()) { \
@ -41,7 +36,6 @@
} \
} while (0)
namespace webrtc {
#if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
@ -353,9 +347,7 @@ int VoEAudioProcessingImpl::GetAgcConfig(AgcConfig& config) {
int VoEAudioProcessingImpl::SetRxNsStatus(int channel,
bool enable,
NsModes mode) {
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
"SetRxNsStatus(channel=%d, enable=%d, mode=%d)",
channel, (int)enable, (int)mode);
LOG_API3(channel, enable, mode);
#ifdef WEBRTC_VOICE_ENGINE_NR
if (!_shared->statistics().Initialized()) {
_shared->SetLastError(VE_NOT_INITED, kTraceError);
@ -514,7 +506,7 @@ bool VoEAudioProcessing::DriftCompensationSupported() {
}
int VoEAudioProcessingImpl::EnableDriftCompensation(bool enable) {
WEBRTC_TRACE_VOICE_API();
LOG_API1(enable);
WEBRTC_VOICE_INIT_CHECK();
if (!DriftCompensationSupported()) {
@ -533,7 +525,7 @@ int VoEAudioProcessingImpl::EnableDriftCompensation(bool enable) {
}
bool VoEAudioProcessingImpl::DriftCompensationEnabled() {
WEBRTC_TRACE_VOICE_API();
LOG_API0();
WEBRTC_VOICE_INIT_CHECK_BOOL();
EchoCancellation* aec = _shared->audio_processing()->echo_cancellation();
@ -1139,13 +1131,12 @@ int VoEAudioProcessingImpl::SetTypingDetectionParameters(int timeWindow,
}
void VoEAudioProcessingImpl::EnableStereoChannelSwapping(bool enable) {
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
"EnableStereoChannelSwapping(enable=%d)", enable);
LOG_API1(enable);
_shared->transmit_mixer()->EnableStereoChannelSwapping(enable);
}
bool VoEAudioProcessingImpl::IsStereoChannelSwappingEnabled() {
WEBRTC_TRACE_VOICE_API();
LOG_API0();
return _shared->transmit_mixer()->IsStereoChannelSwappingEnabled();
}