Use suffixed {uint,int}{8,16,32,64}_t types.

talk/media/webrtc/webrtcvideoengine2_unittest.cc

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 41 matching lines @@
 
 static const cricket::VideoCodec kVp8Codec(100, "VP8", 640, 400, 30, 0);
 static const cricket::VideoCodec kVp9Codec(101, "VP9", 640, 400, 30, 0);
 static const cricket::VideoCodec kH264Codec(102, "H264", 640, 400, 30, 0);
 
 static const cricket::VideoCodec kRedCodec(116, "red", 0, 0, 0, 0);
 static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec", 0, 0, 0, 0);
 
 static const uint8_t kRedRtxPayloadType = 125;
 
-static const uint32 kSsrcs1[] = {1};
-static const uint32 kSsrcs3[] = {1, 2, 3};
-static const uint32 kRtxSsrcs1[] = {4};
-static const uint32 kIncomingUnsignalledSsrc = 0xC0FFEE;
+static const uint32_t kSsrcs1[] = {1};
+static const uint32_t kSsrcs3[] = {1, 2, 3};
+static const uint32_t kRtxSsrcs1[] = {4};
+static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE;
 static const char kUnsupportedExtensionName[] =
     "urn:ietf:params:rtp-hdrext:unsupported";
 
 void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) {
   EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
       cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)));
   EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
       cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli)));
   EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
       cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty)));
@@ skipping 404 matching lines @@
   channel->SetSend(true);
   FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
 
   FakeVideoCapturer capturer1;
   EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer1));
 
   cricket::CapturedFrame frame;
   frame.width = 1280;
   frame.height = 720;
   frame.fourcc = cricket::FOURCC_I420;
-  frame.data_size = static_cast<uint32>(
+  frame.data_size = static_cast<uint32_t>(
       cricket::VideoFrame::SizeOf(frame.width, frame.height));
   rtc::scoped_ptr<char[]> data(new char[frame.data_size]);
   frame.data = data.get();
   memset(frame.data, 1, frame.data_size);
   const int kInitialTimestamp = 123456;
   frame.time_stamp = kInitialTimestamp;
 
   // Deliver initial frame.
   capturer1.SignalCapturedFrame(&frame);
   // Deliver next frame 1 second later.
@@ skipping 51 matching lines @@
 
 TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
   std::vector<cricket::VideoCodec> codecs;
   codecs.push_back(kVp8Codec);
 
   rtc::scoped_ptr<VideoMediaChannel> channel(
       SetUpForExternalEncoderFactory(&encoder_factory, codecs));
 
-  std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3);
+  std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
 
   EXPECT_TRUE(
       channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
   EXPECT_TRUE(channel->SetSend(true));
 
   cricket::FakeVideoCapturer capturer;
   EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer));
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
   EXPECT_TRUE(capturer.CaptureFrame());
@@ skipping 57 matching lines @@
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
 
   std::vector<cricket::VideoCodec> codecs;
   codecs.push_back(kVp8Codec);
 
   rtc::scoped_ptr<VideoMediaChannel> channel(
       SetUpForExternalEncoderFactory(&encoder_factory, codecs));
 
-  std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3);
+  std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
 
   EXPECT_TRUE(
       channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
   EXPECT_TRUE(channel->SetSend(true));
 
   // Send a fake frame, or else the media engine will configure the simulcast
   // encoder adapter at a low-enough size that it'll only create a single
   // encoder layer.
   cricket::FakeVideoCapturer capturer;
   EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer));
@@ skipping 35 matching lines @@
 
 TEST_F(WebRtcVideoEngine2Test, SimulcastDisabledForH264) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
   std::vector<cricket::VideoCodec> codecs;
   codecs.push_back(kH264Codec);
 
   rtc::scoped_ptr<VideoMediaChannel> channel(
       SetUpForExternalEncoderFactory(&encoder_factory, codecs));
 
-  const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3);
+  const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
   EXPECT_TRUE(
       channel->AddSendStream(cricket::CreateSimStreamParams("cname", ssrcs)));
   // Set the stream to 720p. This should trigger a "real" encoder
   // initialization.
   cricket::VideoFormat format(
       1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420);
   EXPECT_TRUE(channel->SetSendStreamFormat(ssrcs[0], format));
   ASSERT_EQ(1u, encoder_factory.encoders().size());
   FakeWebRtcVideoEncoder* encoder = encoder_factory.encoders()[0];
   EXPECT_EQ(webrtc::kVideoCodecH264, encoder->GetCodecSettings().codecType);
