From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- dom/media/webrtc/common/CandidateInfo.h | 27 ++ dom/media/webrtc/common/CommonTypes.h | 52 +++ dom/media/webrtc/common/EncodingConstraints.h | 58 +++ dom/media/webrtc/common/MediaEngineWrapper.h | 32 ++ dom/media/webrtc/common/NullDeleter.h | 14 + dom/media/webrtc/common/NullTransport.h | 56 +++ dom/media/webrtc/common/Wrapper.h | 157 ++++++++ dom/media/webrtc/common/YuvStamper.cpp | 394 +++++++++++++++++++++ dom/media/webrtc/common/YuvStamper.h | 77 ++++ dom/media/webrtc/common/browser_logging/CSFLog.cpp | 85 +++++ dom/media/webrtc/common/browser_logging/CSFLog.h | 58 +++ .../webrtc/common/browser_logging/WebRtcLog.cpp | 162 +++++++++ .../webrtc/common/browser_logging/WebRtcLog.h | 17 + dom/media/webrtc/common/csf_common.h | 90 +++++ dom/media/webrtc/common/moz.build | 23 ++ dom/media/webrtc/common/time_profiling/timecard.c | 112 ++++++ dom/media/webrtc/common/time_profiling/timecard.h | 74 ++++ 17 files changed, 1488 insertions(+) create mode 100644 dom/media/webrtc/common/CandidateInfo.h create mode 100644 dom/media/webrtc/common/CommonTypes.h create mode 100644 dom/media/webrtc/common/EncodingConstraints.h create mode 100644 dom/media/webrtc/common/MediaEngineWrapper.h create mode 100644 dom/media/webrtc/common/NullDeleter.h create mode 100644 dom/media/webrtc/common/NullTransport.h create mode 100644 dom/media/webrtc/common/Wrapper.h create mode 100644 dom/media/webrtc/common/YuvStamper.cpp create mode 100644 dom/media/webrtc/common/YuvStamper.h create mode 100644 dom/media/webrtc/common/browser_logging/CSFLog.cpp create mode 100644 dom/media/webrtc/common/browser_logging/CSFLog.h create mode 100644 dom/media/webrtc/common/browser_logging/WebRtcLog.cpp create mode 100644 dom/media/webrtc/common/browser_logging/WebRtcLog.h create mode 100644 dom/media/webrtc/common/csf_common.h create mode 100644 dom/media/webrtc/common/moz.build create mode 100644 dom/media/webrtc/common/time_profiling/timecard.c create mode 100644 dom/media/webrtc/common/time_profiling/timecard.h (limited to 'dom/media/webrtc/common') diff --git a/dom/media/webrtc/common/CandidateInfo.h b/dom/media/webrtc/common/CandidateInfo.h new file mode 100644 index 0000000000..eb5b2ea299 --- /dev/null +++ b/dom/media/webrtc/common/CandidateInfo.h @@ -0,0 +1,27 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef _CANDIDATE_INFO_H__ +#define _CANDIDATE_INFO_H__ + +#include +#include + +namespace mozilla { + +// This is used both by IPDL code, and by signaling code. +struct CandidateInfo { + std::string mCandidate; + std::string mMDNSAddress; + std::string mActualAddress; + std::string mUfrag; + std::string mDefaultHostRtp; + uint16_t mDefaultPortRtp = 0; + std::string mDefaultHostRtcp; + uint16_t mDefaultPortRtcp = 0; +}; + +} // namespace mozilla + +#endif //_CANDIDATE_INFO_H__ diff --git a/dom/media/webrtc/common/CommonTypes.h b/dom/media/webrtc/common/CommonTypes.h new file mode 100644 index 0000000000..e9c9ffdefc --- /dev/null +++ b/dom/media/webrtc/common/CommonTypes.h @@ -0,0 +1,52 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#pragma once + +#include + +namespace csf { + +namespace ProviderStateEnum { +enum ProviderState { + Ready, + Registering, + AwaitingIpAddress, + FetchingDeviceConfig, + Idle, + RecoveryPending, + Connected +}; +const std::string toString(ProviderState); +} // namespace ProviderStateEnum +namespace LoginErrorStatusEnum { +enum LoginErrorStatus { + Ok, // No Error + Unknown, // Unknown Error + NoCallManagerConfigured, // No Primary or Backup Call Manager + NoDevicesFound, // No devices + NoCsfDevicesFound, // Devices but none of type CSF + PhoneConfigGenError, // Could not generate phone config + SipProfileGenError, // Could not build SIP profile + ConfigNotSet, // Config not set before calling login() + CreateConfigProviderFailed, // Could not create ConfigProvider + CreateSoftPhoneProviderFailed, // Could not create SoftPhoneProvider + MissingUsername, // Username argument missing, + ManualLogout, // logout() has been called + LoggedInElseWhere, // Another process has the mutex indicating it is logged + // in + AuthenticationFailure, // Authentication failure (probably bad password, but + // best not to say for sure) + CtiCouldNotConnect, // Could not connect to CTI service + InvalidServerSearchList +}; +const std::string toString(LoginErrorStatus); +} // namespace LoginErrorStatusEnum + +namespace ErrorCodeEnum { +enum ErrorCode { Ok, Unknown, InvalidState, InvalidArgument }; +const std::string toString(ErrorCode); +} // namespace ErrorCodeEnum + +} // namespace csf diff --git a/dom/media/webrtc/common/EncodingConstraints.h b/dom/media/webrtc/common/EncodingConstraints.h new file mode 100644 index 0000000000..0bfa7f9f75 --- /dev/null +++ b/dom/media/webrtc/common/EncodingConstraints.h @@ -0,0 +1,58 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef _ENCODING_CONSTRAINTS_H_ +#define _ENCODING_CONSTRAINTS_H_ + +#include +#include "mozilla/Maybe.h" + +namespace mozilla { +class EncodingConstraints { + public: + EncodingConstraints() + : maxWidth(0), + maxHeight(0), + maxFs(0), + maxBr(0), + maxPps(0), + maxMbps(0), + maxCpb(0), + maxDpb(0), + scaleDownBy(1.0) {} + + bool operator==(const EncodingConstraints& constraints) const { + return maxWidth == constraints.maxWidth && + maxHeight == constraints.maxHeight && maxFps == constraints.maxFps && + maxFs == constraints.maxFs && maxBr == constraints.maxBr && + maxPps == constraints.maxPps && maxMbps == constraints.maxMbps && + maxCpb == constraints.maxCpb && maxDpb == constraints.maxDpb && + scaleDownBy == constraints.scaleDownBy; + } + + /** + * This returns true if the constraints affecting resolution are equal. + */ + bool ResolutionEquals(const EncodingConstraints& constraints) const { + return maxWidth == constraints.maxWidth && + maxHeight == constraints.maxHeight && maxFs == constraints.maxFs && + scaleDownBy == constraints.scaleDownBy; + } + + uint32_t maxWidth; + uint32_t maxHeight; + Maybe maxFps; + uint32_t maxFs; + uint32_t maxBr; + uint32_t maxPps; + uint32_t maxMbps; // macroblocks per second + uint32_t maxCpb; // coded picture buffer size + uint32_t maxDpb; // decoded picture buffer size + double scaleDownBy; // To preserve resolution +}; +} // namespace mozilla + +#endif // _ENCODING_CONSTRAINTS_H_ diff --git a/dom/media/webrtc/common/MediaEngineWrapper.h b/dom/media/webrtc/common/MediaEngineWrapper.h new file mode 100644 index 0000000000..ba48ad57d8 --- /dev/null +++ b/dom/media/webrtc/common/MediaEngineWrapper.h @@ -0,0 +1,32 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef MEDIA_ENGINE_WRAPPER_H_ +#define MEDIA_ENGINE_WRAPPER_H_ + +#include + +namespace mozilla { +/** + * A Custom scoped template to release a resoure of Type T + * with a function of Type F + * ScopedCustomReleasePtr ptr = + * webrtc::VoENetwork->GetInterface(voiceEngine); + * + */ +template +struct ScopedCustomReleaseTraits0 { + typedef T* type; + static T* empty() { return nullptr; } + static void release(T* ptr) { + if (ptr) { + (ptr)->Release(); + } + } +}; + +SCOPED_TEMPLATE(ScopedCustomReleasePtr, ScopedCustomReleaseTraits0) +} // namespace mozilla + +#endif diff --git a/dom/media/webrtc/common/NullDeleter.h b/dom/media/webrtc/common/NullDeleter.h new file mode 100644 index 0000000000..76326c197e --- /dev/null +++ b/dom/media/webrtc/common/NullDeleter.h @@ -0,0 +1,14 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#pragma once + +/* + * Helper class to allow smart pointers to stack objects to be constructed for + * ease of unit testing. Recycled here to help expose a shared_ptr interface to + * objects which are really raw pointers. + */ +struct null_deleter { + void operator()(void const*) const {} +}; diff --git a/dom/media/webrtc/common/NullTransport.h b/dom/media/webrtc/common/NullTransport.h new file mode 100644 index 0000000000..a9b270c6d6 --- /dev/null +++ b/dom/media/webrtc/common/NullTransport.h @@ -0,0 +1,56 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef NULL_TRANSPORT_H_ +#define NULL_TRANSPORT_H_ + +#include "mozilla/Attributes.h" + +#include "api/call/transport.h" + +namespace mozilla { + +/** + * NullTransport is registered as ExternalTransport to throw away data + */ +class NullTransport : public webrtc::Transport { + public: + virtual bool SendRtp(const uint8_t* packet, size_t length, + const webrtc::PacketOptions& options) override { + (void)packet; + (void)length; + (void)options; + return true; + } + + virtual bool SendRtcp(const uint8_t* packet, size_t length) override { + (void)packet; + (void)length; + return true; + } +#if 0 + virtual int SendPacket(int channel, const void *data, size_t len) + { + (void) channel; (void) data; + return len; + } + + virtual int SendRTCPPacket(int channel, const void *data, size_t len) + { + (void) channel; (void) data; + return len; + } +#endif + NullTransport() {} + + virtual ~NullTransport() {} + + private: + NullTransport(const NullTransport& other) = delete; + void operator=(const NullTransport& other) = delete; +}; + +} // namespace mozilla + +#endif diff --git a/dom/media/webrtc/common/Wrapper.h b/dom/media/webrtc/common/Wrapper.h new file mode 100644 index 0000000000..69c7406b07 --- /dev/null +++ b/dom/media/webrtc/common/Wrapper.h @@ -0,0 +1,157 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#pragma once + +/* + * Wrapper - Helper class for wrapper objects. + * + * This helps to construct a shared_ptr object which wraps access to an + * underlying handle. (The handle could be a pointer to some low-level type, a + * conventional C handle, an int ID, a GUID, etc.) + * + * Usage: + * To obtain a FooPtr from a foo_handle_t, call + * FooPtr Foo::wrap(foo_handle_t); + * + * To implement Foo using Wrapper, Foo needs to include this macro in its class + * definition: + * CSF_DECLARE_WRAP(Foo, foo_handle_t); + * It also needs to include this in the cpp file, to provide the wrap() + * implementation and define the static Wrapper. + * CSF_IMPLEMENT_WRAP(Foo, foo_handle_t); + * These are all declared in common/Wrapper.h - Foo.h needs to include this + * too. + * The client needs to declare Foo(foo_handle_t) as private, and provide a + * suitable implementation, as well as implementing wrappers for any other + * functions to be exposed. + * The client needs to implement ~Foo() to perform any cleanup as usual. + * + * wrap() will always return the same FooPtr for a given foo_handle_t, it will + * not construct additional objects if a suitable one already exists. + * changeHandle() is used in rare cases where the underlying handle is changed, + * but the wrapper object is intended to remain. This is the + * case for the "fake" CC_DPCall generated on + * CC_DPLine::CreateCall(), where the correct IDPCall* is + * provided later. + * reset() is a cleanup step to wipe the handle map and allow memory to be + * reclaimed. + * + * Future enhancements: + * - For now, objects remain in the map forever. Better would be to add a + * releaseHandle() function which would allow the map to be emptied as + * underlying handles expired. While we can't force the client to give up + * its shared_ptr objects, we can remove our own copy, for instance on a + * call ended event. + */ + +#include +#include "prlock.h" +#include "mozilla/Assertions.h" + +/* + * Wrapper has its own autolock class because the instances are declared + * statically and mozilla::Mutex will not work properly when instantiated + * in a static constructor. + */ + +class LockNSPR { + public: + LockNSPR() : lock_(nullptr) { + lock_ = PR_NewLock(); + MOZ_ASSERT(lock_); + } + ~LockNSPR() { PR_DestroyLock(lock_); } + + void Acquire() { PR_Lock(lock_); } + + void Release() { PR_Unlock(lock_); } + + private: + PRLock* lock_; +}; + +class AutoLockNSPR { + public: + explicit AutoLockNSPR(LockNSPR& lock) : lock_(lock) { lock_.Acquire(); } + ~AutoLockNSPR() { lock_.Release(); } + + private: + LockNSPR& lock_; +}; + +template +class Wrapper { + private: + typedef std::map HandleMapType; + HandleMapType handleMap; + LockNSPR handleMapMutex; + + public: + Wrapper() {} + + typename T::Ptr wrap(typename T::Handle handle) { + AutoLockNSPR lock(handleMapMutex); + typename HandleMapType::iterator it = handleMap.find(handle); + if (it != handleMap.end()) { + return it->second; + } else { + typename T::Ptr p(new T(handle)); + handleMap[handle] = p; + return p; + } + } + + bool changeHandle(typename T::Handle oldHandle, + typename T::Handle newHandle) { + AutoLockNSPR lock(handleMapMutex); + typename HandleMapType::iterator it = handleMap.find(oldHandle); + if (it != handleMap.end()) { + typename T::Ptr p = it->second; + handleMap.erase(it); + handleMap[newHandle] = p; + return true; + } else { + return false; + } + } + + bool release(typename T::Handle handle) { + AutoLockNSPR lock(handleMapMutex); + typename HandleMapType::iterator it = handleMap.find(handle); + if (it != handleMap.end()) { + handleMap.erase(it); + return true; + } else { + return false; + } + } + + void reset() { + AutoLockNSPR lock(handleMapMutex); + handleMap.clear(); + } +}; + +#define CSF_DECLARE_WRAP(classname, handletype) \ + public: \ + static classname##Ptr wrap(handletype handle); \ + static void reset(); \ + static void release(handletype handle); \ + \ + private: \ + friend class Wrapper; \ + typedef classname##Ptr Ptr; \ + typedef handletype Handle; \ + static Wrapper& getWrapper() { \ + static Wrapper wrapper; \ + return wrapper; \ + } + +#define CSF_IMPLEMENT_WRAP(classname, handletype) \ + classname##Ptr classname::wrap(handletype handle) { \ + return getWrapper().wrap(handle); \ + } \ + void classname::reset() { getWrapper().reset(); } \ + void classname::release(handletype handle) { getWrapper().release(handle); } diff --git a/dom/media/webrtc/common/YuvStamper.cpp b/dom/media/webrtc/common/YuvStamper.cpp new file mode 100644 index 0000000000..b0c8426983 --- /dev/null +++ b/dom/media/webrtc/common/YuvStamper.cpp @@ -0,0 +1,394 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifdef HAVE_NETINET_IN_H +# include +#elif defined XP_WIN +# include +#endif +#include + +#include "nspr.h" +#include "YuvStamper.h" +#include "mozilla/Sprintf.h" + +typedef uint32_t UINT4; // Needed for r_crc32() call +extern "C" { +#include "r_crc32.h" +} + +namespace mozilla { + +#define ON_5 0x20 +#define ON_4 0x10 +#define ON_3 0x08 +#define ON_2 0x04 +#define ON_1 0x02 +#define ON_0 0x01 + +/* + 0, 0, 1, 1, 0, 0, + 0, 1, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 1, + 1, 0, 0, 0, 0, 1, + 1, 0, 0, 0, 0, 1, + 0, 1, 0, 0, 1, 0, + 0, 0, 1, 1, 0, 0 +*/ +static unsigned char DIGIT_0[] = {ON_3 | ON_2, ON_4 | ON_1, ON_5 | ON_0, + ON_5 | ON_0, ON_5 | ON_0, ON_4 | ON_1, + ON_3 | ON_2}; + +/* + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, +*/ +static unsigned char DIGIT_1[] = {ON_2, ON_2, ON_2, ON_2, ON_2, ON_2, ON_2}; + +/* + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 1, + 0, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, +*/ +static unsigned char DIGIT_2[] = { + ON_5 | ON_4 | ON_3 | ON_2 | ON_1, ON_0, ON_0, + ON_4 | ON_3 | ON_2 | ON_1, ON_5, ON_5, + ON_4 | ON_3 | ON_2 | ON_1 | ON_0, +}; + +/* + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 1, + 0, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 1, + 1, 1, 1, 1, 1, 0, +*/ +static unsigned char DIGIT_3[] = { + ON_5 | ON_4 | ON_3 | ON_2 | ON_1, ON_0, ON_0, + ON_4 | ON_3 | ON_2 | ON_1 | ON_0, ON_0, ON_0, + ON_5 | ON_4 | ON_3 | ON_2 | ON_1, +}; + +/* + 0, 1, 0, 0, 0, 1, + 0, 1, 0, 0, 0, 1, + 0, 1, 0, 0, 0, 1, + 0, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 1 +*/ +static unsigned char DIGIT_4[] = { + ON_4 | ON_0, ON_4 | ON_0, ON_4 | ON_0, ON_4 | ON_3 | ON_2 | ON_1 | ON_0, + ON_0, ON_0, ON_0, +}; + +/* + 0, 1, 1, 1, 1, 1, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 1, + 1, 1, 1, 1, 1, 0, +*/ +static unsigned char DIGIT_5[] = { + ON_4 | ON_3 | ON_2 | ON_1 | ON_0, ON_5, ON_5, + ON_4 | ON_3 | ON_2 | ON_1, ON_0, ON_0, + ON_5 | ON_4 | ON_3 | ON_2 | ON_1, +}; + +/* + 0, 1, 1, 1, 1, 1, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 1, + 1, 0, 0, 0, 0, 1, + 0, 1, 1, 1, 1, 0, +*/ +static unsigned char DIGIT_6[] = { + ON_4 | ON_3 | ON_2 | ON_1 | ON_0, ON_5, ON_5, + ON_4 | ON_3 | ON_2 | ON_1, ON_5 | ON_0, ON_5 | ON_0, + ON_4 | ON_3 | ON_2 | ON_1, +}; + +/* + 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0 +*/ +static unsigned char DIGIT_7[] = {ON_5 | ON_4 | ON_3 | ON_2 | ON_1 | ON_0, + ON_0, + ON_1, + ON_2, + ON_3, + ON_4, + ON_5}; + +/* + 0, 1, 1, 1, 1, 1, + 1, 0, 0, 0, 0, 1, + 1, 0, 0, 0, 0, 1, + 0, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 1, + 1, 0, 0, 0, 0, 1, + 0, 1, 1, 1, 1, 0 +*/ +static unsigned char DIGIT_8[] = { + ON_4 | ON_3 | ON_2 | ON_1, ON_5 | ON_0, ON_5 | ON_0, + ON_4 | ON_3 | ON_2 | ON_1, ON_5 | ON_0, ON_5 | ON_0, + ON_4 | ON_3 | ON_2 | ON_1, +}; + +/* + 0, 1, 1, 1, 1, 1, + 1, 0, 0, 0, 0, 1, + 1, 0, 0, 0, 0, 1, + 0, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 1, + 0, 1, 1, 1, 1, 0 +*/ +static unsigned char DIGIT_9[] = { + ON_4 | ON_3 | ON_2 | ON_1 | ON_0, ON_5 | ON_0, ON_5 | ON_0, + ON_4 | ON_3 | ON_2 | ON_1 | ON_0, ON_0, ON_0, + ON_4 | ON_3 | ON_2 | ON_1, +}; + +static unsigned char* DIGITS[] = {DIGIT_0, DIGIT_1, DIGIT_2, DIGIT_3, DIGIT_4, + DIGIT_5, DIGIT_6, DIGIT_7, DIGIT_8, DIGIT_9}; + +YuvStamper::YuvStamper(unsigned char* pYData, uint32_t width, uint32_t height, + uint32_t stride, uint32_t x, uint32_t y, + unsigned char symbol_width, unsigned char symbol_height) + : pYData(pYData), + mStride(stride), + mWidth(width), + mHeight(height), + mSymbolWidth(symbol_width), + mSymbolHeight(symbol_height), + mCursor(x, y) {} + +bool YuvStamper::Encode(uint32_t width, uint32_t height, uint32_t stride, + unsigned char* pYData, unsigned char* pMsg, + size_t msg_len, uint32_t x, uint32_t y) { + YuvStamper stamper(pYData, width, height, stride, x, y, sBitSize, sBitSize); + + // Reserve space for a checksum. + if (stamper.Capacity() < 8 * (msg_len + sizeof(uint32_t))) { + return false; + } + + bool ok = false; + uint32_t crc; + unsigned char* pCrc = reinterpret_cast(&crc); + r_crc32(reinterpret_cast(pMsg), (int)msg_len, &crc); + crc = htonl(crc); + + while (msg_len-- > 0) { + if (!stamper.Write8(*pMsg++)) { + return false; + } + } + + // Add checksum after the message. + ok = stamper.Write8(*pCrc++) && stamper.Write8(*pCrc++) && + stamper.Write8(*pCrc++) && stamper.Write8(*pCrc++); + + return ok; +} + +bool YuvStamper::Decode(uint32_t width, uint32_t height, uint32_t stride, + unsigned char* pYData, unsigned char* pMsg, + size_t msg_len, uint32_t x, uint32_t y) { + YuvStamper stamper(pYData, width, height, stride, x, y, sBitSize, sBitSize); + + unsigned char* ptr = pMsg; + size_t len = msg_len; + uint32_t crc, msg_crc; + unsigned char* pCrc = reinterpret_cast(&crc); + + // Account for space reserved for the checksum + if (stamper.Capacity() < 8 * (len + sizeof(uint32_t))) { + return false; + } + + while (len-- > 0) { + if (!stamper.Read8(*ptr++)) { + return false; + } + } + + if (!(stamper.Read8(*pCrc++) && stamper.Read8(*pCrc++) && + stamper.Read8(*pCrc++) && stamper.Read8(*pCrc++))) { + return false; + } + + r_crc32(reinterpret_cast(pMsg), (int)msg_len, &msg_crc); + return crc == htonl(msg_crc); +} + +inline uint32_t YuvStamper::Capacity() { + // Enforce at least a symbol width and height offset from outer edges. + if (mCursor.y + mSymbolHeight > mHeight) { + return 0; + } + + if (mCursor.x + mSymbolWidth > mWidth && !AdvanceCursor()) { + return 0; + } + + // Normalize frame integral to mSymbolWidth x mSymbolHeight + uint32_t width = mWidth / mSymbolWidth; + uint32_t height = mHeight / mSymbolHeight; + uint32_t x = mCursor.x / mSymbolWidth; + uint32_t y = mCursor.y / mSymbolHeight; + + return (width * height - width * y) - x; +} + +bool YuvStamper::Write8(unsigned char value) { + // Encode MSB to LSB. + unsigned char mask = 0x80; + while (mask) { + if (!WriteBit(!!(value & mask))) { + return false; + } + mask >>= 1; + } + return true; +} + +bool YuvStamper::WriteBit(bool one) { + // A bit is mapped to a mSymbolWidth x mSymbolHeight square of luma data + // points. Don't use ternary op.: + // https://bugzilla.mozilla.org/show_bug.cgi?id=1001708 + unsigned char value; + if (one) + value = sYOn; + else + value = sYOff; + + for (uint32_t y = 0; y < mSymbolHeight; y++) { + for (uint32_t x = 0; x < mSymbolWidth; x++) { + *(pYData + (mCursor.x + x) + ((mCursor.y + y) * mStride)) = value; + } + } + + return AdvanceCursor(); +} + +bool YuvStamper::AdvanceCursor() { + mCursor.x += mSymbolWidth; + if (mCursor.x + mSymbolWidth > mWidth) { + // move to the start of the next row if possible. + mCursor.y += mSymbolHeight; + if (mCursor.y + mSymbolHeight > mHeight) { + // end of frame, do not advance + mCursor.y -= mSymbolHeight; + mCursor.x -= mSymbolWidth; + return false; + } else { + mCursor.x = 0; + } + } + + return true; +} + +bool YuvStamper::Read8(unsigned char& value) { + unsigned char octet = 0; + unsigned char bit = 0; + + for (int i = 8; i > 0; --i) { + if (!ReadBit(bit)) { + return false; + } + octet <<= 1; + octet |= bit; + } + + value = octet; + return true; +} + +bool YuvStamper::ReadBit(unsigned char& bit) { + uint32_t sum = 0; + for (uint32_t y = 0; y < mSymbolHeight; y++) { + for (uint32_t x = 0; x < mSymbolWidth; x++) { + sum += *(pYData + mStride * (mCursor.y + y) + mCursor.x + x); + } + } + + // apply threshold to collected bit square + bit = (sum > (sBitThreshold * mSymbolWidth * mSymbolHeight)) ? 1 : 0; + return AdvanceCursor(); +} + +bool YuvStamper::WriteDigits(uint32_t value) { + char buf[20]; + SprintfLiteral(buf, "%.5u", value); + size_t size = strlen(buf); + + if (Capacity() < size) { + return false; + } + + for (size_t i = 0; i < size; ++i) { + if (!WriteDigit(buf[i] - '0')) return false; + if (!AdvanceCursor()) { + return false; + } + } + + return true; +} + +bool YuvStamper::WriteDigit(unsigned char digit) { + if (digit > sizeof(DIGITS) / sizeof(DIGITS[0])) return false; + + unsigned char* dig = DIGITS[digit]; + for (uint32_t row = 0; row < sDigitHeight; ++row) { + unsigned char mask = 0x01 << (sDigitWidth - 1); + for (uint32_t col = 0; col < sDigitWidth; ++col, mask >>= 1) { + if (dig[row] & mask) { + for (uint32_t xx = 0; xx < sPixelSize; ++xx) { + for (uint32_t yy = 0; yy < sPixelSize; ++yy) { + WritePixel(pYData, mCursor.x + (col * sPixelSize) + xx, + mCursor.y + (row * sPixelSize) + yy); + } + } + } + } + } + + return true; +} + +void YuvStamper::WritePixel(unsigned char* data, uint32_t x, uint32_t y) { + unsigned char* ptr = &data[y * mStride + x]; + // Don't use ternary op.: https://bugzilla.mozilla.org/show_bug.cgi?id=1001708 + if (*ptr > sLumaThreshold) + *ptr = sLumaMin; + else + *ptr = sLumaMax; +} + +} // namespace mozilla. diff --git a/dom/media/webrtc/common/YuvStamper.h b/dom/media/webrtc/common/YuvStamper.h new file mode 100644 index 0000000000..f355055cd9 --- /dev/null +++ b/dom/media/webrtc/common/YuvStamper.h @@ -0,0 +1,77 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef YUV_STAMPER_H_ +#define YUV_STAMPER_H_ + +#include + +namespace mozilla { + +class YuvStamper { + public: + bool WriteDigits(uint32_t value); + + template + static bool Write(uint32_t width, uint32_t height, uint32_t stride, + unsigned char* pYData, const T& value, uint32_t x = 0, + uint32_t y = 0) { + YuvStamper stamper(pYData, width, height, stride, x, y, + (sDigitWidth + sInterDigit) * sPixelSize, + (sDigitHeight + sInterLine) * sPixelSize); + return stamper.WriteDigits(value); + } + + static bool Encode(uint32_t width, uint32_t height, uint32_t stride, + unsigned char* pYData, unsigned char* pMsg, size_t msg_len, + uint32_t x = 0, uint32_t y = 0); + + static bool Decode(uint32_t width, uint32_t height, uint32_t stride, + unsigned char* pYData, unsigned char* pMsg, size_t msg_len, + uint32_t x = 0, uint32_t y = 0); + + private: + YuvStamper(unsigned char* pYData, uint32_t width, uint32_t height, + uint32_t stride, uint32_t x, uint32_t y, + unsigned char symbol_width, unsigned char symbol_height); + + bool WriteDigit(unsigned char digit); + void WritePixel(unsigned char* data, uint32_t x, uint32_t y); + uint32_t Capacity(); + bool AdvanceCursor(); + bool WriteBit(bool one); + bool Write8(unsigned char value); + bool ReadBit(unsigned char& value); + bool Read8(unsigned char& bit); + + const static unsigned char sPixelSize = 3; + const static unsigned char sDigitWidth = 6; + const static unsigned char sDigitHeight = 7; + const static unsigned char sInterDigit = 1; + const static unsigned char sInterLine = 1; + const static uint32_t sBitSize = 4; + const static uint32_t sBitThreshold = 60; + const static unsigned char sYOn = 0x80; + const static unsigned char sYOff = 0; + const static unsigned char sLumaThreshold = 96; + const static unsigned char sLumaMin = 16; + const static unsigned char sLumaMax = 235; + + unsigned char* pYData; + uint32_t mStride; + uint32_t mWidth; + uint32_t mHeight; + unsigned char mSymbolWidth; + unsigned char mSymbolHeight; + + struct Cursor { + Cursor(uint32_t x, uint32_t y) : x(x), y(y) {} + uint32_t x; + uint32_t y; + } mCursor; +}; + +} // namespace mozilla + +#endif diff --git a/dom/media/webrtc/common/browser_logging/CSFLog.cpp b/dom/media/webrtc/common/browser_logging/CSFLog.cpp new file mode 100644 index 0000000000..d58f5726a5 --- /dev/null +++ b/dom/media/webrtc/common/browser_logging/CSFLog.cpp @@ -0,0 +1,85 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include +#include +#include + +#include "CSFLog.h" + +#include +#include "prrwlock.h" +#include "prthread.h" +#include "nsThreadUtils.h" + +#include "mozilla/Logging.h" +#include "mozilla/Sprintf.h" + +mozilla::LazyLogModule gSignalingLog("signaling"); + +void CSFLogV(CSFLogLevel priority, const char* sourceFile, int sourceLine, + const char* tag, const char* format, va_list args) { +#ifdef STDOUT_LOGGING + printf("%s\n:", tag); + vprintf(format, args); +#else + + mozilla::LogLevel level = + static_cast(static_cast(priority)); + + // Skip doing any of this work if we're not logging the indicated level... + if (!MOZ_LOG_TEST(gSignalingLog, level)) { + return; + } + + // Trim the path component from the filename + const char* lastSlash = sourceFile; + while (*sourceFile) { + if (*sourceFile == '/' || *sourceFile == '\\') { + lastSlash = sourceFile; + } + sourceFile++; + } + sourceFile = lastSlash; + if (*sourceFile == '/' || *sourceFile == '\\') { + sourceFile++; + } + +# define MAX_MESSAGE_LENGTH 1024 + char message[MAX_MESSAGE_LENGTH]; + + const char* threadName = NULL; + + // Check if we're the main thread... + if (NS_IsMainThread()) { + threadName = "main"; + } else { + threadName = PR_GetThreadName(PR_GetCurrentThread()); + } + + // If we can't find it anywhere, use a blank string + if (!threadName) { + threadName = ""; + } + + VsprintfLiteral(message, format, args); + MOZ_LOG( + gSignalingLog, level, + ("[%s|%s] %s:%d: %s", threadName, tag, sourceFile, sourceLine, message)); +#endif +} + +void CSFLog(CSFLogLevel priority, const char* sourceFile, int sourceLine, + const char* tag, const char* format, ...) { + va_list ap; + va_start(ap, format); + + CSFLogV(priority, sourceFile, sourceLine, tag, format, ap); + va_end(ap); +} + +int CSFLogTestLevel(CSFLogLevel priority) { + return MOZ_LOG_TEST(gSignalingLog, static_cast( + static_cast(priority))); +} diff --git a/dom/media/webrtc/common/browser_logging/CSFLog.h b/dom/media/webrtc/common/browser_logging/CSFLog.h new file mode 100644 index 0000000000..eb46b37cc3 --- /dev/null +++ b/dom/media/webrtc/common/browser_logging/CSFLog.h @@ -0,0 +1,58 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef CSFLOG_H +#define CSFLOG_H + +#include + +typedef enum { + CSF_LOG_ERROR = 1, + CSF_LOG_WARNING, + CSF_LOG_INFO, + CSF_LOG_DEBUG, + CSF_LOG_VERBOSE, +} CSFLogLevel; + +#define CSFLogError(tag, format, ...) \ + CSFLog(CSF_LOG_ERROR, __FILE__, __LINE__, tag, format, ##__VA_ARGS__) +#define CSFLogErrorV(tag, format, va_list_arg) \ + CSFLogV(CSF_LOG_ERROR, __FILE__, __LINE__, tag, format, va_list_arg) +#define CSFLogWarn(tag, format, ...) \ + CSFLog(CSF_LOG_WARNING, __FILE__, __LINE__, tag, format, ##__VA_ARGS__) +#define CSFLogWarnV(tag, format, va_list_arg) \ + CSFLogV(CSF_LOG_WARNING, __FILE__, __LINE__, tag, format, va_list_arg) +#define CSFLogInfo(tag, format, ...) \ + CSFLog(CSF_LOG_INFO, __FILE__, __LINE__, tag, format, ##__VA_ARGS__) +#define CSFLogInfoV(tag, format, va_list_arg) \ + CSFLogV(CSF_LOG_INFO, __FILE__, __LINE__, tag, format, va_list_arg) +#define CSFLogDebug(tag, format, ...) \ + CSFLog(CSF_LOG_DEBUG, __FILE__, __LINE__, tag, format, ##__VA_ARGS__) +#define CSFLogDebugV(tag, format, va_list_arg) \ + CSFLogV(CSF_LOG_DEBUG, __FILE__, __LINE__, tag, format, va_list_arg) +#define CSFLogVerbose(tag, format, ...) \ + CSFLog(CSF_LOG_VERBOSE, __FILE__, __LINE__, tag, format, ##__VA_ARGS__) +#define CSFLogVerboseV(tag, format, va_list_arg) \ + CSFLogV(CSF_LOG_VERBOSE, __FILE__, __LINE__, tag, format, va_list_arg) + +#ifdef __cplusplus +extern "C" { +#endif +void CSFLog(CSFLogLevel priority, const char* sourceFile, int sourceLine, + const char* tag, const char* format, ...) +#ifdef __GNUC__ + __attribute__((format(printf, 5, 6))) +#endif + ; + +void CSFLogV(CSFLogLevel priority, const char* sourceFile, int sourceLine, + const char* tag, const char* format, va_list args); + +int CSFLogTestLevel(CSFLogLevel priority); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/dom/media/webrtc/common/browser_logging/WebRtcLog.cpp b/dom/media/webrtc/common/browser_logging/WebRtcLog.cpp new file mode 100644 index 0000000000..0f3769604e --- /dev/null +++ b/dom/media/webrtc/common/browser_logging/WebRtcLog.cpp @@ -0,0 +1,162 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "WebRtcLog.h" + +#include "mozilla/Logging.h" +#include "mozilla/StaticPtr.h" +#include "prenv.h" +#include "rtc_base/logging.h" + +#include "nscore.h" +#include "nsString.h" +#include "nsXULAppAPI.h" +#include "mozilla/Preferences.h" + +#include "nsIFile.h" +#include "nsDirectoryServiceUtils.h" +#include "nsDirectoryServiceDefs.h" +#include "nsNativeCharsetUtils.h" + +using mozilla::LogLevel; + +static mozilla::LazyLogModule sWebRtcLog("webrtc_trace"); +static mozilla::LazyLogModule sLogAEC("AEC"); + +class LogSinkImpl : public rtc::LogSink { + public: + LogSinkImpl() {} + + private: + void OnLogMessage(const std::string& message) override { + MOZ_LOG(sWebRtcLog, LogLevel::Debug, ("%s", message.data())); + } +}; + +// For RTC_LOG() +static mozilla::StaticAutoPtr sSink; + +void GetWebRtcLogPrefs() { + rtc::LogMessage::set_aec_debug_size( + mozilla::Preferences::GetUint("media.webrtc.debug.aec_dump_max_size")); +} + +mozilla::LogLevel CheckOverrides() { + mozilla::LogModule* log_info = sWebRtcLog; + mozilla::LogLevel log_level = log_info->Level(); + + log_info = sLogAEC; + if (sLogAEC && (log_info->Level() != mozilla::LogLevel::Disabled)) { + rtc::LogMessage::set_aec_debug(true); + } + + return log_level; +} + +void ConfigWebRtcLog(mozilla::LogLevel level) { + rtc::LoggingSeverity log_level; + switch (level) { + case mozilla::LogLevel::Verbose: + log_level = rtc::LoggingSeverity::LS_VERBOSE; + break; + case mozilla::LogLevel::Debug: + case mozilla::LogLevel::Info: + log_level = rtc::LoggingSeverity::LS_INFO; + break; + case mozilla::LogLevel::Warning: + log_level = rtc::LoggingSeverity::LS_WARNING; + break; + case mozilla::LogLevel::Error: + log_level = rtc::LoggingSeverity::LS_ERROR; + break; + case mozilla::LogLevel::Disabled: + log_level = rtc::LoggingSeverity::LS_NONE; + break; + default: + MOZ_ASSERT(false); + break; + } + rtc::LogMessage::LogToDebug(log_level); + if (level != mozilla::LogLevel::Disabled) { + // always capture LOG(...) << ... logging in webrtc.org code to nspr logs + if (!sSink) { + sSink = new LogSinkImpl(); + rtc::LogMessage::AddLogToStream(sSink, log_level); + // it's ok if this leaks to program end + } + } else if (sSink) { + rtc::LogMessage::RemoveLogToStream(sSink); + sSink = nullptr; + } +} + +void StartWebRtcLog(mozilla::LogLevel log_level) { + if (log_level == mozilla::LogLevel::Disabled) { + return; + } + + GetWebRtcLogPrefs(); + mozilla::LogLevel level = CheckOverrides(); + + ConfigWebRtcLog(level); +} + +void EnableWebRtcLog() { + GetWebRtcLogPrefs(); + mozilla::LogLevel level = CheckOverrides(); + ConfigWebRtcLog(level); +} + +// Called when we destroy the singletons from PeerConnectionCtx or if the +// user changes logging in about:webrtc +void StopWebRtcLog() { + if (sSink) { + rtc::LogMessage::RemoveLogToStream(sSink); + sSink = nullptr; + } +} + +nsCString ConfigAecLog() { + nsCString aecLogDir; + if (rtc::LogMessage::aec_debug()) { + return ""_ns; + } +#if defined(ANDROID) + const char* default_tmp_dir = "/dev/null"; + aecLogDir.Assign(default_tmp_dir); +#else + nsCOMPtr tempDir; + nsresult rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(tempDir)); + if (NS_SUCCEEDED(rv)) { +# ifdef XP_WIN + // WebRTC wants a path encoded in the native charset, not UTF-8. + nsAutoString temp; + tempDir->GetPath(temp); + NS_CopyUnicodeToNative(temp, aecLogDir); +# else + tempDir->GetNativePath(aecLogDir); +# endif + } +#endif + rtc::LogMessage::set_aec_debug_filename(aecLogDir.get()); + + return aecLogDir; +} + +nsCString StartAecLog() { + nsCString aecLogDir; + if (rtc::LogMessage::aec_debug()) { + return ""_ns; + } + + GetWebRtcLogPrefs(); + CheckOverrides(); + aecLogDir = ConfigAecLog(); + + rtc::LogMessage::set_aec_debug(true); + + return aecLogDir; +} + +void StopAecLog() { rtc::LogMessage::set_aec_debug(false); } diff --git a/dom/media/webrtc/common/browser_logging/WebRtcLog.h b/dom/media/webrtc/common/browser_logging/WebRtcLog.h new file mode 100644 index 0000000000..b933ff43a5 --- /dev/null +++ b/dom/media/webrtc/common/browser_logging/WebRtcLog.h @@ -0,0 +1,17 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef WEBRTCLOG_H_ +#define WEBRTCLOG_H_ + +#include "mozilla/Logging.h" +#include "nsStringFwd.h" + +nsCString StartAecLog(); +void StopAecLog(); +void EnableWebRtcLog(); +void StartWebRtcLog(mozilla::LogLevel level); +void StopWebRtcLog(); + +#endif diff --git a/dom/media/webrtc/common/csf_common.h b/dom/media/webrtc/common/csf_common.h new file mode 100644 index 0000000000..8b01047553 --- /dev/null +++ b/dom/media/webrtc/common/csf_common.h @@ -0,0 +1,90 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef _CSF_COMMON_E58E5677_950A_424c_B6C2_CA180092E6A2_H +#define _CSF_COMMON_E58E5677_950A_424c_B6C2_CA180092E6A2_H + +#include +#include +#include +#include + +/* + +This header file defines: + +csf_countof +csf_sprintf +csf_vsprintf + +*/ + +/* + General security tip: Ensure that "format" is never a user-defined string. + Format should ALWAYS be something that's built into your code, not user + supplied. For example: never write: + + csf_sprintf(buffer, csf_countof(buffer), pUserSuppliedString); + + Instead write: + + csf_sprintf(buffer, csf_countof(buffer), "%s", pUserSuppliedString); + +*/ + +#ifdef WIN32 +# if !defined(_countof) +# if !defined(__cplusplus) +# define _countof(_Array) (sizeof(_Array) / sizeof(_Array[0])) +# else +extern "C++" { +template +char (*_csf_countof_helper(_CountofType (&_Array)[_SizeOfArray]))[_SizeOfArray]; +# define _countof(_Array) sizeof(*_csf_countof_helper(_Array)) +} +# endif +# endif +#else +# define _countof(_Array) (sizeof(_Array) / sizeof(_Array[0])) +#endif +// csf_countof + +#define csf_countof(anArray) _countof(anArray) + +// csf_sprintf + +#ifdef _WIN32 +// Unlike snprintf, sprintf_s guarantees that the buffer will be null-terminated +// (unless the buffer size is zero). +# define csf_sprintf(/* char* */ buffer, \ + /* size_t */ sizeOfBufferInCharsInclNullTerm, \ + /* const char * */ format, ...) \ + _snprintf_s(buffer, sizeOfBufferInCharsInclNullTerm, _TRUNCATE, format, \ + __VA_ARGS__) +#else +# define csf_sprintf(/* char */ buffer, \ + /* size_t */ sizeOfBufferInCharsInclNullTerm, \ + /* const char * */ format, ...) \ + snprintf(buffer, sizeOfBufferInCharsInclNullTerm, format, __VA_ARGS__); \ + buffer[sizeOfBufferInCharsInclNullTerm - 1] = '\0' +#endif + +// csf_vsprintf + +#ifdef _WIN32 +# define csf_vsprintf(/* char* */ buffer, \ + /* size_t */ sizeOfBufferInCharsInclNullTerm, \ + /* const char * */ format, /* va_list */ vaList) \ + vsnprintf_s(buffer, sizeOfBufferInCharsInclNullTerm, _TRUNCATE, format, \ + vaList); \ + buffer[sizeOfBufferInCharsInclNullTerm - 1] = '\0' +#else +# define csf_vsprintf(/* char */ buffer, \ + /* size_t */ sizeOfBufferInCharsInclNullTerm, \ + /* const char * */ format, /* va_list */ vaList) \ + vsprintf(buffer, format, vaList); \ + buffer[sizeOfBufferInCharsInclNullTerm - 1] = '\0' +#endif + +#endif diff --git a/dom/media/webrtc/common/moz.build b/dom/media/webrtc/common/moz.build new file mode 100644 index 0000000000..7605d27835 --- /dev/null +++ b/dom/media/webrtc/common/moz.build @@ -0,0 +1,23 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. +include("/dom/media/webrtc/third_party_build/webrtc.mozbuild") + +EXPORTS.mozilla.dom += ["CandidateInfo.h"] + +LOCAL_INCLUDES += [ + "/dom/media/webrtc/transport/third_party/nrappkit/src/util/libekr", + "/third_party/libwebrtc", + "/third_party/libwebrtc/third_party/abseil-cpp", +] + +UNIFIED_SOURCES += [ + "browser_logging/CSFLog.cpp", + "browser_logging/WebRtcLog.cpp", + "time_profiling/timecard.c", + "YuvStamper.cpp", +] + +FINAL_LIBRARY = "xul" diff --git a/dom/media/webrtc/common/time_profiling/timecard.c b/dom/media/webrtc/common/time_profiling/timecard.c new file mode 100644 index 0000000000..c0218cb92d --- /dev/null +++ b/dom/media/webrtc/common/time_profiling/timecard.c @@ -0,0 +1,112 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include +#include +#include "timecard.h" +#include "mozilla/mozalloc.h" + +Timecard* create_timecard() { + Timecard* tc = moz_xcalloc(1, sizeof(Timecard)); + tc->entries_allocated = TIMECARD_INITIAL_TABLE_SIZE; + tc->entries = moz_xcalloc(tc->entries_allocated, sizeof(TimecardEntry)); + tc->start_time = PR_Now(); + return tc; +} + +void destroy_timecard(Timecard* tc) { + free(tc->entries); + free(tc); +} + +void stamp_timecard(Timecard* tc, const char* event, const char* file, + unsigned int line, const char* function) { + TimecardEntry* entry = NULL; + + /* Trim the path component from the filename */ + const char* last_slash = file; + while (*file) { + if (*file == '/' || *file == '\\') { + last_slash = file; + } + file++; + } + file = last_slash; + if (*file == '/' || *file == '\\') { + file++; + } + + /* Ensure there is enough space left in the entries list */ + if (tc->curr_entry == tc->entries_allocated) { + tc->entries_allocated *= 2; + tc->entries = moz_xrealloc(tc->entries, + tc->entries_allocated * sizeof(TimecardEntry)); + } + + /* Record the data into the timecard entry */ + entry = &tc->entries[tc->curr_entry]; + entry->timestamp = PR_Now(); + entry->event = event; + entry->file = file; + entry->line = line; + entry->function = function; + tc->curr_entry++; +} + +void print_timecard(Timecard* tc) { + size_t i; + TimecardEntry* entry; + size_t event_width = 5; + size_t file_width = 4; + size_t function_width = 8; + size_t line_width; + PRTime offset, delta; + + for (i = 0; i < tc->curr_entry; i++) { + entry = &tc->entries[i]; + if (strlen(entry->event) > event_width) { + event_width = strlen(entry->event); + } + if (strlen(entry->file) > file_width) { + file_width = strlen(entry->file); + } + if (strlen(entry->function) > function_width) { + function_width = strlen(entry->function); + } + } + + printf("\nTimecard created %4ld.%6.6ld\n\n", + (long)(tc->start_time / PR_USEC_PER_SEC), + (long)(tc->start_time % PR_USEC_PER_SEC)); + + line_width = + 1 + 11 + 11 + event_width + file_width + 6 + function_width + (4 * 3); + + printf(" %-11s | %-11s | %-*s | %-*s | %-*s\n", "Timestamp", "Delta", + (int)event_width, "Event", (int)file_width + 6, "File", + (int)function_width, "Function"); + + for (i = 0; i <= line_width; i++) { + printf("="); + } + printf("\n"); + + for (i = 0; i < tc->curr_entry; i++) { + entry = &tc->entries[i]; + offset = entry->timestamp - tc->start_time; + if (i > 0) { + delta = entry->timestamp - tc->entries[i - 1].timestamp; + } else { + delta = entry->timestamp - tc->start_time; + } + printf(" %4ld.%6.6ld | %4ld.%6.6ld | %-*s | %*s:%-5d | %-*s\n", + (long)(offset / PR_USEC_PER_SEC), (long)(offset % PR_USEC_PER_SEC), + (long)(delta / PR_USEC_PER_SEC), (long)(delta % PR_USEC_PER_SEC), + (int)event_width, entry->event, (int)file_width, entry->file, + entry->line, (int)function_width, entry->function); + } + printf("\n"); +} diff --git a/dom/media/webrtc/common/time_profiling/timecard.h b/dom/media/webrtc/common/time_profiling/timecard.h new file mode 100644 index 0000000000..38d4a8d1ec --- /dev/null +++ b/dom/media/webrtc/common/time_profiling/timecard.h @@ -0,0 +1,74 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef timecard_h__ +#define timecard_h__ + +#include +#include "prtime.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define STAMP_TIMECARD(card, event) \ + do { \ + if (card) { \ + stamp_timecard((card), (event), __FILE__, __LINE__, __FUNCTION__); \ + } \ + } while (0) + +#define TIMECARD_INITIAL_TABLE_SIZE 16 + +/* + * The "const char *" members of this structure point to static strings. + * We do not own them, and should not attempt to deallocate them. + */ + +typedef struct { + PRTime timestamp; + const char* event; + const char* file; + unsigned int line; + const char* function; +} TimecardEntry; + +typedef struct Timecard { + size_t curr_entry; + size_t entries_allocated; + TimecardEntry* entries; + PRTime start_time; +} Timecard; + +/** + * Creates a new Timecard structure for tracking events. + */ +Timecard* create_timecard(); + +/** + * Frees the memory associated with a timecard. After returning, the + * timecard pointed to by tc is no longer valid. + */ +void destroy_timecard(Timecard* tc); + +/** + * Records a new event in the indicated timecard. This should not be + * called directly; code should instead use the STAMP_TIMECARD macro, + * above. + */ +void stamp_timecard(Timecard* tc, const char* event, const char* file, + unsigned int line, const char* function); + +/** + * Formats and outputs the contents of a timecard onto stdout. + */ +void print_timecard(Timecard* tc); + +#ifdef __cplusplus +} +#endif + +#endif -- cgit v1.2.3