admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Comment unused variables in implemented functions 14\n

Browse Source 
Bug: webrtc:370878648
Change-Id: I7c48313e64fafb8f23121e9bae1d50c3d32f7d07
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/366983
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Dor Hen <dorhen@meta.com>
Cr-Commit-Position: refs/heads/main@{#43414}
This commit is contained in:
Dor Hen 2024-11-11 15:51:41 +02:00 committed by WebRTC LUCI CQ
parent bda11ca6da
commit 69cc695699
58 changed files with 182 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
call/call.cc
View File

@ -110,12 +110,12 @@ namespace {
class PayloadTypeSuggesterForTests : public PayloadTypeSuggester { class PayloadTypeSuggesterForTests : public PayloadTypeSuggester {
public: public:
PayloadTypeSuggesterForTests() = default; PayloadTypeSuggesterForTests() = default;
RTCErrorOr<PayloadType> SuggestPayloadType(const std::string& mid, RTCErrorOr<PayloadType> SuggestPayloadType(const std::string& /* mid */,
cricket::Codec codec) override { cricket::Codec codec) override {
return payload_type_picker_.SuggestMapping(codec, nullptr); return payload_type_picker_.SuggestMapping(codec, nullptr);
} }
RTCError AddLocalMapping(const std::string& mid, RTCError AddLocalMapping(const std::string& /* mid */,
PayloadType payload_type, PayloadType /* payload_type */,
const cricket::Codec& codec) override { const cricket::Codec& codec) override {
return RTCError::OK(); return RTCError::OK();
} }

2
modules/audio_device/include/audio_device_default.h
View File

@ -124,7 +124,7 @@ class AudioDeviceModuleDefault : public T {
bool BuiltInAGCIsAvailable() const override { return false; } bool BuiltInAGCIsAvailable() const override { return false; }
int32_t EnableBuiltInAGC(bool /* enable */) override { return -1; } int32_t EnableBuiltInAGC(bool /* enable */) override { return -1; }
bool BuiltInNSIsAvailable() const override { return false; } bool BuiltInNSIsAvailable() const override { return false; }
int32_t EnableBuiltInNS(bool enable) override { return -1; } int32_t EnableBuiltInNS(bool /* enable */) override { return -1; }
int32_t GetPlayoutUnderrunCount() const override { return -1; } int32_t GetPlayoutUnderrunCount() const override { return -1; }

4
modules/audio_device/include/test_audio_device.cc
View File

@ -287,7 +287,9 @@ class DiscardRenderer final : public TestAudioDeviceModule::Renderer {
int NumChannels() const override { return num_channels_; } int NumChannels() const override { return num_channels_; }
bool Render(rtc::ArrayView<const int16_t> data) override { return true; } bool Render(rtc::ArrayView<const int16_t> /* data */) override {
return true;
}
private: private:
int sampling_frequency_in_hz_; int sampling_frequency_in_hz_;

46
modules/audio_device/test_audio_device_impl_test.cc
View File

@ -42,17 +42,17 @@ class TestAudioTransport : public AudioTransport {
~TestAudioTransport() override = default; ~TestAudioTransport() override = default;
int32_t RecordedDataIsAvailable( int32_t RecordedDataIsAvailable(
const void* audioSamples, const void* /* audioSamples */,
size_t samples_per_channel, size_t samples_per_channel,
size_t bytes_per_sample, size_t bytes_per_sample,
size_t number_of_channels, size_t number_of_channels,
uint32_t samples_per_second, uint32_t samples_per_second,
uint32_t total_delay_ms, uint32_t /* total_delay_ms */,
int32_t clock_drift, int32_t /* clock_drift */,
uint32_t current_mic_level, uint32_t /* current_mic_level */,
bool key_pressed, bool /* key_pressed */,
uint32_t& new_mic_level, uint32_t& new_mic_level,
std::optional<int64_t> estimated_capture_time_ns) override { std::optional<int64_t> /* estimated_capture_time_ns */) override {
new_mic_level = 1; new_mic_level = 1;
if (mode_ != Mode::kRecording) { if (mode_ != Mode::kRecording) {
@ -97,26 +97,26 @@ class TestAudioTransport : public AudioTransport {
return 0; return 0;
} }
int32_t RecordedDataIsAvailable(const void* audio_samples, int32_t RecordedDataIsAvailable(const void* /* audio_samples */,
size_t samples_per_channel, size_t /* samples_per_channel */,
size_t bytes_per_sample, size_t /* bytes_per_sample */,
size_t number_of_channels, size_t /* number_of_channels */,
uint32_t samples_per_second, uint32_t /* samples_per_second */,
uint32_t total_delay_ms, uint32_t /* total_delay_ms */,
int32_t clockDrift, int32_t /* clockDrift */,
uint32_t current_mic_level, uint32_t /* current_mic_level */,
bool key_pressed, bool /* key_pressed */,
uint32_t& new_mic_level) override { uint32_t& /* new_mic_level */) override {
RTC_CHECK(false) << "This methods should be never executed"; RTC_CHECK(false) << "This methods should be never executed";
} }
void PullRenderData(int bits_per_sample, void PullRenderData(int /* bits_per_sample */,
int sample_rate, int /* sample_rate */,
size_t number_of_channels, size_t /* number_of_channels */,
size_t number_of_frames, size_t /* number_of_frames */,
void* audio_data, void* /* audio_data */,
int64_t* elapsed_time_ms, int64_t* /* elapsed_time_ms */,
int64_t* ntp_time_ms) override { int64_t* /* ntp_time_ms */) override {
RTC_CHECK(false) << "This methods should be never executed"; RTC_CHECK(false) << "This methods should be never executed";
} }

4
modules/audio_processing/aec3/echo_canceller3_unittest.cc
View File

@ -164,9 +164,9 @@ class RenderTransportVerificationProcessor : public BlockProcessor {
void GetMetrics(EchoControl::Metrics* /* metrics */) const override {} void GetMetrics(EchoControl::Metrics* /* metrics */) const override {}
void SetAudioBufferDelay(int delay_ms) override {} void SetAudioBufferDelay(int /* delay_ms */) override {}
void SetCaptureOutputUsage(bool capture_output_used) {} void SetCaptureOutputUsage(bool /* capture_output_used */) {}
private: private:
std::deque<Block> received_render_blocks_; std::deque<Block> received_render_blocks_;

13
modules/pacing/packet_router_unittest.cc
View File

@ -298,7 +298,7 @@ TEST_F(PacketRouterTest, PadsOnLastActiveMediaStream) {
RtpRtcpInterface* last_send_module; RtpRtcpInterface* last_send_module;
EXPECT_CALL(rtp_1, GeneratePadding(kPaddingBytes)) EXPECT_CALL(rtp_1, GeneratePadding(kPaddingBytes))
.Times(1) .Times(1)
.WillOnce([&](size_t target_size_bytes) { .WillOnce([&](size_t /* target_size_bytes */) {
last_send_module = &rtp_1; last_send_module = &rtp_1;
std::vector<std::unique_ptr<RtpPacketToSend>> packets; std::vector<std::unique_ptr<RtpPacketToSend>> packets;
packets.push_back(BuildRtpPacket(kSsrc1)); packets.push_back(BuildRtpPacket(kSsrc1));
@ -306,7 +306,7 @@ TEST_F(PacketRouterTest, PadsOnLastActiveMediaStream) {
}); });
EXPECT_CALL(rtp_3, GeneratePadding(kPaddingBytes)) EXPECT_CALL(rtp_3, GeneratePadding(kPaddingBytes))
.Times(1) .Times(1)
.WillOnce([&](size_t target_size_bytes) { .WillOnce([&](size_t /* target_size_bytes */) {
last_send_module = &rtp_3; last_send_module = &rtp_3;
std::vector<std::unique_ptr<RtpPacketToSend>> packets; std::vector<std::unique_ptr<RtpPacketToSend>> packets;
packets.push_back(BuildRtpPacket(kSsrc3)); packets.push_back(BuildRtpPacket(kSsrc3));
@ -371,7 +371,7 @@ TEST_F(PacketRouterTest, AllocatesTransportSequenceNumbers) {
EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>()); EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
EXPECT_CALL(notify_bwe_callback, Call) EXPECT_CALL(notify_bwe_callback, Call)
.WillOnce([](const RtpPacketToSend& packet, .WillOnce([](const RtpPacketToSend& packet,
const PacedPacketInfo& pacing_info) { const PacedPacketInfo& /* pacing_info */) {
EXPECT_EQ(packet.transport_sequence_number(), 1); EXPECT_EQ(packet.transport_sequence_number(), 1);
}); });
packet_router.SendPacket(std::move(packet), PacedPacketInfo()); packet_router.SendPacket(std::move(packet), PacedPacketInfo());
@ -442,9 +442,8 @@ TEST_F(PacketRouterTest, DoesNotIncrementTransportSequenceNumberOnSendFailure) {
// Return failure status code to make sure sequence number is not incremented. // Return failure status code to make sure sequence number is not incremented.
auto packet = BuildRtpPacket(kSsrc); auto packet = BuildRtpPacket(kSsrc);
EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>()); EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
EXPECT_CALL(rtp, CanSendPacket).WillOnce([&](const RtpPacketToSend& packet) { EXPECT_CALL(rtp, CanSendPacket)
return false; .WillOnce([&](const RtpPacketToSend& /* packet */) { return false; });
});
packet_router_.SendPacket(std::move(packet), PacedPacketInfo()); packet_router_.SendPacket(std::move(packet), PacedPacketInfo());
// Send another packet, verify transport sequence number is still at the // Send another packet, verify transport sequence number is still at the
@ -455,7 +454,7 @@ TEST_F(PacketRouterTest, DoesNotIncrementTransportSequenceNumberOnSendFailure) {
EXPECT_CALL(rtp, CanSendPacket).WillOnce(Return(true)); EXPECT_CALL(rtp, CanSendPacket).WillOnce(Return(true));
EXPECT_CALL(rtp, SendPacket) EXPECT_CALL(rtp, SendPacket)
.WillOnce([&](std::unique_ptr<RtpPacketToSend> packet, .WillOnce([&](std::unique_ptr<RtpPacketToSend> packet,
const PacedPacketInfo& pacing_info) { const PacedPacketInfo& /* pacing_info */) {
EXPECT_EQ(packet->transport_sequence_number(), EXPECT_EQ(packet->transport_sequence_number(),
kStartTransportSequenceNumber); kStartTransportSequenceNumber);
}); });

10
modules/pacing/task_queue_paced_sender_unittest.cc
View File

@ -142,8 +142,8 @@ TEST(TaskQueuePacedSenderTest, PacesPackets) {
size_t packets_sent = 0; size_t packets_sent = 0;
Timestamp end_time = Timestamp::PlusInfinity(); Timestamp end_time = Timestamp::PlusInfinity();
EXPECT_CALL(packet_router, SendPacket) EXPECT_CALL(packet_router, SendPacket)
.WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> packet, .WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> /* packet */,
const PacedPacketInfo& cluster_info) { const PacedPacketInfo& /* cluster_info */) {
++packets_sent; ++packets_sent;
if (packets_sent == kPacketsToSend) { if (packets_sent == kPacketsToSend) {
end_time = time_controller.GetClock()->CurrentTime(); end_time = time_controller.GetClock()->CurrentTime();
@ -188,8 +188,8 @@ TEST(TaskQueuePacedSenderTest, PacesPacketsWithBurst) {
size_t packets_sent = 0; size_t packets_sent = 0;
Timestamp end_time = Timestamp::PlusInfinity(); Timestamp end_time = Timestamp::PlusInfinity();
EXPECT_CALL(packet_router, SendPacket) EXPECT_CALL(packet_router, SendPacket)
.WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> packet, .WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> /* packet */,
const PacedPacketInfo& cluster_info) { const PacedPacketInfo& /* cluster_info */) {
++packets_sent; ++packets_sent;
if (packets_sent == kPacketsToSend) { if (packets_sent == kPacketsToSend) {
end_time = time_controller.GetClock()->CurrentTime(); end_time = time_controller.GetClock()->CurrentTime();
@ -240,7 +240,7 @@ TEST(TaskQueuePacedSenderTest, ReschedulesProcessOnRateChange) {
EXPECT_CALL(packet_router, SendPacket) EXPECT_CALL(packet_router, SendPacket)
.Times(3) .Times(3)
.WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> packet, .WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> /* packet */,
const PacedPacketInfo& cluster_info) { const PacedPacketInfo& cluster_info) {
if (first_packet_time.IsInfinite()) { if (first_packet_time.IsInfinite()) {
first_packet_time = time_controller.GetClock()->CurrentTime(); first_packet_time = time_controller.GetClock()->CurrentTime();

11
modules/remote_bitrate_estimator/congestion_control_feedback_generator_unittest.cc
View File

@ -40,11 +40,12 @@ using ::testing::MockFunction;
using ::testing::SizeIs; using ::testing::SizeIs;
using ::testing::WithoutArgs; using ::testing::WithoutArgs;
RtpPacketReceived CreatePacket(Timestamp arrival_time, RtpPacketReceived CreatePacket(
bool marker, Timestamp arrival_time,
uint32_t ssrc = 1234, bool marker,
uint16_t seq = 1, uint32_t ssrc = 1234,
rtc::EcnMarking ecn = rtc::EcnMarking::kNotEct) { uint16_t seq = 1,
rtc::EcnMarking /* ecn */ = rtc::EcnMarking::kNotEct) {
RtpPacketReceived packet; RtpPacketReceived packet;
packet.SetSsrc(ssrc); packet.SetSsrc(ssrc);
packet.SetSequenceNumber(seq); packet.SetSequenceNumber(seq);

2
modules/remote_bitrate_estimator/overuse_estimator.cc
View File

@ -32,7 +32,7 @@ void OveruseEstimator::Update(int64_t t_delta,
double ts_delta, double ts_delta,
int size_delta, int size_delta,
BandwidthUsage current_hypothesis, BandwidthUsage current_hypothesis,
int64_t now_ms) { int64_t /* now_ms */) {
const double min_frame_period = UpdateMinFramePeriod(ts_delta); const double min_frame_period = UpdateMinFramePeriod(ts_delta);
const double t_ts_delta = t_delta - ts_delta; const double t_ts_delta = t_delta - ts_delta;
double fs_delta = size_delta; double fs_delta = size_delta;

2
modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc
View File

@ -164,7 +164,7 @@ void RemoteBitrateEstimatorSingleStream::UpdateEstimate(Timestamp now) {
} }
void RemoteBitrateEstimatorSingleStream::OnRttUpdate(int64_t avg_rtt_ms, void RemoteBitrateEstimatorSingleStream::OnRttUpdate(int64_t avg_rtt_ms,
int64_t max_rtt_ms) { int64_t /* max_rtt_ms */) {
remote_rate_.SetRtt(TimeDelta::Millis(avg_rtt_ms)); remote_rate_.SetRtt(TimeDelta::Millis(avg_rtt_ms));
} }

4
modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.cc
View File

@ -29,7 +29,7 @@ const int kNumInitialPackets = 2;
namespace testing { namespace testing {
void TestBitrateObserver::OnReceiveBitrateChanged( void TestBitrateObserver::OnReceiveBitrateChanged(
const std::vector<uint32_t>& ssrcs, const std::vector<uint32_t>& /* ssrcs */,
uint32_t bitrate) { uint32_t bitrate) {
latest_bitrate_ = bitrate; latest_bitrate_ = bitrate;
updated_ = true; updated_ = true;
@ -251,7 +251,7 @@ void RemoteBitrateEstimatorTest::IncomingPacket(uint32_t ssrc,
// Returns true if an over-use was seen, false otherwise. // Returns true if an over-use was seen, false otherwise.
// The StreamGenerator::updated() should be used to check for any changes in // The StreamGenerator::updated() should be used to check for any changes in
// target bitrate after the call to this function. // target bitrate after the call to this function.
bool RemoteBitrateEstimatorTest::GenerateAndProcessFrame(uint32_t ssrc, bool RemoteBitrateEstimatorTest::GenerateAndProcessFrame(uint32_t /* ssrc */,
uint32_t bitrate_bps) { uint32_t bitrate_bps) {
RTC_DCHECK_GT(bitrate_bps, 0); RTC_DCHECK_GT(bitrate_bps, 0);
stream_generator_->SetBitrateBps(bitrate_bps); stream_generator_->SetBitrateBps(bitrate_bps);

2
modules/rtp_rtcp/source/absolute_capture_time_interpolator.cc
View File

@ -81,7 +81,7 @@ uint64_t AbsoluteCaptureTimeInterpolator::InterpolateAbsoluteCaptureTimestamp(
bool AbsoluteCaptureTimeInterpolator::ShouldInterpolateExtension( bool AbsoluteCaptureTimeInterpolator::ShouldInterpolateExtension(
Timestamp receive_time, Timestamp receive_time,
uint32_t source, uint32_t source,
uint32_t rtp_timestamp, uint32_t /* rtp_timestamp */,
int rtp_clock_frequency_hz) const { int rtp_clock_frequency_hz) const {
// Shouldn't if the last received extension is not eligible for interpolation, // Shouldn't if the last received extension is not eligible for interpolation,
// in particular if we don't have a previously received extension stored. // in particular if we don't have a previously received extension stored.

2
modules/rtp_rtcp/source/deprecated/deprecated_rtp_sender_egress.h
View File

@ -45,7 +45,7 @@ class DEPRECATED_RtpSenderEgress {
void EnqueuePackets( void EnqueuePackets(
std::vector<std::unique_ptr<RtpPacketToSend>> packets) override; std::vector<std::unique_ptr<RtpPacketToSend>> packets) override;
void RemovePacketsForSsrc(uint32_t ssrc) override {} void RemovePacketsForSsrc(uint32_t /* ssrc */) override {}
private: private:
uint16_t transport_sequence_number_; uint16_t transport_sequence_number_;

2
modules/rtp_rtcp/source/forward_error_correction.cc
View File

@ -571,7 +571,7 @@ bool ForwardErrorCorrection::StartPacketRecovery(
} }
bool ForwardErrorCorrection::FinishPacketRecovery( bool ForwardErrorCorrection::FinishPacketRecovery(
const ReceivedFecPacket& fec_packet, const ReceivedFecPacket& /* fec_packet */,
RecoveredPacket* recovered_packet) { RecoveredPacket* recovered_packet) {
uint8_t* data = recovered_packet->pkt->data.MutableData(); uint8_t* data = recovered_packet->pkt->data.MutableData();
// Set the RTP version to 2. // Set the RTP version to 2.

2
modules/rtp_rtcp/source/nack_rtx_unittest.cc
View File

@ -78,7 +78,7 @@ class RtxLoopBackTransport : public webrtc::Transport {
} }
bool SendRtp(rtc::ArrayView<const uint8_t> data, bool SendRtp(rtc::ArrayView<const uint8_t> data,
const PacketOptions& options) override { const PacketOptions& /* options */) override {
count_++; count_++;
RtpPacketReceived packet; RtpPacketReceived packet;
if (!packet.Parse(data)) if (!packet.Parse(data))

19
modules/rtp_rtcp/source/rtcp_sender.cc
View File

@ -221,7 +221,7 @@ bool RTCPSender::Sending() const {
return sending_; return sending_;
} }
void RTCPSender::SetSendingStatus(const FeedbackState& feedback_state, void RTCPSender::SetSendingStatus(const FeedbackState& /* feedback_state */,
bool sending) { bool sending) {
MutexLock lock(&mutex_rtcp_sender_); MutexLock lock(&mutex_rtcp_sender_);
sending_ = sending; sending_ = sending;
@ -404,7 +404,7 @@ void RTCPSender::BuildSR(const RtcpContext& ctx, PacketSender& sender) {
sender.AppendPacket(report); sender.AppendPacket(report);
} }
void RTCPSender::BuildSDES(const RtcpContext& ctx, PacketSender& sender) { void RTCPSender::BuildSDES(const RtcpContext& /* ctx */, PacketSender& sender) {
size_t length_cname = cname_.length(); size_t length_cname = cname_.length();
RTC_CHECK_LT(length_cname, RTCP_CNAME_SIZE); RTC_CHECK_LT(length_cname, RTCP_CNAME_SIZE);
@ -422,7 +422,7 @@ void RTCPSender::BuildRR(const RtcpContext& ctx, PacketSender& sender) {
} }
} }
void RTCPSender::BuildPLI(const RtcpContext& ctx, PacketSender& sender) { void RTCPSender::BuildPLI(const RtcpContext& /* ctx */, PacketSender& sender) {
rtcp::Pli pli; rtcp::Pli pli;
pli.SetSenderSsrc(ssrc_); pli.SetSenderSsrc(ssrc_);
pli.SetMediaSsrc(remote_ssrc_); pli.SetMediaSsrc(remote_ssrc_);
@ -431,7 +431,7 @@ void RTCPSender::BuildPLI(const RtcpContext& ctx, PacketSender& sender) {
sender.AppendPacket(pli); sender.AppendPacket(pli);
} }
void RTCPSender::BuildFIR(const RtcpContext& ctx, PacketSender& sender) { void RTCPSender::BuildFIR(const RtcpContext& /* ctx */, PacketSender& sender) {
++sequence_number_fir_; ++sequence_number_fir_;
rtcp::Fir fir; rtcp::Fir fir;
@ -442,7 +442,7 @@ void RTCPSender::BuildFIR(const RtcpContext& ctx, PacketSender& sender) {
sender.AppendPacket(fir); sender.AppendPacket(fir);
} }
void RTCPSender::BuildREMB(const RtcpContext& ctx, PacketSender& sender) { void RTCPSender::BuildREMB(const RtcpContext& /* ctx */, PacketSender& sender) {
rtcp::Remb remb; rtcp::Remb remb;
remb.SetSenderSsrc(ssrc_); remb.SetSenderSsrc(ssrc_);
remb.SetBitrateBps(remb_bitrate_); remb.SetBitrateBps(remb_bitrate_);
@ -509,7 +509,8 @@ void RTCPSender::BuildTMMBR(const RtcpContext& ctx, PacketSender& sender) {
sender.AppendPacket(tmmbr); sender.AppendPacket(tmmbr);
} }
void RTCPSender::BuildTMMBN(const RtcpContext& ctx, PacketSender& sender) { void RTCPSender::BuildTMMBN(const RtcpContext& /* ctx */,
PacketSender& sender) {
rtcp::Tmmbn tmmbn; rtcp::Tmmbn tmmbn;
tmmbn.SetSenderSsrc(ssrc_); tmmbn.SetSenderSsrc(ssrc_);
for (const rtcp::TmmbItem& tmmbr : tmmbn_to_send_) { for (const rtcp::TmmbItem& tmmbr : tmmbn_to_send_) {
@ -520,13 +521,13 @@ void RTCPSender::BuildTMMBN(const RtcpContext& ctx, PacketSender& sender) {
sender.AppendPacket(tmmbn); sender.AppendPacket(tmmbn);
} }
void RTCPSender::BuildAPP(const RtcpContext& ctx, PacketSender& sender) { void RTCPSender::BuildAPP(const RtcpContext& /* ctx */, PacketSender& sender) {
rtcp::App app; rtcp::App app;
app.SetSenderSsrc(ssrc_); app.SetSenderSsrc(ssrc_);
sender.AppendPacket(app); sender.AppendPacket(app);
} }
void RTCPSender::BuildLossNotification(const RtcpContext& ctx, void RTCPSender::BuildLossNotification(const RtcpContext& /* ctx */,
PacketSender& sender) { PacketSender& sender) {
loss_notification_.SetSenderSsrc(ssrc_); loss_notification_.SetSenderSsrc(ssrc_);
loss_notification_.SetMediaSsrc(remote_ssrc_); loss_notification_.SetMediaSsrc(remote_ssrc_);
@ -550,7 +551,7 @@ void RTCPSender::BuildNACK(const RtcpContext& ctx, PacketSender& sender) {
sender.AppendPacket(nack); sender.AppendPacket(nack);
} }
void RTCPSender::BuildBYE(const RtcpContext& ctx, PacketSender& sender) { void RTCPSender::BuildBYE(const RtcpContext& /* ctx */, PacketSender& sender) {
rtcp::Bye bye; rtcp::Bye bye;
bye.SetSenderSsrc(ssrc_); bye.SetSenderSsrc(ssrc_);
bye.SetCsrcs(csrcs_); bye.SetCsrcs(csrcs_);

2
modules/rtp_rtcp/source/rtcp_sender_unittest.cc
View File

@ -78,7 +78,7 @@ class TestTransport : public Transport {
TestTransport() {} TestTransport() {}
bool SendRtp(rtc::ArrayView<const uint8_t> /*data*/, bool SendRtp(rtc::ArrayView<const uint8_t> /*data*/,
const PacketOptions& options) override { const PacketOptions& /* options */) override {
return false; return false;
} }
bool SendRtcp(rtc::ArrayView<const uint8_t> data) override { bool SendRtcp(rtc::ArrayView<const uint8_t> data) override {

23
modules/rtp_rtcp/source/rtcp_transceiver_config.h
View File

@ -34,12 +34,13 @@ class MediaReceiverRtcpObserver {
public: public:
virtual ~MediaReceiverRtcpObserver() = default; virtual ~MediaReceiverRtcpObserver() = default;
virtual void OnSenderReport(uint32_t sender_ssrc, virtual void OnSenderReport(uint32_t /* sender_ssrc */,
NtpTime ntp_time, NtpTime /* ntp_time */,
uint32_t rtp_time) {} uint32_t /* rtp_time */) {}
virtual void OnBye(uint32_t sender_ssrc) {} virtual void OnBye(uint32_t /* sender_ssrc */) {}
virtual void OnBitrateAllocation(uint32_t sender_ssrc, virtual void OnBitrateAllocation(
const VideoBitrateAllocation& allocation) {} uint32_t /* sender_ssrc */,
const VideoBitrateAllocation& /* allocation */) {}
}; };
// Handles RTCP related messages for a single RTP stream (i.e. single SSRC) // Handles RTCP related messages for a single RTP stream (i.e. single SSRC)
@ -76,14 +77,14 @@ class RtpStreamRtcpHandler {
}; };
virtual RtpStats SentStats() = 0; virtual RtpStats SentStats() = 0;
virtual void OnNack(uint32_t sender_ssrc, virtual void OnNack(uint32_t /* sender_ssrc */,
rtc::ArrayView<const uint16_t> sequence_numbers) {} rtc::ArrayView<const uint16_t> /* sequence_numbers */) {}
virtual void OnFir(uint32_t sender_ssrc) {} virtual void OnFir(uint32_t /* sender_ssrc */) {}
virtual void OnPli(uint32_t sender_ssrc) {} virtual void OnPli(uint32_t /* sender_ssrc */) {}
// Called on an RTCP packet with sender or receiver reports with a report // Called on an RTCP packet with sender or receiver reports with a report
// block for the handled RTP stream. // block for the handled RTP stream.
virtual void OnReport(const ReportBlockData& report_block) {} virtual void OnReport(const ReportBlockData& /* report_block */) {}
}; };
struct RtcpTransceiverConfig { struct RtcpTransceiverConfig {

3
modules/rtp_rtcp/source/rtcp_transceiver_impl.cc
View File

@ -56,7 +56,8 @@ std::function<void(rtc::ArrayView<const uint8_t>)> GetRtcpTransport(
bool first = true; bool first = true;
std::string log_prefix = config.debug_id; std::string log_prefix = config.debug_id;
return [first, log_prefix](rtc::ArrayView<const uint8_t> packet) mutable { return [first,
log_prefix](rtc::ArrayView<const uint8_t> /* packet */) mutable {
if (first) { if (first) {
RTC_LOG(LS_ERROR) << log_prefix << "Sending RTCP packets is disabled."; RTC_LOG(LS_ERROR) << log_prefix << "Sending RTCP packets is disabled.";
first = false; first = false;

2
modules/rtp_rtcp/source/rtp_fec_unittest.cc
View File

@ -184,7 +184,7 @@ class FlexfecForwardErrorCorrection : public ForwardErrorCorrection {
// For FlexFEC we let the FEC packet sequence numbers be independent of // For FlexFEC we let the FEC packet sequence numbers be independent of
// the media packet sequence numbers. // the media packet sequence numbers.
static uint16_t GetFirstFecSeqNum(uint16_t next_media_seq_num) { static uint16_t GetFirstFecSeqNum(uint16_t /* next_media_seq_num */) {
Random random(0xbe110); Random random(0xbe110);
return random.Rand<uint16_t>(); return random.Rand<uint16_t>();
} }

14
modules/rtp_rtcp/source/rtp_header_extensions.h
View File

@ -48,7 +48,9 @@ class AbsoluteSendTime {
} }
static bool Parse(rtc::ArrayView<const uint8_t> data, uint32_t* time_24bits); static bool Parse(rtc::ArrayView<const uint8_t> data, uint32_t* time_24bits);
static size_t ValueSize(uint32_t time_24bits) { return kValueSizeBytes; } static size_t ValueSize(uint32_t /* time_24bits */) {
return kValueSizeBytes;
}
static bool Write(rtc::ArrayView<uint8_t> data, uint32_t time_24bits); static bool Write(rtc::ArrayView<uint8_t> data, uint32_t time_24bits);
static constexpr uint32_t To24Bits(Timestamp time) { static constexpr uint32_t To24Bits(Timestamp time) {
@ -98,7 +100,7 @@ class AudioLevelExtension {
} }
static bool Parse(rtc::ArrayView<const uint8_t> data, AudioLevel* extension); static bool Parse(rtc::ArrayView<const uint8_t> data, AudioLevel* extension);
static size_t ValueSize(const AudioLevel& extension) { static size_t ValueSize(const AudioLevel& /* extension */) {
return kValueSizeBytes; return kValueSizeBytes;
} }
static bool Write(rtc::ArrayView<uint8_t> data, const AudioLevel& extension); static bool Write(rtc::ArrayView<uint8_t> data, const AudioLevel& extension);
@ -129,7 +131,7 @@ class TransmissionOffset {
} }
static bool Parse(rtc::ArrayView<const uint8_t> data, int32_t* rtp_time); static bool Parse(rtc::ArrayView<const uint8_t> data, int32_t* rtp_time);
static size_t ValueSize(int32_t rtp_time) { return kValueSizeBytes; } static size_t ValueSize(int32_t /* rtp_time */) { return kValueSizeBytes; }
static bool Write(rtc::ArrayView<uint8_t> data, int32_t rtp_time); static bool Write(rtc::ArrayView<uint8_t> data, int32_t rtp_time);
}; };
@ -191,7 +193,7 @@ class VideoOrientation {
static size_t ValueSize(VideoRotation) { return kValueSizeBytes; } static size_t ValueSize(VideoRotation) { return kValueSizeBytes; }
static bool Write(rtc::ArrayView<uint8_t> data, VideoRotation value); static bool Write(rtc::ArrayView<uint8_t> data, VideoRotation value);
static bool Parse(rtc::ArrayView<const uint8_t> data, uint8_t* value); static bool Parse(rtc::ArrayView<const uint8_t> data, uint8_t* value);
static size_t ValueSize(uint8_t value) { return kValueSizeBytes; } static size_t ValueSize(uint8_t /* value */) { return kValueSizeBytes; }
static bool Write(rtc::ArrayView<uint8_t> data, uint8_t value); static bool Write(rtc::ArrayView<uint8_t> data, uint8_t value);
}; };
@ -259,7 +261,7 @@ class VideoTimingExtension {
static bool Write(rtc::ArrayView<uint8_t> data, static bool Write(rtc::ArrayView<uint8_t> data,
const VideoSendTiming& timing); const VideoSendTiming& timing);
static size_t ValueSize(uint16_t time_delta_ms, uint8_t idx) { static size_t ValueSize(uint16_t /* time_delta_ms */, uint8_t /* idx */) {
return kValueSizeBytes; return kValueSizeBytes;
} }
// Writes only single time delta to position idx. // Writes only single time delta to position idx.
@ -354,7 +356,7 @@ class InbandComfortNoiseExtension {
static bool Parse(rtc::ArrayView<const uint8_t> data, static bool Parse(rtc::ArrayView<const uint8_t> data,
std::optional<uint8_t>* level); std::optional<uint8_t>* level);
static size_t ValueSize(std::optional<uint8_t> level) { static size_t ValueSize(std::optional<uint8_t> /* level */) {
return kValueSizeBytes; return kValueSizeBytes;
} }
static bool Write(rtc::ArrayView<uint8_t> data, std::optional<uint8_t> level); static bool Write(rtc::ArrayView<uint8_t> data, std::optional<uint8_t> level);

14
modules/rtp_rtcp/source/rtp_packet_unittest.cc
View File

@ -874,13 +874,13 @@ struct UncopyableExtension {
static constexpr RTPExtensionType kId = kRtpExtensionDependencyDescriptor; static constexpr RTPExtensionType kId = kRtpExtensionDependencyDescriptor;
static constexpr absl::string_view Uri() { return "uri"; } static constexpr absl::string_view Uri() { return "uri"; }
static size_t ValueSize(const UncopyableValue& value) { return 1; } static size_t ValueSize(const UncopyableValue& /* value */) { return 1; }
static bool Write(rtc::ArrayView<uint8_t> data, static bool Write(rtc::ArrayView<uint8_t> /* data */,
const UncopyableValue& value) { const UncopyableValue& /* value */) {
return true; return true;
} }
static bool Parse(rtc::ArrayView<const uint8_t> data, static bool Parse(rtc::ArrayView<const uint8_t> /* data */,
UncopyableValue* value) { UncopyableValue* /* value */) {
return true; return true;
} }
}; };
@ -909,7 +909,9 @@ struct ParseByReferenceExtension {
static constexpr RTPExtensionType kId = kRtpExtensionDependencyDescriptor; static constexpr RTPExtensionType kId = kRtpExtensionDependencyDescriptor;
static constexpr absl::string_view Uri() { return "uri"; } static constexpr absl::string_view Uri() { return "uri"; }
static size_t ValueSize(uint8_t value1, uint8_t value2) { return 2; } static size_t ValueSize(uint8_t /* value1 */, uint8_t /* value2 */) {
return 2;
}
static bool Write(rtc::ArrayView<uint8_t> data, static bool Write(rtc::ArrayView<uint8_t> data,
uint8_t value1, uint8_t value1,
uint8_t value2) { uint8_t value2) {

5
modules/rtp_rtcp/source/rtp_rtcp_impl.cc
View File

@ -219,7 +219,8 @@ void ModuleRtpRtcpImpl::RegisterSendPayloadFrequency(int payload_type,
rtcp_sender_.SetRtpClockRate(payload_type, payload_frequency); rtcp_sender_.SetRtpClockRate(payload_type, payload_frequency);
} }
int32_t ModuleRtpRtcpImpl::DeRegisterSendPayload(const int8_t payload_type) { int32_t ModuleRtpRtcpImpl::DeRegisterSendPayload(
const int8_t /* payload_type */) {
return 0; return 0;
} }
@ -402,7 +403,7 @@ ModuleRtpRtcpImpl::FetchFecPackets() {
} }
void ModuleRtpRtcpImpl::OnAbortedRetransmissions( void ModuleRtpRtcpImpl::OnAbortedRetransmissions(
rtc::ArrayView<const uint16_t> sequence_numbers) { rtc::ArrayView<const uint16_t> /* sequence_numbers */) {
RTC_DCHECK_NOTREACHED() RTC_DCHECK_NOTREACHED()
<< "Stream flushing not supported with legacy rtp modules."; << "Stream flushing not supported with legacy rtp modules.";
} }

10
modules/rtp_rtcp/source/rtp_rtcp_impl.h
View File

@ -103,7 +103,7 @@ class ABSL_DEPRECATED("") ModuleRtpRtcpImpl
RtpState GetRtpState() const override; RtpState GetRtpState() const override;
RtpState GetRtxState() const override; RtpState GetRtxState() const override;
void SetNonSenderRttMeasurement(bool enabled) override {} void SetNonSenderRttMeasurement(bool /* enabled */) override {}
uint32_t SSRC() const override { return rtcp_sender_.SSRC(); } uint32_t SSRC() const override { return rtcp_sender_.SSRC(); }
@ -142,17 +142,17 @@ class ABSL_DEPRECATED("") ModuleRtpRtcpImpl
bool TrySendPacket(std::unique_ptr<RtpPacketToSend> packet, bool TrySendPacket(std::unique_ptr<RtpPacketToSend> packet,
const PacedPacketInfo& pacing_info) override; const PacedPacketInfo& pacing_info) override;
bool CanSendPacket(const RtpPacketToSend& packet) const override { bool CanSendPacket(const RtpPacketToSend& /* packet */) const override {
RTC_DCHECK_NOTREACHED() << "Not implemented"; RTC_DCHECK_NOTREACHED() << "Not implemented";
return false; return false;
} }
void AssignSequenceNumber(RtpPacketToSend& packet) override { void AssignSequenceNumber(RtpPacketToSend& /* packet */) override {
RTC_DCHECK_NOTREACHED() << "Not implemented"; RTC_DCHECK_NOTREACHED() << "Not implemented";
} }
void SendPacket(std::unique_ptr<RtpPacketToSend> packet, void SendPacket(std::unique_ptr<RtpPacketToSend> /* packet */,
const PacedPacketInfo& pacing_info) override { const PacedPacketInfo& /* pacing_info */) override {
RTC_DCHECK_NOTREACHED() << "Not implemented"; RTC_DCHECK_NOTREACHED() << "Not implemented";
} }

3
modules/rtp_rtcp/source/rtp_rtcp_impl2.cc
View File

@ -169,7 +169,8 @@ void ModuleRtpRtcpImpl2::RegisterSendPayloadFrequency(int payload_type,
rtcp_sender_.SetRtpClockRate(payload_type, payload_frequency); rtcp_sender_.SetRtpClockRate(payload_type, payload_frequency);
} }
int32_t ModuleRtpRtcpImpl2::DeRegisterSendPayload(const int8_t payload_type) { int32_t ModuleRtpRtcpImpl2::DeRegisterSendPayload(
const int8_t /* payload_type */) {
return 0; return 0;
} }

2
modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc
View File

@ -104,7 +104,7 @@ class SendTransport : public Transport,
void SetRtpRtcpModule(ModuleRtpRtcpImpl2* receiver) { receiver_ = receiver; } void SetRtpRtcpModule(ModuleRtpRtcpImpl2* receiver) { receiver_ = receiver; }
void SimulateNetworkDelay(TimeDelta delay) { delay_ = delay; } void SimulateNetworkDelay(TimeDelta delay) { delay_ = delay; }
bool SendRtp(rtc::ArrayView<const uint8_t> data, bool SendRtp(rtc::ArrayView<const uint8_t> data,
const PacketOptions& options) override { const PacketOptions& /* options */) override {
EXPECT_TRUE(last_packet_.Parse(data)); EXPECT_TRUE(last_packet_.Parse(data));
++rtp_packets_sent_; ++rtp_packets_sent_;
return true; return true;

2
modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
View File

@ -96,7 +96,7 @@ class SendTransport : public Transport {
delay_ms_ = delay_ms; delay_ms_ = delay_ms;
} }
bool SendRtp(rtc::ArrayView<const uint8_t> data, bool SendRtp(rtc::ArrayView<const uint8_t> data,
const PacketOptions& options) override { const PacketOptions& /* options */) override {
RtpPacket packet; RtpPacket packet;
EXPECT_TRUE(packet.Parse(data)); EXPECT_TRUE(packet.Parse(data));
++rtp_packets_sent_; ++rtp_packets_sent_;

5
modules/rtp_rtcp/source/rtp_sender.cc
View File

@ -327,7 +327,8 @@ int32_t RTPSender::ReSendPacket(uint16_t packet_id) {
return packet_size; return packet_size;
} }
void RTPSender::OnReceivedAckOnSsrc(int64_t extended_highest_sequence_number) { void RTPSender::OnReceivedAckOnSsrc(
int64_t /* extended_highest_sequence_number */) {
MutexLock lock(&send_mutex_); MutexLock lock(&send_mutex_);
bool update_required = !ssrc_has_acked_; bool update_required = !ssrc_has_acked_;
ssrc_has_acked_ = true; ssrc_has_acked_ = true;
@ -337,7 +338,7 @@ void RTPSender::OnReceivedAckOnSsrc(int64_t extended_highest_sequence_number) {
} }
void RTPSender::OnReceivedAckOnRtxSsrc( void RTPSender::OnReceivedAckOnRtxSsrc(
int64_t extended_highest_sequence_number) { int64_t /* extended_highest_sequence_number */) {
MutexLock lock(&send_mutex_); MutexLock lock(&send_mutex_);
bool update_required = !rtx_ssrc_has_acked_; bool update_required = !rtx_ssrc_has_acked_;
rtx_ssrc_has_acked_ = true; rtx_ssrc_has_acked_ = true;

4
modules/rtp_rtcp/source/rtp_sender_audio.cc
View File

@ -47,8 +47,8 @@ RTPSenderAudio::~RTPSenderAudio() {}
int32_t RTPSenderAudio::RegisterAudioPayload(absl::string_view payload_name, int32_t RTPSenderAudio::RegisterAudioPayload(absl::string_view payload_name,
const int8_t payload_type, const int8_t payload_type,
const uint32_t frequency, const uint32_t frequency,
const size_t channels, const size_t /* channels */,
const uint32_t rate) { const uint32_t /* rate */) {
if (absl::EqualsIgnoreCase(payload_name, "cn")) { if (absl::EqualsIgnoreCase(payload_name, "cn")) {
MutexLock lock(&send_audio_mutex_); MutexLock lock(&send_audio_mutex_);
// we can have multiple CNG payload types // we can have multiple CNG payload types

4
modules/rtp_rtcp/source/rtp_sender_audio_unittest.cc
View File

@ -52,7 +52,9 @@ class LoopbackTransportTest : public webrtc::Transport {
EXPECT_TRUE(sent_packets_.back().Parse(data)); EXPECT_TRUE(sent_packets_.back().Parse(data));
return true; return true;
} }
bool SendRtcp(rtc::ArrayView<const uint8_t> data) override { return false; } bool SendRtcp(rtc::ArrayView<const uint8_t> /* data */) override {
return false;
}
const RtpPacketReceived& last_sent_packet() { return sent_packets_.back(); } const RtpPacketReceived& last_sent_packet() { return sent_packets_.back(); }
int packets_sent() { return sent_packets_.size(); } int packets_sent() { return sent_packets_.size(); }

2
modules/rtp_rtcp/source/rtp_sender_egress.h
View File

@ -54,7 +54,7 @@ class RtpSenderEgress {
void EnqueuePackets( void EnqueuePackets(
std::vector<std::unique_ptr<RtpPacketToSend>> packets) override; std::vector<std::unique_ptr<RtpPacketToSend>> packets) override;
// Since we don't pace packets, there's no pending packets to remove. // Since we don't pace packets, there's no pending packets to remove.
void RemovePacketsForSsrc(uint32_t ssrc) override {} void RemovePacketsForSsrc(uint32_t /* ssrc */) override {}
private: private:
void PrepareForSend(RtpPacketToSend* packet); void PrepareForSend(RtpPacketToSend* packet);

8
modules/rtp_rtcp/source/rtp_sender_video_unittest.cc
View File

@ -123,12 +123,14 @@ class LoopbackTransportTest : public webrtc::Transport {
} }
bool SendRtp(rtc::ArrayView<const uint8_t> data, bool SendRtp(rtc::ArrayView<const uint8_t> data,
const PacketOptions& options) override { const PacketOptions& /* options */) override {
sent_packets_.push_back(RtpPacketReceived(&receivers_extensions_)); sent_packets_.push_back(RtpPacketReceived(&receivers_extensions_));
EXPECT_TRUE(sent_packets_.back().Parse(data)); EXPECT_TRUE(sent_packets_.back().Parse(data));
return true; return true;
} }
bool SendRtcp(rtc::ArrayView<const uint8_t> data) override { return false; } bool SendRtcp(rtc::ArrayView<const uint8_t> /* data */) override {
return false;
}
const RtpPacketReceived& last_sent_packet() { return sent_packets_.back(); } const RtpPacketReceived& last_sent_packet() { return sent_packets_.back(); }
int packets_sent() { return sent_packets_.size(); } int packets_sent() { return sent_packets_.size(); }
const std::vector<RtpPacketReceived>& sent_packets() const { const std::vector<RtpPacketReceived>& sent_packets() const {
@ -969,7 +971,7 @@ TEST_F(RtpSenderVideoTest, PopulateGenericFrameDescriptor) {
void RtpSenderVideoTest:: void RtpSenderVideoTest::
UsesMinimalVp8DescriptorWhenGenericFrameDescriptorExtensionIsUsed( UsesMinimalVp8DescriptorWhenGenericFrameDescriptorExtensionIsUsed(
int version) { int /* version */) {
const int64_t kFrameId = 100000; const int64_t kFrameId = 100000;
const size_t kFrameSize = 100; const size_t kFrameSize = 100;
uint8_t kFrame[kFrameSize]; uint8_t kFrame[kFrameSize];

2
modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc
View File

@ -98,7 +98,7 @@ UlpfecHeaderWriter::~UlpfecHeaderWriter() = default;
// returns a bound on the sequence number spread), if logic is added to // returns a bound on the sequence number spread), if logic is added to
// UlpfecHeaderWriter::FinalizeFecHeader to truncate packet masks which end // UlpfecHeaderWriter::FinalizeFecHeader to truncate packet masks which end
// in a string of zeroes. (Similar to how it is done in the FlexFEC case.) // in a string of zeroes. (Similar to how it is done in the FlexFEC case.)
size_t UlpfecHeaderWriter::MinPacketMaskSize(const uint8_t* packet_mask, size_t UlpfecHeaderWriter::MinPacketMaskSize(const uint8_t* /* packet_mask */,
size_t packet_mask_size) const { size_t packet_mask_size) const {
return packet_mask_size; return packet_mask_size;
} }

2
modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc
View File

@ -41,7 +41,7 @@ constexpr uint32_t kMediaSsrc = 835424;
class NullRecoveredPacketReceiver : public RecoveredPacketReceiver { class NullRecoveredPacketReceiver : public RecoveredPacketReceiver {
public: public:
void OnRecoveredPacket(const RtpPacketReceived& packet) override {} void OnRecoveredPacket(const RtpPacketReceived& /* packet */) override {}
}; };
} // namespace } // namespace

2
modules/rtp_rtcp/test/testFec/test_packet_masks_metrics.cc
View File

@ -693,7 +693,7 @@ class FecPacketMaskMetricsTest : public ::testing::Test {
int num_media_packets, int num_media_packets,
int num_fec_packets, int num_fec_packets,
int mask_bytes_fec_packet, int mask_bytes_fec_packet,
CodeType code_type) { CodeType /* code_type */) {
for (int i = 0; i < num_fec_packets; i++) { for (int i = 0; i < num_fec_packets; i++) {
for (int j = 0; j < num_media_packets; j++) { for (int j = 0; j < num_media_packets; j++) {
const uint8_t byte_mask = const uint8_t byte_mask =

2
modules/video_capture/device_info_impl.cc
View File

@ -202,7 +202,7 @@ int32_t DeviceInfoImpl::GetBestMatchedCapability(
} }
// Default implementation. This should be overridden by Mobile implementations. // Default implementation. This should be overridden by Mobile implementations.
int32_t DeviceInfoImpl::GetOrientation(const char* deviceUniqueIdUTF8, int32_t DeviceInfoImpl::GetOrientation(const char* /* deviceUniqueIdUTF8 */,
VideoRotation& orientation) { VideoRotation& orientation) {
orientation = kVideoRotation_0; orientation = kVideoRotation_0;
return -1; return -1;

8
modules/video_capture/video_capture_factory.cc
View File

@ -15,7 +15,7 @@
namespace webrtc { namespace webrtc {
rtc::scoped_refptr<VideoCaptureModule> VideoCaptureFactory::Create( rtc::scoped_refptr<VideoCaptureModule> VideoCaptureFactory::Create(
const char* deviceUniqueIdUTF8) { [[maybe_unused]] const char* deviceUniqueIdUTF8) {
#if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC) #if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC)
return nullptr; return nullptr;
#else #else
@ -24,8 +24,8 @@ rtc::scoped_refptr<VideoCaptureModule> VideoCaptureFactory::Create(
} }
rtc::scoped_refptr<VideoCaptureModule> VideoCaptureFactory::Create( rtc::scoped_refptr<VideoCaptureModule> VideoCaptureFactory::Create(
VideoCaptureOptions* options, [[maybe_unused]] VideoCaptureOptions* options,
const char* deviceUniqueIdUTF8) { [[maybe_unused]] const char* deviceUniqueIdUTF8) {
// This is only implemented on pure Linux and WEBRTC_LINUX is defined for // This is only implemented on pure Linux and WEBRTC_LINUX is defined for
// Android as well // Android as well
#if !defined(WEBRTC_LINUX) || defined(WEBRTC_ANDROID) #if !defined(WEBRTC_LINUX) || defined(WEBRTC_ANDROID)
@ -45,7 +45,7 @@ VideoCaptureModule::DeviceInfo* VideoCaptureFactory::CreateDeviceInfo() {
} }
VideoCaptureModule::DeviceInfo* VideoCaptureFactory::CreateDeviceInfo( VideoCaptureModule::DeviceInfo* VideoCaptureFactory::CreateDeviceInfo(
VideoCaptureOptions* options) { [[maybe_unused]] VideoCaptureOptions* options) {
// This is only implemented on pure Linux and WEBRTC_LINUX is defined for // This is only implemented on pure Linux and WEBRTC_LINUX is defined for
// Android as well // Android as well
#if !defined(WEBRTC_LINUX) || defined(WEBRTC_ANDROID) #if !defined(WEBRTC_LINUX) || defined(WEBRTC_ANDROID)

2
modules/video_coding/codecs/av1/dav1d_decoder.cc
View File

@ -72,7 +72,7 @@ class ScopedDav1dPicture
constexpr char kDav1dName[] = "dav1d"; constexpr char kDav1dName[] = "dav1d";
// Calling `dav1d_data_wrap` requires a `free_callback` to be registered. // Calling `dav1d_data_wrap` requires a `free_callback` to be registered.
void NullFreeCallback(const uint8_t* buffer, void* opaque) {} void NullFreeCallback(const uint8_t* /* buffer */, void* /* opaque */) {}
Dav1dDecoder::Dav1dDecoder() = default; Dav1dDecoder::Dav1dDecoder() = default;

2
modules/video_coding/codecs/av1/libaom_av1_encoder_unittest.cc
View File

@ -415,7 +415,7 @@ TEST(LibaomAv1EncoderTest, AdheresToTargetBitrateDespiteUnevenFrameTiming) {
private: private:
Result OnEncodedImage( Result OnEncodedImage(
const EncodedImage& encoded_image, const EncodedImage& encoded_image,
const CodecSpecificInfo* codec_specific_info) override { const CodecSpecificInfo* /* codec_specific_info */) override {
bytes_encoded_ += DataSize::Bytes(encoded_image.size()); bytes_encoded_ += DataSize::Bytes(encoded_image.size());
return Result(Result::Error::OK); return Result(Result::Error::OK);
} }

4
modules/video_coding/codecs/h264/h264.cc
View File

@ -134,8 +134,8 @@ H264EncoderSettings H264EncoderSettings::Parse(const SdpVideoFormat& format) {
} }
absl::Nonnull<std::unique_ptr<VideoEncoder>> CreateH264Encoder( absl::Nonnull<std::unique_ptr<VideoEncoder>> CreateH264Encoder(
const Environment& env, [[maybe_unused]] const Environment& env,
H264EncoderSettings settings) { [[maybe_unused]] H264EncoderSettings settings) {
#if defined(WEBRTC_USE_H264) #if defined(WEBRTC_USE_H264)
RTC_CHECK(g_rtc_use_h264); RTC_CHECK(g_rtc_use_h264);
RTC_LOG(LS_INFO) << "Creating H264EncoderImpl."; RTC_LOG(LS_INFO) << "Creating H264EncoderImpl.";

5
modules/video_coding/codecs/test/video_codec_unittest.cc
View File

@ -57,7 +57,7 @@ VideoCodecUnitTest::FakeEncodeCompleteCallback::OnEncodedImage(
void VideoCodecUnitTest::FakeDecodeCompleteCallback::Decoded( void VideoCodecUnitTest::FakeDecodeCompleteCallback::Decoded(
VideoFrame& frame, VideoFrame& frame,
std::optional<int32_t> decode_time_ms, std::optional<int32_t> /* decode_time_ms */,
std::optional<uint8_t> qp) { std::optional<uint8_t> qp) {
MutexLock lock(&test_->decoded_frame_section_); MutexLock lock(&test_->decoded_frame_section_);
test_->decoded_frame_.emplace(frame); test_->decoded_frame_.emplace(frame);
@ -97,7 +97,8 @@ void VideoCodecUnitTest::SetUp() {
EXPECT_TRUE(decoder_->Configure(decoder_settings)); EXPECT_TRUE(decoder_->Configure(decoder_settings));
} }
void VideoCodecUnitTest::ModifyCodecSettings(VideoCodec* codec_settings) {} void VideoCodecUnitTest::ModifyCodecSettings(VideoCodec* /* codec_settings */) {
}
VideoFrame VideoCodecUnitTest::NextInputFrame() { VideoFrame VideoCodecUnitTest::NextInputFrame() {
test::FrameGeneratorInterface::VideoFrameData frame_data = test::FrameGeneratorInterface::VideoFrameData frame_data =

5
modules/video_coding/codecs/test/video_codec_unittest.h
View File

@ -56,11 +56,12 @@ class VideoCodecUnitTest : public ::testing::Test {
explicit FakeDecodeCompleteCallback(VideoCodecUnitTest* test) explicit FakeDecodeCompleteCallback(VideoCodecUnitTest* test)
: test_(test) {} : test_(test) {}
int32_t Decoded(VideoFrame& frame) override { int32_t Decoded(VideoFrame& /* frame */) override {
RTC_DCHECK_NOTREACHED(); RTC_DCHECK_NOTREACHED();
return -1; return -1;
} }
int32_t Decoded(VideoFrame& frame, int64_t decode_time_ms) override { int32_t Decoded(VideoFrame& /* frame */,
int64_t /* decode_time_ms */) override {
RTC_DCHECK_NOTREACHED(); RTC_DCHECK_NOTREACHED();
return -1; return -1;
} }

2
modules/video_coding/codecs/test/videocodec_test_libvpx.cc
View File

@ -364,7 +364,7 @@ TEST(VideoCodecTestLibvpx, MAYBE_SimulcastVP8) {
InternalEncoderFactory internal_encoder_factory; InternalEncoderFactory internal_encoder_factory;
auto adapted_encoder_factory = std::make_unique<FunctionVideoEncoderFactory>( auto adapted_encoder_factory = std::make_unique<FunctionVideoEncoderFactory>(
[&](const Environment& env, const SdpVideoFormat& format) { [&](const Environment& env, const SdpVideoFormat& /* format */) {
return std::make_unique<SimulcastEncoderAdapter>( return std::make_unique<SimulcastEncoderAdapter>(
env, &internal_encoder_factory, nullptr, SdpVideoFormat::VP8()); env, &internal_encoder_factory, nullptr, SdpVideoFormat::VP8());
}); });

4
modules/video_coding/codecs/test/videoprocessor.cc
View File

@ -644,8 +644,8 @@ void VideoProcessor::DecodeFrame(const EncodedImage& encoded_image,
const webrtc::EncodedImage* VideoProcessor::BuildAndStoreSuperframe( const webrtc::EncodedImage* VideoProcessor::BuildAndStoreSuperframe(
const EncodedImage& encoded_image, const EncodedImage& encoded_image,
const VideoCodecType codec, const VideoCodecType /* codec */,
size_t frame_number, size_t /* frame_number */,
size_t spatial_idx, size_t spatial_idx,
bool inter_layer_predicted) { bool inter_layer_predicted) {
// Should only be called for SVC. // Should only be called for SVC.

6
modules/video_coding/codecs/test/videoprocessor.h
View File

@ -141,13 +141,13 @@ class VideoProcessor {
int32_t Decoded(webrtc::VideoFrame& image) override; int32_t Decoded(webrtc::VideoFrame& image) override;
int32_t Decoded(webrtc::VideoFrame& image, int32_t Decoded(webrtc::VideoFrame& image,
int64_t decode_time_ms) override { int64_t /* decode_time_ms */) override {
return Decoded(image); return Decoded(image);
} }
void Decoded(webrtc::VideoFrame& image, void Decoded(webrtc::VideoFrame& image,
std::optional<int32_t> decode_time_ms, std::optional<int32_t> /* decode_time_ms */,
std::optional<uint8_t> qp) override { std::optional<uint8_t> /* qp */) override {
Decoded(image); Decoded(image);
} }

17
modules/video_coding/codecs/vp8/default_temporal_layers.cc
View File

@ -240,8 +240,8 @@ DefaultTemporalLayers::DefaultTemporalLayers(int number_of_temporal_layers)
DefaultTemporalLayers::~DefaultTemporalLayers() = default; DefaultTemporalLayers::~DefaultTemporalLayers() = default;
void DefaultTemporalLayers::SetQpLimits(size_t stream_index, void DefaultTemporalLayers::SetQpLimits(size_t stream_index,
int min_qp, int /* min_qp */,
int max_qp) { int /* max_qp */) {
RTC_DCHECK_LT(stream_index, StreamCount()); RTC_DCHECK_LT(stream_index, StreamCount());
// Ignore. // Ignore.
} }
@ -260,7 +260,7 @@ bool DefaultTemporalLayers::SupportsEncoderFrameDropping(
void DefaultTemporalLayers::OnRatesUpdated( void DefaultTemporalLayers::OnRatesUpdated(
size_t stream_index, size_t stream_index,
const std::vector<uint32_t>& bitrates_bps, const std::vector<uint32_t>& bitrates_bps,
int framerate_fps) { int /* framerate_fps */) {
RTC_DCHECK_LT(stream_index, StreamCount()); RTC_DCHECK_LT(stream_index, StreamCount());
RTC_DCHECK_GT(bitrates_bps.size(), 0); RTC_DCHECK_GT(bitrates_bps.size(), 0);
RTC_DCHECK_LE(bitrates_bps.size(), num_layers_); RTC_DCHECK_LE(bitrates_bps.size(), num_layers_);
@ -471,7 +471,7 @@ void DefaultTemporalLayers::OnEncodeDone(size_t stream_index,
uint32_t rtp_timestamp, uint32_t rtp_timestamp,
size_t size_bytes, size_t size_bytes,
bool is_keyframe, bool is_keyframe,
int qp, int /* qp */,
CodecSpecificInfo* info) { CodecSpecificInfo* info) {
RTC_DCHECK_LT(stream_index, StreamCount()); RTC_DCHECK_LT(stream_index, StreamCount());
RTC_DCHECK_GT(num_layers_, 0); RTC_DCHECK_GT(num_layers_, 0);
@ -576,7 +576,7 @@ void DefaultTemporalLayers::OnEncodeDone(size_t stream_index,
pending_frames_.pop_front(); pending_frames_.pop_front();
} }
void DefaultTemporalLayers::OnFrameDropped(size_t stream_index, void DefaultTemporalLayers::OnFrameDropped(size_t /* stream_index */,
uint32_t rtp_timestamp) { uint32_t rtp_timestamp) {
CullPendingFramesBefore(rtp_timestamp); CullPendingFramesBefore(rtp_timestamp);
RTC_CHECK(!pending_frames_.empty()); RTC_CHECK(!pending_frames_.empty());
@ -584,12 +584,13 @@ void DefaultTemporalLayers::OnFrameDropped(size_t stream_index,
pending_frames_.pop_front(); pending_frames_.pop_front();
} }
void DefaultTemporalLayers::OnPacketLossRateUpdate(float packet_loss_rate) {} void DefaultTemporalLayers::OnPacketLossRateUpdate(
float /* packet_loss_rate */) {}
void DefaultTemporalLayers::OnRttUpdate(int64_t rtt_ms) {} void DefaultTemporalLayers::OnRttUpdate(int64_t /* rtt_ms */) {}
void DefaultTemporalLayers::OnLossNotification( void DefaultTemporalLayers::OnLossNotification(
const VideoEncoder::LossNotification& loss_notification) {} const VideoEncoder::LossNotification& /* loss_notification */) {}
FrameDependencyStructure DefaultTemporalLayers::GetTemplateStructure( FrameDependencyStructure DefaultTemporalLayers::GetTemplateStructure(
int num_layers) const { int num_layers) const {

4
modules/video_coding/codecs/vp8/libvpx_vp8_simulcast_test.cc
View File

@ -24,12 +24,12 @@ namespace {
std::unique_ptr<SimulcastTestFixture> CreateSpecificSimulcastTestFixture() { std::unique_ptr<SimulcastTestFixture> CreateSpecificSimulcastTestFixture() {
std::unique_ptr<VideoEncoderFactory> encoder_factory = std::unique_ptr<VideoEncoderFactory> encoder_factory =
std::make_unique<FunctionVideoEncoderFactory>( std::make_unique<FunctionVideoEncoderFactory>(
[](const Environment& env, const SdpVideoFormat& format) { [](const Environment& env, const SdpVideoFormat& /* format */) {
return CreateVp8Encoder(env); return CreateVp8Encoder(env);
}); });
std::unique_ptr<VideoDecoderFactory> decoder_factory = std::unique_ptr<VideoDecoderFactory> decoder_factory =
std::make_unique<FunctionVideoDecoderFactory>( std::make_unique<FunctionVideoDecoderFactory>(
[](const Environment& env, const SdpVideoFormat& format) { [](const Environment& env, const SdpVideoFormat& /* format */) {
return CreateVp8Decoder(env); return CreateVp8Decoder(env);
}); });
return CreateSimulcastTestFixture(std::move(encoder_factory), return CreateSimulcastTestFixture(std::move(encoder_factory),

10
modules/video_coding/codecs/vp8/screenshare_layers.cc
View File

@ -410,18 +410,18 @@ void ScreenshareLayers::OnEncodeDone(size_t stream_index,
} }
} }
void ScreenshareLayers::OnFrameDropped(size_t stream_index, void ScreenshareLayers::OnFrameDropped(size_t /* stream_index */,
uint32_t rtp_timestamp) { uint32_t /* rtp_timestamp */) {
layers_[active_layer_].state = TemporalLayer::State::kDropped; layers_[active_layer_].state = TemporalLayer::State::kDropped;
++stats_.num_overshoots_; ++stats_.num_overshoots_;
} }
void ScreenshareLayers::OnPacketLossRateUpdate(float packet_loss_rate) {} void ScreenshareLayers::OnPacketLossRateUpdate(float /* packet_loss_rate */) {}
void ScreenshareLayers::OnRttUpdate(int64_t rtt_ms) {} void ScreenshareLayers::OnRttUpdate(int64_t /* rtt_ms */) {}
void ScreenshareLayers::OnLossNotification( void ScreenshareLayers::OnLossNotification(
const VideoEncoder::LossNotification& loss_notification) {} const VideoEncoder::LossNotification& /* loss_notification */) {}
FrameDependencyStructure ScreenshareLayers::GetTemplateStructure( FrameDependencyStructure ScreenshareLayers::GetTemplateStructure(
int num_layers) const { int num_layers) const {

2
modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
View File

@ -84,7 +84,7 @@ class ScreenshareLayerTest : public ::testing::Test {
return flags; return flags;
} }
int ConfigureFrame(bool key_frame) { int ConfigureFrame(bool /* key_frame */) {
tl_config_ = NextFrameConfig(0, timestamp_); tl_config_ = NextFrameConfig(0, timestamp_);
EXPECT_EQ(0, tl_config_.encoder_layer_id) EXPECT_EQ(0, tl_config_.encoder_layer_id)
<< "ScreenshareLayers always encodes using the bitrate allocator for " << "ScreenshareLayers always encodes using the bitrate allocator for "

4
modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
View File

@ -607,7 +607,7 @@ TEST_F(TestVp8Impl, KeepsTimestampOnReencode) {
EXPECT_CALL(*vpx, img_wrap(_, _, _, _, _, _)) EXPECT_CALL(*vpx, img_wrap(_, _, _, _, _, _))
.WillOnce(Invoke([](vpx_image_t* img, vpx_img_fmt_t fmt, unsigned int d_w, .WillOnce(Invoke([](vpx_image_t* img, vpx_img_fmt_t fmt, unsigned int d_w,
unsigned int d_h, unsigned int stride_align, unsigned int d_h, unsigned int /* stride_align */,
unsigned char* img_data) { unsigned char* img_data) {
img->fmt = fmt; img->fmt = fmt;
img->d_w = d_w; img->d_w = d_w;
@ -906,7 +906,7 @@ TEST_P(TestVp8ImplWithMaxFrameDropTrial, EnforcesMaxFrameDropInterval) {
protected: protected:
Result OnEncodedImage(const EncodedImage& encoded_image, Result OnEncodedImage(const EncodedImage& encoded_image,
const CodecSpecificInfo* codec_specific_info) { const CodecSpecificInfo* /* codec_specific_info */) {
Timestamp timestamp = Timestamp timestamp =
Timestamp::Millis(encoded_image.RtpTimestamp() / 90); Timestamp::Millis(encoded_image.RtpTimestamp() / 90);
if (last_callback_.IsFinite()) { if (last_callback_.IsFinite()) {

2
modules/video_coding/codecs/vp9/libvpx_vp9_encoder.cc
View File

@ -1551,7 +1551,7 @@ void LibvpxVp9Encoder::FillReferenceIndices(const vpx_codec_cx_pkt& pkt,
} }
} }
void LibvpxVp9Encoder::UpdateReferenceBuffers(const vpx_codec_cx_pkt& pkt, void LibvpxVp9Encoder::UpdateReferenceBuffers(const vpx_codec_cx_pkt& /* pkt */,
const size_t pic_num) { const size_t pic_num) {
vpx_svc_layer_id_t layer_id = {0}; vpx_svc_layer_id_t layer_id = {0};
libvpx_->codec_control(encoder_, VP9E_GET_SVC_LAYER_ID, &layer_id); libvpx_->codec_control(encoder_, VP9E_GET_SVC_LAYER_ID, &layer_id);

2
modules/video_coding/deprecated/session_info.cc
View File

@ -420,7 +420,7 @@ bool VCMSessionInfo::HaveLastPacket() const {
int VCMSessionInfo::InsertPacket(const VCMPacket& packet, int VCMSessionInfo::InsertPacket(const VCMPacket& packet,
uint8_t* frame_buffer, uint8_t* frame_buffer,
const FrameData& frame_data) { const FrameData& /* frame_data */) {
if (packet.video_header.frame_type == VideoFrameType::kEmptyFrame) { if (packet.video_header.frame_type == VideoFrameType::kEmptyFrame) {
// Update sequence number of an empty packet. // Update sequence number of an empty packet.
// Only media packets are inserted into the packet list. // Only media packets are inserted into the packet list.

2
modules/video_coding/fec_controller_default.cc
View File

@ -80,7 +80,7 @@ uint32_t FecControllerDefault::UpdateFecRates(
uint32_t estimated_bitrate_bps, uint32_t estimated_bitrate_bps,
int actual_framerate_fps, int actual_framerate_fps,
uint8_t fraction_lost, uint8_t fraction_lost,
std::vector<bool> loss_mask_vector, std::vector<bool> /* loss_mask_vector */,
int64_t round_trip_time_ms) { int64_t round_trip_time_ms) {
float target_bitrate_kbps = float target_bitrate_kbps =
static_cast<float>(estimated_bitrate_bps) / 1000.0f; static_cast<float>(estimated_bitrate_bps) / 1000.0f;

6
modules/video_coding/fec_controller_unittest.cc
View File

@ -32,8 +32,8 @@ class ProtectionBitrateCalculatorTest : public ::testing::Test {
class ProtectionCallback : public VCMProtectionCallback { class ProtectionCallback : public VCMProtectionCallback {
public: public:
int ProtectionRequest(const FecProtectionParams* delta_params, int ProtectionRequest(const FecProtectionParams* /* delta_params */,
const FecProtectionParams* key_params, const FecProtectionParams* /* key_params */,
uint32_t* sent_video_rate_bps, uint32_t* sent_video_rate_bps,
uint32_t* sent_nack_rate_bps, uint32_t* sent_nack_rate_bps,
uint32_t* sent_fec_rate_bps) override { uint32_t* sent_fec_rate_bps) override {
@ -42,7 +42,7 @@ class ProtectionBitrateCalculatorTest : public ::testing::Test {
*sent_fec_rate_bps = fec_rate_bps_; *sent_fec_rate_bps = fec_rate_bps_;
return 0; return 0;
} }
void SetRetransmissionMode(int retransmission_mode) {} void SetRetransmissionMode(int /* retransmission_mode */) {}
uint32_t fec_rate_bps_ = 0; uint32_t fec_rate_bps_ = 0;
uint32_t nack_rate_bps_ = 0; uint32_t nack_rate_bps_ = 0;

2
modules/video_coding/generic_decoder.cc
View File

@ -44,7 +44,7 @@ constexpr size_t kDecoderFrameMemoryLength = 10;
VCMDecodedFrameCallback::VCMDecodedFrameCallback( VCMDecodedFrameCallback::VCMDecodedFrameCallback(
VCMTiming* timing, VCMTiming* timing,
Clock* clock, Clock* clock,
const FieldTrialsView& field_trials, const FieldTrialsView& /* field_trials */,
CorruptionScoreCalculator* corruption_score_calculator) CorruptionScoreCalculator* corruption_score_calculator)
: _clock(clock), : _clock(clock),
_timing(timing), _timing(timing),

10
modules/video_coding/include/video_coding_defines.h
View File

@ -64,11 +64,11 @@ class VCMReceiveCallback {
}; };
// TODO: bugs.webrtc.org/358039777 - Delete this function. // TODO: bugs.webrtc.org/358039777 - Delete this function.
virtual int32_t FrameToRender(VideoFrame& videoFrame, // NOLINT virtual int32_t FrameToRender(VideoFrame& /* videoFrame */, // NOLINT
std::optional<uint8_t> qp, std::optional<uint8_t> /* qp */,
TimeDelta decode_time, TimeDelta /* decode_time */,
VideoContentType content_type, VideoContentType /* content_type */,
VideoFrameType frame_type) { VideoFrameType /* frame_type */) {
RTC_CHECK_NOTREACHED(); RTC_CHECK_NOTREACHED();
return 0; return 0;
} }

2
modules/video_coding/loss_notification_controller_unittest.cc
View File

@ -35,7 +35,7 @@ struct Packet {
Packet CreatePacket( Packet CreatePacket(
bool first_in_frame, bool first_in_frame,
bool last_in_frame, bool /* last_in_frame */,
uint16_t seq_num, uint16_t seq_num,
uint16_t frame_id, uint16_t frame_id,
bool is_key_frame, bool is_key_frame,

2
modules/video_coding/media_opt_util.cc
View File

@ -233,7 +233,7 @@ VCMNackMethod::~VCMNackMethod() {
} }
bool VCMNackMethod::EffectivePacketLoss( bool VCMNackMethod::EffectivePacketLoss(
const VCMProtectionParameters* parameter) { const VCMProtectionParameters* /* parameter */) {
// Effective Packet Loss, NA in current version. // Effective Packet Loss, NA in current version.
_effectivePacketLoss = 0; _effectivePacketLoss = 0;
return true; return true;