[rtp_rtcp] lint errors about rand() usage fixed.

webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 /*
  * Test application for core FEC algorithm. Calls encoding and decoding
  * functions in ForwardErrorCorrection directly.
  */
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
 #include <list>
 
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/base/random.h"
+#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h"
-
-#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 // #define VERBOSE_OUTPUT
 
 namespace webrtc {
 namespace fec_private_tables {
 extern const uint8_t** kPacketMaskBurstyTbl[12];
 }
 namespace test {
 using fec_private_tables::kPacketMaskBurstyTbl;
 
 void ReceivePackets(
     ForwardErrorCorrection::ReceivedPacketList* toDecodeList,
     ForwardErrorCorrection::ReceivedPacketList* receivedPacketList,
-    uint32_t numPacketsToDecode,
+    size_t numPacketsToDecode,
     float reorderRate,
-    float duplicateRate) {
+    float duplicateRate,
+    Random* random) {
   assert(toDecodeList->empty());
   assert(numPacketsToDecode <= receivedPacketList->size());
 
   ForwardErrorCorrection::ReceivedPacketList::iterator it;
-  for (uint32_t i = 0; i < numPacketsToDecode; i++) {
+  for (size_t i = 0; i < numPacketsToDecode; i++) {
     it = receivedPacketList->begin();
     // Reorder packets.
-    float randomVariable = static_cast<float>(rand()) / RAND_MAX;
+    float randomVariable = random->Rand<float>();
     while (randomVariable < reorderRate) {
       ++it;
       if (it == receivedPacketList->end()) {
         --it;
         break;
       }
-      randomVariable = static_cast<float>(rand()) / RAND_MAX;
+      randomVariable = random->Rand<float>();
     }
     ForwardErrorCorrection::ReceivedPacket* receivedPacket = *it;
     toDecodeList->push_back(receivedPacket);
 
     // Duplicate packets.
-    randomVariable = static_cast<float>(rand()) / RAND_MAX;
+    randomVariable = random->Rand<float>();
     while (randomVariable < duplicateRate) {
       ForwardErrorCorrection::ReceivedPacket* duplicatePacket =
           new ForwardErrorCorrection::ReceivedPacket;
       *duplicatePacket = *receivedPacket;
       duplicatePacket->pkt = new ForwardErrorCorrection::Packet;
       memcpy(duplicatePacket->pkt->data, receivedPacket->pkt->data,
              receivedPacket->pkt->length);
       duplicatePacket->pkt->length = receivedPacket->pkt->length;
 
       toDecodeList->push_back(duplicatePacket);
-      randomVariable = static_cast<float>(rand()) / RAND_MAX;
+      randomVariable = random->Rand<float>();
     }
     receivedPacketList->erase(it);
   }
 }
 
 TEST(FecTest, FecTest) {
   // TODO(marpan): Split this function into subroutines/helper functions.
   enum { kMaxNumberMediaPackets = 48 };
   enum { kMaxNumberFecPackets = 48 };
 
@@ skipping 30 matching lines @@
   const float reorderRate = 0.1f;
   const float duplicateRate = 0.1f;
 
   uint8_t mediaLossMask[kMaxNumberMediaPackets];
   uint8_t fecLossMask[kMaxNumberFecPackets];
   uint8_t fecPacketMasks[kMaxNumberFecPackets][kMaxNumberMediaPackets];
 
   // Seed the random number generator, storing the seed to file in order to
   // reproduce past results.
   const unsigned int randomSeed = static_cast<unsigned int>(time(NULL));
-  srand(randomSeed);
+  Random random(randomSeed);
   std::string filename = webrtc::test::OutputPath() + "randomSeedLog.txt";
   FILE* randomSeedFile = fopen(filename.c_str(), "a");
   fprintf(randomSeedFile, "%u\n", randomSeed);
   fclose(randomSeedFile);
   randomSeedFile = NULL;
 
   uint16_t seqNum = 0;
-  uint32_t timeStamp = static_cast<uint32_t>(rand());
-  const uint32_t ssrc = static_cast<uint32_t>(rand());
+  uint32_t timeStamp = random.Rand<uint32_t>();
+  const uint32_t ssrc = random.Rand(1u, 0xfffffffe);
 
   // Loop over the mask types: random and bursty.
   for (int mask_type_idx = 0; mask_type_idx < kNumFecMaskTypes;
        ++mask_type_idx) {
     for (uint32_t lossRateIdx = 0; lossRateIdx < lossRateSize; ++lossRateIdx) {
       printf("Loss rate: %.2f, Mask type %d \n", lossRate[lossRateIdx],
              mask_type_idx);
 
       const uint32_t packetMaskMax = kMaxMediaPackets[mask_type_idx];
       uint8_t* packetMask = new uint8_t[packetMaskMax * kNumMaskBytesL1];
@@ skipping 72 matching lines @@
 
             // Construct media packets.
             // Reset the sequence number here for each FEC code/mask tested
             // below, to avoid sequence number wrap-around. In actual decoding,
             // old FEC packets in list are dropped if sequence number wrap
             // around is detected. This case is currently not handled below.
             seqNum = 0;
             for (uint32_t i = 0; i < numMediaPackets; ++i) {
               mediaPacket = new ForwardErrorCorrection::Packet;
               mediaPacketList.push_back(mediaPacket);
-              mediaPacket->length = static_cast<size_t>(
-                  (static_cast<float>(rand()) / RAND_MAX) *
-                  (IP_PACKET_SIZE - 12 - 28 -
-                   ForwardErrorCorrection::PacketOverhead()));
-              if (mediaPacket->length < 12) {
-                mediaPacket->length = 12;
-              }
+              const uint32_t kMinPacketSize = 12;
+              const uint32_t kMaxPacketSize = static_cast<uint32_t>(
+                  IP_PACKET_SIZE - 12 - 28 -
+                  ForwardErrorCorrection::PacketOverhead());
+              mediaPacket->length = random.Rand(kMinPacketSize, kMaxPacketSize);
+
               // Generate random values for the first 2 bytes.
-              mediaPacket->data[0] = static_cast<uint8_t>(rand() % 256);
-              mediaPacket->data[1] = static_cast<uint8_t>(rand() % 256);
+              mediaPacket->data[0] = random.Rand<uint8_t>();
+              mediaPacket->data[1] = random.Rand<uint8_t>();
 
               // The first two bits are assumed to be 10 by the
               // FEC encoder. In fact the FEC decoder will set the
               // two first bits to 10 regardless of what they
               // actually were. Set the first two bits to 10
               // so that a memcmp can be performed for the
               // whole restored packet.
               mediaPacket->data[0] |= 0x80;
               mediaPacket->data[0] &= 0xbf;
 
               // FEC is applied to a whole frame.
               // A frame is signaled by multiple packets without
               // the marker bit set followed by the last packet of
               // the frame for which the marker bit is set.
               // Only push one (fake) frame to the FEC.
               mediaPacket->data[1] &= 0x7f;
 
               ByteWriter<uint16_t>::WriteBigEndian(&mediaPacket->data[2],
                                                    seqNum);
               ByteWriter<uint32_t>::WriteBigEndian(&mediaPacket->data[4],
                                                    timeStamp);
               ByteWriter<uint32_t>::WriteBigEndian(&mediaPacket->data[8], ssrc);
               // Generate random values for payload
               for (size_t j = 12; j < mediaPacket->length; ++j) {
-                mediaPacket->data[j] = static_cast<uint8_t>(rand() % 256);
+                mediaPacket->data[j] = random.Rand<uint8_t>();
               }
               seqNum++;
             }
             mediaPacket->data[1] |= 0x80;
 
             ASSERT_EQ(0, fec.GenerateFEC(mediaPacketList, protectionFactor,
                                          numImpPackets, kUseUnequalProtection,
                                          fec_mask_type, &fecPacketList))
                 << "GenerateFEC() failed";
 
             ASSERT_EQ(numFecPackets, fecPacketList.size())
                 << "We requested " << numFecPackets << " FEC packets, but "
                 << "GenerateFEC() produced " << fecPacketList.size();
             memset(mediaLossMask, 0, sizeof(mediaLossMask));
             ForwardErrorCorrection::PacketList::iterator mediaPacketListItem =
                 mediaPacketList.begin();
             ForwardErrorCorrection::ReceivedPacket* receivedPacket;
             uint32_t mediaPacketIdx = 0;
 
             while (mediaPacketListItem != mediaPacketList.end()) {
               mediaPacket = *mediaPacketListItem;
               // We want a value between 0 and 1.
-              const float lossRandomVariable =
-                  (static_cast<float>(rand()) / (RAND_MAX));
+              const float lossRandomVariable = random.Rand<float>();
 
               if (lossRandomVariable >= lossRate[lossRateIdx]) {
                 mediaLossMask[mediaPacketIdx] = 1;
                 receivedPacket = new ForwardErrorCorrection::ReceivedPacket;
                 receivedPacket->pkt = new ForwardErrorCorrection::Packet;
                 receivedPacketList.push_back(receivedPacket);
 
                 receivedPacket->pkt->length = mediaPacket->length;
                 memcpy(receivedPacket->pkt->data, mediaPacket->data,
                        mediaPacket->length);
                 receivedPacket->seq_num =
                     ByteReader<uint16_t>::ReadBigEndian(&mediaPacket->data[2]);
                 receivedPacket->is_fec = false;
               }
               mediaPacketIdx++;
               ++mediaPacketListItem;
             }
             memset(fecLossMask, 0, sizeof(fecLossMask));
             ForwardErrorCorrection::PacketList::iterator fecPacketListItem =
                 fecPacketList.begin();
             ForwardErrorCorrection::Packet* fecPacket;
             uint32_t fecPacketIdx = 0;
             while (fecPacketListItem != fecPacketList.end()) {
               fecPacket = *fecPacketListItem;
-              const float lossRandomVariable =
-                  (static_cast<float>(rand()) / (RAND_MAX));
+              const float lossRandomVariable = random.Rand<float>();
               if (lossRandomVariable >= lossRate[lossRateIdx]) {
                 fecLossMask[fecPacketIdx] = 1;
                 receivedPacket = new ForwardErrorCorrection::ReceivedPacket;
                 receivedPacket->pkt = new ForwardErrorCorrection::Packet;
 
                 receivedPacketList.push_back(receivedPacket);
 
                 receivedPacket->pkt->length = fecPacket->length;
                 memcpy(receivedPacket->pkt->data, fecPacket->data,
                        fecPacket->length);
@@ skipping 50 matching lines @@
 #ifdef VERBOSE_OUTPUT
             printf("Recovery mask:\n");
             for (uint32_t i = 0; i < numMediaPackets; ++i) {
               printf("%u ", mediaLossMask[i]);
             }
             printf("\n\n");
 #endif
             // For error-checking frame completion.
             bool fecPacketReceived = false;
             while (!receivedPacketList.empty()) {
-              uint32_t numPacketsToDecode = static_cast<uint32_t>(
-                  (static_cast<float>(rand()) / RAND_MAX) *
-                      receivedPacketList.size() +
-                  0.5);
-              if (numPacketsToDecode < 1) {
-                numPacketsToDecode = 1;
-              }
+              size_t numPacketsToDecode = random.Rand(
+                  1u, static_cast<uint32_t>(receivedPacketList.size()));
               ReceivePackets(&toDecodeList, &receivedPacketList,
-                             numPacketsToDecode, reorderRate, duplicateRate);
+                             numPacketsToDecode, reorderRate, duplicateRate,
+                             &random);
 
               if (fecPacketReceived == false) {
                 ForwardErrorCorrection::ReceivedPacketList::iterator
                     toDecodeIt = toDecodeList.begin();
                 while (toDecodeIt != toDecodeList.end()) {
                   receivedPacket = *toDecodeIt;
                   if (receivedPacket->is_fec) {
                     fecPacketReceived = true;
                   }
                   ++toDecodeIt;
@@ skipping 75 matching lines @@
   }    // loop over mask types
 
   // Have DecodeFEC free allocated memory.
   fec.ResetState(&recoveredPacketList);
   ASSERT_TRUE(recoveredPacketList.empty())
       << "Recovered packet list is not empty";
 }
 
 }  // namespace test
 }  // namespace webrtc