[rtp_rtcp] Lint errors cleared from rtp_rtcp/test

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.
  */
 
@@ skipping 10 matching lines @@
 
 #include <list>
 
 #include "testing/gtest/include/gtest/gtest.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
+// #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, float reorderRate, float duplicateRate) {
+    uint32_t numPacketsToDecode,
+    float reorderRate,
+    float duplicateRate) {
   assert(toDecodeList->empty());
   assert(numPacketsToDecode <= receivedPacketList->size());
 
   ForwardErrorCorrection::ReceivedPacketList::iterator it;
   for (uint32_t i = 0; i < numPacketsToDecode; i++) {
     it = receivedPacketList->begin();
     // Reorder packets.
     float randomVariable = static_cast<float>(rand()) / RAND_MAX;
     while (randomVariable < reorderRate) {
       ++it;
@@ skipping 19 matching lines @@
 
       toDecodeList->push_back(duplicatePacket);
       randomVariable = static_cast<float>(rand()) / RAND_MAX;
     }
     receivedPacketList->erase(it);
   }
 }
 
 TEST(FecTest, FecTest) {
   // TODO(marpan): Split this function into subroutines/helper functions.
-  enum {
-    kMaxNumberMediaPackets = 48
-  };
-  enum {
-    kMaxNumberFecPackets = 48
-  };
+  enum { kMaxNumberMediaPackets = 48 };
+  enum { kMaxNumberFecPackets = 48 };
 
   const uint32_t kNumMaskBytesL0 = 2;
   const uint32_t kNumMaskBytesL1 = 6;
 
   // FOR UEP
   const bool kUseUnequalProtection = true;
 
   // FEC mask types.
-  const FecMaskType kMaskTypes[] = { kFecMaskRandom, kFecMaskBursty };
+  const FecMaskType kMaskTypes[] = {kFecMaskRandom, kFecMaskBursty};
   const int kNumFecMaskTypes = sizeof(kMaskTypes) / sizeof(*kMaskTypes);
 
   // Maximum number of media packets allowed for the mask type.
-  const uint16_t kMaxMediaPackets[] = {kMaxNumberMediaPackets,
+  const uint16_t kMaxMediaPackets[] = {
+      kMaxNumberMediaPackets,
       sizeof(kPacketMaskBurstyTbl) / sizeof(*kPacketMaskBurstyTbl)};
 
   ASSERT_EQ(12, kMaxMediaPackets[1]) << "Max media packets for bursty mode not "
                                      << "equal to 12.";
 
   ForwardErrorCorrection fec;
   ForwardErrorCorrection::PacketList mediaPacketList;
   ForwardErrorCorrection::PacketList fecPacketList;
   ForwardErrorCorrection::ReceivedPacketList toDecodeList;
   ForwardErrorCorrection::ReceivedPacketList receivedPacketList;
   ForwardErrorCorrection::RecoveredPacketList recoveredPacketList;
   std::list<uint8_t*> fecMaskList;
 
   ForwardErrorCorrection::Packet* mediaPacket = NULL;
   // Running over only one loss rate to limit execution time.
-  const float lossRate[] = { 0.5f };
+  const float lossRate[] = {0.5f};
   const uint32_t lossRateSize = sizeof(lossRate) / sizeof(*lossRate);
   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);
   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());
 
   // 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];
 
       FecMaskType fec_mask_type = kMaskTypes[mask_type_idx];
 
       for (uint32_t numMediaPackets = 1; numMediaPackets <= packetMaskMax;
            numMediaPackets++) {
         internal::PacketMaskTable mask_table(fec_mask_type, numMediaPackets);
 
         for (uint32_t numFecPackets = 1;
              numFecPackets <= numMediaPackets && numFecPackets <= packetMaskMax;
              numFecPackets++) {
-
           // Loop over numImpPackets: usually <= (0.3*numMediaPackets).
           // For this test we check up to ~ (numMediaPackets / 4).
           uint32_t maxNumImpPackets = numMediaPackets / 4 + 1;
           for (uint32_t numImpPackets = 0; numImpPackets <= maxNumImpPackets &&
-                                               numImpPackets <= packetMaskMax;
+                                           numImpPackets <= packetMaskMax;
                numImpPackets++) {
-
             uint8_t protectionFactor =
                 static_cast<uint8_t>(numFecPackets * 255 / numMediaPackets);
 
             const uint32_t maskBytesPerFecPacket =
                 (numMediaPackets > 16) ? kNumMaskBytesL1 : kNumMaskBytesL0;
 
             memset(packetMask, 0, numMediaPackets * maskBytesPerFecPacket);
 
             // Transfer packet masks from bit-mask to byte-mask.
             internal::GeneratePacketMasks(numMediaPackets, numFecPackets,
                                           numImpPackets, kUseUnequalProtection,
                                           mask_table, packetMask);
 
 #ifdef VERBOSE_OUTPUT
-            printf("%u media packets, %u FEC packets, %u numImpPackets, "
-                   "loss rate = %.2f \n",
-                   numMediaPackets, numFecPackets, numImpPackets,
-                   lossRate[lossRateIdx]);
+            printf(
+                "%u media packets, %u FEC packets, %u numImpPackets, "
+                "loss rate = %.2f \n",
+                numMediaPackets, numFecPackets, numImpPackets,
+                lossRate[lossRateIdx]);
             printf("Packet mask matrix \n");
 #endif
 
             for (uint32_t i = 0; i < numFecPackets; i++) {
               for (uint32_t j = 0; j < numMediaPackets; j++) {
                 const uint8_t byteMask =
                     packetMask[i * maskBytesPerFecPacket + j / 8];
                 const uint32_t bitPosition = (7 - j % 8);
                 fecPacketMasks[i][j] =
                     (byteMask & (1 << bitPosition)) >> bitPosition;
@@ skipping 184 matching lines @@
             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);
+                      receivedPacketList.size() +
+                  0.5);
               if (numPacketsToDecode < 1) {
                 numPacketsToDecode = 1;
               }
               ReceivePackets(&toDecodeList, &receivedPacketList,
                              numPacketsToDecode, reorderRate, duplicateRate);
 
               if (fecPacketReceived == false) {
                 ForwardErrorCorrection::ReceivedPacketList::iterator
-                toDecodeIt = toDecodeList.begin();
+                    toDecodeIt = toDecodeList.begin();
                 while (toDecodeIt != toDecodeList.end()) {
                   receivedPacket = *toDecodeIt;
                   if (receivedPacket->is_fec) {
                     fecPacketReceived = true;
                   }
                   ++toDecodeIt;
                 }
               }
               ASSERT_EQ(0, fec.DecodeFEC(&toDecodeList, &recoveredPacketList))
                   << "DecodeFEC() failed";
               ASSERT_TRUE(toDecodeList.empty())
                   << "Received packet list is not empty.";
             }
             mediaPacketListItem = mediaPacketList.begin();
             mediaPacketIdx = 0;
             while (mediaPacketListItem != mediaPacketList.end()) {
               if (mediaLossMask[mediaPacketIdx] == 1) {
                 // Should have recovered this packet.
                 ForwardErrorCorrection::RecoveredPacketList::iterator
-                recoveredPacketListItem = recoveredPacketList.begin();
+                    recoveredPacketListItem = recoveredPacketList.begin();
 
-                ASSERT_FALSE(
-                    recoveredPacketListItem == recoveredPacketList.end())
-                  << "Insufficient number of recovered packets.";
+                ASSERT_FALSE(recoveredPacketListItem ==
+                             recoveredPacketList.end())
+                    << "Insufficient number of recovered packets.";
                 mediaPacket = *mediaPacketListItem;
                 ForwardErrorCorrection::RecoveredPacket* recoveredPacket =
                     *recoveredPacketListItem;
 
                 ASSERT_EQ(recoveredPacket->pkt->length, mediaPacket->length)
                     << "Recovered packet length not identical to original "
                     << "media packet";
                 ASSERT_EQ(0, memcmp(recoveredPacket->pkt->data,
                                     mediaPacket->data, mediaPacket->length))
                     << "Recovered packet payload not identical to original "
@@ skipping 19 matching lines @@
 
             fecPacketListItem = fecPacketList.begin();
             while (fecPacketListItem != fecPacketList.end()) {
               ++fecPacketListItem;
               fecPacketList.pop_front();
             }
 
             // Delete received packets we didn't pass to DecodeFEC(), due to
             // early frame completion.
             ForwardErrorCorrection::ReceivedPacketList::iterator
-            receivedPacketIt = receivedPacketList.begin();
+                receivedPacketIt = receivedPacketList.begin();
             while (receivedPacketIt != receivedPacketList.end()) {
               receivedPacket = *receivedPacketIt;
               delete receivedPacket;
               ++receivedPacketIt;
               receivedPacketList.pop_front();
             }
             assert(receivedPacketList.empty());
 
             while (!fecMaskList.empty()) {
               fecMaskList.pop_front();
             }
             timeStamp += 90000 / 30;
           }  // loop over numImpPackets
-        }  // loop over FecPackets
-      }  // loop over numMediaPackets
+        }    // loop over FecPackets
+      }      // loop over numMediaPackets
       delete[] packetMask;
     }  // loop over loss rates
-  }  // loop over mask types
+  }    // 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