NetEq decoder database: Don't keep track of sample rate for builtin decoders

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 357 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.
   std::unique_ptr<DecoderDatabase::DecoderInfo> info0(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderISAC, "", 16000,
-                                       nullptr));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderISAC, ""));
   EXPECT_CALL(decoder_database, GetDecoderInfo(0))
       .WillRepeatedly(Return(info0.get()));
   std::unique_ptr<DecoderDatabase::DecoderInfo> info1(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderISACswb, "", 32000,
-                                       nullptr));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderISACswb, ""));
   EXPECT_CALL(decoder_database, GetDecoderInfo(1))
       .WillRepeatedly(Return(info1.get()));
   std::unique_ptr<DecoderDatabase::DecoderInfo> info2(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderRED, "", 8000,
-                                       nullptr));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderRED, ""));
   EXPECT_CALL(decoder_database, GetDecoderInfo(2))
       .WillRepeatedly(Return(info2.get()));
   std::unique_ptr<DecoderDatabase::DecoderInfo> info3(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderAVT, "", 8000,
-                                       nullptr));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderAVT, ""));
   EXPECT_CALL(decoder_database, GetDecoderInfo(3))
       .WillRepeatedly(Return(info3.get()));
   std::unique_ptr<DecoderDatabase::DecoderInfo> info4(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderCNGnb, "", 8000,
-                                       nullptr));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderCNGnb, ""));
   EXPECT_CALL(decoder_database, GetDecoderInfo(4))
       .WillRepeatedly(Return(info4.get()));
   std::unique_ptr<DecoderDatabase::DecoderInfo> info5(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderArbitrary, "",
-                                       8000, nullptr));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderArbitrary, ""));
   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 117 matching lines @@
     packet_list.push_back(CreatePacket(kPayloadType, payload_size_bytes,
                                        payload_size_ms));
   }
 
   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.
   // (Sample rate is set to 8000 Hz, but does not matter.)
   std::unique_ptr<DecoderDatabase::DecoderInfo> info(
-      new DecoderDatabase::DecoderInfo(decoder_type_, "", 8000, nullptr));
+      new DecoderDatabase::DecoderInfo(decoder_type_, ""));
   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
       .WillRepeatedly(Return(info.get()));
 
   PayloadSplitter splitter;
   EXPECT_EQ(0, splitter.SplitAudio(&packet_list, decoder_database));
   // The payloads are expected to be split as follows:
   // 10 ms -> 10 ms
   // 20 ms -> 20 ms
   // 30 ms -> 30 ms
   // 40 ms -> 20 + 20 ms
@@ skipping 66 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.
   std::unique_ptr<DecoderDatabase::DecoderInfo> info(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, "", 8000,
-                                       nullptr));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, ""));
   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;
   std::unique_ptr<DecoderDatabase::DecoderInfo> info(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, "", 8000,
-                                       nullptr));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, ""));
   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;
   std::unique_ptr<DecoderDatabase::DecoderInfo> info(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, "", 8000,
-                                       nullptr));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, ""));
   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();
@@ skipping 119 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