diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..e04cbbb
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,24 @@
+---
+BasedOnStyle: LLVM
+Language: Cpp
+Standard: c++20
+ColumnLimit: 120
+IndentWidth: 2
+ContinuationIndentWidth: 4
+NamespaceIndentation: All
+AccessModifierOffset: -2
+PointerAlignment: Right
+QualifierAlignment: Left
+ReferenceAlignment: Right
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakTemplateDeclarations: Yes
+BreakBeforeBraces: Attach
+InsertBraces: true
+IncludeBlocks: Preserve
+SortIncludes: CaseSensitive
+FixNamespaceComments: true
+SpaceAfterTemplateKeyword: true
+...
diff --git a/.clang-tidy b/.clang-tidy
new file mode 100644
index 0000000..d7ff6bb
--- /dev/null
+++ b/.clang-tidy
@@ -0,0 +1,48 @@
+---
+# Every disabled check has a reason; everything else is fixed, or NOLINT(check) with a reason where it can't be.
+Checks: >
+  -*,
+  bugprone-*,
+  cert-*,
+  clang-analyzer-*,
+  concurrency-*,
+  cppcoreguidelines-*,
+  misc-*,
+  modernize-*,
+  performance-*,
+  portability-*,
+  readability-*,
+  -modernize-use-trailing-return-type,
+  -misc-include-cleaner,
+  -misc-multiple-inheritance,
+  -cppcoreguidelines-owning-memory,
+  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
+  -cppcoreguidelines-pro-bounds-constant-array-index,
+  -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access,
+  -cppcoreguidelines-pro-type-static-cast-downcast
+
+# modernize-use-trailing-return-type: libwebrtc and pybind11 APIs, which we override and mirror, use leading returns
+# misc-include-cleaner: pybind11 and libwebrtc are used through umbrella headers the check maps to internal ones
+# misc-multiple-inheritance: libwebrtc observer interfaces (not pure virtual) are implemented next to our bases
+# cppcoreguidelines-owning-memory: libwebrtc takes raw `new` into its refcounting, and there's no GSL owner<>
+# cppcoreguidelines-pro-bounds-*: libwebrtc frames and audio are raw planes with strides, indexed per sample
+# cppcoreguidelines-pro-type-static-cast-downcast: libwebrtc has no RTTI, tracks are downcast by kind() as it does
+
+WarningsAsErrors: '*'
+HeaderFilterRegex: '.*/python-webrtc/cpp/src/.*'
+FormatStyle: file
+
+CheckOptions:
+  # running out of memory terminates anyway, and so does calling an empty std::function, a bug
+  bugprone-exception-escape.IgnoredExceptions: 'bad_alloc,bad_array_new_length,length_error,bad_function_call'
+  # pybind11 dataclass-like models (def_readwrite) are plain structs
+  misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic: true
+  # `m` for the pybind11 module, `pc` for a peer connection, coordinates and iterators
+  readability-identifier-length.IgnoredVariableNames: '^(m|pc|id|it|x|y|u|v|uv|i|j)$'
+  readability-identifier-length.IgnoredParameterNames: '^(m|pc|id|it|x|y|u|v|uv|i|j)$'
+  readability-identifier-length.IgnoredLoopCounterNames: '^[ijkxy_]$'
+  # a width and a height, in the order everything takes them
+  bugprone-easily-swappable-parameters.IgnoredParameterNames: '"";iterator;Iterator;begin;Begin;end;End;first;First;last;Last;lhs;LHS;rhs;RHS;width;height'
+  cppcoreguidelines-special-member-functions.AllowSoleDefaultDtor: true
+  cppcoreguidelines-special-member-functions.AllowMissingMoveFunctionsWhenCopyIsDeleted: true
+...
diff --git a/.github/scripts/tidy.sh b/.github/scripts/tidy.sh
new file mode 100755
index 0000000..1af4bf2
--- /dev/null
+++ b/.github/scripts/tidy.sh
@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+#
+# Runs clang-tidy (see .clang-tidy) over the extension sources, against a configured (not built) tree in build/tidy.
+#
+#   .github/scripts/tidy.sh [run-clang-tidy arguments, e.g. -fix or a file regex]
+#
+# The LLVM version is pinned to match clang-format in the Makefile.
+
+set -euo pipefail
+
+SRC="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+BUILD="${WRTC_TIDY_BUILD_DIR:-$SRC/build/tidy}"
+LLVM_VERSION=22.1.8
+
+if [ ! -x "$BUILD/venv/bin/python" ]; then
+    uv venv -q "$BUILD/venv" --python 3.13
+fi
+uv pip install -q --python "$BUILD/venv/bin/python" cmake ninja "pybind11>=3.0" "clang-tidy==$LLVM_VERSION"
+export PATH="$BUILD/venv/bin:$PATH"
+
+# libwebrtc for Linux is compiled against Chromium's libc++, which needs Clang
+if [ "$(uname)" = Linux ]; then
+    export CC="${CC:-clang}" CXX="${CXX:-clang++}"
+fi
+cmake -S "$SRC" -B "$BUILD" -G Ninja \
+    -DCMAKE_BUILD_TYPE=Debug \
+    -DPython_EXECUTABLE="$BUILD/venv/bin/python" \
+    -Dpybind11_DIR="$("$BUILD/venv/bin/python" -m pybind11 --cmakedir)" > /dev/null
+
+EXTRA=()
+if [ "$(uname)" = Darwin ]; then
+    # the wheel's clang doesn't know the SDK Apple Clang uses implicitly
+    EXTRA+=(-extra-arg=-isysroot"$(xcrun --show-sdk-path)")
+fi
+
+cd "$SRC"
+python "$BUILD/venv/bin/run-clang-tidy.py" -p "$BUILD" -quiet -j "$(getconf _NPROCESSORS_ONLN)" \
+    ${EXTRA[@]+"${EXTRA[@]}"} "$@" "$SRC/python-webrtc/cpp/src/"
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a48fc6f..e46255f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -20,11 +20,20 @@ permissions:
 jobs:
   lint:
     runs-on: ubuntu-latest
+    env:
+      WRTC_CACHE_DIR: ${{ github.workspace }}/.wrtc-cache
     steps:
       - uses: actions/checkout@v7
       - uses: astral-sh/setup-uv@v7
       - run: uvx ruff check
       - run: uvx ruff format --check
+      - run: make format-check
+      # clang-tidy reads the libwebrtc headers, from the cache the wheels use
+      - uses: actions/cache@v6
+        with:
+          path: .wrtc-cache
+          key: libwebrtc-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('cmake/libwebrtc.cmake', 'cmake/libcxx/*.sha256') }}
+      - run: make tidy
 
   sdist:
     runs-on: ubuntu-latest
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e1001aa..97e0ee1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -15,6 +15,8 @@ project(python_webrtc
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
+# for clang-tidy (make tidy) and editors
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 if(MSVC)
   # libwebrtc is linked against the static release CRT
   set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)
diff --git a/Makefile b/Makefile
index 8f2e971..1a299c3 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,8 @@
-.PHONY: dev test asan tsan lint format stub wheels doc clean
+.PHONY: dev test asan tsan lint format format-check tidy stub wheels doc clean
+
+# pinned to the clang-tidy of .github/scripts/tidy.sh
+CLANG_FORMAT := uvx clang-format==22.1.8
+CPP_SRC = $(shell find python-webrtc/cpp/src -name '*.cpp' -o -name '*.h')
 
 # editable install; the extension is rebuilt automatically on import after C++ changes
 dev:
@@ -16,13 +20,21 @@ asan:
 tsan:
 	SANITIZE=thread .github/scripts/sanitizers-macos.sh $(O)
 
-lint:
+lint: format-check
 	uvx ruff check
 	uvx ruff format --check
 
 format:
 	uvx ruff check --fix
 	uvx ruff format
+	$(CLANG_FORMAT) -i $(CPP_SRC)
+
+format-check:
+	@$(CLANG_FORMAT) --dry-run --Werror $(CPP_SRC)
+
+# clang-tidy over the extension, see .clang-tidy
+tidy:
+	.github/scripts/tidy.sh $(O)
 
 stub:
 	uv run --no-sync pybind11-stubgen wrtc -o build/stubs
diff --git a/python-webrtc/cpp/src/enums/enums.h b/python-webrtc/cpp/src/enums/enums.h
index d2f7654..ea0792c 100644
--- a/python-webrtc/cpp/src/enums/enums.h
+++ b/python-webrtc/cpp/src/enums/enums.h
@@ -5,8 +5,11 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_ENUMS_ENUMS_H_
+#define PYTHON_WEBRTC_ENUMS_ENUMS_H_
 
+#include <array>
+#include <cstdint>
 #include <optional>
 #include <string>
 #include <type_traits>
@@ -32,48 +35,54 @@
 
 namespace python_webrtc {
 
-  enum RTCIceComponent { kRtp, kRtcp };
+  enum class RTCIceComponent : uint8_t { kRtp, kRtcp };
 
   // the media type of a kind of track ("audio" or "video")
   std::optional<webrtc::MediaType> mediaTypeOf(const std::string &kind);
 
   // A C++ enum that Python sees as the str enum `name` of webrtc.enums, converted by the values listed here.
   // Every file that binds one must include this header, or pybind11 silently uses its own caster.
-  template<typename T> struct StrEnum {};
+  template <typename T>
+  struct StrEnum {};
 
-  template<typename T, typename = void> struct IsStrEnum : std::false_type {};
-  template<typename T> struct IsStrEnum<T, std::void_t<decltype(StrEnum<T>::values)>> : std::true_type {};
+  template <typename T, typename = void>
+  struct IsStrEnum : std::false_type {};
+  template <typename T>
+  struct IsStrEnum<T, std::void_t<decltype(StrEnum<T>::values)>> : std::true_type {};
 
-  template<> struct StrEnum<webrtc::PeerConnectionInterface::PeerConnectionState> {
+  template <>
+  struct StrEnum<webrtc::PeerConnectionInterface::PeerConnectionState> {
     using State = webrtc::PeerConnectionInterface::PeerConnectionState;
-    static constexpr char name[] = "RTCPeerConnectionState";
-    static constexpr std::pair<State, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("RTCPeerConnectionState");
+    static constexpr auto values = std::to_array<std::pair<State, const char *>>({
         {State::kNew, "new"},
         {State::kConnecting, "connecting"},
         {State::kConnected, "connected"},
         {State::kDisconnected, "disconnected"},
         {State::kFailed, "failed"},
         {State::kClosed, "closed"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::PeerConnectionInterface::SignalingState> {
+  template <>
+  struct StrEnum<webrtc::PeerConnectionInterface::SignalingState> {
     using State = webrtc::PeerConnectionInterface::SignalingState;
-    static constexpr char name[] = "RTCSignalingState";
-    static constexpr std::pair<State, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("RTCSignalingState");
+    static constexpr auto values = std::to_array<std::pair<State, const char *>>({
         {State::kStable, "stable"},
         {State::kHaveLocalOffer, "have-local-offer"},
         {State::kHaveLocalPrAnswer, "have-local-pranswer"},
         {State::kHaveRemoteOffer, "have-remote-offer"},
         {State::kHaveRemotePrAnswer, "have-remote-pranswer"},
         {State::kClosed, "closed"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::PeerConnectionInterface::IceConnectionState> {
+  template <>
+  struct StrEnum<webrtc::PeerConnectionInterface::IceConnectionState> {
     using State = webrtc::PeerConnectionInterface::IceConnectionState;
-    static constexpr char name[] = "RTCIceConnectionState";
-    static constexpr std::pair<State, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("RTCIceConnectionState");
+    static constexpr auto values = std::to_array<std::pair<State, const char *>>({
         {State::kIceConnectionNew, "new"},
         {State::kIceConnectionChecking, "checking"},
         {State::kIceConnectionConnected, "connected"},
@@ -82,81 +91,89 @@ namespace python_webrtc {
         {State::kIceConnectionDisconnected, "disconnected"},
         {State::kIceConnectionClosed, "closed"},
         {State::kIceConnectionMax, "max"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::PeerConnectionInterface::IceGatheringState> {
+  template <>
+  struct StrEnum<webrtc::PeerConnectionInterface::IceGatheringState> {
     using State = webrtc::PeerConnectionInterface::IceGatheringState;
-    static constexpr char name[] = "RTCIceGatheringState";
-    static constexpr std::pair<State, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("RTCIceGatheringState");
+    static constexpr auto values = std::to_array<std::pair<State, const char *>>({
         {State::kIceGatheringNew, "new"},
         {State::kIceGatheringGathering, "gathering"},
         {State::kIceGatheringComplete, "complete"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::SdpType> {
-    static constexpr char name[] = "RTCSdpType";
-    static constexpr std::pair<webrtc::SdpType, const char *> values[] = {
+  template <>
+  struct StrEnum<webrtc::SdpType> {
+    static constexpr auto name = pybind11::detail::const_name("RTCSdpType");
+    static constexpr auto values = std::to_array<std::pair<webrtc::SdpType, const char *>>({
         {webrtc::SdpType::kOffer, "offer"},
         {webrtc::SdpType::kPrAnswer, "pranswer"},
         {webrtc::SdpType::kAnswer, "answer"},
         {webrtc::SdpType::kRollback, "rollback"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::MediaStreamTrackInterface::TrackState> {
+  template <>
+  struct StrEnum<webrtc::MediaStreamTrackInterface::TrackState> {
     using State = webrtc::MediaStreamTrackInterface::TrackState;
-    static constexpr char name[] = "MediaStreamTrackState";
-    static constexpr std::pair<State, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("MediaStreamTrackState");
+    static constexpr auto values = std::to_array<std::pair<State, const char *>>({
         {State::kLive, "live"},
         {State::kEnded, "ended"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::RtpTransceiverDirection> {
+  template <>
+  struct StrEnum<webrtc::RtpTransceiverDirection> {
     using Direction = webrtc::RtpTransceiverDirection;
-    static constexpr char name[] = "TransceiverDirection";
-    static constexpr std::pair<Direction, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("TransceiverDirection");
+    static constexpr auto values = std::to_array<std::pair<Direction, const char *>>({
         {Direction::kSendRecv, "sendrecv"},
         {Direction::kSendOnly, "sendonly"},
         {Direction::kRecvOnly, "recvonly"},
         {Direction::kInactive, "inactive"},
         {Direction::kStopped, "stopped"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::MediaType> {
-    static constexpr char name[] = "MediaType";
-    static constexpr std::pair<webrtc::MediaType, const char *> values[] = {
+  template <>
+  struct StrEnum<webrtc::MediaType> {
+    static constexpr auto name = pybind11::detail::const_name("MediaType");
+    static constexpr auto values = std::to_array<std::pair<webrtc::MediaType, const char *>>({
         {webrtc::MediaType::AUDIO, "audio"},
         {webrtc::MediaType::VIDEO, "video"},
         {webrtc::MediaType::DATA, "data"},
         {webrtc::MediaType::UNSUPPORTED, "unsupported"},
-    };
+    });
   };
 
-  template<> struct StrEnum<RTCIceComponent> {
-    static constexpr char name[] = "RTCIceComponent";
-    static constexpr std::pair<RTCIceComponent, const char *> values[] = {
+  template <>
+  struct StrEnum<RTCIceComponent> {
+    static constexpr auto name = pybind11::detail::const_name("RTCIceComponent");
+    static constexpr auto values = std::to_array<std::pair<RTCIceComponent, const char *>>({
         {RTCIceComponent::kRtp, "rtp"},
         {RTCIceComponent::kRtcp, "rtcp"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::IceRole> {
-    static constexpr char name[] = "RTCIceRole";
-    static constexpr std::pair<webrtc::IceRole, const char *> values[] = {
+  template <>
+  struct StrEnum<webrtc::IceRole> {
+    static constexpr auto name = pybind11::detail::const_name("RTCIceRole");
+    static constexpr auto values = std::to_array<std::pair<webrtc::IceRole, const char *>>({
         {webrtc::IceRole::ICEROLE_CONTROLLING, "controlling"},
         {webrtc::IceRole::ICEROLE_CONTROLLED, "controlled"},
         {webrtc::IceRole::ICEROLE_UNKNOWN, "unknown"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::IceTransportState> {
+  template <>
+  struct StrEnum<webrtc::IceTransportState> {
     using State = webrtc::IceTransportState;
-    static constexpr char name[] = "RTCIceTransportState";
-    static constexpr std::pair<State, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("RTCIceTransportState");
+    static constexpr auto values = std::to_array<std::pair<State, const char *>>({
         {State::kNew, "new"},
         {State::kChecking, "checking"},
         {State::kConnected, "connected"},
@@ -164,78 +181,85 @@ namespace python_webrtc {
         {State::kDisconnected, "disconnected"},
         {State::kFailed, "failed"},
         {State::kClosed, "closed"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::IceGatheringState> {
-    static constexpr char name[] = "CricketIceGatheringState";
-    static constexpr std::pair<webrtc::IceGatheringState, const char *> values[] = {
+  template <>
+  struct StrEnum<webrtc::IceGatheringState> {
+    static constexpr auto name = pybind11::detail::const_name("CricketIceGatheringState");
+    static constexpr auto values = std::to_array<std::pair<webrtc::IceGatheringState, const char *>>({
         {webrtc::IceGatheringState::kIceGatheringNew, "new"},
         {webrtc::IceGatheringState::kIceGatheringGathering, "gathering"},
         {webrtc::IceGatheringState::kIceGatheringComplete, "complete"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::DtlsTransportState> {
+  template <>
+  struct StrEnum<webrtc::DtlsTransportState> {
     using State = webrtc::DtlsTransportState;
-    static constexpr char name[] = "DtlsTransportState";
-    static constexpr std::pair<State, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("DtlsTransportState");
+    static constexpr auto values = std::to_array<std::pair<State, const char *>>({
         {State::kNew, "new"},
         {State::kConnecting, "connecting"},
         {State::kConnected, "connected"},
         {State::kClosed, "closed"},
         {State::kFailed, "failed"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::SctpTransportState> {
+  template <>
+  struct StrEnum<webrtc::SctpTransportState> {
     using State = webrtc::SctpTransportState;
-    static constexpr char name[] = "SctpTransportState";
-    static constexpr std::pair<State, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("SctpTransportState");
+    static constexpr auto values = std::to_array<std::pair<State, const char *>>({
         {State::kNew, "new"},
         {State::kConnecting, "connecting"},
         {State::kConnected, "connected"},
         {State::kClosed, "closed"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::DataChannelInterface::DataState> {
+  template <>
+  struct StrEnum<webrtc::DataChannelInterface::DataState> {
     using State = webrtc::DataChannelInterface::DataState;
-    static constexpr char name[] = "RTCDataChannelState";
-    static constexpr std::pair<State, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("RTCDataChannelState");
+    static constexpr auto values = std::to_array<std::pair<State, const char *>>({
         {State::kConnecting, "connecting"},
         {State::kOpen, "open"},
         {State::kClosing, "closing"},
         {State::kClosed, "closed"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::Priority> {
-    static constexpr char name[] = "RTCPriorityType";
-    static constexpr std::pair<webrtc::Priority, const char *> values[] = {
+  template <>
+  struct StrEnum<webrtc::Priority> {
+    static constexpr auto name = pybind11::detail::const_name("RTCPriorityType");
+    static constexpr auto values = std::to_array<std::pair<webrtc::Priority, const char *>>({
         {webrtc::Priority::kVeryLow, "very-low"},
         {webrtc::Priority::kLow, "low"},
         {webrtc::Priority::kMedium, "medium"},
         {webrtc::Priority::kHigh, "high"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::DegradationPreference> {
+  template <>
+  struct StrEnum<webrtc::DegradationPreference> {
     using Preference = webrtc::DegradationPreference;
-    static constexpr char name[] = "RTCDegradationPreference";
-    static constexpr std::pair<Preference, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("RTCDegradationPreference");
+    static constexpr auto values = std::to_array<std::pair<Preference, const char *>>({
         {Preference::MAINTAIN_FRAMERATE, "maintain-framerate"},
         {Preference::MAINTAIN_RESOLUTION, "maintain-resolution"},
         {Preference::BALANCED, "balanced"},
         {Preference::MAINTAIN_FRAMERATE_AND_RESOLUTION, "maintain-framerate-and-resolution"},
-    };
+    });
   };
 
   // NONE is None in Python
-  template<> struct StrEnum<webrtc::RTCErrorDetailType> {
+  template <>
+  struct StrEnum<webrtc::RTCErrorDetailType> {
     using Detail = webrtc::RTCErrorDetailType;
-    static constexpr char name[] = "RTCErrorDetailType";
-    static constexpr std::pair<Detail, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("RTCErrorDetailType");
+    static constexpr auto values = std::to_array<std::pair<Detail, const char *>>({
         {Detail::DATA_CHANNEL_FAILURE, "data-channel-failure"},
         {Detail::DTLS_FAILURE, "dtls-failure"},
         {Detail::FINGERPRINT_FAILURE, "fingerprint-failure"},
@@ -243,43 +267,47 @@ namespace python_webrtc {
         {Detail::SDP_SYNTAX_ERROR, "sdp-syntax-error"},
         {Detail::HARDWARE_ENCODER_NOT_AVAILABLE, "hardware-encoder-not-available"},
         {Detail::HARDWARE_ENCODER_ERROR, "hardware-encoder-error"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::PeerConnectionInterface::IceTransportsType> {
+  template <>
+  struct StrEnum<webrtc::PeerConnectionInterface::IceTransportsType> {
     using Policy = webrtc::PeerConnectionInterface::IceTransportsType;
-    static constexpr char name[] = "RTCIceTransportPolicy";
-    static constexpr std::pair<Policy, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("RTCIceTransportPolicy");
+    static constexpr auto values = std::to_array<std::pair<Policy, const char *>>({
         {Policy::kAll, "all"},
         {Policy::kRelay, "relay"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::PeerConnectionInterface::BundlePolicy> {
+  template <>
+  struct StrEnum<webrtc::PeerConnectionInterface::BundlePolicy> {
     using Policy = webrtc::PeerConnectionInterface::BundlePolicy;
-    static constexpr char name[] = "RTCBundlePolicy";
-    static constexpr std::pair<Policy, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("RTCBundlePolicy");
+    static constexpr auto values = std::to_array<std::pair<Policy, const char *>>({
         {Policy::kBundlePolicyBalanced, "balanced"},
         {Policy::kBundlePolicyMaxCompat, "max-compat"},
         {Policy::kBundlePolicyMaxBundle, "max-bundle"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::PeerConnectionInterface::RtcpMuxPolicy> {
+  template <>
+  struct StrEnum<webrtc::PeerConnectionInterface::RtcpMuxPolicy> {
     using Policy = webrtc::PeerConnectionInterface::RtcpMuxPolicy;
-    static constexpr char name[] = "RTCRtcpMuxPolicy";
-    static constexpr std::pair<Policy, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("RTCRtcpMuxPolicy");
+    static constexpr auto values = std::to_array<std::pair<Policy, const char *>>({
         {Policy::kRtcpMuxPolicyRequire, "require"},
-    };
+    });
   };
 
-  template<> struct StrEnum<webrtc::CryptoOptions::Srtp::CryptexPolicy> {
+  template <>
+  struct StrEnum<webrtc::CryptoOptions::Srtp::CryptexPolicy> {
     using Policy = webrtc::CryptoOptions::Srtp::CryptexPolicy;
-    static constexpr char name[] = "RTCRtpHeaderEncryptionPolicy";
-    static constexpr std::pair<Policy, const char *> values[] = {
+    static constexpr auto name = pybind11::detail::const_name("RTCRtpHeaderEncryptionPolicy");
+    static constexpr auto values = std::to_array<std::pair<Policy, const char *>>({
         {Policy::kNegotiate, "negotiate"},
         {Policy::kRequire, "require"},
-    };
+    });
   };
 
 } // namespace python_webrtc
@@ -287,18 +315,19 @@ namespace python_webrtc {
 namespace pybind11::detail {
 
   // not the caster of py::enum_ and py::native_enum
-  template<typename T>
+  template <typename T>
   struct type_caster_enum_type_enabled<T, enable_if_t<python_webrtc::IsStrEnum<T>::value>> : std::false_type {};
 
-  template<typename T> class type_caster<T, enable_if_t<python_webrtc::IsStrEnum<T>::value>> {
+  template <typename T>
+  class type_caster<T, enable_if_t<python_webrtc::IsStrEnum<T>::value>> {
     using Enum = python_webrtc::StrEnum<T>;
 
   public:
-    PYBIND11_TYPE_CASTER(T, const_name("webrtc.enums.") + const_name(Enum::name));
+    PYBIND11_TYPE_CASTER(T, const_name("webrtc.enums.") + Enum::name);
 
     // a member of the Python enum, or its value: like a wrong type, another string is a TypeError (as it is for
     // a WebIDL enum)
-    bool load(handle src, bool) {
+    bool load(handle src, bool /*unused*/) {
       if (!isinstance<str>(src)) {
         return false;
       }
@@ -312,15 +341,17 @@ namespace pybind11::detail {
       return false;
     }
 
-    static handle cast(T src, return_value_policy, handle) {
+    static handle cast(T src, return_value_policy /*unused*/, handle /*unused*/) {
       for (const auto &[member, memberValue] : Enum::values) {
         if (member == src) {
           // looked up when converting, as webrtc.enums may be imported after this module
-          return module_::import("webrtc.enums").attr(Enum::name)(memberValue).release();
+          return module_::import("webrtc.enums").attr(Enum::name.text)(memberValue).release();
         }
       }
-      throw value_error(std::string(Enum::name) + " has no member for " + std::to_string(static_cast<int>(src)));
+      throw value_error(std::string(Enum::name.text) + " has no member for " + std::to_string(static_cast<int>(src)));
     }
   };
 
 } // namespace pybind11::detail
+
+#endif // PYTHON_WEBRTC_ENUMS_ENUMS_H_
diff --git a/python-webrtc/cpp/src/exceptions.cpp b/python-webrtc/cpp/src/exceptions.cpp
index e3ade2d..c259187 100644
--- a/python-webrtc/cpp/src/exceptions.cpp
+++ b/python-webrtc/cpp/src/exceptions.cpp
@@ -16,7 +16,7 @@ namespace python_webrtc {
 
   webrtc::RTCError closedError(const std::string &method, const std::string &interface) {
     return {webrtc::RTCErrorType::INVALID_STATE, "Failed to execute '" + method + "' on '" + interface +
-                                                 "': The RTCPeerConnection's signalingState is 'closed'."};
+                                                     "': The RTCPeerConnection's signalingState is 'closed'."};
   }
 
   pybind11::object rtcErrorToPython(const webrtc::RTCError &error, std::optional<int> sdpLineNumber) {
@@ -24,14 +24,16 @@ namespace python_webrtc {
     if (error.sctp_cause_code()) {
       sctpCauseCode = pybind11::int_(*error.sctp_cause_code());
     }
-    pybind11::object lineNumber = sdpLineNumber ? pybind11::object(pybind11::int_(*sdpLineNumber)) : pybind11::none();
+    const pybind11::object lineNumber =
+        sdpLineNumber ? pybind11::object(pybind11::int_(*sdpLineNumber)) : pybind11::none();
     pybind11::object detail = pybind11::none();
     if (error.error_detail() != webrtc::RTCErrorDetailType::NONE) {
       detail = pybind11::cast(error.error_detail());
     }
     // the exception classes are defined in Python, to be subclassed and constructed like any Python exception
-    return pybind11::module_::import("webrtc.exceptions").attr("_from_native")(
-        std::string(ToString(error.type())), std::string(error.message()), detail, sctpCauseCode, lineNumber);
+    return pybind11::module_::import("webrtc.exceptions")
+        .attr("_from_native")(std::string(ToString(error.type())), std::string(error.message()), detail, sctpCauseCode,
+                              lineNumber);
   }
 
   pybind11::object RTCCallbackException::ToPython() const {
@@ -39,23 +41,23 @@ namespace python_webrtc {
   }
 
   void Exceptions::Init(pybind11::module &m) {
-    pybind11::class_<RTCCallbackException>(m, "RTCCallbackException")
-        .def("toPython", &RTCCallbackException::ToPython);
+    pybind11::class_<RTCCallbackException>(m, "RTCCallbackException").def("toPython", &RTCCallbackException::ToPython);
 
-    static pybind11::exception<PythonWebRTCException> baseExc(m, "PythonWebRTCExceptionBase");
+    static const pybind11::exception<PythonWebRTCException> baseExc(m, "PythonWebRTCExceptionBase");
 
     pybind11::register_exception<PythonWebRTCException>(m, "PythonWebRTCException", baseExc);
     pybind11::register_exception<SdpParseException>(m, "SdpParseException", baseExc);
 
-    // registered last to be tried first
-    pybind11::register_exception_translator([](std::exception_ptr p) {
+    // registered last to be tried first; pybind11's translator type takes the pointer by value
+    // NOLINTNEXTLINE(performance-unnecessary-value-param)
+    pybind11::register_exception_translator([](std::exception_ptr error) {
       try {
-        if (p) {
-          std::rethrow_exception(p);
+        if (error) {
+          std::rethrow_exception(error);
         }
       } catch (const RTCException &e) {
         auto exc = rtcErrorToPython(e.error());
-        PyErr_SetObject(reinterpret_cast<PyObject *>(Py_TYPE(exc.ptr())), exc.ptr());
+        PyErr_SetObject(exc.get_type().ptr(), exc.ptr());
       }
     });
   }
diff --git a/python-webrtc/cpp/src/exceptions.h b/python-webrtc/cpp/src/exceptions.h
index 7c1decd..454a962 100644
--- a/python-webrtc/cpp/src/exceptions.h
+++ b/python-webrtc/cpp/src/exceptions.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_EXCEPTIONS_H_
+#define PYTHON_WEBRTC_EXCEPTIONS_H_
 
 #include <optional>
 #include <string>
@@ -30,11 +31,9 @@ namespace python_webrtc {
   // (see webrtc/exceptions.py).
   class RTCException : public PythonWebRTCException {
   public:
-    explicit RTCException(webrtc::RTCError error)
-        : PythonWebRTCException(error.message()), _error(std::move(error)) {}
+    explicit RTCException(webrtc::RTCError error) : PythonWebRTCException(error.message()), _error(std::move(error)) {}
 
-    RTCException(webrtc::RTCErrorType type, const std::string &msg)
-        : PythonWebRTCException(msg), _error(type, msg) {}
+    RTCException(webrtc::RTCErrorType type, const std::string &msg) : PythonWebRTCException(msg), _error(type, msg) {}
 
     [[nodiscard]] const webrtc::RTCError &error() const { return _error; }
 
@@ -76,3 +75,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_EXCEPTIONS_H_
diff --git a/python-webrtc/cpp/src/functions/functions.cpp b/python-webrtc/cpp/src/functions/functions.cpp
index 08d5a56..4e03649 100644
--- a/python-webrtc/cpp/src/functions/functions.cpp
+++ b/python-webrtc/cpp/src/functions/functions.cpp
@@ -6,8 +6,8 @@
 //
 
 #include "functions.h"
-#include "get_user_media.h"
 #include "../utils/gil.h"
+#include "get_user_media.h"
 
 namespace python_webrtc {
 
@@ -17,4 +17,4 @@ namespace python_webrtc {
           pybind11::arg("width"), pybind11::arg("height"), pybind11::arg("frameRate"));
   }
 
-}
+} // namespace python_webrtc
diff --git a/python-webrtc/cpp/src/functions/functions.h b/python-webrtc/cpp/src/functions/functions.h
index 6e1354b..8e57e15 100644
--- a/python-webrtc/cpp/src/functions/functions.h
+++ b/python-webrtc/cpp/src/functions/functions.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_FUNCTIONS_FUNCTIONS_H_
+#define PYTHON_WEBRTC_FUNCTIONS_FUNCTIONS_H_
 
 #include <pybind11/pybind11.h>
 
@@ -16,4 +17,6 @@ namespace python_webrtc {
     static void Init(pybind11::module &m);
   };
 
-}
+} // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_FUNCTIONS_FUNCTIONS_H_
diff --git a/python-webrtc/cpp/src/functions/get_user_media.cpp b/python-webrtc/cpp/src/functions/get_user_media.cpp
index b3c31a1..c293cab 100644
--- a/python-webrtc/cpp/src/functions/get_user_media.cpp
+++ b/python-webrtc/cpp/src/functions/get_user_media.cpp
@@ -18,8 +18,8 @@ namespace python_webrtc {
   namespace {
 
     // a synthetic microphone, as the audio device of the factory records nothing
-    webrtc::scoped_refptr<webrtc::AudioTrackInterface> CreateMicrophoneTrack(
-        const std::shared_ptr<PeerConnectionFactory> &factory) {
+    webrtc::scoped_refptr<webrtc::AudioTrackInterface>
+    CreateMicrophoneTrack(const std::shared_ptr<PeerConnectionFactory> &factory) {
       auto source = webrtc::make_ref_counted<RTCAudioTrackSource>();
       source->StartMicrophone();
       auto track = factory->factory()->CreateAudioTrack(webrtc::CreateRandomUuid(), source.get());
@@ -27,8 +27,8 @@ namespace python_webrtc {
       return track;
     }
 
-    webrtc::scoped_refptr<webrtc::VideoTrackInterface> CreateCameraTrack(
-        const std::shared_ptr<PeerConnectionFactory> &factory, int width, int height, double frameRate) {
+    webrtc::scoped_refptr<webrtc::VideoTrackInterface>
+    CreateCameraTrack(const std::shared_ptr<PeerConnectionFactory> &factory, int width, int height, double frameRate) {
       auto source = webrtc::make_ref_counted<RTCVideoTrackSource>(false, std::nullopt);
       source->StartCamera(width, height, frameRate);
       auto track = factory->factory()->CreateVideoTrack(source, webrtc::CreateRandomUuid());
diff --git a/python-webrtc/cpp/src/functions/get_user_media.h b/python-webrtc/cpp/src/functions/get_user_media.h
index 82ce192..b27f95f 100644
--- a/python-webrtc/cpp/src/functions/get_user_media.h
+++ b/python-webrtc/cpp/src/functions/get_user_media.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_FUNCTIONS_GET_USER_MEDIA_H_
+#define PYTHON_WEBRTC_FUNCTIONS_GET_USER_MEDIA_H_
 
 #include <memory>
 
@@ -17,4 +18,6 @@ namespace python_webrtc {
   // (https://github.com/MarshalX/python-webrtc/issues/169, https://github.com/MarshalX/python-webrtc/issues/170)
   std::shared_ptr<MediaStream> GetUserMedia(bool audio, bool video, int width, int height, double frameRate);
 
-}
+} // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_FUNCTIONS_GET_USER_MEDIA_H_
diff --git a/python-webrtc/cpp/src/interfaces/create_session_description_observer.cpp b/python-webrtc/cpp/src/interfaces/create_session_description_observer.cpp
index 8939e6f..eab326d 100644
--- a/python-webrtc/cpp/src/interfaces/create_session_description_observer.cpp
+++ b/python-webrtc/cpp/src/interfaces/create_session_description_observer.cpp
@@ -22,4 +22,4 @@ namespace python_webrtc {
     _onFailure(RTCCallbackException(std::move(error)));
   }
 
-}
+} // namespace python_webrtc
diff --git a/python-webrtc/cpp/src/interfaces/create_session_description_observer.h b/python-webrtc/cpp/src/interfaces/create_session_description_observer.h
index a3a7559..f12169f 100644
--- a/python-webrtc/cpp/src/interfaces/create_session_description_observer.h
+++ b/python-webrtc/cpp/src/interfaces/create_session_description_observer.h
@@ -5,11 +5,14 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_CREATE_SESSION_DESCRIPTION_OBSERVER_H_
+#define PYTHON_WEBRTC_INTERFACES_CREATE_SESSION_DESCRIPTION_OBSERVER_H_
 
 #include "rtc_peer_connection.h"
 
-namespace webrtc { class RTCError; }
+namespace webrtc {
+  class RTCError;
+}
 
 namespace python_webrtc {
 
@@ -17,12 +20,12 @@ namespace python_webrtc {
   public:
     CreateSessionDescriptionObserver(std::weak_ptr<RTCPeerConnection> peerConnection,
                                      std::function<void(RTCSessionDescription)> &onSuccess,
-                                     std::function<void(RTCCallbackException)> &onFailure) :
-        _peerConnection(std::move(peerConnection)), _onSuccess(onSuccess), _onFailure(onFailure) {}
+                                     std::function<void(RTCCallbackException)> &onFailure)
+        : _peerConnection(std::move(peerConnection)), _onSuccess(onSuccess), _onFailure(onFailure) {}
 
-    void OnSuccess(webrtc::SessionDescriptionInterface *) override;
+    void OnSuccess(webrtc::SessionDescriptionInterface *description) override;
 
-    void OnFailure(webrtc::RTCError) override;
+    void OnFailure(webrtc::RTCError error) override;
 
   private:
     // the connection may be gone by the time the description is created
@@ -32,3 +35,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_CREATE_SESSION_DESCRIPTION_OBSERVER_H_
diff --git a/python-webrtc/cpp/src/interfaces/interfaces.cpp b/python-webrtc/cpp/src/interfaces/interfaces.cpp
index 0ae4aa8..da6db65 100644
--- a/python-webrtc/cpp/src/interfaces/interfaces.cpp
+++ b/python-webrtc/cpp/src/interfaces/interfaces.cpp
@@ -7,23 +7,23 @@
 
 #include "interfaces.h"
 
-#include "peer_connection_factory.h"
-#include "media_stream_track.h"
-#include "media_stream.h"
-#include "rtc_ice_transport.h"
-#include "rtc_dtls_transport.h"
-#include "rtc_sctp_transport.h"
-#include "rtc_rtp_sender.h"
-#include "rtc_rtp_receiver.h"
-#include "rtc_rtp_transceiver.h"
-#include "rtc_data_channel.h"
-#include "rtc_dtmf_sender.h"
-#include "rtc_peer_connection.h"
 #include "../media/media_stream_track_processor.h"
 #include "../media/track_generator.h"
 #include "../media/video_frame_buffer.h"
 #include "../utils/alive_count.h"
 #include "../utils/gil.h"
+#include "media_stream.h"
+#include "media_stream_track.h"
+#include "peer_connection_factory.h"
+#include "rtc_data_channel.h"
+#include "rtc_dtls_transport.h"
+#include "rtc_dtmf_sender.h"
+#include "rtc_ice_transport.h"
+#include "rtc_peer_connection.h"
+#include "rtc_rtp_receiver.h"
+#include "rtc_rtp_sender.h"
+#include "rtc_rtp_transceiver.h"
+#include "rtc_sctp_transport.h"
 
 #include <map>
 #include <string>
@@ -47,23 +47,26 @@ namespace python_webrtc {
     RTCPeerConnection::Init(m);
 
     // the native objects alive, by type, so tests can check that none leaks
-    m.def("_alive", []() {
-      return std::map<std::string, int>{
-          {"RTCPeerConnection", AliveCount<RTCPeerConnection>::count.load()},
-          {"MediaStreamTrack", MediaStreamTrack::holder().Alive()},
-          {"MediaStream", MediaStream::holder().Alive()},
-          {"RTCRtpTransceiver", RTCRtpTransceiver::holder().Alive()},
-          {"RTCRtpSender", RTCRtpSender::holder().Alive()},
-          {"RTCRtpReceiver", RTCRtpReceiver::holder().Alive()},
-          {"RTCDTMFSender", RTCDTMFSender::holder().Alive()},
-          {"RTCDataChannel", RTCDataChannel::holder().Alive()},
-          {"RTCSctpTransport", RTCSctpTransport::holder().Alive()},
-          {"RTCDtlsTransport", RTCDtlsTransport::holder().Alive()},
-          {"RTCIceTransport", RTCIceTransport::holder().Alive()},
-          {"MediaStreamTrackProcessor", AliveCount<MediaStreamTrackProcessor>::count.load()},
-          {"TrackGenerator", AliveCount<TrackGenerator>::count.load()},
-          {"VideoFrameBuffer", AliveCount<VideoFrameBuffer>::count.load()},
-      };
-    }, nogil());
+    m.def(
+        "_alive",
+        []() {
+          return std::map<std::string, int>{
+              {"RTCPeerConnection", AliveCount<RTCPeerConnection>::count.load()},
+              {"MediaStreamTrack", MediaStreamTrack::holder().Alive()},
+              {"MediaStream", MediaStream::holder().Alive()},
+              {"RTCRtpTransceiver", RTCRtpTransceiver::holder().Alive()},
+              {"RTCRtpSender", RTCRtpSender::holder().Alive()},
+              {"RTCRtpReceiver", RTCRtpReceiver::holder().Alive()},
+              {"RTCDTMFSender", RTCDTMFSender::holder().Alive()},
+              {"RTCDataChannel", RTCDataChannel::holder().Alive()},
+              {"RTCSctpTransport", RTCSctpTransport::holder().Alive()},
+              {"RTCDtlsTransport", RTCDtlsTransport::holder().Alive()},
+              {"RTCIceTransport", RTCIceTransport::holder().Alive()},
+              {"MediaStreamTrackProcessor", AliveCount<MediaStreamTrackProcessor>::count.load()},
+              {"TrackGenerator", AliveCount<TrackGenerator>::count.load()},
+              {"VideoFrameBuffer", AliveCount<VideoFrameBuffer>::count.load()},
+          };
+        },
+        nogil());
   }
-}
+} // namespace python_webrtc
diff --git a/python-webrtc/cpp/src/interfaces/interfaces.h b/python-webrtc/cpp/src/interfaces/interfaces.h
index d517ae2..5c88681 100644
--- a/python-webrtc/cpp/src/interfaces/interfaces.h
+++ b/python-webrtc/cpp/src/interfaces/interfaces.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_INTERFACES_H_
+#define PYTHON_WEBRTC_INTERFACES_INTERFACES_H_
 
 #include <pybind11/pybind11.h>
 
@@ -16,4 +17,6 @@ namespace python_webrtc {
     static void Init(pybind11::module &m);
   };
 
-}
+} // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_INTERFACES_H_
diff --git a/python-webrtc/cpp/src/interfaces/media_stream.cpp b/python-webrtc/cpp/src/interfaces/media_stream.cpp
index abb3803..de80a37 100644
--- a/python-webrtc/cpp/src/interfaces/media_stream.cpp
+++ b/python-webrtc/cpp/src/interfaces/media_stream.cpp
@@ -14,54 +14,55 @@
 
 namespace python_webrtc {
 
-  MediaStream::MediaStream(
-      std::shared_ptr<PeerConnectionFactory> factory, webrtc::scoped_refptr<webrtc::MediaStreamInterface> stream)
+  MediaStream::MediaStream(std::shared_ptr<PeerConnectionFactory> factory,
+                           webrtc::scoped_refptr<webrtc::MediaStreamInterface> stream)
       : _factory(std::move(factory)), _stream(std::move(stream)) {
-    for (const auto &track: tracks()) {
+    for (const auto &track : tracks()) {
       _known.insert(track.get());
     }
     // see AliveGuard
-    _factory->_signalingThread->PostTask(_alive.Guard([this]() { _stream->RegisterObserver(this); }));
+    _factory->signalingThread()->PostTask(_alive.Guard([this]() { _stream->RegisterObserver(this); }));
   }
 
   MediaStream::~MediaStream() {
-    BlockingDestructor release("MediaStream");
-    _factory->_signalingThread->BlockingCall([this]() { _stream->UnregisterObserver(this); });
+    const BlockingDestructor release("MediaStream");
+    _factory->signalingThread()->BlockingCall([this]() { _stream->UnregisterObserver(this); });
     DropListeners();
   }
 
   void MediaStream::OnChanged() {
-    std::vector<webrtc::scoped_refptr<webrtc::MediaStreamTrackInterface>> added, removed;
+    std::vector<webrtc::scoped_refptr<webrtc::MediaStreamTrackInterface>> added;
+    std::vector<webrtc::scoped_refptr<webrtc::MediaStreamTrackInterface>> removed;
     {
-      std::lock_guard<std::mutex> lock(_tracksMutex);
+      const std::scoped_lock lock(_tracksMutex);
       std::set<webrtc::MediaStreamTrackInterface *> current;
-      for (const auto &track: tracks()) {
+      for (const auto &track : tracks()) {
         current.insert(track.get());
-        if (!_known.count(track.get())) {
+        if (!_known.contains(track.get())) {
           added.push_back(track);
         }
       }
-      for (auto track: _known) {
-        if (!current.count(track)) {
-          removed.push_back(webrtc::scoped_refptr<webrtc::MediaStreamTrackInterface>(track));
+      for (auto *track : _known) {
+        if (!current.contains(track)) {
+          removed.emplace_back(track);
         }
       }
       _known = std::move(current);
     }
-    for (const auto &track: removed) {
+    for (const auto &track : removed) {
       Emit("removetrack", MediaStreamTrack::holder().GetOrCreate(_factory, track));
     }
-    for (const auto &track: added) {
+    for (const auto &track : added) {
       Emit("addtrack", MediaStreamTrack::holder().GetOrCreate(_factory, track));
     }
   }
 
   std::vector<webrtc::scoped_refptr<webrtc::MediaStreamTrackInterface>> MediaStream::tracks() {
     auto tracks = std::vector<webrtc::scoped_refptr<webrtc::MediaStreamTrackInterface>>();
-    for (auto const &track: _stream->GetAudioTracks()) {
+    for (const auto &track : _stream->GetAudioTracks()) {
       tracks.emplace_back(track);
     }
-    for (auto const &track: _stream->GetVideoTracks()) {
+    for (const auto &track : _stream->GetVideoTracks()) {
       tracks.emplace_back(track);
     }
     return tracks;
@@ -70,7 +71,7 @@ namespace python_webrtc {
   std::vector<std::shared_ptr<MediaStreamTrack>> MediaStream::SyncTracks() {
     // Python keeps the wrappers, the holder finds them
     std::vector<std::shared_ptr<MediaStreamTrack>> tracks;
-    for (auto const &track: this->tracks()) {
+    for (const auto &track : this->tracks()) {
       tracks.push_back(MediaStreamTrack::holder().GetOrCreate(_factory, track));
     }
     return tracks;
@@ -101,7 +102,7 @@ namespace python_webrtc {
   bool MediaStream::GetActive() {
     auto active = false;
 
-    for (auto const &track: SyncTracks()) {
+    for (const auto &track : SyncTracks()) {
       active = active || track->active();
     }
 
@@ -111,7 +112,7 @@ namespace python_webrtc {
   std::vector<std::shared_ptr<MediaStreamTrack>> MediaStream::GetAudioTracks() {
     auto tracks = std::vector<std::shared_ptr<MediaStreamTrack>>();
 
-    for (auto const &track: SyncTracks()) {
+    for (const auto &track : SyncTracks()) {
       if (track->track()->kind() == webrtc::MediaStreamTrackInterface::kAudioKind) {
         tracks.push_back(track);
       }
@@ -123,7 +124,7 @@ namespace python_webrtc {
   std::vector<std::shared_ptr<MediaStreamTrack>> MediaStream::GetVideoTracks() {
     auto tracks = std::vector<std::shared_ptr<MediaStreamTrack>>();
 
-    for (auto const &track: SyncTracks()) {
+    for (const auto &track : SyncTracks()) {
       if (track->track()->kind() == webrtc::MediaStreamTrackInterface::kVideoKind) {
         tracks.push_back(track);
       }
@@ -138,7 +139,7 @@ namespace python_webrtc {
 
   std::optional<std::shared_ptr<MediaStreamTrack>> MediaStream::GetTrackById(const std::string &id) {
     // by the id Python sees, which differs from the libwebrtc one for remote tracks
-    for (const auto &track: GetTracks()) {
+    for (const auto &track : GetTracks()) {
       if (track->GetId() == id) {
         return track;
       }
@@ -150,7 +151,7 @@ namespace python_webrtc {
     auto track = mediaStreamTrack->track();
     {
       // changes made by Python fire no events
-      std::lock_guard<std::mutex> lock(_tracksMutex);
+      const std::scoped_lock lock(_tracksMutex);
       _known.insert(track.get());
     }
 
@@ -165,7 +166,7 @@ namespace python_webrtc {
     auto track = mediaStreamTrack.track();
     {
       // changes made by Python fire no events
-      std::lock_guard<std::mutex> lock(_tracksMutex);
+      const std::scoped_lock lock(_tracksMutex);
       _known.erase(track.get());
     }
 
@@ -179,16 +180,17 @@ namespace python_webrtc {
   std::shared_ptr<MediaStream> MediaStream::Clone() {
     auto clonedStream = _factory->factory()->CreateLocalMediaStream(webrtc::CreateRandomUuid());
 
-    for (auto const &track: this->tracks()) {
-      if (track->kind() == track->kAudioKind) {
-        auto audioTrack = dynamic_cast<webrtc::AudioTrackInterface *>(track.get());
-        auto source = audioTrack->GetSource();
+    for (const auto &track : this->tracks()) {
+      if (track->kind() == webrtc::MediaStreamTrackInterface::kAudioKind) {
+        auto *audioTrack = dynamic_cast<webrtc::AudioTrackInterface *>(track.get());
+        auto *source = audioTrack->GetSource();
         auto clonedTrack = _factory->factory()->CreateAudioTrack(webrtc::CreateRandomUuid(), source);
         clonedStream->AddTrack(clonedTrack);
       } else {
-        auto videoTrack = dynamic_cast<webrtc::VideoTrackInterface *>(track.get());
-        auto source = videoTrack->GetSource();
-        auto clonedTrack = _factory->factory()->CreateVideoTrack(webrtc::scoped_refptr<webrtc::VideoTrackSourceInterface>(source), webrtc::CreateRandomUuid());
+        auto *videoTrack = dynamic_cast<webrtc::VideoTrackInterface *>(track.get());
+        auto *source = videoTrack->GetSource();
+        auto clonedTrack = _factory->factory()->CreateVideoTrack(
+            webrtc::scoped_refptr<webrtc::VideoTrackSourceInterface>(source), webrtc::CreateRandomUuid());
         clonedStream->AddTrack(clonedTrack);
       }
     }
@@ -200,7 +202,7 @@ namespace python_webrtc {
     auto factory = PeerConnectionFactory::GetOrCreateDefault();
     auto stream = MediaStream::holder().GetOrCreate(
         factory, factory->factory()->CreateLocalMediaStream(webrtc::CreateRandomUuid()));
-    for (const auto &track: tracks) {
+    for (const auto &track : tracks) {
       stream->AddTrack(track);
     }
     return stream;
@@ -208,7 +210,7 @@ namespace python_webrtc {
 
   InstanceHolder<MediaStream, webrtc::MediaStreamInterface> &MediaStream::holder() {
     // never destroyed: wrappers may outlive static destructors
-    static auto holder = new InstanceHolder<MediaStream, webrtc::MediaStreamInterface>();
+    static auto *holder = new InstanceHolder<MediaStream, webrtc::MediaStreamInterface>();
     return *holder;
   }
 
diff --git a/python-webrtc/cpp/src/interfaces/media_stream.h b/python-webrtc/cpp/src/interfaces/media_stream.h
index 924b4e0..a4cce27 100644
--- a/python-webrtc/cpp/src/interfaces/media_stream.h
+++ b/python-webrtc/cpp/src/interfaces/media_stream.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_MEDIA_STREAM_H_
+#define PYTHON_WEBRTC_INTERFACES_MEDIA_STREAM_H_
 
 #include <memory>
 #include <mutex>
@@ -20,28 +21,24 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
-#include "peer_connection_factory.h"
-#include "media_stream_track.h"
 #include "../utils/alive_guard.h"
 #include "../utils/listeners.h"
-
-namespace webrtc {
-
-  class MediaStreamInterface;
-
-  class MediaStreamTrackInterface;
-
-}
+#include "media_stream_track.h"
+#include "peer_connection_factory.h"
 
 namespace python_webrtc {
 
   // Emits addtrack and removetrack when libwebrtc changes the tracks of a remote stream
   class MediaStream : public webrtc::ObserverInterface, public Listeners {
   public:
-    MediaStream(std::shared_ptr<PeerConnectionFactory>, webrtc::scoped_refptr<webrtc::MediaStreamInterface>);
+    MediaStream(std::shared_ptr<PeerConnectionFactory> factory,
+                webrtc::scoped_refptr<webrtc::MediaStreamInterface> stream);
 
     ~MediaStream() override;
 
+    MediaStream(const MediaStream &) = delete;
+    MediaStream &operator=(const MediaStream &) = delete;
+
     // ObserverInterface, on the signaling thread
     void OnChanged() override;
 
@@ -64,11 +61,11 @@ namespace python_webrtc {
 
     std::vector<std::shared_ptr<MediaStreamTrack>> GetTracks();
 
-    std::optional<std::shared_ptr<MediaStreamTrack>> GetTrackById(const std::string &);
+    std::optional<std::shared_ptr<MediaStreamTrack>> GetTrackById(const std::string &id);
 
-    void AddTrack(const std::shared_ptr<MediaStreamTrack> &);
+    void AddTrack(const std::shared_ptr<MediaStreamTrack> &mediaStreamTrack);
 
-    void RemoveTrack(MediaStreamTrack &);
+    void RemoveTrack(MediaStreamTrack &mediaStreamTrack);
 
     std::shared_ptr<MediaStream> Clone();
 
@@ -78,7 +75,6 @@ namespace python_webrtc {
     // wrappers of the current tracks of the stream; the stream owns them, so their state outlives Python references
     std::vector<std::shared_ptr<MediaStreamTrack>> SyncTracks();
 
-
     std::shared_ptr<PeerConnectionFactory> _factory;
     webrtc::scoped_refptr<webrtc::MediaStreamInterface> _stream;
 
@@ -91,3 +87,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_MEDIA_STREAM_H_
diff --git a/python-webrtc/cpp/src/interfaces/media_stream_track.cpp b/python-webrtc/cpp/src/interfaces/media_stream_track.cpp
index d014a71..bf5b998 100644
--- a/python-webrtc/cpp/src/interfaces/media_stream_track.cpp
+++ b/python-webrtc/cpp/src/interfaces/media_stream_track.cpp
@@ -7,21 +7,21 @@
 
 #include "media_stream_track.h"
 
+#include <cmath>
 #include <rtc_base/crypto_random.h>
 
-#include "rtc_video_track_source.h"
 #include "../utils/gil.h"
 #include "../utils/libwebrtc_thread.h"
+#include "rtc_video_track_source.h"
 
 namespace python_webrtc {
 
   MediaStreamTrack::MediaStreamTrack(std::shared_ptr<PeerConnectionFactory> factory,
                                      webrtc::scoped_refptr<webrtc::MediaStreamTrackInterface> track)
-      : _factory(std::move(factory)),
-        _track(std::move(track)),
+      : _factory(std::move(factory)), _track(std::move(track)),
         _source(SourceControl::Find(_track.get(), _track->id())) {
     // see AliveGuard
-    _factory->_signalingThread->PostTask(_alive.Guard([this]() {
+    _factory->signalingThread()->PostTask(_alive.Guard([this]() {
       _track->RegisterObserver(this);
       _observing = true;
       AttachMonitor();
@@ -29,10 +29,10 @@ namespace python_webrtc {
   }
 
   MediaStreamTrack::~MediaStreamTrack() {
-    BlockingDestructor release("MediaStreamTrack");
+    const BlockingDestructor release("MediaStreamTrack");
 
     // after this the track can't notify us anymore: it notifies on the same thread
-    _factory->_signalingThread->BlockingCall([this]() {
+    _factory->signalingThread()->BlockingCall([this]() {
       DetachMonitor();
       if (_observing) {
         _track->UnregisterObserver(this);
@@ -42,15 +42,7 @@ namespace python_webrtc {
 
     _track = nullptr;
     // released as the listeners are (see DropListeners)
-    {
-      PythonEntry entry;
-      if (!entry) {
-        (void) _constraints.release();
-      } else if (_constraints) {
-        pybind11::gil_scoped_acquire gil;
-        pybind11::object dropped = std::move(_constraints);
-      }
-    }
+    ReleasePythonObject(_constraints);
     DropListeners();
   }
 
@@ -100,7 +92,7 @@ namespace python_webrtc {
   void MediaStreamTrack::Stop() {
     _stopped = true;
     _surfacedEnded.Reset();
-    _factory->_signalingThread->BlockingCall([this]() { StopOnSignalingThread(); });
+    _factory->signalingThread()->BlockingCall([this]() { StopOnSignalingThread(); });
   }
 
   void MediaStreamTrack::StopOnSignalingThread() {
@@ -115,7 +107,7 @@ namespace python_webrtc {
 
   void MediaStreamTrack::AddEndObserver(const std::shared_ptr<TrackEndObserver> &observer) {
     {
-      std::lock_guard<std::mutex> lock(_endObserversMutex);
+      const std::scoped_lock lock(_endObserversMutex);
       if (!_ended) {
         _endObservers.push_back(observer);
         return;
@@ -127,10 +119,10 @@ namespace python_webrtc {
   void MediaStreamTrack::NotifyEnded() {
     std::vector<std::weak_ptr<TrackEndObserver>> observers;
     {
-      std::lock_guard<std::mutex> lock(_endObserversMutex);
+      const std::scoped_lock lock(_endObserversMutex);
       observers.swap(_endObservers);
     }
-    for (auto &observer: observers) {
+    for (auto &observer : observers) {
       if (auto locked = observer.lock()) {
         locked->OnTrackEnded();
       }
@@ -140,7 +132,7 @@ namespace python_webrtc {
   void MediaStreamTrack::OnChanged() {
     if (_track->state() == webrtc::MediaStreamTrackInterface::TrackState::kEnded && !_ended) {
       // ended by the remote peer or by renegotiation, rather than by stop()
-      bool emit = !_stopped;
+      const bool emit = !_stopped;
       if (emit) {
         // the track is live until its ended event (see Surfaced)
         _surfacedEnded.Changed(IsTracked(), false);
@@ -164,7 +156,7 @@ namespace python_webrtc {
     _muted = true;
     {
       // a remote track has its own id, rather than the one in the description, which every receiver of it shares
-      std::lock_guard<std::mutex> lock(_idMutex);
+      const std::scoped_lock lock(_idMutex);
       _id = webrtc::CreateRandomUuid();
       _label = _track->kind() == webrtc::MediaStreamTrackInterface::kAudioKind ? "remote audio" : "remote video";
     }
@@ -177,7 +169,7 @@ namespace python_webrtc {
       // an ended track stays as it was
       return;
     }
-    bool previous = _muted.exchange(muted);
+    const bool previous = _muted.exchange(muted);
     if (previous != muted) {
       // a held remote track keeps showing the previous value until its event is delivered
       _surfacedMuted.Changed(IsTracked(), previous);
@@ -214,7 +206,7 @@ namespace python_webrtc {
   }
 
   std::string MediaStreamTrack::GetId() {
-    std::lock_guard<std::mutex> lock(_idMutex);
+    const std::scoped_lock lock(_idMutex);
     return _id ? *_id : _track->id();
   }
 
@@ -223,19 +215,20 @@ namespace python_webrtc {
   }
 
   std::string MediaStreamTrack::GetLabel() {
-    std::lock_guard<std::mutex> lock(_idMutex);
+    const std::scoped_lock lock(_idMutex);
     return _label;
   }
 
   void MediaStreamTrack::SetLabel(const std::string &label) {
-    std::lock_guard<std::mutex> lock(_idMutex);
+    const std::scoped_lock lock(_idMutex);
     _label = label;
   }
 
   webrtc::MediaType MediaStreamTrack::GetKind() {
     if (_track->kind() == webrtc::MediaStreamTrackInterface::kAudioKind) {
       return webrtc::MediaType::AUDIO;
-    } else if (_track->kind() == webrtc::MediaStreamTrackInterface::kVideoKind) {
+    }
+    if (_track->kind() == webrtc::MediaStreamTrackInterface::kVideoKind) {
       return webrtc::MediaType::VIDEO;
     }
 
@@ -243,11 +236,11 @@ namespace python_webrtc {
   }
 
   webrtc::MediaStreamTrackInterface::TrackState MediaStreamTrack::GetReadyState() {
-    bool ended = _ended || _track->state() == webrtc::MediaStreamTrackInterface::TrackState::kEnded;
+    const bool ended = _ended || _track->state() == webrtc::MediaStreamTrackInterface::TrackState::kEnded;
     // without listeners (outside of an event loop), no event is going to surface it
-    return (HasListeners() ? _surfacedEnded.Get(ended) : ended)
-           ? webrtc::MediaStreamTrackInterface::TrackState::kEnded
-           : webrtc::MediaStreamTrackInterface::TrackState::kLive;
+    const bool surfaced = HasListeners() ? _surfacedEnded.Get(ended) : ended;
+    return surfaced ? webrtc::MediaStreamTrackInterface::TrackState::kEnded
+                    : webrtc::MediaStreamTrackInterface::TrackState::kLive;
   }
 
   bool MediaStreamTrack::GetMuted() {
@@ -260,12 +253,12 @@ namespace python_webrtc {
     std::optional<std::tuple<int, int, double>> camera;
     bool microphone = false;
     {
-      gil_release release;
+      const gil_release release;
       video = _monitor.video();
       audio = _monitor.audio();
       camera = GetCamera();
       if (_source) {
-        std::lock_guard<std::mutex> lock(_source->mutex);
+        const std::scoped_lock lock(_source->mutex);
         microphone = _source->microphone;
       }
     }
@@ -303,10 +296,11 @@ namespace python_webrtc {
     if (!_source) {
       return std::nullopt;
     }
-    std::lock_guard<std::mutex> lock(_source->mutex);
-    int width, height;
-    double frameRate;
-    if (!_source->camera || !_source->camera->IsCamera(&width, &height, &frameRate)) {
+    const std::scoped_lock lock(_source->mutex);
+    int width{};
+    int height{};
+    double frameRate = NAN;
+    if ((_source->camera == nullptr) || !_source->camera->IsCamera(&width, &height, &frameRate)) {
       return std::nullopt;
     }
     return std::make_tuple(width, height, frameRate);
@@ -316,8 +310,8 @@ namespace python_webrtc {
     if (!_source || _ended) {
       return false;
     }
-    std::lock_guard<std::mutex> lock(_source->mutex);
-    if (!_source->camera) {
+    const std::scoped_lock lock(_source->mutex);
+    if (_source->camera == nullptr) {
       return false;
     }
     _source->camera->StartCamera(width, height, frameRate);
@@ -334,14 +328,18 @@ namespace python_webrtc {
 
   std::string MediaStreamTrack::GetContentHint() {
     if (_track->kind() == webrtc::MediaStreamTrackInterface::kAudioKind) {
-      std::lock_guard<std::mutex> lock(_contentHintMutex);
+      const std::scoped_lock lock(_contentHintMutex);
       return _audioContentHint;
     }
     switch (static_cast<webrtc::VideoTrackInterface *>(_track.get())->content_hint()) {
-      case webrtc::VideoTrackInterface::ContentHint::kFluid: return "motion";
-      case webrtc::VideoTrackInterface::ContentHint::kDetailed: return "detail";
-      case webrtc::VideoTrackInterface::ContentHint::kText: return "text";
-      default: return "";
+    case webrtc::VideoTrackInterface::ContentHint::kFluid:
+      return "motion";
+    case webrtc::VideoTrackInterface::ContentHint::kDetailed:
+      return "detail";
+    case webrtc::VideoTrackInterface::ContentHint::kText:
+      return "text";
+    default:
+      return "";
     }
   }
 
@@ -349,13 +347,13 @@ namespace python_webrtc {
     // hints of the other kind, and unknown ones, are ignored
     if (_track->kind() == webrtc::MediaStreamTrackInterface::kAudioKind) {
       if (hint.empty() || hint == "speech" || hint == "speaking" || hint == "music") {
-        std::lock_guard<std::mutex> lock(_contentHintMutex);
+        const std::scoped_lock lock(_contentHintMutex);
         _audioContentHint = hint;
       }
       return;
     }
     using ContentHint = webrtc::VideoTrackInterface::ContentHint;
-    auto track = static_cast<webrtc::VideoTrackInterface *>(_track.get());
+    auto *track = static_cast<webrtc::VideoTrackInterface *>(_track.get());
     if (hint.empty()) {
       track->set_content_hint(ContentHint::kNone);
     } else if (hint == "motion") {
@@ -371,12 +369,13 @@ namespace python_webrtc {
     auto label = webrtc::CreateRandomUuid();
     webrtc::scoped_refptr<webrtc::MediaStreamTrackInterface> clonedTrack = nullptr;
 
-    if (_track->kind() == _track->kAudioKind) {
-      auto audioTrack = dynamic_cast<webrtc::AudioTrackInterface *>(_track.get());
+    if (_track->kind() == webrtc::MediaStreamTrackInterface::kAudioKind) {
+      auto *audioTrack = dynamic_cast<webrtc::AudioTrackInterface *>(_track.get());
       clonedTrack = _factory->factory()->CreateAudioTrack(label, audioTrack->GetSource());
     } else {
-      auto videoTrack = dynamic_cast<webrtc::VideoTrackInterface *>(_track.get());
-      clonedTrack = _factory->factory()->CreateVideoTrack(webrtc::scoped_refptr<webrtc::VideoTrackSourceInterface>(videoTrack->GetSource()), label);
+      auto *videoTrack = dynamic_cast<webrtc::VideoTrackInterface *>(_track.get());
+      clonedTrack = _factory->factory()->CreateVideoTrack(
+          webrtc::scoped_refptr<webrtc::VideoTrackSourceInterface>(videoTrack->GetSource()), label);
     }
 
     if (_source) {
@@ -392,16 +391,18 @@ namespace python_webrtc {
   }
 
   MediaStreamTrack::operator webrtc::scoped_refptr<webrtc::AudioTrackInterface>() {
-    return webrtc::scoped_refptr<webrtc::AudioTrackInterface>(dynamic_cast<webrtc::AudioTrackInterface *>(_track.get()));
+    return webrtc::scoped_refptr<webrtc::AudioTrackInterface>(
+        dynamic_cast<webrtc::AudioTrackInterface *>(_track.get()));
   }
 
   MediaStreamTrack::operator webrtc::scoped_refptr<webrtc::VideoTrackInterface>() {
-    return webrtc::scoped_refptr<webrtc::VideoTrackInterface>(dynamic_cast<webrtc::VideoTrackInterface *>(_track.get()));
+    return webrtc::scoped_refptr<webrtc::VideoTrackInterface>(
+        dynamic_cast<webrtc::VideoTrackInterface *>(_track.get()));
   }
 
   InstanceHolder<MediaStreamTrack, webrtc::MediaStreamTrackInterface> &MediaStreamTrack::holder() {
     // never destroyed: wrappers may outlive static destructors
-    static auto holder = new InstanceHolder<MediaStreamTrack, webrtc::MediaStreamTrackInterface>();
+    static auto *holder = new InstanceHolder<MediaStreamTrack, webrtc::MediaStreamTrackInterface>();
     return *holder;
   }
 
diff --git a/python-webrtc/cpp/src/interfaces/media_stream_track.h b/python-webrtc/cpp/src/interfaces/media_stream_track.h
index 71b403d..e3e0ae1 100644
--- a/python-webrtc/cpp/src/interfaces/media_stream_track.h
+++ b/python-webrtc/cpp/src/interfaces/media_stream_track.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_MEDIA_STREAM_TRACK_H_
+#define PYTHON_WEBRTC_INTERFACES_MEDIA_STREAM_TRACK_H_
 
 #include <atomic>
 #include <memory>
@@ -20,7 +21,7 @@
 
 #include <pybind11/pybind11.h>
 
-#include "peer_connection_factory.h"
+#include "../enums/enums.h"
 #include "../media/source_control.h"
 #include "../media/track_monitor.h"
 #include "../utils/alive_guard.h"
@@ -28,7 +29,7 @@
 #include "../utils/instance_holder.h"
 #include "../utils/listeners.h"
 #include "../utils/surfaced.h"
-#include "../enums/enums.h"
+#include "peer_connection_factory.h"
 
 namespace python_webrtc {
 
@@ -42,11 +43,14 @@ namespace python_webrtc {
 
   class MediaStreamTrack : public webrtc::ObserverInterface, public Listeners {
   public:
-    explicit MediaStreamTrack(
-        std::shared_ptr<PeerConnectionFactory>, webrtc::scoped_refptr<webrtc::MediaStreamTrackInterface>);
+    explicit MediaStreamTrack(std::shared_ptr<PeerConnectionFactory> factory,
+                              webrtc::scoped_refptr<webrtc::MediaStreamTrackInterface> track);
 
     ~MediaStreamTrack() override;
 
+    MediaStreamTrack(const MediaStreamTrack &) = delete;
+    MediaStreamTrack &operator=(const MediaStreamTrack &) = delete;
+
     static void Init(pybind11::module &m);
 
     static InstanceHolder<MediaStreamTrack, webrtc::MediaStreamTrackInterface> &holder();
@@ -60,7 +64,7 @@ namespace python_webrtc {
 
     bool GetEnabled();
 
-    void SetEnabled(bool);
+    void SetEnabled(bool enabled);
 
     std::string GetId();
 
@@ -176,3 +180,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_MEDIA_STREAM_TRACK_H_
diff --git a/python-webrtc/cpp/src/interfaces/peer_connection_factory.cpp b/python-webrtc/cpp/src/interfaces/peer_connection_factory.cpp
index 2064d6a..5c00c53 100644
--- a/python-webrtc/cpp/src/interfaces/peer_connection_factory.cpp
+++ b/python-webrtc/cpp/src/interfaces/peer_connection_factory.cpp
@@ -12,10 +12,10 @@
 #include "../utils/instance_holder.h"
 #include "../utils/libwebrtc_thread.h"
 
+#include <api/audio_codecs/builtin_audio_decoder_factory.h>
+#include <api/audio_codecs/builtin_audio_encoder_factory.h>
 #include <api/create_peerconnection_factory.h>
 #include <api/make_ref_counted.h>
-#include <api/audio_codecs/builtin_audio_encoder_factory.h>
-#include <api/audio_codecs/builtin_audio_decoder_factory.h>
 #include <api/video_codecs/video_decoder_factory_template.h>
 #include <api/video_codecs/video_decoder_factory_template_dav1d_adapter.h>
 #include <api/video_codecs/video_decoder_factory_template_libvpx_vp8_adapter.h>
@@ -36,21 +36,19 @@
 namespace python_webrtc {
 
   // Royalty-free codecs only (the prebuilts have no H.264).
-  using VideoEncoderFactory = webrtc::VideoEncoderFactoryTemplate<
-      webrtc::LibvpxVp8EncoderTemplateAdapter,
-      webrtc::LibvpxVp9EncoderTemplateAdapter,
-      webrtc::LibaomAv1EncoderTemplateAdapter>;
+  using VideoEncoderFactory = webrtc::VideoEncoderFactoryTemplate<webrtc::LibvpxVp8EncoderTemplateAdapter,
+                                                                  webrtc::LibvpxVp9EncoderTemplateAdapter,
+                                                                  webrtc::LibaomAv1EncoderTemplateAdapter>;
 
-  using VideoDecoderFactory = webrtc::VideoDecoderFactoryTemplate<
-      webrtc::LibvpxVp8DecoderTemplateAdapter,
-      webrtc::LibvpxVp9DecoderTemplateAdapter,
-      webrtc::Dav1dDecoderTemplateAdapter>;
+  using VideoDecoderFactory =
+      webrtc::VideoDecoderFactoryTemplate<webrtc::LibvpxVp8DecoderTemplateAdapter,
+                                          webrtc::LibvpxVp9DecoderTemplateAdapter, webrtc::Dav1dDecoderTemplateAdapter>;
 
   std::weak_ptr<PeerConnectionFactory> PeerConnectionFactory::_default{};
   std::mutex PeerConnectionFactory::_mutex{};
   std::atomic<int> PeerConnectionFactory::_alive{0};
 
-  PeerConnectionFactory::PeerConnectionFactory() : _generation(forks.load()) {
+  PeerConnectionFactory::PeerConnectionFactory() : _generation(Forks().load()) {
     _alive++;
 
     _workerThread = webrtc::Thread::CreateWithSocketServer();
@@ -73,22 +71,15 @@ namespace python_webrtc {
     assert(result);
 
     _workerThread->BlockingCall([this]() {
-      onLibwebrtcThread = true;
+      OnLibwebrtcThread() = true;
       _audioDeviceModule = webrtc::make_ref_counted<PlayoutAudioDevice>();
     });
-    _signalingThread->BlockingCall([]() { onLibwebrtcThread = true; });
+    _signalingThread->BlockingCall([]() { OnLibwebrtcThread() = true; });
 
     _factory = webrtc::CreatePeerConnectionFactory(
-        _workerThread.get(),
-        _workerThread.get(),
-        _signalingThread.get(),
-        _audioDeviceModule,
-        webrtc::CreateBuiltinAudioEncoderFactory(),
-        webrtc::CreateBuiltinAudioDecoderFactory(),
-        std::make_unique<VideoEncoderFactory>(),
-        std::make_unique<VideoDecoderFactory>(),
-        nullptr,
-        nullptr);
+        _workerThread.get(), _workerThread.get(), _signalingThread.get(), _audioDeviceModule,
+        webrtc::CreateBuiltinAudioEncoderFactory(), webrtc::CreateBuiltinAudioDecoderFactory(),
+        std::make_unique<VideoEncoderFactory>(), std::make_unique<VideoDecoderFactory>(), nullptr, nullptr);
     assert(_factory);
 
     webrtc::PeerConnectionFactoryInterface::Options options;
@@ -98,13 +89,11 @@ namespace python_webrtc {
 
   PeerConnectionFactory::~PeerConnectionFactory() {
     // stopping the threads waits for their tasks, which may be waiting for the GIL
-    BlockingDestructor release("PeerConnectionFactory");
+    const BlockingDestructor release("PeerConnectionFactory");
 
     _factory = nullptr;
 
-    _workerThread->BlockingCall([this]() {
-      this->_audioDeviceModule = nullptr;
-    });
+    _workerThread->BlockingCall([this]() { this->_audioDeviceModule = nullptr; });
 
     _workerThread->Stop();
     _signalingThread->Stop();
@@ -116,23 +105,24 @@ namespace python_webrtc {
   }
 
   void RunOnSignalingThread(PeerConnectionFactory &factory, const std::function<void()> &function) {
-    gil_release_if_held release;
-    factory._signalingThread->BlockingCall([&]() { function(); });
+    const gil_release_if_held release;
+    factory.signalingThread()->BlockingCall([&]() { function(); });
   }
 
   std::shared_ptr<PeerConnectionFactory> PeerConnectionFactory::Create() {
 #ifdef __APPLE__
     // libwebrtc runs its task queues on libdispatch, which crashes in the child of a fork
-    if (forks.load() > 0) {
-      throw std::runtime_error("python-webrtc can't be used in the child of a fork on macOS (libdispatch doesn't support "
-                               "it): use the spawn start method of multiprocessing");
+    if (Forks().load() > 0) {
+      throw std::runtime_error(
+          "python-webrtc can't be used in the child of a fork on macOS (libdispatch doesn't support "
+          "it): use the spawn start method of multiprocessing");
     }
 #endif
     return {new PeerConnectionFactory(), &PeerConnectionFactory::Destroy};
   }
 
   std::shared_ptr<PeerConnectionFactory> PeerConnectionFactory::GetOrCreateDefault() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     auto factory = _default.lock();
     if (!factory) {
       factory = Create();
@@ -143,7 +133,7 @@ namespace python_webrtc {
 
   void PeerConnectionFactory::Destroy(PeerConnectionFactory *factory) {
     // leaked while the interpreter finalizes or in a forked child: its threads may hang or be gone
-    if (!PythonAlive() || factory->_generation != forks.load()) {
+    if (!PythonAlive() || factory->_generation != Forks().load()) {
       return;
     }
     // the last owner may be released by a task on one of the factory threads, which can't stop itself
@@ -160,7 +150,7 @@ namespace python_webrtc {
   }
 
   void PeerConnectionFactory::Init(pybind11::module &m) {
-    [[maybe_unused]] bool result = webrtc::InitializeSSL();
+    [[maybe_unused]] const bool result = webrtc::InitializeSSL();
     assert(result);
 
 #ifndef _WIN32
@@ -175,7 +165,7 @@ namespace python_webrtc {
           _mutex.unlock();
         },
         []() {
-          forks++;
+          Forks()++;
           _default.reset();
           Wakeup::UnlockAfterFork();
           _mutex.unlock();
diff --git a/python-webrtc/cpp/src/interfaces/peer_connection_factory.h b/python-webrtc/cpp/src/interfaces/peer_connection_factory.h
index dc095b7..38e748b 100644
--- a/python-webrtc/cpp/src/interfaces/peer_connection_factory.h
+++ b/python-webrtc/cpp/src/interfaces/peer_connection_factory.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_PEER_CONNECTION_FACTORY_H_
+#define PYTHON_WEBRTC_INTERFACES_PEER_CONNECTION_FACTORY_H_
 
 #include <atomic>
 #include <memory>
@@ -13,18 +14,12 @@
 
 #include <api/peer_connection_interface.h>
 #include <api/scoped_refptr.h>
-#include <rtc_base/thread.h>
 #include <modules/audio_device/include/audio_device.h>
+#include <rtc_base/thread.h>
 
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
-namespace webrtc {
-
-  class PeerConnectionFactoryInterface;
-
-}  // namespace webrtc
-
 namespace python_webrtc {
 
   // Owned by every wrapper created with it, it's destroyed together with the last of them.
@@ -34,6 +29,9 @@ namespace python_webrtc {
 
     ~PeerConnectionFactory();
 
+    PeerConnectionFactory(const PeerConnectionFactory &) = delete;
+    PeerConnectionFactory &operator=(const PeerConnectionFactory &) = delete;
+
     static std::shared_ptr<PeerConnectionFactory> Create();
 
     // The factory shared by everything created without an explicit one, alive while anything uses it.
@@ -45,14 +43,18 @@ namespace python_webrtc {
 
     static void Dispose();
 
+    webrtc::Thread *signalingThread() { return _signalingThread.get(); }
+
+    webrtc::Thread *workerThread() { return _workerThread.get(); }
+
+  private:
     std::unique_ptr<webrtc::Thread> _signalingThread;
     std::unique_ptr<webrtc::Thread> _workerThread;
 
-  private:
     // of the process the factory was created in (see forks)
     const int _generation;
 
-    static void Destroy(PeerConnectionFactory *);
+    static void Destroy(PeerConnectionFactory *factory);
 
     static std::weak_ptr<PeerConnectionFactory> _default;
     static std::mutex _mutex;
@@ -64,3 +66,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_PEER_CONNECTION_FACTORY_H_
diff --git a/python-webrtc/cpp/src/interfaces/rtc_audio_track_source.cpp b/python-webrtc/cpp/src/interfaces/rtc_audio_track_source.cpp
index 479a703..720a339 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_audio_track_source.cpp
+++ b/python-webrtc/cpp/src/interfaces/rtc_audio_track_source.cpp
@@ -24,15 +24,15 @@ namespace python_webrtc {
   }
 
   void RTCAudioTrackSource::AddSink(webrtc::AudioTrackSinkInterface *sink) {
-    std::lock_guard<std::mutex> lock(_sinkMutex);
-    if (std::find(_sinks.begin(), _sinks.end(), sink) == _sinks.end()) {
+    const std::scoped_lock lock(_sinkMutex);
+    if (std::ranges::find(_sinks, sink) == _sinks.end()) {
       _sinks.push_back(sink);
     }
   }
 
   void RTCAudioTrackSource::RemoveSink(webrtc::AudioTrackSinkInterface *sink) {
-    std::lock_guard<std::mutex> lock(_sinkMutex);
-    _sinks.erase(std::remove(_sinks.begin(), _sinks.end(), sink), _sinks.end());
+    const std::scoped_lock lock(_sinkMutex);
+    std::erase(_sinks, sink);
   }
 
   void RTCAudioTrackSource::End() {
@@ -41,29 +41,35 @@ namespace python_webrtc {
     }
   }
 
-  void RTCAudioTrackSource::PushSamples(
-      const void *samples, int bitsPerSample, int sampleRate, size_t channels, size_t frames) {
-    std::lock_guard<std::mutex> lock(_sinkMutex);
-    for (auto sink: _sinks) {
+  void RTCAudioTrackSource::PushSamples(const void *samples, int bitsPerSample, int sampleRate, size_t channels,
+                                        size_t frames) {
+    const std::scoped_lock lock(_sinkMutex);
+    for (auto *sink : _sinks) {
       sink->OnData(samples, bitsPerSample, sampleRate, channels, frames, std::nullopt);
     }
   }
 
   void RTCAudioTrackSource::StartMicrophone() {
     constexpr int sampleRate = 48000;
-    constexpr size_t frames = sampleRate / 100;
+    constexpr auto interval = std::chrono::milliseconds(10);
+    constexpr size_t frames = sampleRate * interval.count() / 1000;
+    constexpr int bitsPerSample = 16;
+    // quiet noise (within 256 of silence), from a linear congruential generator (Numerical Recipes constants)
+    constexpr uint32_t multiplier = 1664525;
+    constexpr uint32_t increment = 1013904223;
+    constexpr int seedShift = 16;
+    constexpr int amplitude = 256;
     // the thread never holds a reference to the source, so the source isn't destroyed on it
-    auto tick = [this, samples = std::vector<int16_t>(frames), seed = uint32_t(1)]() mutable {
-      for (auto &sample: samples) {
-        // quiet noise (within 256 of silence), from a linear congruential generator (Numerical Recipes constants)
-        seed = seed * 1664525 + 1013904223;
-        sample = static_cast<int16_t>(static_cast<int32_t>(seed >> 16) % 512 - 256);
+    auto tick = [this, samples = std::vector<int16_t>(frames), seed = uint32_t{1}]() mutable {
+      for (auto &sample : samples) {
+        seed = (seed * multiplier) + increment;
+        sample = static_cast<int16_t>((static_cast<int32_t>(seed >> seedShift) % (2 * amplitude)) - amplitude);
       }
-      PushSamples(samples.data(), 16, sampleRate, 1, frames);
+      PushSamples(samples.data(), bitsPerSample, sampleRate, 1, frames);
     };
     _control = std::make_shared<SourceControl>();
     _control->microphone = true;
-    _microphone.Start(std::chrono::milliseconds(10), std::move(tick));
+    _microphone.Start(interval, std::move(tick));
   }
 
 } // namespace python_webrtc
diff --git a/python-webrtc/cpp/src/interfaces/rtc_audio_track_source.h b/python-webrtc/cpp/src/interfaces/rtc_audio_track_source.h
index b8f7594..146d6ae 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_audio_track_source.h
+++ b/python-webrtc/cpp/src/interfaces/rtc_audio_track_source.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_RTC_AUDIO_TRACK_SOURCE_H_
+#define PYTHON_WEBRTC_INTERFACES_RTC_AUDIO_TRACK_SOURCE_H_
 
 #include <atomic>
 #include <memory>
@@ -39,9 +40,9 @@ namespace python_webrtc {
     // ends the tracks of the source; must be called on the signaling thread, where they observe it
     void End();
 
-    void AddSink(webrtc::AudioTrackSinkInterface *) override;
+    void AddSink(webrtc::AudioTrackSinkInterface * /*unused*/) override;
 
-    void RemoveSink(webrtc::AudioTrackSinkInterface *) override;
+    void RemoveSink(webrtc::AudioTrackSinkInterface * /*unused*/) override;
 
   private:
     // guards the sinks (the sender, processors), removed (and maybe destroyed) on other threads than the one pushing
@@ -55,3 +56,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_RTC_AUDIO_TRACK_SOURCE_H_
diff --git a/python-webrtc/cpp/src/interfaces/rtc_data_channel.cpp b/python-webrtc/cpp/src/interfaces/rtc_data_channel.cpp
index f1d38f4..2323768 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_data_channel.cpp
+++ b/python-webrtc/cpp/src/interfaces/rtc_data_channel.cpp
@@ -15,14 +15,14 @@
 
 namespace python_webrtc {
 
-  RTCDataChannel::RTCDataChannel(
-      std::shared_ptr<PeerConnectionFactory> factory, webrtc::scoped_refptr<webrtc::DataChannelInterface> channel)
+  RTCDataChannel::RTCDataChannel(std::shared_ptr<PeerConnectionFactory> factory,
+                                 webrtc::scoped_refptr<webrtc::DataChannelInterface> channel)
       : _factory(std::move(factory)), _channel(std::move(channel)) {
     Hold();
     // open only once the open event is delivered
     _surfacedState.Surface(DataState::kConnecting);
     // see AliveGuard
-    _factory->_signalingThread->PostTask(_alive.Guard([this]() {
+    _factory->signalingThread()->PostTask(_alive.Guard([this]() {
       _lastState = _channel->state();
       if (_lastState != DataState::kOpen && _lastState != DataState::kConnecting) {
         _surfacedState.Surface(_lastState);
@@ -38,10 +38,10 @@ namespace python_webrtc {
   }
 
   RTCDataChannel::~RTCDataChannel() {
-    BlockingDestructor release("RTCDataChannel");
+    const BlockingDestructor release("RTCDataChannel");
 
     // callbacks run on the signaling thread, so after this none of them can be running or start again
-    _factory->_signalingThread->BlockingCall([this]() {
+    _factory->signalingThread()->BlockingCall([this]() {
       // a newer wrapper of the channel may have taken its single observer slot
       if (holder().TakeObserver(_channel.get(), this)) {
         _channel->UnregisterObserver();
@@ -85,7 +85,7 @@ namespace python_webrtc {
 
   InstanceHolder<RTCDataChannel, webrtc::DataChannelInterface> &RTCDataChannel::holder() {
     // never destroyed: wrappers may outlive static destructors
-    static auto holder = new InstanceHolder<RTCDataChannel, webrtc::DataChannelInterface>();
+    static auto *holder = new InstanceHolder<RTCDataChannel, webrtc::DataChannelInterface>();
     return *holder;
   }
 
@@ -98,7 +98,7 @@ namespace python_webrtc {
     _lastState = state;
 
     {
-      std::lock_guard<std::mutex> lock(_closeMutex);
+      const std::scoped_lock lock(_closeMutex);
       if (_closeRequested && state == DataState::kClosing) {
         // closing locally has shown the closing state already, and fires no event
         return;
@@ -107,33 +107,34 @@ namespace python_webrtc {
     }
 
     switch (state) {
-      case DataState::kOpen:
-        Emit("open", state);
-        break;
-      case DataState::kClosing:
-        Emit("closing", state);
-        break;
-      case DataState::kClosed: {
-        auto error = _channel->error();
-        // closing locally isn't an error, even if queued messages couldn't be sent
-        bool closedLocally;
-        {
-          std::lock_guard<std::mutex> lock(_closeMutex);
-          closedLocally = _closeRequested;
-        }
-        if (!error.ok() && !closedLocally) {
-          Emit("error", RTCCallbackException(std::move(error)));
-        }
-        Emit("close", state);
-        break;
+    case DataState::kOpen:
+      Emit("open", state);
+      break;
+    case DataState::kClosing:
+      Emit("closing", state);
+      break;
+    case DataState::kClosed: {
+      auto error = _channel->error();
+      // closing locally isn't an error, even if queued messages couldn't be sent
+      bool closedLocally = false;
+      {
+        const std::scoped_lock lock(_closeMutex);
+        closedLocally = _closeRequested;
       }
-      default:
-        break;
+      if (!error.ok() && !closedLocally) {
+        Emit("error", RTCCallbackException(std::move(error)));
+      }
+      Emit("close", state);
+      break;
+    }
+    default:
+      break;
     }
   }
 
   void RTCDataChannel::OnMessage(const webrtc::DataBuffer &buffer) {
-    Emit("message", DataChannelMessage{std::string(buffer.data.cdata<char>(), buffer.size()), buffer.binary});
+    Emit("message",
+         DataChannelMessage{.data = std::string(buffer.data.cdata<char>(), buffer.size()), .binary = buffer.binary});
   }
 
   void RTCDataChannel::OnBufferedAmountChange(uint64_t sentDataSize) {
@@ -142,7 +143,7 @@ namespace python_webrtc {
   }
 
   void RTCDataChannel::OnAnnounced() {
-    std::lock_guard<std::mutex> lock(_closeMutex);
+    const std::scoped_lock lock(_closeMutex);
     // a channel announced by the remote peer is open when its datachannel event fires
     if (_lastState == DataState::kConnecting || _lastState == DataState::kOpen) {
       _surfacedState.Surface(DataState::kOpen);
@@ -192,14 +193,17 @@ namespace python_webrtc {
 
   webrtc::Priority RTCDataChannel::GetPriority() {
     // the ranges Chromium maps priority values to
+    constexpr int veryLowMax = 192;
+    constexpr int lowMax = 384;
+    constexpr int mediumMax = 768;
     auto value = _channel->priority().value();
-    if (value <= 192) {
+    if (value <= veryLowMax) {
       return webrtc::Priority::kVeryLow;
     }
-    if (value <= 384) {
+    if (value <= lowMax) {
       return webrtc::Priority::kLow;
     }
-    if (value <= 768) {
+    if (value <= mediumMax) {
       return webrtc::Priority::kMedium;
     }
     return webrtc::Priority::kHigh;
@@ -210,7 +214,7 @@ namespace python_webrtc {
   }
 
   void RTCDataChannel::SurfaceState(DataState state) {
-    std::lock_guard<std::mutex> lock(_closeMutex);
+    const std::scoped_lock lock(_closeMutex);
     // an open event that was queued before closing locally doesn't reopen the channel
     if (_closeRequested && state == DataState::kOpen) {
       return;
@@ -242,19 +246,24 @@ namespace python_webrtc {
   }
 
   bool RTCDataChannel::DecreaseBufferedAmount(uint64_t sent) {
+    auto decrease = [sent](uint64_t value) { return value > sent ? value - sent : 0; };
     uint64_t amount = _bufferedAmount.load();
-    uint64_t decreased;
-    do {
-      decreased = amount > sent ? amount - sent : 0;
-    } while (!_bufferedAmount.compare_exchange_weak(amount, decreased));
+    uint64_t decreased = decrease(amount);
+    while (!_bufferedAmount.compare_exchange_weak(amount, decreased)) {
+      decreased = decrease(amount);
+    }
 
     auto threshold = _bufferedAmountLowThreshold.load();
     return amount > threshold && decreased <= threshold;
   }
 
-  static RTCException sendQueueFullError() {
-    return {webrtc::RTCErrorType::RESOURCE_EXHAUSTED, "The send queue of the RTCDataChannel is full"};
-  }
+  namespace {
+
+    RTCException sendQueueFullError() {
+      return {webrtc::RTCErrorType::RESOURCE_EXHAUSTED, "The send queue of the RTCDataChannel is full"};
+    }
+
+  } // namespace
 
   void RTCDataChannel::Send(const std::string &data, bool binary) {
     if (GetReadyState() != DataState::kOpen) {
@@ -283,7 +292,7 @@ namespace python_webrtc {
     // read before locking: it's a call to the signaling thread, which takes the lock in OnStateChange
     auto current = _channel->state();
     {
-      std::lock_guard<std::mutex> lock(_closeMutex);
+      const std::scoped_lock lock(_closeMutex);
       auto state = _surfacedState.Get(current);
       if (state == DataState::kClosing || state == DataState::kClosed) {
         return;
diff --git a/python-webrtc/cpp/src/interfaces/rtc_data_channel.h b/python-webrtc/cpp/src/interfaces/rtc_data_channel.h
index 20bea2e..c8925c4 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_data_channel.h
+++ b/python-webrtc/cpp/src/interfaces/rtc_data_channel.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_RTC_DATA_CHANNEL_H_
+#define PYTHON_WEBRTC_INTERFACES_RTC_DATA_CHANNEL_H_
 
 #include <atomic>
 #include <functional>
@@ -18,13 +19,13 @@
 
 #include <pybind11/pybind11.h>
 
-#include "peer_connection_factory.h"
+#include "../enums/enums.h"
 #include "../utils/alive_guard.h"
 #include "../utils/instance_holder.h"
 #include "../utils/listeners.h"
 #include "../utils/locked_function.h"
 #include "../utils/surfaced.h"
-#include "../enums/enums.h"
+#include "peer_connection_factory.h"
 
 namespace python_webrtc {
 
@@ -39,10 +40,14 @@ namespace python_webrtc {
     using DataState = webrtc::DataChannelInterface::DataState;
 
     // Starts holding its events (see Listeners::Hold), Python releases them once it has the channel
-    RTCDataChannel(std::shared_ptr<PeerConnectionFactory>, webrtc::scoped_refptr<webrtc::DataChannelInterface>);
+    RTCDataChannel(std::shared_ptr<PeerConnectionFactory> factory,
+                   webrtc::scoped_refptr<webrtc::DataChannelInterface> channel);
 
     ~RTCDataChannel() override;
 
+    RTCDataChannel(const RTCDataChannel &) = delete;
+    RTCDataChannel &operator=(const RTCDataChannel &) = delete;
+
     static void Init(pybind11::module &m);
 
     static InstanceHolder<RTCDataChannel, webrtc::DataChannelInterface> &holder();
@@ -129,3 +134,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_RTC_DATA_CHANNEL_H_
diff --git a/python-webrtc/cpp/src/interfaces/rtc_dtls_transport.cpp b/python-webrtc/cpp/src/interfaces/rtc_dtls_transport.cpp
index 65ba0be..dbda994 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_dtls_transport.cpp
+++ b/python-webrtc/cpp/src/interfaces/rtc_dtls_transport.cpp
@@ -10,37 +10,42 @@
 #include <pybind11/stl.h>
 
 #include "../exceptions.h"
+#include "../utils/buffer.h"
 #include "../utils/gil.h"
 #include "../utils/libwebrtc_thread.h"
 
 namespace python_webrtc {
 
-  static std::vector<webrtc::Buffer> copyCertificates(const webrtc::DtlsTransportInformation& information) {
-    auto certificates = information.remote_ssl_certificates();
-    if (certificates) {
-      auto size = certificates->GetSize();
+  namespace {
 
-      auto derCertificates = std::vector<webrtc::Buffer>();
-      derCertificates.reserve(size);
+    std::vector<webrtc::Buffer> copyCertificates(const webrtc::DtlsTransportInformation &information) {
+      const auto *certificates = information.remote_ssl_certificates();
+      if (certificates != nullptr) {
+        auto size = certificates->GetSize();
 
-      for (unsigned long i = 0; i < size; ++i) {
-        webrtc::Buffer buffer;
-        certificates->Get(i).ToDER(&buffer);
-        derCertificates.emplace_back(std::move(buffer));
+        auto derCertificates = std::vector<webrtc::Buffer>();
+        derCertificates.reserve(size);
+
+        for (unsigned long i = 0; i < size; ++i) {
+          webrtc::Buffer buffer;
+          certificates->Get(i).ToDER(&buffer);
+          derCertificates.emplace_back(std::move(buffer));
+        }
+
+        return derCertificates;
       }
 
-      return derCertificates;
+      return {};
     }
 
-    return {};
-  }
+  } // namespace
 
-  RTCDtlsTransport::RTCDtlsTransport(
-      std::shared_ptr<PeerConnectionFactory> factory, webrtc::scoped_refptr<webrtc::DtlsTransportInterface> transport
-  ) : _factory(std::move(factory)), _transport(std::move(transport)) {
+  RTCDtlsTransport::RTCDtlsTransport(std::shared_ptr<PeerConnectionFactory> factory,
+                                     webrtc::scoped_refptr<webrtc::DtlsTransportInterface> transport)
+      : _factory(std::move(factory)), _transport(std::move(transport)) {
     _iceTransport = RTCIceTransport::holder().GetOrCreate(_factory, _transport->ice_transport());
 
-    _factory->_workerThread->BlockingCall([this]() {
+    _factory->workerThread()->BlockingCall([this]() {
       _transport->RegisterObserver(this);
       holder().SetObserver(_transport.get(), this);
       _observing = true;
@@ -56,10 +61,10 @@ namespace python_webrtc {
   }
 
   RTCDtlsTransport::~RTCDtlsTransport() {
-    BlockingDestructor release("RTCDtlsTransport");
+    const BlockingDestructor release("RTCDtlsTransport");
 
     // callbacks run on the network thread, so after this none of them can be running or start again
-    _factory->_workerThread->BlockingCall([this]() { Unobserve(); });
+    _factory->workerThread()->BlockingCall([this]() { Unobserve(); });
 
     _iceTransport = nullptr;
     _transport = nullptr;
@@ -70,28 +75,28 @@ namespace python_webrtc {
     Listeners::BindClass<RTCDtlsTransport>(m, "RTCDtlsTransport")
         .def_property_readonly("iceTransport", nogil_fn(&RTCDtlsTransport::GetIceTransport))
         .def_property_readonly("state", nogil_fn(&RTCDtlsTransport::GetState))
-        .def("getRemoteCertificates", [](RTCDtlsTransport &self) {
-          pybind11::list certificates;
-          for (const auto &certificate: self.GetRemoteCertificates()) {
-            auto data = reinterpret_cast<const char *>(certificate.data());
-            certificates.append(pybind11::bytes(data, certificate.size()));
-          }
-          return certificates;
-        })
+        .def("getRemoteCertificates",
+             [](RTCDtlsTransport &self) {
+               pybind11::list certificates;
+               for (const auto &certificate : self.GetRemoteCertificates()) {
+                 certificates.append(Bytes(certificate.data(), certificate.size()));
+               }
+               return certificates;
+             })
         .def("_surfaceState", &RTCDtlsTransport::SurfaceState, nogil(), pybind11::arg("state"));
   }
 
   InstanceHolder<RTCDtlsTransport, webrtc::DtlsTransportInterface> &RTCDtlsTransport::holder() {
     // never destroyed: wrappers may outlive static destructors
-    static auto holder = new InstanceHolder<RTCDtlsTransport, webrtc::DtlsTransportInterface>();
+    static auto *holder = new InstanceHolder<RTCDtlsTransport, webrtc::DtlsTransportInterface>();
     return *holder;
   }
 
   void RTCDtlsTransport::OnStateChange(webrtc::DtlsTransportInformation information) {
-    bool changed;
-    webrtc::DtlsTransportState previous;
+    bool changed = false;
+    webrtc::DtlsTransportState previous{};
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       previous = _state;
       changed = _state != information.state();
       _state = information.state();
@@ -141,18 +146,19 @@ namespace python_webrtc {
   }
 
   webrtc::DtlsTransportState RTCDtlsTransport::GetState() {
-    webrtc::DtlsTransportState state;
+    webrtc::DtlsTransportState state{};
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       state = _state;
     }
     return _surfacedState.Get(state);
   }
 
   std::vector<webrtc::Buffer> RTCDtlsTransport::GetRemoteCertificates() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     std::vector<webrtc::Buffer> certificates;
-    for (const auto &certificate: _certificates) {
+    certificates.reserve(_certificates.size());
+    for (const auto &certificate : _certificates) {
       certificates.emplace_back(certificate.data(), certificate.size());
     }
     return certificates;
diff --git a/python-webrtc/cpp/src/interfaces/rtc_dtls_transport.h b/python-webrtc/cpp/src/interfaces/rtc_dtls_transport.h
index 4e96423..5603f0e 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_dtls_transport.h
+++ b/python-webrtc/cpp/src/interfaces/rtc_dtls_transport.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_RTC_DTLS_TRANSPORT_H_
+#define PYTHON_WEBRTC_INTERFACES_RTC_DTLS_TRANSPORT_H_
 
 #include <memory>
 #include <mutex>
@@ -15,30 +16,34 @@
 
 #include <pybind11/pybind11.h>
 
-#include "peer_connection_factory.h"
-#include "rtc_ice_transport.h"
+#include "../enums/enums.h"
 #include "../utils/instance_holder.h"
 #include "../utils/listeners.h"
 #include "../utils/surfaced.h"
-#include "../enums/enums.h"
+#include "peer_connection_factory.h"
+#include "rtc_ice_transport.h"
 
 namespace python_webrtc {
 
   class RTCDtlsTransport : public webrtc::DtlsTransportObserverInterface, public Listeners, public SingleObserverSlot {
   public:
-    explicit RTCDtlsTransport(std::shared_ptr<PeerConnectionFactory>, webrtc::scoped_refptr<webrtc::DtlsTransportInterface>);
+    explicit RTCDtlsTransport(std::shared_ptr<PeerConnectionFactory> factory,
+                              webrtc::scoped_refptr<webrtc::DtlsTransportInterface> transport);
 
     ~RTCDtlsTransport() override;
 
+    RTCDtlsTransport(const RTCDtlsTransport &) = delete;
+    RTCDtlsTransport &operator=(const RTCDtlsTransport &) = delete;
+
     static void Init(pybind11::module &m);
 
     static InstanceHolder<RTCDtlsTransport, webrtc::DtlsTransportInterface> &holder();
 
     webrtc::scoped_refptr<webrtc::DtlsTransportInterface> transport() { return _transport; }
 
-    void OnStateChange(webrtc::DtlsTransportInformation) override;
+    void OnStateChange(webrtc::DtlsTransportInformation info) override;
 
-    void OnError(webrtc::RTCError) override;
+    void OnError(webrtc::RTCError error) override;
 
     // a closed connection fires no events of its transports, which show their current state
     void OnPeerConnectionClosed();
@@ -75,3 +80,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_RTC_DTLS_TRANSPORT_H_
diff --git a/python-webrtc/cpp/src/interfaces/rtc_dtmf_sender.cpp b/python-webrtc/cpp/src/interfaces/rtc_dtmf_sender.cpp
index 40de318..1e5e71d 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_dtmf_sender.cpp
+++ b/python-webrtc/cpp/src/interfaces/rtc_dtmf_sender.cpp
@@ -15,21 +15,21 @@
 
 namespace python_webrtc {
 
-  RTCDTMFSender::RTCDTMFSender(
-      std::shared_ptr<PeerConnectionFactory> factory, webrtc::scoped_refptr<webrtc::DtmfSenderInterface> dtmf)
+  RTCDTMFSender::RTCDTMFSender(std::shared_ptr<PeerConnectionFactory> factory,
+                               webrtc::scoped_refptr<webrtc::DtmfSenderInterface> dtmf)
       : _factory(std::move(factory)), _dtmf(std::move(dtmf)) {
     // see AliveGuard
-    _factory->_signalingThread->PostTask(_alive.Guard([this]() {
+    _factory->signalingThread()->PostTask(_alive.Guard([this]() {
       _dtmf->RegisterObserver(this);
       holder().SetObserver(_dtmf.get(), this);
     }));
   }
 
   RTCDTMFSender::~RTCDTMFSender() {
-    BlockingDestructor release("RTCDTMFSender");
+    const BlockingDestructor release("RTCDTMFSender");
 
     // callbacks run on the signaling thread, so after this none of them can be running or start again
-    _factory->_signalingThread->BlockingCall([this]() {
+    _factory->signalingThread()->BlockingCall([this]() {
       // a newer wrapper of the sender may have taken its single observer slot
       if (holder().TakeObserver(_dtmf.get(), this)) {
         _dtmf->UnregisterObserver();
@@ -42,26 +42,27 @@ namespace python_webrtc {
     Listeners::BindClass<RTCDTMFSender>(m, "RTCDTMFSender")
         .def_property_readonly("toneBuffer", nogil_fn(&RTCDTMFSender::GetToneBuffer))
         .def_property_readonly("canInsertDTMF", nogil_fn(&RTCDTMFSender::GetCanInsertDtmf))
-        .def("insertDTMF", &RTCDTMFSender::InsertDtmf, nogil(),
-             pybind11::arg("tones"), pybind11::arg("duration"), pybind11::arg("interToneGap"))
-        .def("_surfaceBuffer", &RTCDTMFSender::SurfaceBuffer, nogil(),
-             pybind11::arg("buffer"), pybind11::arg("insertion"));
+        .def("insertDTMF", &RTCDTMFSender::InsertDtmf, nogil(), pybind11::arg("tones"), pybind11::arg("duration"),
+             pybind11::arg("interToneGap"))
+        .def("_surfaceBuffer", &RTCDTMFSender::SurfaceBuffer, nogil(), pybind11::arg("buffer"),
+             pybind11::arg("insertion"));
   }
 
   InstanceHolder<RTCDTMFSender, webrtc::DtmfSenderInterface> &RTCDTMFSender::holder() {
     // never destroyed: wrappers may outlive static destructors
-    static auto holder = new InstanceHolder<RTCDTMFSender, webrtc::DtmfSenderInterface>();
+    static auto *holder = new InstanceHolder<RTCDTMFSender, webrtc::DtmfSenderInterface>();
     return *holder;
   }
 
-  void RTCDTMFSender::SetTransceiver(std::function<webrtc::scoped_refptr<webrtc::RtpTransceiverInterface>()> transceiver) {
+  void
+  RTCDTMFSender::SetTransceiver(std::function<webrtc::scoped_refptr<webrtc::RtpTransceiverInterface>()> transceiver) {
     _transceiver.Set(std::move(transceiver));
   }
 
   void RTCDTMFSender::OnToneChange(const std::string &tone, const std::string &toneBuffer) {
-    uint64_t insertion;
+    uint64_t insertion = 0;
     {
-      std::lock_guard<std::mutex> lock(_bufferMutex);
+      const std::scoped_lock lock(_bufferMutex);
       insertion = _insertions;
     }
     Emit("tonechange", tone, toneBuffer, insertion);
@@ -84,20 +85,23 @@ namespace python_webrtc {
     }
     {
       // tone changes of the tones inserted before don't change the buffer anymore
-      std::lock_guard<std::mutex> lock(_bufferMutex);
+      const std::scoped_lock lock(_bufferMutex);
       ++_insertions;
     }
     // libwebrtc takes longer tones and gaps than the specification
-    if (!_dtmf->InsertDtmf(tones, std::max(duration, 70), std::max(interToneGap, 50)) && !tones.empty()) {
+    constexpr int minDuration = 70;
+    constexpr int minInterToneGap = 50;
+    if (!_dtmf->InsertDtmf(tones, std::max(duration, minDuration), std::max(interToneGap, minInterToneGap)) &&
+        !tones.empty()) {
       throw RTCException(webrtc::RTCErrorType::INVALID_STATE, "The DTMF sender can't send tones yet");
     }
-    std::lock_guard<std::mutex> lock(_bufferMutex);
+    const std::scoped_lock lock(_bufferMutex);
     _surfacedBuffer = tones;
   }
 
   std::string RTCDTMFSender::GetToneBuffer() {
     {
-      std::lock_guard<std::mutex> lock(_bufferMutex);
+      const std::scoped_lock lock(_bufferMutex);
       if (HasListeners() && _surfacedBuffer) {
         return *_surfacedBuffer;
       }
@@ -106,7 +110,7 @@ namespace python_webrtc {
   }
 
   void RTCDTMFSender::SurfaceBuffer(const std::string &buffer, uint64_t insertion) {
-    std::lock_guard<std::mutex> lock(_bufferMutex);
+    const std::scoped_lock lock(_bufferMutex);
     // a tone played before the last insertDTMF() doesn't change what it set
     if (insertion == _insertions) {
       _surfacedBuffer = buffer;
diff --git a/python-webrtc/cpp/src/interfaces/rtc_dtmf_sender.h b/python-webrtc/cpp/src/interfaces/rtc_dtmf_sender.h
index e924e6c..c906a67 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_dtmf_sender.h
+++ b/python-webrtc/cpp/src/interfaces/rtc_dtmf_sender.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_RTC_DTMF_SENDER_H_
+#define PYTHON_WEBRTC_INTERFACES_RTC_DTMF_SENDER_H_
 
 #include <functional>
 #include <memory>
@@ -18,21 +19,25 @@
 
 #include <pybind11/pybind11.h>
 
-#include "peer_connection_factory.h"
 #include "../utils/alive_guard.h"
 #include "../utils/instance_holder.h"
 #include "../utils/listeners.h"
 #include "../utils/locked_function.h"
+#include "peer_connection_factory.h"
 
 namespace python_webrtc {
 
   // Sends DTMF tones on an audio sender (webrtc.RTCDTMFSender)
   class RTCDTMFSender : public webrtc::DtmfSenderObserverInterface, public Listeners, public SingleObserverSlot {
   public:
-    RTCDTMFSender(std::shared_ptr<PeerConnectionFactory>, webrtc::scoped_refptr<webrtc::DtmfSenderInterface>);
+    RTCDTMFSender(std::shared_ptr<PeerConnectionFactory> factory,
+                  webrtc::scoped_refptr<webrtc::DtmfSenderInterface> dtmf);
 
     ~RTCDTMFSender() override;
 
+    RTCDTMFSender(const RTCDTMFSender &) = delete;
+    RTCDTMFSender &operator=(const RTCDTMFSender &) = delete;
+
     static void Init(pybind11::module &m);
 
     static InstanceHolder<RTCDTMFSender, webrtc::DtmfSenderInterface> &holder();
@@ -67,3 +72,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_RTC_DTMF_SENDER_H_
diff --git a/python-webrtc/cpp/src/interfaces/rtc_ice_transport.cpp b/python-webrtc/cpp/src/interfaces/rtc_ice_transport.cpp
index c8c44fe..f8a7e8f 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_ice_transport.cpp
+++ b/python-webrtc/cpp/src/interfaces/rtc_ice_transport.cpp
@@ -46,6 +46,9 @@ namespace python_webrtc {
       channel = nullptr;
     }
 
+    StandaloneIce(const StandaloneIce &) = delete;
+    StandaloneIce &operator=(const StandaloneIce &) = delete;
+
     webrtc::Environment env;
     std::unique_ptr<webrtc::BasicNetworkManager> networkManager;
     std::unique_ptr<webrtc::BasicPacketSocketFactory> socketFactory;
@@ -54,25 +57,23 @@ namespace python_webrtc {
     webrtc::scoped_refptr<webrtc::IceTransportWithPointer> transport;
   };
 
-  RTCIceTransport::RTCIceTransport(
-      std::shared_ptr<PeerConnectionFactory> factory, webrtc::scoped_refptr<webrtc::IceTransportInterface> transport)
+  RTCIceTransport::RTCIceTransport(std::shared_ptr<PeerConnectionFactory> factory,
+                                   webrtc::scoped_refptr<webrtc::IceTransportInterface> transport)
       : _factory(std::move(factory)), _transport(std::move(transport)) {
-    _factory->_workerThread->BlockingCall([this]() {
-      auto internal = _transport->internal();
+    _factory->workerThread()->BlockingCall([this]() {
+      auto *internal = _transport->internal();
       if (internal) {
         auto alive = _alive;
-        internal->SubscribeIceTransportStateChanged(
-            this, [this, alive](webrtc::IceTransportInternal *transport) {
-              if (*alive) {
-                OnStateChanged(transport);
-              }
-            });
-        internal->AddGatheringStateCallback(
-            this, [this, alive](webrtc::IceTransportInternal *transport) {
-              if (*alive) {
-                OnGatheringStateChanged(transport);
-              }
-            });
+        internal->SubscribeIceTransportStateChanged(this, [this, alive](webrtc::IceTransportInternal *transport) {
+          if (*alive) {
+            OnStateChanged(transport);
+          }
+        });
+        internal->AddGatheringStateCallback(this, [this, alive](webrtc::IceTransportInternal *transport) {
+          if (*alive) {
+            OnGatheringStateChanged(transport);
+          }
+        });
         _subscribed = internal;
       }
       TakeSnapshot();
@@ -80,10 +81,10 @@ namespace python_webrtc {
   }
 
   RTCIceTransport::~RTCIceTransport() {
-    BlockingDestructor release("RTCIceTransport");
+    const BlockingDestructor release("RTCIceTransport");
 
     // callbacks run on the network thread, so after this none of them can be running or start again
-    _factory->_workerThread->BlockingCall([this]() {
+    _factory->workerThread()->BlockingCall([this]() {
       *_alive = false;
       // the internal transport is gone (with its callbacks) once the ice transport is cleared
       if (_subscribed && _transport->internal() == _subscribed) {
@@ -103,7 +104,8 @@ namespace python_webrtc {
   void RTCIceTransport::Init(pybind11::module &m) {
     Listeners::BindClass<RTCIceTransport>(m, "RTCIceTransport")
         // a transport of its own
-        .def(pybind11::init(nogil_factory(+[]() { return CreateStandalone(PeerConnectionFactory::GetOrCreateDefault()); })))
+        .def(pybind11::init(
+            nogil_factory(+[]() { return CreateStandalone(PeerConnectionFactory::GetOrCreateDefault()); })))
         .def_property_readonly("component", nogil_fn(&RTCIceTransport::GetComponent))
         .def_property_readonly("gatheringState", nogil_fn(&RTCIceTransport::GetGatheringState))
         .def_property_readonly("role", nogil_fn(&RTCIceTransport::GetRole))
@@ -114,11 +116,10 @@ namespace python_webrtc {
         .def("getLocalParameters", &RTCIceTransport::GetLocalParameters, nogil())
         .def("getRemoteParameters", &RTCIceTransport::GetRemoteParameters, nogil())
         .def("gather", &RTCIceTransport::Gather, nogil(), pybind11::arg("policy"), pybind11::arg("iceServers"))
-        .def("start", &RTCIceTransport::Start, nogil(),
-             pybind11::arg("usernameFragment"), pybind11::arg("password"), pybind11::arg("role"))
-        .def("addRemoteCandidate", &RTCIceTransport::AddStandaloneRemoteCandidate, nogil(),
-             pybind11::arg("candidate"), pybind11::arg("sdpMid"), pybind11::arg("sdpMLineIndex"),
-             pybind11::arg("usernameFragment"))
+        .def("start", &RTCIceTransport::Start, nogil(), pybind11::arg("usernameFragment"), pybind11::arg("password"),
+             pybind11::arg("role"))
+        .def("addRemoteCandidate", &RTCIceTransport::AddStandaloneRemoteCandidate, nogil(), pybind11::arg("candidate"),
+             pybind11::arg("sdpMid"), pybind11::arg("sdpMLineIndex"), pybind11::arg("usernameFragment"))
         .def("stop", &RTCIceTransport::StopStandalone, nogil())
         .def_property_readonly("_standalone", &RTCIceTransport::IsStandalone)
         .def("_surfaceState", &RTCIceTransport::SurfaceState, nogil(), pybind11::arg("state"))
@@ -128,18 +129,21 @@ namespace python_webrtc {
 
   InstanceHolder<RTCIceTransport, webrtc::IceTransportInterface> &RTCIceTransport::holder() {
     // never destroyed: wrappers may outlive static destructors
-    static auto holder = new InstanceHolder<RTCIceTransport, webrtc::IceTransportInterface>();
+    static auto *holder = new InstanceHolder<RTCIceTransport, webrtc::IceTransportInterface>();
     return *holder;
   }
 
   RTCIceTransport::StateChange RTCIceTransport::TakeSnapshot() {
-    std::lock_guard<std::mutex> lock(_mutex);
-    StateChange change{_state, _state, _gatheringState, _gatheringState};
+    const std::scoped_lock lock(_mutex);
+    StateChange change{.previousState = _state,
+                       .state = _state,
+                       .previousGatheringState = _gatheringState,
+                       .gatheringState = _gatheringState};
     if (_stopped) {
       return change;
     }
-    auto internal = _transport->internal();
-    if (internal) {
+    auto *internal = _transport->internal();
+    if (internal != nullptr) {
       _component = internal->component() == 1 ? RTCIceComponent::kRtp : RTCIceComponent::kRtcp;
       _role = internal->GetIceRole();
       _state = internal->GetIceTransportState();
@@ -163,9 +167,9 @@ namespace python_webrtc {
   }
 
   void RTCIceTransport::OnRTCDtlsTransportStopped() {
-    webrtc::IceTransportState previous;
+    webrtc::IceTransportState previous{};
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       previous = _state;
       _state = webrtc::IceTransportState::kClosed;
     }
@@ -180,7 +184,7 @@ namespace python_webrtc {
   void RTCIceTransport::OnPeerConnectionClosed() {
     Mute();
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       _gatheringState = _surfacedGatheringState.Get(_gatheringState);
       _gatheringFrozen = true;
     }
@@ -188,7 +192,7 @@ namespace python_webrtc {
     _surfacedGatheringState.Reset();
   }
 
-  void RTCIceTransport::OnStateChanged(webrtc::IceTransportInternal *) {
+  void RTCIceTransport::OnStateChanged(webrtc::IceTransportInternal * /*unused*/) {
     auto change = TakeSnapshot();
     if (change.state == change.previousState) {
       return;
@@ -206,7 +210,7 @@ namespace python_webrtc {
     Emit("statechange", change.state);
   }
 
-  void RTCIceTransport::OnGatheringStateChanged(webrtc::IceTransportInternal *) {
+  void RTCIceTransport::OnGatheringStateChanged(webrtc::IceTransportInternal * /*unused*/) {
     auto change = TakeSnapshot();
     auto current = change.gatheringState;
     if (current == change.previousGatheringState) {
@@ -227,14 +231,14 @@ namespace python_webrtc {
   }
 
   RTCIceComponent RTCIceTransport::GetComponent() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     return _component;
   }
 
   webrtc::IceGatheringState RTCIceTransport::GetGatheringState() {
-    webrtc::IceGatheringState state;
+    webrtc::IceGatheringState state{};
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       state = _gatheringState;
     }
     return _surfacedGatheringState.Get(state);
@@ -242,16 +246,16 @@ namespace python_webrtc {
 
   webrtc::IceRole RTCIceTransport::GetRole() {
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       if (!_roleKnown) {
         return webrtc::IceRole::ICEROLE_UNKNOWN;
       }
     }
-    auto role = _factory->_workerThread->BlockingCall([this]() {
-      auto internal = _transport ? _transport->internal() : nullptr;
+    auto role = _factory->workerThread()->BlockingCall([this]() {
+      auto *internal = _transport ? _transport->internal() : nullptr;
       return internal ? internal->GetIceRole() : webrtc::IceRole::ICEROLE_UNKNOWN;
     });
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     // a closed transport has the last one
     if (role != webrtc::IceRole::ICEROLE_UNKNOWN) {
       _role = role;
@@ -260,14 +264,14 @@ namespace python_webrtc {
   }
 
   void RTCIceTransport::SetRoleKnown() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     _roleKnown = true;
   }
 
   webrtc::IceTransportState RTCIceTransport::GetState() {
-    webrtc::IceTransportState state;
+    webrtc::IceTransportState state{};
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       state = _state;
     }
     return _surfacedState.Get(state);
@@ -275,14 +279,14 @@ namespace python_webrtc {
 
   std::optional<std::tuple<IceCandidateInit, IceCandidateInit, bool>> RTCIceTransport::GetSelectedCandidatePair() {
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       if (_stopped) {
         return std::nullopt;
       }
     }
     std::optional<std::tuple<IceCandidateInit, IceCandidateInit, bool>> result;
-    _factory->_workerThread->BlockingCall([&]() {
-      auto internal = _transport ? _transport->internal() : nullptr;
+    _factory->workerThread()->BlockingCall([&]() {
+      auto *internal = _transport ? _transport->internal() : nullptr;
       auto pair = internal ? internal->GetSelectedCandidatePair() : std::nullopt;
       if (!pair) {
         return;
@@ -291,17 +295,17 @@ namespace python_webrtc {
       auto mid = internal->transport_name();
       auto local = webrtc::CreateIceCandidate(mid, 0, pair->local_candidate());
       auto remote = webrtc::CreateIceCandidate(mid, 0, pair->remote_candidate());
-      auto signaled = pair->remote_candidate().is_prflx() ? FindSignaledCandidate(pair->remote_candidate())
-                                                           : std::nullopt;
-      bool peerReflexive = pair->remote_candidate().is_prflx() && !signaled;
+      auto signaled =
+          pair->remote_candidate().is_prflx() ? FindSignaledCandidate(pair->remote_candidate()) : std::nullopt;
+      const bool peerReflexive = pair->remote_candidate().is_prflx() && !signaled;
       result.emplace(IceCandidateInit(*local), signaled ? *signaled : IceCandidateInit(*remote), peerReflexive);
     });
     return result;
   }
 
   std::optional<IceCandidateInit> RTCIceTransport::FindSignaledCandidate(const webrtc::Candidate &candidate) {
-    std::lock_guard<std::mutex> lock(_mutex);
-    for (const auto &signaled: _remoteCandidates) {
+    const std::scoped_lock lock(_mutex);
+    for (const auto &signaled : _remoteCandidates) {
       webrtc::SdpParseError error;
       auto parsed = webrtc::IceCandidate::Create(signaled.sdpMid, signaled.sdpMLineIndex, signaled.candidate, &error);
       if (parsed && parsed->candidate().address().port() == candidate.address().port() &&
@@ -312,44 +316,49 @@ namespace python_webrtc {
     return std::nullopt;
   }
 
-  static void addCandidate(std::vector<IceCandidateInit> &candidates, const IceCandidateInit &candidate) {
-    if (candidate.candidate.empty()) {
-      return;
-    }
-    for (const auto &known: candidates) {
-      if (known.candidate == candidate.candidate) {
+  namespace {
+
+    void addCandidate(std::vector<IceCandidateInit> &candidates, const IceCandidateInit &candidate) {
+      if (candidate.candidate.empty()) {
         return;
       }
+      for (const auto &known : candidates) {
+        if (known.candidate == candidate.candidate) {
+          return;
+        }
+      }
+      candidates.push_back(candidate);
     }
-    candidates.push_back(candidate);
-  }
+
+  } // namespace
 
   void RTCIceTransport::AddLocalCandidate(const IceCandidateInit &candidate) {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     addCandidate(_localCandidates, candidate);
   }
 
   void RTCIceTransport::AddRemoteCandidate(const IceCandidateInit &candidate) {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     addCandidate(_remoteCandidates, candidate);
   }
 
   std::vector<IceCandidateInit> RTCIceTransport::GetLocalCandidates() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     if (_standalone && HasListeners()) {
       // the candidates of a transport of its own come with their events
-      return {_localCandidates.begin(), _localCandidates.begin() + std::min(_surfacedLocal, _localCandidates.size())};
+      const auto surfaced = static_cast<std::ptrdiff_t>(std::min(_surfacedLocal, _localCandidates.size()));
+      return {_localCandidates.begin(), _localCandidates.begin() + surfaced};
     }
     return _localCandidates;
   }
 
   void RTCIceTransport::SurfaceLocalCandidate() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     ++_surfacedLocal;
   }
 
   std::vector<IceCandidateInit> RTCIceTransport::GetRemoteCandidates() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     return _remoteCandidates;
   }
 
@@ -359,7 +368,7 @@ namespace python_webrtc {
 
   std::optional<std::pair<std::string, std::string>> RTCIceTransport::GetParameters(bool local) {
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       if (_standalone) {
         return local ? _localParameters : _remoteParameters;
       }
@@ -376,14 +385,14 @@ namespace python_webrtc {
     return GetParameters(false);
   }
 
-  std::shared_ptr<RTCIceTransport> RTCIceTransport::CreateStandalone(
-      const std::shared_ptr<PeerConnectionFactory> &factory) {
+  std::shared_ptr<RTCIceTransport>
+  RTCIceTransport::CreateStandalone(const std::shared_ptr<PeerConnectionFactory> &factory) {
     std::shared_ptr<StandaloneIce> standalone;
     webrtc::scoped_refptr<webrtc::IceTransportInterface> transport;
-    std::pair<std::string, std::string> parameters(
-        webrtc::CreateRandomString(webrtc::ICE_UFRAG_LENGTH), webrtc::CreateRandomString(webrtc::ICE_PWD_LENGTH));
-    factory->_workerThread->BlockingCall([&]() {
-      standalone = std::make_shared<StandaloneIce>(factory->_workerThread.get());
+    std::pair<std::string, std::string> parameters(webrtc::CreateRandomString(webrtc::ICE_UFRAG_LENGTH),
+                                                   webrtc::CreateRandomString(webrtc::ICE_PWD_LENGTH));
+    factory->workerThread()->BlockingCall([&]() {
+      standalone = std::make_shared<StandaloneIce>(factory->workerThread());
       webrtc::IceTransportInit init(standalone->env);
       init.set_port_allocator(standalone->allocator.get());
       standalone->channel = webrtc::P2PTransportChannel::Create("", 1, std::move(init));
@@ -394,12 +403,12 @@ namespace python_webrtc {
 
     auto wrapper = holder().GetOrCreate(factory, transport);
     {
-      std::lock_guard<std::mutex> lock(wrapper->_mutex);
+      const std::scoped_lock lock(wrapper->_mutex);
       wrapper->_standalone = std::move(standalone);
       wrapper->_localParameters = parameters;
     }
-    factory->_workerThread->BlockingCall([&]() {
-      auto internal = transport->internal();
+    factory->workerThread()->BlockingCall([&]() {
+      auto *internal = transport->internal();
       auto alive = wrapper->_alive;
       auto *self = wrapper.get();
       internal->SubscribeCandidateGathered(
@@ -413,8 +422,8 @@ namespace python_webrtc {
       // both ends took the same role: the one told to switch does (RFC 8445 section 7.3.1.1)
       internal->SubscribeRoleConflict(self, [alive](webrtc::IceTransportInternal *transport) {
         if (*alive) {
-          transport->SetIceRole(transport->GetIceRole() == webrtc::ICEROLE_CONTROLLING
-                                ? webrtc::ICEROLE_CONTROLLED : webrtc::ICEROLE_CONTROLLING);
+          transport->SetIceRole(transport->GetIceRole() == webrtc::ICEROLE_CONTROLLING ? webrtc::ICEROLE_CONTROLLED
+                                                                                       : webrtc::ICEROLE_CONTROLLING);
         }
       });
       internal->SetCandidatePairChangeCallback([self, alive](const webrtc::CandidatePairChangeEvent &) {
@@ -426,11 +435,11 @@ namespace python_webrtc {
     return wrapper;
   }
 
-  void RTCIceTransport::Gather(
-      webrtc::PeerConnectionInterface::IceTransportsType policy, const std::vector<IceServerInit> &iceServers) {
+  void RTCIceTransport::Gather(webrtc::PeerConnectionInterface::IceTransportsType policy,
+                               const std::vector<IceServerInit> &iceServers) {
     auto servers = toIceServers(iceServers);
     webrtc::RTCError error;
-    _factory->_workerThread->BlockingCall([&]() {
+    _factory->workerThread()->BlockingCall([&]() {
       webrtc::ServerAddresses stunServers;
       std::vector<webrtc::RelayServerConfig> turnServers;
       error = webrtc::ParseIceServersOrError(servers, &stunServers, &turnServers);
@@ -438,8 +447,8 @@ namespace python_webrtc {
         return;
       }
       _standalone->allocator->SetConfiguration(stunServers, turnServers, 0, webrtc::NO_PRUNE);
-      _standalone->allocator->SetCandidateFilter(
-          policy == webrtc::PeerConnectionInterface::kRelay ? webrtc::CF_RELAY : webrtc::CF_ALL);
+      _standalone->allocator->SetCandidateFilter(policy == webrtc::PeerConnectionInterface::kRelay ? webrtc::CF_RELAY
+                                                                                                   : webrtc::CF_ALL);
       _transport->internal()->MaybeStartGathering();
     });
     if (!error.ok()) {
@@ -449,14 +458,14 @@ namespace python_webrtc {
   }
 
   void RTCIceTransport::Start(const std::string &usernameFragment, const std::string &password, webrtc::IceRole role) {
-    bool changed;
+    bool changed = false;
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       if (_startedRole && *_startedRole != role) {
         throw RTCException(webrtc::RTCErrorType::INVALID_STATE, "The transport started with another role");
       }
       _startedRole = role;
-      std::pair<std::string, std::string> parameters(usernameFragment, password);
+      const std::pair<std::string, std::string> parameters(usernameFragment, password);
       changed = _remoteParameters && *_remoteParameters != parameters;
       _remoteParameters = parameters;
       _roleKnown = true;
@@ -464,8 +473,8 @@ namespace python_webrtc {
         _remoteCandidates.clear();
       }
     }
-    _factory->_workerThread->BlockingCall([&]() {
-      auto internal = _transport->internal();
+    _factory->workerThread()->BlockingCall([&]() {
+      auto *internal = _transport->internal();
       if (changed) {
         // the candidates were for the previous remote agent
         internal->RemoveAllRemoteCandidates();
@@ -476,31 +485,30 @@ namespace python_webrtc {
     SurfaceCurrent();
   }
 
-  void RTCIceTransport::AddStandaloneRemoteCandidate(
-      const std::string &candidate, const std::string &sdpMid, int sdpMLineIndex,
-      const std::optional<std::string> &usernameFragment) {
+  void RTCIceTransport::AddStandaloneRemoteCandidate(const std::string &candidate, const std::string &sdpMid,
+                                                     int sdpMLineIndex,
+                                                     const std::optional<std::string> &usernameFragment) {
     IceCandidateInit init(sdpMid, sdpMLineIndex, usernameFragment);
     init.candidate = candidate;
     webrtc::SdpParseError error;
     auto parsed = webrtc::IceCandidate::Create(sdpMid, sdpMLineIndex, candidate, &error);
     if (!parsed) {
-      throw RTCException(webrtc::RTCErrorType::INTERNAL_ERROR, "Failed to parse the ICE candidate: " + error.description);
+      throw RTCException(webrtc::RTCErrorType::INTERNAL_ERROR,
+                         "Failed to parse the ICE candidate: " + error.description);
     }
     AddRemoteCandidate(init);
-    _factory->_workerThread->BlockingCall([&]() {
-      _transport->internal()->AddRemoteCandidate(parsed->candidate());
-    });
+    _factory->workerThread()->BlockingCall([&]() { _transport->internal()->AddRemoteCandidate(parsed->candidate()); });
     SurfaceCurrent();
   }
 
   void RTCIceTransport::StopStandalone() {
-    _factory->_workerThread->BlockingCall([&]() {
+    _factory->workerThread()->BlockingCall([&]() {
       // nothing more to connect with, and no more events
       *_alive = false;
       _transport->internal()->RemoveAllRemoteCandidates();
     });
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       _stopped = true;
       _state = webrtc::IceTransportState::kClosed;
     }
@@ -510,15 +518,15 @@ namespace python_webrtc {
   }
 
   void RTCIceTransport::SurfaceCurrent() {
-    _factory->_workerThread->BlockingCall([this]() { TakeSnapshot(); });
-    std::lock_guard<std::mutex> lock(_mutex);
+    _factory->workerThread()->BlockingCall([this]() { TakeSnapshot(); });
+    const std::scoped_lock lock(_mutex);
     _surfacedState.Surface(_state);
     _surfacedGatheringState.Surface(_gatheringState);
   }
 
   void RTCIceTransport::CreatedByDescription() {
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       if (_gatheringState == webrtc::IceGatheringState::kIceGatheringNew) {
         return;
       }
@@ -535,7 +543,7 @@ namespace python_webrtc {
     auto pair = GetSelectedCandidatePair();
     auto key = pair ? std::get<0>(*pair).candidate + "|" + std::get<1>(*pair).candidate : std::string();
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       if (key == _selectedPair) {
         return;
       }
diff --git a/python-webrtc/cpp/src/interfaces/rtc_ice_transport.h b/python-webrtc/cpp/src/interfaces/rtc_ice_transport.h
index 46d2f03..b99a361 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_ice_transport.h
+++ b/python-webrtc/cpp/src/interfaces/rtc_ice_transport.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_RTC_ICE_TRANSPORT_H_
+#define PYTHON_WEBRTC_INTERFACES_RTC_ICE_TRANSPORT_H_
 
 #include <functional>
 #include <memory>
@@ -19,7 +20,6 @@
 #include <api/ice_transport_interface.h>
 #include <p2p/base/ice_transport_internal.h>
 
-#include "peer_connection_factory.h"
 #include "../enums/enums.h"
 #include "../models/python_webrtc/rtc_configuration.h"
 #include "../models/python_webrtc/rtc_ice_candidate.h"
@@ -27,6 +27,7 @@
 #include "../utils/listeners.h"
 #include "../utils/locked_function.h"
 #include "../utils/surfaced.h"
+#include "peer_connection_factory.h"
 
 namespace python_webrtc {
 
@@ -35,10 +36,14 @@ namespace python_webrtc {
 
   class RTCIceTransport : public Listeners {
   public:
-    explicit RTCIceTransport(std::shared_ptr<PeerConnectionFactory>, webrtc::scoped_refptr<webrtc::IceTransportInterface>);
+    explicit RTCIceTransport(std::shared_ptr<PeerConnectionFactory> factory,
+                             webrtc::scoped_refptr<webrtc::IceTransportInterface> transport);
 
     ~RTCIceTransport() override;
 
+    RTCIceTransport(const RTCIceTransport &) = delete;
+    RTCIceTransport &operator=(const RTCIceTransport &) = delete;
+
     static void Init(pybind11::module &m);
 
     static InstanceHolder<RTCIceTransport, webrtc::IceTransportInterface> &holder();
@@ -108,7 +113,8 @@ namespace python_webrtc {
 
     bool IsStandalone() { return _standalone != nullptr; }
 
-    void Gather(webrtc::PeerConnectionInterface::IceTransportsType policy, const std::vector<IceServerInit> &iceServers);
+    void Gather(webrtc::PeerConnectionInterface::IceTransportsType policy,
+                const std::vector<IceServerInit> &iceServers);
 
     // the remote parameters (flushing the remote candidates if they changed) and the role
     void Start(const std::string &usernameFragment, const std::string &password, webrtc::IceRole role);
@@ -137,9 +143,9 @@ namespace python_webrtc {
     // reads the states of the transport, on the network thread
     StateChange TakeSnapshot();
 
-    void OnStateChanged(webrtc::IceTransportInternal *);
+    void OnStateChanged(webrtc::IceTransportInternal * /*unused*/);
 
-    void OnGatheringStateChanged(webrtc::IceTransportInternal *);
+    void OnGatheringStateChanged(webrtc::IceTransportInternal * /*unused*/);
 
     std::optional<std::pair<std::string, std::string>> GetParameters(bool local);
 
@@ -183,3 +189,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_RTC_ICE_TRANSPORT_H_
diff --git a/python-webrtc/cpp/src/interfaces/rtc_peer_connection.cpp b/python-webrtc/cpp/src/interfaces/rtc_peer_connection.cpp
index 1885245..43c84cd 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_peer_connection.cpp
+++ b/python-webrtc/cpp/src/interfaces/rtc_peer_connection.cpp
@@ -11,20 +11,22 @@
 #include <algorithm>
 #include <limits>
 #include <set>
+#include <string_view>
 #include <thread>
+#include <utility>
 
 #include <absl/strings/match.h>
 #include <media/base/media_constants.h>
 #include <pc/rtp_media_utils.h>
 #include <pc/session_description.h>
 
-#include "peer_connection_factory.h"
-#include "create_session_description_observer.h"
-#include "set_session_description_observer.h"
-#include "stats_collector_callback.h"
 #include "../models/python_webrtc/rtc_ice_candidate.h"
 #include "../utils/gil.h"
 #include "../utils/libwebrtc_thread.h"
+#include "create_session_description_observer.h"
+#include "peer_connection_factory.h"
+#include "set_session_description_observer.h"
+#include "stats_collector_callback.h"
 
 namespace python_webrtc {
 
@@ -44,13 +46,13 @@ namespace python_webrtc {
         connection->_heldGathering.Hold();
         _connection = connection;
       }
-      for (auto &iceTransport: iceTransports) {
+      for (auto &iceTransport : iceTransports) {
         if (!iceTransport->IsHeld()) {
           iceTransport->Hold();
           _iceTransports.push_back(std::move(iceTransport));
         }
       }
-      for (const auto &transceiver: pc->GetTransceivers()) {
+      for (const auto &transceiver : pc->GetTransceivers()) {
         auto track = MediaStreamTrack::holder().Find(transceiver->receiver()->track().get());
         if (track) {
           track->HoldEnded();
@@ -62,13 +64,16 @@ namespace python_webrtc {
     // also when the operation fails before it starts
     ~HeldOperationEvents() { Release(); }
 
+    HeldOperationEvents(const HeldOperationEvents &) = delete;
+    HeldOperationEvents &operator=(const HeldOperationEvents &) = delete;
+
     void Release() {
-      std::lock_guard<std::mutex> lock(_mutex);
-      for (const auto &track: _tracks) {
+      const std::scoped_lock lock(_mutex);
+      for (const auto &track : _tracks) {
         track->ReleaseEnded();
       }
       _tracks.clear();
-      for (const auto &iceTransport: _iceTransports) {
+      for (const auto &iceTransport : _iceTransports) {
         iceTransport->Release();
       }
       _iceTransports.clear();
@@ -94,8 +99,7 @@ namespace python_webrtc {
 
     webrtc::PeerConnectionDependencies dependencies(this);
 
-    auto result = _factory->factory()->CreatePeerConnectionOrError(
-        configuration, std::move(dependencies));
+    auto result = _factory->factory()->CreatePeerConnectionOrError(configuration, std::move(dependencies));
 
     if (!result.ok()) {
       throw RTCException(result.error());
@@ -106,7 +110,7 @@ namespace python_webrtc {
 
   RTCPeerConnection::~RTCPeerConnection() {
     // destroying the peer connection blocks on the signaling thread, which may be waiting for the GIL
-    BlockingDestructor release("RTCPeerConnection");
+    const BlockingDestructor release("RTCPeerConnection");
 
     // closing stops the connection from calling this observer
     Close();
@@ -114,7 +118,7 @@ namespace python_webrtc {
     // released here, without the GIL, as it blocks on the signaling thread
     webrtc::scoped_refptr<webrtc::PeerConnectionInterface> closed;
     {
-      std::lock_guard<std::mutex> lock(_connectionMutex);
+      const std::scoped_lock lock(_connectionMutex);
       closed = std::move(_closedConnection);
     }
     closed = nullptr;
@@ -126,39 +130,44 @@ namespace python_webrtc {
         .def(pybind11::init(nogil_factory(+[](const std::optional<ConfigurationInit> &configuration) {
           return std::shared_ptr<RTCPeerConnection>(new RTCPeerConnection(configuration), DeleteOffLibwebrtcThread());
         })))
-        .def("createOffer", WithCallbacks(&RTCPeerConnection::CreateOffer),
-             pybind11::arg("onSuccess"), pybind11::arg("onFailure"), pybind11::arg("iceRestart"),
-             pybind11::arg("voiceActivityDetection"))
-        .def("createAnswer", WithCallbacks(&RTCPeerConnection::CreateAnswer),
-             pybind11::arg("onSuccess"), pybind11::arg("onFailure"), pybind11::arg("voiceActivityDetection"))
-        .def("setLocalDescription", WithCallbacks(&RTCPeerConnection::SetLocalDescription),
-             pybind11::arg("onSuccess"), pybind11::arg("onFailure"), pybind11::arg("description"))
+        .def("createOffer", WithCallbacks(&RTCPeerConnection::CreateOffer), pybind11::arg("onSuccess"),
+             pybind11::arg("onFailure"), pybind11::arg("iceRestart"), pybind11::arg("voiceActivityDetection"))
+        .def("createAnswer", WithCallbacks(&RTCPeerConnection::CreateAnswer), pybind11::arg("onSuccess"),
+             pybind11::arg("onFailure"), pybind11::arg("voiceActivityDetection"))
+        .def("setLocalDescription", WithCallbacks(&RTCPeerConnection::SetLocalDescription), pybind11::arg("onSuccess"),
+             pybind11::arg("onFailure"), pybind11::arg("description"))
         .def("setRemoteDescription", WithCallbacks(&RTCPeerConnection::SetRemoteDescription),
              pybind11::arg("onSuccess"), pybind11::arg("onFailure"), pybind11::arg("description"))
-        .def("addIceCandidate", WithCallbacks(&RTCPeerConnection::AddIceCandidate),
-             pybind11::arg("onSuccess"), pybind11::arg("onFailure"), pybind11::arg("candidate"),
-             pybind11::arg("sdpMid"), pybind11::arg("sdpMLineIndex"), pybind11::arg("usernameFragment"))
+        .def("addIceCandidate", WithCallbacks(&RTCPeerConnection::AddIceCandidate), pybind11::arg("onSuccess"),
+             pybind11::arg("onFailure"), pybind11::arg("candidate"), pybind11::arg("sdpMid"),
+             pybind11::arg("sdpMLineIndex"), pybind11::arg("usernameFragment"))
         .def("addTrack",
              pybind11::overload_cast<MediaStreamTrack &, std::optional<std::reference_wrapper<MediaStream>>>(
-                 &RTCPeerConnection::AddTrack), nogil(), pybind11::arg("track"), pybind11::arg("stream"))
+                 &RTCPeerConnection::AddTrack),
+             nogil(), pybind11::arg("track"), pybind11::arg("stream"))
         .def("addTrack",
              pybind11::overload_cast<MediaStreamTrack &, const std::vector<MediaStream *> &>(
-                 &RTCPeerConnection::AddTrack), nogil(), pybind11::arg("track"), pybind11::arg("streams"))
+                 &RTCPeerConnection::AddTrack),
+             nogil(), pybind11::arg("track"), pybind11::arg("streams"))
         .def("removeTrack", &RTCPeerConnection::RemoveTrack, nogil(), pybind11::arg("sender"))
         .def("addTransceiver",
-             pybind11::overload_cast<webrtc::MediaType, std::optional<std::reference_wrapper<webrtc::RtpTransceiverInit>> &>(
-                 &RTCPeerConnection::AddTransceiver), nogil(), pybind11::arg("kind"), pybind11::arg("init"))
+             pybind11::overload_cast<webrtc::MediaType,
+                                     std::optional<std::reference_wrapper<webrtc::RtpTransceiverInit>> &>(
+                 &RTCPeerConnection::AddTransceiver),
+             nogil(), pybind11::arg("kind"), pybind11::arg("init"))
         .def("addTransceiver",
-             pybind11::overload_cast<MediaStreamTrack &, std::optional<std::reference_wrapper<webrtc::RtpTransceiverInit>> &>(
-                 &RTCPeerConnection::AddTransceiver), nogil(), pybind11::arg("track"), pybind11::arg("init"))
+             pybind11::overload_cast<MediaStreamTrack &,
+                                     std::optional<std::reference_wrapper<webrtc::RtpTransceiverInit>> &>(
+                 &RTCPeerConnection::AddTransceiver),
+             nogil(), pybind11::arg("track"), pybind11::arg("init"))
         .def("getTransceivers", &RTCPeerConnection::GetTransceivers, nogil())
         .def("getSenders", &RTCPeerConnection::GetSenders, nogil())
         .def("getReceivers", &RTCPeerConnection::GetReceivers, nogil())
-        .def("createDataChannel", &RTCPeerConnection::CreateDataChannel, nogil(),
-             pybind11::arg("label"), pybind11::arg("ordered"), pybind11::arg("maxPacketLifeTime"),
-             pybind11::arg("maxRetransmits"), pybind11::arg("protocol"), pybind11::arg("negotiated"),
-             pybind11::arg("id"), pybind11::arg("priority"))
-        .def("getStats", WithCallbacks(&RTCPeerConnection::GetStats), pybind11::arg("onSuccess"), pybind11::arg("onFailure"))
+        .def("createDataChannel", &RTCPeerConnection::CreateDataChannel, nogil(), pybind11::arg("label"),
+             pybind11::arg("ordered"), pybind11::arg("maxPacketLifeTime"), pybind11::arg("maxRetransmits"),
+             pybind11::arg("protocol"), pybind11::arg("negotiated"), pybind11::arg("id"), pybind11::arg("priority"))
+        .def("getStats", WithCallbacks(&RTCPeerConnection::GetStats), pybind11::arg("onSuccess"),
+             pybind11::arg("onFailure"))
         .def("restartIce", &RTCPeerConnection::RestartIce, nogil())
         .def("getConfiguration", &RTCPeerConnection::GetConfiguration, nogil())
         .def("setConfiguration", &RTCPeerConnection::SetConfiguration, nogil(), pybind11::arg("configuration"))
@@ -177,14 +186,11 @@ namespace python_webrtc {
         .def_property_readonly("canTrickleIceCandidates", nogil_fn(&RTCPeerConnection::GetCanTrickleIceCandidates))
         .def("_shouldFireNegotiationNeededEvent", &RTCPeerConnection::ShouldFireNegotiationNeededEvent, nogil(),
              pybind11::arg("eventId"))
-        .def("_surfaceSignalingState", &RTCPeerConnection::SurfaceSignalingState, nogil(),
-             pybind11::arg("state"))
+        .def("_surfaceSignalingState", &RTCPeerConnection::SurfaceSignalingState, nogil(), pybind11::arg("state"))
         .def("_surfaceIceConnectionState", &RTCPeerConnection::SurfaceIceConnectionState, nogil(),
              pybind11::arg("state"))
-        .def("_surfaceIceGatheringState", &RTCPeerConnection::SurfaceIceGatheringState, nogil(),
-             pybind11::arg("state"))
-        .def("_surfaceConnectionState", &RTCPeerConnection::SurfaceConnectionState, nogil(),
-             pybind11::arg("state"))
+        .def("_surfaceIceGatheringState", &RTCPeerConnection::SurfaceIceGatheringState, nogil(), pybind11::arg("state"))
+        .def("_surfaceConnectionState", &RTCPeerConnection::SurfaceConnectionState, nogil(), pybind11::arg("state"))
         .def("_refreshDescriptions", &RTCPeerConnection::RefreshDescriptions, nogil())
         .def_static("_connectionOf", &RTCPeerConnection::ConnectionOf, nogil(), pybind11::arg("sender"))
         .def("_applyDescriptions", &RTCPeerConnection::ApplyDescriptions, nogil(),
@@ -205,12 +211,12 @@ namespace python_webrtc {
   }
 
   webrtc::scoped_refptr<webrtc::PeerConnectionInterface> RTCPeerConnection::connection() {
-    std::lock_guard<std::mutex> lock(_connectionMutex);
+    const std::scoped_lock lock(_connectionMutex);
     return _jinglePeerConnection;
   }
 
   webrtc::scoped_refptr<webrtc::PeerConnectionInterface> RTCPeerConnection::closedConnection() {
-    std::lock_guard<std::mutex> lock(_connectionMutex);
+    const std::scoped_lock lock(_connectionMutex);
     return _closedConnection;
   }
 
@@ -218,16 +224,16 @@ namespace python_webrtc {
     return !connection();
   }
 
-  template<typename T, typename U>
+  template <typename T, typename U>
   std::shared_ptr<T> RTCPeerConnection::Wrap(Wrappers<T, U> &wrappers, webrtc::scoped_refptr<U> object) {
-    if (!onLibwebrtcThread) {
+    if (!OnLibwebrtcThread()) {
       // on the signaling thread, which wraps objects too: the lock isn't held while waiting for it
-      gil_release_if_held release;
-      return _factory->_signalingThread->BlockingCall([&]() { return Wrap(wrappers, std::move(object)); });
+      const gil_release_if_held release;
+      return _factory->signalingThread()->BlockingCall([&]() { return Wrap(wrappers, std::move(object)); });
     }
     std::shared_ptr<T> wrapper;
     {
-      std::lock_guard<std::mutex> lock(_wrappersMutex);
+      const std::scoped_lock lock(_wrappersMutex);
       auto it = wrappers.find(object.get());
       if (it != wrappers.end()) {
         return it->second;
@@ -240,19 +246,19 @@ namespace python_webrtc {
     return wrapper;
   }
 
-  template<typename T, typename U>
-  std::vector<std::shared_ptr<T>> RTCPeerConnection::Sync(
-      Wrappers<T, U> &wrappers, const std::vector<webrtc::scoped_refptr<U>> &objects) {
-    if (!onLibwebrtcThread) {
+  template <typename T, typename U>
+  std::vector<std::shared_ptr<T>> RTCPeerConnection::Sync(Wrappers<T, U> &wrappers,
+                                                          const std::vector<webrtc::scoped_refptr<U>> &objects) {
+    if (!OnLibwebrtcThread()) {
       // see Wrap
-      gil_release_if_held release;
-      return _factory->_signalingThread->BlockingCall([&]() { return Sync(wrappers, objects); });
+      const gil_release_if_held release;
+      return _factory->signalingThread()->BlockingCall([&]() { return Sync(wrappers, objects); });
     }
     std::vector<std::shared_ptr<T>> result;
     Wrappers<T, U> current;
     {
-      std::lock_guard<std::mutex> lock(_wrappersMutex);
-      for (const auto &object: objects) {
+      const std::scoped_lock lock(_wrappersMutex);
+      for (const auto &object : objects) {
         auto it = wrappers.find(object.get());
         auto wrapper = it != wrappers.end() ? it->second : T::holder().GetOrCreate(_factory, object);
         current[object.get()] = wrapper;
@@ -260,17 +266,17 @@ namespace python_webrtc {
       }
       std::swap(wrappers, current);
     }
-    for (const auto &wrapper: result) {
+    for (const auto &wrapper : result) {
       Adopt(wrapper);
     }
     // wrappers of the objects that are gone are released here, out of the lock
     return result;
   }
 
-  template<typename T, typename U>
+  template <typename T, typename U>
   std::vector<std::shared_ptr<T>> RTCPeerConnection::Unkept(const std::vector<webrtc::scoped_refptr<U>> &objects) {
     std::vector<std::shared_ptr<T>> result;
-    for (const auto &object: objects) {
+    for (const auto &object : objects) {
       auto wrapper = T::holder().GetOrCreate(_factory, object);
       Adopt(wrapper);
       result.push_back(std::move(wrapper));
@@ -286,7 +292,7 @@ namespace python_webrtc {
     decltype(_channels) channels;
     decltype(_dtlsTransports) dtlsTransports;
     {
-      std::lock_guard<std::mutex> lock(_wrappersMutex);
+      const std::scoped_lock lock(_wrappersMutex);
       std::swap(channels, _channels);
       std::swap(dtlsTransports, _dtlsTransports);
       std::swap(transceivers, _transceivers);
@@ -334,117 +340,121 @@ namespace python_webrtc {
     });
   }
 
-  static webrtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiverOf(
-      const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc,
-      const webrtc::scoped_refptr<webrtc::RtpSenderInterface> &sender) {
-    for (const auto &transceiver: pc->GetTransceivers()) {
-      if (transceiver->sender() == sender) {
-        return transceiver;
+  namespace {
+
+    webrtc::scoped_refptr<webrtc::RtpTransceiverInterface>
+    transceiverOf(const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc,
+                  const webrtc::scoped_refptr<webrtc::RtpSenderInterface> &sender) {
+      for (const auto &transceiver : pc->GetTransceivers()) {
+        if (transceiver->sender() == sender) {
+          return transceiver;
+        }
       }
+      return nullptr;
     }
-    return nullptr;
-  }
 
-  static webrtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiverOf(
-      const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc,
-      const webrtc::scoped_refptr<webrtc::RtpReceiverInterface> &receiver) {
-    for (const auto &transceiver: pc->GetTransceivers()) {
-      if (transceiver->receiver() == receiver) {
-        return transceiver;
+    webrtc::scoped_refptr<webrtc::RtpTransceiverInterface>
+    transceiverOf(const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc,
+                  const webrtc::scoped_refptr<webrtc::RtpReceiverInterface> &receiver) {
+      for (const auto &transceiver : pc->GetTransceivers()) {
+        if (transceiver->receiver() == receiver) {
+          return transceiver;
+        }
       }
+      return nullptr;
     }
-    return nullptr;
-  }
 
-  // The media section a transceiver negotiated, in the current remote (for the sender) or local (for the receiver)
-  // description; null until it's negotiated, and when it's rejected. On the signaling thread.
-  static const webrtc::MediaContentDescription *negotiatedContent(
-      const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc,
-      const webrtc::scoped_refptr<webrtc::RtpTransceiverInterface> &transceiver, bool remote) {
-    auto mid = transceiver ? transceiver->mid() : std::nullopt;
-    auto description = remote ? pc->current_remote_description() : pc->current_local_description();
-    auto content = mid && description ? description->description()->GetContentByName(*mid) : nullptr;
-    return content && !content->rejected ? content->media_description() : nullptr;
-  }
+    // The media section a transceiver negotiated, in the current remote (for the sender) or local (for the receiver)
+    // description; null until it's negotiated, and when it's rejected. On the signaling thread.
+    const webrtc::MediaContentDescription *
+    negotiatedContent(const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc,
+                      const webrtc::scoped_refptr<webrtc::RtpTransceiverInterface> &transceiver, bool remote) {
+      auto mid = transceiver ? transceiver->mid() : std::nullopt;
+      const auto *description = remote ? pc->current_remote_description() : pc->current_local_description();
+      const auto *content =
+          mid && (description != nullptr) ? description->description()->GetContentByName(*mid) : nullptr;
+      return (content != nullptr) && !content->rejected ? content->media_description() : nullptr;
+    }
 
-  static bool isSupported(const webrtc::Codec &codec, const webrtc::RtpCapabilities &capabilities,
-                          webrtc::MediaType kind) {
-    return std::any_of(capabilities.codecs.begin(), capabilities.codecs.end(), [&](const auto &capability) {
-      return absl::EqualsIgnoreCase(capability.name, codec.name) &&
-             capability.clock_rate == codec.clockrate &&
-             (kind != webrtc::MediaType::AUDIO || static_cast<size_t>(capability.num_channels.value_or(1)) == codec.channels);
-    });
-  }
+    bool isSupported(const webrtc::Codec &codec, const webrtc::RtpCapabilities &capabilities, webrtc::MediaType kind) {
+      return std::ranges::any_of(capabilities.codecs, [&](const auto &capability) {
+        return absl::EqualsIgnoreCase(capability.name, codec.name) && capability.clock_rate == codec.clockrate &&
+               (kind != webrtc::MediaType::AUDIO ||
+                static_cast<size_t>(capability.num_channels.value_or(1)) == codec.channels);
+      });
+    }
 
-  // the codecs of a media section this side can use (the remote peer may list unknown ones)
-  static std::vector<webrtc::RtpCodecParameters> supportedCodecs(
-      const webrtc::MediaContentDescription &content, const webrtc::RtpCapabilities &capabilities) {
-    std::set<int> kept;
-    for (const auto &codec: content.codecs()) {
-      if (codec.GetResiliencyType() != webrtc::Codec::ResiliencyType::kRtx &&
-          isSupported(codec, capabilities, content.type())) {
-        kept.insert(codec.id);
+    // the codecs of a media section this side can use (the remote peer may list unknown ones)
+    std::vector<webrtc::RtpCodecParameters> supportedCodecs(const webrtc::MediaContentDescription &content,
+                                                            const webrtc::RtpCapabilities &capabilities) {
+      std::set<int> kept;
+      for (const auto &codec : content.codecs()) {
+        if (codec.GetResiliencyType() != webrtc::Codec::ResiliencyType::kRtx &&
+            isSupported(codec, capabilities, content.type())) {
+          kept.insert(codec.id);
+        }
       }
-    }
-    std::vector<webrtc::RtpCodecParameters> codecs;
-    for (const auto &codec: content.codecs()) {
-      // a retransmission codec goes with the codec it retransmits
-      int associated;
-      bool rtx = codec.GetResiliencyType() == webrtc::Codec::ResiliencyType::kRtx;
-      if (rtx ? codec.GetParam(webrtc::kCodecParamAssociatedPayloadType, &associated) && kept.count(associated)
-              : kept.count(codec.id)) {
-        codecs.push_back(codec.ToCodecParameters());
+      std::vector<webrtc::RtpCodecParameters> codecs;
+      for (const auto &codec : content.codecs()) {
+        // a retransmission codec goes with the codec it retransmits
+        int associated = 0;
+        const bool rtx = codec.GetResiliencyType() == webrtc::Codec::ResiliencyType::kRtx;
+        const auto *associatedParam = static_cast<const char *>(webrtc::kCodecParamAssociatedPayloadType);
+        if (rtx ? codec.GetParam(associatedParam, &associated) && kept.contains(associated) : kept.contains(codec.id)) {
+          codecs.push_back(codec.ToCodecParameters());
+        }
       }
+      return codecs;
     }
-    return codecs;
-  }
 
-  webrtc::scoped_refptr<webrtc::RtpTransceiverInterface> RTCPeerConnection::TransceiverOf(
-      const webrtc::scoped_refptr<webrtc::RtpSenderInterface> &sender) {
+  } // namespace
+
+  webrtc::scoped_refptr<webrtc::RtpTransceiverInterface>
+  RTCPeerConnection::TransceiverOf(const webrtc::scoped_refptr<webrtc::RtpSenderInterface> &sender) {
     auto pc = connection();
     return pc ? transceiverOf(pc, sender) : nullptr;
   }
 
-  std::vector<webrtc::RtpCodecParameters> RTCPeerConnection::NegotiatedCodecs(
-      const webrtc::scoped_refptr<webrtc::RtpSenderInterface> &sender) {
+  std::vector<webrtc::RtpCodecParameters>
+  RTCPeerConnection::NegotiatedCodecs(const webrtc::scoped_refptr<webrtc::RtpSenderInterface> &sender) {
     auto pc = connection();
     if (!pc) {
       return {};
     }
-    return _factory->_signalingThread->BlockingCall([&]() {
-      auto content = negotiatedContent(pc, transceiverOf(pc, sender), true);
+    return _factory->signalingThread()->BlockingCall([&]() {
+      const auto *content = negotiatedContent(pc, transceiverOf(pc, sender), true);
       return content ? supportedCodecs(*content, _factory->factory()->GetRtpSenderCapabilities(content->type()))
                      : std::vector<webrtc::RtpCodecParameters>();
     });
   }
 
-  std::vector<webrtc::RtpCodecParameters> RTCPeerConnection::NegotiatedCodecs(
-      const webrtc::scoped_refptr<webrtc::RtpReceiverInterface> &receiver) {
+  std::vector<webrtc::RtpCodecParameters>
+  RTCPeerConnection::NegotiatedCodecs(const webrtc::scoped_refptr<webrtc::RtpReceiverInterface> &receiver) {
     auto pc = connection();
     if (!pc) {
       return {};
     }
-    return _factory->_signalingThread->BlockingCall([&]() {
-      auto content = negotiatedContent(pc, transceiverOf(pc, receiver), false);
+    return _factory->signalingThread()->BlockingCall([&]() {
+      const auto *content = negotiatedContent(pc, transceiverOf(pc, receiver), false);
       return content ? supportedCodecs(*content, _factory->factory()->GetRtpReceiverCapabilities(content->type()))
                      : std::vector<webrtc::RtpCodecParameters>();
     });
   }
 
-  std::vector<webrtc::RtpExtension> RTCPeerConnection::NegotiatedHeaderExtensions(
-      const webrtc::scoped_refptr<webrtc::RtpReceiverInterface> &receiver) {
+  std::vector<webrtc::RtpExtension>
+  RTCPeerConnection::NegotiatedHeaderExtensions(const webrtc::scoped_refptr<webrtc::RtpReceiverInterface> &receiver) {
     auto pc = connection();
     if (!pc) {
       return {};
     }
-    return _factory->_signalingThread->BlockingCall([&]() {
-      auto content = negotiatedContent(pc, transceiverOf(pc, receiver), false);
+    return _factory->signalingThread()->BlockingCall([&]() {
+      const auto *content = negotiatedContent(pc, transceiverOf(pc, receiver), false);
       return content ? content->rtp_header_extensions() : std::vector<webrtc::RtpExtension>();
     });
   }
 
-  webrtc::scoped_refptr<webrtc::PeerConnectionInterface> RTCPeerConnection::StatsConnection(
-      const std::function<void(RTCCallbackException)> &onFailure) {
+  webrtc::scoped_refptr<webrtc::PeerConnectionInterface>
+  RTCPeerConnection::StatsConnection(const std::function<void(RTCCallbackException)> &onFailure) {
     auto pc = connection();
     if (!pc) {
       pc = closedConnection();
@@ -488,10 +498,9 @@ namespace python_webrtc {
     pc->GetStats(receiver, webrtc::make_ref_counted<StatsCollectorCallback>(onSuccess, std::move(excluded)));
   }
 
-  void RTCPeerConnection::CreateOffer(
-      std::function<void(RTCSessionDescription)> &onSuccess,
-      std::function<void(RTCCallbackException)> &onFailure,
-      bool iceRestart, bool voiceActivityDetection) {
+  void RTCPeerConnection::CreateOffer(std::function<void(RTCSessionDescription)> &onSuccess,
+                                      std::function<void(RTCCallbackException)> &onFailure, bool iceRestart,
+                                      bool voiceActivityDetection) {
     auto pc = connection();
     auto state = pc ? pc->signaling_state() : SignalingState::kClosed;
     if (state == SignalingState::kClosed) {
@@ -500,107 +509,112 @@ namespace python_webrtc {
     }
     if (state != SignalingState::kStable && state != SignalingState::kHaveLocalOffer) {
       onFailure(RTCCallbackException(webrtc::RTCErrorType::INVALID_STATE,
-          "Failed to execute 'createOffer' on 'RTCPeerConnection': Called in wrong state: " +
-          std::string(webrtc::PeerConnectionInterface::AsString(state))));
+                                     "Failed to execute 'createOffer' on 'RTCPeerConnection': Called in wrong state: " +
+                                         std::string(webrtc::PeerConnectionInterface::AsString(state))));
       return;
     }
 
-    auto observer = new webrtc::RefCountedObject<CreateSessionDescriptionObserver>(weak_from_this(), onSuccess, onFailure);
+    auto observer = webrtc::make_ref_counted<CreateSessionDescriptionObserver>(weak_from_this(), onSuccess, onFailure);
 
     auto options = webrtc::PeerConnectionInterface::RTCOfferAnswerOptions();
     options.ice_restart = iceRestart;
     options.voice_activity_detection = voiceActivityDetection;
 
-    pc->CreateOffer(observer, options);
+    pc->CreateOffer(observer.get(), options);
   }
 
-  void RTCPeerConnection::CreateAnswer(
-      std::function<void(RTCSessionDescription)> &onSuccess,
-      std::function<void(RTCCallbackException)> &onFailure,
-      bool voiceActivityDetection) {
+  void RTCPeerConnection::CreateAnswer(std::function<void(RTCSessionDescription)> &onSuccess,
+                                       std::function<void(RTCCallbackException)> &onFailure,
+                                       bool voiceActivityDetection) {
     auto pc = connection();
     if (!pc || pc->signaling_state() == SignalingState::kClosed) {
       onFailure(RTCCallbackException(closedError("createAnswer")));
       return;
     }
 
-    auto observer = new webrtc::RefCountedObject<CreateSessionDescriptionObserver>(weak_from_this(), onSuccess, onFailure);
+    auto observer = webrtc::make_ref_counted<CreateSessionDescriptionObserver>(weak_from_this(), onSuccess, onFailure);
     auto options = webrtc::PeerConnectionInterface::RTCOfferAnswerOptions();
     options.voice_activity_detection = voiceActivityDetection;
-    pc->CreateAnswer(observer, options);
+    pc->CreateAnswer(observer.get(), options);
   }
 
   void RTCPeerConnection::SaveCreatedDescription(const RTCSessionDescriptionInit &description) {
-    std::lock_guard<std::mutex> lock(_createdMutex);
+    const std::scoped_lock lock(_createdMutex);
     (description.type == webrtc::SdpType::kOffer ? _lastOffer : _lastAnswer) = description.sdp;
   }
 
-  // A remote TCP candidate on a port Fetch blocks is ignored, as the WebRTC specification requires
-  // (https://fetch.spec.whatwg.org/#bad-port)
-  static bool isBlockedCandidate(const webrtc::Candidate &candidate) {
-    static const std::set<int> badPorts = {
-        0, 1, 7, 9, 11, 13, 15, 17, 19, 20, 21, 22, 23, 25, 37, 42, 43, 53, 69, 77, 79, 87, 95, 101, 102, 103, 104,
-        109, 110, 111, 113, 115, 117, 119, 123, 135, 137, 139, 143, 161, 179, 389, 427, 465, 512, 513, 514, 515, 526,
-        530, 531, 532, 540, 548, 554, 556, 563, 587, 601, 636, 989, 990, 993, 995, 1719, 1720, 1723, 2049, 3659, 4045,
-        4190, 5060, 5061, 6000, 6566, 6665, 6666, 6667, 6668, 6669, 6679, 6697, 10080};
-    return candidate.protocol() == "tcp" && badPorts.count(candidate.address().port()) > 0;
-  }
-
-  static void removeBlockedCandidates(webrtc::SessionDescriptionInterface &description) {
-    std::vector<std::unique_ptr<webrtc::IceCandidate>> blocked;
-    for (size_t i = 0; i < description.number_of_mediasections(); ++i) {
-      auto candidates = description.candidates(i);
-      for (size_t j = 0; candidates && j < candidates->count(); ++j) {
-        auto candidate = candidates->at(j);
-        if (isBlockedCandidate(candidate->candidate())) {
-          blocked.push_back(webrtc::CreateIceCandidate(
-              candidate->sdp_mid(), candidate->sdp_mline_index(), candidate->candidate()));
+  namespace {
+
+    // A remote TCP candidate on a port Fetch blocks is ignored, as the WebRTC specification requires
+    // (https://fetch.spec.whatwg.org/#bad-port)
+    bool isBlockedCandidate(const webrtc::Candidate &candidate) {
+      static const std::set<int> badPorts = {
+          0,    1,    7,    9,    11,   13,   15,   17,   19,   20,   21,   22,   23,   25,   37,   42,   43,
+          53,   69,   77,   79,   87,   95,   101,  102,  103,  104,  109,  110,  111,  113,  115,  117,  119,
+          123,  135,  137,  139,  143,  161,  179,  389,  427,  465,  512,  513,  514,  515,  526,  530,  531,
+          532,  540,  548,  554,  556,  563,  587,  601,  636,  989,  990,  993,  995,  1719, 1720, 1723, 2049,
+          3659, 4045, 4190, 5060, 5061, 6000, 6566, 6665, 6666, 6667, 6668, 6669, 6679, 6697, 10080};
+      return candidate.protocol() == "tcp" && badPorts.contains(candidate.address().port());
+    }
+
+    void removeBlockedCandidates(webrtc::SessionDescriptionInterface &description) {
+      std::vector<std::unique_ptr<webrtc::IceCandidate>> blocked;
+      for (size_t i = 0; i < description.number_of_mediasections(); ++i) {
+        const auto *candidates = description.candidates(i);
+        for (size_t j = 0; (candidates != nullptr) && j < candidates->count(); ++j) {
+          const auto *candidate = candidates->at(j);
+          if (isBlockedCandidate(candidate->candidate())) {
+            blocked.push_back(
+                webrtc::CreateIceCandidate(candidate->sdp_mid(), candidate->sdp_mline_index(), candidate->candidate()));
+          }
         }
       }
+      for (const auto &candidate : blocked) {
+        description.RemoveCandidate(candidate.get());
+      }
     }
-    for (const auto &candidate: blocked) {
-      description.RemoveCandidate(candidate.get());
-    }
-  }
 
-  // the line of an SDP parse error, counting from 1
-  static std::optional<int> lineNumber(const std::string &sdp, const std::string &line) {
-    auto pos = line.empty() ? std::string::npos : sdp.find(line);
-    if (pos == std::string::npos) {
-      return std::nullopt;
+    // the line of an SDP parse error, counting from 1
+    std::optional<int> lineNumber(const std::string &sdp, const std::string &line) {
+      auto pos = line.empty() ? std::string::npos : sdp.find(line);
+      if (pos == std::string::npos) {
+        return std::nullopt;
+      }
+      return 1 + static_cast<int>(std::count(sdp.begin(), sdp.begin() + static_cast<std::ptrdiff_t>(pos), '\n'));
     }
-    return 1 + static_cast<int>(std::count(sdp.begin(), sdp.begin() + static_cast<std::ptrdiff_t>(pos), '\n'));
-  }
 
-  static std::unique_ptr<webrtc::SessionDescriptionInterface> parseDescription(
-      const RTCSessionDescriptionInit &init, std::optional<RTCCallbackException> &error) {
-    webrtc::SdpParseError parseError;
-    auto description = webrtc::CreateSessionDescription(init.type, init.sdp, &parseError);
-    if (!description) {
-      webrtc::RTCError rtcError(webrtc::RTCErrorType::OPERATION_ERROR_WITH_DATA,
-                                "Failed to parse the session description: " + parseError.description +
-                                (parseError.line.empty() ? "" : " (" + parseError.line + ")"));
-      rtcError.set_error_detail(webrtc::RTCErrorDetailType::SDP_SYNTAX_ERROR);
-      error.emplace(std::move(rtcError), lineNumber(init.sdp, parseError.line));
+    std::unique_ptr<webrtc::SessionDescriptionInterface> parseDescription(const RTCSessionDescriptionInit &init,
+                                                                          std::optional<RTCCallbackException> &error) {
+      webrtc::SdpParseError parseError;
+      auto description = webrtc::CreateSessionDescription(init.type, init.sdp, &parseError);
+      if (!description) {
+        webrtc::RTCError rtcError(webrtc::RTCErrorType::OPERATION_ERROR_WITH_DATA,
+                                  "Failed to parse the session description: " + parseError.description +
+                                      (parseError.line.empty() ? "" : " (" + parseError.line + ")"));
+        rtcError.set_error_detail(webrtc::RTCErrorDetailType::SDP_SYNTAX_ERROR);
+        error.emplace(std::move(rtcError), lineNumber(init.sdp, parseError.line));
+      }
+      return description;
     }
-    return description;
-  }
 
-  static bool canSetLocal(webrtc::SdpType type, RTCPeerConnection::SignalingState state) {
-    using SignalingState = RTCPeerConnection::SignalingState;
-    if (type == webrtc::SdpType::kOffer) {
-      return state == SignalingState::kStable || state == SignalingState::kHaveLocalOffer;
-    }
-    if (type == webrtc::SdpType::kRollback) {
-      return state == SignalingState::kHaveLocalOffer || state == SignalingState::kHaveLocalPrAnswer;
+    bool canSetLocal(webrtc::SdpType type, RTCPeerConnection::SignalingState state) {
+      using SignalingState = RTCPeerConnection::SignalingState;
+      if (type == webrtc::SdpType::kOffer) {
+        return state == SignalingState::kStable || state == SignalingState::kHaveLocalOffer;
+      }
+      if (type == webrtc::SdpType::kRollback) {
+        return state == SignalingState::kHaveLocalOffer || state == SignalingState::kHaveLocalPrAnswer;
+      }
+      return state == SignalingState::kHaveRemoteOffer || state == SignalingState::kHaveLocalPrAnswer;
     }
-    return state == SignalingState::kHaveRemoteOffer || state == SignalingState::kHaveLocalPrAnswer;
-  }
 
-  std::function<void(webrtc::RTCError)> RTCPeerConnection::Completion(
-      std::function<void()> &onSuccess, std::function<void(RTCCallbackException)> &onFailure,
-      const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc, DescriptionKind kind) {
-    bool remote = kind == DescriptionKind::kRemote;
+  } // namespace
+
+  std::function<void(webrtc::RTCError)>
+  RTCPeerConnection::Completion(std::function<void()> &onSuccess, std::function<void(RTCCallbackException)> &onFailure,
+                                const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc,
+                                DescriptionKind kind) {
+    const bool remote = kind == DescriptionKind::kRemote;
     // a local description starts gathering, the candidates come after it
     auto held = std::make_shared<HeldOperationEvents>(pc, IceTransports(), remote ? nullptr : shared_from_this());
     if (remote) {
@@ -622,7 +636,7 @@ namespace python_webrtc {
         }
         onSuccess();
         // their gathering events come after the operation
-        for (const auto &iceTransport: created) {
+        for (const auto &iceTransport : created) {
           iceTransport->CreatedByDescription();
         }
       } else {
@@ -633,10 +647,9 @@ namespace python_webrtc {
     };
   }
 
-  void RTCPeerConnection::SetLocalDescription(
-      std::function<void()> &onSuccess,
-      std::function<void(RTCCallbackException)> &onFailure,
-      const std::optional<RTCSessionDescriptionInit> &init) {
+  void RTCPeerConnection::SetLocalDescription(std::function<void()> &onSuccess,
+                                              std::function<void(RTCCallbackException)> &onFailure,
+                                              const std::optional<RTCSessionDescriptionInit> &init) {
     auto pc = connection();
     auto state = pc ? pc->signaling_state() : SignalingState::kClosed;
     if (state == SignalingState::kClosed) {
@@ -644,7 +657,8 @@ namespace python_webrtc {
       return;
     }
     if (init && !canSetLocal(init->type, state)) {
-      onFailure(RTCCallbackException(webrtc::RTCErrorType::INVALID_STATE,
+      onFailure(RTCCallbackException(
+          webrtc::RTCErrorType::INVALID_STATE,
           "Failed to execute 'setLocalDescription' on 'RTCPeerConnection': The description type doesn't match "
           "the signaling state."));
       return;
@@ -652,10 +666,13 @@ namespace python_webrtc {
 
     if (!init || (init->sdp.empty() && init->type != webrtc::SdpType::kRollback)) {
       // without a type, an answer in the states that wait for one, an offer otherwise
-      bool waitsForAnswer = state == SignalingState::kHaveRemoteOffer || state == SignalingState::kHaveLocalPrAnswer;
-      auto type = init ? init->type : (waitsForAnswer ? webrtc::SdpType::kAnswer : webrtc::SdpType::kOffer);
+      const bool waitsForAnswer =
+          state == SignalingState::kHaveRemoteOffer || state == SignalingState::kHaveLocalPrAnswer;
+      const auto implicitType = waitsForAnswer ? webrtc::SdpType::kAnswer : webrtc::SdpType::kOffer;
+      auto type = init ? init->type : implicitType;
       auto complete = Completion(onSuccess, onFailure, pc, DescriptionKind::kLocal);
-      if (type == webrtc::SdpType::kOffer || (type == webrtc::SdpType::kAnswer && state == SignalingState::kHaveRemoteOffer)) {
+      if (type == webrtc::SdpType::kOffer ||
+          (type == webrtc::SdpType::kAnswer && state == SignalingState::kHaveRemoteOffer)) {
         // libwebrtc creates the offer or the answer the signaling state calls for
         pc->SetLocalDescription(webrtc::make_ref_counted<SetLocalDescriptionObserver>(std::move(complete)));
       } else {
@@ -665,10 +682,11 @@ namespace python_webrtc {
     }
 
     if (init->type != webrtc::SdpType::kRollback) {
-      std::lock_guard<std::mutex> lock(_createdMutex);
+      const std::scoped_lock lock(_createdMutex);
       auto &last = init->type == webrtc::SdpType::kOffer ? _lastOffer : _lastAnswer;
       if (init->sdp != last) {
-        onFailure(RTCCallbackException(webrtc::RTCErrorType::INVALID_MODIFICATION,
+        onFailure(RTCCallbackException(
+            webrtc::RTCErrorType::INVALID_MODIFICATION,
             "Failed to execute 'setLocalDescription' on 'RTCPeerConnection': The SDP does not match the previously "
             "generated SDP for this type"));
         return;
@@ -682,12 +700,12 @@ namespace python_webrtc {
       return;
     }
     pc->SetLocalDescription(std::move(description), webrtc::make_ref_counted<SetLocalDescriptionObserver>(
-        Completion(onSuccess, onFailure, pc, DescriptionKind::kLocal)));
+                                                        Completion(onSuccess, onFailure, pc, DescriptionKind::kLocal)));
   }
 
-  void RTCPeerConnection::SetImplicitAnswer(
-      const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc, webrtc::SdpType type,
-      std::function<void(webrtc::RTCError)> complete, const std::function<void(RTCCallbackException)> &onFailure) {
+  void RTCPeerConnection::SetImplicitAnswer(const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc,
+                                            webrtc::SdpType type, std::function<void(webrtc::RTCError)> complete,
+                                            const std::function<void(RTCCallbackException)> &onFailure) {
     auto observer = webrtc::make_ref_counted<SetLocalDescriptionObserver>(std::move(complete));
     auto apply = [pc, observer, type, onFailure](const std::string &sdp) {
       std::optional<RTCCallbackException> error;
@@ -700,25 +718,24 @@ namespace python_webrtc {
     };
     std::string lastAnswer;
     {
-      std::lock_guard<std::mutex> lock(_createdMutex);
+      const std::scoped_lock lock(_createdMutex);
       lastAnswer = _lastAnswer;
     }
     if (!lastAnswer.empty()) {
       apply(lastAnswer);
       return;
     }
-    std::function<void(RTCSessionDescription)> created = [apply](RTCSessionDescription answer) {
+    std::function<void(RTCSessionDescription)> created = [apply](const RTCSessionDescription &answer) {
       apply(answer.init().sdp);
     };
     std::function<void(RTCCallbackException)> failed = onFailure;
-    pc->CreateAnswer(new webrtc::RefCountedObject<CreateSessionDescriptionObserver>(weak_from_this(), created, failed),
-                     webrtc::PeerConnectionInterface::RTCOfferAnswerOptions());
+    auto answerObserver = webrtc::make_ref_counted<CreateSessionDescriptionObserver>(weak_from_this(), created, failed);
+    pc->CreateAnswer(answerObserver.get(), webrtc::PeerConnectionInterface::RTCOfferAnswerOptions());
   }
 
-  void RTCPeerConnection::SetRemoteDescription(
-      std::function<void()> &onSuccess,
-      std::function<void(RTCCallbackException)> &onFailure,
-      const RTCSessionDescriptionInit &init) {
+  void RTCPeerConnection::SetRemoteDescription(std::function<void()> &onSuccess,
+                                               std::function<void(RTCCallbackException)> &onFailure,
+                                               const RTCSessionDescriptionInit &init) {
     auto pc = connection();
     auto state = pc ? pc->signaling_state() : SignalingState::kClosed;
     if (state == SignalingState::kClosed) {
@@ -727,18 +744,21 @@ namespace python_webrtc {
     }
 
     // the state is checked before the SDP is parsed
-    bool answer = init.type == webrtc::SdpType::kAnswer || init.type == webrtc::SdpType::kPrAnswer;
-    bool rollback = init.type == webrtc::SdpType::kRollback;
+    const bool answer = init.type == webrtc::SdpType::kAnswer || init.type == webrtc::SdpType::kPrAnswer;
+    const bool rollback = init.type == webrtc::SdpType::kRollback;
     if ((answer && state != SignalingState::kHaveLocalOffer && state != SignalingState::kHaveRemotePrAnswer) ||
         (rollback && state != SignalingState::kHaveRemoteOffer && state != SignalingState::kHaveRemotePrAnswer)) {
-      onFailure(RTCCallbackException(webrtc::RTCErrorType::INVALID_STATE,
+      onFailure(RTCCallbackException(
+          webrtc::RTCErrorType::INVALID_STATE,
           "Failed to execute 'setRemoteDescription' on 'RTCPeerConnection': Called in wrong state: " +
-          std::string(webrtc::PeerConnectionInterface::AsString(state))));
+              std::string(webrtc::PeerConnectionInterface::AsString(state))));
       return;
     }
 
-    auto complete = Completion(onSuccess, onFailure, pc, DescriptionKind::kRemote);
-    auto apply = [init, complete, onFailure](webrtc::scoped_refptr<webrtc::PeerConnectionInterface> pc) {
+    // shared by the rollback and the application of the description
+    auto complete = std::make_shared<const std::function<void(webrtc::RTCError)>>(
+        Completion(onSuccess, onFailure, pc, DescriptionKind::kRemote));
+    auto apply = [init, complete, onFailure](const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc) {
       std::optional<RTCCallbackException> error;
       auto description = parseDescription(init, error);
       if (error) {
@@ -746,7 +766,9 @@ namespace python_webrtc {
         return;
       }
       removeBlockedCandidates(*description);
-      pc->SetRemoteDescription(std::move(description), webrtc::make_ref_counted<SetRemoteDescriptionObserver>(complete));
+      pc->SetRemoteDescription(std::move(description),
+                               webrtc::make_ref_counted<SetRemoteDescriptionObserver>(
+                                   [complete](webrtc::RTCError error) { (*complete)(std::move(error)); }));
     };
 
     if (init.type == webrtc::SdpType::kOffer && state == SignalingState::kHaveLocalOffer) {
@@ -757,9 +779,9 @@ namespace python_webrtc {
             auto self = weak.lock();
             auto pc = self ? self->connection() : nullptr;
             if (!rollbackError.ok()) {
-              complete(std::move(rollbackError));
+              (*complete)(std::move(rollbackError));
             } else if (!pc) {
-              complete(closedError("setRemoteDescription"));
+              (*complete)(closedError("setRemoteDescription"));
             } else {
               apply(pc);
             }
@@ -772,99 +794,119 @@ namespace python_webrtc {
     apply(pc);
   }
 
-  // End-of-candidates candidates of a local description, one per transport (the first media section of each)
-  static std::vector<IceCandidateInit> endOfCandidates(const webrtc::SessionDescriptionInterface *description) {
-    std::vector<IceCandidateInit> result;
-    if (!description) {
+  namespace {
+
+    // End-of-candidates candidates of a local description, one per transport (the first media section of each)
+    std::vector<IceCandidateInit> endOfCandidates(const webrtc::SessionDescriptionInterface *description) {
+      std::vector<IceCandidateInit> result;
+      if (description == nullptr) {
+        return result;
+      }
+      const auto *session = description->description();
+      const auto *bundle = session->GetGroupByName(static_cast<const char *>(webrtc::GROUP_TYPE_BUNDLE));
+      bool bundleDone = false;
+      int index = 0;
+      for (const auto &content : session->contents()) {
+        auto mid = content.mid();
+        const bool bundled = (bundle != nullptr) && bundle->HasContentName(mid);
+        if (!content.rejected && !(bundled && bundleDone)) {
+          const auto *transport = session->GetTransportInfoByName(mid);
+          std::optional<std::string> ufrag;
+          if ((transport != nullptr) && !transport->description.ice_ufrag.empty()) {
+            ufrag = transport->description.ice_ufrag;
+          }
+          result.emplace_back(mid, index, ufrag);
+          bundleDone = bundleDone || bundled;
+        }
+        ++index;
+      }
       return result;
     }
-    auto session = description->description();
-    auto bundle = session->GetGroupByName(webrtc::GROUP_TYPE_BUNDLE);
-    bool bundleDone = false;
-    int index = 0;
-    for (const auto &content: session->contents()) {
-      auto mid = content.mid();
-      bool bundled = bundle && bundle->HasContentName(mid);
-      if (!content.rejected && !(bundled && bundleDone)) {
-        auto transport = session->GetTransportInfoByName(mid);
-        std::optional<std::string> ufrag;
-        if (transport && !transport->description.ice_ufrag.empty()) {
-          ufrag = transport->description.ice_ufrag;
+
+    constexpr std::string_view kMidPrefix = "a=mid:";
+
+    // Adds a=end-of-candidates to the media sections of a description (of these mids, or all of them)
+    std::string addEndOfCandidates(const std::string &sdp, const std::set<std::string> *mids = nullptr) {
+      std::string result;
+      bool inMedia = false;
+      bool rejected = false;
+      bool ended = false;
+      std::string mid;
+      auto endSection = [&]() {
+        if (inMedia && !rejected && !ended && (!mids || mids->contains(mid))) {
+          result += "a=end-of-candidates\r\n";
         }
-        result.emplace_back(mid, index, ufrag);
-        bundleDone = bundleDone || bundled;
+      };
+      size_t pos = 0;
+      while (pos < sdp.size()) {
+        auto end = sdp.find("\r\n", pos);
+        auto line = sdp.substr(pos, end == std::string::npos ? std::string::npos : end - pos);
+        if (line.starts_with("m=")) {
+          endSection();
+          inMedia = true;
+          ended = false;
+          // a rejected media section has port 0
+          auto space = line.find(' ');
+          rejected = space != std::string::npos && line.compare(space + 1, 2, "0 ") == 0;
+          mid.clear();
+        } else if (line == "a=end-of-candidates") {
+          ended = true;
+        } else if (line.starts_with(kMidPrefix)) {
+          mid = line.substr(kMidPrefix.size());
+        }
+        result += line + "\r\n";
+        if (end == std::string::npos) {
+          break;
+        }
+        pos = end + 2;
       }
-      ++index;
+      endSection();
+      return result;
     }
-    return result;
-  }
 
-  // Adds a=end-of-candidates to the media sections of a description (of these mids, or all of them)
-  static std::string addEndOfCandidates(const std::string &sdp, const std::set<std::string> *mids = nullptr) {
-    std::string result;
-    bool inMedia = false, rejected = false, ended = false;
-    std::string mid;
-    auto endSection = [&]() {
-      if (inMedia && !rejected && !ended && (!mids || mids->count(mid))) {
-        result += "a=end-of-candidates\r\n";
-      }
-    };
-    size_t pos = 0;
-    while (pos < sdp.size()) {
-      auto end = sdp.find("\r\n", pos);
-      auto line = sdp.substr(pos, end == std::string::npos ? std::string::npos : end - pos);
-      if (line.rfind("m=", 0) == 0) {
-        endSection();
-        inMedia = true;
-        ended = false;
-        // a rejected media section has port 0
-        auto space = line.find(' ');
-        rejected = space != std::string::npos && line.compare(space + 1, 2, "0 ") == 0;
-        mid.clear();
-      } else if (line == "a=end-of-candidates") {
-        ended = true;
-      } else if (line.rfind("a=mid:", 0) == 0) {
-        mid = line.substr(6);
-      }
-      result += line + "\r\n";
-      if (end == std::string::npos) {
-        break;
-      }
-      pos = end + 2;
+    std::vector<const webrtc::SessionDescriptionInterface *>
+    liveDescriptions(const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc) {
+      return {pc->current_local_description(), pc->current_remote_description(), pc->pending_local_description(),
+              pc->pending_remote_description()};
     }
-    endSection();
-    return result;
-  }
 
-  static std::vector<const webrtc::SessionDescriptionInterface *> liveDescriptions(
-      const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc) {
-    return {pc->current_local_description(), pc->current_remote_description(),
-            pc->pending_local_description(), pc->pending_remote_description()};
-  }
+  } // namespace
 
-  RTCPeerConnection::DescriptionView RTCPeerConnection::ReadDescription(
-      const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc, DescriptionKind kind) {
+  RTCPeerConnection::DescriptionView
+  RTCPeerConnection::ReadDescription(const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc,
+                                     DescriptionKind kind) {
     DescriptionView view;
     switch (kind) {
-      case DescriptionKind::kLocal: view.description = pc->local_description(); break;
-      case DescriptionKind::kRemote: view.description = pc->remote_description(); break;
-      case DescriptionKind::kCurrentLocal: view.description = pc->current_local_description(); break;
-      case DescriptionKind::kCurrentRemote: view.description = pc->current_remote_description(); break;
-      case DescriptionKind::kPendingLocal: view.description = pc->pending_local_description(); break;
-      case DescriptionKind::kPendingRemote: view.description = pc->pending_remote_description(); break;
-    }
-    if (!view.description) {
+    case DescriptionKind::kLocal:
+      view.description = pc->local_description();
+      break;
+    case DescriptionKind::kRemote:
+      view.description = pc->remote_description();
+      break;
+    case DescriptionKind::kCurrentLocal:
+      view.description = pc->current_local_description();
+      break;
+    case DescriptionKind::kCurrentRemote:
+      view.description = pc->current_remote_description();
+      break;
+    case DescriptionKind::kPendingLocal:
+      view.description = pc->pending_local_description();
+      break;
+    case DescriptionKind::kPendingRemote:
+      view.description = pc->pending_remote_description();
+      break;
+    }
+    if (view.description == nullptr) {
       return view;
     }
-    auto &init = view.init.emplace(
-        RTCSessionDescriptionInit::Wrap(const_cast<webrtc::SessionDescriptionInterface *>(view.description)));
-    bool local = kind == DescriptionKind::kLocal || kind == DescriptionKind::kCurrentLocal ||
-                 kind == DescriptionKind::kPendingLocal;
+    auto &init = view.init.emplace(RTCSessionDescriptionInit::Wrap(view.description));
+    const bool local = kind == DescriptionKind::kLocal || kind == DescriptionKind::kCurrentLocal ||
+                       kind == DescriptionKind::kPendingLocal;
     if (local && pc->ice_gathering_state() == IceGatheringState::kIceGatheringComplete) {
       init.sdp = addEndOfCandidates(init.sdp);
     } else if (!local && view.description == pc->remote_description()) {
       // the end of remote candidates, from addIceCandidate
-      std::lock_guard<std::mutex> lock(_remoteEndOfCandidatesMutex);
+      const std::scoped_lock lock(_remoteEndOfCandidatesMutex);
       if (_remoteEndOfCandidatesDescription == view.description && !_remoteEndOfCandidates.empty()) {
         init.sdp = addEndOfCandidates(init.sdp, &_remoteEndOfCandidates);
       }
@@ -883,7 +925,7 @@ namespace python_webrtc {
     bool shown = false;
     {
       // the descriptions as the last event that changed them left them, until the next one
-      std::lock_guard<std::mutex> lock(_descriptionsMutex);
+      const std::scoped_lock lock(_descriptionsMutex);
       if (HasListeners() && _shown && _shownGeneration == _descriptionsGeneration) {
         view = _shown->kinds[static_cast<size_t>(kind)];
         live = _shown->live;
@@ -892,36 +934,37 @@ namespace python_webrtc {
     }
     if (!shown) {
       // the description is owned by the peer connection and must be read on the signaling thread
-      _factory->_signalingThread->BlockingCall([&]() {
+      _factory->signalingThread()->BlockingCall([&]() {
         view = ReadDescription(pc, kind);
         live = liveDescriptions(pc);
       });
     }
 
-    std::lock_guard<std::mutex> lock(_descriptionsMutex);
+    const std::scoped_lock lock(_descriptionsMutex);
     // while events are delivered, a description only changes with them; without events it's always current
-    bool refresh = shown || !HasListeners() || _descriptionsCachedGeneration != _descriptionsGeneration;
+    const bool refresh = shown || !HasListeners() || _descriptionsCachedGeneration != _descriptionsGeneration;
     _descriptionsCachedGeneration = _descriptionsGeneration;
     return FindOrCreateDescription(view, live, refresh);
   }
 
   std::shared_ptr<RTCSessionDescription> RTCPeerConnection::FindOrCreateDescription(
-      const DescriptionView &view, const std::vector<const webrtc::SessionDescriptionInterface *> &live,
-      bool refresh) {
+      const DescriptionView &view, const std::vector<const webrtc::SessionDescriptionInterface *> &live, bool refresh) {
     // descriptions that aren't set anymore are forgotten, so a new one at the same address is a new object
     std::vector<std::pair<const webrtc::SessionDescriptionInterface *, std::shared_ptr<RTCSessionDescription>>> kept;
     std::shared_ptr<RTCSessionDescription> result;
-    for (auto &entry: _descriptions) {
-      if (std::find(live.begin(), live.end(), entry.first) == live.end()) {
+    for (auto &entry : _descriptions) {
+      if (std::ranges::find(live, entry.first) == live.end()) {
         continue;
       }
-      auto &init = entry.second->init();
-      if (entry.first == view.description && init.type == view.init->type && (!refresh || init.sdp == view.init->sdp)) {
+      const auto &init = entry.second->init();
+      if (view.init && entry.first == view.description && init.type == view.init->type &&
+          (!refresh || init.sdp == view.init->sdp)) {
         result = entry.second;
       }
       kept.push_back(std::move(entry));
     }
-    if (view.description && !result) {
+    // set with the description
+    if (view.init && !result) {
       result = std::make_shared<RTCSessionDescription>(*view.init);
       kept.emplace_back(view.description, result);
     }
@@ -963,7 +1006,7 @@ namespace python_webrtc {
       snapshot.kinds[kind] = ReadDescription(pc, static_cast<DescriptionKind>(kind));
     }
     snapshot.live = liveDescriptions(pc);
-    std::lock_guard<std::mutex> lock(_descriptionsMutex);
+    const std::scoped_lock lock(_descriptionsMutex);
     auto id = ++_lastSnapshot;
     _snapshots.emplace(id, std::move(snapshot));
     while (_snapshots.size() > kMaxPendingSnapshots) {
@@ -973,7 +1016,7 @@ namespace python_webrtc {
   }
 
   void RTCPeerConnection::ApplyDescriptions(std::optional<uint64_t> snapshot) {
-    std::lock_guard<std::mutex> lock(_descriptionsMutex);
+    const std::scoped_lock lock(_descriptionsMutex);
     auto it = _snapshots.find(snapshot.value_or(_completionSnapshot));
     if (it == _snapshots.end()) {
       return;
@@ -985,7 +1028,7 @@ namespace python_webrtc {
   }
 
   void RTCPeerConnection::RefreshDescriptions() {
-    std::lock_guard<std::mutex> lock(_descriptionsMutex);
+    const std::scoped_lock lock(_descriptionsMutex);
     ++_descriptionsGeneration;
   }
 
@@ -994,8 +1037,8 @@ namespace python_webrtc {
     return pc ? pc->can_trickle_ice_candidates() : std::nullopt;
   }
 
-  std::shared_ptr<RTCRtpSender> RTCPeerConnection::AddTrack(
-      MediaStreamTrack &mediaStreamTrack, const std::vector<MediaStream *> &mediaStreams) {
+  std::shared_ptr<RTCRtpSender> RTCPeerConnection::AddTrack(MediaStreamTrack &mediaStreamTrack,
+                                                            const std::vector<MediaStream *> &mediaStreams) {
     auto pc = connection();
     if (!pc) {
       throw RTCException(closedError("addTrack"));
@@ -1003,7 +1046,7 @@ namespace python_webrtc {
 
     std::vector<std::string> streamIds;
     streamIds.reserve(mediaStreams.size());
-    for (auto const &stream: mediaStreams) {
+    for (const auto &stream : mediaStreams) {
       streamIds.emplace_back(stream->stream()->id());
     }
 
@@ -1016,8 +1059,9 @@ namespace python_webrtc {
     return Wrap(_senders, result.value());
   }
 
-  std::shared_ptr<RTCRtpSender> RTCPeerConnection::AddTrack(
-      MediaStreamTrack &mediaStreamTrack, std::optional<std::reference_wrapper<MediaStream>> mediaStream) {
+  std::shared_ptr<RTCRtpSender>
+  RTCPeerConnection::AddTrack(MediaStreamTrack &mediaStreamTrack,
+                              std::optional<std::reference_wrapper<MediaStream>> mediaStream) {
     std::vector<MediaStream *> mediaStreams;
     if (mediaStream) {
       mediaStreams.push_back(&mediaStream->get());
@@ -1032,8 +1076,9 @@ namespace python_webrtc {
     }
 
     auto senders = pc->GetSenders();
-    if (std::find(senders.begin(), senders.end(), sender.sender()) == senders.end()) {
-      throw RTCException(webrtc::RTCErrorType::INVALID_PARAMETER, "The sender was not created by this RTCPeerConnection");
+    if (std::ranges::find(senders, sender.sender()) == senders.end()) {
+      throw RTCException(webrtc::RTCErrorType::INVALID_PARAMETER,
+                         "The sender was not created by this RTCPeerConnection");
     }
 
     auto error = pc->RemoveTrackOrError(sender.sender());
@@ -1043,8 +1088,9 @@ namespace python_webrtc {
     QueueNegotiationNeeded();
   }
 
-  std::shared_ptr<RTCRtpTransceiver> RTCPeerConnection::AddTransceiver(
-      webrtc::MediaType kind, std::optional<std::reference_wrapper<webrtc::RtpTransceiverInit>> &init) {
+  std::shared_ptr<RTCRtpTransceiver>
+  RTCPeerConnection::AddTransceiver(webrtc::MediaType kind,
+                                    std::optional<std::reference_wrapper<webrtc::RtpTransceiverInit>> &init) {
     auto pc = connection();
     if (!pc) {
       throw RTCException(closedError("addTransceiver"));
@@ -1052,8 +1098,9 @@ namespace python_webrtc {
     return AddedTransceiver(init ? pc->AddTransceiver(kind, init->get()) : pc->AddTransceiver(kind));
   }
 
-  std::shared_ptr<RTCRtpTransceiver> RTCPeerConnection::AddTransceiver(
-      MediaStreamTrack &track, std::optional<std::reference_wrapper<webrtc::RtpTransceiverInit>> &init) {
+  std::shared_ptr<RTCRtpTransceiver>
+  RTCPeerConnection::AddTransceiver(MediaStreamTrack &track,
+                                    std::optional<std::reference_wrapper<webrtc::RtpTransceiverInit>> &init) {
     auto pc = connection();
     if (!pc) {
       throw RTCException(closedError("addTransceiver"));
@@ -1075,7 +1122,8 @@ namespace python_webrtc {
       return Sync(_transceivers, pc->GetTransceivers());
     }
     auto closed = closedConnection();
-    return closed ? Unkept<RTCRtpTransceiver>(closed->GetTransceivers()) : std::vector<std::shared_ptr<RTCRtpTransceiver>>();
+    return closed ? Unkept<RTCRtpTransceiver>(closed->GetTransceivers())
+                  : std::vector<std::shared_ptr<RTCRtpTransceiver>>();
   }
 
   std::vector<std::shared_ptr<RTCRtpSender>> RTCPeerConnection::GetSenders() {
@@ -1094,9 +1142,10 @@ namespace python_webrtc {
     return {};
   }
 
-  std::shared_ptr<RTCDataChannel> RTCPeerConnection::CreateDataChannel(
-      const std::string &label, bool ordered, std::optional<int> maxPacketLifeTime, std::optional<int> maxRetransmits,
-      const std::string &protocol, bool negotiated, std::optional<int> id, webrtc::Priority priority) {
+  std::shared_ptr<RTCDataChannel>
+  RTCPeerConnection::CreateDataChannel(const std::string &label, bool ordered, std::optional<int> maxPacketLifeTime,
+                                       std::optional<int> maxRetransmits, const std::string &protocol, bool negotiated,
+                                       std::optional<int> id, webrtc::Priority priority) {
     auto pc = connection();
     if (!pc || pc->signaling_state() == SignalingState::kClosed) {
       throw RTCException(closedError("createDataChannel"));
@@ -1116,17 +1165,19 @@ namespace python_webrtc {
       auto error = result.MoveError();
       // an id in use, no id left, or too many channels: the arguments were checked by Python already
       throw RTCException(error.type() == webrtc::RTCErrorType::INVALID_STATE
-                         ? error.type() : webrtc::RTCErrorType::UNSUPPORTED_OPERATION, error.message());
+                             ? error.type()
+                             : webrtc::RTCErrorType::UNSUPPORTED_OPERATION,
+                         error.message());
     }
     QueueNegotiationNeeded();
     return Wrap(_channels, result.MoveValue());
   }
 
   std::optional<std::shared_ptr<RTCSctpTransport>> RTCPeerConnection::GetSctp() {
-    if (!onLibwebrtcThread) {
+    if (!OnLibwebrtcThread()) {
       // see Wrap
-      gil_release_if_held release;
-      return _factory->_signalingThread->BlockingCall([this]() { return GetSctp(); });
+      const gil_release_if_held release;
+      return _factory->signalingThread()->BlockingCall([this]() { return GetSctp(); });
     }
     auto pc = connection();
     auto transport = pc ? pc->GetSctpTransport() : nullptr;
@@ -1135,7 +1186,7 @@ namespace python_webrtc {
     }
 
     std::shared_ptr<RTCSctpTransport> previous;
-    std::lock_guard<std::mutex> lock(_wrappersMutex);
+    const std::scoped_lock lock(_wrappersMutex);
     if (!_sctp || _sctp->transport() != transport) {
       previous = std::move(_sctp);
       _sctp = RTCSctpTransport::holder().GetOrCreate(_factory, transport);
@@ -1151,22 +1202,22 @@ namespace python_webrtc {
     if (!pc) {
       return {};
     }
-    return _factory->_signalingThread->BlockingCall([&pc]() -> std::optional<double> {
+    return _factory->signalingThread()->BlockingCall([&pc]() -> std::optional<double> {
       auto sctpSize = [](const webrtc::SessionDescriptionInterface *description) -> std::optional<int> {
         if (!description) {
           return {};
         }
-        for (const auto &content: description->description()->contents()) {
-          auto *sctp = content.media_description() ? content.media_description()->as_sctp() : nullptr;
+        for (const auto &content : description->description()->contents()) {
+          const auto *sctp = content.media_description() ? content.media_description()->as_sctp() : nullptr;
           if (sctp && !content.rejected) {
             return sctp->max_message_size();
           }
         }
         return {};
       };
-      double canSendSize = sctpSize(pc->current_local_description()).value_or(kLocalMaxMessageSize);
+      const double canSendSize = sctpSize(pc->current_local_description()).value_or(kLocalMaxMessageSize);
       // updated once the description is negotiated, when an answer is set
-      double remoteSize = sctpSize(pc->current_remote_description()).value_or(kDefaultRemoteMaxMessageSize);
+      const double remoteSize = sctpSize(pc->current_remote_description()).value_or(kDefaultRemoteMaxMessageSize);
       if (remoteSize == 0 && canSendSize == 0) {
         return std::numeric_limits<double>::infinity();
       }
@@ -1178,7 +1229,7 @@ namespace python_webrtc {
   }
 
   ConfigurationInit RTCPeerConnection::GetConfiguration() {
-    std::lock_guard<std::mutex> lock(_connectionMutex);
+    const std::scoped_lock lock(_connectionMutex);
     return _configuration;
   }
 
@@ -1189,11 +1240,11 @@ namespace python_webrtc {
     }
 
     {
-      std::lock_guard<std::mutex> lock(_connectionMutex);
+      const std::scoped_lock lock(_connectionMutex);
       if (init.alwaysNegotiateDataChannels != _configuration.alwaysNegotiateDataChannels ||
           init.rtpHeaderEncryptionPolicy != _configuration.rtpHeaderEncryptionPolicy) {
         throw RTCException(webrtc::RTCErrorType::INVALID_MODIFICATION,
-            "alwaysNegotiateDataChannels and rtpHeaderEncryptionPolicy can't be changed");
+                           "alwaysNegotiateDataChannels and rtpHeaderEncryptionPolicy can't be changed");
       }
     }
     auto error = pc->SetConfiguration(init.Apply(pc->GetConfiguration()));
@@ -1201,7 +1252,7 @@ namespace python_webrtc {
       throw RTCException(error);
     }
 
-    std::lock_guard<std::mutex> lock(_connectionMutex);
+    const std::scoped_lock lock(_connectionMutex);
     auto certificates = _configuration.certificates;
     _configuration = init;
     if (!_configuration.certificates) {
@@ -1212,7 +1263,7 @@ namespace python_webrtc {
   void RTCPeerConnection::RestartIce() {
     auto pc = connection();
     // before the first local description, there are no credentials to replace: the first offer has new ones
-    if (pc && pc->local_description()) {
+    if (pc && (pc->local_description() != nullptr)) {
       pc->RestartIce();
       QueueNegotiationNeeded();
     }
@@ -1221,7 +1272,7 @@ namespace python_webrtc {
   void RTCPeerConnection::QueueNegotiationNeeded() {
     // libwebrtc posts the negotiationneeded event of a change to the signaling thread: once the thread ran it,
     // the event is queued during the call
-    _factory->_signalingThread->BlockingCall([]() {});
+    _factory->signalingThread()->BlockingCall([]() {});
   }
 
   bool RTCPeerConnection::ShouldFireNegotiationNeededEvent(uint32_t eventId) {
@@ -1233,8 +1284,8 @@ namespace python_webrtc {
     // closing changes states, but a closed connection fires no events, nor do its channels and transports
     Mute();
     {
-      std::lock_guard<std::mutex> lock(_wrappersMutex);
-      for (auto &channel: _channels) {
+      const std::scoped_lock lock(_wrappersMutex);
+      for (auto &channel : _channels) {
         channel.second->OnPeerConnectionClosed();
       }
     }
@@ -1242,7 +1293,7 @@ namespace python_webrtc {
 
     webrtc::scoped_refptr<webrtc::PeerConnectionInterface> pc;
     {
-      std::lock_guard<std::mutex> lock(_connectionMutex);
+      const std::scoped_lock lock(_connectionMutex);
       pc = std::move(_jinglePeerConnection);
       if (pc) {
         _closedConnection = pc;
@@ -1251,7 +1302,7 @@ namespace python_webrtc {
 
     if (pc) {
       pc->Close();
-      for (const auto &transceiver: pc->GetTransceivers()) {
+      for (const auto &transceiver : pc->GetTransceivers()) {
         Wrap(_transceivers, transceiver)->GetReceiver()->GetTrack()->OnPeerConnectionClosed();
       }
     }
@@ -1315,7 +1366,7 @@ namespace python_webrtc {
     Emit("signalingstatechange", newState, SnapshotDescriptions());
   }
 
-  void RTCPeerConnection::OnIceConnectionChange(IceConnectionState) {
+  void RTCPeerConnection::OnIceConnectionChange(IceConnectionState /*unused*/) {
     // the legacy state, iceConnectionState is the standardized one
   }
 
@@ -1331,8 +1382,8 @@ namespace python_webrtc {
     Emit("connectionstatechange", newState);
   }
 
-  template<typename... Args>
-  void RTCPeerConnection::EmitGathering(const char *name, Args... args) {
+  template <typename... Args>
+  void RTCPeerConnection::EmitGathering(const char *name, const Args &...args) {
     _heldGathering.Emit([this, name, args...]() { Emit(name, args...); });
   }
 
@@ -1346,12 +1397,12 @@ namespace python_webrtc {
 
     // every transport ends its candidates with an empty one
     auto pc = connection();
-    for (auto &candidate: endOfCandidates(pc ? pc->local_description() : nullptr)) {
+    for (auto &candidate : endOfCandidates(pc ? pc->local_description() : nullptr)) {
       EmitGathering("icecandidate", candidate);
     }
     // then, in a single task, the ICE transports and the connection complete, and the candidates end
     std::vector<std::shared_ptr<RTCIceTransport>> iceTransports;
-    for (const auto &iceTransport: IceTransports()) {
+    for (const auto &iceTransport : IceTransports()) {
       if (iceTransport->IsHeld()) {
         // Python doesn't have it yet: its completion waits along with its other events
         iceTransport->EmitGatheringComplete();
@@ -1364,8 +1415,8 @@ namespace python_webrtc {
 
   void RTCPeerConnection::OnIceCandidate(const webrtc::IceCandidateInterface *candidate) {
     // the candidate is only valid during the call
-    if (candidate) {
-      IceCandidateInit init(*candidate);
+    if (candidate != nullptr) {
+      const IceCandidateInit init(*candidate);
       if (auto iceTransport = IceTransportByMid(candidate->sdp_mid())) {
         iceTransport->AddLocalCandidate(init);
       }
@@ -1378,20 +1429,24 @@ namespace python_webrtc {
     Emit("icecandidateerror", address, port, url, errorCode, errorText);
   }
 
-  // the DTLS transports of the media sections and of the data channels, some of them shared (bundled)
-  static std::vector<webrtc::scoped_refptr<webrtc::DtlsTransportInterface>> dtlsTransports(
-      const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc) {
-    std::vector<webrtc::scoped_refptr<webrtc::DtlsTransportInterface>> transports;
-    for (const auto &transceiver: pc->GetTransceivers()) {
-      transports.push_back(transceiver->sender()->dtls_transport());
-      transports.push_back(transceiver->receiver()->dtls_transport());
-    }
-    if (auto sctp = pc->GetSctpTransport()) {
-      transports.push_back(sctp->dtls_transport());
+  namespace {
+
+    // the DTLS transports of the media sections and of the data channels, some of them shared (bundled)
+    std::vector<webrtc::scoped_refptr<webrtc::DtlsTransportInterface>>
+    dtlsTransports(const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc) {
+      std::vector<webrtc::scoped_refptr<webrtc::DtlsTransportInterface>> transports;
+      for (const auto &transceiver : pc->GetTransceivers()) {
+        transports.push_back(transceiver->sender()->dtls_transport());
+        transports.push_back(transceiver->receiver()->dtls_transport());
+      }
+      if (auto sctp = pc->GetSctpTransport()) {
+        transports.push_back(sctp->dtls_transport());
+      }
+      std::erase(transports, nullptr);
+      return transports;
     }
-    transports.erase(std::remove(transports.begin(), transports.end(), nullptr), transports.end());
-    return transports;
-  }
+
+  } // namespace
 
   std::vector<std::shared_ptr<RTCIceTransport>> RTCPeerConnection::IceTransports() {
     std::vector<std::shared_ptr<RTCIceTransport>> iceTransports;
@@ -1399,10 +1454,10 @@ namespace python_webrtc {
     if (!pc) {
       return iceTransports;
     }
-    for (const auto &transport: dtlsTransports(pc)) {
+    for (const auto &transport : dtlsTransports(pc)) {
       auto dtls = RTCDtlsTransport::holder().Find(transport.get());
       auto ice = dtls ? dtls->GetIceTransport() : nullptr;
-      if (ice && std::find(iceTransports.begin(), iceTransports.end(), ice) == iceTransports.end()) {
+      if (ice && std::ranges::find(iceTransports, ice) == iceTransports.end()) {
         iceTransports.push_back(ice);
       }
     }
@@ -1423,8 +1478,8 @@ namespace python_webrtc {
       return created;
     }
     std::vector<std::shared_ptr<RTCDtlsTransport>> wrappers;
-    for (const auto &transport: dtlsTransports(pc)) {
-      bool existed = RTCDtlsTransport::holder().Find(transport.get()) != nullptr;
+    for (const auto &transport : dtlsTransports(pc)) {
+      const bool existed = RTCDtlsTransport::holder().Find(transport.get()) != nullptr;
       auto wrapper = RTCDtlsTransport::holder().GetOrCreate(_factory, transport);
       if (!existed) {
         // Python doesn't have the transports yet, their events wait for it
@@ -1432,7 +1487,7 @@ namespace python_webrtc {
         wrapper->GetIceTransport()->Hold();
         Adopt(wrapper);
       }
-      if (std::find(wrappers.begin(), wrappers.end(), wrapper) == wrappers.end()) {
+      if (std::ranges::find(wrappers, wrapper) == wrappers.end()) {
         if (!existed) {
           created.push_back(wrapper->GetIceTransport());
         }
@@ -1440,7 +1495,7 @@ namespace python_webrtc {
       }
     }
     {
-      std::lock_guard<std::mutex> lock(_wrappersMutex);
+      const std::scoped_lock lock(_wrappersMutex);
       std::swap(_dtlsTransports, wrappers);
     }
     // wrappers of transports that are gone are released here, out of the lock
@@ -1455,7 +1510,7 @@ namespace python_webrtc {
 
     std::vector<webrtc::scoped_refptr<webrtc::DtlsTransportInterface>> transports;
     webrtc::scoped_refptr<webrtc::SctpTransportInterface> sctpTransport;
-    _factory->_signalingThread->BlockingCall([&]() {
+    _factory->signalingThread()->BlockingCall([&]() {
       transports = dtlsTransports(pc);
       sctpTransport = pc->GetSctpTransport();
     });
@@ -1463,7 +1518,7 @@ namespace python_webrtc {
     if (auto sctp = sctpTransport ? RTCSctpTransport::holder().Find(sctpTransport.get()) : nullptr) {
       sctp->OnPeerConnectionClosed();
     }
-    for (const auto &transport: transports) {
+    for (const auto &transport : transports) {
       if (auto dtls = RTCDtlsTransport::holder().Find(transport.get())) {
         dtls->OnPeerConnectionClosed();
         dtls->GetIceTransport()->OnPeerConnectionClosed();
@@ -1479,7 +1534,7 @@ namespace python_webrtc {
     auto state = pc->signaling_state();
     if (state == SignalingState::kStable || state == SignalingState::kHaveLocalPrAnswer ||
         state == SignalingState::kHaveRemotePrAnswer) {
-      for (const auto &iceTransport: IceTransports()) {
+      for (const auto &iceTransport : IceTransports()) {
         iceTransport->SetRoleKnown();
       }
     }
@@ -1490,10 +1545,10 @@ namespace python_webrtc {
     auto pc = connection();
     if (mid.empty() && pc) {
       // signaled by the index of its media section
-      _factory->_signalingThread->BlockingCall([&]() {
-        auto description = pc->remote_description();
-        auto &contents = description ? description->description()->contents()
-                                     : std::vector<webrtc::ContentInfo>();
+      _factory->signalingThread()->BlockingCall([&]() {
+        const auto *description = pc->remote_description();
+        const auto &contents =
+            description ? description->description()->contents() : std::vector<webrtc::ContentInfo>();
         if (candidate.sdpMLineIndex >= 0 && static_cast<size_t>(candidate.sdpMLineIndex) < contents.size()) {
           mid = contents[candidate.sdpMLineIndex].mid();
         }
@@ -1506,37 +1561,37 @@ namespace python_webrtc {
 
   void RTCPeerConnection::RecordRemoteDescriptionCandidates() {
     auto pc = connection();
-    auto description = pc ? pc->remote_description() : nullptr;
-    if (!description) {
+    const auto *description = pc ? pc->remote_description() : nullptr;
+    if (description == nullptr) {
       return;
     }
     const auto &contents = description->description()->contents();
     for (size_t index = 0; index < contents.size(); ++index) {
       auto iceTransport = IceTransportByMid(contents[index].mid());
-      auto candidates = description->candidates(index);
-      if (!iceTransport || !candidates) {
+      const auto *candidates = description->candidates(index);
+      if (!iceTransport || (candidates == nullptr)) {
         continue;
       }
-      for (const auto &candidate: candidates->candidates()) {
+      for (const auto &candidate : candidates->candidates()) {
         iceTransport->AddRemoteCandidate(IceCandidateInit(*candidate));
       }
     }
   }
 
-  std::optional<std::pair<std::string, std::string>> RTCPeerConnection::IceParameters(
-      const webrtc::IceTransportInterface *iceTransport, bool local) {
+  std::optional<std::pair<std::string, std::string>>
+  RTCPeerConnection::IceParameters(const webrtc::IceTransportInterface *iceTransport, bool local) {
     auto pc = connection();
     if (!pc) {
       return {};
     }
-    return _factory->_signalingThread->BlockingCall([&]() -> std::optional<std::pair<std::string, std::string>> {
-      auto description = local ? pc->local_description() : pc->remote_description();
+    return _factory->signalingThread()->BlockingCall([&]() -> std::optional<std::pair<std::string, std::string>> {
+      const auto *description = local ? pc->local_description() : pc->remote_description();
       if (!description) {
         return std::nullopt;
       }
-      for (const auto &content: description->description()->contents()) {
+      for (const auto &content : description->description()->contents()) {
         auto dtls = pc->LookupDtlsTransportByMid(content.mid());
-        auto info = description->description()->GetTransportInfoByName(content.mid());
+        const auto *info = description->description()->GetTransportInfoByName(content.mid());
         if (dtls && dtls->ice_transport().get() == iceTransport && info) {
           return std::make_pair(info->description.ice_ufrag, info->description.ice_pwd);
         }
@@ -1545,57 +1600,74 @@ namespace python_webrtc {
     });
   }
 
-  void RTCPeerConnection::OnIceSelectedCandidatePairChanged(const webrtc::CandidatePairChangeEvent &) {
+  void RTCPeerConnection::OnIceSelectedCandidatePairChanged(const webrtc::CandidatePairChangeEvent & /*unused*/) {
     // the event doesn't tell which transport changed, the ICE transports that Python has check themselves
-    for (const auto &ice: IceTransports()) {
+    for (const auto &ice : IceTransports()) {
       ice->CheckSelectedCandidatePair();
     }
   }
 
-  void RTCPeerConnection::AddIceCandidate(
-      std::function<void()> &onSuccess, std::function<void(RTCCallbackException)> &onFailure,
-      const std::string &candidate, const std::optional<std::string> &sdpMid, std::optional<int> sdpMLineIndex,
-      const std::optional<std::string> &usernameFragment) {
-    auto pc = connection();
-    if (!pc) {
-      onFailure(RTCCallbackException(closedError("addIceCandidate")));
-      return;
-    }
+  namespace {
 
-    // the media sections the candidate is for (all of them for a null mid and index), and whether its ufrag is known
-    std::optional<RTCCallbackException> error;
-    std::set<std::string> mids;
-    const webrtc::SessionDescriptionInterface *remote = nullptr;
-    _factory->_signalingThread->BlockingCall([&]() {
-      remote = pc->remote_description();
-      if (!remote) {
-        error.emplace(webrtc::RTCErrorType::INVALID_STATE, "The remote description was null");
-        return;
+    // The media sections a candidate is for (all of them for a null mid and index), into mids, and whether its ufrag
+    // is known. On the signaling thread.
+    std::optional<RTCCallbackException> candidateSections(const webrtc::SessionDescriptionInterface *remote,
+                                                          const std::optional<std::string> &sdpMid,
+                                                          std::optional<int> sdpMLineIndex,
+                                                          const std::optional<std::string> &usernameFragment,
+                                                          std::set<std::string> &mids) {
+      if (remote == nullptr) {
+        return RTCCallbackException(webrtc::RTCErrorType::INVALID_STATE, "The remote description was null");
       }
-      auto session = remote->description();
-      auto &contents = session->contents();
+      const auto *session = remote->description();
+      const auto &contents = session->contents();
       for (size_t i = 0; i < contents.size(); ++i) {
-        bool matches = sdpMid ? contents[i].mid() == *sdpMid
-                              : sdpMLineIndex ? static_cast<int>(i) == *sdpMLineIndex : true;
+        bool matches = true;
+        if (sdpMid) {
+          matches = contents[i].mid() == *sdpMid;
+        } else if (sdpMLineIndex) {
+          matches = std::cmp_equal(i, *sdpMLineIndex);
+        }
         if (matches && !contents[i].rejected) {
           mids.insert(contents[i].mid());
         }
       }
       if (mids.empty() && (sdpMid || sdpMLineIndex)) {
-        error.emplace(webrtc::RTCErrorType::UNSUPPORTED_OPERATION, "The media section of the candidate was not found");
-        return;
+        return RTCCallbackException(webrtc::RTCErrorType::UNSUPPORTED_OPERATION,
+                                    "The media section of the candidate was not found");
       }
       if (usernameFragment) {
-        bool known = false;
-        for (const auto &mid: mids) {
-          auto transport = session->GetTransportInfoByName(mid);
-          known = known || (transport && transport->description.ice_ufrag == *usernameFragment);
-        }
+        const bool known = std::ranges::any_of(mids, [&](const std::string &mid) {
+          const auto *transport = session->GetTransportInfoByName(mid);
+          return transport != nullptr && transport->description.ice_ufrag == *usernameFragment;
+        });
         if (!known) {
-          error.emplace(webrtc::RTCErrorType::UNSUPPORTED_OPERATION,
-                        "The usernameFragment doesn't match the remote description");
+          return RTCCallbackException(webrtc::RTCErrorType::UNSUPPORTED_OPERATION,
+                                      "The usernameFragment doesn't match the remote description");
         }
       }
+      return std::nullopt;
+    }
+
+  } // namespace
+
+  void RTCPeerConnection::AddIceCandidate(std::function<void()> &onSuccess,
+                                          std::function<void(RTCCallbackException)> &onFailure,
+                                          const std::string &candidate, const std::optional<std::string> &sdpMid,
+                                          std::optional<int> sdpMLineIndex,
+                                          const std::optional<std::string> &usernameFragment) {
+    auto pc = connection();
+    if (!pc) {
+      onFailure(RTCCallbackException(closedError("addIceCandidate")));
+      return;
+    }
+
+    std::optional<RTCCallbackException> error;
+    std::set<std::string> mids;
+    const webrtc::SessionDescriptionInterface *remote = nullptr;
+    _factory->signalingThread()->BlockingCall([&]() {
+      remote = pc->remote_description();
+      error = candidateSections(remote, sdpMid, sdpMLineIndex, usernameFragment, mids);
     });
     if (error) {
       onFailure(*error);
@@ -1605,7 +1677,7 @@ namespace python_webrtc {
     if (candidate.empty()) {
       // the end of candidates, which libwebrtc doesn't take: the remote description shows it
       {
-        std::lock_guard<std::mutex> lock(_remoteEndOfCandidatesMutex);
+        const std::scoped_lock lock(_remoteEndOfCandidatesMutex);
         if (_remoteEndOfCandidatesDescription != remote) {
           _remoteEndOfCandidates.clear();
           _remoteEndOfCandidatesDescription = remote;
@@ -1618,11 +1690,11 @@ namespace python_webrtc {
     }
 
     webrtc::SdpParseError parseError;
-    auto iceCandidate = webrtc::IceCandidate::Create(
-        sdpMid.value_or(""), sdpMLineIndex.value_or(0), candidate, &parseError);
+    auto iceCandidate =
+        webrtc::IceCandidate::Create(sdpMid.value_or(""), sdpMLineIndex.value_or(0), candidate, &parseError);
     if (!iceCandidate) {
       onFailure(RTCCallbackException(webrtc::RTCErrorType::UNSUPPORTED_OPERATION,
-          "Failed to parse the ICE candidate: " + parseError.description));
+                                     "Failed to parse the ICE candidate: " + parseError.description));
       return;
     }
 
@@ -1666,27 +1738,28 @@ namespace python_webrtc {
     Emit("datachannel", channel);
   }
 
-  void RTCPeerConnection::OnAddStream(webrtc::scoped_refptr<webrtc::MediaStreamInterface>) {}
+  void RTCPeerConnection::OnAddStream(webrtc::scoped_refptr<webrtc::MediaStreamInterface> /*unused*/) {}
 
-  void RTCPeerConnection::OnRemoveStream(webrtc::scoped_refptr<webrtc::MediaStreamInterface>) {}
+  void RTCPeerConnection::OnRemoveStream(webrtc::scoped_refptr<webrtc::MediaStreamInterface> /*unused*/) {}
 
-  void RTCPeerConnection::OnAddTrack(webrtc::scoped_refptr<webrtc::RtpReceiverInterface>,
-                                     const std::vector<webrtc::scoped_refptr<webrtc::MediaStreamInterface>> &) {}
+  void
+  RTCPeerConnection::OnAddTrack(webrtc::scoped_refptr<webrtc::RtpReceiverInterface> /*unused*/,
+                                const std::vector<webrtc::scoped_refptr<webrtc::MediaStreamInterface>> & /*unused*/) {}
 
   void RTCPeerConnection::OnTrack(webrtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
     // a rejected media section (port 0) negotiates no track, but libwebrtc still reports it
     auto pc = connection();
-    auto description = pc ? pc->remote_description() : nullptr;
+    const auto *description = pc ? pc->remote_description() : nullptr;
     auto mid = transceiver->mid();
-    if (description && mid) {
-      auto content = description->description()->GetContentByName(*mid);
-      if (content && content->rejected) {
+    if ((description != nullptr) && mid) {
+      const auto *content = description->description()->GetContentByName(*mid);
+      if ((content != nullptr) && content->rejected) {
         return;
       }
     }
 
     {
-      std::lock_guard<std::mutex> lock(_remoteStreamsMutex);
+      const std::scoped_lock lock(_remoteStreamsMutex);
       _trackFired.insert(transceiver.get());
     }
     EmitTrack(transceiver);
@@ -1703,49 +1776,53 @@ namespace python_webrtc {
     auto wrapper = Wrap(_transceivers, transceiver);
     auto receiver = Wrap(_receivers, transceiver->receiver());
     std::vector<std::shared_ptr<MediaStream>> streams;
-    for (const auto &stream: transceiver->receiver()->streams()) {
+    for (const auto &stream : transceiver->receiver()->streams()) {
       streams.push_back(MediaStream::holder().GetOrCreate(_factory, stream));
     }
     Emit("track", wrapper, receiver, streams);
   }
 
-  static std::vector<std::string> remoteStreamIds(
-      const webrtc::scoped_refptr<webrtc::RtpTransceiverInterface> &transceiver) {
-    std::vector<std::string> ids;
-    for (const auto &stream: transceiver->receiver()->streams()) {
-      ids.push_back(stream->id());
+  namespace {
+
+    std::vector<std::string>
+    remoteStreamIds(const webrtc::scoped_refptr<webrtc::RtpTransceiverInterface> &transceiver) {
+      std::vector<std::string> ids;
+      for (const auto &stream : transceiver->receiver()->streams()) {
+        ids.push_back(stream->id());
+      }
+      return ids;
     }
-    return ids;
-  }
+
+  } // namespace
 
   void RTCPeerConnection::SnapshotRemoteStreams(const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc) {
     std::map<const void *, std::vector<std::string>> before;
-    for (const auto &transceiver: pc->GetTransceivers()) {
+    for (const auto &transceiver : pc->GetTransceivers()) {
       before[transceiver.get()] = remoteStreamIds(transceiver);
     }
-    std::lock_guard<std::mutex> lock(_remoteStreamsMutex);
+    const std::scoped_lock lock(_remoteStreamsMutex);
     _remoteStreamsBefore = std::move(before);
     _trackFired.clear();
   }
 
   void RTCPeerConnection::FireRemoteStreamChanges() {
     auto pc = connection();
-    auto description = pc ? pc->remote_description() : nullptr;
-    if (!description) {
+    const auto *description = pc ? pc->remote_description() : nullptr;
+    if (description == nullptr) {
       return;
     }
     std::map<const void *, std::vector<std::string>> before;
     std::set<const void *> fired;
     {
-      std::lock_guard<std::mutex> lock(_remoteStreamsMutex);
+      const std::scoped_lock lock(_remoteStreamsMutex);
       std::swap(before, _remoteStreamsBefore);
       std::swap(fired, _trackFired);
     }
-    for (const auto &transceiver: pc->GetTransceivers()) {
+    for (const auto &transceiver : pc->GetTransceivers()) {
       auto mid = transceiver->mid();
-      auto content = mid ? description->description()->GetContentByName(*mid) : nullptr;
+      const auto *content = mid ? description->description()->GetContentByName(*mid) : nullptr;
       auto previous = before.find(transceiver.get());
-      if (!content || content->rejected || fired.count(transceiver.get()) || previous == before.end() ||
+      if ((content == nullptr) || content->rejected || fired.contains(transceiver.get()) || previous == before.end() ||
           !webrtc::RtpTransceiverDirectionHasSend(content->media_description()->direction())) {
         continue;
       }
diff --git a/python-webrtc/cpp/src/interfaces/rtc_peer_connection.h b/python-webrtc/cpp/src/interfaces/rtc_peer_connection.h
index 1446fef..9c0b090 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_peer_connection.h
+++ b/python-webrtc/cpp/src/interfaces/rtc_peer_connection.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_RTC_PEER_CONNECTION_H_
+#define PYTHON_WEBRTC_INTERFACES_RTC_PEER_CONNECTION_H_
 
 #include <array>
 #include <atomic>
@@ -23,23 +24,23 @@
 #include <api/peer_connection_interface.h>
 #include <api/scoped_refptr.h>
 
-#include <pybind11/pybind11.h>
 #include <pybind11/functional.h>
+#include <pybind11/pybind11.h>
 
-#include "../utils/alive_count.h"
 #include "../exceptions.h"
 #include "../models/python_webrtc/rtc_configuration.h"
 #include "../models/python_webrtc/rtc_session_description.h"
+#include "../utils/alive_count.h"
 #include "../utils/held_events.h"
 #include "../utils/listeners.h"
 #include "../utils/surfaced.h"
 
-#include "media_stream_track.h"
 #include "media_stream.h"
+#include "media_stream_track.h"
+#include "rtc_data_channel.h"
 #include "rtc_rtp_sender.h"
 #include "rtc_rtp_transceiver.h"
 #include "rtc_sctp_transport.h"
-#include "rtc_data_channel.h"
 
 namespace webrtc {
   struct PeerConnectionDependencies;
@@ -51,58 +52,61 @@ namespace python_webrtc {
 
   // An operation that completes after close() fails, rather than never settling as in a browser, which would
   // leave a Python caller waiting forever.
-  class RTCPeerConnection
-      : public webrtc::PeerConnectionObserver, public Listeners, public std::enable_shared_from_this<RTCPeerConnection> {
+  class RTCPeerConnection : public webrtc::PeerConnectionObserver,
+                            public Listeners,
+                            public std::enable_shared_from_this<RTCPeerConnection> {
   public:
     using SignalingState = webrtc::PeerConnectionInterface::SignalingState;
     using IceConnectionState = webrtc::PeerConnectionInterface::IceConnectionState;
     using IceGatheringState = webrtc::PeerConnectionInterface::IceGatheringState;
     using PeerConnectionState = webrtc::PeerConnectionInterface::PeerConnectionState;
 
-    explicit RTCPeerConnection(const std::optional<ConfigurationInit> &);
+    explicit RTCPeerConnection(const std::optional<ConfigurationInit> &init);
 
     static void Init(pybind11::module &m);
 
     ~RTCPeerConnection() override;
 
+    RTCPeerConnection(const RTCPeerConnection &) = delete;
+    RTCPeerConnection &operator=(const RTCPeerConnection &) = delete;
+
     // A reference taken in a callback of libwebrtc, released on a thread of its own: the connection can't be
     // destroyed on the signaling thread in the middle of its own callback
     static void ReleaseElsewhere(std::shared_ptr<RTCPeerConnection> &&connection);
 
-    void CreateOffer(
-        std::function<void(RTCSessionDescription)> &, std::function<void(RTCCallbackException)> &,
-        bool iceRestart, bool voiceActivityDetection);
+    void CreateOffer(std::function<void(RTCSessionDescription)> &onSuccess,
+                     std::function<void(RTCCallbackException)> &onFailure, bool iceRestart,
+                     bool voiceActivityDetection);
 
-    void CreateAnswer(
-        std::function<void(RTCSessionDescription)> &, std::function<void(RTCCallbackException)> &,
-        bool voiceActivityDetection);
+    void CreateAnswer(std::function<void(RTCSessionDescription)> &onSuccess,
+                      std::function<void(RTCCallbackException)> &onFailure, bool voiceActivityDetection);
 
     // the last description createOffer or createAnswer made, which are the only ones setLocalDescription takes
     void SaveCreatedDescription(const RTCSessionDescriptionInit &description);
 
-    void SetLocalDescription(
-        std::function<void()> &, std::function<void(RTCCallbackException)> &,
-        const std::optional<RTCSessionDescriptionInit> &);
+    void SetLocalDescription(std::function<void()> &onSuccess, std::function<void(RTCCallbackException)> &onFailure,
+                             const std::optional<RTCSessionDescriptionInit> &init);
 
-    void SetRemoteDescription(
-        std::function<void()> &, std::function<void(RTCCallbackException)> &, const RTCSessionDescriptionInit &);
+    void SetRemoteDescription(std::function<void()> &onSuccess, std::function<void(RTCCallbackException)> &onFailure,
+                              const RTCSessionDescriptionInit &init);
 
-    void AddIceCandidate(
-        std::function<void()> &, std::function<void(RTCCallbackException)> &, const std::string &candidate,
-        const std::optional<std::string> &sdpMid, std::optional<int> sdpMLineIndex,
-        const std::optional<std::string> &usernameFragment);
+    void AddIceCandidate(std::function<void()> &onSuccess, std::function<void(RTCCallbackException)> &onFailure,
+                         const std::string &candidate, const std::optional<std::string> &sdpMid,
+                         std::optional<int> sdpMLineIndex, const std::optional<std::string> &usernameFragment);
 
-    std::shared_ptr<RTCRtpSender> AddTrack(MediaStreamTrack &, std::optional<std::reference_wrapper<MediaStream>>);
+    std::shared_ptr<RTCRtpSender> AddTrack(MediaStreamTrack &mediaStreamTrack,
+                                           std::optional<std::reference_wrapper<MediaStream>> mediaStream);
 
-    std::shared_ptr<RTCRtpSender> AddTrack(MediaStreamTrack &, const std::vector<MediaStream *> &);
+    std::shared_ptr<RTCRtpSender> AddTrack(MediaStreamTrack &mediaStreamTrack,
+                                           const std::vector<MediaStream *> &mediaStreams);
 
-    void RemoveTrack(RTCRtpSender &);
+    void RemoveTrack(RTCRtpSender &sender);
 
-    std::shared_ptr<RTCRtpTransceiver> AddTransceiver(
-        webrtc::MediaType, std::optional<std::reference_wrapper<webrtc::RtpTransceiverInit>> &);
+    std::shared_ptr<RTCRtpTransceiver>
+    AddTransceiver(webrtc::MediaType kind, std::optional<std::reference_wrapper<webrtc::RtpTransceiverInit>> &init);
 
-    std::shared_ptr<RTCRtpTransceiver> AddTransceiver(
-        MediaStreamTrack &, std::optional<std::reference_wrapper<webrtc::RtpTransceiverInit>> &);
+    std::shared_ptr<RTCRtpTransceiver>
+    AddTransceiver(MediaStreamTrack &track, std::optional<std::reference_wrapper<webrtc::RtpTransceiverInit>> &init);
 
     std::vector<std::shared_ptr<RTCRtpTransceiver>> GetTransceivers();
 
@@ -110,19 +114,21 @@ namespace python_webrtc {
 
     std::vector<std::shared_ptr<RTCRtpReceiver>> GetReceivers();
 
-    std::shared_ptr<RTCDataChannel> CreateDataChannel(
-        const std::string &label, bool ordered, std::optional<int> maxPacketLifeTime, std::optional<int> maxRetransmits,
-        const std::string &protocol, bool negotiated, std::optional<int> id, webrtc::Priority priority);
+    std::shared_ptr<RTCDataChannel> CreateDataChannel(const std::string &label, bool ordered,
+                                                      std::optional<int> maxPacketLifeTime,
+                                                      std::optional<int> maxRetransmits, const std::string &protocol,
+                                                      bool negotiated, std::optional<int> id,
+                                                      webrtc::Priority priority);
 
     std::optional<std::shared_ptr<RTCSctpTransport>> GetSctp();
 
-    void GetStats(std::function<void(std::string)> &, std::function<void(RTCCallbackException)> &);
+    void GetStats(std::function<void(std::string)> &onSuccess, std::function<void(RTCCallbackException)> &onFailure);
 
     void RestartIce();
 
     ConfigurationInit GetConfiguration();
 
-    void SetConfiguration(const ConfigurationInit &);
+    void SetConfiguration(const ConfigurationInit &init);
 
     void Close();
 
@@ -176,26 +182,28 @@ namespace python_webrtc {
     bool IsClosed();
 
     // the transceiver of a sender, while it's in the connection
-    webrtc::scoped_refptr<webrtc::RtpTransceiverInterface> TransceiverOf(
-        const webrtc::scoped_refptr<webrtc::RtpSenderInterface> &sender);
+    webrtc::scoped_refptr<webrtc::RtpTransceiverInterface>
+    TransceiverOf(const webrtc::scoped_refptr<webrtc::RtpSenderInterface> &sender);
 
     // The negotiated codecs this side can use: libwebrtc reports none for an inactive sender (receiver), and
     // lists remote codecs it doesn't know
-    std::vector<webrtc::RtpCodecParameters> NegotiatedCodecs(
-        const webrtc::scoped_refptr<webrtc::RtpSenderInterface> &sender);
+    std::vector<webrtc::RtpCodecParameters>
+    NegotiatedCodecs(const webrtc::scoped_refptr<webrtc::RtpSenderInterface> &sender);
 
-    std::vector<webrtc::RtpCodecParameters> NegotiatedCodecs(
-        const webrtc::scoped_refptr<webrtc::RtpReceiverInterface> &receiver);
+    std::vector<webrtc::RtpCodecParameters>
+    NegotiatedCodecs(const webrtc::scoped_refptr<webrtc::RtpReceiverInterface> &receiver);
 
     // the header extensions negotiated for a receiver (in the local description)
-    std::vector<webrtc::RtpExtension> NegotiatedHeaderExtensions(
-        const webrtc::scoped_refptr<webrtc::RtpReceiverInterface> &receiver);
+    std::vector<webrtc::RtpExtension>
+    NegotiatedHeaderExtensions(const webrtc::scoped_refptr<webrtc::RtpReceiverInterface> &receiver);
 
     void CollectStats(const webrtc::scoped_refptr<webrtc::RtpSenderInterface> &sender,
-                      std::function<void(std::string)> &, std::function<void(RTCCallbackException)> &);
+                      std::function<void(std::string)> &onSuccess,
+                      std::function<void(RTCCallbackException)> &onFailure);
 
     void CollectStats(const webrtc::scoped_refptr<webrtc::RtpReceiverInterface> &receiver,
-                      std::function<void(std::string)> &, std::function<void(RTCCallbackException)> &);
+                      std::function<void(std::string)> &onSuccess,
+                      std::function<void(RTCCallbackException)> &onFailure);
 
     // PeerConnectionObserver implementation, on the signaling thread.
     void OnSignalingChange(SignalingState newState) override;
@@ -237,7 +245,14 @@ namespace python_webrtc {
     // until it completes, so that they come after it
     class HeldOperationEvents;
 
-    enum class DescriptionKind { kLocal, kRemote, kCurrentLocal, kCurrentRemote, kPendingLocal, kPendingRemote };
+    enum class DescriptionKind : uint8_t {
+      kLocal,
+      kRemote,
+      kCurrentLocal,
+      kCurrentRemote,
+      kPendingLocal,
+      kPendingRemote
+    };
 
     static constexpr size_t kDescriptionKinds = 6;
 
@@ -253,7 +268,7 @@ namespace python_webrtc {
       std::vector<const webrtc::SessionDescriptionInterface *> live;
     };
 
-    template<typename T, typename U>
+    template <typename T, typename U>
     using Wrappers = std::unordered_map<U *, std::shared_ptr<T>>;
 
     // Python threads may call close() concurrently with other methods (the GIL is released)
@@ -264,35 +279,36 @@ namespace python_webrtc {
 
     // The connection to collect the stats of, even closed, with its stats cache cleared: libwebrtc reuses a report
     // for 50 ms, the stats are the current ones. None fails the request.
-    webrtc::scoped_refptr<webrtc::PeerConnectionInterface> StatsConnection(
-        const std::function<void(RTCCallbackException)> &onFailure);
+    webrtc::scoped_refptr<webrtc::PeerConnectionInterface>
+    StatsConnection(const std::function<void(RTCCallbackException)> &onFailure);
 
     // the wrapper of a libwebrtc object of this connection, which the connection keeps while it's open
-    template<typename T, typename U>
-    std::shared_ptr<T> Wrap(Wrappers<T, U> &, webrtc::scoped_refptr<U>);
+    template <typename T, typename U>
+    std::shared_ptr<T> Wrap(Wrappers<T, U> &wrappers, webrtc::scoped_refptr<U> object);
 
     // wrappers of the current objects of this connection; wrappers of the objects that are gone are released
-    template<typename T, typename U>
-    std::vector<std::shared_ptr<T>> Sync(Wrappers<T, U> &, const std::vector<webrtc::scoped_refptr<U>> &);
+    template <typename T, typename U>
+    std::vector<std::shared_ptr<T>> Sync(Wrappers<T, U> &wrappers,
+                                         const std::vector<webrtc::scoped_refptr<U>> &objects);
 
     // wrappers of the objects of a closed connection, which doesn't keep them (see ReleaseWrappers)
-    template<typename T, typename U>
-    std::vector<std::shared_ptr<T>> Unkept(const std::vector<webrtc::scoped_refptr<U>> &);
+    template <typename T, typename U>
+    std::vector<std::shared_ptr<T>> Unkept(const std::vector<webrtc::scoped_refptr<U>> &objects);
 
     void ReleaseWrappers();
 
     // gives a wrapper what it needs from the connection
-    void Adopt(const std::shared_ptr<RTCRtpSender> &);
+    void Adopt(const std::shared_ptr<RTCRtpSender> &sender);
 
-    void Adopt(const std::shared_ptr<RTCRtpReceiver> &);
+    void Adopt(const std::shared_ptr<RTCRtpReceiver> &receiver);
 
-    void Adopt(const std::shared_ptr<RTCRtpTransceiver> &);
+    void Adopt(const std::shared_ptr<RTCRtpTransceiver> &transceiver);
 
-    void Adopt(const std::shared_ptr<RTCDataChannel> &);
+    void Adopt(const std::shared_ptr<RTCDataChannel> &channel);
 
-    void Adopt(const std::shared_ptr<RTCSctpTransport> &);
+    void Adopt(const std::shared_ptr<RTCSctpTransport> &sctp);
 
-    void Adopt(const std::shared_ptr<RTCDtlsTransport> &);
+    void Adopt(const std::shared_ptr<RTCDtlsTransport> &dtls);
 
     // the maxMessageSize of the SCTP transport, from the descriptions until the transport knows it
     std::optional<double> MaxMessageSize();
@@ -300,31 +316,33 @@ namespace python_webrtc {
     // waits for the negotiationneeded event a change may have caused to be emitted
     void QueueNegotiationNeeded();
 
-    std::shared_ptr<RTCRtpTransceiver> AddedTransceiver(
-        webrtc::RTCErrorOr<webrtc::scoped_refptr<webrtc::RtpTransceiverInterface>> result);
+    std::shared_ptr<RTCRtpTransceiver>
+    AddedTransceiver(webrtc::RTCErrorOr<webrtc::scoped_refptr<webrtc::RtpTransceiverInterface>> result);
 
     // A provisional answer, or the final one after it, without SDP: the last answer createAnswer made, or a new one
     // (libwebrtc makes only final answers itself, and offers in have-local-pranswer)
-    void SetImplicitAnswer(
-        const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc, webrtc::SdpType type,
-        std::function<void(webrtc::RTCError)> complete, const std::function<void(RTCCallbackException)> &onFailure);
+    void SetImplicitAnswer(const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc, webrtc::SdpType type,
+                           std::function<void(webrtc::RTCError)> complete,
+                           const std::function<void(RTCCallbackException)> &onFailure);
 
     // What completes setLocalDescription (kLocal) or setRemoteDescription (kRemote); created right before the
     // operation starts, as it holds its events
-    std::function<void(webrtc::RTCError)> Completion(
-        std::function<void()> &onSuccess, std::function<void(RTCCallbackException)> &onFailure,
-        const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc, DescriptionKind kind);
+    std::function<void(webrtc::RTCError)> Completion(std::function<void()> &onSuccess,
+                                                     std::function<void(RTCCallbackException)> &onFailure,
+                                                     const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc,
+                                                     DescriptionKind kind);
 
-    std::shared_ptr<RTCSessionDescription> GetDescription(DescriptionKind);
+    std::shared_ptr<RTCSessionDescription> GetDescription(DescriptionKind kind);
 
     // on the signaling thread
-    DescriptionView ReadDescription(const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &, DescriptionKind);
+    DescriptionView ReadDescription(const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc,
+                                    DescriptionKind kind);
 
     // the wrapper of a description that is set: the same object for as long as it's set, unless its SDP changed
     // meanwhile (refresh), under _descriptionsMutex
-    std::shared_ptr<RTCSessionDescription> FindOrCreateDescription(
-        const DescriptionView &view, const std::vector<const webrtc::SessionDescriptionInterface *> &live,
-        bool refresh);
+    std::shared_ptr<RTCSessionDescription>
+    FindOrCreateDescription(const DescriptionView &view,
+                            const std::vector<const webrtc::SessionDescriptionInterface *> &live, bool refresh);
 
     // The descriptions as an operation or event left them, shown from when Python gets it (see ApplyDescriptions).
     // On the signaling thread.
@@ -352,18 +370,18 @@ namespace python_webrtc {
     void RecordRemoteDescriptionCandidates();
 
     // the username fragment and the password of an ICE transport in the local or the remote description
-    std::optional<std::pair<std::string, std::string>> IceParameters(
-        const webrtc::IceTransportInterface *iceTransport, bool local);
+    std::optional<std::pair<std::string, std::string>> IceParameters(const webrtc::IceTransportInterface *iceTransport,
+                                                                     bool local);
 
     // candidates and gathering state changes wait for the local description that caused them to be set
-    template<typename... Args>
-    void EmitGathering(const char *name, Args... args);
+    template <typename... Args>
+    void EmitGathering(const char *name, const Args &...args);
 
     void EmitTrack(const webrtc::scoped_refptr<webrtc::RtpTransceiverInterface> &transceiver);
 
     // The remote streams of each track before a remote description is set, to fire track events for tracks
     // moved to other streams. On the signaling thread.
-    void SnapshotRemoteStreams(const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &);
+    void SnapshotRemoteStreams(const webrtc::scoped_refptr<webrtc::PeerConnectionInterface> &pc);
 
     void FireRemoteStreamChanges();
 
@@ -426,4 +444,6 @@ namespace python_webrtc {
     Wrappers<RTCDataChannel, webrtc::DataChannelInterface> _channels;
   };
 
-}
+} // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_RTC_PEER_CONNECTION_H_
diff --git a/python-webrtc/cpp/src/interfaces/rtc_rtp_receiver.cpp b/python-webrtc/cpp/src/interfaces/rtc_rtp_receiver.cpp
index 07a9169..0c7b560 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_rtp_receiver.cpp
+++ b/python-webrtc/cpp/src/interfaces/rtc_rtp_receiver.cpp
@@ -13,31 +13,31 @@
 #include <pybind11/functional.h>
 #include <pybind11/stl.h>
 
-#include "rtc_peer_connection.h"
 #include "../enums/enums.h"
 #include "../utils/gil.h"
 #include "../utils/libwebrtc_thread.h"
+#include "rtc_peer_connection.h"
 
 namespace python_webrtc {
 
-  RTCRtpReceiver::RTCRtpReceiver(
-      std::shared_ptr<PeerConnectionFactory> factory, webrtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver
-  ) : _factory(std::move(factory)), _receiver(std::move(receiver)),
-      _track(MediaStreamTrack::holder().GetOrCreate(_factory, _receiver->track())) {
+  RTCRtpReceiver::RTCRtpReceiver(std::shared_ptr<PeerConnectionFactory> factory,
+                                 webrtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver)
+      : _factory(std::move(factory)), _receiver(std::move(receiver)),
+        _track(MediaStreamTrack::holder().GetOrCreate(_factory, _receiver->track())) {
     // the track of a receiver is a remote one
     _track->MarkRemote();
     // see AliveGuard
-    _factory->_signalingThread->PostTask(_alive.Guard([this]() {
+    _factory->signalingThread()->PostTask(_alive.Guard([this]() {
       _receiver->SetObserver(this);
       holder().SetObserver(_receiver.get(), this);
     }));
   }
 
   RTCRtpReceiver::~RTCRtpReceiver() {
-    BlockingDestructor release("RTCRtpReceiver");
+    const BlockingDestructor release("RTCRtpReceiver");
 
     // callbacks run on the signaling thread, so after this none of them can be running or start again
-    _factory->_signalingThread->BlockingCall([this]() {
+    _factory->signalingThread()->BlockingCall([this]() {
       // a newer wrapper of the receiver may have taken its single observer slot
       if (holder().TakeObserver(_receiver.get(), this)) {
         _receiver->SetObserver(nullptr);
@@ -45,7 +45,7 @@ namespace python_webrtc {
     });
   }
 
-  void RTCRtpReceiver::OnFirstPacketReceived(webrtc::MediaType) {
+  void RTCRtpReceiver::OnFirstPacketReceived(webrtc::MediaType /*mediaType*/) {
     _track->SetMuted(false);
   }
 
@@ -60,24 +60,25 @@ namespace python_webrtc {
         .def_property("jitterBufferTarget", nogil_fn(&RTCRtpReceiver::GetJitterBufferTarget),
                       nogil_fn(&RTCRtpReceiver::SetJitterBufferTarget))
         .def("getParameters", &RTCRtpReceiver::GetParameters, nogil())
-        .def("getStats", WithCallbacks(&RTCRtpReceiver::GetStats), pybind11::arg("onSuccess"), pybind11::arg("onFailure"))
+        .def("getStats", WithCallbacks(&RTCRtpReceiver::GetStats), pybind11::arg("onSuccess"),
+             pybind11::arg("onFailure"))
         .def_static("getCapabilities", &RTCRtpReceiver::GetCapabilities, nogil(), pybind11::arg("kind"))
         .def("_getSources", &RTCRtpReceiver::GetSources, nogil());
   }
 
   InstanceHolder<RTCRtpReceiver, webrtc::RtpReceiverInterface> &RTCRtpReceiver::holder() {
     // never destroyed: wrappers may outlive static destructors
-    static auto holder = new InstanceHolder<RTCRtpReceiver, webrtc::RtpReceiverInterface>();
+    static auto *holder = new InstanceHolder<RTCRtpReceiver, webrtc::RtpReceiverInterface>();
     return *holder;
   }
 
   void RTCRtpReceiver::SetConnection(std::weak_ptr<RTCPeerConnection> connection) {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     _connection = std::move(connection);
   }
 
   std::shared_ptr<RTCPeerConnection> RTCRtpReceiver::GetConnection() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     return _connection.lock();
   }
 
@@ -91,7 +92,7 @@ namespace python_webrtc {
     auto wrapper = RTCDtlsTransport::holder().GetOrCreate(_factory, transport);
 
     std::shared_ptr<RTCDtlsTransport> previous;
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     if (!_transport || _transport->transport() != transport) {
       previous = std::move(_transport);
       _transport = std::move(wrapper);
@@ -119,16 +120,18 @@ namespace python_webrtc {
   }
 
   std::optional<double> RTCRtpReceiver::GetJitterBufferTarget() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     return _jitterBufferTarget;
   }
 
   void RTCRtpReceiver::SetJitterBufferTarget(std::optional<double> target) {
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       _jitterBufferTarget = target;
     }
-    _receiver->SetJitterBufferMinimumDelay(target ? std::optional<double>(*target / 1000) : std::nullopt);
+    // milliseconds in Python, seconds in libwebrtc
+    constexpr double msPerSecond = 1000;
+    _receiver->SetJitterBufferMinimumDelay(target ? std::optional<double>(*target / msPerSecond) : std::nullopt);
   }
 
   void RTCRtpReceiver::GetStats(std::function<void(std::string)> &onSuccess,
@@ -145,7 +148,7 @@ namespace python_webrtc {
     std::vector<Source> sources;
     // libwebrtc times the packets with its monotonic clock
     auto offset = static_cast<double>(webrtc::TimeUTCMillis() - webrtc::TimeMillis());
-    for (const auto &source: _receiver->GetSources()) {
+    for (const auto &source : _receiver->GetSources()) {
       auto level = source.audio_level();
       sources.emplace_back(source.source_type() == webrtc::RtpSourceType::SSRC, source.source_id(),
                            static_cast<double>(source.timestamp().ms()) + offset, source.rtp_timestamp(),
diff --git a/python-webrtc/cpp/src/interfaces/rtc_rtp_receiver.h b/python-webrtc/cpp/src/interfaces/rtc_rtp_receiver.h
index 63fa1ff..93c7f71 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_rtp_receiver.h
+++ b/python-webrtc/cpp/src/interfaces/rtc_rtp_receiver.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_RTC_RTP_RECEIVER_H_
+#define PYTHON_WEBRTC_INTERFACES_RTC_RTP_RECEIVER_H_
 
 #include <functional>
 #include <memory>
@@ -18,11 +19,11 @@
 #include <api/rtp_receiver_interface.h>
 #include <api/scoped_refptr.h>
 
-#include "peer_connection_factory.h"
-#include "media_stream_track.h"
-#include "rtc_dtls_transport.h"
 #include "../exceptions.h"
 #include "../utils/alive_guard.h"
+#include "media_stream_track.h"
+#include "peer_connection_factory.h"
+#include "rtc_dtls_transport.h"
 
 namespace python_webrtc {
 
@@ -34,10 +35,14 @@ namespace python_webrtc {
     // audio level in -dBov)
     using Source = std::tuple<bool, uint32_t, double, uint32_t, std::optional<int>>;
 
-    explicit RTCRtpReceiver(std::shared_ptr<PeerConnectionFactory>, webrtc::scoped_refptr<webrtc::RtpReceiverInterface>);
+    explicit RTCRtpReceiver(std::shared_ptr<PeerConnectionFactory> factory,
+                            webrtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver);
 
     ~RTCRtpReceiver() override;
 
+    RTCRtpReceiver(const RTCRtpReceiver &) = delete;
+    RTCRtpReceiver &operator=(const RTCRtpReceiver &) = delete;
+
     static void Init(pybind11::module &m);
 
     static InstanceHolder<RTCRtpReceiver, webrtc::RtpReceiverInterface> &holder();
@@ -45,9 +50,9 @@ namespace python_webrtc {
     webrtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver() { return _receiver; }
 
     // RtpReceiverObserverInterface: media arrived, which unmutes the track
-    void OnFirstPacketReceived(webrtc::MediaType) override;
+    void OnFirstPacketReceived(webrtc::MediaType mediaType) override;
 
-    void OnFirstPacketReceivedAfterReceptiveChange(webrtc::MediaType) override;
+    void OnFirstPacketReceivedAfterReceptiveChange(webrtc::MediaType mediaType) override;
 
     // the connection of the receiver, which knows what was negotiated for it; set by the connection
     void SetConnection(std::weak_ptr<RTCPeerConnection> connection);
@@ -63,7 +68,7 @@ namespace python_webrtc {
 
     void SetJitterBufferTarget(std::optional<double> target);
 
-    void GetStats(std::function<void(std::string)> &, std::function<void(RTCCallbackException)> &);
+    void GetStats(std::function<void(std::string)> &onSuccess, std::function<void(RTCCallbackException)> &onFailure);
 
     // the sources of the packets of the last 10 seconds, the most recent first
     std::vector<Source> GetSources();
@@ -89,3 +94,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_RTC_RTP_RECEIVER_H_
diff --git a/python-webrtc/cpp/src/interfaces/rtc_rtp_sender.cpp b/python-webrtc/cpp/src/interfaces/rtc_rtp_sender.cpp
index 4d68c08..709a8f0 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_rtp_sender.cpp
+++ b/python-webrtc/cpp/src/interfaces/rtc_rtp_sender.cpp
@@ -11,14 +11,14 @@
 #include <pybind11/functional.h>
 #include <pybind11/stl.h>
 
-#include "rtc_peer_connection.h"
 #include "../enums/enums.h"
 #include "../utils/gil.h"
+#include "rtc_peer_connection.h"
 
 namespace python_webrtc {
 
-  RTCRtpSender::RTCRtpSender(
-      std::shared_ptr<PeerConnectionFactory> factory, webrtc::scoped_refptr<webrtc::RtpSenderInterface> sender)
+  RTCRtpSender::RTCRtpSender(std::shared_ptr<PeerConnectionFactory> factory,
+                             webrtc::scoped_refptr<webrtc::RtpSenderInterface> sender)
       : _factory(std::move(factory)), _sender(std::move(sender)) {}
 
   void RTCRtpSender::Init(pybind11::module &m) {
@@ -28,8 +28,8 @@ namespace python_webrtc {
         .def_property_readonly("kind", nogil_fn(&RTCRtpSender::GetKind))
         .def_property_readonly("dtmf", nogil_fn(&RTCRtpSender::GetDtmf))
         .def("getParameters", &RTCRtpSender::GetParameters, nogil())
-        .def("setParameters", WithCallbacks(&RTCRtpSender::SetParameters),
-             pybind11::arg("onSuccess"), pybind11::arg("onFailure"), pybind11::arg("parameters"))
+        .def("setParameters", WithCallbacks(&RTCRtpSender::SetParameters), pybind11::arg("onSuccess"),
+             pybind11::arg("onFailure"), pybind11::arg("parameters"))
         .def("replaceTrack", &RTCRtpSender::ReplaceTrack, nogil(), pybind11::arg("track"))
         .def("setStreams", &RTCRtpSender::SetStreams, nogil(), pybind11::arg("streamIds"))
         .def("getStreamIds", &RTCRtpSender::GetStreamIds, nogil())
@@ -43,12 +43,12 @@ namespace python_webrtc {
 
   InstanceHolder<RTCRtpSender, webrtc::RtpSenderInterface> &RTCRtpSender::holder() {
     // never destroyed: wrappers may outlive static destructors
-    static auto holder = new InstanceHolder<RTCRtpSender, webrtc::RtpSenderInterface>();
+    static auto *holder = new InstanceHolder<RTCRtpSender, webrtc::RtpSenderInterface>();
     return *holder;
   }
 
   void RTCRtpSender::SetConnection(std::weak_ptr<RTCPeerConnection> connection) {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     _connection = std::move(connection);
     if (_dtmf) {
       _dtmf->SetTransceiver(TransceiverGetter());
@@ -56,7 +56,7 @@ namespace python_webrtc {
   }
 
   std::shared_ptr<RTCPeerConnection> RTCRtpSender::GetConnection() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     return _connection.lock();
   }
 
@@ -73,7 +73,7 @@ namespace python_webrtc {
     auto wrapper = MediaStreamTrack::holder().GetOrCreate(_factory, track);
 
     std::shared_ptr<MediaStreamTrack> previous;
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     if (!_track || _track->track() != track) {
       previous = std::move(_track);
       _track = std::move(wrapper);
@@ -91,7 +91,7 @@ namespace python_webrtc {
     auto wrapper = RTCDtlsTransport::holder().GetOrCreate(_factory, transport);
 
     std::shared_ptr<RTCDtlsTransport> previous;
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     if (!_transport || _transport->transport() != transport) {
       previous = std::move(_transport);
       _transport = std::move(wrapper);
@@ -111,7 +111,7 @@ namespace python_webrtc {
     auto dtmf = _sender->GetDtmfSender();
     // see GetTrack
     auto wrapper = RTCDTMFSender::holder().GetOrCreate(_factory, dtmf);
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     if (wrapper && _dtmf != wrapper) {
       _dtmf = std::move(wrapper);
       _dtmf->SetTransceiver(TransceiverGetter());
@@ -122,7 +122,7 @@ namespace python_webrtc {
   webrtc::RtpParameters RTCRtpSender::GetParameters() {
     {
       // the same parameters until they expire
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       if (_lastParameters) {
         return *_lastParameters;
       }
@@ -135,18 +135,18 @@ namespace python_webrtc {
     if (!negotiated.empty()) {
       parameters.codecs = std::move(negotiated);
     }
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     _lastParameters = parameters;
     return parameters;
   }
 
   std::optional<webrtc::RtpParameters> RTCRtpSender::GetLastParameters() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     return _lastParameters;
   }
 
   void RTCRtpSender::ExpireParameters(const std::optional<std::string> &transactionId) {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     if (_lastParameters && (!transactionId || _lastParameters->transaction_id == *transactionId)) {
       _lastParameters.reset();
     }
@@ -156,15 +156,15 @@ namespace python_webrtc {
                                    std::function<void(RTCCallbackException)> &onFailure,
                                    const webrtc::RtpParameters &parameters) {
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       if (!_lastParameters) {
         onFailure(RTCCallbackException(webrtc::RTCErrorType::INVALID_STATE,
-            "getParameters() must be called before setParameters(), in the same task"));
+                                       "getParameters() must be called before setParameters(), in the same task"));
         return;
       }
       if (_lastParameters->transaction_id != parameters.transaction_id) {
         onFailure(RTCCallbackException(webrtc::RTCErrorType::INVALID_MODIFICATION,
-            "The transactionId doesn't match the one of the last getParameters()"));
+                                       "The transactionId doesn't match the one of the last getParameters()"));
         return;
       }
     }
@@ -177,7 +177,7 @@ namespace python_webrtc {
     }
     if (!sameLayers) {
       onFailure(RTCCallbackException(webrtc::RTCErrorType::INVALID_MODIFICATION,
-          "The encodings of the sender changed since getParameters()"));
+                                     "The encodings of the sender changed since getParameters()"));
       return;
     }
     auto current = parameters;
diff --git a/python-webrtc/cpp/src/interfaces/rtc_rtp_sender.h b/python-webrtc/cpp/src/interfaces/rtc_rtp_sender.h
index 2824f62..92357d6 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_rtp_sender.h
+++ b/python-webrtc/cpp/src/interfaces/rtc_rtp_sender.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_RTC_RTP_SENDER_H_
+#define PYTHON_WEBRTC_INTERFACES_RTC_RTP_SENDER_H_
 
 #include <functional>
 #include <memory>
@@ -17,12 +18,12 @@
 #include <api/rtp_sender_interface.h>
 #include <api/scoped_refptr.h>
 
-#include "peer_connection_factory.h"
+#include "../enums/enums.h"
+#include "../exceptions.h"
 #include "media_stream_track.h"
+#include "peer_connection_factory.h"
 #include "rtc_dtls_transport.h"
 #include "rtc_dtmf_sender.h"
-#include "../exceptions.h"
-#include "../enums/enums.h"
 
 namespace python_webrtc {
 
@@ -30,7 +31,8 @@ namespace python_webrtc {
 
   class RTCRtpSender {
   public:
-    explicit RTCRtpSender(std::shared_ptr<PeerConnectionFactory>, webrtc::scoped_refptr<webrtc::RtpSenderInterface>);
+    explicit RTCRtpSender(std::shared_ptr<PeerConnectionFactory> factory,
+                          webrtc::scoped_refptr<webrtc::RtpSenderInterface> sender);
 
     static void Init(pybind11::module &m);
 
@@ -55,8 +57,8 @@ namespace python_webrtc {
 
     webrtc::RtpParameters GetParameters();
 
-    void SetParameters(std::function<void()> &, std::function<void(RTCCallbackException)> &,
-                       const webrtc::RtpParameters &);
+    void SetParameters(std::function<void()> &onSuccess, std::function<void(RTCCallbackException)> &onFailure,
+                       const webrtc::RtpParameters &parameters);
 
     // The parameters getParameters returned last, which setParameters takes until they expire (Python expires them
     // once the task that got them ends, as the specification requires)
@@ -72,7 +74,7 @@ namespace python_webrtc {
 
     std::vector<std::string> GetStreamIds();
 
-    void GetStats(std::function<void(std::string)> &, std::function<void(RTCCallbackException)> &);
+    void GetStats(std::function<void(std::string)> &onSuccess, std::function<void(RTCCallbackException)> &onFailure);
 
     // whether its transceiver is stopping or stopped (or gone), where the sender can't be changed anymore
     bool IsTransceiverStopped();
@@ -96,3 +98,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_RTC_RTP_SENDER_H_
diff --git a/python-webrtc/cpp/src/interfaces/rtc_rtp_transceiver.cpp b/python-webrtc/cpp/src/interfaces/rtc_rtp_transceiver.cpp
index d295b69..e85c736 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_rtp_transceiver.cpp
+++ b/python-webrtc/cpp/src/interfaces/rtc_rtp_transceiver.cpp
@@ -7,9 +7,9 @@
 
 #include "rtc_rtp_transceiver.h"
 
-#include "rtc_peer_connection.h"
 #include "../exceptions.h"
 #include "../utils/gil.h"
+#include "rtc_peer_connection.h"
 
 namespace python_webrtc {
 
@@ -28,7 +28,8 @@ namespace python_webrtc {
         .def_property_readonly("stopped", nogil_fn(&RTCRtpTransceiver::GetStopped))
         .def_property_readonly("stopping", nogil_fn(&RTCRtpTransceiver::GetStopping))
         .def_property_readonly("kind", nogil_fn(&RTCRtpTransceiver::GetKind))
-        .def_property("direction", nogil_fn(&RTCRtpTransceiver::GetDirection), nogil_fn(&RTCRtpTransceiver::SetDirection))
+        .def_property("direction", nogil_fn(&RTCRtpTransceiver::GetDirection),
+                      nogil_fn(&RTCRtpTransceiver::SetDirection))
         .def_property_readonly("currentDirection", nogil_fn(&RTCRtpTransceiver::GetCurrentDirection))
         .def("setCodecPreferences", &RTCRtpTransceiver::SetCodecPreferences, nogil(), pybind11::arg("codecs"))
         .def("getCodecPreferences", &RTCRtpTransceiver::GetCodecPreferences, nogil())
@@ -41,21 +42,17 @@ namespace python_webrtc {
 
   InstanceHolder<RTCRtpTransceiver, webrtc::RtpTransceiverInterface> &RTCRtpTransceiver::holder() {
     // never destroyed: wrappers may outlive static destructors
-    static auto holder = new InstanceHolder<RTCRtpTransceiver, webrtc::RtpTransceiverInterface>();
+    static auto *holder = new InstanceHolder<RTCRtpTransceiver, webrtc::RtpTransceiverInterface>();
     return *holder;
   }
 
   void RTCRtpTransceiver::SetConnection(std::weak_ptr<RTCPeerConnection> connection) {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     _connection = std::move(connection);
   }
 
   std::optional<std::string> RTCRtpTransceiver::GetMid() {
-    if (_transceiver->mid()) {
-      return _transceiver->mid().value();
-    }
-
-    return {};
+    return _transceiver->mid();
   }
 
   std::shared_ptr<RTCRtpSender> RTCRtpTransceiver::GetSender() {
@@ -90,17 +87,13 @@ namespace python_webrtc {
   }
 
   std::optional<webrtc::RtpTransceiverDirection> RTCRtpTransceiver::GetCurrentDirection() {
-    if (_transceiver->current_direction()) {
-      return _transceiver->current_direction().value();
-    }
-
-    return {};
+    return _transceiver->current_direction();
   }
 
   void RTCRtpTransceiver::Stop() {
     std::shared_ptr<RTCPeerConnection> connection;
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       connection = _connection.lock();
     }
     if (!connection || connection->IsClosed()) {
diff --git a/python-webrtc/cpp/src/interfaces/rtc_rtp_transceiver.h b/python-webrtc/cpp/src/interfaces/rtc_rtp_transceiver.h
index 1edffd0..be3c779 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_rtp_transceiver.h
+++ b/python-webrtc/cpp/src/interfaces/rtc_rtp_transceiver.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_RTC_RTP_TRANSCEIVER_H_
+#define PYTHON_WEBRTC_INTERFACES_RTC_RTP_TRANSCEIVER_H_
 
 #include <memory>
 #include <mutex>
@@ -18,10 +19,10 @@
 
 #include <pybind11/pybind11.h>
 
+#include "../enums/enums.h"
 #include "peer_connection_factory.h"
 #include "rtc_rtp_receiver.h"
 #include "rtc_rtp_sender.h"
-#include "../enums/enums.h"
 
 namespace python_webrtc {
 
@@ -29,7 +30,8 @@ namespace python_webrtc {
 
   class RTCRtpTransceiver {
   public:
-    RTCRtpTransceiver(std::shared_ptr<PeerConnectionFactory>, webrtc::scoped_refptr<webrtc::RtpTransceiverInterface>);
+    RTCRtpTransceiver(std::shared_ptr<PeerConnectionFactory> factory,
+                      webrtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver);
 
     static void Init(pybind11::module &m);
 
@@ -52,7 +54,7 @@ namespace python_webrtc {
 
     webrtc::RtpTransceiverDirection GetDirection();
 
-    void SetDirection(webrtc::RtpTransceiverDirection);
+    void SetDirection(webrtc::RtpTransceiverDirection direction);
 
     std::optional<webrtc::RtpTransceiverDirection> GetCurrentDirection();
 
@@ -82,3 +84,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_RTC_RTP_TRANSCEIVER_H_
diff --git a/python-webrtc/cpp/src/interfaces/rtc_sctp_transport.cpp b/python-webrtc/cpp/src/interfaces/rtc_sctp_transport.cpp
index c445ec0..25f813c 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_sctp_transport.cpp
+++ b/python-webrtc/cpp/src/interfaces/rtc_sctp_transport.cpp
@@ -11,11 +11,11 @@
 
 namespace python_webrtc {
 
-  RTCSctpTransport::RTCSctpTransport(
-      std::shared_ptr<PeerConnectionFactory> factory, webrtc::scoped_refptr<webrtc::SctpTransportInterface> transport
-  ) : _factory(std::move(factory)), _transport(std::move(transport)) {
+  RTCSctpTransport::RTCSctpTransport(std::shared_ptr<PeerConnectionFactory> factory,
+                                     webrtc::scoped_refptr<webrtc::SctpTransportInterface> transport)
+      : _factory(std::move(factory)), _transport(std::move(transport)) {
     webrtc::scoped_refptr<webrtc::DtlsTransportInterface> dtlsTransport;
-    _factory->_workerThread->BlockingCall([this, &dtlsTransport]() {
+    _factory->workerThread()->BlockingCall([this, &dtlsTransport]() {
       dtlsTransport = _transport->dtls_transport();
       _transport->RegisterObserver(this);
       holder().SetObserver(_transport.get(), this);
@@ -31,10 +31,10 @@ namespace python_webrtc {
   }
 
   RTCSctpTransport::~RTCSctpTransport() {
-    BlockingDestructor release("RTCSctpTransport");
+    const BlockingDestructor release("RTCSctpTransport");
 
     // callbacks run on the network thread, so after this none of them can be running or start again
-    _factory->_workerThread->BlockingCall([this]() { Stop(); });
+    _factory->workerThread()->BlockingCall([this]() { Stop(); });
 
     _dtlsTransport = nullptr;
     _transport = nullptr;
@@ -52,7 +52,7 @@ namespace python_webrtc {
 
   InstanceHolder<RTCSctpTransport, webrtc::SctpTransportInterface> &RTCSctpTransport::holder() {
     // never destroyed: wrappers may outlive static destructors
-    static auto holder = new InstanceHolder<RTCSctpTransport, webrtc::SctpTransportInterface>();
+    static auto *holder = new InstanceHolder<RTCSctpTransport, webrtc::SctpTransportInterface>();
     return *holder;
   }
 
@@ -87,7 +87,7 @@ namespace python_webrtc {
 
   webrtc::SctpTransportInformation RTCSctpTransport::Information() {
     // the information is owned by the network thread
-    return _factory->_workerThread->BlockingCall([this]() { return _transport->Information(); });
+    return _factory->workerThread()->BlockingCall([this]() { return _transport->Information(); });
   }
 
   webrtc::SctpTransportState RTCSctpTransport::GetState() {
diff --git a/python-webrtc/cpp/src/interfaces/rtc_sctp_transport.h b/python-webrtc/cpp/src/interfaces/rtc_sctp_transport.h
index d24fbc6..3779c6b 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_sctp_transport.h
+++ b/python-webrtc/cpp/src/interfaces/rtc_sctp_transport.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_RTC_SCTP_TRANSPORT_H_
+#define PYTHON_WEBRTC_INTERFACES_RTC_SCTP_TRANSPORT_H_
 
 #include <functional>
 #include <memory>
@@ -13,27 +14,31 @@
 
 #include <api/sctp_transport_interface.h>
 
-#include "rtc_dtls_transport.h"
+#include "../enums/enums.h"
 #include "../utils/listeners.h"
 #include "../utils/locked_function.h"
 #include "../utils/surfaced.h"
-#include "../enums/enums.h"
+#include "rtc_dtls_transport.h"
 
 namespace python_webrtc {
 
   class RTCSctpTransport : public webrtc::SctpTransportObserverInterface, public Listeners, public SingleObserverSlot {
   public:
-    explicit RTCSctpTransport(std::shared_ptr<PeerConnectionFactory>, webrtc::scoped_refptr<webrtc::SctpTransportInterface>);
+    explicit RTCSctpTransport(std::shared_ptr<PeerConnectionFactory> factory,
+                              webrtc::scoped_refptr<webrtc::SctpTransportInterface> transport);
 
     ~RTCSctpTransport() override;
 
+    RTCSctpTransport(const RTCSctpTransport &) = delete;
+    RTCSctpTransport &operator=(const RTCSctpTransport &) = delete;
+
     static void Init(pybind11::module &m);
 
     static InstanceHolder<RTCSctpTransport, webrtc::SctpTransportInterface> &holder();
 
     webrtc::scoped_refptr<webrtc::SctpTransportInterface> transport() { return _transport; }
 
-    void OnStateChange(webrtc::SctpTransportInformation) override;
+    void OnStateChange(webrtc::SctpTransportInformation info) override;
 
     // a closed connection fires no events of its transports, which show their current state
     void OnPeerConnectionClosed();
@@ -72,3 +77,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_RTC_SCTP_TRANSPORT_H_
diff --git a/python-webrtc/cpp/src/interfaces/rtc_video_track_source.cpp b/python-webrtc/cpp/src/interfaces/rtc_video_track_source.cpp
index f69506b..960c2f4 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_video_track_source.cpp
+++ b/python-webrtc/cpp/src/interfaces/rtc_video_track_source.cpp
@@ -21,7 +21,7 @@ namespace python_webrtc {
 
   RTCVideoTrackSource::~RTCVideoTrackSource() {
     if (_control) {
-      std::lock_guard<std::mutex> lock(_control->mutex);
+      const std::scoped_lock lock(_control->mutex);
       _control->camera = nullptr;
     }
   }
@@ -31,8 +31,9 @@ namespace python_webrtc {
       _control = std::make_shared<SourceControl>();
       _control->camera = this;
     }
-    auto interval = std::chrono::microseconds(static_cast<int64_t>(1000000 / frameRate));
-    std::lock_guard<std::mutex> lock(_cameraMutex);
+    constexpr double usPerSecond = 1e6;
+    auto interval = std::chrono::microseconds(static_cast<int64_t>(usPerSecond / frameRate));
+    const std::scoped_lock lock(_cameraMutex);
     // the previous camera stops first: one thread draws at a time
     _camera = nullptr;
     _cameraWidth = width;
@@ -40,13 +41,12 @@ namespace python_webrtc {
     _cameraFrameRate = frameRate;
     _camera = std::make_unique<PacedThread>();
     // the thread never holds a reference to the source, so the source isn't destroyed on it
-    _camera->Start(interval, [this, width, height, frame = uint32_t(0)]() mutable {
-      DrawFrame(width, height, frame++);
-    });
+    _camera->Start(interval,
+                   [this, width, height, frame = uint32_t{0}]() mutable { DrawFrame(width, height, frame++); });
   }
 
   bool RTCVideoTrackSource::IsCamera(int *width, int *height, double *frameRate) {
-    std::lock_guard<std::mutex> lock(_cameraMutex);
+    const std::scoped_lock lock(_cameraMutex);
     if (!_camera) {
       return false;
     }
@@ -60,23 +60,30 @@ namespace python_webrtc {
     // a gradient moving across the frame, with a moving block, so that encoders have work to do
     auto buffer = webrtc::I420Buffer::Create(width, height);
     for (int y = 0; y < height; ++y) {
-      auto row = buffer->MutableDataY() + y * buffer->StrideY();
+      auto *row = buffer->MutableDataY() + (static_cast<std::ptrdiff_t>(y) * buffer->StrideY());
       for (int x = 0; x < width; ++x) {
-        row[x] = static_cast<uint8_t>(x + y + frame * 4);
+        row[x] = static_cast<uint8_t>(x + y + (frame * 4));
       }
     }
-    std::memset(buffer->MutableDataU(), static_cast<int>(64 + frame % 128), buffer->StrideU() * ((height + 1) / 2));
-    std::memset(buffer->MutableDataV(), static_cast<int>(192 - frame % 128), buffer->StrideV() * ((height + 1) / 2));
-    int block = std::min(width, height) / 4;
-    int left = static_cast<int>((frame * 8) % std::max(1, width - block));
+    // the colors drift through a range of the chroma planes, the block is white
+    constexpr uint32_t chromaRange = 128;
+    constexpr int uBase = 64;
+    constexpr int vBase = 192;
+    constexpr int white = 255;
+    constexpr uint32_t blockSpeed = 8;
+    std::memset(buffer->MutableDataU(), static_cast<int>(uBase + (frame % chromaRange)),
+                static_cast<size_t>(buffer->StrideU()) * ((height + 1) / 2));
+    std::memset(buffer->MutableDataV(), static_cast<int>(vBase - (frame % chromaRange)),
+                static_cast<size_t>(buffer->StrideV()) * ((height + 1) / 2));
+    const int block = std::min(width, height) / 4;
+    const int left = static_cast<int>((frame * blockSpeed) % std::max(1, width - block));
     for (int y = 0; y < block; ++y) {
-      std::memset(buffer->MutableDataY() + (height / 3 + y) * buffer->StrideY() + left, 255, block);
+      std::memset(buffer->MutableDataY() + (static_cast<std::ptrdiff_t>((height / 3) + y) * buffer->StrideY()) + left,
+                  white, block);
     }
 
-    PushFrame(webrtc::VideoFrame::Builder()
-                  .set_video_frame_buffer(buffer)
-                  .set_timestamp_us(webrtc::TimeMicros())
-                  .build());
+    PushFrame(
+        webrtc::VideoFrame::Builder().set_video_frame_buffer(buffer).set_timestamp_us(webrtc::TimeMicros()).build());
   }
 
   void RTCVideoTrackSource::PushFrame(const webrtc::VideoFrame &frame) {
diff --git a/python-webrtc/cpp/src/interfaces/rtc_video_track_source.h b/python-webrtc/cpp/src/interfaces/rtc_video_track_source.h
index 2546abd..8ff970a 100644
--- a/python-webrtc/cpp/src/interfaces/rtc_video_track_source.h
+++ b/python-webrtc/cpp/src/interfaces/rtc_video_track_source.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_RTC_VIDEO_TRACK_SOURCE_H_
+#define PYTHON_WEBRTC_INTERFACES_RTC_VIDEO_TRACK_SOURCE_H_
 
 #include <atomic>
 #include <cstdint>
@@ -31,6 +32,9 @@ namespace python_webrtc {
 
     ~RTCVideoTrackSource() override;
 
+    RTCVideoTrackSource(const RTCVideoTrackSource &) = delete;
+    RTCVideoTrackSource &operator=(const RTCVideoTrackSource &) = delete;
+
     // Starts the synthetic camera, or restarts it with another size and frame rate
     void StartCamera(int width, int height, double frameRate);
 
@@ -89,3 +93,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_RTC_VIDEO_TRACK_SOURCE_H_
diff --git a/python-webrtc/cpp/src/interfaces/set_session_description_observer.h b/python-webrtc/cpp/src/interfaces/set_session_description_observer.h
index 0cf0e18..507153c 100644
--- a/python-webrtc/cpp/src/interfaces/set_session_description_observer.h
+++ b/python-webrtc/cpp/src/interfaces/set_session_description_observer.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_SET_SESSION_DESCRIPTION_OBSERVER_H_
+#define PYTHON_WEBRTC_INTERFACES_SET_SESSION_DESCRIPTION_OBSERVER_H_
 
 #include <functional>
 #include <utility>
@@ -40,3 +41,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_SET_SESSION_DESCRIPTION_OBSERVER_H_
diff --git a/python-webrtc/cpp/src/interfaces/stats_collector_callback.h b/python-webrtc/cpp/src/interfaces/stats_collector_callback.h
index 7581c40..44b4a8e 100644
--- a/python-webrtc/cpp/src/interfaces/stats_collector_callback.h
+++ b/python-webrtc/cpp/src/interfaces/stats_collector_callback.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_INTERFACES_STATS_COLLECTOR_CALLBACK_H_
+#define PYTHON_WEBRTC_INTERFACES_STATS_COLLECTOR_CALLBACK_H_
 
 #include <functional>
 #include <set>
@@ -29,8 +30,8 @@ namespace python_webrtc {
         return;
       }
       auto filtered = webrtc::RTCStatsReport::Create(report->timestamp());
-      for (const auto &stats: *report) {
-        if (!_excluded.count(stats.type())) {
+      for (const auto &stats : *report) {
+        if (!_excluded.contains(stats.type())) {
           filtered->AddStats(stats.copy());
         }
       }
@@ -43,3 +44,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_INTERFACES_STATS_COLLECTOR_CALLBACK_H_
diff --git a/python-webrtc/cpp/src/media/audio_samples.cpp b/python-webrtc/cpp/src/media/audio_samples.cpp
index d0f0762..18d5c91 100644
--- a/python-webrtc/cpp/src/media/audio_samples.cpp
+++ b/python-webrtc/cpp/src/media/audio_samples.cpp
@@ -19,7 +19,7 @@ namespace python_webrtc {
 
   namespace {
 
-    enum class SampleType { U8, S16, S32, F32 };
+    enum class SampleType : uint8_t { U8, S16, S32, F32 };
 
     struct SampleFormat {
       SampleType type;
@@ -29,100 +29,106 @@ namespace python_webrtc {
     constexpr std::string_view kPlanarSuffix = "-planar";
     constexpr double kS16Scale = 32768.0;
     constexpr double kS32Scale = 2147483648.0;
+    // unsigned 8-bit samples are offset by half their range
+    constexpr int kU8Offset = 128;
+    constexpr double kU8Scale = 128.0;
+    // how far each type sits below s32
+    constexpr int kU8Shift = 24;
+    constexpr int kS16Shift = 16;
 
     SampleFormat ParseFormat(const std::string &format) {
       std::string_view type = format;
-      bool planar = type.size() > kPlanarSuffix.size() &&
-                    type.substr(type.size() - kPlanarSuffix.size()) == kPlanarSuffix;
+      const bool planar =
+          type.size() > kPlanarSuffix.size() && type.substr(type.size() - kPlanarSuffix.size()) == kPlanarSuffix;
       if (planar) {
         type.remove_suffix(kPlanarSuffix.size());
       }
       if (type == "u8") {
-        return {SampleType::U8, planar};
+        return {.type = SampleType::U8, .planar = planar};
       }
       if (type == "s16") {
-        return {SampleType::S16, planar};
+        return {.type = SampleType::S16, .planar = planar};
       }
       if (type == "s32") {
-        return {SampleType::S32, planar};
+        return {.type = SampleType::S32, .planar = planar};
       }
       if (type == "f32") {
-        return {SampleType::F32, planar};
+        return {.type = SampleType::F32, .planar = planar};
       }
       throw pybind11::value_error("Unsupported sample format " + format);
     }
 
     size_t Size(SampleType type) {
       switch (type) {
-        case SampleType::U8:
-          return sizeof(uint8_t);
-        case SampleType::S16:
-          return sizeof(int16_t);
-        default:
-          return sizeof(int32_t);
+      case SampleType::U8:
+        return sizeof(uint8_t);
+      case SampleType::S16:
+        return sizeof(int16_t);
+      default:
+        return sizeof(int32_t);
       }
     }
 
     // unaligned, as the buffers of Python may be
-    template<typename T>
-    T Load(const uint8_t *p) {
+    template <typename T>
+    T Load(const uint8_t *data) {
       T value;
-      std::memcpy(&value, p, sizeof(T));
+      std::memcpy(&value, data, sizeof(T));
       return value;
     }
 
-    template<typename T>
-    void Store(uint8_t *p, T value) {
-      std::memcpy(p, &value, sizeof(T));
+    template <typename T>
+    void Store(uint8_t *data, T value) {
+      std::memcpy(data, &value, sizeof(T));
     }
 
     // the sample as s32, the widest type, so integer conversions are exact shifts
-    int32_t ReadInt(const uint8_t *p, SampleType type) {
+    int32_t ReadInt(const uint8_t *data, SampleType type) {
       switch (type) {
-        case SampleType::U8:
-          return static_cast<int32_t>(static_cast<uint32_t>(*p - 128) << 24);
-        case SampleType::S16:
-          return static_cast<int32_t>(static_cast<uint32_t>(Load<int16_t>(p)) << 16);
-        case SampleType::S32:
-          return Load<int32_t>(p);
-        default: {
-          double scaled = std::clamp(static_cast<double>(Load<float>(p)), -1.0, 1.0) * kS32Scale;
-          return static_cast<int32_t>(std::clamp(scaled, -kS32Scale, kS32Scale - 1));
-        }
+      case SampleType::U8:
+        return static_cast<int32_t>(static_cast<uint32_t>(*data - kU8Offset) << kU8Shift);
+      case SampleType::S16:
+        return static_cast<int32_t>(static_cast<uint32_t>(Load<int16_t>(data)) << kS16Shift);
+      case SampleType::S32:
+        return Load<int32_t>(data);
+      default: {
+        const double scaled = std::clamp(static_cast<double>(Load<float>(data)), -1.0, 1.0) * kS32Scale;
+        return static_cast<int32_t>(std::clamp(scaled, -kS32Scale, kS32Scale - 1));
+      }
       }
     }
 
-    float ReadFloat(const uint8_t *p, SampleType type) {
+    float ReadFloat(const uint8_t *data, SampleType type) {
       switch (type) {
-        case SampleType::U8:
-          return static_cast<float>((static_cast<int>(*p) - 128) / 128.0);
-        case SampleType::S16:
-          return static_cast<float>(Load<int16_t>(p) / kS16Scale);
-        case SampleType::S32:
-          return static_cast<float>(Load<int32_t>(p) / kS32Scale);
-        default:
-          return Load<float>(p);
+      case SampleType::U8:
+        return static_cast<float>((static_cast<int>(*data) - kU8Offset) / kU8Scale);
+      case SampleType::S16:
+        return static_cast<float>(Load<int16_t>(data) / kS16Scale);
+      case SampleType::S32:
+        return static_cast<float>(Load<int32_t>(data) / kS32Scale);
+      default:
+        return Load<float>(data);
       }
     }
 
-    void Convert(const uint8_t *from, SampleType fromType, uint8_t *to, SampleType toType) {
+    void Convert(const uint8_t *from, SampleType fromType, uint8_t *target, SampleType toType) {
       if (fromType == toType) {
-        std::memcpy(to, from, Size(toType));
+        std::memcpy(target, from, Size(toType));
         return;
       }
       switch (toType) {
-        case SampleType::F32:
-          Store(to, ReadFloat(from, fromType));
-          break;
-        case SampleType::S32:
-          Store(to, ReadInt(from, fromType));
-          break;
-        case SampleType::S16:
-          Store(to, static_cast<int16_t>(ReadInt(from, fromType) >> 16));
-          break;
-        case SampleType::U8:
-          *to = static_cast<uint8_t>((ReadInt(from, fromType) >> 24) + 128);
-          break;
+      case SampleType::F32:
+        Store(target, ReadFloat(from, fromType));
+        break;
+      case SampleType::S32:
+        Store(target, ReadInt(from, fromType));
+        break;
+      case SampleType::S16:
+        Store(target, static_cast<int16_t>(ReadInt(from, fromType) >> kS16Shift));
+        break;
+      case SampleType::U8:
+        *target = static_cast<uint8_t>((ReadInt(from, fromType) >> kU8Shift) + kU8Offset);
+        break;
       }
     }
 
@@ -136,18 +142,17 @@ namespace python_webrtc {
   }
 
   void AudioSamples::Copy(const pybind11::buffer &source, const std::string &sourceFormatName, size_t channels,
-                          size_t frames, const pybind11::buffer &destination,
-                          const std::string &destinationFormatName, size_t planeIndex, size_t frameOffset,
-                          size_t frameCount) {
+                          size_t frames, const pybind11::buffer &destination, const std::string &destinationFormatName,
+                          size_t planeIndex, size_t frameOffset, size_t frameCount) {
     auto sourceFormat = ParseFormat(sourceFormatName);
     auto destinationFormat = ParseFormat(destinationFormatName);
     auto sourceInfo = ContiguousBuffer(source);
     auto destinationInfo = ContiguousBuffer(destination, true);
     auto sourceSize = static_cast<size_t>(sourceInfo.size * sourceInfo.itemsize);
     auto destinationSize = static_cast<size_t>(destinationInfo.size * destinationInfo.itemsize);
-    size_t sourceSample = Size(sourceFormat.type);
-    size_t destinationSample = Size(destinationFormat.type);
-    size_t copiedChannels = destinationFormat.planar ? 1 : channels;
+    const size_t sourceSample = Size(sourceFormat.type);
+    const size_t destinationSample = Size(destinationFormat.type);
+    const size_t copiedChannels = destinationFormat.planar ? 1 : channels;
 
     // divided rather than multiplied, which could overflow
     if (channels == 0 || frameOffset > frames || frameCount > frames - frameOffset ||
@@ -157,16 +162,16 @@ namespace python_webrtc {
       throw pybind11::value_error("The copy is out of the bounds of the samples or of the destination");
     }
 
-    auto from = static_cast<const uint8_t *>(sourceInfo.ptr);
-    auto to = static_cast<uint8_t *>(destinationInfo.ptr);
-    gil_release release;
+    const auto *from = static_cast<const uint8_t *>(sourceInfo.ptr);
+    auto *target = static_cast<uint8_t *>(destinationInfo.ptr);
+    const gil_release release;
     for (size_t frame = 0; frame < frameCount; ++frame) {
-      for (size_t c = 0; c < copiedChannels; ++c) {
-        size_t channel = destinationFormat.planar ? planeIndex : c;
-        size_t sourceIndex = sourceFormat.planar ? channel * frames + frameOffset + frame
-                                                 : (frameOffset + frame) * channels + channel;
-        size_t destinationIndex = frame * copiedChannels + c;
-        Convert(from + sourceIndex * sourceSample, sourceFormat.type, to + destinationIndex * destinationSample,
+      for (size_t copied = 0; copied < copiedChannels; ++copied) {
+        const size_t channel = destinationFormat.planar ? planeIndex : copied;
+        const size_t sourceIndex = sourceFormat.planar ? (channel * frames) + frameOffset + frame
+                                                       : ((frameOffset + frame) * channels) + channel;
+        const size_t destinationIndex = (frame * copiedChannels) + copied;
+        Convert(from + (sourceIndex * sourceSample), sourceFormat.type, target + (destinationIndex * destinationSample),
                 destinationFormat.type);
       }
     }
diff --git a/python-webrtc/cpp/src/media/audio_samples.h b/python-webrtc/cpp/src/media/audio_samples.h
index 060104a..6a87aea 100644
--- a/python-webrtc/cpp/src/media/audio_samples.h
+++ b/python-webrtc/cpp/src/media/audio_samples.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MEDIA_AUDIO_SAMPLES_H_
+#define PYTHON_WEBRTC_MEDIA_AUDIO_SAMPLES_H_
 
 #include <cstddef>
 #include <string>
@@ -26,3 +27,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MEDIA_AUDIO_SAMPLES_H_
diff --git a/python-webrtc/cpp/src/media/media.h b/python-webrtc/cpp/src/media/media.h
index aee9943..226b0d5 100644
--- a/python-webrtc/cpp/src/media/media.h
+++ b/python-webrtc/cpp/src/media/media.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MEDIA_MEDIA_H_
+#define PYTHON_WEBRTC_MEDIA_MEDIA_H_
 
 #include <pybind11/pybind11.h>
 
@@ -18,3 +19,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MEDIA_MEDIA_H_
diff --git a/python-webrtc/cpp/src/media/media_stream_track_processor.cpp b/python-webrtc/cpp/src/media/media_stream_track_processor.cpp
index ace47ae..d4574cc 100644
--- a/python-webrtc/cpp/src/media/media_stream_track_processor.cpp
+++ b/python-webrtc/cpp/src/media/media_stream_track_processor.cpp
@@ -12,21 +12,21 @@
 
 #include <rtc_base/time_utils.h>
 
+#include "../utils/buffer.h"
 #include "../utils/gil.h"
 #include "../utils/libwebrtc_thread.h"
 
 namespace python_webrtc {
 
-  MediaStreamTrackProcessor::MediaStreamTrackProcessor(
-      std::shared_ptr<PeerConnectionFactory> factory, webrtc::scoped_refptr<webrtc::MediaStreamTrackInterface> track,
-      size_t maxBufferSize)
-      : _factory(std::move(factory)),
-        _track(std::move(track)),
+  MediaStreamTrackProcessor::MediaStreamTrackProcessor(std::shared_ptr<PeerConnectionFactory> factory,
+                                                       webrtc::scoped_refptr<webrtc::MediaStreamTrackInterface> track,
+                                                       size_t maxBufferSize)
+      : _factory(std::move(factory)), _track(std::move(track)),
         _video(_track->kind() == webrtc::MediaStreamTrackInterface::kVideoKind),
         _maxBufferSize(std::max<size_t>(1, maxBufferSize)) {}
 
-  std::shared_ptr<MediaStreamTrackProcessor> MediaStreamTrackProcessor::Create(std::shared_ptr<MediaStreamTrack> track,
-                                                                               size_t maxBufferSize) {
+  std::shared_ptr<MediaStreamTrackProcessor>
+  MediaStreamTrackProcessor::Create(const std::shared_ptr<MediaStreamTrack> &track, size_t maxBufferSize) {
     // Python keeps the track's wrapper, so the collector sees handlers of the track referencing the processor
     std::shared_ptr<MediaStreamTrackProcessor> processor(
         new MediaStreamTrackProcessor(track->factory(), track->track(), maxBufferSize), DeleteOffLibwebrtcThread());
@@ -39,7 +39,7 @@ namespace python_webrtc {
   }
 
   MediaStreamTrackProcessor::~MediaStreamTrackProcessor() {
-    BlockingDestructor release("MediaStreamTrackProcessor");
+    const BlockingDestructor release("MediaStreamTrackProcessor");
     Detach();
     DropListeners();
   }
@@ -57,7 +57,7 @@ namespace python_webrtc {
   }
 
   void MediaStreamTrackProcessor::Attach() {
-    std::lock_guard<std::mutex> lock(_attachMutex);
+    const std::scoped_lock lock(_attachMutex);
     if (_attached) {
       return;
     }
@@ -70,7 +70,7 @@ namespace python_webrtc {
   }
 
   void MediaStreamTrackProcessor::Detach() {
-    std::lock_guard<std::mutex> lock(_attachMutex);
+    const std::scoped_lock lock(_attachMutex);
     if (!_attached) {
       return;
     }
@@ -84,7 +84,7 @@ namespace python_webrtc {
   }
 
   void MediaStreamTrackProcessor::Push(Item item) {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     if (_ended) {
       return;
     }
@@ -105,8 +105,10 @@ namespace python_webrtc {
   }
 
   void MediaStreamTrackProcessor::OnFrame(const webrtc::VideoFrame &frame) {
-    Push(VideoItem{frame.video_frame_buffer(), frame.timestamp_us(), static_cast<int>(frame.rotation()),
-                   frame.rtp_timestamp()});
+    Push(VideoItem{.buffer = frame.video_frame_buffer(),
+                   .timestampUs = frame.timestamp_us(),
+                   .rotation = static_cast<int>(frame.rotation()),
+                   .rtpTimestamp = frame.rtp_timestamp()});
   }
 
   void MediaStreamTrackProcessor::OnData(const void *audioData, int bitsPerSample, int sampleRate, size_t channels,
@@ -115,11 +117,16 @@ namespace python_webrtc {
   }
 
   void MediaStreamTrackProcessor::OnData(const void *audioData, int bitsPerSample, int sampleRate, size_t channels,
-                                         size_t frames, std::optional<int64_t> absoluteCaptureTimestampMs) {
-    size_t size = frames * channels * (bitsPerSample / 8);
+                                         size_t frames, std::optional<int64_t> /*absoluteCaptureTimestampMs*/) {
+    const size_t size = frames * channels * (bitsPerSample / 8);
     std::vector<uint8_t> data(size);
     std::memcpy(data.data(), audioData, size);
-    Push(AudioItem{std::move(data), bitsPerSample, sampleRate, channels, frames, webrtc::TimeMicros()});
+    Push(AudioItem{.data = std::move(data),
+                   .bitsPerSample = bitsPerSample,
+                   .sampleRate = sampleRate,
+                   .channels = channels,
+                   .frames = frames,
+                   .timestampUs = webrtc::TimeMicros()});
   }
 
   void MediaStreamTrackProcessor::OnWakeup() {
@@ -127,7 +134,7 @@ namespace python_webrtc {
   }
 
   void MediaStreamTrackProcessor::OnTrackEnded() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     if (_ended) {
       return;
     }
@@ -140,7 +147,7 @@ namespace python_webrtc {
 
   void MediaStreamTrackProcessor::Cancel() {
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       _ended = true;
       _queue.clear();
     }
@@ -148,21 +155,21 @@ namespace python_webrtc {
   }
 
   void MediaStreamTrackProcessor::AckWakeup() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     _wakePending = false;
   }
 
   bool MediaStreamTrackProcessor::GetEnded() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     return _ended && _queue.empty();
   }
 
   pybind11::object MediaStreamTrackProcessor::Read() {
     std::optional<Item> item;
-    bool ended;
+    bool ended = false;
     {
-      gil_release release;
-      std::lock_guard<std::mutex> lock(_mutex);
+      const gil_release release;
+      const std::scoped_lock lock(_mutex);
       if (!_queue.empty()) {
         item = std::move(_queue.front());
         _queue.pop_front();
@@ -171,22 +178,22 @@ namespace python_webrtc {
     }
     if (ended && !item) {
       // the sink is detached here rather than on the thread that ended the track
-      gil_release release;
+      const gil_release release;
       Detach();
     }
     if (!item) {
       return pybind11::none();
     }
-    if (auto video = std::get_if<VideoItem>(&*item)) {
+    if (auto *video = std::get_if<VideoItem>(&*item)) {
       std::shared_ptr<VideoFrameBuffer> buffer;
       {
-        gil_release release;
+        const gil_release release;
         buffer = VideoFrameBuffer::FromWebrtc(video->buffer);
       }
       return pybind11::make_tuple(buffer, video->timestampUs, video->rotation, video->rtpTimestamp);
     }
     auto &audio = std::get<AudioItem>(*item);
-    pybind11::bytes data(reinterpret_cast<const char *>(audio.data.data()), audio.data.size());
+    const pybind11::bytes data = Bytes(audio.data.data(), audio.data.size());
     return pybind11::make_tuple(data, audio.bitsPerSample, audio.sampleRate, audio.channels, audio.frames,
                                 audio.timestampUs);
   }
diff --git a/python-webrtc/cpp/src/media/media_stream_track_processor.h b/python-webrtc/cpp/src/media/media_stream_track_processor.h
index 882a01f..8734024 100644
--- a/python-webrtc/cpp/src/media/media_stream_track_processor.h
+++ b/python-webrtc/cpp/src/media/media_stream_track_processor.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MEDIA_MEDIA_STREAM_TRACK_PROCESSOR_H_
+#define PYTHON_WEBRTC_MEDIA_MEDIA_STREAM_TRACK_PROCESSOR_H_
 
 #include <atomic>
 #include <cstdint>
@@ -22,11 +23,11 @@
 
 #include <pybind11/pybind11.h>
 
+#include "../interfaces/media_stream_track.h"
 #include "../utils/alive_count.h"
+#include "../utils/listeners.h"
 #include "video_frame_buffer.h"
 #include "wakeup.h"
-#include "../interfaces/media_stream_track.h"
-#include "../utils/listeners.h"
 
 namespace python_webrtc {
 
@@ -38,11 +39,14 @@ namespace python_webrtc {
                                     public webrtc::AudioTrackSinkInterface,
                                     public std::enable_shared_from_this<MediaStreamTrackProcessor> {
   public:
-    static std::shared_ptr<MediaStreamTrackProcessor> Create(std::shared_ptr<MediaStreamTrack> track,
+    static std::shared_ptr<MediaStreamTrackProcessor> Create(const std::shared_ptr<MediaStreamTrack> &track,
                                                              size_t maxBufferSize);
 
     ~MediaStreamTrackProcessor() override;
 
+    MediaStreamTrackProcessor(const MediaStreamTrackProcessor &) = delete;
+    MediaStreamTrackProcessor &operator=(const MediaStreamTrackProcessor &) = delete;
+
     static void Init(pybind11::module &m);
 
     // the oldest media queued: (VideoFrameBuffer, timestampUs, rotation, rtpTimestamp) or
@@ -129,3 +133,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MEDIA_MEDIA_STREAM_TRACK_PROCESSOR_H_
diff --git a/python-webrtc/cpp/src/media/playout_audio_device.cpp b/python-webrtc/cpp/src/media/playout_audio_device.cpp
index 4b5b68d..68203f2 100644
--- a/python-webrtc/cpp/src/media/playout_audio_device.cpp
+++ b/python-webrtc/cpp/src/media/playout_audio_device.cpp
@@ -9,20 +9,22 @@
 
 #include <chrono>
 #include <cstring>
+#include <span>
 #include <vector>
 
 namespace python_webrtc {
 
   namespace {
 
-    int32_t DeviceName(uint16_t index, char name[webrtc::kAdmMaxDeviceNameSize], char guid[webrtc::kAdmMaxGuidSize]) {
+    // the single device, without a guid
+    int32_t DeviceName(uint16_t index, std::span<char, webrtc::kAdmMaxDeviceNameSize> name, char *guid) {
       if (index != 0) {
         return -1;
       }
-      std::strncpy(name, "python-webrtc", webrtc::kAdmMaxDeviceNameSize - 1);
-      name[webrtc::kAdmMaxDeviceNameSize - 1] = '\0';
-      if (guid) {
-        guid[0] = '\0';
+      std::strncpy(name.data(), "python-webrtc", name.size() - 1);
+      name.back() = '\0';
+      if (guid != nullptr) {
+        *guid = '\0';
       }
       return 0;
     }
@@ -30,7 +32,8 @@ namespace python_webrtc {
   } // namespace
 
   PlayoutAudioDevice::~PlayoutAudioDevice() {
-    StopPlayout();
+    // this class's own, as in any destructor
+    PlayoutAudioDevice::StopPlayout();
   }
 
   int32_t PlayoutAudioDevice::ActiveAudioLayer(AudioLayer *audioLayer) const {
@@ -39,13 +42,13 @@ namespace python_webrtc {
   }
 
   int32_t PlayoutAudioDevice::RegisterAudioCallback(webrtc::AudioTransport *audioCallback) {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     _transport = audioCallback;
     return 0;
   }
 
   int32_t PlayoutAudioDevice::Init() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     _initialized = true;
     return 0;
   }
@@ -53,24 +56,22 @@ namespace python_webrtc {
   int32_t PlayoutAudioDevice::Terminate() {
     StopPlayout();
     StopRecording();
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     _initialized = false;
     return 0;
   }
 
   bool PlayoutAudioDevice::Initialized() const {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     return _initialized;
   }
 
-  int32_t PlayoutAudioDevice::PlayoutDeviceName(uint16_t index, char name[webrtc::kAdmMaxDeviceNameSize],
-                                                char guid[webrtc::kAdmMaxGuidSize]) {
-    return DeviceName(index, name, guid);
+  int32_t PlayoutAudioDevice::PlayoutDeviceName(uint16_t index, char *name, char *guid) {
+    return DeviceName(index, std::span<char, webrtc::kAdmMaxDeviceNameSize>(name, webrtc::kAdmMaxDeviceNameSize), guid);
   }
 
-  int32_t PlayoutAudioDevice::RecordingDeviceName(uint16_t index, char name[webrtc::kAdmMaxDeviceNameSize],
-                                                  char guid[webrtc::kAdmMaxGuidSize]) {
-    return DeviceName(index, name, guid);
+  int32_t PlayoutAudioDevice::RecordingDeviceName(uint16_t index, char *name, char *guid) {
+    return DeviceName(index, std::span<char, webrtc::kAdmMaxDeviceNameSize>(name, webrtc::kAdmMaxDeviceNameSize), guid);
   }
 
   int32_t PlayoutAudioDevice::PlayoutIsAvailable(bool *available) {
@@ -79,13 +80,13 @@ namespace python_webrtc {
   }
 
   int32_t PlayoutAudioDevice::InitPlayout() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     _playoutInitialized = true;
     return 0;
   }
 
   bool PlayoutAudioDevice::PlayoutIsInitialized() const {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     return _playoutInitialized;
   }
 
@@ -95,25 +96,25 @@ namespace python_webrtc {
   }
 
   int32_t PlayoutAudioDevice::InitRecording() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     _recordingInitialized = true;
     return 0;
   }
 
   bool PlayoutAudioDevice::RecordingIsInitialized() const {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     return _recordingInitialized;
   }
 
   int32_t PlayoutAudioDevice::StartPlayout() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     if (_playout) {
       return 0;
     }
     _playout = std::make_unique<PacedThread>();
     std::vector<int16_t> samples(kFrames * kChannels);
     _playout->Start(std::chrono::milliseconds(kPullIntervalMs), [this, samples = std::move(samples)]() mutable {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       if (!_transport) {
         return;
       }
@@ -129,7 +130,7 @@ namespace python_webrtc {
   int32_t PlayoutAudioDevice::StopPlayout() {
     std::unique_ptr<PacedThread> playout;
     {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       playout = std::move(_playout);
       _playoutInitialized = false;
     }
@@ -139,25 +140,25 @@ namespace python_webrtc {
   }
 
   bool PlayoutAudioDevice::Playing() const {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     return static_cast<bool>(_playout);
   }
 
   int32_t PlayoutAudioDevice::StartRecording() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     _recording = true;
     return 0;
   }
 
   int32_t PlayoutAudioDevice::StopRecording() {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     _recording = false;
     _recordingInitialized = false;
     return 0;
   }
 
   bool PlayoutAudioDevice::Recording() const {
-    std::lock_guard<std::mutex> lock(_mutex);
+    const std::scoped_lock lock(_mutex);
     return _recording;
   }
 
diff --git a/python-webrtc/cpp/src/media/playout_audio_device.h b/python-webrtc/cpp/src/media/playout_audio_device.h
index b25850a..83c2b66 100644
--- a/python-webrtc/cpp/src/media/playout_audio_device.h
+++ b/python-webrtc/cpp/src/media/playout_audio_device.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MEDIA_PLAYOUT_AUDIO_DEVICE_H_
+#define PYTHON_WEBRTC_MEDIA_PLAYOUT_AUDIO_DEVICE_H_
 
 #include <cstdint>
 #include <memory>
@@ -28,6 +29,11 @@ namespace python_webrtc {
 
     ~PlayoutAudioDevice() override;
 
+    PlayoutAudioDevice() = default;
+
+    PlayoutAudioDevice(const PlayoutAudioDevice &) = delete;
+    PlayoutAudioDevice &operator=(const PlayoutAudioDevice &) = delete;
+
     int32_t ActiveAudioLayer(AudioLayer *audioLayer) const override;
 
     int32_t RegisterAudioCallback(webrtc::AudioTransport *audioCallback) override;
@@ -42,19 +48,18 @@ namespace python_webrtc {
 
     int16_t RecordingDevices() override { return 1; }
 
-    int32_t PlayoutDeviceName(uint16_t index, char name[webrtc::kAdmMaxDeviceNameSize],
-                              char guid[webrtc::kAdmMaxGuidSize]) override;
+    // name and guid point to kAdmMaxDeviceNameSize and kAdmMaxGuidSize chars
+    int32_t PlayoutDeviceName(uint16_t index, char *name, char *guid) override;
 
-    int32_t RecordingDeviceName(uint16_t index, char name[webrtc::kAdmMaxDeviceNameSize],
-                                char guid[webrtc::kAdmMaxGuidSize]) override;
+    int32_t RecordingDeviceName(uint16_t index, char *name, char *guid) override;
 
-    int32_t SetPlayoutDevice(uint16_t index) override { return 0; }
+    int32_t SetPlayoutDevice(uint16_t /*index*/) override { return 0; }
 
-    int32_t SetPlayoutDevice(WindowsDeviceType device) override { return 0; }
+    int32_t SetPlayoutDevice(WindowsDeviceType /*device*/) override { return 0; }
 
-    int32_t SetRecordingDevice(uint16_t index) override { return 0; }
+    int32_t SetRecordingDevice(uint16_t /*index*/) override { return 0; }
 
-    int32_t SetRecordingDevice(WindowsDeviceType device) override { return 0; }
+    int32_t SetRecordingDevice(WindowsDeviceType /*device*/) override { return 0; }
 
     int32_t PlayoutIsAvailable(bool *available) override;
 
@@ -90,45 +95,45 @@ namespace python_webrtc {
 
     int32_t SpeakerVolumeIsAvailable(bool *available) override;
 
-    int32_t SetSpeakerVolume(uint32_t volume) override { return -1; }
+    int32_t SetSpeakerVolume(uint32_t /*volume*/) override { return -1; }
 
-    int32_t SpeakerVolume(uint32_t *volume) const override { return -1; }
+    int32_t SpeakerVolume(uint32_t * /*volume*/) const override { return -1; }
 
-    int32_t MaxSpeakerVolume(uint32_t *maxVolume) const override { return -1; }
+    int32_t MaxSpeakerVolume(uint32_t * /*maxVolume*/) const override { return -1; }
 
-    int32_t MinSpeakerVolume(uint32_t *minVolume) const override { return -1; }
+    int32_t MinSpeakerVolume(uint32_t * /*minVolume*/) const override { return -1; }
 
     int32_t MicrophoneVolumeIsAvailable(bool *available) override;
 
-    int32_t SetMicrophoneVolume(uint32_t volume) override { return -1; }
+    int32_t SetMicrophoneVolume(uint32_t /*volume*/) override { return -1; }
 
-    int32_t MicrophoneVolume(uint32_t *volume) const override { return -1; }
+    int32_t MicrophoneVolume(uint32_t * /*volume*/) const override { return -1; }
 
-    int32_t MaxMicrophoneVolume(uint32_t *maxVolume) const override { return -1; }
+    int32_t MaxMicrophoneVolume(uint32_t * /*maxVolume*/) const override { return -1; }
 
-    int32_t MinMicrophoneVolume(uint32_t *minVolume) const override { return -1; }
+    int32_t MinMicrophoneVolume(uint32_t * /*minVolume*/) const override { return -1; }
 
     int32_t SpeakerMuteIsAvailable(bool *available) override;
 
-    int32_t SetSpeakerMute(bool enable) override { return -1; }
+    int32_t SetSpeakerMute(bool /*enable*/) override { return -1; }
 
-    int32_t SpeakerMute(bool *enabled) const override { return -1; }
+    int32_t SpeakerMute(bool * /*enabled*/) const override { return -1; }
 
     int32_t MicrophoneMuteIsAvailable(bool *available) override;
 
-    int32_t SetMicrophoneMute(bool enable) override { return -1; }
+    int32_t SetMicrophoneMute(bool /*enable*/) override { return -1; }
 
-    int32_t MicrophoneMute(bool *enabled) const override { return -1; }
+    int32_t MicrophoneMute(bool * /*enabled*/) const override { return -1; }
 
     int32_t StereoPlayoutIsAvailable(bool *available) const override;
 
-    int32_t SetStereoPlayout(bool enable) override { return 0; }
+    int32_t SetStereoPlayout(bool /*enable*/) override { return 0; }
 
     int32_t StereoPlayout(bool *enabled) const override;
 
     int32_t StereoRecordingIsAvailable(bool *available) const override;
 
-    int32_t SetStereoRecording(bool enable) override { return 0; }
+    int32_t SetStereoRecording(bool /*enable*/) override { return 0; }
 
     int32_t StereoRecording(bool *enabled) const override;
 
@@ -140,11 +145,11 @@ namespace python_webrtc {
 
     bool BuiltInNSIsAvailable() const override { return false; }
 
-    int32_t EnableBuiltInAEC(bool enable) override { return -1; }
+    int32_t EnableBuiltInAEC(bool /*enable*/) override { return -1; }
 
-    int32_t EnableBuiltInAGC(bool enable) override { return -1; }
+    int32_t EnableBuiltInAGC(bool /*enable*/) override { return -1; }
 
-    int32_t EnableBuiltInNS(bool enable) override { return -1; }
+    int32_t EnableBuiltInNS(bool /*enable*/) override { return -1; }
 
   private:
     mutable std::mutex _mutex;
@@ -158,3 +163,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MEDIA_PLAYOUT_AUDIO_DEVICE_H_
diff --git a/python-webrtc/cpp/src/media/source_control.h b/python-webrtc/cpp/src/media/source_control.h
index e0b7da8..ce2e733 100644
--- a/python-webrtc/cpp/src/media/source_control.h
+++ b/python-webrtc/cpp/src/media/source_control.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MEDIA_SOURCE_CONTROL_H_
+#define PYTHON_WEBRTC_MEDIA_SOURCE_CONTROL_H_
 
 #include <map>
 #include <memory>
@@ -29,7 +30,7 @@ namespace python_webrtc {
 
     static void Register(const webrtc::MediaStreamTrackInterface *track, const std::string &trackId,
                          const std::shared_ptr<SourceControl> &control) {
-      std::lock_guard<std::mutex> lock(RegistryMutex());
+      const std::scoped_lock lock(RegistryMutex());
       auto &registry = Registry();
       for (auto it = registry.begin(); it != registry.end();) {
         it = it->second.expired() ? registry.erase(it) : std::next(it);
@@ -39,7 +40,7 @@ namespace python_webrtc {
 
     static std::shared_ptr<SourceControl> Find(const webrtc::MediaStreamTrackInterface *track,
                                                const std::string &trackId) {
-      std::lock_guard<std::mutex> lock(RegistryMutex());
+      const std::scoped_lock lock(RegistryMutex());
       auto &registry = Registry();
       auto it = registry.find({track, trackId});
       return it != registry.end() ? it->second.lock() : nullptr;
@@ -52,14 +53,16 @@ namespace python_webrtc {
 
     static Map &Registry() {
       // never destroyed: wrappers may outlive static destructors
-      static auto registry = new Map();
+      static auto *registry = new Map();
       return *registry;
     }
 
     static std::mutex &RegistryMutex() {
-      static auto mutex = new std::mutex();
+      static auto *mutex = new std::mutex();
       return *mutex;
     }
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MEDIA_SOURCE_CONTROL_H_
diff --git a/python-webrtc/cpp/src/media/track_generator.cpp b/python-webrtc/cpp/src/media/track_generator.cpp
index 94bb535..0ddbfa7 100644
--- a/python-webrtc/cpp/src/media/track_generator.cpp
+++ b/python-webrtc/cpp/src/media/track_generator.cpp
@@ -7,6 +7,7 @@
 
 #include "track_generator.h"
 
+#include <climits>
 #include <cstring>
 #include <string>
 #include <string_view>
@@ -27,6 +28,7 @@ namespace python_webrtc {
 
     // libwebrtc takes audio in 10 ms frames
     constexpr int kAudioFramesPerSecond = 100;
+    constexpr int kBitsPerSample = sizeof(int16_t) * CHAR_BIT;
     // libwebrtc's native rates: its resampler crashes on much lower ones
     constexpr int kMinSampleRate = 8000;
     constexpr int kMaxSampleRate = 384000;
@@ -55,7 +57,7 @@ namespace python_webrtc {
   std::shared_ptr<MediaStreamTrack> TrackGenerator::GetTrack() {
     // wrapped out of the lock: wrapping may wait for the signaling thread (the holder finds a live wrapper)
     auto wrapped = MediaStreamTrack::holder().GetOrCreate(_factory, _webrtcTrack);
-    std::lock_guard<std::mutex> lock(_trackMutex);
+    const std::scoped_lock lock(_trackMutex);
     auto track = _track.lock();
     if (!track) {
       track = std::move(wrapped);
@@ -75,7 +77,7 @@ namespace python_webrtc {
   }
 
   std::shared_ptr<TrackGenerator> TrackGenerator::Create(const std::string &kind) {
-    return std::shared_ptr<TrackGenerator>(new TrackGenerator(kind), DeleteOffLibwebrtcThread());
+    return {new TrackGenerator(kind), DeleteOffLibwebrtcThread()};
   }
 
   void TrackGenerator::Init(pybind11::module &m) {
@@ -85,8 +87,8 @@ namespace python_webrtc {
         .def_property_readonly("kind", &TrackGenerator::GetKind)
         .def_property_readonly("live", nogil_fn(&TrackGenerator::GetLive))
         .def_property("muted", nogil_fn(&TrackGenerator::GetMuted), nogil_fn(&TrackGenerator::SetMuted))
-        .def("writeVideo", &TrackGenerator::WriteVideo, nogil(), pybind11::arg("buffer"),
-             pybind11::arg("timestampUs"), pybind11::arg("rotation"))
+        .def("writeVideo", &TrackGenerator::WriteVideo, nogil(), pybind11::arg("buffer"), pybind11::arg("timestampUs"),
+             pybind11::arg("rotation"))
         .def("writeAudio", &TrackGenerator::WriteAudio, pybind11::arg("samples"), pybind11::arg("sampleRate"),
              pybind11::arg("channels"), pybind11::arg("frames"))
         .def("close", &TrackGenerator::Close, nogil());
@@ -97,8 +99,7 @@ namespace python_webrtc {
       return false;
     }
     auto track = _track.lock();
-    return track ? track->active()
-                 : _webrtcTrack->state() == webrtc::MediaStreamTrackInterface::TrackState::kLive;
+    return track ? track->active() : _webrtcTrack->state() == webrtc::MediaStreamTrackInterface::TrackState::kLive;
   }
 
   bool TrackGenerator::GetMuted() {
@@ -112,8 +113,7 @@ namespace python_webrtc {
     }
   }
 
-  void TrackGenerator::WriteVideo(const std::shared_ptr<VideoFrameBuffer> &buffer, int64_t timestampUs,
-                                  int rotation) {
+  void TrackGenerator::WriteVideo(const std::shared_ptr<VideoFrameBuffer> &buffer, int64_t timestampUs, int rotation) {
     if (!_video) {
       throw pybind11::type_error("An audio generator takes AudioData");
     }
@@ -138,36 +138,35 @@ namespace python_webrtc {
     if (sampleRate < kMinSampleRate || sampleRate > kMaxSampleRate || channels == 0 ||
         channels > webrtc::kMaxNumberOfAudioChannels ||
         static_cast<size_t>(sampleRate / kAudioFramesPerSecond) * channels > webrtc::AudioFrame::kMaxDataSizeSamples) {
-      throw pybind11::value_error("Audio of " + std::to_string(channels) + " channels at " +
-                                  std::to_string(sampleRate) + " Hz isn't supported: up to " +
-                                  std::to_string(webrtc::kMaxNumberOfAudioChannels) + " channels from " +
-                                  std::to_string(kMinSampleRate) + " to " + std::to_string(kMaxSampleRate) +
-                                  " Hz, and " + std::to_string(webrtc::AudioFrame::kMaxDataSizeSamples) +
-                                  " samples every 10 ms");
+      throw pybind11::value_error(
+          "Audio of " + std::to_string(channels) + " channels at " + std::to_string(sampleRate) +
+          " Hz isn't supported: up to " + std::to_string(webrtc::kMaxNumberOfAudioChannels) + " channels from " +
+          std::to_string(kMinSampleRate) + " to " + std::to_string(kMaxSampleRate) + " Hz, and " +
+          std::to_string(webrtc::AudioFrame::kMaxDataSizeSamples) + " samples every 10 ms");
     }
-    std::string_view data = samples;
+    const std::string_view data = samples;
     if (frames > data.size() || data.size() != frames * channels * sizeof(int16_t)) {
       throw pybind11::value_error("The samples don't have the given number of frames");
     }
-    gil_release release;
+    const gil_release release;
     if (!GetLive() || _muted) {
       return;
     }
-    std::lock_guard<std::mutex> lock(_audioMutex);
+    const std::scoped_lock lock(_audioMutex);
     if (sampleRate != _pendingRate || channels != _pendingChannels) {
       _pending.clear();
       _pendingRate = sampleRate;
       _pendingChannels = channels;
     }
-    size_t offset = _pending.size();
-    _pending.resize(offset + frames * channels);
+    const size_t offset = _pending.size();
+    _pending.resize(offset + (frames * channels));
     std::memcpy(_pending.data() + offset, data.data(), data.size());
 
-    size_t chunkFrames = static_cast<size_t>(sampleRate / kAudioFramesPerSecond);
-    size_t chunk = chunkFrames * channels;
+    const auto chunkFrames = static_cast<size_t>(sampleRate / kAudioFramesPerSecond);
+    const size_t chunk = chunkFrames * channels;
     size_t sent = 0;
     while (chunk > 0 && _pending.size() - sent >= chunk) {
-      _audioSource->PushSamples(_pending.data() + sent, sizeof(int16_t) * 8, sampleRate, channels, chunkFrames);
+      _audioSource->PushSamples(_pending.data() + sent, kBitsPerSample, sampleRate, channels, chunkFrames);
       sent += chunk;
     }
     _pending.erase(_pending.begin(), _pending.begin() + static_cast<std::ptrdiff_t>(sent));
@@ -175,7 +174,7 @@ namespace python_webrtc {
 
   void TrackGenerator::Close() {
     // the tracks observe their source on the signaling thread
-    _factory->_signalingThread->BlockingCall([this]() {
+    _factory->signalingThread()->BlockingCall([this]() {
       if (_video) {
         _videoSource->End();
       } else {
diff --git a/python-webrtc/cpp/src/media/track_generator.h b/python-webrtc/cpp/src/media/track_generator.h
index dcc7ac9..3966153 100644
--- a/python-webrtc/cpp/src/media/track_generator.h
+++ b/python-webrtc/cpp/src/media/track_generator.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MEDIA_TRACK_GENERATOR_H_
+#define PYTHON_WEBRTC_MEDIA_TRACK_GENERATOR_H_
 
 #include <atomic>
 #include <cstdint>
@@ -18,12 +19,12 @@
 
 #include <pybind11/pybind11.h>
 
-#include "../utils/alive_count.h"
-#include "video_frame_buffer.h"
 #include "../interfaces/media_stream_track.h"
 #include "../interfaces/peer_connection_factory.h"
 #include "../interfaces/rtc_audio_track_source.h"
 #include "../interfaces/rtc_video_track_source.h"
+#include "../utils/alive_count.h"
+#include "video_frame_buffer.h"
 
 namespace python_webrtc {
 
@@ -40,7 +41,7 @@ namespace python_webrtc {
     // the wrapper of the track, owned by Python once it has it
     std::shared_ptr<MediaStreamTrack> GetTrack();
 
-    std::string GetKind() { return _video ? "video" : "audio"; }
+    std::string GetKind() const { return _video ? "video" : "audio"; }
 
     // whether the track can still take frames: it ends with the generator or with stop()
     bool GetLive();
@@ -62,9 +63,7 @@ namespace python_webrtc {
     struct EndState : TrackEndObserver {
       std::atomic<bool> ended = false;
 
-      void OnTrackEnded() override {
-        ended = true;
-      }
+      void OnTrackEnded() override { ended = true; }
     };
 
     AliveCount<TrackGenerator> _counted;
@@ -88,3 +87,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MEDIA_TRACK_GENERATOR_H_
diff --git a/python-webrtc/cpp/src/media/track_monitor.h b/python-webrtc/cpp/src/media/track_monitor.h
index 8d44a1d..d25e9d0 100644
--- a/python-webrtc/cpp/src/media/track_monitor.h
+++ b/python-webrtc/cpp/src/media/track_monitor.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MEDIA_TRACK_MONITOR_H_
+#define PYTHON_WEBRTC_MEDIA_TRACK_MONITOR_H_
 
 #include <algorithm>
 #include <array>
@@ -38,46 +39,49 @@ namespace python_webrtc {
 
     void OnFrame(const webrtc::VideoFrame &frame) override {
       auto now = webrtc::TimeMicros();
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       if (_video && (_video->width != frame.width() || _video->height != frame.height())) {
         // the rate is measured from the new size on, as the source changed
         _count = 0;
       }
-      _video = Video{frame.width(), frame.height(), std::nullopt};
+      _video = Video{.width = frame.width(), .height = frame.height(), .frameRate = std::nullopt};
       _times[_count % _times.size()] = now;
       _count++;
     }
 
-    void OnData(const void *audioData, int bitsPerSample, int sampleRate, size_t channels, size_t frames) override {
-      std::lock_guard<std::mutex> lock(_mutex);
-      _audio = Audio{sampleRate, static_cast<int>(channels), bitsPerSample};
+    // NOLINTNEXTLINE(bugprone-easily-swappable-parameters): libwebrtc's signature
+    void OnData(const void * /*audioData*/, int bitsPerSample, int sampleRate, size_t channels,
+                size_t /*frames*/) override {
+      const std::scoped_lock lock(_mutex);
+      _audio = Audio{.sampleRate = sampleRate, .channels = static_cast<int>(channels), .bitsPerSample = bitsPerSample};
     }
 
     void OnData(const void *audioData, int bitsPerSample, int sampleRate, size_t channels, size_t frames,
-                std::optional<int64_t> absoluteCaptureTimestampMs) override {
+                std::optional<int64_t> /*absoluteCaptureTimestampMs*/) override {
       OnData(audioData, bitsPerSample, sampleRate, channels, frames);
     }
 
     std::optional<Video> video() {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       if (!_video) {
         return std::nullopt;
       }
       auto video = *_video;
-      size_t samples = std::min<size_t>(_count, _times.size());
+      const size_t samples = std::min<size_t>(_count, _times.size());
       if (samples >= 2) {
         auto last = _times[(_count - 1) % _times.size()];
         auto first = _times[(_count - samples) % _times.size()];
         // frames that stopped more than a second ago have no rate anymore
         if (last > first && webrtc::TimeMicros() - last < webrtc::kNumMicrosecsPerSec) {
-          video.frameRate = (samples - 1) * 1e6 / static_cast<double>(last - first);
+          video.frameRate =
+              static_cast<double>((samples - 1) * webrtc::kNumMicrosecsPerSec) / static_cast<double>(last - first);
         }
       }
       return video;
     }
 
     std::optional<Audio> audio() {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       return _audio;
     }
 
@@ -86,8 +90,11 @@ namespace python_webrtc {
     std::optional<Video> _video;
     std::optional<Audio> _audio;
     // arrival times of the last frames, in microseconds
-    std::array<int64_t, 30> _times{};
+    static constexpr size_t kTimedFrames = 30;
+    std::array<int64_t, kTimedFrames> _times{};
     size_t _count = 0;
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MEDIA_TRACK_MONITOR_H_
diff --git a/python-webrtc/cpp/src/media/video_frame_buffer.cpp b/python-webrtc/cpp/src/media/video_frame_buffer.cpp
index 2c11425..fc5f4cc 100644
--- a/python-webrtc/cpp/src/media/video_frame_buffer.cpp
+++ b/python-webrtc/cpp/src/media/video_frame_buffer.cpp
@@ -7,9 +7,12 @@
 
 #include "video_frame_buffer.h"
 
+#include <array>
 #include <cstring>
-#include <string>
+#include <memory>
 #include <stdexcept>
+#include <string>
+#include <utility>
 
 #include <api/video/i420_buffer.h>
 #include <api/video/nv12_buffer.h>
@@ -30,28 +33,106 @@ namespace python_webrtc {
 
     // keeps the sizes of planes and rows in ints
     constexpr int kMaxDimension = 1 << 24;
+    // the depth of the formats libwebrtc takes as they are, deeper ones are 16-bit samples
+    constexpr int kEightBit = 8;
+    constexpr uint8_t kOpaque = 255;
 
     using Layout = PixelFormat::Layout;
 
-    const PixelFormat FORMATS[] = {
-        {"I420", Layout::I420, 8, false, false},     {"I420P10", Layout::I420, 10, false, false},
-        {"I420P12", Layout::I420, 12, false, false}, {"I420A", Layout::I420, 8, true, false},
-        {"I420AP10", Layout::I420, 10, true, false}, {"I420AP12", Layout::I420, 12, true, false},
-        {"I422", Layout::I422, 8, false, false},     {"I422P10", Layout::I422, 10, false, false},
-        {"I422P12", Layout::I422, 12, false, false}, {"I422A", Layout::I422, 8, true, false},
-        {"I422AP10", Layout::I422, 10, true, false}, {"I422AP12", Layout::I422, 12, true, false},
-        {"I444", Layout::I444, 8, false, false},     {"I444P10", Layout::I444, 10, false, false},
-        {"I444P12", Layout::I444, 12, false, false}, {"I444A", Layout::I444, 8, true, false},
-        {"I444AP10", Layout::I444, 10, true, false}, {"I444AP12", Layout::I444, 12, true, false},
-        {"NV12", Layout::NV12, 8, false, false},     {"RGBA", Layout::RGB, 8, true, true},
-        {"RGBX", Layout::RGB, 8, false, true},       {"BGRA", Layout::RGB, 8, true, false},
-        {"BGRX", Layout::RGB, 8, false, false},
-    };
+    const auto FORMATS = std::to_array<PixelFormat>({
+        {.name = "I420", .layout = Layout::I420, .bits = 8, .alpha = false, .rgbOrder = false},
+        {.name = "I420P10", .layout = Layout::I420, .bits = 10, .alpha = false, .rgbOrder = false},
+        {.name = "I420P12", .layout = Layout::I420, .bits = 12, .alpha = false, .rgbOrder = false},
+        {.name = "I420A", .layout = Layout::I420, .bits = 8, .alpha = true, .rgbOrder = false},
+        {.name = "I420AP10", .layout = Layout::I420, .bits = 10, .alpha = true, .rgbOrder = false},
+        {.name = "I420AP12", .layout = Layout::I420, .bits = 12, .alpha = true, .rgbOrder = false},
+        {.name = "I422", .layout = Layout::I422, .bits = 8, .alpha = false, .rgbOrder = false},
+        {.name = "I422P10", .layout = Layout::I422, .bits = 10, .alpha = false, .rgbOrder = false},
+        {.name = "I422P12", .layout = Layout::I422, .bits = 12, .alpha = false, .rgbOrder = false},
+        {.name = "I422A", .layout = Layout::I422, .bits = 8, .alpha = true, .rgbOrder = false},
+        {.name = "I422AP10", .layout = Layout::I422, .bits = 10, .alpha = true, .rgbOrder = false},
+        {.name = "I422AP12", .layout = Layout::I422, .bits = 12, .alpha = true, .rgbOrder = false},
+        {.name = "I444", .layout = Layout::I444, .bits = 8, .alpha = false, .rgbOrder = false},
+        {.name = "I444P10", .layout = Layout::I444, .bits = 10, .alpha = false, .rgbOrder = false},
+        {.name = "I444P12", .layout = Layout::I444, .bits = 12, .alpha = false, .rgbOrder = false},
+        {.name = "I444A", .layout = Layout::I444, .bits = 8, .alpha = true, .rgbOrder = false},
+        {.name = "I444AP10", .layout = Layout::I444, .bits = 10, .alpha = true, .rgbOrder = false},
+        {.name = "I444AP12", .layout = Layout::I444, .bits = 12, .alpha = true, .rgbOrder = false},
+        {.name = "NV12", .layout = Layout::NV12, .bits = 8, .alpha = false, .rgbOrder = false},
+        {.name = "RGBA", .layout = Layout::RGB, .bits = 8, .alpha = true, .rgbOrder = true},
+        {.name = "RGBX", .layout = Layout::RGB, .bits = 8, .alpha = false, .rgbOrder = true},
+        {.name = "BGRA", .layout = Layout::RGB, .bits = 8, .alpha = true, .rgbOrder = false},
+        {.name = "BGRX", .layout = Layout::RGB, .bits = 8, .alpha = false, .rgbOrder = false},
+    });
 
     int Divide(int value, int divisor) {
       return (value + divisor - 1) / divisor;
     }
 
+    // The YUV matrix of a frame. U and V swapped (Yvu) give R and B swapped.
+    const libyuv::YuvConstants *YuvMatrix(const std::string &matrix, bool fullRange, bool swapped) {
+      if (matrix == "bt709") {
+        if (swapped) {
+          return fullRange ? &libyuv::kYvuF709Constants : &libyuv::kYvuH709Constants;
+        }
+        return fullRange ? &libyuv::kYuvF709Constants : &libyuv::kYuvH709Constants;
+      }
+      if (matrix == "bt2020-ncl") {
+        if (swapped) {
+          return fullRange ? &libyuv::kYvuV2020Constants : &libyuv::kYvu2020Constants;
+        }
+        return fullRange ? &libyuv::kYuvV2020Constants : &libyuv::kYuv2020Constants;
+      }
+      if (swapped) {
+        return fullRange ? &libyuv::kYvuJPEGConstants : &libyuv::kYvuI601Constants;
+      }
+      return fullRange ? &libyuv::kYuvJPEGConstants : &libyuv::kYuvI601Constants;
+    }
+
+    // the libyuv conversions of the planar layouts
+    auto AlphaToArgb(Layout layout) {
+      switch (layout) {
+      case Layout::I420:
+        return libyuv::I420AlphaToARGBMatrix;
+      case Layout::I422:
+        return libyuv::I422AlphaToARGBMatrix;
+      default:
+        return libyuv::I444AlphaToARGBMatrix;
+      }
+    }
+
+    auto ToArgb(Layout layout) {
+      switch (layout) {
+      case Layout::I420:
+        return libyuv::I420ToARGBMatrix;
+      case Layout::I422:
+        return libyuv::I422ToARGBMatrix;
+      default:
+        return libyuv::I444ToARGBMatrix;
+      }
+    }
+
+    auto ToI420(Layout layout) {
+      switch (layout) {
+      case Layout::I420:
+        return libyuv::I420Copy;
+      case Layout::I422:
+        return libyuv::I422ToI420;
+      default:
+        return libyuv::I444ToI420;
+      }
+    }
+
+    // opaque alpha in the 4th byte of each pixel
+    void FillOpaque(uint8_t *dst, size_t stride, int width, int height) {
+      for (int row = 0; row < height; ++row) {
+        auto *pixel = dst + (row * stride) + 3;
+        for (int column = 0; column < width; ++column, pixel += 4) {
+          *pixel = kOpaque;
+        }
+      }
+    }
+
   } // namespace
 
   void VideoFrameBuffer::Init(pybind11::module &m) {
@@ -69,7 +150,7 @@ namespace python_webrtc {
   }
 
   const PixelFormat &PixelFormat::Parse(const std::string &name) {
-    for (const auto &format: FORMATS) {
+    for (const auto &format : FORMATS) {
       if (name == format.name) {
         return format;
       }
@@ -79,20 +160,23 @@ namespace python_webrtc {
 
   std::vector<PixelFormat::Plane> PixelFormat::Planes() const {
     switch (layout) {
-      case Layout::NV12:
-        return {{1, 1, 1}, {2, 2, 2}};
-      case Layout::RGB:
-        return {{4, 1, 1}};
-      default: {
-        int bytes = bits > 8 ? 2 : 1;
-        int x = layout == Layout::I444 ? 1 : 2;
-        int y = layout == Layout::I420 ? 2 : 1;
-        std::vector<Plane> planes = {{bytes, 1, 1}, {bytes, x, y}, {bytes, x, y}};
-        if (alpha) {
-          planes.push_back({bytes, 1, 1});
-        }
-        return planes;
+    case Layout::NV12:
+      return {{.sampleBytes = 1, .subsamplingX = 1, .subsamplingY = 1},
+              {.sampleBytes = 2, .subsamplingX = 2, .subsamplingY = 2}};
+    case Layout::RGB:
+      return {{.sampleBytes = 4, .subsamplingX = 1, .subsamplingY = 1}};
+    default: {
+      const int bytes = bits > kEightBit ? 2 : 1;
+      const int x = layout == Layout::I444 ? 1 : 2;
+      const int y = layout == Layout::I420 ? 2 : 1;
+      std::vector<Plane> planes = {{.sampleBytes = bytes, .subsamplingX = 1, .subsamplingY = 1},
+                                   {.sampleBytes = bytes, .subsamplingX = x, .subsamplingY = y},
+                                   {.sampleBytes = bytes, .subsamplingX = x, .subsamplingY = y}};
+      if (alpha) {
+        planes.push_back({.sampleBytes = bytes, .subsamplingX = 1, .subsamplingY = 1});
       }
+      return planes;
+    }
     }
   }
 
@@ -104,8 +188,8 @@ namespace python_webrtc {
     return Divide(height, subsamplingY);
   }
 
-  std::shared_ptr<VideoFrameBuffer> VideoFrameBuffer::FromWebrtc(
-      webrtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer) {
+  std::shared_ptr<VideoFrameBuffer>
+  VideoFrameBuffer::FromWebrtc(webrtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer) {
     using Type = webrtc::VideoFrameBuffer::Type;
     std::shared_ptr<VideoFrameBuffer> result;
     auto wrapYuv = [&](const char *name, const webrtc::PlanarYuv8Buffer *planes) {
@@ -114,36 +198,36 @@ namespace python_webrtc {
       result->_stride = {planes->StrideY(), planes->StrideU(), planes->StrideV(), 0};
     };
     switch (buffer->type()) {
-      case Type::kI420A: {
-        auto planes = buffer->GetI420A();
-        wrapYuv("I420A", planes);
-        result->_data[3] = planes->DataA();
-        result->_stride[3] = planes->StrideA();
-        break;
-      }
-      case Type::kI422:
-        wrapYuv("I422", buffer->GetI422());
-        break;
-      case Type::kI444:
-        wrapYuv("I444", buffer->GetI444());
-        break;
-      case Type::kNV12: {
-        auto planes = buffer->GetNV12();
-        result.reset(new VideoFrameBuffer(PixelFormat::Parse("NV12"), buffer->width(), buffer->height()));
-        result->_data = {planes->DataY(), planes->DataUV(), nullptr, nullptr};
-        result->_stride = {planes->StrideY(), planes->StrideUV(), 0, 0};
-        break;
-      }
-      default:
-        if (buffer->type() != Type::kI420) {
-          // native or high bit depth
-          buffer = buffer->ToI420();
-          if (!buffer) {
-            throw std::runtime_error("The frame can't be converted to I420");
-          }
+    case Type::kI420A: {
+      const auto *planes = buffer->GetI420A();
+      wrapYuv("I420A", planes);
+      result->_data[3] = planes->DataA();
+      result->_stride[3] = planes->StrideA();
+      break;
+    }
+    case Type::kI422:
+      wrapYuv("I422", buffer->GetI422());
+      break;
+    case Type::kI444:
+      wrapYuv("I444", buffer->GetI444());
+      break;
+    case Type::kNV12: {
+      const auto *planes = buffer->GetNV12();
+      result.reset(new VideoFrameBuffer(PixelFormat::Parse("NV12"), buffer->width(), buffer->height()));
+      result->_data = {planes->DataY(), planes->DataUV(), nullptr, nullptr};
+      result->_stride = {planes->StrideY(), planes->StrideUV(), 0, 0};
+      break;
+    }
+    default:
+      if (buffer->type() != Type::kI420) {
+        // native or high bit depth
+        buffer = buffer->ToI420();
+        if (!buffer) {
+          throw std::runtime_error("The frame can't be converted to I420");
         }
-        wrapYuv("I420", buffer->GetI420());
-        break;
+      }
+      wrapYuv("I420", buffer->GetI420());
+      break;
     }
     result->_webrtc = std::move(buffer);
     return result;
@@ -162,7 +246,7 @@ namespace python_webrtc {
     }
 
     auto info = ContiguousBuffer(data);
-    auto source = static_cast<const uint8_t *>(info.ptr);
+    const auto *source = static_cast<const uint8_t *>(info.ptr);
     auto sourceSize = static_cast<size_t>(info.size * info.itemsize);
 
     std::shared_ptr<VideoFrameBuffer> result(new VideoFrameBuffer(format, width, height));
@@ -174,7 +258,7 @@ namespace python_webrtc {
       result->_stride[i] = planes[i].Columns(width) * planes[i].sampleBytes;
       rows[i] = planes[i].Rows(height);
       auto [offset, stride] = layout[i];
-      if (stride < static_cast<size_t>(result->_stride[i]) ||
+      if (std::cmp_less(stride, result->_stride[i]) ||
           !RowsFit(offset, stride, rows[i], result->_stride[i], sourceSize)) {
         throw pybind11::value_error("The layout doesn't fit in the data");
       }
@@ -183,12 +267,13 @@ namespace python_webrtc {
     result->_owned = std::make_shared<std::vector<uint8_t>>(total);
 
     {
-      gil_release release;
+      const gil_release release;
       for (size_t i = 0; i < planes.size(); ++i) {
         auto [offset, stride] = layout[i];
-        size_t rowBytes = result->_stride[i];
+        const size_t rowBytes = result->_stride[i];
         for (size_t row = 0; row < rows[i]; ++row) {
-          std::memcpy(result->_owned->data() + offsets[i] + row * rowBytes, source + offset + row * stride, rowBytes);
+          std::memcpy(result->_owned->data() + offsets[i] + (row * rowBytes), source + offset + (row * stride),
+                      rowBytes);
         }
       }
     }
@@ -209,7 +294,7 @@ namespace python_webrtc {
       // I420A, I420AP10...
       name.erase(4, 1);
     }
-    std::shared_ptr<VideoFrameBuffer> result(new VideoFrameBuffer(*this));
+    std::shared_ptr<VideoFrameBuffer> result = std::make_shared<VideoFrameBuffer>(*this);
     result->_format = &PixelFormat::Parse(name);
     if (_format->layout != Layout::RGB) {
       result->_data[3] = nullptr;
@@ -221,34 +306,35 @@ namespace python_webrtc {
   void VideoFrameBuffer::CopyPlanes(const pybind11::buffer &destination, const std::vector<PlaneCopy> &copies) const {
     auto info = ContiguousBuffer(destination, true);
     auto size = static_cast<size_t>(info.size * info.itemsize);
-    auto target = static_cast<uint8_t *>(info.ptr);
+    auto *target = static_cast<uint8_t *>(info.ptr);
     auto planes = _format->Planes();
     if (copies.size() != planes.size()) {
       throw pybind11::value_error("One copy per plane is needed");
     }
     for (size_t i = 0; i < planes.size(); ++i) {
       auto [leftBytes, top, rowBytes, rows, offset, stride] = copies[i];
-      size_t planeRows = planes[i].Rows(_height);
-      size_t planeRowBytes = static_cast<size_t>(planes[i].Columns(_width)) * planes[i].sampleBytes;
+      const size_t planeRows = planes[i].Rows(_height);
+      const size_t planeRowBytes = static_cast<size_t>(planes[i].Columns(_width)) * planes[i].sampleBytes;
       if (rows > 0 && rowBytes > 0 &&
           (top > planeRows || rows > planeRows - top || leftBytes > planeRowBytes ||
-           rowBytes > planeRowBytes - leftBytes || stride < rowBytes || !RowsFit(offset, stride, rows, rowBytes, size))) {
+           rowBytes > planeRowBytes - leftBytes || stride < rowBytes ||
+           !RowsFit(offset, stride, rows, rowBytes, size))) {
         throw pybind11::value_error("The copy is out of the bounds of the frame or of the destination");
       }
     }
 
-    gil_release release;
+    const gil_release release;
     for (size_t i = 0; i < planes.size(); ++i) {
       auto [leftBytes, top, rowBytes, rows, offset, stride] = copies[i];
       for (size_t row = 0; row < rows && rowBytes > 0; ++row) {
-        std::memcpy(target + offset + row * stride, _data[i] + (top + row) * _stride[i] + leftBytes, rowBytes);
+        std::memcpy(target + offset + (row * stride), _data[i] + ((top + row) * _stride[i]) + leftBytes, rowBytes);
       }
     }
   }
 
   VideoFrameBuffer::EightBit VideoFrameBuffer::ToEightBit() const {
     EightBit result;
-    if (_format->bits == 8) {
+    if (_format->bits == kEightBit) {
       result.data = _data;
       result.stride = _stride;
       return result;
@@ -263,11 +349,12 @@ namespace python_webrtc {
     }
     result.storage.resize(total);
     // the samples are in the low bits of 16: scaled down to 8 (x * scale >> 16)
-    int scale = 1 << (24 - _format->bits);
+    const int scale = 1 << (24 - _format->bits);
     for (size_t i = 0; i < planes.size(); ++i) {
-      auto target = result.storage.data() + offsets[i];
-      libyuv::Convert16To8Plane(reinterpret_cast<const uint16_t *>(_data[i]), _stride[i] / 2, target,
-                                result.stride[i], scale, result.stride[i], planes[i].Rows(_height));
+      auto *target = result.storage.data() + offsets[i];
+      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast): deeper samples are 16-bit, stored as bytes
+      libyuv::Convert16To8Plane(reinterpret_cast<const uint16_t *>(_data[i]), _stride[i] / 2, target, result.stride[i],
+                                scale, result.stride[i], planes[i].Rows(_height));
       result.data[i] = target;
     }
     return result;
@@ -285,94 +372,75 @@ namespace python_webrtc {
     }
     auto info = ContiguousBuffer(destination, true);
     auto size = static_cast<size_t>(info.size * info.itemsize);
-    if (stride < static_cast<size_t>(width) * 4 || !RowsFit(offset, stride, height, static_cast<size_t>(width) * 4, size)) {
+    if (stride < static_cast<size_t>(width) * 4 ||
+        !RowsFit(offset, stride, height, static_cast<size_t>(width) * 4, size)) {
       throw pybind11::value_error("The destination is too small");
     }
-    auto dst = static_cast<uint8_t *>(info.ptr) + offset;
+    auto *dst = static_cast<uint8_t *>(info.ptr) + offset;
     auto dstStride = static_cast<int>(stride);
-    bool rgbOrder = format.rgbOrder;
+    const bool rgbOrder = format.rgbOrder;
     // alpha is kept when both the frame and the format have it, opaque otherwise
-    bool alpha = format.alpha && _format->alpha;
+    const bool alpha = format.alpha && _format->alpha;
 
-    // the YUV matrix of the frame: U and V swapped (Yvu) give R and B swapped
-    const libyuv::YuvConstants *yuv = fullRange ? &libyuv::kYuvJPEGConstants : &libyuv::kYuvI601Constants;
-    const libyuv::YuvConstants *yvu = fullRange ? &libyuv::kYvuJPEGConstants : &libyuv::kYvuI601Constants;
-    if (matrix == "bt709") {
-      yuv = fullRange ? &libyuv::kYuvF709Constants : &libyuv::kYuvH709Constants;
-      yvu = fullRange ? &libyuv::kYvuF709Constants : &libyuv::kYvuH709Constants;
-    } else if (matrix == "bt2020-ncl") {
-      yuv = fullRange ? &libyuv::kYuvV2020Constants : &libyuv::kYuv2020Constants;
-      yvu = fullRange ? &libyuv::kYvuV2020Constants : &libyuv::kYvu2020Constants;
-    }
-    auto constants = rgbOrder ? yvu : yuv;
+    const auto *constants = YuvMatrix(matrix, fullRange, rgbOrder);
 
-    gil_release release;
+    const gil_release release;
     auto planes = _format->Planes();
     auto source = ToEightBit();
     auto plane = [&](int i) {
       // high bit depth planes are 8-bit now
-      int sampleBytes = _format->bits == 8 ? planes[i].sampleBytes : 1;
-      return source.data[i] + (y / planes[i].subsamplingY) * source.stride[i] +
-             (x / planes[i].subsamplingX) * sampleBytes;
+      const int sampleBytes = _format->bits == kEightBit ? planes[i].sampleBytes : 1;
+      return source.data[i] + (static_cast<std::ptrdiff_t>(y / planes[i].subsamplingY) * source.stride[i]) +
+             (static_cast<std::ptrdiff_t>(x / planes[i].subsamplingX) * sampleBytes);
     };
     // libyuv writes B, G, R, A (its ARGB): swapping U and V swaps R and B
-    int u = rgbOrder ? 2 : 1;
-    int v = rgbOrder ? 1 : 2;
+    const int u = rgbOrder ? 2 : 1;
+    const int v = rgbOrder ? 1 : 2;
 
     int result = 0;
     switch (_format->layout) {
-      case Layout::I420:
-      case Layout::I422:
-      case Layout::I444: {
-        bool i420 = _format->layout == Layout::I420;
-        bool i422 = _format->layout == Layout::I422;
-        if (alpha) {
-          auto convert = i420   ? libyuv::I420AlphaToARGBMatrix
-                         : i422 ? libyuv::I422AlphaToARGBMatrix
-                                : libyuv::I444AlphaToARGBMatrix;
-          result = convert(plane(0), source.stride[0], plane(u), source.stride[u], plane(v), source.stride[v],
-                           plane(3), source.stride[3], dst, dstStride, constants, width, height, 0);
-        } else {
-          auto convert = i420 ? libyuv::I420ToARGBMatrix : i422 ? libyuv::I422ToARGBMatrix : libyuv::I444ToARGBMatrix;
-          result = convert(plane(0), source.stride[0], plane(u), source.stride[u], plane(v), source.stride[v], dst,
-                           dstStride, constants, width, height);
-        }
-        break;
+    case Layout::I420:
+    case Layout::I422:
+    case Layout::I444: {
+      if (alpha) {
+        result = AlphaToArgb(_format->layout)(plane(0), source.stride[0], plane(u), source.stride[u], plane(v),
+                                              source.stride[v], plane(3), source.stride[3], dst, dstStride, constants,
+                                              width, height, 0);
+      } else {
+        result = ToArgb(_format->layout)(plane(0), source.stride[0], plane(u), source.stride[u], plane(v),
+                                         source.stride[v], dst, dstStride, constants, width, height);
       }
-      case Layout::NV12: {
-        // NV21 is NV12 with U and V swapped
-        auto convert = rgbOrder ? libyuv::NV21ToARGBMatrix : libyuv::NV12ToARGBMatrix;
-        result = convert(plane(0), source.stride[0], plane(1), source.stride[1], dst, dstStride, constants, width,
-                         height);
-        break;
+      break;
+    }
+    case Layout::NV12: {
+      // NV21 is NV12 with U and V swapped
+      auto convert = rgbOrder ? libyuv::NV21ToARGBMatrix : libyuv::NV12ToARGBMatrix;
+      result =
+          convert(plane(0), source.stride[0], plane(1), source.stride[1], dst, dstStride, constants, width, height);
+      break;
+    }
+    case Layout::RGB:
+      if (_format->rgbOrder == rgbOrder) {
+        result = libyuv::ARGBCopy(plane(0), source.stride[0], dst, dstStride, width, height);
+      } else {
+        // swapping R and B is its own inverse
+        result = libyuv::ARGBToABGR(plane(0), source.stride[0], dst, dstStride, width, height);
       }
-      case Layout::RGB:
-        if (_format->rgbOrder == rgbOrder) {
-          result = libyuv::ARGBCopy(plane(0), source.stride[0], dst, dstStride, width, height);
-        } else {
-          // swapping R and B is its own inverse
-          result = libyuv::ARGBToABGR(plane(0), source.stride[0], dst, dstStride, width, height);
-        }
-        break;
+      break;
     }
     if (result != 0) {
       throw std::runtime_error("The frame can't be converted");
     }
     if (!alpha) {
       // opaque, like a conversion from YUV without alpha
-      for (int row = 0; row < height; ++row) {
-        auto pixel = dst + row * stride + 3;
-        for (int column = 0; column < width; ++column, pixel += 4) {
-          *pixel = 255;
-        }
-      }
+      FillOpaque(dst, stride, width, height);
     }
   }
 
   webrtc::scoped_refptr<webrtc::VideoFrameBuffer> VideoFrameBuffer::ToWebrtc() const {
     const auto &format = *_format;
     // a received I420A buffer without its alpha is wrapped again as I420
-    bool alphaDropped = !format.alpha && _webrtc && _webrtc->type() == webrtc::VideoFrameBuffer::Type::kI420A;
+    const bool alphaDropped = !format.alpha && _webrtc && _webrtc->type() == webrtc::VideoFrameBuffer::Type::kI420A;
     if (_webrtc && !alphaDropped) {
       return _webrtc;
     }
@@ -393,38 +461,35 @@ namespace python_webrtc {
               buffer->StrideU(), buffer->MutableDataV(), buffer->StrideV(), _width, _height);
       return buffer;
     }
-    if (format.bits == 8) {
+    if (format.bits == kEightBit) {
       switch (format.layout) {
-        case Layout::I420:
-          if (format.alpha) {
-            return webrtc::WrapI420ABuffer(_width, _height, _data[0], _stride[0], _data[1], _stride[1], _data[2],
-                                           _stride[2], _data[3], _stride[3], keep);
-          }
-          return webrtc::WrapI420Buffer(_width, _height, _data[0], _stride[0], _data[1], _stride[1], _data[2],
+      case Layout::I420:
+        if (format.alpha) {
+          return webrtc::WrapI420ABuffer(_width, _height, _data[0], _stride[0], _data[1], _stride[1], _data[2],
+                                         _stride[2], _data[3], _stride[3], keep);
+        }
+        return webrtc::WrapI420Buffer(_width, _height, _data[0], _stride[0], _data[1], _stride[1], _data[2], _stride[2],
+                                      keep);
+      case Layout::I422:
+        if (!format.alpha) {
+          return webrtc::WrapI422Buffer(_width, _height, _data[0], _stride[0], _data[1], _stride[1], _data[2],
+                                        _stride[2], keep);
+        }
+        break;
+      default:
+        if (!format.alpha) {
+          return webrtc::WrapI444Buffer(_width, _height, _data[0], _stride[0], _data[1], _stride[1], _data[2],
                                         _stride[2], keep);
-        case Layout::I422:
-          if (!format.alpha) {
-            return webrtc::WrapI422Buffer(_width, _height, _data[0], _stride[0], _data[1], _stride[1], _data[2],
-                                          _stride[2], keep);
-          }
-          break;
-        default:
-          if (!format.alpha) {
-            return webrtc::WrapI444Buffer(_width, _height, _data[0], _stride[0], _data[1], _stride[1], _data[2],
-                                          _stride[2], keep);
-          }
-          break;
+        }
+        break;
       }
     }
     // high bit depth, or alpha libwebrtc has no buffer for: 8-bit I420 without alpha
     auto buffer = webrtc::I420Buffer::Create(_width, _height);
     auto source = ToEightBit();
-    auto convert = format.layout == Layout::I420   ? libyuv::I420Copy
-                   : format.layout == Layout::I422 ? libyuv::I422ToI420
-                                                   : libyuv::I444ToI420;
-    convert(source.data[0], source.stride[0], source.data[1], source.stride[1], source.data[2], source.stride[2],
-            buffer->MutableDataY(), buffer->StrideY(), buffer->MutableDataU(), buffer->StrideU(),
-            buffer->MutableDataV(), buffer->StrideV(), _width, _height);
+    ToI420(format.layout)(source.data[0], source.stride[0], source.data[1], source.stride[1], source.data[2],
+                          source.stride[2], buffer->MutableDataY(), buffer->StrideY(), buffer->MutableDataU(),
+                          buffer->StrideU(), buffer->MutableDataV(), buffer->StrideV(), _width, _height);
     return buffer;
   }
 
diff --git a/python-webrtc/cpp/src/media/video_frame_buffer.h b/python-webrtc/cpp/src/media/video_frame_buffer.h
index 80a4174..81cfb9b 100644
--- a/python-webrtc/cpp/src/media/video_frame_buffer.h
+++ b/python-webrtc/cpp/src/media/video_frame_buffer.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MEDIA_VIDEO_FRAME_BUFFER_H_
+#define PYTHON_WEBRTC_MEDIA_VIDEO_FRAME_BUFFER_H_
 
 #include <array>
 #include <cstdint>
@@ -25,7 +26,7 @@ namespace python_webrtc {
 
   // A pixel format of VideoFrame (WebCodecs VideoPixelFormat)
   struct PixelFormat {
-    enum class Layout { I420, I422, I444, NV12, RGB };
+    enum class Layout : uint8_t { I420, I422, I444, NV12, RGB };
 
     const char *name;
     Layout layout;
@@ -40,12 +41,12 @@ namespace python_webrtc {
       int subsamplingY;
 
       // samples in a row of the plane of a frame this wide
-      int Columns(int width) const;
+      [[nodiscard]] int Columns(int width) const;
 
-      int Rows(int height) const;
+      [[nodiscard]] int Rows(int height) const;
     };
 
-    std::vector<Plane> Planes() const;
+    [[nodiscard]] std::vector<Plane> Planes() const;
 
     static const PixelFormat &Parse(const std::string &name);
   };
@@ -68,24 +69,24 @@ namespace python_webrtc {
                                                       const pybind11::buffer &data,
                                                       const std::vector<SourceLayout> &layout);
 
-    std::string GetFormat() const { return _format->name; }
+    [[nodiscard]] std::string GetFormat() const { return _format->name; }
 
-    int width() const { return _width; }
+    [[nodiscard]] int width() const { return _width; }
 
-    int height() const { return _height; }
+    [[nodiscard]] int height() const { return _height; }
 
     // the same planes without the alpha one (I420A to I420, RGBA to RGBX...)
-    std::shared_ptr<VideoFrameBuffer> WithoutAlpha() const;
+    [[nodiscard]] std::shared_ptr<VideoFrameBuffer> WithoutAlpha() const;
 
     // copies rows of the planes into the destination, at the given place of each
     void CopyPlanes(const pybind11::buffer &destination, const std::vector<PlaneCopy> &copies) const;
 
     // converts a rect into an RGB format, with the YUV matrix (VideoMatrixCoefficients) and range of the frame
-    void ConvertTo(const pybind11::buffer &destination, const std::string &format, int x, int y, int width,
-                   int height, size_t offset, size_t stride, const std::string &matrix, bool fullRange) const;
+    void ConvertTo(const pybind11::buffer &destination, const std::string &format, int x, int y, int width, int height,
+                   size_t offset, size_t stride, const std::string &matrix, bool fullRange) const;
 
     // the frame as libwebrtc takes it: its planes when they're in a format libwebrtc has, converted to I420 if not
-    webrtc::scoped_refptr<webrtc::VideoFrameBuffer> ToWebrtc() const;
+    [[nodiscard]] webrtc::scoped_refptr<webrtc::VideoFrameBuffer> ToWebrtc() const;
 
   private:
     VideoFrameBuffer(const PixelFormat &format, int width, int height)
@@ -98,7 +99,7 @@ namespace python_webrtc {
       std::vector<uint8_t> storage;
     };
 
-    EightBit ToEightBit() const;
+    [[nodiscard]] EightBit ToEightBit() const;
 
     const PixelFormat *_format;
     int _width;
@@ -113,3 +114,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MEDIA_VIDEO_FRAME_BUFFER_H_
diff --git a/python-webrtc/cpp/src/media/wakeup.h b/python-webrtc/cpp/src/media/wakeup.h
index 5b6aecf..17a0a90 100644
--- a/python-webrtc/cpp/src/media/wakeup.h
+++ b/python-webrtc/cpp/src/media/wakeup.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MEDIA_WAKEUP_H_
+#define PYTHON_WEBRTC_MEDIA_WAKEUP_H_
 
 #include <condition_variable>
 #include <deque>
@@ -32,10 +33,10 @@ namespace python_webrtc {
     static void Post(std::weak_ptr<Wakeable> target) {
       auto &wakeup = Instance();
       {
-        std::lock_guard<std::mutex> lock(wakeup._mutex);
-        if (wakeup._generation != forks.load()) {
+        const std::scoped_lock lock(wakeup._mutex);
+        if (wakeup._generation != Forks().load()) {
           // the child of a fork: the thread is gone, and so are the objects of the parent
-          wakeup._generation = forks.load();
+          wakeup._generation = Forks().load();
           wakeup._targets.clear();
           std::thread([&wakeup]() { wakeup.Run(); }).detach();
         }
@@ -45,18 +46,14 @@ namespace python_webrtc {
     }
 
     // held across a fork, so the child doesn't get it locked by a thread it doesn't have
-    static void LockForFork() {
-      Instance()._mutex.lock();
-    }
+    static void LockForFork() { Instance()._mutex.lock(); }
 
-    static void UnlockAfterFork() {
-      Instance()._mutex.unlock();
-    }
+    static void UnlockAfterFork() { Instance()._mutex.unlock(); }
 
   private:
     static Wakeup &Instance() {
       // never destroyed: its thread may run while the process exits
-      static auto wakeup = new Wakeup();
+      static auto *wakeup = new Wakeup();
       return *wakeup;
     }
 
@@ -82,9 +79,11 @@ namespace python_webrtc {
 
     std::mutex _mutex;
     // of the process the thread runs in (see forks)
-    int _generation = forks.load();
+    int _generation = Forks().load();
     std::condition_variable _posted;
     std::deque<std::weak_ptr<Wakeable>> _targets;
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MEDIA_WAKEUP_H_
diff --git a/python-webrtc/cpp/src/models/models.cpp b/python-webrtc/cpp/src/models/models.cpp
index 4a18e44..293257c 100644
--- a/python-webrtc/cpp/src/models/models.cpp
+++ b/python-webrtc/cpp/src/models/models.cpp
@@ -7,13 +7,13 @@
 
 #include "models.h"
 
-#include "python_webrtc/rtc_session_description.h"
-#include "python_webrtc/rtc_ice_candidate.h"
-#include "python_webrtc/rtc_configuration.h"
 #include "python_webrtc/rtc_certificate.h"
+#include "python_webrtc/rtc_configuration.h"
+#include "python_webrtc/rtc_ice_candidate.h"
+#include "python_webrtc/rtc_session_description.h"
 
-#include "webrtc/rtp_transceiver_init.h"
 #include "webrtc/rtp_parameters.h"
+#include "webrtc/rtp_transceiver_init.h"
 
 namespace python_webrtc {
 
@@ -27,4 +27,4 @@ namespace python_webrtc {
     bindRtpParameters(m);
     bindRtpTransceiverInit(m);
   }
-}
+} // namespace python_webrtc
diff --git a/python-webrtc/cpp/src/models/models.h b/python-webrtc/cpp/src/models/models.h
index c62b37e..885a172 100644
--- a/python-webrtc/cpp/src/models/models.h
+++ b/python-webrtc/cpp/src/models/models.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MODELS_MODELS_H_
+#define PYTHON_WEBRTC_MODELS_MODELS_H_
 
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
@@ -17,4 +18,6 @@ namespace python_webrtc {
     static void Init(pybind11::module &m);
   };
 
-}
+} // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MODELS_MODELS_H_
diff --git a/python-webrtc/cpp/src/models/python_webrtc/rtc_certificate.cpp b/python-webrtc/cpp/src/models/python_webrtc/rtc_certificate.cpp
index fd1c77f..04ca5c0 100644
--- a/python-webrtc/cpp/src/models/python_webrtc/rtc_certificate.cpp
+++ b/python-webrtc/cpp/src/models/python_webrtc/rtc_certificate.cpp
@@ -27,8 +27,8 @@ namespace python_webrtc {
         .def("fingerprints", &RTCCertificate::Fingerprints);
   }
 
-  std::shared_ptr<RTCCertificate> RTCCertificate::Generate(
-      const std::string &keyType, int modulusLength, int publicExponent, std::optional<uint64_t> expiresMs) {
+  std::shared_ptr<RTCCertificate> RTCCertificate::Generate(const std::string &keyType, int modulusLength,
+                                                           int publicExponent, std::optional<uint64_t> expiresMs) {
     auto params = keyType == "rsa" ? webrtc::KeyParams::RSA(modulusLength, publicExponent) : webrtc::KeyParams::ECDSA();
     if (!params.IsValid()) {
       return nullptr;
@@ -42,7 +42,7 @@ namespace python_webrtc {
     auto fingerprint = webrtc::SSLFingerprint::CreateFromCertificate(*_certificate);
     if (fingerprint) {
       auto value = fingerprint->GetRfc4572Fingerprint();
-      std::transform(value.begin(), value.end(), value.begin(), [](unsigned char c) { return std::tolower(c); });
+      std::ranges::transform(value, value.begin(), [](unsigned char character) { return std::tolower(character); });
       fingerprints.emplace_back(fingerprint->algorithm, value);
     }
     return fingerprints;
diff --git a/python-webrtc/cpp/src/models/python_webrtc/rtc_certificate.h b/python-webrtc/cpp/src/models/python_webrtc/rtc_certificate.h
index c93fa8d..020d77f 100644
--- a/python-webrtc/cpp/src/models/python_webrtc/rtc_certificate.h
+++ b/python-webrtc/cpp/src/models/python_webrtc/rtc_certificate.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MODELS_PYTHON_WEBRTC_RTC_CERTIFICATE_H_
+#define PYTHON_WEBRTC_MODELS_PYTHON_WEBRTC_RTC_CERTIFICATE_H_
 
 #include <memory>
 #include <optional>
@@ -28,19 +29,21 @@ namespace python_webrtc {
     static void Init(pybind11::module &m);
 
     // "rsa", or ECDSA (P-256) for any other key type; null if the key can't be generated
-    static std::shared_ptr<RTCCertificate> Generate(
-        const std::string &keyType, int modulusLength, int publicExponent, std::optional<uint64_t> expiresMs);
+    static std::shared_ptr<RTCCertificate> Generate(const std::string &keyType, int modulusLength, int publicExponent,
+                                                    std::optional<uint64_t> expiresMs);
 
-    webrtc::scoped_refptr<webrtc::RTCCertificate> certificate() const { return _certificate; }
+    [[nodiscard]] webrtc::scoped_refptr<webrtc::RTCCertificate> certificate() const { return _certificate; }
 
     // milliseconds since the epoch
-    uint64_t Expires() const { return _certificate->Expires(); }
+    [[nodiscard]] uint64_t Expires() const { return _certificate->Expires(); }
 
     // (algorithm, lowercase hex with colons)
-    std::vector<std::pair<std::string, std::string>> Fingerprints() const;
+    [[nodiscard]] std::vector<std::pair<std::string, std::string>> Fingerprints() const;
 
   private:
     webrtc::scoped_refptr<webrtc::RTCCertificate> _certificate;
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MODELS_PYTHON_WEBRTC_RTC_CERTIFICATE_H_
diff --git a/python-webrtc/cpp/src/models/python_webrtc/rtc_configuration.cpp b/python-webrtc/cpp/src/models/python_webrtc/rtc_configuration.cpp
index a0b037b..b94c3c1 100644
--- a/python-webrtc/cpp/src/models/python_webrtc/rtc_configuration.cpp
+++ b/python-webrtc/cpp/src/models/python_webrtc/rtc_configuration.cpp
@@ -13,7 +13,7 @@ namespace python_webrtc {
 
   webrtc::PeerConnectionInterface::IceServers toIceServers(const std::vector<IceServerInit> &iceServers) {
     webrtc::PeerConnectionInterface::IceServers servers;
-    for (const auto &server: iceServers) {
+    for (const auto &server : iceServers) {
       webrtc::PeerConnectionInterface::IceServer iceServer;
       iceServer.urls = server.urls;
       iceServer.username = server.username.value_or("");
@@ -23,8 +23,8 @@ namespace python_webrtc {
     return servers;
   }
 
-  webrtc::PeerConnectionInterface::RTCConfiguration ConfigurationInit::Apply(
-      webrtc::PeerConnectionInterface::RTCConfiguration configuration) const {
+  webrtc::PeerConnectionInterface::RTCConfiguration
+  ConfigurationInit::Apply(webrtc::PeerConnectionInterface::RTCConfiguration configuration) const {
     configuration.servers = toIceServers(iceServers);
     configuration.type = iceTransportPolicy;
     configuration.bundle_policy = bundlePolicy;
@@ -34,7 +34,7 @@ namespace python_webrtc {
     configuration.crypto_options.srtp.cryptex_policy = rtpHeaderEncryptionPolicy;
     if (certificates) {
       configuration.certificates.clear();
-      for (const auto &certificate: *certificates) {
+      for (const auto &certificate : *certificates) {
         configuration.certificates.push_back(certificate->certificate());
       }
     }
diff --git a/python-webrtc/cpp/src/models/python_webrtc/rtc_configuration.h b/python-webrtc/cpp/src/models/python_webrtc/rtc_configuration.h
index 3da0166..7ad7099 100644
--- a/python-webrtc/cpp/src/models/python_webrtc/rtc_configuration.h
+++ b/python-webrtc/cpp/src/models/python_webrtc/rtc_configuration.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MODELS_PYTHON_WEBRTC_RTC_CONFIGURATION_H_
+#define PYTHON_WEBRTC_MODELS_PYTHON_WEBRTC_RTC_CONFIGURATION_H_
 
 #include <optional>
 #include <string>
@@ -16,8 +17,8 @@
 
 #include <api/peer_connection_interface.h>
 
-#include "rtc_certificate.h"
 #include "../../enums/enums.h"
+#include "rtc_certificate.h"
 
 namespace python_webrtc {
 
@@ -47,8 +48,8 @@ namespace python_webrtc {
     std::optional<std::vector<std::shared_ptr<RTCCertificate>>> certificates;
 
     // the libwebrtc configuration, on top of the one the connection has (for its settings that can't change)
-    [[nodiscard]] webrtc::PeerConnectionInterface::RTCConfiguration Apply(
-        webrtc::PeerConnectionInterface::RTCConfiguration configuration) const;
+    [[nodiscard]] webrtc::PeerConnectionInterface::RTCConfiguration
+    Apply(webrtc::PeerConnectionInterface::RTCConfiguration configuration) const;
 
     static void Init(pybind11::module &m);
   };
@@ -56,3 +57,5 @@ namespace python_webrtc {
   webrtc::PeerConnectionInterface::IceServers toIceServers(const std::vector<IceServerInit> &iceServers);
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MODELS_PYTHON_WEBRTC_RTC_CONFIGURATION_H_
diff --git a/python-webrtc/cpp/src/models/python_webrtc/rtc_ice_candidate.cpp b/python-webrtc/cpp/src/models/python_webrtc/rtc_ice_candidate.cpp
index 0313ea3..f6cdcab 100644
--- a/python-webrtc/cpp/src/models/python_webrtc/rtc_ice_candidate.cpp
+++ b/python-webrtc/cpp/src/models/python_webrtc/rtc_ice_candidate.cpp
@@ -11,34 +11,35 @@
 
 namespace python_webrtc {
 
-  static std::optional<std::string> optionalIfNonEmpty(const std::string &value) {
-    return value.empty() ? std::nullopt : std::optional<std::string>(value);
-  }
+  namespace {
+
+    std::optional<std::string> optionalIfNonEmpty(const std::string &value) {
+      return value.empty() ? std::nullopt : std::optional<std::string>(value);
+    }
+
+  } // namespace
 
   IceCandidateInit::IceCandidateInit(const webrtc::IceCandidate &iceCandidate)
-      : candidate(iceCandidate.ToString()),
-        sdpMid(iceCandidate.sdp_mid()),
+      : candidate(iceCandidate.ToString()), sdpMid(iceCandidate.sdp_mid()),
         sdpMLineIndex(iceCandidate.sdp_mline_index()),
         usernameFragment(optionalIfNonEmpty(iceCandidate.candidate().username())),
         url(optionalIfNonEmpty(iceCandidate.server_url())),
         relayProtocol(optionalIfNonEmpty(iceCandidate.candidate().relay_protocol())) {}
 
-  IceCandidateInit::IceCandidateInit(
-      std::string sdpMid, int sdpMLineIndex, std::optional<std::string> usernameFragment)
+  IceCandidateInit::IceCandidateInit(std::string sdpMid, int sdpMLineIndex, std::optional<std::string> usernameFragment)
       : sdpMid(std::move(sdpMid)), sdpMLineIndex(sdpMLineIndex), usernameFragment(std::move(usernameFragment)) {}
 
   void RTCIceCandidate::Init(pybind11::module &m) {
-    pybind11::class_<IceCandidateInit>(m, "IceCandidateInit")
-        .def("kwargs", [](const IceCandidateInit &init) {
-          pybind11::dict kwargs;
-          kwargs["candidate"] = init.candidate;
-          kwargs["sdp_mid"] = init.sdpMid;
-          kwargs["sdp_m_line_index"] = init.sdpMLineIndex;
-          kwargs["username_fragment"] = init.usernameFragment;
-          kwargs["url"] = init.url;
-          kwargs["relay_protocol"] = init.relayProtocol;
-          return kwargs;
-        });
+    pybind11::class_<IceCandidateInit>(m, "IceCandidateInit").def("kwargs", [](const IceCandidateInit &init) {
+      pybind11::dict kwargs;
+      kwargs["candidate"] = init.candidate;
+      kwargs["sdp_mid"] = init.sdpMid;
+      kwargs["sdp_m_line_index"] = init.sdpMLineIndex;
+      kwargs["username_fragment"] = init.usernameFragment;
+      kwargs["url"] = init.url;
+      kwargs["relay_protocol"] = init.relayProtocol;
+      return kwargs;
+    });
   }
 
 } // namespace python_webrtc
diff --git a/python-webrtc/cpp/src/models/python_webrtc/rtc_ice_candidate.h b/python-webrtc/cpp/src/models/python_webrtc/rtc_ice_candidate.h
index dbd395a..e43b2a3 100644
--- a/python-webrtc/cpp/src/models/python_webrtc/rtc_ice_candidate.h
+++ b/python-webrtc/cpp/src/models/python_webrtc/rtc_ice_candidate.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MODELS_PYTHON_WEBRTC_RTC_ICE_CANDIDATE_H_
+#define PYTHON_WEBRTC_MODELS_PYTHON_WEBRTC_RTC_ICE_CANDIDATE_H_
 
 #include <optional>
 #include <string>
@@ -37,3 +38,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MODELS_PYTHON_WEBRTC_RTC_ICE_CANDIDATE_H_
diff --git a/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description.cpp b/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description.cpp
index 9144702..d7adda9 100644
--- a/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description.cpp
+++ b/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description.cpp
@@ -7,15 +7,17 @@
 
 #include "rtc_session_description.h"
 
+#include <utility>
+
 namespace python_webrtc {
 
-  RTCSessionDescription::RTCSessionDescription(const RTCSessionDescriptionInit &init) : _init(init) {}
+  RTCSessionDescription::RTCSessionDescription(RTCSessionDescriptionInit init) : _init(std::move(init)) {}
 
-  webrtc::SdpType RTCSessionDescription::getType() {
+  webrtc::SdpType RTCSessionDescription::getType() const {
     return _init.type;
   }
 
-  std::string RTCSessionDescription::getSdp() {
+  std::string RTCSessionDescription::getSdp() const {
     return _init.sdp;
   }
 
diff --git a/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description.h b/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description.h
index d7d1c0a..55121da 100644
--- a/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description.h
+++ b/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MODELS_PYTHON_WEBRTC_RTC_SESSION_DESCRIPTION_H_
+#define PYTHON_WEBRTC_MODELS_PYTHON_WEBRTC_RTC_SESSION_DESCRIPTION_H_
 
 #include "rtc_session_description_init.h"
 
@@ -14,21 +15,23 @@ namespace python_webrtc {
   class RTCSessionDescription {
   public:
     // the init is required, as in the specification: its sdp is empty by default
-    explicit RTCSessionDescription(const RTCSessionDescriptionInit &rtcSessionDescriptionInit);
+    explicit RTCSessionDescription(RTCSessionDescriptionInit init);
 
     static void Init(pybind11::module &m);
 
-    static RTCSessionDescription Wrap(webrtc::SessionDescriptionInterface *);
+    static RTCSessionDescription Wrap(webrtc::SessionDescriptionInterface *description);
 
     [[nodiscard]] const RTCSessionDescriptionInit &init() const { return _init; }
 
-    webrtc::SdpType getType();
+    [[nodiscard]] webrtc::SdpType getType() const;
 
-    std::string getSdp();
+    [[nodiscard]] std::string getSdp() const;
 
   private:
     // not parsed: an invalid description is only rejected when it's set
     RTCSessionDescriptionInit _init;
   };
 
-} // namespace python_web_rtc
+} // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MODELS_PYTHON_WEBRTC_RTC_SESSION_DESCRIPTION_H_
diff --git a/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description_init.cpp b/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description_init.cpp
index e04ccdf..c0e8f2b 100644
--- a/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description_init.cpp
+++ b/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description_init.cpp
@@ -11,8 +11,8 @@ namespace python_webrtc {
 
   RTCSessionDescriptionInit::RTCSessionDescriptionInit() = default;
 
-  RTCSessionDescriptionInit::RTCSessionDescriptionInit(webrtc::SdpType type, std::string sdp) :
-      type(type), sdp(std::move(sdp)) {}
+  RTCSessionDescriptionInit::RTCSessionDescriptionInit(webrtc::SdpType type, std::string sdp)
+      : type(type), sdp(std::move(sdp)) {}
 
   void RTCSessionDescriptionInit::Init(pybind11::module &m) {
     pybind11::class_<RTCSessionDescriptionInit>(m, "RTCSessionDescriptionInit")
@@ -21,11 +21,11 @@ namespace python_webrtc {
         .def_readwrite("sdp", &RTCSessionDescriptionInit::sdp);
   }
 
-  RTCSessionDescriptionInit RTCSessionDescriptionInit::Wrap(webrtc::SessionDescriptionInterface *description) {
+  RTCSessionDescriptionInit RTCSessionDescriptionInit::Wrap(const webrtc::SessionDescriptionInterface *description) {
     std::string sdp;
     description->ToString(&sdp);
 
     return {description->GetType(), sdp};
   }
 
-}
+} // namespace python_webrtc
diff --git a/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description_init.h b/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description_init.h
index 95e4601..0559cc3 100644
--- a/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description_init.h
+++ b/python-webrtc/cpp/src/models/python_webrtc/rtc_session_description_init.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MODELS_PYTHON_WEBRTC_RTC_SESSION_DESCRIPTION_INIT_H_
+#define PYTHON_WEBRTC_MODELS_PYTHON_WEBRTC_RTC_SESSION_DESCRIPTION_INIT_H_
 
 #include <string>
 
@@ -24,10 +25,12 @@ namespace python_webrtc {
 
     static void Init(pybind11::module &m);
 
-    static RTCSessionDescriptionInit Wrap(webrtc::SessionDescriptionInterface *);
+    static RTCSessionDescriptionInit Wrap(const webrtc::SessionDescriptionInterface *description);
 
-    webrtc::SdpType type;
+    webrtc::SdpType type{};
     std::string sdp;
   };
 
-} //namespace python_webrtc
+} // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MODELS_PYTHON_WEBRTC_RTC_SESSION_DESCRIPTION_INIT_H_
diff --git a/python-webrtc/cpp/src/models/webrtc/rtp_parameters.cpp b/python-webrtc/cpp/src/models/webrtc/rtp_parameters.cpp
index e3aa961..483c856 100644
--- a/python-webrtc/cpp/src/models/webrtc/rtp_parameters.cpp
+++ b/python-webrtc/cpp/src/models/webrtc/rtp_parameters.cpp
@@ -21,13 +21,14 @@ namespace python_webrtc {
         .def_readwrite("kind", &webrtc::RtpCodec::kind)
         .def_readwrite("clockRate", &webrtc::RtpCodec::clock_rate)
         .def_readwrite("numChannels", &webrtc::RtpCodec::num_channels)
-        .def_property("parameters",
-                      [](const webrtc::RtpCodec &codec) {
-                        return std::map<std::string, std::string>(codec.parameters.begin(), codec.parameters.end());
-                      },
-                      [](webrtc::RtpCodec &codec, const std::map<std::string, std::string> &parameters) {
-                        codec.parameters = webrtc::CodecParameterMap(parameters);
-                      })
+        .def_property(
+            "parameters",
+            [](const webrtc::RtpCodec &codec) {
+              return std::map<std::string, std::string>(codec.parameters.begin(), codec.parameters.end());
+            },
+            [](webrtc::RtpCodec &codec, const std::map<std::string, std::string> &parameters) {
+              codec.parameters = webrtc::CodecParameterMap(parameters);
+            })
         .def_property_readonly("mimeType", &webrtc::RtpCodec::mime_type);
 
     pybind11::class_<webrtc::RtpCodecCapability, webrtc::RtpCodec>(m, "RtpCodecCapability")
@@ -41,28 +42,29 @@ namespace python_webrtc {
     pybind11::class_<webrtc::RtpExtension>(m, "RtpExtension")
         .def(pybind11::init<>())
         .def_readwrite("uri", &webrtc::RtpExtension::uri)
-        .def_property("id",
-                      [](const webrtc::RtpExtension &extension) { return extension.id.value(); },
-                      [](webrtc::RtpExtension &extension, int id) { extension.id = webrtc::RtpHeaderExtensionId(id); })
+        .def_property(
+            "id", [](const webrtc::RtpExtension &extension) { return extension.id.value(); },
+            [](webrtc::RtpExtension &extension, int id) { extension.id = webrtc::RtpHeaderExtensionId(id); })
         .def_readwrite("encrypt", &webrtc::RtpExtension::encrypt);
 
     pybind11::class_<webrtc::RtpHeaderExtensionCapability>(m, "RtpHeaderExtensionCapability")
         .def(pybind11::init<>())
         .def_readwrite("uri", &webrtc::RtpHeaderExtensionCapability::uri)
-        .def_property("preferredId",
-                      [](const webrtc::RtpHeaderExtensionCapability &capability) -> std::optional<int> {
-                        if (!capability.preferred_id) {
-                          return std::nullopt;
-                        }
-                        return capability.preferred_id->value();
-                      },
-                      [](webrtc::RtpHeaderExtensionCapability &capability, std::optional<int> id) {
-                        if (id) {
-                          capability.preferred_id = webrtc::RtpHeaderExtensionId(*id);
-                        } else {
-                          capability.preferred_id.reset();
-                        }
-                      })
+        .def_property(
+            "preferredId",
+            [](const webrtc::RtpHeaderExtensionCapability &capability) -> std::optional<int> {
+              if (!capability.preferred_id) {
+                return std::nullopt;
+              }
+              return capability.preferred_id->value();
+            },
+            [](webrtc::RtpHeaderExtensionCapability &capability, std::optional<int> id) {
+              if (id) {
+                capability.preferred_id = webrtc::RtpHeaderExtensionId(*id);
+              } else {
+                capability.preferred_id.reset();
+              }
+            })
         .def_readwrite("direction", &webrtc::RtpHeaderExtensionCapability::direction);
 
     pybind11::class_<webrtc::RtcpParameters>(m, "RtcpParameters")
diff --git a/python-webrtc/cpp/src/models/webrtc/rtp_parameters.h b/python-webrtc/cpp/src/models/webrtc/rtp_parameters.h
index 08cb6d5..854fbff 100644
--- a/python-webrtc/cpp/src/models/webrtc/rtp_parameters.h
+++ b/python-webrtc/cpp/src/models/webrtc/rtp_parameters.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MODELS_WEBRTC_RTP_PARAMETERS_H_
+#define PYTHON_WEBRTC_MODELS_WEBRTC_RTP_PARAMETERS_H_
 
 #include <pybind11/pybind11.h>
 
@@ -17,3 +18,5 @@ namespace python_webrtc {
   void bindRtpParameters(pybind11::module &m);
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MODELS_WEBRTC_RTP_PARAMETERS_H_
diff --git a/python-webrtc/cpp/src/models/webrtc/rtp_transceiver_init.h b/python-webrtc/cpp/src/models/webrtc/rtp_transceiver_init.h
index ed37896..5cee969 100644
--- a/python-webrtc/cpp/src/models/webrtc/rtp_transceiver_init.h
+++ b/python-webrtc/cpp/src/models/webrtc/rtp_transceiver_init.h
@@ -5,10 +5,11 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_MODELS_WEBRTC_RTP_TRANSCEIVER_INIT_H_
+#define PYTHON_WEBRTC_MODELS_WEBRTC_RTP_TRANSCEIVER_INIT_H_
 
-#include <pybind11/pybind11.h>
 #include <api/rtp_transceiver_interface.h>
+#include <pybind11/pybind11.h>
 
 #include "../../enums/enums.h"
 
@@ -23,3 +24,5 @@ namespace python_webrtc {
   }
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_MODELS_WEBRTC_RTP_TRANSCEIVER_INIT_H_
diff --git a/python-webrtc/cpp/src/module.cpp b/python-webrtc/cpp/src/module.cpp
index ba8c3c5..7bc187b 100644
--- a/python-webrtc/cpp/src/module.cpp
+++ b/python-webrtc/cpp/src/module.cpp
@@ -8,12 +8,12 @@
 #include <pybind11/pybind11.h>
 
 #include "config.h"
-#include "utils/gil.h"
 #include "exceptions.h"
-#include "models/models.h"
-#include "interfaces/interfaces.h"
 #include "functions/functions.h"
+#include "interfaces/interfaces.h"
 #include "media/media.h"
+#include "models/models.h"
+#include "utils/gil.h"
 
 namespace py = pybind11;
 
@@ -25,16 +25,19 @@ namespace py = pybind11;
 #endif
 #endif
 
-static bool copyrightShowed = false;
+namespace {
 
-static void ping() {
-  py::print("pong");
-}
+  void ping() {
+    py::print("pong");
+  }
+
+} // namespace
 
 PYBIND11_MODULE(wrtc, m) {
+  static bool copyrightShowed = false;
   if (!copyrightShowed) {
     auto ver = std::string(PROJECT_VER);
-    auto dev = ver.find("dev") != std::string::npos ? " DEV" : "";
+    const auto *dev = ver.find("dev") != std::string::npos ? " DEV" : "";
     py::print("Python WebRTC v" + ver + dev + ", Copyright (C) 2026 Ilya (Marshal) <https://github.com/MarshalX>");
     py::print("Licensed under the terms of the BSD 3-Clause License\n\n");
 
diff --git a/python-webrtc/cpp/src/utils/absl_optional.h b/python-webrtc/cpp/src/utils/absl_optional.h
index 6846187..013fbe1 100644
--- a/python-webrtc/cpp/src/utils/absl_optional.h
+++ b/python-webrtc/cpp/src/utils/absl_optional.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_UTILS_ABSL_OPTIONAL_H_
+#define PYTHON_WEBRTC_UTILS_ABSL_OPTIONAL_H_
 
 #ifndef ABSL_USES_STD_OPTIONAL
 
@@ -16,8 +17,12 @@
 #include <absl/types/optional.h>
 
 namespace pybind11::detail {
-  template<typename T> struct type_caster<absl::optional<T>>: public optional_caster<absl::optional<T>> {};
-  template<> struct type_caster<absl::nullopt_t> : public void_caster<absl::nullopt_t> {};
+  template <typename T>
+  struct type_caster<absl::optional<T>> : public optional_caster<absl::optional<T>> {};
+  template <>
+  struct type_caster<absl::nullopt_t> : public void_caster<absl::nullopt_t> {};
 } // namespace pybind11::detail
 
 #endif // ABSL_USES_STD_OPTIONAL
+
+#endif // PYTHON_WEBRTC_UTILS_ABSL_OPTIONAL_H_
diff --git a/python-webrtc/cpp/src/utils/alive_count.h b/python-webrtc/cpp/src/utils/alive_count.h
index 6f8734e..b446425 100644
--- a/python-webrtc/cpp/src/utils/alive_count.h
+++ b/python-webrtc/cpp/src/utils/alive_count.h
@@ -5,31 +5,32 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_UTILS_ALIVE_COUNT_H_
+#define PYTHON_WEBRTC_UTILS_ALIVE_COUNT_H_
 
 #include <atomic>
 
 namespace python_webrtc {
 
   // Counts the live objects of a type, a member of it, so tests can check that none leaks (wrtc._alive)
-  template<typename T>
+  template <typename T>
   class AliveCount {
   public:
-    AliveCount() {
-      count++;
-    }
+    AliveCount() { count++; }
 
-    AliveCount(const AliveCount &) {
-      count++;
-    }
+    AliveCount(const AliveCount & /*unused*/) { count++; }
+
+    AliveCount(AliveCount && /*unused*/) noexcept { count++; }
 
     AliveCount &operator=(const AliveCount &) = default;
 
-    ~AliveCount() {
-      count--;
-    }
+    AliveCount &operator=(AliveCount &&) noexcept = default;
+
+    ~AliveCount() { count--; }
 
     static inline std::atomic<int> count{0};
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_UTILS_ALIVE_COUNT_H_
diff --git a/python-webrtc/cpp/src/utils/alive_guard.h b/python-webrtc/cpp/src/utils/alive_guard.h
index 8769ab6..d697feb 100644
--- a/python-webrtc/cpp/src/utils/alive_guard.h
+++ b/python-webrtc/cpp/src/utils/alive_guard.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_UTILS_ALIVE_GUARD_H_
+#define PYTHON_WEBRTC_UTILS_ALIVE_GUARD_H_
 
 #include <atomic>
 #include <memory>
@@ -18,11 +19,14 @@ namespace python_webrtc {
   // thread or block on it, so a task never overlaps a destructor.
   class AliveGuard {
   public:
-    ~AliveGuard() {
-      *_alive = false;
-    }
+    ~AliveGuard() { *_alive = false; }
+
+    AliveGuard() = default;
 
-    template<typename F>
+    AliveGuard(const AliveGuard &) = delete;
+    AliveGuard &operator=(const AliveGuard &) = delete;
+
+    template <typename F>
     auto Guard(F task) {
       return [alive = _alive, task = std::move(task)]() mutable {
         if (*alive) {
@@ -36,3 +40,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_UTILS_ALIVE_GUARD_H_
diff --git a/python-webrtc/cpp/src/utils/buffer.h b/python-webrtc/cpp/src/utils/buffer.h
index e0384fc..bd1df1f 100644
--- a/python-webrtc/cpp/src/utils/buffer.h
+++ b/python-webrtc/cpp/src/utils/buffer.h
@@ -5,9 +5,11 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_UTILS_BUFFER_H_
+#define PYTHON_WEBRTC_UTILS_BUFFER_H_
 
 #include <cstddef>
+#include <cstdint>
 
 #include <pybind11/pybind11.h>
 
@@ -16,12 +18,18 @@ namespace python_webrtc {
   // A Python buffer used as one block: a strided view (like view[::-1]) would be accessed out of its bounds
   inline pybind11::buffer_info ContiguousBuffer(const pybind11::buffer &buffer, bool writable = false) {
     auto info = buffer.request(writable);
-    if (!PyBuffer_IsContiguous(info.view(), 'C')) {
+    if (PyBuffer_IsContiguous(info.view(), 'C') == 0) {
       throw pybind11::type_error("The buffer must be contiguous");
     }
     return info;
   }
 
+  // bytes of a buffer of octets
+  inline pybind11::bytes Bytes(const uint8_t *data, size_t size) {
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast): Python bytes are chars, octets alias them
+    return {reinterpret_cast<const char *>(data), size};
+  }
+
   // Whether rows of rowBytes, stride apart and starting at offset, fit in size bytes, without overflowing
   inline bool RowsFit(size_t offset, size_t stride, size_t rows, size_t rowBytes, size_t size) {
     if (rows == 0 || rowBytes == 0) {
@@ -34,3 +42,5 @@ namespace python_webrtc {
   }
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_UTILS_BUFFER_H_
diff --git a/python-webrtc/cpp/src/utils/gil.h b/python-webrtc/cpp/src/utils/gil.h
index 68d59f3..333aa3a 100644
--- a/python-webrtc/cpp/src/utils/gil.h
+++ b/python-webrtc/cpp/src/utils/gil.h
@@ -5,10 +5,13 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_UTILS_GIL_H_
+#define PYTHON_WEBRTC_UTILS_GIL_H_
 
 #include <atomic>
 #include <chrono>
+#include <cstdio>
+#include <exception>
 #include <optional>
 #include <thread>
 #include <utility>
@@ -19,19 +22,28 @@ namespace python_webrtc {
 
   // Once the interpreter finalizes, another thread taking the GIL is stopped: with pthread_exit before 3.14, whose
   // unwinding through native frames (noexcept ones, libwebrtc's) aborts. So threads stop taking it at exit already.
-  inline std::atomic<bool> pythonExiting{false};
+  inline std::atomic<bool> &PythonExiting() {
+    static std::atomic<bool> exiting{false};
+    return exiting;
+  }
   // the thread running the exit, which finalizes the interpreter
-  inline std::atomic<std::thread::id> exitThread{};
+  inline std::atomic<std::thread::id> &ExitThread() {
+    static std::atomic<std::thread::id> thread{};
+    return thread;
+  }
   // threads entering Python or taking the GIL back, which the exit waits for
-  inline std::atomic<int> pythonEntries{0};
+  inline std::atomic<int> &PythonEntries() {
+    static std::atomic<int> entries{0};
+    return entries;
+  }
 
   // Whether Python code can still run: libwebrtc threads may outlive the interpreter
   inline bool PythonAlive() {
-    if (pythonExiting) {
+    if (PythonExiting()) {
       return false;
     }
 #if PY_VERSION_HEX >= 0x030D0000
-    return Py_IsInitialized() && !Py_IsFinalizing();
+    return (Py_IsInitialized() != 0) && (Py_IsFinalizing() == 0);
 #else
     return Py_IsInitialized() && !_Py_IsFinalizing();
 #endif
@@ -40,23 +52,22 @@ namespace python_webrtc {
   // Taking the GIL from a thread without it: not once the interpreter exits (see pythonExiting)
   class PythonEntry {
   public:
-    PythonEntry() {
-      pythonEntries++;
-      _entered = PythonAlive();
-    }
+    PythonEntry() : _entered(Enter()) {}
 
-    ~PythonEntry() {
-      pythonEntries--;
-    }
+    ~PythonEntry() { PythonEntries()--; }
 
     PythonEntry(const PythonEntry &) = delete;
     PythonEntry &operator=(const PythonEntry &) = delete;
 
-    explicit operator bool() const {
-      return _entered;
-    }
+    explicit operator bool() const { return _entered; }
 
   private:
+    // counted before checking, so the exit either sees the entry or the entry sees the exit
+    static bool Enter() {
+      PythonEntries()++;
+      return PythonAlive();
+    }
+
     bool _entered;
   };
 
@@ -68,8 +79,8 @@ namespace python_webrtc {
 
     ~gil_release() {
       {
-        PythonEntry entry;
-        if (entry || std::this_thread::get_id() == exitThread) {
+        const PythonEntry entry;
+        if (entry || std::this_thread::get_id() == ExitThread()) {
           PyEval_RestoreThread(_state);
           return;
         }
@@ -88,12 +99,13 @@ namespace python_webrtc {
 
   // An atexit handler: threads stop taking the GIL before the interpreter finalizes, the ones taking it are waited for
   inline void StopEnteringPython() {
-    exitThread = std::this_thread::get_id();
-    pythonExiting = true;
-    gil_release release;
+    ExitThread() = std::this_thread::get_id();
+    PythonExiting() = true;
+    const gil_release release;
     // bounded: a Python handler may never return
-    auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(5);
-    while (pythonEntries > 0 && std::chrono::steady_clock::now() < deadline) {
+    constexpr auto timeout = std::chrono::seconds(5);
+    auto deadline = std::chrono::steady_clock::now() + timeout;
+    while (PythonEntries() > 0 && std::chrono::steady_clock::now() < deadline) {
       std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }
   }
@@ -103,16 +115,16 @@ namespace python_webrtc {
   using nogil = pybind11::call_guard<gil_release>;
 
   // Property getters/setters can't take a call guard directly, wrap them into a function instead.
-  template<typename F>
-  pybind11::cpp_function nogil_fn(F &&f) {
-    return pybind11::cpp_function(std::forward<F>(f), nogil());
+  template <typename F>
+  pybind11::cpp_function nogil_fn(F &&function) {
+    return pybind11::cpp_function(std::forward<F>(function), nogil());
   }
 
   // A pybind11::init factory without the GIL: a call guard would also cover registering the instance, which needs it
-  template<typename R, typename... Args>
+  template <typename R, typename... Args>
   auto nogil_factory(R (*factory)(Args...)) {
     return [factory](Args... args) {
-      gil_release release;
+      const gil_release release;
       return factory(std::forward<Args>(args)...);
     };
   }
@@ -122,7 +134,7 @@ namespace python_webrtc {
   class gil_release_if_held {
   public:
     gil_release_if_held() {
-      if (Py_IsInitialized() && PyGILState_Check()) {
+      if ((Py_IsInitialized() != 0) && (PyGILState_Check() != 0)) {
         _release.emplace();
       }
     }
@@ -131,4 +143,29 @@ namespace python_webrtc {
     std::optional<gil_release> _release;
   };
 
+  // Releases a Python object on any thread, from destructors too: leaked once the interpreter is gone, or if
+  // pybind11 fails to take the GIL, which is reported rather than terminating
+  inline void ReleasePythonObject(pybind11::object &object) noexcept {
+    const PythonEntry entry;
+    if (!entry) {
+      // the interpreter is gone, and so are the objects
+      (void)object.release();
+      return;
+    }
+    if (!object) {
+      return;
+    }
+    try {
+      const pybind11::gil_scoped_acquire gil;
+      const pybind11::object dropped = std::move(object);
+    } catch (const std::exception &e) {
+      (void)object.release();
+      (void)std::fputs("python-webrtc: leaked a Python object, the GIL couldn't be taken: ", stderr);
+      (void)std::fputs(e.what(), stderr);
+      (void)std::fputs("\n", stderr);
+    }
+  }
+
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_UTILS_GIL_H_
diff --git a/python-webrtc/cpp/src/utils/held_events.h b/python-webrtc/cpp/src/utils/held_events.h
index f834192..d6933f8 100644
--- a/python-webrtc/cpp/src/utils/held_events.h
+++ b/python-webrtc/cpp/src/utils/held_events.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_UTILS_HELD_EVENTS_H_
+#define PYTHON_WEBRTC_UTILS_HELD_EVENTS_H_
 
 #include <functional>
 #include <mutex>
@@ -19,14 +20,14 @@ namespace python_webrtc {
   class HeldEvents {
   public:
     void Hold() {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       _held = true;
     }
 
     void Release() {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       // emitted under the lock, so that events emitted meanwhile come after these
-      for (auto &emit: _events) {
+      for (auto &emit : _events) {
         emit();
       }
       _events.clear();
@@ -34,15 +35,15 @@ namespace python_webrtc {
     }
 
     bool IsHeld() {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       return _held;
     }
 
     // emits an event now, or on release while held
-    template<typename F>
+    template <typename F>
     void Emit(F &&emit) {
       {
-        std::lock_guard<std::mutex> lock(_mutex);
+        const std::scoped_lock lock(_mutex);
         if (_held) {
           _events.emplace_back(std::forward<F>(emit));
           return;
@@ -58,3 +59,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_UTILS_HELD_EVENTS_H_
diff --git a/python-webrtc/cpp/src/utils/instance_holder.h b/python-webrtc/cpp/src/utils/instance_holder.h
index d90dc48..0a213d4 100644
--- a/python-webrtc/cpp/src/utils/instance_holder.h
+++ b/python-webrtc/cpp/src/utils/instance_holder.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_UTILS_INSTANCE_HOLDER_H_
+#define PYTHON_WEBRTC_UTILS_INSTANCE_HOLDER_H_
 
 #include <functional>
 #include <memory>
@@ -32,17 +33,18 @@ namespace python_webrtc {
 
   // At most one wrapper T per libwebrtc object U, so Python always sees the same object for it. Entries are weak:
   // Python and parent wrappers own the wrappers.
-  template<typename T, typename U>
+  template <typename T, typename U>
   class InstanceHolder {
   public:
-    std::shared_ptr<T> GetOrCreate(const std::shared_ptr<PeerConnectionFactory> &factory, webrtc::scoped_refptr<U> object) {
+    std::shared_ptr<T> GetOrCreate(const std::shared_ptr<PeerConnectionFactory> &factory,
+                                   webrtc::scoped_refptr<U> object) {
       if (!object) {
         return nullptr;
       }
       if (auto instance = Find(object.get())) {
         return instance;
       }
-      if (!onLibwebrtcThread) {
+      if (!OnLibwebrtcThread()) {
         // created on the signaling thread: constructors call it, which may be wrapping objects under the same locks
         std::shared_ptr<T> instance;
         RunOnSignalingThread(*factory, [&]() { instance = GetOrCreate(factory, object); });
@@ -50,7 +52,7 @@ namespace python_webrtc {
       }
 
       // wrappers may create nested wrappers (sctp -> dtls -> ice) while holding the lock
-      std::unique_lock<std::recursive_mutex> lock(_mutex);
+      const std::unique_lock<std::recursive_mutex> lock(_mutex);
       auto key = object.get();
       auto it = _store.find(key);
       if (it != _store.end()) {
@@ -59,32 +61,34 @@ namespace python_webrtc {
         }
       }
 
-      std::shared_ptr<T> instance(new T(factory, std::move(object)), [this, key, generation = forks.load()](T *dying) {
-        // left to the exit of the process (see ReleaseOffLibwebrtcThread): the lock may be held by a hung thread
-        if (!PythonAlive() || generation != forks.load()) {
-          return;
-        }
-        // the lock's holder may wait for a libwebrtc thread waiting for the GIL
-        gil_release_if_held release;
-        StartDestroying(key);
-        ReleaseOffLibwebrtcThread([this, key, dying]() { Destroy(key, dying); });
-      });
+      std::shared_ptr<T> instance(new T(factory, std::move(object)),
+                                  [this, key, generation = Forks().load()](T *dying) {
+                                    // left to the exit of the process (see ReleaseOffLibwebrtcThread): the lock may be
+                                    // held by a hung thread
+                                    if (!PythonAlive() || generation != Forks().load()) {
+                                      return;
+                                    }
+                                    // the lock's holder may wait for a libwebrtc thread waiting for the GIL
+                                    const gil_release_if_held release;
+                                    StartDestroying(key);
+                                    ReleaseOffLibwebrtcThread([this, key, dying]() { Destroy(key, dying); });
+                                  });
       _store[key] = instance;
       return instance;
     }
 
     // The live wrapper of a libwebrtc object, if there's one
     std::shared_ptr<T> Find(const U *object) {
-      std::lock_guard<std::recursive_mutex> lock(_mutex);
-      auto it = _store.find(const_cast<U *>(object));
+      const std::scoped_lock lock(_mutex);
+      auto it = _store.find(object);
       return it != _store.end() ? it->second.lock() : nullptr;
     }
 
     // wrappers alive or being destroyed, for tests (wrtc._alive)
     int Alive() {
-      std::lock_guard<std::recursive_mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       int alive = static_cast<int>(_destroying.size());
-      for (const auto &entry: _store) {
+      for (const auto &entry : _store) {
         alive += entry.second.expired() ? 0 : 1;
       }
       return alive;
@@ -92,13 +96,13 @@ namespace python_webrtc {
 
     // A wrapper registered as the observer of its object, on the observer's thread
     void SetObserver(const U *object, const T *wrapper) {
-      std::lock_guard<std::mutex> lock(_observersMutex);
+      const std::scoped_lock lock(_observersMutex);
       _observers[object] = wrapper;
     }
 
     // Whether a wrapper is still the observer of its object, which it no longer is then, on the observer's thread
     bool TakeObserver(const U *object, const T *wrapper) {
-      std::lock_guard<std::mutex> lock(_observersMutex);
+      const std::scoped_lock lock(_observersMutex);
       auto it = _observers.find(object);
       if (it == _observers.end() || it->second != wrapper) {
         return false;
@@ -109,7 +113,7 @@ namespace python_webrtc {
 
   private:
     void StartDestroying(U *key) {
-      std::lock_guard<std::recursive_mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       auto it = _store.find(key);
       if (it != _store.end() && it->second.expired()) {
         _store.erase(it);
@@ -118,16 +122,16 @@ namespace python_webrtc {
     }
 
     void Destroy(U *key, T *dying) {
-      gil_release_if_held release;
+      const gil_release_if_held release;
 
       // out of the lock: destructors block on libwebrtc threads, which may be waiting for it (wrapping an object)
       delete dying;
-      std::lock_guard<std::recursive_mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       _destroying.erase(_destroying.find(key));
     }
 
     std::recursive_mutex _mutex;
-    std::unordered_map<U *, std::weak_ptr<T>> _store;
+    std::unordered_map<const U *, std::weak_ptr<T>> _store;
     // objects whose wrapper is being destroyed
     std::unordered_multiset<U *> _destroying;
     std::mutex _observersMutex;
@@ -135,3 +139,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_UTILS_INSTANCE_HOLDER_H_
diff --git a/python-webrtc/cpp/src/utils/libwebrtc_thread.h b/python-webrtc/cpp/src/utils/libwebrtc_thread.h
index 4e973c0..e767d86 100644
--- a/python-webrtc/cpp/src/utils/libwebrtc_thread.h
+++ b/python-webrtc/cpp/src/utils/libwebrtc_thread.h
@@ -5,12 +5,14 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_UTILS_LIBWEBRTC_THREAD_H_
+#define PYTHON_WEBRTC_UTILS_LIBWEBRTC_THREAD_H_
 
 #include <atomic>
 #include <cstdio>
 #include <cstdlib>
 #include <memory>
+#include <string>
 #include <thread>
 #include <utility>
 
@@ -21,18 +23,17 @@ namespace python_webrtc {
   // Whether this is a libwebrtc thread. Python code runs on them (to emit events), and so does the garbage collector,
   // which may release the last reference to a wrapper, whose destructor blocks on libwebrtc threads that may be
   // blocked on this one.
-  inline thread_local bool onLibwebrtcThread = false;
+  inline bool &OnLibwebrtcThread() {
+    static thread_local bool onLibwebrtcThread = false;
+    return onLibwebrtcThread;
+  }
 
   // Marks the calling thread as a libwebrtc one while it runs Python code
   class LibwebrtcThreadScope {
   public:
-    LibwebrtcThreadScope() : _previous(onLibwebrtcThread) {
-      onLibwebrtcThread = true;
-    }
+    LibwebrtcThreadScope() : _previous(OnLibwebrtcThread()) { OnLibwebrtcThread() = true; }
 
-    ~LibwebrtcThreadScope() {
-      onLibwebrtcThread = _previous;
-    }
+    ~LibwebrtcThreadScope() { OnLibwebrtcThread() = _previous; }
 
     LibwebrtcThreadScope(const LibwebrtcThreadScope &) = delete;
     LibwebrtcThreadScope &operator=(const LibwebrtcThreadScope &) = delete;
@@ -42,15 +43,18 @@ namespace python_webrtc {
   };
 
   // Forks, counted in the child: objects from before one are never released there, their threads are gone
-  inline std::atomic<int> forks{0};
+  inline std::atomic<int> &Forks() {
+    static std::atomic<int> forks{0};
+    return forks;
+  }
 
   // Runs a release right away, or on a thread of its own on a libwebrtc thread; leaks while the interpreter finalizes
-  template<typename F>
-  void ReleaseOffLibwebrtcThread(F &&release, int generation = forks.load()) {
-    if (!PythonAlive() || generation != forks.load()) {
+  template <typename F>
+  void ReleaseOffLibwebrtcThread(F &&release, int generation = Forks().load()) {
+    if (!PythonAlive() || generation != Forks().load()) {
       return;
     }
-    if (onLibwebrtcThread) {
+    if (OnLibwebrtcThread()) {
       std::thread(std::forward<F>(release)).detach();
     } else {
       release();
@@ -60,14 +64,14 @@ namespace python_webrtc {
   // Deletes wrappers whose destructors block on libwebrtc threads off those threads
   struct DeleteOffLibwebrtcThread {
     // of the process the wrapper was created in (see forks)
-    int generation = forks.load();
+    int generation = Forks().load();
 
-    template<typename T>
+    template <typename T>
     void operator()(T *dying) const {
       ReleaseOffLibwebrtcThread(
           [dying]() {
             // members too are released without it, like proxies destroyed on their thread
-            gil_release_if_held release;
+            const gil_release_if_held release;
             delete dying;
           },
           generation);
@@ -79,8 +83,10 @@ namespace python_webrtc {
   class BlockingDestructor {
   public:
     explicit BlockingDestructor(const char *name) {
-      if (onLibwebrtcThread) {
-        std::fprintf(stderr, "python-webrtc: %s destroyed on a libwebrtc thread, see DeleteOffLibwebrtcThread\n", name);
+      if (OnLibwebrtcThread()) {
+        const std::string message =
+            std::string("python-webrtc: ") + name + " destroyed on a libwebrtc thread, see DeleteOffLibwebrtcThread\n";
+        (void)std::fputs(message.c_str(), stderr);
         std::abort();
       }
     }
@@ -90,3 +96,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_UTILS_LIBWEBRTC_THREAD_H_
diff --git a/python-webrtc/cpp/src/utils/listeners.h b/python-webrtc/cpp/src/utils/listeners.h
index bba4443..37bf382 100644
--- a/python-webrtc/cpp/src/utils/listeners.h
+++ b/python-webrtc/cpp/src/utils/listeners.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_UTILS_LISTENERS_H_
+#define PYTHON_WEBRTC_UTILS_LISTENERS_H_
 
 #include <atomic>
 #include <memory>
@@ -23,114 +24,101 @@ namespace python_webrtc {
   // libwebrtc threads: with the GIL, the Python listeners object only schedules handlers on their event loops.
   class Listeners {
   public:
-    virtual ~Listeners() {
-      DropListeners();
-    }
+    virtual ~Listeners() { DropListeners(); }
+
+    Listeners() = default;
+
+    Listeners(const Listeners &) = delete;
+    Listeners &operator=(const Listeners &) = delete;
 
     // the class of a wrapper, with its listeners property
-    template<typename T>
+    template <typename T>
     static pybind11::class_<T, std::shared_ptr<T>> BindClass(pybind11::module &m, const char *name) {
       pybind11::class_<T, std::shared_ptr<T>> cls(m, name, TypeSetup<T>());
       cls.def_property("_listeners", &T::GetListeners, &T::SetListeners);
       return cls;
     }
 
-    pybind11::object GetListeners() {
-      return _listeners ? _listeners : pybind11::none();
-    }
+    pybind11::object GetListeners() { return _listeners ? _listeners : pybind11::none(); }
 
     void SetListeners(pybind11::object listeners) {
       _listeners = listeners.is_none() ? pybind11::object() : std::move(listeners);
       _active = static_cast<bool>(_listeners);
       if (_active) {
         // held events are delivered now, without the GIL: a thread releasing them holds their lock waiting for it
-        gil_release release;
+        const gil_release release;
         if (IsHeld()) {
           Release();
         }
       }
     }
 
-    bool HasListeners() const {
-      return _active;
-    }
+    bool HasListeners() const { return _active; }
 
     // whether events are held, and so are going to be delivered once Python has the object
-    bool IsHeld() {
-      return _held.IsHeld();
-    }
+    bool IsHeld() { return _held.IsHeld(); }
 
     // whether events are delivered or held for Python
-    bool IsTracked() {
-      return HasListeners() || IsHeld();
-    }
+    bool IsTracked() { return HasListeners() || IsHeld(); }
 
     // Events emitted while held are emitted on release: an object that Python doesn't have yet
     // (like a data channel before its datachannel event) mustn't lose its first events
-    void Hold() {
-      _held.Hold();
-    }
+    void Hold() { _held.Hold(); }
 
-    void Release() {
-      _held.Release();
-    }
+    void Release() { _held.Release(); }
 
     // Stops delivering events without releasing the handlers, e.g. while closing
-    void Mute() {
-      _active = false;
-    }
+    void Mute() { _active = false; }
 
   protected:
     // Calls the listeners object with the event name and arguments, on any thread
-    template<typename... Args>
-    void Emit(const char *name, Args... args) {
+    template <typename... Args>
+    void Emit(const char *name, const Args &...args) {
       _held.Emit([this, name, args...]() { EmitNow(name, args...); });
     }
 
     // No events are delivered anymore, and the handlers are released. The destructors of wrappers call it once
     // their libwebrtc objects are released, rather than leaving it to ~Listeners, which runs after the members.
-    void DropListeners() {
+    void DropListeners() noexcept {
       _active = false;
-      PythonEntry entry;
-      if (!entry) {
-        // the interpreter is gone, and so are the objects
-        (void) _listeners.release();
-        return;
-      }
-      if (_listeners) {
-        pybind11::gil_scoped_acquire gil;
-        pybind11::object dropped = std::move(_listeners);
-      }
+      ReleasePythonObject(_listeners);
     }
 
   private:
     // Lets the garbage collector see the handlers while Python is the only owner, so handlers referencing
     // the wrapper don't keep it alive forever
-    template<typename T>
+    template <typename T>
     static pybind11::custom_type_setup TypeSetup() {
       return pybind11::custom_type_setup([](PyHeapTypeObject *heap_type) {
         auto *type = &heap_type->ht_type;
         type->tp_flags |= Py_TPFLAGS_HAVE_GC;
-        type->tp_traverse = [](PyObject *self, visitproc visit, void *arg) -> int {
-          Py_VISIT(Py_TYPE(self));
-          if (auto *listeners = OwnedListeners<T>(self)) {
-            Py_VISIT(listeners->_listeners.ptr());
-          }
-          return 0;
-        };
-        type->tp_clear = [](PyObject *self) -> int {
-          if (auto *listeners = OwnedListeners<T>(self)) {
-            listeners->_active = false;
-            // the handlers may hold the last reference to anything, release them after the field is reset
-            pybind11::object dropped = std::move(listeners->_listeners);
-          }
-          return 0;
-        };
+        type->tp_traverse = &Traverse<T>;
+        type->tp_clear = &Clear<T>;
       });
     }
 
-    template<typename T>
+    template <typename T>
+    static int Traverse(PyObject *self, visitproc visit, void *arg) {
+      Py_VISIT(Py_TYPE(self));
+      if (auto *listeners = OwnedListeners<T>(self)) {
+        Py_VISIT(listeners->_listeners.ptr());
+      }
+      return 0;
+    }
+
+    template <typename T>
+    static int Clear(PyObject *self) {
+      if (auto *listeners = OwnedListeners<T>(self)) {
+        listeners->_active = false;
+        // the handlers may hold the last reference to anything, release them after the field is reset
+        const pybind11::object dropped = std::move(listeners->_listeners);
+      }
+      return 0;
+    }
+
+    template <typename T>
     static Listeners *OwnedListeners(PyObject *self) {
+      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast): pybind11 instances are these Python objects
       auto *inst = reinterpret_cast<pybind11::detail::instance *>(self);
       auto v_h = inst->get_value_and_holder();
       if (!v_h.holder_constructed()) {
@@ -143,25 +131,29 @@ namespace python_webrtc {
       return static_cast<Listeners *>(holder.get());
     }
 
-    template<typename... Args>
-    void EmitNow(const char *name, Args... args) {
-      PythonEntry entry;
+    template <typename... Args>
+    void EmitNow(const char *name, const Args &...args) {
+      const PythonEntry entry;
       if (!_active || !entry) {
         return;
       }
 
       // whatever the handlers release here is destroyed elsewhere
-      LibwebrtcThreadScope scope;
-      pybind11::gil_scoped_acquire gil;
+      const LibwebrtcThreadScope scope;
+      const pybind11::gil_scoped_acquire gil;
       if (!_listeners) {
         return;
       }
       // keeps the listeners alive even if a handler registration replaces them meanwhile
-      pybind11::object listeners = _listeners;
+      const pybind11::object listeners = _listeners;
       try {
-        listeners(name, std::move(args)...);
+        listeners(name, args...);
       } catch (pybind11::error_already_set &e) {
         e.discard_as_unraisable(name);
+      } catch (const std::exception &e) {
+        // like an argument pybind11 can't convert: nowhere to propagate to on a libwebrtc thread
+        PyErr_SetString(PyExc_RuntimeError, e.what());
+        PyErr_WriteUnraisable(listeners.ptr());
       }
     }
 
@@ -171,3 +163,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_UTILS_LISTENERS_H_
diff --git a/python-webrtc/cpp/src/utils/locked_function.h b/python-webrtc/cpp/src/utils/locked_function.h
index 68c046f..77e01c7 100644
--- a/python-webrtc/cpp/src/utils/locked_function.h
+++ b/python-webrtc/cpp/src/utils/locked_function.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_UTILS_LOCKED_FUNCTION_H_
+#define PYTHON_WEBRTC_UTILS_LOCKED_FUNCTION_H_
 
 #include <functional>
 #include <mutex>
@@ -15,16 +16,16 @@ namespace python_webrtc {
 
   // A function another object sets (like the connection of a transport), which may be set on one thread while it's
   // called on another. It's called out of the lock: calls block on libwebrtc threads, which may be setting it.
-  template<typename Signature>
+  template <typename Signature>
   class LockedFunction {
   public:
     void Set(std::function<Signature> function) {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       _function = std::move(function);
     }
 
     std::function<Signature> Get() {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       return _function;
     }
 
@@ -34,3 +35,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_UTILS_LOCKED_FUNCTION_H_
diff --git a/python-webrtc/cpp/src/utils/paced_thread.h b/python-webrtc/cpp/src/utils/paced_thread.h
index b0d2600..b2d495a 100644
--- a/python-webrtc/cpp/src/utils/paced_thread.h
+++ b/python-webrtc/cpp/src/utils/paced_thread.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_UTILS_PACED_THREAD_H_
+#define PYTHON_WEBRTC_UTILS_PACED_THREAD_H_
 
 #include <chrono>
 #include <condition_variable>
@@ -22,7 +23,7 @@ namespace python_webrtc {
   public:
     ~PacedThread() {
       {
-        std::lock_guard<std::mutex> lock(_mutex);
+        const std::scoped_lock lock(_mutex);
         _stopping = true;
       }
       _stop.notify_all();
@@ -31,6 +32,11 @@ namespace python_webrtc {
       }
     }
 
+    PacedThread() = default;
+
+    PacedThread(const PacedThread &) = delete;
+    PacedThread &operator=(const PacedThread &) = delete;
+
     // the first call is right away
     void Start(std::chrono::microseconds interval, std::function<void()> tick) {
       _thread = std::thread([this, interval, tick = std::move(tick)]() {
@@ -56,3 +62,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_UTILS_PACED_THREAD_H_
diff --git a/python-webrtc/cpp/src/utils/python_callback.h b/python-webrtc/cpp/src/utils/python_callback.h
index f37abeb..10e03c9 100644
--- a/python-webrtc/cpp/src/utils/python_callback.h
+++ b/python-webrtc/cpp/src/utils/python_callback.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_UTILS_PYTHON_CALLBACK_H_
+#define PYTHON_WEBRTC_UTILS_PYTHON_CALLBACK_H_
 
 #include <functional>
 #include <memory>
@@ -20,27 +21,28 @@ namespace python_webrtc {
 
   // A Python function called back from libwebrtc threads. pybind11's std::function takes the GIL to be called, copied
   // or released, which stops the thread once the interpreter exits: this one is ignored then (see PythonEntry).
-  template<typename... Args>
+  template <typename... Args>
   std::function<void(Args...)> PythonCallback(pybind11::function function) {
-    std::shared_ptr<pybind11::function> held(new pybind11::function(std::move(function)), [](pybind11::function *f) {
-      PythonEntry entry;
+    const std::shared_ptr<pybind11::function> held(new pybind11::function(std::move(function)),
+                                                   [](pybind11::function *function) {
+                                                     const PythonEntry entry;
+                                                     if (!entry) {
+                                                       // the interpreter is gone
+                                                       (void)function->release();
+                                                       delete function;
+                                                       return;
+                                                     }
+                                                     const pybind11::gil_scoped_acquire gil;
+                                                     delete function;
+                                                   });
+    return [held](const Args &...args) {
+      const PythonEntry entry;
       if (!entry) {
-        // the interpreter is gone
-        (void) f->release();
-        delete f;
         return;
       }
-      pybind11::gil_scoped_acquire gil;
-      delete f;
-    });
-    return [held](Args... args) {
-      PythonEntry entry;
-      if (!entry) {
-        return;
-      }
-      pybind11::gil_scoped_acquire gil;
+      const pybind11::gil_scoped_acquire gil;
       try {
-        (*held)(std::move(args)...);
+        (*held)(args...);
       } catch (pybind11::error_already_set &e) {
         e.discard_as_unraisable("callback");
       }
@@ -48,15 +50,17 @@ namespace python_webrtc {
   }
 
   // A method taking (onSuccess, onFailure, ...) callbacks, bound with PythonCallbacks and without the GIL
-  template<typename C, typename... Result, typename... Rest>
+  template <typename C, typename... Result, typename... Rest>
   auto WithCallbacks(void (C::*method)(std::function<void(Result...)> &, std::function<void(RTCCallbackException)> &,
                                        Rest...)) {
     return [method](C &self, pybind11::function onSuccess, pybind11::function onFailure, Rest... rest) {
       auto success = PythonCallback<Result...>(std::move(onSuccess));
       auto failure = PythonCallback<RTCCallbackException>(std::move(onFailure));
-      gil_release release;
+      const gil_release release;
       (self.*method)(success, failure, std::forward<Rest>(rest)...);
     };
   }
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_UTILS_PYTHON_CALLBACK_H_
diff --git a/python-webrtc/cpp/src/utils/surfaced.h b/python-webrtc/cpp/src/utils/surfaced.h
index 7b7aeae..127b2b8 100644
--- a/python-webrtc/cpp/src/utils/surfaced.h
+++ b/python-webrtc/cpp/src/utils/surfaced.h
@@ -5,7 +5,8 @@
 // that can be found in the LICENSE.md file in the root of the project.
 //
 
-#pragma once
+#ifndef PYTHON_WEBRTC_UTILS_SURFACED_H_
+#define PYTHON_WEBRTC_UTILS_SURFACED_H_
 
 #include <mutex>
 #include <optional>
@@ -14,12 +15,12 @@ namespace python_webrtc {
 
   // An attribute that changes when Python delivers its event (Surface), rather than when libwebrtc reports it;
   // without listeners there are no events, and the current value is seen.
-  template<typename T>
+  template <typename T>
   class Surfaced {
   public:
     // a change reported by libwebrtc, before its event is emitted
     void Changed(bool listening, T previous) {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       if (!listening) {
         _value.reset();
       } else if (!_value) {
@@ -28,18 +29,18 @@ namespace python_webrtc {
     }
 
     void Surface(T value) {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       _value = value;
     }
 
     // shows the current value again, like when events stop
     void Reset() {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       _value.reset();
     }
 
     T Get(T current) {
-      std::lock_guard<std::mutex> lock(_mutex);
+      const std::scoped_lock lock(_mutex);
       return _value ? *_value : current;
     }
 
@@ -49,3 +50,5 @@ namespace python_webrtc {
   };
 
 } // namespace python_webrtc
+
+#endif // PYTHON_WEBRTC_UTILS_SURFACED_H_