Make an enum class out of NetEqDecoder, and hide the neteq_decoders_ table

webrtc/modules/audio_coding/neteq/payload_splitter_unittest.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 292 matching lines @@
   for (uint8_t i = 0; i <= 3; ++i) {
     // Create packet with payload type |i|, payload length 10 bytes, all 0.
     Packet* packet = CreatePacket(i, 10, 0);
     packet_list.push_back(packet);
   }
 
   // Use a real DecoderDatabase object here instead of a mock, since it is
   // easier to just register the payload types and let the actual implementation
   // do its job.
   DecoderDatabase decoder_database;
-  decoder_database.RegisterPayload(0, kDecoderCNGnb);
-  decoder_database.RegisterPayload(1, kDecoderPCMu);
-  decoder_database.RegisterPayload(2, kDecoderAVT);
-  decoder_database.RegisterPayload(3, kDecoderILBC);
+  decoder_database.RegisterPayload(0, NetEqDecoder::kDecoderCNGnb);
+  decoder_database.RegisterPayload(1, NetEqDecoder::kDecoderPCMu);
+  decoder_database.RegisterPayload(2, NetEqDecoder::kDecoderAVT);
+  decoder_database.RegisterPayload(3, NetEqDecoder::kDecoderILBC);
 
   PayloadSplitter splitter;
   splitter.CheckRedPayloads(&packet_list, decoder_database);
 
   ASSERT_EQ(3u, packet_list.size());  // Should have dropped the last packet.
   // Verify packets. The loop verifies that payload types 0, 1, and 2 are in the
   // list.
   for (int i = 0; i <= 2; ++i) {
     Packet* packet = packet_list.front();
     VerifyPacket(packet, 10, i, kSequenceNumber, kBaseTimestamp, 0, true);
@@ skipping 38 matching lines @@
   for (uint8_t i = 0; i < 6; ++i) {
     // Let the payload type be |i|, and the payload value 10 * |i|.
     packet_list.push_back(CreatePacket(i, kPayloadLength, 10 * i));
   }
 
   MockDecoderDatabase decoder_database;
   // Tell the mock decoder database to return DecoderInfo structs with different
   // codec types.
   // Use scoped pointers to avoid having to delete them later.
   rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info0(
-      new DecoderDatabase::DecoderInfo(kDecoderISAC, 16000, NULL, false));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderISAC, 16000, NULL,
+                                       false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(0))
       .WillRepeatedly(Return(info0.get()));
   rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info1(
-      new DecoderDatabase::DecoderInfo(kDecoderISACswb, 32000, NULL, false));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderISACswb, 32000,
+                                       NULL, false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(1))
       .WillRepeatedly(Return(info1.get()));
   rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info2(
-      new DecoderDatabase::DecoderInfo(kDecoderRED, 8000, NULL, false));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderRED, 8000, NULL,
+                                       false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(2))
       .WillRepeatedly(Return(info2.get()));
   rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info3(
-      new DecoderDatabase::DecoderInfo(kDecoderAVT, 8000, NULL, false));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderAVT, 8000, NULL,
+                                       false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(3))
       .WillRepeatedly(Return(info3.get()));
   rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info4(
-      new DecoderDatabase::DecoderInfo(kDecoderCNGnb, 8000, NULL, false));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderCNGnb, 8000, NULL,
+                                       false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(4))
       .WillRepeatedly(Return(info4.get()));
   rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info5(
-      new DecoderDatabase::DecoderInfo(kDecoderArbitrary, 8000, NULL, false));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderArbitrary, 8000,
+                                       NULL, false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(5))
       .WillRepeatedly(Return(info5.get()));
 
   PayloadSplitter splitter;
   EXPECT_EQ(0, splitter.SplitAudio(&packet_list, decoder_database));
   EXPECT_EQ(6u, packet_list.size());
 
   // Check that all payloads are intact.
   uint8_t payload_type = 0;
   PacketList::iterator it = packet_list.begin();
