blob: 429f8ed2ad73fc5a9eaaa76fcda120f5cb52c699 [file] [log] [blame]
/*
* Copyright (c) 2018 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 LOGGING_RTC_EVENT_LOG_ENCODER_RTC_EVENT_LOG_ENCODER_COMMON_H_
#define LOGGING_RTC_EVENT_LOG_ENCODER_RTC_EVENT_LOG_ENCODER_COMMON_H_
#include <stdint.h>
#include <limits>
#include <type_traits>
namespace webrtc {
// Convert between the packet fraction loss (a floating point number in
// the range [0.0, 1.0]), and a uint32_t with up to a fixed number of bits.
// The latter can be more efficiently stored in a protobuf and/or delta-encoded.
uint32_t ConvertPacketLossFractionToProtoFormat(float packet_loss_fraction);
bool ParsePacketLossFractionFromProtoFormat(uint32_t proto_packet_loss_fraction,
float* output);
} // namespace webrtc
namespace webrtc_event_logging {
// Produce an unsigned representation of a signed integer. On two's complement
// machines, this is equivalent to:
// static_cast<uint64_t>(static_cast<std::make_unsigned<T>>(y))
template <typename T>
uint64_t ToUnsigned(T y) {
static_assert(std::is_integral<T>::value, "");
static_assert(std::is_signed<T>::value, "");
// Note that a signed integer whose width is N bits, has N-1 digits.
static_assert(std::numeric_limits<T>::digits < 64, "");
constexpr T MIN_T = std::numeric_limits<T>::min();
constexpr T MAX_T = std::numeric_limits<T>::max();
static_assert(MAX_T + MIN_T + 1 >= 0, "MAX_T >= abs(MIN_T) - 1");
if (y >= 0) {
return static_cast<uint64_t>(y);
} else {
// y is in the range [MIN_T, -1], so (y - MIN_T) is in the
// range [0, abs(MIN_T) - 1]. This is representable in a T
// because MAX_T >= abs(MIN_T) - 1, as per the static_assert above.
return static_cast<uint64_t>(MAX_T) + 1 + static_cast<uint64_t>(y - MIN_T);
}
}
// Assuming x = ToUnsigned(y), return |y|.
// Note: static_cast<T>(x) would work on most platforms and compilers, but
// involves undefined behavior. This function is well-defined, and can be
// optimized to a noop for 64 bit types, or a few arithmetic
// instructions and a single conditional jump for narrower types.
template <typename T>
bool ToSigned(uint64_t x, T* y) {
static_assert(std::is_integral<T>::value, "");
static_assert(std::is_signed<T>::value, "");
// Note that a signed integer whose width is N bits, has N-1 digits.
static_assert(std::numeric_limits<T>::digits < 64, "");
constexpr T MIN_T = std::numeric_limits<T>::min();
constexpr T MAX_T = std::numeric_limits<T>::max();
using UNSIGNED_T = typename std::make_unsigned<T>::type;
constexpr auto MAX_UNSIGNED_T = std::numeric_limits<UNSIGNED_T>::max();
if (x > static_cast<uint64_t>(MAX_UNSIGNED_T)) {
return false; // |x| cannot be represented using a T.
}
if (x <= static_cast<uint64_t>(MAX_T)) {
// The original value was positive, so it is safe to just static_cast.
*y = static_cast<T>(x);
} else { // x > static_cast<uint64_t>(MAX_T)
const uint64_t neg_x = x - static_cast<uint64_t>(MAX_T) - 1;
*y = static_cast<T>(neg_x) + MIN_T;
}
return true;
}
} // namespace webrtc_event_logging
#endif // LOGGING_RTC_EVENT_LOG_ENCODER_RTC_EVENT_LOG_ENCODER_COMMON_H_