@@ skipping 361 matching lines @@
       return AddSendStream(
           cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
     }
     return AddSendStream(CreateSimStreamParams("cname", ssrcs));
   }
 
   rtc::scoped_ptr<FakeCall> fake_call_;
   rtc::scoped_ptr<VideoMediaChannel> channel_;
   cricket::VideoSendParameters send_parameters_;
   cricket::VideoRecvParameters recv_parameters_;
-  uint32 last_ssrc_;
+  uint32_t last_ssrc_;
 };
 
 TEST_F(WebRtcVideoChannel2Test, SetsSyncGroupFromSyncLabel) {
-  const uint32 kVideoSsrc = 123;
+  const uint32_t kVideoSsrc = 123;
   const std::string kSyncLabel = "AvSyncLabel";
 
   cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kVideoSsrc);
   sp.sync_label = kSyncLabel;
   EXPECT_TRUE(channel_->AddRecvStream(sp));
 
   EXPECT_EQ(1, fake_call_->GetVideoReceiveStreams().size());
   EXPECT_EQ(kSyncLabel,
             fake_call_->GetVideoReceiveStreams()[0]->GetConfig().sync_group)
       << "SyncGroup should be set based on sync_label";
 }
 
 TEST_F(WebRtcVideoChannel2Test, RecvStreamWithSimAndRtx) {
   cricket::VideoSendParameters parameters;
   parameters.codecs = engine_.codecs();
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_TRUE(channel_->SetSend(true));
   parameters.options.conference_mode.Set(true);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
   // Send side.
-  const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
-  const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
+  const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
+  const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
   FakeVideoSendStream* send_stream = AddSendStream(
       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
 
   ASSERT_EQ(rtx_ssrcs.size(), send_stream->GetConfig().rtp.rtx.ssrcs.size());
   for (size_t i = 0; i < rtx_ssrcs.size(); ++i)
     EXPECT_EQ(rtx_ssrcs[i], send_stream->GetConfig().rtp.rtx.ssrcs[i]);
 
   // Receiver side.
   FakeVideoReceiveStream* recv_stream = AddRecvStream(
       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
@@ skipping 726 matching lines @@
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) {
   ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   VideoCodec codec;
   EXPECT_TRUE(channel_->GetSendCodec(&codec));
   EXPECT_TRUE(codec.Matches(engine_.codecs()[0]));
 
   // Using a RTX setup to verify that the default RTX payload type is good.
-  const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
-  const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
+  const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
+  const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
   FakeVideoSendStream* stream = AddSendStream(
       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
   webrtc::VideoSendStream::Config config = stream->GetConfig();
 
   // Make sure NACK and FEC are enabled on the correct payload types.
   EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms);
   EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.fec.ulpfec_payload_type);
   EXPECT_EQ(default_red_codec_.id, config.rtp.fec.red_payload_type);
 
   EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size());
@@ skipping 700 matching lines @@
             info.bw_estimations[0].actual_enc_bitrate);
   EXPECT_EQ(1 + 3 + 5 + 7, info.bw_estimations[0].transmit_bitrate)
       << "Bandwidth stats should take all streams into account.";
   EXPECT_EQ(2 + 4 + 6 + 8, info.bw_estimations[0].retransmit_bitrate)
       << "Bandwidth stats should take all streams into account.";
 }
 
 TEST_F(WebRtcVideoChannel2Test, DefaultReceiveStreamReconfiguresToUseRtx) {
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
-  const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
-  const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
+  const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
+  const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
 
   ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
   const size_t kDataLength = 12;
   uint8_t data[kDataLength];
   memset(data, 0, sizeof(data));
   rtc::SetBE32(&data[8], ssrcs[0]);
   rtc::Buffer packet(data, kDataLength);
   rtc::PacketTime packet_time;
   channel_->OnPacketReceived(&packet, packet_time);
 
   ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
       << "No default receive stream created.";
   FakeVideoReceiveStream* recv_stream = fake_call_->GetVideoReceiveStreams()[0];
   EXPECT_EQ(0u, recv_stream->GetConfig().rtp.rtx.size())
       << "Default receive stream should not have configured RTX";
 
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)));
   ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
       << "AddRecvStream should've reconfigured, not added a new receiver.";
   recv_stream = fake_call_->GetVideoReceiveStreams()[0];
   ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size());
   EXPECT_EQ(rtx_ssrcs[0],
             recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
 }
 
 TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithMissingSsrcsForRtx) {
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
-  const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
-  const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
+  const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
+  const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
 
   StreamParams sp =
       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
   sp.ssrcs = ssrcs;  // Without RTXs, this is the important part.
 
   EXPECT_FALSE(channel_->AddSendStream(sp));
   EXPECT_FALSE(channel_->AddRecvStream(sp));
 }
 
 TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithOverlappingRtxSsrcs) {
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
-  const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
-  const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
+  const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
+  const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
 
   StreamParams sp =
       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
 
   EXPECT_TRUE(channel_->AddSendStream(sp));
   EXPECT_TRUE(channel_->AddRecvStream(sp));
 
   // The RTX SSRC is already used in previous streams, using it should fail.
   sp = cricket::StreamParams::CreateLegacy(rtx_ssrcs[0]);
   EXPECT_FALSE(channel_->AddSendStream(sp));
   EXPECT_FALSE(channel_->AddRecvStream(sp));
 
   // After removing the original stream this should be fine to add (makes sure
   // that RTX ssrcs are not forever taken).
   EXPECT_TRUE(channel_->RemoveSendStream(ssrcs[0]));
   EXPECT_TRUE(channel_->RemoveRecvStream(ssrcs[0]));
   EXPECT_TRUE(channel_->AddSendStream(sp));
   EXPECT_TRUE(channel_->AddRecvStream(sp));
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        RejectsAddingStreamsWithOverlappingSimulcastSsrcs) {
-  static const uint32 kFirstStreamSsrcs[] = {1, 2, 3};
-  static const uint32 kOverlappingStreamSsrcs[] = {4, 3, 5};
+  static const uint32_t kFirstStreamSsrcs[] = {1, 2, 3};
+  static const uint32_t kOverlappingStreamSsrcs[] = {4, 3, 5};
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   StreamParams sp =
       cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs));
 
   EXPECT_TRUE(channel_->AddSendStream(sp));
   EXPECT_TRUE(channel_->AddRecvStream(sp));
 
   // One of the SSRCs is already used in previous streams, using it should fail.
   sp = cricket::CreateSimStreamParams("cname",
@@ skipping 305 matching lines @@
   void VerifySimulcastSettings(const VideoCodec& codec,
                                VideoOptions::HighestBitrate bitrate_mode,
                                size_t num_configured_streams,
                                size_t expected_num_streams,
                                SimulcastBitrateMode simulcast_bitrate_mode) {
     cricket::VideoSendParameters parameters;
     parameters.options.video_highest_bitrate.Set(bitrate_mode);
     parameters.codecs.push_back(codec);
     ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
-    std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3);
+    std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
     RTC_DCHECK(num_configured_streams <= ssrcs.size());
     ssrcs.resize(num_configured_streams);
 
     FakeVideoSendStream* stream =
         AddSendStream(CreateSimStreamParams("cname", ssrcs));
     // Send a full-size frame to trigger a stream reconfiguration to use all
     // expected simulcast layers.
     cricket::FakeVideoCapturer capturer;
     EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), &capturer));
     EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(cricket::VideoFormat(
@@ skipping 88 matching lines @@
     EXPECT_TRUE(channel_->AddRecvStream(sp));
     std::vector<FakeVideoReceiveStream*> streams =
         fake_call_.GetVideoReceiveStreams();
     EXPECT_EQ(num_streams + 1, streams.size());
     return streams[streams.size() - 1];
   }
 
   FakeCall fake_call_;
   WebRtcVideoEngine2 engine_;
   rtc::scoped_ptr<VideoMediaChannel> channel_;
-  uint32 last_ssrc_;
+  uint32_t last_ssrc_;
 };
 
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) {
   VerifySimulcastSettings(kVp8Codec, VideoOptions::NORMAL, 2, 2, SBM_NORMAL);
 }
 
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) {
   VerifySimulcastSettings(
       kVp8Codec720p, VideoOptions::NORMAL, 3, 3, SBM_NORMAL);
 }
@@ skipping 103 matching lines @@
 // Ensures that the correct settings are applied to the codec when two temporal
 // layer screencasting is enabled, and that the correct simulcast settings are
 // reapplied when disabling screencasting.
 TEST_F(WebRtcVideoChannel2SimulcastTest,
        DISABLED_TwoTemporalLayerScreencastSettings) {
   // TODO(pbos): Implement.
   FAIL() << "Not implemented.";
 }
 
 }  // namespace cricket