generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Avoid implicit type truncations by inserting explicit casts or modifying prototypes to avoid needless up- and then down-casting.

Browse Source 
BUG=chromium:82439
TEST=none
R=henrik.lundin@webrtc.org, mflodman@webrtc.org, pthatcher@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/40569004

Cr-Commit-Position: refs/heads/master@{#8229}
git-svn-id: http://webrtc.googlecode.com/svn/trunk@8229 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
pkasting@chromium.org 2015-02-02 23:54:03 +00:00
parent 19f3f71c98
commit 0e81fdf5d2
10 changed files with 62 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
talk/media/base/rtputils.cc
View File

@ -29,7 +29,7 @@
namespace cricket { namespace cricket {
static const int kRtpVersion = 2; static const uint8_t kRtpVersion = 2;
static const size_t kRtpFlagsOffset = 0; static const size_t kRtpFlagsOffset = 0;
static const size_t kRtpPayloadTypeOffset = 1; static const size_t kRtpPayloadTypeOffset = 1;
static const size_t kRtpSeqNumOffset = 2; static const size_t kRtpSeqNumOffset = 2;
@ -62,7 +62,7 @@ bool GetUint32(const void* data, size_t offset, uint32* value) {
return true; return true;
} }
bool SetUint8(void* data, size_t offset, int value) { bool SetUint8(void* data, size_t offset, uint8_t value) {
if (!data) { if (!data) {
return false; return false;
} }
@ -70,7 +70,7 @@ bool SetUint8(void* data, size_t offset, int value) {
return true; return true;
} }
bool SetUint16(void* data, size_t offset, int value) { bool SetUint16(void* data, size_t offset, uint16_t value) {
if (!data) { if (!data) {
return false; return false;
} }
@ -142,16 +142,6 @@ bool GetRtpHeaderLen(const void* data, size_t len, size_t* value) {
return true; return true;
} }
bool GetRtpVersion(const void* data, size_t len, int* version) {
if (len == 0) {
return false;
}
const uint8 first = static_cast<const uint8*>(data)[0];
*version = static_cast<int>((first >> 6) & 0x3);
return true;
}
bool GetRtpHeader(const void* data, size_t len, RtpHeader* header) { bool GetRtpHeader(const void* data, size_t len, RtpHeader* header) {
return (GetRtpPayloadType(data, len, &(header->payload_type)) && return (GetRtpPayloadType(data, len, &(header->payload_type)) &&
GetRtpSeqNum(data, len, &(header->seq_num)) && GetRtpSeqNum(data, len, &(header->seq_num)) &&
@ -180,46 +170,20 @@ bool GetRtcpSsrc(const void* data, size_t len, uint32* value) {
return true; return true;
} }
bool SetRtpHeaderFlags(
void* data, size_t len,
bool padding, bool extension, int csrc_count) {
if (csrc_count > 0x0F) {
return false;
}
int flags = 0;
flags |= (kRtpVersion << 6);
flags |= ((padding ? 1 : 0) << 5);
flags |= ((extension ? 1 : 0) << 4);
flags |= csrc_count;
return SetUint8(data, kRtpFlagsOffset, flags);
}
// Assumes marker bit is 0.
bool SetRtpPayloadType(void* data, size_t len, int value) {
if (value >= 0x7F) {
return false;
}
return SetUint8(data, kRtpPayloadTypeOffset, value & 0x7F);
}
bool SetRtpSeqNum(void* data, size_t len, int value) {
return SetUint16(data, kRtpSeqNumOffset, value);
}
bool SetRtpTimestamp(void* data, size_t len, uint32 value) {
return SetUint32(data, kRtpTimestampOffset, value);
}
bool SetRtpSsrc(void* data, size_t len, uint32 value) { bool SetRtpSsrc(void* data, size_t len, uint32 value) {
return SetUint32(data, kRtpSsrcOffset, value); return SetUint32(data, kRtpSsrcOffset, value);
} }
// Assumes version 2, no padding, no extensions, no csrcs. // Assumes version 2, no padding, no extensions, no csrcs.
bool SetRtpHeader(void* data, size_t len, const RtpHeader& header) { bool SetRtpHeader(void* data, size_t len, const RtpHeader& header) {
return (SetRtpHeaderFlags(data, len, false, false, 0) && if (header.payload_type >= 0x7F) {
SetRtpPayloadType(data, len, header.payload_type) && return false;
SetRtpSeqNum(data, len, header.seq_num) && }
SetRtpTimestamp(data, len, header.timestamp) && return (SetUint8(data, kRtpFlagsOffset, kRtpVersion << 6) &&
SetUint8(data, kRtpPayloadTypeOffset, header.payload_type & 0x7F) &&
SetUint16(data, kRtpSeqNumOffset,
static_cast<uint16_t>(header.seq_num)) &&
SetUint32(data, kRtpTimestampOffset, header.timestamp) &&
SetRtpSsrc(data, len, header.ssrc)); SetRtpSsrc(data, len, header.ssrc));
} }
@ -227,11 +191,7 @@ bool IsRtpPacket(const void* data, size_t len) {
if (len < kMinRtpPacketLen) if (len < kMinRtpPacketLen)
return false; return false;
int version = 0; return (static_cast<const uint8*>(data)[0] >> 6) == kRtpVersion;
if (!GetRtpVersion(data, len, &version))
return false;
return version == kRtpVersion;
} }
} // namespace cricket } // namespace cricket

8
talk/media/base/rtputils.h
View File

@ -53,7 +53,6 @@ enum RtcpTypes {
kRtcpTypePSFB = 206, // Payload-specific Feedback message payload type. kRtcpTypePSFB = 206, // Payload-specific Feedback message payload type.
}; };
bool GetRtpVersion(const void* data, size_t len, int* version);
bool GetRtpPayloadType(const void* data, size_t len, int* value); bool GetRtpPayloadType(const void* data, size_t len, int* value);
bool GetRtpSeqNum(const void* data, size_t len, int* value); bool GetRtpSeqNum(const void* data, size_t len, int* value);
bool GetRtpTimestamp(const void* data, size_t len, uint32* value); bool GetRtpTimestamp(const void* data, size_t len, uint32* value);
@ -63,13 +62,6 @@ bool GetRtcpType(const void* data, size_t len, int* value);
bool GetRtcpSsrc(const void* data, size_t len, uint32* value); bool GetRtcpSsrc(const void* data, size_t len, uint32* value);
bool GetRtpHeader(const void* data, size_t len, RtpHeader* header); bool GetRtpHeader(const void* data, size_t len, RtpHeader* header);
// Assumes marker bit is 0.
bool SetRtpHeaderFlags(
void* data, size_t len,
bool padding, bool extension, int csrc_count);
bool SetRtpPayloadType(void* data, size_t len, int value);
bool SetRtpSeqNum(void* data, size_t len, int value);
bool SetRtpTimestamp(void* data, size_t len, uint32 value);
bool SetRtpSsrc(void* data, size_t len, uint32 value); bool SetRtpSsrc(void* data, size_t len, uint32 value);
// Assumes version 2, no padding, no extensions, no csrcs. // Assumes version 2, no padding, no extensions, no csrcs.
bool SetRtpHeader(void* data, size_t len, const RtpHeader& header); bool SetRtpHeader(void* data, size_t len, const RtpHeader& header);

30
talk/media/base/rtputils_unittest.cc
View File

@ -75,9 +75,7 @@ static const unsigned char kNonCompoundRtcpSDESPacket[] = {
}; };
TEST(RtpUtilsTest, GetRtp) { TEST(RtpUtilsTest, GetRtp) {
int ver; EXPECT_TRUE(IsRtpPacket(kPcmuFrame, sizeof(kPcmuFrame)));
EXPECT_TRUE(GetRtpVersion(kPcmuFrame, sizeof(kPcmuFrame), &ver));
EXPECT_EQ(2, ver);
int pt; int pt;
EXPECT_TRUE(GetRtpPayloadType(kPcmuFrame, sizeof(kPcmuFrame), &pt)); EXPECT_TRUE(GetRtpPayloadType(kPcmuFrame, sizeof(kPcmuFrame), &pt));
@ -111,44 +109,24 @@ TEST(RtpUtilsTest, GetRtp) {
EXPECT_FALSE(GetRtpSsrc(kInvalidPacket, sizeof(kInvalidPacket), &ssrc)); EXPECT_FALSE(GetRtpSsrc(kInvalidPacket, sizeof(kInvalidPacket), &ssrc));
} }
TEST(RtpUtilsTest, SetRtp) { TEST(RtpUtilsTest, SetRtpHeader) {
unsigned char packet[] = { unsigned char packet[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}; };
EXPECT_TRUE(SetRtpHeaderFlags(packet, sizeof(packet), false, false, 0)); RtpHeader header = { 9, 1111, 2222u, 3333u };
EXPECT_TRUE(SetRtpPayloadType(packet, sizeof(packet), 9u)); EXPECT_TRUE(SetRtpHeader(packet, sizeof(packet), header));
EXPECT_TRUE(SetRtpSeqNum(packet, sizeof(packet), 1111u));
EXPECT_TRUE(SetRtpTimestamp(packet, sizeof(packet), 2222u));
EXPECT_TRUE(SetRtpSsrc(packet, sizeof(packet), 3333u));
// Bits: 10 0 0 0000 // Bits: 10 0 0 0000
EXPECT_EQ(128u, packet[0]); EXPECT_EQ(128u, packet[0]);
size_t len; size_t len;
EXPECT_TRUE(GetRtpHeaderLen(packet, sizeof(packet), &len)); EXPECT_TRUE(GetRtpHeaderLen(packet, sizeof(packet), &len));
EXPECT_EQ(12U, len); EXPECT_EQ(12U, len);
RtpHeader header;
EXPECT_TRUE(GetRtpHeader(packet, sizeof(packet), &header)); EXPECT_TRUE(GetRtpHeader(packet, sizeof(packet), &header));
EXPECT_EQ(9, header.payload_type); EXPECT_EQ(9, header.payload_type);
EXPECT_EQ(1111, header.seq_num); EXPECT_EQ(1111, header.seq_num);
EXPECT_EQ(2222u, header.timestamp); EXPECT_EQ(2222u, header.timestamp);
EXPECT_EQ(3333u, header.ssrc); EXPECT_EQ(3333u, header.ssrc);
unsigned char packet2[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
EXPECT_TRUE(SetRtpHeader(packet2, sizeof(packet2), header));
// Bits: 10 0 0 0000
EXPECT_EQ(128u, packet2[0]);
EXPECT_TRUE(GetRtpHeaderLen(packet2, sizeof(packet2), &len));
EXPECT_EQ(12U, len);
EXPECT_TRUE(GetRtpHeader(packet2, sizeof(packet2), &header));
EXPECT_EQ(9, header.payload_type);
EXPECT_EQ(1111, header.seq_num);
EXPECT_EQ(2222u, header.timestamp);
EXPECT_EQ(3333u, header.ssrc);
} }
TEST(RtpUtilsTest, GetRtpHeaderLen) { TEST(RtpUtilsTest, GetRtpHeaderLen) {

3
talk/session/media/channel_unittest.cc
View File

@ -423,7 +423,8 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
rtc::SetBE32(const_cast<char*>(data.c_str()) + 8, ssrc); rtc::SetBE32(const_cast<char*>(data.c_str()) + 8, ssrc);
rtc::SetBE16(const_cast<char*>(data.c_str()) + 2, sequence_number); rtc::SetBE16(const_cast<char*>(data.c_str()) + 2, sequence_number);
if (pl_type >= 0) { if (pl_type >= 0) {
rtc::Set8(const_cast<char*>(data.c_str()), 1, pl_type); rtc::Set8(const_cast<char*>(data.c_str()), 1,
static_cast<uint8_t>(pl_type));
} }
return data; return data;
} }

4
webrtc/modules/audio_coding/main/acm2/acm_send_test.cc
View File

@ -61,7 +61,7 @@ bool AcmSendTest::RegisterCodec(int codec_type,
Packet* AcmSendTest::NextPacket() { Packet* AcmSendTest::NextPacket() {
assert(codec_registered_); assert(codec_registered_);
if (filter_.test(payload_type_)) { if (filter_.test(static_cast<size_t>(payload_type_))) {
// This payload type should be filtered out. Since the payload type is the // This payload type should be filtered out. Since the payload type is the
// same throughout the whole test run, no packet at all will be delivered. // same throughout the whole test run, no packet at all will be delivered.
// We can just as well signal that the test is over by returning NULL. // We can just as well signal that the test is over by returning NULL.
@ -111,7 +111,7 @@ Packet* AcmSendTest::CreatePacket() {
uint8_t* packet_memory = new uint8_t[allocated_bytes]; uint8_t* packet_memory = new uint8_t[allocated_bytes];
// Populate the header bytes. // Populate the header bytes.
packet_memory[0] = 0x80; packet_memory[0] = 0x80;
packet_memory[1] = payload_type_; packet_memory[1] = static_cast<uint8_t>(payload_type_);
packet_memory[2] = (sequence_number_ >> 8) & 0xFF; packet_memory[2] = (sequence_number_ >> 8) & 0xFF;
packet_memory[3] = (sequence_number_) & 0xFF; packet_memory[3] = (sequence_number_) & 0xFF;
packet_memory[4] = (timestamp_ >> 24) & 0xFF; packet_memory[4] = (timestamp_ >> 24) & 0xFF;

4
webrtc/modules/audio_coding/main/acm2/acm_send_test_oldapi.cc
View File

@ -64,7 +64,7 @@ bool AcmSendTestOldApi::RegisterCodec(const char* payload_name,
Packet* AcmSendTestOldApi::NextPacket() { Packet* AcmSendTestOldApi::NextPacket() {
assert(codec_registered_); assert(codec_registered_);
if (filter_.test(payload_type_)) { if (filter_.test(static_cast<size_t>(payload_type_))) {
// This payload type should be filtered out. Since the payload type is the // This payload type should be filtered out. Since the payload type is the
// same throughout the whole test run, no packet at all will be delivered. // same throughout the whole test run, no packet at all will be delivered.
// We can just as well signal that the test is over by returning NULL. // We can just as well signal that the test is over by returning NULL.
@ -115,7 +115,7 @@ Packet* AcmSendTestOldApi::CreatePacket() {
uint8_t* packet_memory = new uint8_t[allocated_bytes]; uint8_t* packet_memory = new uint8_t[allocated_bytes];
// Populate the header bytes. // Populate the header bytes.
packet_memory[0] = 0x80; packet_memory[0] = 0x80;
packet_memory[1] = payload_type_; packet_memory[1] = static_cast<uint8_t>(payload_type_);
packet_memory[2] = (sequence_number_ >> 8) & 0xFF; packet_memory[2] = (sequence_number_ >> 8) & 0xFF;
packet_memory[3] = (sequence_number_) & 0xFF; packet_memory[3] = (sequence_number_) & 0xFF;
packet_memory[4] = (timestamp_ >> 24) & 0xFF; packet_memory[4] = (timestamp_ >> 24) & 0xFF;

6
webrtc/modules/audio_coding/neteq/neteq_impl.cc
View File

@ -1129,12 +1129,12 @@ int NetEqImpl::Decode(PacketList* packet_list, Operations* operation,
AudioDecoder* decoder = NULL; AudioDecoder* decoder = NULL;
if (!packet_list->empty()) { if (!packet_list->empty()) {
const Packet* packet = packet_list->front(); const Packet* packet = packet_list->front();
int payload_type = packet->header.payloadType; uint8_t payload_type = packet->header.payloadType;
if (!decoder_database_->IsComfortNoise(payload_type)) { if (!decoder_database_->IsComfortNoise(payload_type)) {
decoder = decoder_database_->GetDecoder(payload_type); decoder = decoder_database_->GetDecoder(payload_type);
assert(decoder); assert(decoder);
if (!decoder) { if (!decoder) {
LOG_FERR1(LS_WARNING, GetDecoder, payload_type); LOG_FERR1(LS_WARNING, GetDecoder, static_cast<int>(payload_type));
PacketBuffer::DeleteAllPackets(packet_list); PacketBuffer::DeleteAllPackets(packet_list);
return kDecoderNotFound; return kDecoderNotFound;
} }
@ -1146,7 +1146,7 @@ int NetEqImpl::Decode(PacketList* packet_list, Operations* operation,
->GetDecoderInfo(payload_type); ->GetDecoderInfo(payload_type);
assert(decoder_info); assert(decoder_info);
if (!decoder_info) { if (!decoder_info) {
LOG_FERR1(LS_WARNING, GetDecoderInfo, payload_type); LOG_FERR1(LS_WARNING, GetDecoderInfo, static_cast<int>(payload_type));
PacketBuffer::DeleteAllPackets(packet_list); PacketBuffer::DeleteAllPackets(packet_list);
return kDecoderNotFound; return kDecoderNotFound;
} }

56
webrtc/modules/audio_coding/neteq/tools/neteq_rtpplay.cc
View File

@ -187,57 +187,64 @@ std::string CodecName(webrtc::NetEqDecoder codec) {
void RegisterPayloadTypes(NetEq* neteq) { void RegisterPayloadTypes(NetEq* neteq) {
assert(neteq); assert(neteq);
int error; int error;
error = neteq->RegisterPayloadType(webrtc::kDecoderPCMu, FLAGS_pcmu); error = neteq->RegisterPayloadType(webrtc::kDecoderPCMu,
static_cast<uint8_t>(FLAGS_pcmu));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_pcmu << std::cerr << "Cannot register payload type " << FLAGS_pcmu <<
" as " << CodecName(webrtc::kDecoderPCMu).c_str() << std::endl; " as " << CodecName(webrtc::kDecoderPCMu).c_str() << std::endl;
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderPCMa, FLAGS_pcma); error = neteq->RegisterPayloadType(webrtc::kDecoderPCMa,
static_cast<uint8_t>(FLAGS_pcma));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_pcma << std::cerr << "Cannot register payload type " << FLAGS_pcma <<
" as " << CodecName(webrtc::kDecoderPCMa).c_str() << std::endl; " as " << CodecName(webrtc::kDecoderPCMa).c_str() << std::endl;
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderILBC, FLAGS_ilbc); error = neteq->RegisterPayloadType(webrtc::kDecoderILBC,
static_cast<uint8_t>(FLAGS_ilbc));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_ilbc << std::cerr << "Cannot register payload type " << FLAGS_ilbc <<
" as " << CodecName(webrtc::kDecoderILBC).c_str() << std::endl; " as " << CodecName(webrtc::kDecoderILBC).c_str() << std::endl;
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderISAC, FLAGS_isac); error = neteq->RegisterPayloadType(webrtc::kDecoderISAC,
static_cast<uint8_t>(FLAGS_isac));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_isac << std::cerr << "Cannot register payload type " << FLAGS_isac <<
" as " << CodecName(webrtc::kDecoderISAC).c_str() << std::endl; " as " << CodecName(webrtc::kDecoderISAC).c_str() << std::endl;
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderISACswb, FLAGS_isac_swb); error = neteq->RegisterPayloadType(webrtc::kDecoderISACswb,
static_cast<uint8_t>(FLAGS_isac_swb));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_isac_swb << std::cerr << "Cannot register payload type " << FLAGS_isac_swb <<
" as " << CodecName(webrtc::kDecoderISACswb).c_str() << std::endl; " as " << CodecName(webrtc::kDecoderISACswb).c_str() << std::endl;
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderOpus, FLAGS_opus); error = neteq->RegisterPayloadType(webrtc::kDecoderOpus,
static_cast<uint8_t>(FLAGS_opus));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_opus << " as " std::cerr << "Cannot register payload type " << FLAGS_opus << " as "
<< CodecName(webrtc::kDecoderOpus).c_str() << std::endl; << CodecName(webrtc::kDecoderOpus).c_str() << std::endl;
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderPCM16B, FLAGS_pcm16b); error = neteq->RegisterPayloadType(webrtc::kDecoderPCM16B,
static_cast<uint8_t>(FLAGS_pcm16b));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_pcm16b << std::cerr << "Cannot register payload type " << FLAGS_pcm16b <<
" as " << CodecName(webrtc::kDecoderPCM16B).c_str() << std::endl; " as " << CodecName(webrtc::kDecoderPCM16B).c_str() << std::endl;
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderPCM16Bwb, error = neteq->RegisterPayloadType(webrtc::kDecoderPCM16Bwb,
FLAGS_pcm16b_wb); static_cast<uint8_t>(FLAGS_pcm16b_wb));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_pcm16b_wb << std::cerr << "Cannot register payload type " << FLAGS_pcm16b_wb <<
" as " << CodecName(webrtc::kDecoderPCM16Bwb).c_str() << std::endl; " as " << CodecName(webrtc::kDecoderPCM16Bwb).c_str() << std::endl;
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderPCM16Bswb32kHz, error = neteq->RegisterPayloadType(webrtc::kDecoderPCM16Bswb32kHz,
FLAGS_pcm16b_swb32); static_cast<uint8_t>(FLAGS_pcm16b_swb32));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_pcm16b_swb32 << std::cerr << "Cannot register payload type " << FLAGS_pcm16b_swb32 <<
" as " << CodecName(webrtc::kDecoderPCM16Bswb32kHz).c_str() << " as " << CodecName(webrtc::kDecoderPCM16Bswb32kHz).c_str() <<
@ -245,52 +252,57 @@ void RegisterPayloadTypes(NetEq* neteq) {
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderPCM16Bswb48kHz, error = neteq->RegisterPayloadType(webrtc::kDecoderPCM16Bswb48kHz,
FLAGS_pcm16b_swb48); static_cast<uint8_t>(FLAGS_pcm16b_swb48));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_pcm16b_swb48 << std::cerr << "Cannot register payload type " << FLAGS_pcm16b_swb48 <<
" as " << CodecName(webrtc::kDecoderPCM16Bswb48kHz).c_str() << " as " << CodecName(webrtc::kDecoderPCM16Bswb48kHz).c_str() <<
std::endl; std::endl;
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderG722, FLAGS_g722); error = neteq->RegisterPayloadType(webrtc::kDecoderG722,
static_cast<uint8_t>(FLAGS_g722));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_g722 << std::cerr << "Cannot register payload type " << FLAGS_g722 <<
" as " << CodecName(webrtc::kDecoderG722).c_str() << std::endl; " as " << CodecName(webrtc::kDecoderG722).c_str() << std::endl;
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderAVT, FLAGS_avt); error = neteq->RegisterPayloadType(webrtc::kDecoderAVT,
static_cast<uint8_t>(FLAGS_avt));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_avt << std::cerr << "Cannot register payload type " << FLAGS_avt <<
" as " << CodecName(webrtc::kDecoderAVT).c_str() << std::endl; " as " << CodecName(webrtc::kDecoderAVT).c_str() << std::endl;
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderRED, FLAGS_red); error = neteq->RegisterPayloadType(webrtc::kDecoderRED,
static_cast<uint8_t>(FLAGS_red));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_red << std::cerr << "Cannot register payload type " << FLAGS_red <<
" as " << CodecName(webrtc::kDecoderRED).c_str() << std::endl; " as " << CodecName(webrtc::kDecoderRED).c_str() << std::endl;
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderCNGnb, FLAGS_cn_nb); error = neteq->RegisterPayloadType(webrtc::kDecoderCNGnb,
static_cast<uint8_t>(FLAGS_cn_nb));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_cn_nb << std::cerr << "Cannot register payload type " << FLAGS_cn_nb <<
" as " << CodecName(webrtc::kDecoderCNGnb).c_str() << std::endl; " as " << CodecName(webrtc::kDecoderCNGnb).c_str() << std::endl;
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderCNGwb, FLAGS_cn_wb); error = neteq->RegisterPayloadType(webrtc::kDecoderCNGwb,
static_cast<uint8_t>(FLAGS_cn_wb));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_cn_wb << std::cerr << "Cannot register payload type " << FLAGS_cn_wb <<
" as " << CodecName(webrtc::kDecoderCNGwb).c_str() << std::endl; " as " << CodecName(webrtc::kDecoderCNGwb).c_str() << std::endl;
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderCNGswb32kHz, error = neteq->RegisterPayloadType(webrtc::kDecoderCNGswb32kHz,
FLAGS_cn_swb32); static_cast<uint8_t>(FLAGS_cn_swb32));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_cn_swb32 << std::cerr << "Cannot register payload type " << FLAGS_cn_swb32 <<
" as " << CodecName(webrtc::kDecoderCNGswb32kHz).c_str() << std::endl; " as " << CodecName(webrtc::kDecoderCNGswb32kHz).c_str() << std::endl;
exit(1); exit(1);
} }
error = neteq->RegisterPayloadType(webrtc::kDecoderCNGswb48kHz, error = neteq->RegisterPayloadType(webrtc::kDecoderCNGswb48kHz,
FLAGS_cn_swb48); static_cast<uint8_t>(FLAGS_cn_swb48));
if (error) { if (error) {
std::cerr << "Cannot register payload type " << FLAGS_cn_swb48 << std::cerr << "Cannot register payload type " << FLAGS_cn_swb48 <<
" as " << CodecName(webrtc::kDecoderCNGswb48kHz).c_str() << std::endl; " as " << CodecName(webrtc::kDecoderCNGswb48kHz).c_str() << std::endl;
@ -442,16 +454,18 @@ size_t ReplacePayload(webrtc::test::InputAudioFile* replacement_audio_file,
// Change payload type to PCM16. // Change payload type to PCM16.
switch (CodecSampleRate(rtp_header->header.payloadType)) { switch (CodecSampleRate(rtp_header->header.payloadType)) {
case 8000: case 8000:
rtp_header->header.payloadType = FLAGS_pcm16b; rtp_header->header.payloadType = static_cast<uint8_t>(FLAGS_pcm16b);
break; break;
case 16000: case 16000:
rtp_header->header.payloadType = FLAGS_pcm16b_wb; rtp_header->header.payloadType = static_cast<uint8_t>(FLAGS_pcm16b_wb);
break; break;
case 32000: case 32000:
rtp_header->header.payloadType = FLAGS_pcm16b_swb32; rtp_header->header.payloadType =
static_cast<uint8_t>(FLAGS_pcm16b_swb32);
break; break;
case 48000: case 48000:
rtp_header->header.payloadType = FLAGS_pcm16b_swb48; rtp_header->header.payloadType =
static_cast<uint8_t>(FLAGS_pcm16b_swb48);
break; break;
default: default:
std::cerr << "Payload type " << std::cerr << "Payload type " <<

2
webrtc/modules/rtp_rtcp/source/producer_fec.cc
View File

@ -55,7 +55,7 @@ void RedPacket::CreateHeader(const uint8_t* rtp_header, size_t header_length,
data_[1] += red_pl_type; data_[1] += red_pl_type;
// Add RED header // Add RED header
// f-bit always 0 // f-bit always 0
data_[header_length] = pl_type; data_[header_length] = static_cast<uint8_t>(pl_type);
header_length_ = header_length + kREDForFECHeaderLength; header_length_ = header_length + kREDForFECHeaderLength;
} }

2
webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc
View File

@ -33,7 +33,7 @@ void VerifyHeader(uint16_t seq_num,
uint32_t parsed_timestamp = (data[4] << 24) + (data[5] << 16) + uint32_t parsed_timestamp = (data[4] << 24) + (data[5] << 16) +
(data[6] << 8) + data[7]; (data[6] << 8) + data[7];
EXPECT_EQ(timestamp, parsed_timestamp); EXPECT_EQ(timestamp, parsed_timestamp);
EXPECT_EQ(fec_pltype, data[kRtpHeaderSize]); EXPECT_EQ(static_cast<uint8_t>(fec_pltype), data[kRtpHeaderSize]);
} }
class ProducerFecTest : public ::testing::Test { class ProducerFecTest : public ::testing::Test {