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

talk/media/base/videoengine_unittest.h

 /*
  * libjingle
  * Copyright 2014 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 40 matching lines @@
 #define EXPECT_FRAME_ON_RENDERER_WAIT(r, c, w, h, t) \
   EXPECT_EQ_WAIT((c), (r).num_rendered_frames(), (t)); \
   EXPECT_EQ((w), (r).width()); \
   EXPECT_EQ((h), (r).height()); \
   EXPECT_EQ(0, (r).errors()); \
 
 #define EXPECT_GT_FRAME_ON_RENDERER_WAIT(r, c, w, h, t) \
   EXPECT_TRUE_WAIT((r).num_rendered_frames() >= (c) && \
                    (w) == (r).width() && \
                    (h) == (r).height(), (t)); \
-  EXPECT_EQ(0, (r).errors()); \
+  EXPECT_EQ(0, (r).errors());
 
-static const uint32 kTimeout = 5000U;
-static const uint32 kDefaultReceiveSsrc = 0;
-static const uint32 kSsrc = 1234u;
-static const uint32 kRtxSsrc = 4321u;
-static const uint32 kSsrcs4[] = {1, 2, 3, 4};
+static const uint32_t kTimeout = 5000U;
+static const uint32_t kDefaultReceiveSsrc = 0;
+static const uint32_t kSsrc = 1234u;
+static const uint32_t kRtxSsrc = 4321u;
+static const uint32_t kSsrcs4[] = {1, 2, 3, 4};
 
 inline bool IsEqualRes(const cricket::VideoCodec& a, int w, int h, int fps) {
   return a.width == w && a.height == h && a.framerate == fps;
 }
 
 inline bool IsEqualCodec(const cricket::VideoCodec& a,
                          const cricket::VideoCodec& b) {
   return a.id == b.id && a.name == b.name &&
       IsEqualRes(a, b.width, b.height, b.framerate);
 }
@@ skipping 34 matching lines @@
       video_capturer->SignalVideoFrame.disconnect(this);
     }
   }
   void OnLocalFrame(cricket::VideoCapturer*,
                     const cricket::VideoFrame*) {
   }
   void OnLocalFrameFormat(cricket::VideoCapturer*,
                           const cricket::VideoFormat*) {
   }
 
-  void TriggerMediaFrame(
-      uint32 ssrc, cricket::VideoFrame* frame, bool* drop_frame) {
+  void TriggerMediaFrame(uint32_t ssrc,
+                         cricket::VideoFrame* frame,
+                         bool* drop_frame) {
     T::SignalMediaFrame(ssrc, frame, drop_frame);
   }
 };
 
 template<class E>
 class VideoEngineTest : public testing::Test {
  protected:
   // Tests starting and stopping the engine, and creating a channel.
   void StartupShutdown() {
     EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
@@ skipping 417 matching lines @@
       success = channel_->SetSendParameters(parameters);
     }
     if (success) {
       success = SetSend(sending);
     }
     return success;
   }
   bool SetSend(bool send) {
     return channel_->SetSend(send);
   }
-  bool SetSendStreamFormat(uint32 ssrc, const cricket::VideoCodec& codec) {
+  bool SetSendStreamFormat(uint32_t ssrc, const cricket::VideoCodec& codec) {
     return channel_->SetSendStreamFormat(ssrc, cricket::VideoFormat(
         codec.width, codec.height,
         cricket::VideoFormat::FpsToInterval(codec.framerate),
         cricket::FOURCC_ANY));
   }
   int DrainOutgoingPackets() {
     int packets = 0;
     do {
       packets = NumRtpPackets();
       // 100 ms should be long enough.
@@ skipping 30 matching lines @@
     return 0;
 #endif
   }
   bool SendCustomVideoFrame(int w, int h) {
     if (!video_capturer_.get()) return false;
     return video_capturer_->CaptureCustomFrame(w, h, cricket::FOURCC_I420);
   }
   int NumRtpBytes() {
     return network_interface_.NumRtpBytes();
   }
-  int NumRtpBytes(uint32 ssrc) {
+  int NumRtpBytes(uint32_t ssrc) {
     return network_interface_.NumRtpBytes(ssrc);
   }
   int NumRtpPackets() {
     return network_interface_.NumRtpPackets();
   }
-  int NumRtpPackets(uint32 ssrc) {
+  int NumRtpPackets(uint32_t ssrc) {
     return network_interface_.NumRtpPackets(ssrc);
   }
   int NumSentSsrcs() {
     return network_interface_.NumSentSsrcs();
   }
   const rtc::Buffer* GetRtpPacket(int index) {
     return network_interface_.GetRtpPacket(index);
   }
   int NumRtcpPackets() {
     return network_interface_.NumRtcpPackets();
   }
   const rtc::Buffer* GetRtcpPacket(int index) {
     return network_interface_.GetRtcpPacket(index);
   }
   static int GetPayloadType(const rtc::Buffer* p) {
     int pt = -1;
     ParseRtpPacket(p, NULL, &pt, NULL, NULL, NULL, NULL);
     return pt;
   }
-  static bool ParseRtpPacket(const rtc::Buffer* p, bool* x, int* pt,
-                             int* seqnum, uint32* tstamp, uint32* ssrc,
+  static bool ParseRtpPacket(const rtc::Buffer* p,
+                             bool* x,
+                             int* pt,
+                             int* seqnum,
+                             uint32_t* tstamp,
+                             uint32_t* ssrc,
                              std::string* payload) {
     rtc::ByteBuffer buf(*p);
-    uint8 u08 = 0;
-    uint16 u16 = 0;
-    uint32 u32 = 0;
+    uint8_t u08 = 0;
+    uint16_t u16 = 0;
+    uint32_t u32 = 0;
 
     // Read X and CC fields.
     if (!buf.ReadUInt8(&u08)) return false;
     bool extension = ((u08 & 0x10) != 0);
-    uint8 cc = (u08 & 0x0F);
+    uint8_t cc = (u08 & 0x0F);
     if (x) *x = extension;
 
     // Read PT field.
     if (!buf.ReadUInt8(&u08)) return false;
     if (pt) *pt = (u08 & 0x7F);
 
     // Read Sequence Number field.
     if (!buf.ReadUInt16(&u16)) return false;
     if (seqnum) *seqnum = u16;
 
     // Read Timestamp field.
     if (!buf.ReadUInt32(&u32)) return false;
     if (tstamp) *tstamp = u32;
 
     // Read SSRC field.
     if (!buf.ReadUInt32(&u32)) return false;
     if (ssrc) *ssrc = u32;
 
     // Skip CSRCs.
-    for (uint8 i = 0; i < cc; ++i) {
+    for (uint8_t i = 0; i < cc; ++i) {
       if (!buf.ReadUInt32(&u32)) return false;
     }
 
     // Skip extension header.
     if (extension) {
       // Read Profile-specific extension header ID
       if (!buf.ReadUInt16(&u16)) return false;
 
       // Read Extension header length
       if (!buf.ReadUInt16(&u16)) return false;
-      uint16 ext_header_len = u16;
+      uint16_t ext_header_len = u16;
 
       // Read Extension header
-      for (uint16 i = 0; i < ext_header_len; ++i) {
+      for (uint16_t i = 0; i < ext_header_len; ++i) {
         if (!buf.ReadUInt32(&u32)) return false;
       }
     }
 
     if (payload) {
       return buf.ReadString(payload, buf.Length());
     }
     return true;
   }
 
   // Parse all RTCP packet, from start_index to stop_index, and count how many
   // FIR (PT=206 and FMT=4 according to RFC 5104). If successful, set the count
   // and return true.
   bool CountRtcpFir(int start_index, int stop_index, int* fir_count) {
     int count = 0;
     for (int i = start_index; i < stop_index; ++i) {
       rtc::scoped_ptr<const rtc::Buffer> p(GetRtcpPacket(i));
       rtc::ByteBuffer buf(*p);
       size_t total_len = 0;
       // The packet may be a compound RTCP packet.
       while (total_len < p->size()) {
         // Read FMT, type and length.
-        uint8 fmt = 0;
-        uint8 type = 0;
-        uint16 length = 0;
+        uint8_t fmt = 0;
+        uint8_t type = 0;
+        uint16_t length = 0;
         if (!buf.ReadUInt8(&fmt)) return false;
         fmt &= 0x1F;
         if (!buf.ReadUInt8(&type)) return false;
         if (!buf.ReadUInt16(&length)) return false;
         buf.Consume(length * 4);  // Skip RTCP data.
         total_len += (length + 1) * 4;
         if ((192 == type) || ((206 == type) && (4 == fmt))) {
           ++count;
         }
       }
     }
 
     if (fir_count) {
       *fir_count = count;
     }
     return true;
   }
 
-  void OnVideoChannelError(uint32 ssrc,
+  void OnVideoChannelError(uint32_t ssrc,
                            cricket::VideoMediaChannel::Error error) {
     media_error_ = error;
   }
 
   // Test that SetSend works.
   void SetSend() {
     EXPECT_FALSE(channel_->sending());
     EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get()));
     EXPECT_TRUE(SetOneCodec(DefaultCodec()));
     EXPECT_FALSE(channel_->sending());
@@ skipping 145 matching lines @@
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(1)));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(2)));
     EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
     EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
     EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_EQ(0, renderer1.num_rendered_frames());
     EXPECT_EQ(0, renderer2.num_rendered_frames());
-    std::vector<uint32> ssrcs;
+    std::vector<uint32_t> ssrcs;
     ssrcs.push_back(1);
     ssrcs.push_back(2);
     network_interface_.SetConferenceMode(true, ssrcs);
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_ON_RENDERER_WAIT(
         renderer1, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
     EXPECT_FRAME_ON_RENDERER_WAIT(
         renderer2, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
 
     EXPECT_TRUE(channel_->SetSend(false));
@@ skipping 57 matching lines @@
     EXPECT_TRUE(channel_->SetRenderer(5678, &renderer2));
     EXPECT_TRUE(capturer->CaptureCustomFrame(
         kTestWidth, kTestHeight, cricket::FOURCC_I420));
     EXPECT_FRAME_ON_RENDERER_WAIT(
         renderer2, 1, kTestWidth, kTestHeight, kTimeout);
 
     // Get stats, and make sure they are correct for two senders. We wait until
     // the number of expected packets have been sent to avoid races where we
     // check stats before it has been updated.
     cricket::VideoMediaInfo info;
-    for (uint32 i = 0; i < kTimeout; ++i) {
+    for (uint32_t i = 0; i < kTimeout; ++i) {
       rtc::Thread::Current()->ProcessMessages(1);
       EXPECT_TRUE(channel_->GetStats(&info));
       ASSERT_EQ(2U, info.senders.size());
       if (info.senders[0].packets_sent + info.senders[1].packets_sent ==
           NumRtpPackets()) {
         // Stats have been updated for both sent frames, expectations can be
         // checked now.
         break;
       }
     }
@@ skipping 21 matching lines @@
     parameters.max_bandwidth_bps = 128 * 1024;
     EXPECT_TRUE(channel_->SetSendParameters(parameters));
   }
   // Test that we can set the SSRC for the default send source.
   void SetSendSsrc() {
     EXPECT_TRUE(SetDefaultCodec());
     EXPECT_TRUE(SetSendStreamFormat(kSsrc, DefaultCodec()));
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(SendFrame());
     EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
-    uint32 ssrc = 0;
+    uint32_t ssrc = 0;
     rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
     EXPECT_EQ(kSsrc, ssrc);
     EXPECT_EQ(NumRtpPackets(), NumRtpPackets(ssrc));
     EXPECT_EQ(NumRtpBytes(), NumRtpBytes(ssrc));
     EXPECT_EQ(1, NumSentSsrcs());
     EXPECT_EQ(0, NumRtpPackets(kSsrc - 1));
     EXPECT_EQ(0, NumRtpBytes(kSsrc - 1));
   }
   // Test that we can set the SSRC even after codecs are set.
   void SetSendSsrcAfterSetCodecs() {
     // Remove stream added in Setup.
     EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
     EXPECT_TRUE(SetDefaultCodec());
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(999)));
     EXPECT_TRUE(channel_->SetCapturer(999u, video_capturer_.get()));
     EXPECT_TRUE(SetSendStreamFormat(999u, DefaultCodec()));
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(WaitAndSendFrame(0));
     EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
-    uint32 ssrc = 0;
+    uint32_t ssrc = 0;
     rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
     EXPECT_EQ(999u, ssrc);
     EXPECT_EQ(NumRtpPackets(), NumRtpPackets(ssrc));
     EXPECT_EQ(NumRtpBytes(), NumRtpBytes(ssrc));
     EXPECT_EQ(1, NumSentSsrcs());
     EXPECT_EQ(0, NumRtpPackets(kSsrc));
     EXPECT_EQ(0, NumRtpBytes(kSsrc));
   }
   // Test that we can set the default video renderer before and after
   // media is received.
   void SetRenderer() {
-    uint8 data1[] = {
-        0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
+    uint8_t data1[] = {
+        0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
     rtc::Buffer packet1(data1, sizeof(data1));
     rtc::SetBE32(packet1.data() + 8, kSsrc);
     channel_->SetRenderer(kDefaultReceiveSsrc, NULL);
     EXPECT_TRUE(SetDefaultCodec());
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     channel_->OnPacketReceived(&packet1, rtc::PacketTime());
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
@@ skipping 14 matching lines @@
 
   // Tests setting up and configuring a send stream.
   void AddRemoveSendStreams() {
     EXPECT_TRUE(SetOneCodec(DefaultCodec()));
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
     EXPECT_GT(NumRtpPackets(), 0);
-    uint32 ssrc = 0;
+    uint32_t ssrc = 0;
     size_t last_packet = NumRtpPackets() - 1;
     rtc::scoped_ptr<const rtc::Buffer>
         p(GetRtpPacket(static_cast<int>(last_packet)));
     ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
     EXPECT_EQ(kSsrc, ssrc);
 
     // Remove the send stream that was added during Setup.
     EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
     int rtp_packets = NumRtpPackets();
 
@@ skipping 154 matching lines @@
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(1)));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(2)));
     EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
     EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
     EXPECT_EQ(0, renderer1.num_rendered_frames());
     EXPECT_EQ(0, renderer2.num_rendered_frames());
-    std::vector<uint32> ssrcs;
+    std::vector<uint32_t> ssrcs;
     ssrcs.push_back(1);
     ssrcs.push_back(2);
     network_interface_.SetConferenceMode(true, ssrcs);
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_ON_RENDERER_WAIT(
         renderer1, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
     EXPECT_FRAME_ON_RENDERER_WAIT(
         renderer2, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
 
     rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
@@ skipping 352 matching lines @@
   void SetSendStreamFormat0x0() {
     EXPECT_TRUE(SetOneCodec(DefaultCodec()));
     EXPECT_TRUE(SetSendStreamFormat(kSsrc, DefaultCodec()));
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     // This frame should be received.
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
-    const int64 interval = cricket::VideoFormat::FpsToInterval(
-        DefaultCodec().framerate);
+    const int64_t interval =
+        cricket::VideoFormat::FpsToInterval(DefaultCodec().framerate);
     cricket::VideoFormat format(
         0,
         0,
         interval,
         cricket::FOURCC_I420);
     EXPECT_TRUE(channel_->SetSendStreamFormat(kSsrc, format));
     // This frame should not be received.
     EXPECT_TRUE(WaitAndSendFrame(
         static_cast<int>(interval/rtc::kNumNanosecsPerMillisec)));
     rtc::Thread::Current()->ProcessMessages(500);
@@ skipping 90 matching lines @@
   void TwoStreamsReUseFirstStream(const cricket::VideoCodec& codec) {
     SetUpSecondStream();
     // Default channel used by the first stream.
     EXPECT_EQ(kSsrc, channel_->GetDefaultSendChannelSsrc());
     EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc));
     EXPECT_FALSE(channel_->RemoveRecvStream(kSsrc));
     EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
     EXPECT_FALSE(channel_->RemoveSendStream(kSsrc));
     // Default channel is no longer used by a stream.
     EXPECT_EQ(0u, channel_->GetDefaultSendChannelSsrc());
-    uint32 new_ssrc = kSsrc + 100;
+    uint32_t new_ssrc = kSsrc + 100;
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(new_ssrc)));
     // Re-use default channel.
     EXPECT_EQ(new_ssrc, channel_->GetDefaultSendChannelSsrc());
     EXPECT_FALSE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(new_ssrc)));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(new_ssrc)));
     EXPECT_TRUE(channel_->SetRenderer(new_ssrc, &renderer_));
     EXPECT_FALSE(channel_->AddRecvStream(
@@ skipping 71 matching lines @@
   rtc::scoped_ptr<C> channel_;
   cricket::FakeNetworkInterface network_interface_;
   cricket::FakeVideoRenderer renderer_;
   cricket::VideoMediaChannel::Error media_error_;
 
   // Used by test cases where 2 streams are run on the same channel.
   cricket::FakeVideoRenderer renderer2_;
 };
 
 #endif  // TALK_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_  NOLINT