63fb95a68d
There was a fast path in PreprocessToAddData that would just use the input timestamps if the input format was equal to the required format of the encoder. This works well as long as the codec never changes. If we are first doing resampling (specifically upsampling) and then change to a codec that does not require resampling, we'll need to stick to whatever input timestamp we left off at, rather than silently accepting whatever we're sent. BUG=622435 Review-Url: https://codereview.webrtc.org/2119393002 Cr-Commit-Position: refs/heads/master@{#13398}
231 lines
10 KiB
C++
231 lines
10 KiB
C++
/*
|
|
* Copyright 2006 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 WEBRTC_BASE_CHECKS_H_
|
|
#define WEBRTC_BASE_CHECKS_H_
|
|
|
|
#include <sstream>
|
|
#include <string>
|
|
|
|
#include "webrtc/typedefs.h"
|
|
|
|
// The macros here print a message to stderr and abort under various
|
|
// conditions. All will accept additional stream messages. For example:
|
|
// RTC_DCHECK_EQ(foo, bar) << "I'm printed when foo != bar.";
|
|
//
|
|
// - RTC_CHECK(x) is an assertion that x is always true, and that if it isn't,
|
|
// it's better to terminate the process than to continue. During development,
|
|
// the reason that it's better to terminate might simply be that the error
|
|
// handling code isn't in place yet; in production, the reason might be that
|
|
// the author of the code truly believes that x will always be true, but that
|
|
// she recognizes that if she is wrong, abrupt and unpleasant process
|
|
// termination is still better than carrying on with the assumption violated.
|
|
//
|
|
// RTC_CHECK always evaluates its argument, so it's OK for x to have side
|
|
// effects.
|
|
//
|
|
// - RTC_DCHECK(x) is the same as RTC_CHECK(x)---an assertion that x is always
|
|
// true---except that x will only be evaluated in debug builds; in production
|
|
// builds, x is simply assumed to be true. This is useful if evaluating x is
|
|
// expensive and the expected cost of failing to detect the violated
|
|
// assumption is acceptable. You should not handle cases where a production
|
|
// build fails to spot a violated condition, even those that would result in
|
|
// crashes. If the code needs to cope with the error, make it cope, but don't
|
|
// call RTC_DCHECK; if the condition really can't occur, but you'd sleep
|
|
// better at night knowing that the process will suicide instead of carrying
|
|
// on in case you were wrong, use RTC_CHECK instead of RTC_DCHECK.
|
|
//
|
|
// RTC_DCHECK only evaluates its argument in debug builds, so if x has visible
|
|
// side effects, you need to write e.g.
|
|
// bool w = x; RTC_DCHECK(w);
|
|
//
|
|
// - RTC_CHECK_EQ, _NE, _GT, ..., and RTC_DCHECK_EQ, _NE, _GT, ... are
|
|
// specialized variants of RTC_CHECK and RTC_DCHECK that print prettier
|
|
// messages if the condition doesn't hold. Prefer them to raw RTC_CHECK and
|
|
// RTC_DCHECK.
|
|
//
|
|
// - FATAL() aborts unconditionally.
|
|
//
|
|
// TODO(ajm): Ideally, checks.h would be combined with logging.h, but
|
|
// consolidation with system_wrappers/logging.h should happen first.
|
|
|
|
namespace rtc {
|
|
|
|
// Helper macro which avoids evaluating the arguments to a stream if
|
|
// the condition doesn't hold.
|
|
#define RTC_LAZY_STREAM(stream, condition) \
|
|
!(condition) ? static_cast<void>(0) : rtc::FatalMessageVoidify() & (stream)
|
|
|
|
// The actual stream used isn't important. We reference condition in the code
|
|
// but don't evaluate it; this is to avoid "unused variable" warnings (we do so
|
|
// in a particularly convoluted way with an extra ?: because that appears to be
|
|
// the simplest construct that keeps Visual Studio from complaining about
|
|
// condition being unused).
|
|
#define RTC_EAT_STREAM_PARAMETERS(condition) \
|
|
(true ? true : !(condition)) \
|
|
? static_cast<void>(0) \
|
|
: rtc::FatalMessageVoidify() & rtc::FatalMessage("", 0).stream()
|
|
|
|
// RTC_CHECK dies with a fatal error if condition is not true. It is *not*
|
|
// controlled by NDEBUG, so the check will be executed regardless of
|
|
// compilation mode.
|
|
//
|
|
// We make sure RTC_CHECK et al. always evaluates their arguments, as
|
|
// doing RTC_CHECK(FunctionWithSideEffect()) is a common idiom.
|
|
#define RTC_CHECK(condition) \
|
|
RTC_LAZY_STREAM(rtc::FatalMessage(__FILE__, __LINE__).stream(), \
|
|
!(condition)) \
|
|
<< "Check failed: " #condition << std::endl << "# "
|
|
|
|
// Helper macro for binary operators.
|
|
// Don't use this macro directly in your code, use RTC_CHECK_EQ et al below.
|
|
//
|
|
// TODO(akalin): Rewrite this so that constructs like if (...)
|
|
// RTC_CHECK_EQ(...) else { ... } work properly.
|
|
#define RTC_CHECK_OP(name, op, val1, val2) \
|
|
if (std::string* _result = \
|
|
rtc::Check##name##Impl((val1), (val2), #val1 " " #op " " #val2)) \
|
|
rtc::FatalMessage(__FILE__, __LINE__, _result).stream()
|
|
|
|
// Build the error message string. This is separate from the "Impl"
|
|
// function template because it is not performance critical and so can
|
|
// be out of line, while the "Impl" code should be inline. Caller
|
|
// takes ownership of the returned string.
|
|
template<class t1, class t2>
|
|
std::string* MakeCheckOpString(const t1& v1, const t2& v2, const char* names) {
|
|
std::ostringstream ss;
|
|
ss << names << " (" << v1 << " vs. " << v2 << ")";
|
|
std::string* msg = new std::string(ss.str());
|
|
return msg;
|
|
}
|
|
|
|
// MSVC doesn't like complex extern templates and DLLs.
|
|
#if !defined(COMPILER_MSVC)
|
|
// Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated
|
|
// in logging.cc.
|
|
extern template std::string* MakeCheckOpString<int, int>(
|
|
const int&, const int&, const char* names);
|
|
extern template
|
|
std::string* MakeCheckOpString<unsigned long, unsigned long>(
|
|
const unsigned long&, const unsigned long&, const char* names);
|
|
extern template
|
|
std::string* MakeCheckOpString<unsigned long, unsigned int>(
|
|
const unsigned long&, const unsigned int&, const char* names);
|
|
extern template
|
|
std::string* MakeCheckOpString<unsigned int, unsigned long>(
|
|
const unsigned int&, const unsigned long&, const char* names);
|
|
extern template
|
|
std::string* MakeCheckOpString<std::string, std::string>(
|
|
const std::string&, const std::string&, const char* name);
|
|
#endif
|
|
|
|
// Helper functions for RTC_CHECK_OP macro.
|
|
// The (int, int) specialization works around the issue that the compiler
|
|
// will not instantiate the template version of the function on values of
|
|
// unnamed enum type - see comment below.
|
|
#define DEFINE_RTC_CHECK_OP_IMPL(name, op) \
|
|
template <class t1, class t2> \
|
|
inline std::string* Check##name##Impl(const t1& v1, const t2& v2, \
|
|
const char* names) { \
|
|
if (v1 op v2) \
|
|
return NULL; \
|
|
else \
|
|
return rtc::MakeCheckOpString(v1, v2, names); \
|
|
} \
|
|
inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \
|
|
if (v1 op v2) \
|
|
return NULL; \
|
|
else \
|
|
return rtc::MakeCheckOpString(v1, v2, names); \
|
|
}
|
|
DEFINE_RTC_CHECK_OP_IMPL(EQ, ==)
|
|
DEFINE_RTC_CHECK_OP_IMPL(NE, !=)
|
|
DEFINE_RTC_CHECK_OP_IMPL(LE, <=)
|
|
DEFINE_RTC_CHECK_OP_IMPL(LT, < )
|
|
DEFINE_RTC_CHECK_OP_IMPL(GE, >=)
|
|
DEFINE_RTC_CHECK_OP_IMPL(GT, > )
|
|
#undef DEFINE_RTC_CHECK_OP_IMPL
|
|
|
|
#define RTC_CHECK_EQ(val1, val2) RTC_CHECK_OP(EQ, ==, val1, val2)
|
|
#define RTC_CHECK_NE(val1, val2) RTC_CHECK_OP(NE, !=, val1, val2)
|
|
#define RTC_CHECK_LE(val1, val2) RTC_CHECK_OP(LE, <=, val1, val2)
|
|
#define RTC_CHECK_LT(val1, val2) RTC_CHECK_OP(LT, < , val1, val2)
|
|
#define RTC_CHECK_GE(val1, val2) RTC_CHECK_OP(GE, >=, val1, val2)
|
|
#define RTC_CHECK_GT(val1, val2) RTC_CHECK_OP(GT, > , val1, val2)
|
|
|
|
// The RTC_DCHECK macro is equivalent to RTC_CHECK except that it only generates
|
|
// code in debug builds. It does reference the condition parameter in all cases,
|
|
// though, so callers won't risk getting warnings about unused variables.
|
|
#if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON))
|
|
#define RTC_DCHECK_IS_ON 1
|
|
#define RTC_DCHECK(condition) RTC_CHECK(condition)
|
|
#define RTC_DCHECK_EQ(v1, v2) RTC_CHECK_EQ(v1, v2)
|
|
#define RTC_DCHECK_NE(v1, v2) RTC_CHECK_NE(v1, v2)
|
|
#define RTC_DCHECK_LE(v1, v2) RTC_CHECK_LE(v1, v2)
|
|
#define RTC_DCHECK_LT(v1, v2) RTC_CHECK_LT(v1, v2)
|
|
#define RTC_DCHECK_GE(v1, v2) RTC_CHECK_GE(v1, v2)
|
|
#define RTC_DCHECK_GT(v1, v2) RTC_CHECK_GT(v1, v2)
|
|
#else
|
|
#define RTC_DCHECK_IS_ON 0
|
|
#define RTC_DCHECK(condition) RTC_EAT_STREAM_PARAMETERS(condition)
|
|
#define RTC_DCHECK_EQ(v1, v2) RTC_EAT_STREAM_PARAMETERS((v1) == (v2))
|
|
#define RTC_DCHECK_NE(v1, v2) RTC_EAT_STREAM_PARAMETERS((v1) != (v2))
|
|
#define RTC_DCHECK_LE(v1, v2) RTC_EAT_STREAM_PARAMETERS((v1) <= (v2))
|
|
#define RTC_DCHECK_LT(v1, v2) RTC_EAT_STREAM_PARAMETERS((v1) < (v2))
|
|
#define RTC_DCHECK_GE(v1, v2) RTC_EAT_STREAM_PARAMETERS((v1) >= (v2))
|
|
#define RTC_DCHECK_GT(v1, v2) RTC_EAT_STREAM_PARAMETERS((v1) > (v2))
|
|
#endif
|
|
|
|
// This is identical to LogMessageVoidify but in name.
|
|
class FatalMessageVoidify {
|
|
public:
|
|
FatalMessageVoidify() { }
|
|
// This has to be an operator with a precedence lower than << but
|
|
// higher than ?:
|
|
void operator&(std::ostream&) { }
|
|
};
|
|
|
|
#define RTC_UNREACHABLE_CODE_HIT false
|
|
#define RTC_NOTREACHED() RTC_DCHECK(RTC_UNREACHABLE_CODE_HIT)
|
|
|
|
#define FATAL() rtc::FatalMessage(__FILE__, __LINE__).stream()
|
|
// TODO(ajm): Consider adding RTC_NOTIMPLEMENTED macro when
|
|
// base/logging.h and system_wrappers/logging.h are consolidated such that we
|
|
// can match the Chromium behavior.
|
|
|
|
// Like a stripped-down LogMessage from logging.h, except that it aborts.
|
|
class FatalMessage {
|
|
public:
|
|
FatalMessage(const char* file, int line);
|
|
// Used for RTC_CHECK_EQ(), etc. Takes ownership of the given string.
|
|
FatalMessage(const char* file, int line, std::string* result);
|
|
NO_RETURN ~FatalMessage();
|
|
|
|
std::ostream& stream() { return stream_; }
|
|
|
|
private:
|
|
void Init(const char* file, int line);
|
|
|
|
std::ostringstream stream_;
|
|
};
|
|
|
|
// Performs the integer division a/b and returns the result. CHECKs that the
|
|
// remainder is zero.
|
|
template <typename T>
|
|
inline T CheckedDivExact(T a, T b) {
|
|
RTC_CHECK_EQ(a % b, static_cast<T>(0)) << a << " is not evenly divisible by "
|
|
<< b;
|
|
return a / b;
|
|
}
|
|
|
|
} // namespace rtc
|
|
|
|
#endif // WEBRTC_BASE_CHECKS_H_
|