WebRtc_Word32 => int32_t for rtp_rtcp/
BUG=314
Review URL: https://webrtc-codereview.appspot.com/1279007
git-svn-id: http://webrtc.googlecode.com/svn/trunk/webrtc@3777 4adac7df-926f-26a2-2b94-8c16560cd09d
diff --git a/modules/rtp_rtcp/test/testAPI/test_api.cc b/modules/rtp_rtcp/test/testAPI/test_api.cc
index fb1b337..4a00935 100644
--- a/modules/rtp_rtcp/test/testAPI/test_api.cc
+++ b/modules/rtp_rtcp/test/testAPI/test_api.cc
@@ -41,10 +41,10 @@
int test_id;
RtpRtcp* module;
- WebRtc_UWord32 test_ssrc;
- WebRtc_UWord32 test_timestamp;
- WebRtc_UWord16 test_sequence_number;
- WebRtc_UWord32 test_CSRC[webrtc::kRtpCsrcSize];
+ uint32_t test_ssrc;
+ uint32_t test_timestamp;
+ uint16_t test_sequence_number;
+ uint32_t test_CSRC[webrtc::kRtpCsrcSize];
SimulatedClock fake_clock;
};
@@ -80,7 +80,7 @@
TEST_F(RtpRtcpAPITest, CSRC) {
EXPECT_EQ(0, module->SetCSRCs(test_CSRC, 2));
- WebRtc_UWord32 testOfCSRC[webrtc::kRtpCsrcSize];
+ uint32_t testOfCSRC[webrtc::kRtpCsrcSize];
EXPECT_EQ(2, module->CSRCs(testOfCSRC));
EXPECT_EQ(test_CSRC[0], testOfCSRC[0]);
EXPECT_EQ(test_CSRC[1], testOfCSRC[1]);
diff --git a/modules/rtp_rtcp/test/testAPI/test_api.h b/modules/rtp_rtcp/test/testAPI/test_api.h
index d3698d4..040ed06 100644
--- a/modules/rtp_rtcp/test/testAPI/test_api.h
+++ b/modules/rtp_rtcp/test/testAPI/test_api.h
@@ -37,13 +37,13 @@
return len;
}
}
- if (_rtpRtcpModule->IncomingPacket((const WebRtc_UWord8*)data, len) == 0) {
+ if (_rtpRtcpModule->IncomingPacket((const uint8_t*)data, len) == 0) {
return len;
}
return -1;
}
virtual int SendRTCPPacket(int channel, const void *data, int len) {
- if (_rtpRtcpModule->IncomingPacket((const WebRtc_UWord8*)data, len) == 0) {
+ if (_rtpRtcpModule->IncomingPacket((const uint8_t*)data, len) == 0) {
return len;
}
return -1;
@@ -58,9 +58,9 @@
public:
enum { kMaxPayloadSize = 1500 };
- virtual WebRtc_Word32 OnReceivedPayloadData(
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord16 payloadSize,
+ virtual int32_t OnReceivedPayloadData(
+ const uint8_t* payloadData,
+ const uint16_t payloadSize,
const webrtc::WebRtcRTPHeader* rtpHeader) {
EXPECT_LE(payloadSize, kMaxPayloadSize);
memcpy(_payloadData, payloadData, payloadSize);
@@ -69,11 +69,11 @@
return 0;
}
- const WebRtc_UWord8* payload_data() const {
+ const uint8_t* payload_data() const {
return _payloadData;
}
- WebRtc_UWord16 payload_size() const {
+ uint16_t payload_size() const {
return _payloadSize;
}
@@ -82,8 +82,8 @@
}
private:
- WebRtc_UWord8 _payloadData[kMaxPayloadSize];
- WebRtc_UWord16 _payloadSize;
+ uint8_t _payloadData[kMaxPayloadSize];
+ uint16_t _payloadSize;
webrtc::WebRtcRTPHeader _rtpHeader;
};
diff --git a/modules/rtp_rtcp/test/testAPI/test_api_audio.cc b/modules/rtp_rtcp/test/testAPI/test_api_audio.cc
index f59b192..0d1ed9d 100644
--- a/modules/rtp_rtcp/test/testAPI/test_api_audio.cc
+++ b/modules/rtp_rtcp/test/testAPI/test_api_audio.cc
@@ -24,9 +24,9 @@
class VerifyingAudioReceiver : public RtpData {
public:
- virtual WebRtc_Word32 OnReceivedPayloadData(
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord16 payloadSize,
+ virtual int32_t OnReceivedPayloadData(
+ const uint8_t* payloadData,
+ const uint16_t payloadSize,
const webrtc::WebRtcRTPHeader* rtpHeader) {
if (rtpHeader->header.payloadType == 98 ||
rtpHeader->header.payloadType == 99) {
@@ -60,44 +60,44 @@
class RTPCallback : public RtpFeedback {
public:
- virtual WebRtc_Word32 OnInitializeDecoder(
- const WebRtc_Word32 id,
- const WebRtc_Word8 payloadType,
+ virtual int32_t OnInitializeDecoder(
+ const int32_t id,
+ const int8_t payloadType,
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
const int frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate) {
+ const uint8_t channels,
+ const uint32_t rate) {
if (payloadType == 96) {
EXPECT_EQ(test_rate, rate) <<
"The rate should be 64K for this payloadType";
}
return 0;
}
- virtual void OnPacketTimeout(const WebRtc_Word32 id) {
+ virtual void OnPacketTimeout(const int32_t id) {
}
- virtual void OnReceivedPacket(const WebRtc_Word32 id,
+ virtual void OnReceivedPacket(const int32_t id,
const RtpRtcpPacketType packetType) {
}
- virtual void OnPeriodicDeadOrAlive(const WebRtc_Word32 id,
+ virtual void OnPeriodicDeadOrAlive(const int32_t id,
const RTPAliveType alive) {
}
- virtual void OnIncomingSSRCChanged(const WebRtc_Word32 id,
- const WebRtc_UWord32 SSRC) {
+ virtual void OnIncomingSSRCChanged(const int32_t id,
+ const uint32_t SSRC) {
}
- virtual void OnIncomingCSRCChanged(const WebRtc_Word32 id,
- const WebRtc_UWord32 CSRC,
+ virtual void OnIncomingCSRCChanged(const int32_t id,
+ const uint32_t CSRC,
const bool added) {
}
};
class AudioFeedback : public RtpAudioFeedback {
- virtual void OnReceivedTelephoneEvent(const WebRtc_Word32 id,
- const WebRtc_UWord8 event,
+ virtual void OnReceivedTelephoneEvent(const int32_t id,
+ const uint8_t event,
const bool end) {
- static WebRtc_UWord8 expectedEvent = 0;
+ static uint8_t expectedEvent = 0;
if (end) {
- WebRtc_UWord8 oldEvent = expectedEvent-1;
+ uint8_t oldEvent = expectedEvent-1;
if (expectedEvent == 32) {
oldEvent = 15;
}
@@ -110,10 +110,10 @@
expectedEvent = 32;
}
}
- virtual void OnPlayTelephoneEvent(const WebRtc_Word32 id,
- const WebRtc_UWord8 event,
- const WebRtc_UWord16 lengthMs,
- const WebRtc_UWord8 volume) {
+ virtual void OnPlayTelephoneEvent(const int32_t id,
+ const uint8_t event,
+ const uint16_t lengthMs,
+ const uint8_t volume) {
};
};
@@ -179,10 +179,10 @@
LoopBackTransport* transport2;
AudioFeedback* audioFeedback;
RTPCallback* rtp_callback;
- WebRtc_UWord32 test_ssrc;
- WebRtc_UWord32 test_timestamp;
- WebRtc_UWord16 test_sequence_number;
- WebRtc_UWord32 test_CSRC[webrtc::kRtpCsrcSize];
+ uint32_t test_ssrc;
+ uint32_t test_timestamp;
+ uint16_t test_sequence_number;
+ uint32_t test_CSRC[webrtc::kRtpCsrcSize];
SimulatedClock fake_clock;
};
@@ -214,7 +214,7 @@
EXPECT_EQ(0, module2->RegisterReceivePayload(voiceCodec));
printf("4\n");
- const WebRtc_UWord8 test[5] = "test";
+ const uint8_t test[5] = "test";
EXPECT_EQ(0, module1->SendOutgoingData(webrtc::kAudioFrameSpeech, 96,
0, -1, test, 4));
@@ -243,7 +243,7 @@
memcpy(voiceCodec.plname, "RED", 4);
EXPECT_EQ(0, module1->SetSendREDPayloadType(voiceCodec.pltype));
- WebRtc_Word8 red = 0;
+ int8_t red = 0;
EXPECT_EQ(0, module1->SendREDPayloadType(red));
EXPECT_EQ(voiceCodec.pltype, red);
EXPECT_EQ(0, module1->RegisterReceivePayload(voiceCodec));
@@ -251,20 +251,20 @@
RTPFragmentationHeader fragmentation;
fragmentation.fragmentationVectorSize = 2;
- fragmentation.fragmentationLength = new WebRtc_UWord32[2];
+ fragmentation.fragmentationLength = new uint32_t[2];
fragmentation.fragmentationLength[0] = 4;
fragmentation.fragmentationLength[1] = 4;
- fragmentation.fragmentationOffset = new WebRtc_UWord32[2];
+ fragmentation.fragmentationOffset = new uint32_t[2];
fragmentation.fragmentationOffset[0] = 0;
fragmentation.fragmentationOffset[1] = 4;
- fragmentation.fragmentationTimeDiff = new WebRtc_UWord16[2];
+ fragmentation.fragmentationTimeDiff = new uint16_t[2];
fragmentation.fragmentationTimeDiff[0] = 0;
fragmentation.fragmentationTimeDiff[1] = 0;
- fragmentation.fragmentationPlType = new WebRtc_UWord8[2];
+ fragmentation.fragmentationPlType = new uint8_t[2];
fragmentation.fragmentationPlType[0] = 96;
fragmentation.fragmentationPlType[1] = 96;
- const WebRtc_UWord8 test[5] = "test";
+ const uint8_t test[5] = "test";
// Send a RTP packet.
EXPECT_EQ(0, module1->SendOutgoingData(webrtc::kAudioFrameSpeech,
96, 160, -1, test, 4,
@@ -299,7 +299,7 @@
EXPECT_EQ(0, module2->RegisterReceivePayload(voiceCodec));
// Start DTMF test.
- WebRtc_UWord32 timeStamp = 160;
+ uint32_t timeStamp = 160;
// Send a DTMF tone using RFC 2833 (4733).
for (int i = 0; i < 16; i++) {
@@ -307,7 +307,7 @@
}
timeStamp += 160; // Prepare for next packet.
- const WebRtc_UWord8 test[9] = "test";
+ const uint8_t test[9] = "test";
// Send RTP packets for 16 tones a 160 ms 100ms
// pause between = 2560ms + 1600ms = 4160ms
diff --git a/modules/rtp_rtcp/test/testAPI/test_api_nack.cc b/modules/rtp_rtcp/test/testAPI/test_api_nack.cc
index 1a859c2..92663fa 100644
--- a/modules/rtp_rtcp/test/testAPI/test_api_nack.cc
+++ b/modules/rtp_rtcp/test/testAPI/test_api_nack.cc
@@ -24,9 +24,9 @@
const int kVideoNackListSize = 10;
const int kTestId = 123;
-const WebRtc_UWord32 kTestSsrc = 3456;
-const WebRtc_UWord16 kTestSequenceNumber = 2345;
-const WebRtc_UWord32 kTestNumberOfPackets = 450;
+const uint32_t kTestSsrc = 3456;
+const uint16_t kTestSequenceNumber = 2345;
+const uint32_t kTestNumberOfPackets = 450;
const int kTestNumberOfRtxPackets = 49;
class VerifyingNackReceiver : public RtpData
@@ -34,9 +34,9 @@
public:
VerifyingNackReceiver() {}
- virtual WebRtc_Word32 OnReceivedPayloadData(
- const WebRtc_UWord8* data,
- const WebRtc_UWord16 size,
+ virtual int32_t OnReceivedPayloadData(
+ const uint8_t* data,
+ const uint16_t size,
const webrtc::WebRtcRTPHeader* rtp_header) {
EXPECT_EQ(kTestSsrc, rtp_header->header.ssrc);
@@ -91,13 +91,13 @@
count_ < consecutive_drop_end_) {
return len;
}
- if (module_->IncomingPacket((const WebRtc_UWord8*)data, len) == 0) {
+ if (module_->IncomingPacket((const uint8_t*)data, len) == 0) {
return len;
}
return -1;
}
virtual int SendRTCPPacket(int channel, const void *data, int len) {
- if (module_->IncomingPacket((const WebRtc_UWord8*)data, len) == 0) {
+ if (module_->IncomingPacket((const uint8_t*)data, len) == 0) {
return len;
}
return -1;
@@ -171,12 +171,12 @@
nack_receiver_->sequence_numbers_.begin();
while (it != nack_receiver_->sequence_numbers_.end()) {
- WebRtc_UWord16 sequence_number_1 = *it;
+ uint16_t sequence_number_1 = *it;
++it;
if (it != nack_receiver_->sequence_numbers_.end()) {
- WebRtc_UWord16 sequence_number_2 = *it;
+ uint16_t sequence_number_2 = *it;
// Add all missing sequence numbers to list
- for (WebRtc_UWord16 i = sequence_number_1 + 1; i < sequence_number_2;
+ for (uint16_t i = sequence_number_1 + 1; i < sequence_number_2;
++i) {
missing_sequence_numbers.push_back(i);
}
@@ -203,13 +203,13 @@
RtpRtcp* video_module_;
NackLoopBackTransport* transport_;
VerifyingNackReceiver* nack_receiver_;
- WebRtc_UWord8 payload_data[65000];
+ uint8_t payload_data[65000];
int payload_data_length;
SimulatedClock fake_clock;
};
TEST_F(RtpRtcpNackTest, RTCP) {
- WebRtc_UWord32 timestamp = 3000;
+ uint32_t timestamp = 3000;
uint16_t nack_list[kVideoNackListSize];
transport_->DropEveryNthPacket(10);
@@ -240,7 +240,7 @@
const int kNumPacketsToDrop = 900;
const int kNumFrames = 30;
const int kNumRequiredRtcp = 4;
- WebRtc_UWord32 timestamp = 3000;
+ uint32_t timestamp = 3000;
uint16_t nack_list[kNumPacketsToDrop];
// Disable StorePackets to be able to set a larger packet history.
EXPECT_EQ(0, video_module_->SetStorePacketsStatus(false, 0));
diff --git a/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc b/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc
index d15dcc8..681f74e 100644
--- a/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc
+++ b/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc
@@ -27,20 +27,20 @@
void SetModule(RtpRtcp* module) {
_rtpRtcpModule = module;
};
- virtual void OnRTCPPacketTimeout(const WebRtc_Word32 id) {
+ virtual void OnRTCPPacketTimeout(const int32_t id) {
}
- virtual void OnLipSyncUpdate(const WebRtc_Word32 id,
- const WebRtc_Word32 audioVideoOffset) {
+ virtual void OnLipSyncUpdate(const int32_t id,
+ const int32_t audioVideoOffset) {
};
virtual void OnXRVoIPMetricReceived(
- const WebRtc_Word32 id,
+ const int32_t id,
const RTCPVoIPMetric* metric) {
};
- virtual void OnApplicationDataReceived(const WebRtc_Word32 id,
- const WebRtc_UWord8 subType,
- const WebRtc_UWord32 name,
- const WebRtc_UWord16 length,
- const WebRtc_UWord8* data) {
+ virtual void OnApplicationDataReceived(const int32_t id,
+ const uint8_t subType,
+ const uint32_t name,
+ const uint16_t length,
+ const uint8_t* data) {
char print_name[5];
print_name[0] = static_cast<char>(name >> 24);
print_name[1] = static_cast<char>(name >> 16);
@@ -50,16 +50,16 @@
EXPECT_STRCASEEQ("test", print_name);
};
- virtual void OnSendReportReceived(const WebRtc_Word32 id,
- const WebRtc_UWord32 senderSSRC,
+ virtual void OnSendReportReceived(const int32_t id,
+ const uint32_t senderSSRC,
uint32_t ntp_secs,
uint32_t ntp_frac,
uint32_t timestamp) {
RTCPSenderInfo senderInfo;
EXPECT_EQ(0, _rtpRtcpModule->RemoteRTCPStat(&senderInfo));
};
- virtual void OnReceiveReportReceived(const WebRtc_Word32 id,
- const WebRtc_UWord32 senderSSRC) {
+ virtual void OnReceiveReportReceived(const int32_t id,
+ const uint32_t senderSSRC) {
};
virtual void OnReceivedIntraFrameRequest(uint32_t ssrc) {
};
@@ -143,7 +143,7 @@
// We need to send one RTP packet to get the RTCP packet to be accepted by
// the receiving module.
// send RTP packet with the data "testtest"
- const WebRtc_UWord8 test[9] = "testtest";
+ const uint8_t test[9] = "testtest";
EXPECT_EQ(0, module1->SendOutgoingData(webrtc::kAudioFrameSpeech, 96,
0, -1, test, 8));
}
@@ -167,10 +167,10 @@
RtcpCallback* myRTCPFeedback1;
RtcpCallback* myRTCPFeedback2;
- WebRtc_UWord32 test_ssrc;
- WebRtc_UWord32 test_timestamp;
- WebRtc_UWord16 test_sequence_number;
- WebRtc_UWord32 test_CSRC[webrtc::kRtpCsrcSize];
+ uint32_t test_ssrc;
+ uint32_t test_timestamp;
+ uint16_t test_sequence_number;
+ uint32_t test_CSRC[webrtc::kRtpCsrcSize];
SimulatedClock fake_clock;
};
@@ -180,7 +180,7 @@
}
TEST_F(RtpRtcpRtcpTest, RTCP_CNAME) {
- WebRtc_UWord32 testOfCSRC[webrtc::kRtpCsrcSize];
+ uint32_t testOfCSRC[webrtc::kRtpCsrcSize];
EXPECT_EQ(2, module2->RemoteCSRCs(testOfCSRC));
EXPECT_EQ(test_CSRC[0], testOfCSRC[0]);
EXPECT_EQ(test_CSRC[1], testOfCSRC[1]);
@@ -236,14 +236,14 @@
reportBlock.lastSR= 7;
EXPECT_EQ(0, module1->AddRTCPReportBlock(test_CSRC[1], &reportBlock));
- WebRtc_UWord32 name = 't' << 24;
+ uint32_t name = 't' << 24;
name += 'e' << 16;
name += 's' << 8;
name += 't';
EXPECT_EQ(0, module1->SetRTCPApplicationSpecificData(
3,
name,
- (const WebRtc_UWord8 *)"test test test test test test test test test"\
+ (const uint8_t *)"test test test test test test test test test"\
" test test test test test test test test test test test test test"\
" test test test test test test test test test test test test test"\
" test test test test test test test test test test test test test"\
@@ -256,10 +256,10 @@
fake_clock.AdvanceTimeMilliseconds(100);
module2->Process();
- WebRtc_UWord32 receivedNTPsecs = 0;
- WebRtc_UWord32 receivedNTPfrac = 0;
- WebRtc_UWord32 RTCPArrivalTimeSecs = 0;
- WebRtc_UWord32 RTCPArrivalTimeFrac = 0;
+ uint32_t receivedNTPsecs = 0;
+ uint32_t receivedNTPfrac = 0;
+ uint32_t RTCPArrivalTimeSecs = 0;
+ uint32_t RTCPArrivalTimeFrac = 0;
EXPECT_EQ(0, module2->RemoteNTP(&receivedNTPsecs,
&receivedNTPfrac,
&RTCPArrivalTimeSecs,
@@ -281,28 +281,28 @@
EXPECT_EQ(test_sequence_number, reportBlockReceived.extendedHighSeqNum);
EXPECT_EQ(0, reportBlockReceived.fractionLost);
- EXPECT_EQ(static_cast<WebRtc_UWord32>(0),
+ EXPECT_EQ(static_cast<uint32_t>(0),
reportBlockReceived.cumulativeLost);
- WebRtc_UWord8 fraction_lost = 0; // scale 0 to 255
- WebRtc_UWord32 cum_lost = 0; // number of lost packets
- WebRtc_UWord32 ext_max = 0; // highest sequence number received
- WebRtc_UWord32 jitter = 0;
- WebRtc_UWord32 max_jitter = 0;
+ uint8_t fraction_lost = 0; // scale 0 to 255
+ uint32_t cum_lost = 0; // number of lost packets
+ uint32_t ext_max = 0; // highest sequence number received
+ uint32_t jitter = 0;
+ uint32_t max_jitter = 0;
EXPECT_EQ(0, module2->StatisticsRTP(&fraction_lost,
&cum_lost,
&ext_max,
&jitter,
&max_jitter));
EXPECT_EQ(0, fraction_lost);
- EXPECT_EQ((WebRtc_UWord32)0, cum_lost);
+ EXPECT_EQ((uint32_t)0, cum_lost);
EXPECT_EQ(test_sequence_number, ext_max);
EXPECT_EQ(reportBlockReceived.jitter, jitter);
- WebRtc_UWord16 RTT;
- WebRtc_UWord16 avgRTT;
- WebRtc_UWord16 minRTT;
- WebRtc_UWord16 maxRTT;
+ uint16_t RTT;
+ uint16_t avgRTT;
+ uint16_t minRTT;
+ uint16_t maxRTT;
// Get RoundTripTime.
EXPECT_EQ(0, module1->RTT(test_ssrc + 1, &RTT, &avgRTT, &minRTT, &maxRTT));
diff --git a/modules/rtp_rtcp/test/testAPI/test_api_video.cc b/modules/rtp_rtcp/test/testAPI/test_api_video.cc
index cf181a6..ea22738 100644
--- a/modules/rtp_rtcp/test/testAPI/test_api_video.cc
+++ b/modules/rtp_rtcp/test/testAPI/test_api_video.cc
@@ -68,24 +68,24 @@
}
}
- WebRtc_Word32 BuildRTPheader(WebRtc_UWord8* dataBuffer,
- WebRtc_UWord32 timestamp,
- WebRtc_UWord32 sequence_number) {
- dataBuffer[0] = static_cast<WebRtc_UWord8>(0x80); // version 2
- dataBuffer[1] = static_cast<WebRtc_UWord8>(kPayloadType);
+ int32_t BuildRTPheader(uint8_t* dataBuffer,
+ uint32_t timestamp,
+ uint32_t sequence_number) {
+ dataBuffer[0] = static_cast<uint8_t>(0x80); // version 2
+ dataBuffer[1] = static_cast<uint8_t>(kPayloadType);
ModuleRTPUtility::AssignUWord16ToBuffer(dataBuffer + 2,
sequence_number);
ModuleRTPUtility::AssignUWord32ToBuffer(dataBuffer + 4, timestamp);
ModuleRTPUtility::AssignUWord32ToBuffer(dataBuffer + 8,
0x1234); // SSRC.
- WebRtc_Word32 rtpHeaderLength = 12;
+ int32_t rtpHeaderLength = 12;
return rtpHeaderLength;
}
int PaddingPacket(uint8_t* buffer,
- WebRtc_UWord32 timestamp,
- WebRtc_UWord32 sequence_number,
- WebRtc_Word32 bytes) {
+ uint32_t timestamp,
+ uint32_t sequence_number,
+ int32_t bytes) {
// Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP.
int max_length = 224;
@@ -97,8 +97,8 @@
int header_length = BuildRTPheader(buffer, timestamp,
sequence_number);
buffer[0] |= 0x20; // Set padding bit.
- WebRtc_Word32* data =
- reinterpret_cast<WebRtc_Word32*>(&(buffer[header_length]));
+ int32_t* data =
+ reinterpret_cast<int32_t*>(&(buffer[header_length]));
// Fill data buffer with random data.
for (int j = 0; j < (padding_bytes_in_packet >> 2); j++) {
@@ -120,17 +120,17 @@
RtpRtcp* video_module_;
LoopBackTransport* transport_;
RtpReceiver* receiver_;
- WebRtc_UWord32 test_ssrc_;
- WebRtc_UWord32 test_timestamp_;
- WebRtc_UWord16 test_sequence_number_;
- WebRtc_UWord8 video_frame_[65000];
+ uint32_t test_ssrc_;
+ uint32_t test_timestamp_;
+ uint16_t test_sequence_number_;
+ uint8_t video_frame_[65000];
int payload_data_length_;
SimulatedClock fake_clock;
enum { kPayloadType = 100 };
};
TEST_F(RtpRtcpVideoTest, BasicVideo) {
- WebRtc_UWord32 timestamp = 3000;
+ uint32_t timestamp = 3000;
EXPECT_EQ(0, video_module_->SendOutgoingData(kVideoFrameDelta, 123,
timestamp,
timestamp / 90,