@@ skipping 39 matching lines @@
 
   // The destructor is called when decoder_database goes out of scope.
   EXPECT_CALL(decoder_database, Die());
 }
 
 class SplitBySamplesTest : public ::testing::TestWithParam<NetEqDecoder> {
  protected:
   virtual void SetUp() {
     decoder_type_ = GetParam();
     switch (decoder_type_) {
-      case kDecoderPCMu:
-      case kDecoderPCMa:
+      case NetEqDecoder::kDecoderPCMu:
+      case NetEqDecoder::kDecoderPCMa:
         bytes_per_ms_ = 8;
         samples_per_ms_ = 8;
         break;
-      case kDecoderPCMu_2ch:
-      case kDecoderPCMa_2ch:
+      case NetEqDecoder::kDecoderPCMu_2ch:
+      case NetEqDecoder::kDecoderPCMa_2ch:
         bytes_per_ms_ = 2 * 8;
         samples_per_ms_ = 8;
         break;
-      case kDecoderG722:
+      case NetEqDecoder::kDecoderG722:
         bytes_per_ms_ = 8;
         samples_per_ms_ = 16;
         break;
-      case kDecoderPCM16B:
+      case NetEqDecoder::kDecoderPCM16B:
         bytes_per_ms_ = 16;
         samples_per_ms_ = 8;
         break;
-      case kDecoderPCM16Bwb:
+      case NetEqDecoder::kDecoderPCM16Bwb:
         bytes_per_ms_ = 32;
         samples_per_ms_ = 16;
         break;
-      case kDecoderPCM16Bswb32kHz:
+      case NetEqDecoder::kDecoderPCM16Bswb32kHz:
         bytes_per_ms_ = 64;
         samples_per_ms_ = 32;
         break;
-      case kDecoderPCM16Bswb48kHz:
+      case NetEqDecoder::kDecoderPCM16Bswb48kHz:
         bytes_per_ms_ = 96;
         samples_per_ms_ = 48;
         break;
-      case kDecoderPCM16B_2ch:
+      case NetEqDecoder::kDecoderPCM16B_2ch:
         bytes_per_ms_ = 2 * 16;
         samples_per_ms_ = 8;
         break;
-      case kDecoderPCM16Bwb_2ch:
+      case NetEqDecoder::kDecoderPCM16Bwb_2ch:
         bytes_per_ms_ = 2 * 32;
         samples_per_ms_ = 16;
         break;
-      case kDecoderPCM16Bswb32kHz_2ch:
+      case NetEqDecoder::kDecoderPCM16Bswb32kHz_2ch:
         bytes_per_ms_ = 2 * 64;
         samples_per_ms_ = 32;
         break;
-      case kDecoderPCM16Bswb48kHz_2ch:
+      case NetEqDecoder::kDecoderPCM16Bswb48kHz_2ch:
         bytes_per_ms_ = 2 * 96;
         samples_per_ms_ = 48;
         break;
-      case kDecoderPCM16B_5ch:
+      case NetEqDecoder::kDecoderPCM16B_5ch:
         bytes_per_ms_ = 5 * 16;
         samples_per_ms_ = 8;
         break;
       default:
         assert(false);
         break;
     }
   }
   size_t bytes_per_ms_;
   int samples_per_ms_;
@@ skipping 50 matching lines @@
     delete (*it);
     it = packet_list.erase(it);
     ++i;
   }
 
   // The destructor is called when decoder_database goes out of scope.
   EXPECT_CALL(decoder_database, Die());
 }
 
 INSTANTIATE_TEST_CASE_P(
-    PayloadSplitter, SplitBySamplesTest,
-    ::testing::Values(kDecoderPCMu, kDecoderPCMa, kDecoderPCMu_2ch,
-                      kDecoderPCMa_2ch, kDecoderG722, kDecoderPCM16B,
-                      kDecoderPCM16Bwb, kDecoderPCM16Bswb32kHz,
-                      kDecoderPCM16Bswb48kHz, kDecoderPCM16B_2ch,
-                      kDecoderPCM16Bwb_2ch, kDecoderPCM16Bswb32kHz_2ch,
-                      kDecoderPCM16Bswb48kHz_2ch, kDecoderPCM16B_5ch));
-
+    PayloadSplitter,
+    SplitBySamplesTest,
+    ::testing::Values(NetEqDecoder::kDecoderPCMu,
+                      NetEqDecoder::kDecoderPCMa,
+                      NetEqDecoder::kDecoderPCMu_2ch,
+                      NetEqDecoder::kDecoderPCMa_2ch,
+                      NetEqDecoder::kDecoderG722,
+                      NetEqDecoder::kDecoderPCM16B,
+                      NetEqDecoder::kDecoderPCM16Bwb,
+                      NetEqDecoder::kDecoderPCM16Bswb32kHz,
+                      NetEqDecoder::kDecoderPCM16Bswb48kHz,
+                      NetEqDecoder::kDecoderPCM16B_2ch,
+                      NetEqDecoder::kDecoderPCM16Bwb_2ch,
+                      NetEqDecoder::kDecoderPCM16Bswb32kHz_2ch,
+                      NetEqDecoder::kDecoderPCM16Bswb48kHz_2ch,
+                      NetEqDecoder::kDecoderPCM16B_5ch));
 
 class SplitIlbcTest : public ::testing::TestWithParam<std::pair<int, int> > {
  protected:
   virtual void SetUp() {
     const std::pair<int, int> parameters = GetParam();
     num_frames_ = parameters.first;
     frame_length_ms_ = parameters.second;
     frame_length_bytes_ = (frame_length_ms_ == 20) ? 38 : 50;
   }
   size_t num_frames_;
@@ skipping 12 matching lines @@
   for (size_t i = 0; i < packet->payload_length; ++i) {
     packet->payload[i] = static_cast<uint8_t>(i);
   }
   packet_list.push_back(packet);
 
   MockDecoderDatabase decoder_database;
   // Tell the mock decoder database to return DecoderInfo structs with different
   // codec types.
   // Use scoped pointers to avoid having to delete them later.
   rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info(
-      new DecoderDatabase::DecoderInfo(kDecoderILBC, 8000, NULL, false));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, 8000, NULL,
+                                       false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
       .WillRepeatedly(Return(info.get()));
 
   PayloadSplitter splitter;
   EXPECT_EQ(0, splitter.SplitAudio(&packet_list, decoder_database));
   EXPECT_EQ(num_frames_, packet_list.size());
 
   PacketList::iterator it = packet_list.begin();
   int frame_num = 0;
   uint8_t payload_value = 0;
@@ skipping 42 matching lines @@
 // Test too large payload size.
 TEST(IlbcPayloadSplitter, TooLargePayload) {
   PacketList packet_list;
   static const uint8_t kPayloadType = 17;  // Just a random number.
   size_t kPayloadLengthBytes = 950;
   Packet* packet = CreatePacket(kPayloadType, kPayloadLengthBytes, 0);
   packet_list.push_back(packet);
 
   MockDecoderDatabase decoder_database;
   rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info(
-      new DecoderDatabase::DecoderInfo(kDecoderILBC, 8000, NULL, false));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, 8000, NULL,
+                                       false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
       .WillRepeatedly(Return(info.get()));
 
   PayloadSplitter splitter;
   EXPECT_EQ(PayloadSplitter::kTooLargePayload,
             splitter.SplitAudio(&packet_list, decoder_database));
   EXPECT_EQ(1u, packet_list.size());
 
   // Delete the packets and payloads to avoid having the test leak memory.
   PacketList::iterator it = packet_list.begin();
@@ skipping 10 matching lines @@
 // Payload not an integer number of frames.
 TEST(IlbcPayloadSplitter, UnevenPayload) {
   PacketList packet_list;
   static const uint8_t kPayloadType = 17;  // Just a random number.
   size_t kPayloadLengthBytes = 39;  // Not an even number of frames.
   Packet* packet = CreatePacket(kPayloadType, kPayloadLengthBytes, 0);
   packet_list.push_back(packet);
 
   MockDecoderDatabase decoder_database;
   rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info(
-      new DecoderDatabase::DecoderInfo(kDecoderILBC, 8000, NULL, false));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, 8000, NULL,
+                                       false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
       .WillRepeatedly(Return(info.get()));
 
   PayloadSplitter splitter;
   EXPECT_EQ(PayloadSplitter::kFrameSplitError,
             splitter.SplitAudio(&packet_list, decoder_database));
   EXPECT_EQ(1u, packet_list.size());
 
   // Delete the packets and payloads to avoid having the test leak memory.
   PacketList::iterator it = packet_list.begin();
   while (it != packet_list.end()) {
     delete [] (*it)->payload;
     delete (*it);
     it = packet_list.erase(it);
   }
 
   // The destructor is called when decoder_database goes out of scope.
   EXPECT_CALL(decoder_database, Die());
 }
 
 TEST(FecPayloadSplitter, MixedPayload) {
   PacketList packet_list;
   DecoderDatabase decoder_database;
 
-  decoder_database.RegisterPayload(0, kDecoderOpus);
-  decoder_database.RegisterPayload(1, kDecoderPCMu);
+  decoder_database.RegisterPayload(0, NetEqDecoder::kDecoderOpus);
+  decoder_database.RegisterPayload(1, NetEqDecoder::kDecoderPCMu);
 
   Packet* packet = CreatePacket(0, 10, 0xFF, true);
   packet_list.push_back(packet);
 
   packet = CreatePacket(0, 10, 0); // Non-FEC Opus payload.
   packet_list.push_back(packet);
 
   packet = CreatePacket(1, 10, 0); // Non-Opus payload.
   packet_list.push_back(packet);
 
@@ skipping 35 matching lines @@
   delete [] packet->payload;
   delete packet;
 }
 
 TEST(FecPayloadSplitter, EmbedFecInRed) {
   PacketList packet_list;
   DecoderDatabase decoder_database;
 
   const int kTimestampOffset = 20 * 48;  // 20 ms * 48 kHz.
   uint8_t payload_types[] = {0, 0};
-  decoder_database.RegisterPayload(0, kDecoderOpus);
+  decoder_database.RegisterPayload(0, NetEqDecoder::kDecoderOpus);
   Packet* packet = CreateRedPayload(2, payload_types, kTimestampOffset, true);
   packet_list.push_back(packet);
 
   PayloadSplitter splitter;
   EXPECT_EQ(PayloadSplitter::kOK,
             splitter.SplitRed(&packet_list));
   EXPECT_EQ(PayloadSplitter::kOK,
             splitter.SplitFec(&packet_list, &decoder_database));
 
   EXPECT_EQ(4u, packet_list.size());
@@ skipping 37 matching lines @@
   EXPECT_EQ(kBaseTimestamp - kTimestampOffset, packet->header.timestamp);
   EXPECT_EQ(kPayloadLength, packet->payload_length);
   EXPECT_TRUE(packet->primary);
   EXPECT_EQ(packet->payload[3], 0);
   delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
 }
 
 }  // namespace webrtc