ACM: Move NACK functionality inside NetEq

webrtc/modules/audio_coding/neteq/nack_unittest.cc

 /*
  *  Copyright (c) 2013 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.
  */
 
-#include "webrtc/modules/audio_coding/main/acm2/nack.h"
+#include "webrtc/modules/audio_coding/neteq/nack.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/typedefs.h"
 #include "webrtc/modules/audio_coding/main/include/audio_coding_module_typedefs.h"
 
 namespace webrtc {
-
-namespace acm2 {
-
 namespace {
 
 const int kNackThreshold = 3;
 const int kSampleRateHz = 16000;
 const int kPacketSizeMs = 30;
 const uint32_t kTimestampIncrement = 480;  // 30 ms.
 const int64_t kShortRoundTripTimeMs = 1;
 
 bool IsNackListCorrect(const std::vector<uint16_t>& nack_list,
                        const uint16_t* lost_sequence_numbers,
@@ skipping 47 matching lines @@
   uint32_t timestamp = 0;
   std::vector<uint16_t> nack_list;
 
   nack->UpdateLastReceivedPacket(seq_num, timestamp);
   nack_list = nack->GetNackList(kShortRoundTripTimeMs);
   EXPECT_TRUE(nack_list.empty());
   int num_late_packets = kNackThreshold + 1;
 
   // Push in reverse order
   while (num_late_packets > 0) {
-    nack->UpdateLastReceivedPacket(seq_num + num_late_packets, timestamp +
-                            num_late_packets * kTimestampIncrement);
+    nack->UpdateLastReceivedPacket(
+        seq_num + num_late_packets,
+        timestamp + num_late_packets * kTimestampIncrement);
     nack_list = nack->GetNackList(kShortRoundTripTimeMs);
     EXPECT_TRUE(nack_list.empty());
     num_late_packets--;
   }
 }
 
 TEST(NackTest, LatePacketsMovedToNackThenNackListDoesNotChange) {
-  const uint16_t kSequenceNumberLostPackets[] = { 2, 3, 4, 5, 6, 7, 8, 9 };
+  const uint16_t kSequenceNumberLostPackets[] = {2, 3, 4, 5, 6, 7, 8, 9};
   static const int kNumAllLostPackets = sizeof(kSequenceNumberLostPackets) /
-      sizeof(kSequenceNumberLostPackets[0]);
+                                        sizeof(kSequenceNumberLostPackets[0]);
 
   for (int k = 0; k < 2; k++) {  // Two iteration with/without wrap around.
     rtc::scoped_ptr<Nack> nack(Nack::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
 
     uint16_t sequence_num_lost_packets[kNumAllLostPackets];
     for (int n = 0; n < kNumAllLostPackets; n++) {
-      sequence_num_lost_packets[n] = kSequenceNumberLostPackets[n] + k *
-          65531;  // Have wrap around in sequence numbers for |k == 1|.
+      sequence_num_lost_packets[n] =
+          kSequenceNumberLostPackets[n] +
+          k * 65531;  // Have wrap around in sequence numbers for |k == 1|.
     }
     uint16_t seq_num = sequence_num_lost_packets[0] - 1;
 
     uint32_t timestamp = 0;
     std::vector<uint16_t> nack_list;
 
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
     nack_list = nack->GetNackList(kShortRoundTripTimeMs);
     EXPECT_TRUE(nack_list.empty());
 
@@ skipping 16 matching lines @@
       nack_list = nack->GetNackList(kShortRoundTripTimeMs);
       EXPECT_TRUE(IsNackListCorrect(nack_list, sequence_num_lost_packets,
                                     kNumAllLostPackets));
       seq_num++;
       timestamp += kTimestampIncrement;
     }
   }
 }
 
 TEST(NackTest, ArrivedPacketsAreRemovedFromNackList) {
-  const uint16_t kSequenceNumberLostPackets[] = { 2, 3, 4, 5, 6, 7, 8, 9 };
+  const uint16_t kSequenceNumberLostPackets[] = {2, 3, 4, 5, 6, 7, 8, 9};
   static const int kNumAllLostPackets = sizeof(kSequenceNumberLostPackets) /
-      sizeof(kSequenceNumberLostPackets[0]);
+                                        sizeof(kSequenceNumberLostPackets[0]);
 
   for (int k = 0; k < 2; ++k) {  // Two iteration with/without wrap around.
     rtc::scoped_ptr<Nack> nack(Nack::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
 
     uint16_t sequence_num_lost_packets[kNumAllLostPackets];
     for (int n = 0; n < kNumAllLostPackets; ++n) {
-      sequence_num_lost_packets[n] = kSequenceNumberLostPackets[n] + k *
-          65531;  // Wrap around for |k == 1|.
+      sequence_num_lost_packets[n] = kSequenceNumberLostPackets[n] +
+                                     k * 65531;  // Wrap around for |k == 1|.
     }
 
     uint16_t seq_num = sequence_num_lost_packets[0] - 1;
     uint32_t timestamp = 0;
 
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
     std::vector<uint16_t> nack_list = nack->GetNackList(kShortRoundTripTimeMs);
     EXPECT_TRUE(nack_list.empty());
 
     size_t index_retransmitted_rtp = 0;
@@ skipping 29 matching lines @@
           nack_list, &sequence_num_lost_packets[index_retransmitted_rtp],
           num_lost_packets - 1));  // One less lost packet in the list.
     }
     ASSERT_TRUE(nack_list.empty());
   }
 }
 
 // Assess if estimation of timestamps and time-to-play is correct. Introduce all
 // combinations that timestamps and sequence numbers might have wrap around.
 TEST(NackTest, EstimateTimestampAndTimeToPlay) {
-  const uint16_t kLostPackets[] = { 2, 3, 4, 5, 6, 7, 8, 9, 10,
-      11, 12, 13, 14, 15 };
-  static const int kNumAllLostPackets = sizeof(kLostPackets) /
-      sizeof(kLostPackets[0]);
-
+  const uint16_t kLostPackets[] = {2, 3,  4,  5,  6,  7,  8,
+                                   9, 10, 11, 12, 13, 14, 15};
+  static const int kNumAllLostPackets =
+      sizeof(kLostPackets) / sizeof(kLostPackets[0]);
 
   for (int k = 0; k < 4; ++k) {
     rtc::scoped_ptr<Nack> nack(Nack::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
 
     // Sequence number wrap around if |k| is 2 or 3;
     int seq_num_offset = (k < 2) ? 0 : 65531;
 
     // Timestamp wrap around if |k| is 1 or 3.
-    uint32_t timestamp_offset = (k & 0x1) ?
-        static_cast<uint32_t>(0xffffffff) - 6 : 0;
+    uint32_t timestamp_offset =
+        (k & 0x1) ? static_cast<uint32_t>(0xffffffff) - 6 : 0;
 
     uint32_t timestamp_lost_packets[kNumAllLostPackets];
     uint16_t seq_num_lost_packets[kNumAllLostPackets];
     for (int n = 0; n < kNumAllLostPackets; ++n) {
-      timestamp_lost_packets[n] = timestamp_offset + kLostPackets[n] *
-          kTimestampIncrement;
+      timestamp_lost_packets[n] =
+          timestamp_offset + kLostPackets[n] * kTimestampIncrement;
       seq_num_lost_packets[n] = seq_num_offset + kLostPackets[n];
     }
 
     // We and to push two packets before lost burst starts.
     uint16_t seq_num = seq_num_lost_packets[0] - 2;
     uint32_t timestamp = timestamp_lost_packets[0] - 2 * kTimestampIncrement;
 
     const uint16_t first_seq_num = seq_num;
     const uint32_t first_timestamp = timestamp;
 
     // Two consecutive packets to have a correct estimate of timestamp increase.
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
     seq_num++;
     timestamp += kTimestampIncrement;
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
 
     // A packet after the last one which is supposed to be lost.
     seq_num = seq_num_lost_packets[kNumAllLostPackets - 1] + 1;
-    timestamp = timestamp_lost_packets[kNumAllLostPackets - 1] +
-        kTimestampIncrement;
+    timestamp =
+        timestamp_lost_packets[kNumAllLostPackets - 1] + kTimestampIncrement;
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
 
     Nack::NackList nack_list = nack->GetNackList();
     EXPECT_EQ(static_cast<size_t>(kNumAllLostPackets), nack_list.size());
 
     // Pretend the first packet is decoded.
     nack->UpdateLastDecodedPacket(first_seq_num, first_timestamp);
     nack_list = nack->GetNackList();
 
     Nack::NackList::iterator it = nack_list.begin();
@@ skipping 22 matching lines @@
 
 TEST(NackTest, MissingPacketsPriorToLastDecodedRtpShouldNotBeInNackList) {
   for (int m = 0; m < 2; ++m) {
     uint16_t seq_num_offset = (m == 0) ? 0 : 65531;  // Wrap around if |m| is 1.
     rtc::scoped_ptr<Nack> nack(Nack::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
 
     // Two consecutive packets to have a correct estimate of timestamp increase.
     uint16_t seq_num = 0;
     nack->UpdateLastReceivedPacket(seq_num_offset + seq_num,
-      seq_num * kTimestampIncrement);
+                                   seq_num * kTimestampIncrement);
     seq_num++;
     nack->UpdateLastReceivedPacket(seq_num_offset + seq_num,
-      seq_num * kTimestampIncrement);
+                                   seq_num * kTimestampIncrement);
 
     // Skip 10 packets (larger than NACK threshold).
     const int kNumLostPackets = 10;
     seq_num += kNumLostPackets + 1;
     nack->UpdateLastReceivedPacket(seq_num_offset + seq_num,
-      seq_num * kTimestampIncrement);
+                                   seq_num * kTimestampIncrement);
 
     const size_t kExpectedListSize = kNumLostPackets - kNackThreshold;
     std::vector<uint16_t> nack_list = nack->GetNackList(kShortRoundTripTimeMs);
     EXPECT_EQ(kExpectedListSize, nack_list.size());
 
     for (int k = 0; k < 2; ++k) {
       // Decoding of the first and the second arrived packets.
       for (int n = 0; n < kPacketSizeMs / 10; ++n) {
         nack->UpdateLastDecodedPacket(seq_num_offset + k,
                                       k * kTimestampIncrement);
         nack_list = nack->GetNackList(kShortRoundTripTimeMs);
         EXPECT_EQ(kExpectedListSize, nack_list.size());
       }
     }
 
     // Decoding of the last received packet.
     nack->UpdateLastDecodedPacket(seq_num + seq_num_offset,
-      seq_num * kTimestampIncrement);
+                                  seq_num * kTimestampIncrement);
     nack_list = nack->GetNackList(kShortRoundTripTimeMs);
     EXPECT_TRUE(nack_list.empty());
 
     // Make sure list of late packets is also empty. To check that, push few
     // packets, if the late list is not empty its content will pop up in NACK
     // list.
     for (int n = 0; n < kNackThreshold + 10; ++n) {
       seq_num++;
       nack->UpdateLastReceivedPacket(seq_num_offset + seq_num,
-       seq_num * kTimestampIncrement);
+                                     seq_num * kTimestampIncrement);
       nack_list = nack->GetNackList(kShortRoundTripTimeMs);
       EXPECT_TRUE(nack_list.empty());
     }
   }
 }
 
 TEST(NackTest, Reset) {
   rtc::scoped_ptr<Nack> nack(Nack::Create(kNackThreshold));
   nack->UpdateSampleRate(kSampleRateHz);
 
@@ skipping 131 matching lines @@
   //
   // sequence number:  1,  2,  3,   4,   5
   // time-to-play:    20, 50, 80, 110, 140
   //
   std::vector<uint16_t> nack_list = nack->GetNackList(100);
   ASSERT_EQ(2u, nack_list.size());
   EXPECT_EQ(4, nack_list[0]);
   EXPECT_EQ(5, nack_list[1]);
 }
 
-}  // namespace acm2
-
 }  // namespace webrtc