Moved codec-specific audio packet splitting into 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 137 matching lines @@
                   uint32_t timestamp,
                   uint8_t payload_value,
                   bool primary = true) {
   EXPECT_EQ(payload_length, packet->payload_length);
   EXPECT_EQ(payload_type, packet->header.payloadType);
   EXPECT_EQ(sequence_number, packet->header.sequenceNumber);
   EXPECT_EQ(timestamp, packet->header.timestamp);
   EXPECT_EQ(primary, packet->primary);
   ASSERT_FALSE(packet->payload == NULL);
   for (size_t i = 0; i < packet->payload_length; ++i) {
-    EXPECT_EQ(payload_value, packet->payload[i]);
+    ASSERT_EQ(payload_value, packet->payload[i]);

[kwiberg-webrtc, 2016/08/26 12:39:25]

The caller of VerifyPacket doesn't call ASSERT/EXPECT_NO_FATAL_FAILURES, so it's
probably better to just EXPECT. See
https://github.com/google/googletest/blob/master/googletest/docs/AdvancedGuid....

[ossu, 2016/08/26 13:05:30]

Well you'll get one roughly one trillion errors during a failing test, rather
than only the first one. The line just before the for-loop does ASSERT_FALSE, so
an assert could already happen.

[kwiberg-webrtc, 2016/08/26 22:05:13]

OK. But then the callers ought to use ASSERT_NO_FATAL_FAILURES.

   }
 }
 
 // Start of test definitions.
 
 TEST(PayloadSplitter, CreateAndDestroy) {
   PayloadSplitter* splitter = new PayloadSplitter;
   delete splitter;
 }
 
@@ skipping 194 matching lines @@
 // get split.
 TEST(AudioPayloadSplitter, NonSplittable) {
   // Set up packets with different RTP payload types. The actual values do not
   // matter, since we are mocking the decoder database anyway.
   PacketList packet_list;
   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));
   }
 
+  class NoOpAudioDecoder : public AudioDecoder {
+   public:
+    void Reset() override { }
+    int SampleRateHz() const override { return 8000; }
+    size_t Channels() const override { return 1; }
+
+   private:
+    int DecodeInternal(const uint8_t* encoded,
+                       size_t encoded_len,
+                       int sample_rate_hz,
+                       int16_t* decoded,
+                       SpeechType* speech_type) override
+    { return 0; }
+  };
+
+  rtc::scoped_refptr<AudioDecoderFactory> factory =
+      CreateBuiltinAudioDecoderFactory();
+  std::unique_ptr<AudioDecoder> external_decoder(new NoOpAudioDecoder);
   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, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderISAC, "",
+                                       factory));
   EXPECT_CALL(decoder_database, GetDecoderInfo(0))
       .WillRepeatedly(Return(info0.get()));
   std::unique_ptr<DecoderDatabase::DecoderInfo> info1(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderISACswb, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderISACswb, "",
+                                       factory));
   EXPECT_CALL(decoder_database, GetDecoderInfo(1))
       .WillRepeatedly(Return(info1.get()));
   std::unique_ptr<DecoderDatabase::DecoderInfo> info2(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderRED, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderRED, "", factory));
   EXPECT_CALL(decoder_database, GetDecoderInfo(2))
       .WillRepeatedly(Return(info2.get()));
   std::unique_ptr<DecoderDatabase::DecoderInfo> info3(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderAVT, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderAVT, "", factory));
   EXPECT_CALL(decoder_database, GetDecoderInfo(3))
       .WillRepeatedly(Return(info3.get()));
   std::unique_ptr<DecoderDatabase::DecoderInfo> info4(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderCNGnb, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderCNGnb, "",
+                                       factory));
   EXPECT_CALL(decoder_database, GetDecoderInfo(4))
       .WillRepeatedly(Return(info4.get()));
   std::unique_ptr<DecoderDatabase::DecoderInfo> info5(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderArbitrary, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderArbitrary, "",
+                                       external_decoder.get()));
   EXPECT_CALL(decoder_database, GetDecoderInfo(5))
-      .WillRepeatedly(Return(info5.get()));
+     .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();
   while (it != packet_list.end()) {
     VerifyPacket((*it), kPayloadLength, payload_type, kSequenceNumber,
@@ skipping 109 matching lines @@
   PacketList packet_list;
   static const uint8_t kPayloadType = 17;  // Just a random number.
   for (int payload_size_ms = 10; payload_size_ms <= 60; payload_size_ms += 10) {
     // The payload values are set to be the same as the payload_size, so that
     // one can distinguish from which packet the split payloads come from.
     size_t payload_size_bytes = payload_size_ms * bytes_per_ms_;
     packet_list.push_back(CreatePacket(kPayloadType, payload_size_bytes,
                                        payload_size_ms));
   }
 
+  rtc::scoped_refptr<AudioDecoderFactory> factory =
+      CreateBuiltinAudioDecoderFactory();
   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_, ""));
+      new DecoderDatabase::DecoderInfo(decoder_type_, "", factory));
   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 61 matching lines @@
   static const uint8_t kPayloadType = 17;  // Just a random number.
   const int frame_length_samples = frame_length_ms_ * 8;
   size_t payload_length_bytes = frame_length_bytes_ * num_frames_;
   Packet* packet = CreatePacket(kPayloadType, payload_length_bytes, 0);
   // Fill payload with increasing integers {0, 1, 2, ...}.
   for (size_t i = 0; i < packet->payload_length; ++i) {
     packet->payload[i] = static_cast<uint8_t>(i);
   }
   packet_list.push_back(packet);
 
+  rtc::scoped_refptr<AudioDecoderFactory> factory =
+      CreateBuiltinAudioDecoderFactory();
   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, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, "",
+                                       factory));
   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 40 matching lines @@
                       std::pair<int, int>(18, 30)));
 
 // 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);
 
+  rtc::scoped_refptr<AudioDecoderFactory> factory =
+      CreateBuiltinAudioDecoderFactory();
   MockDecoderDatabase decoder_database;
   std::unique_ptr<DecoderDatabase::DecoderInfo> info(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, "",
+                                       factory));
   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
       .WillRepeatedly(Return(info.get()));
 
   PayloadSplitter splitter;
-  EXPECT_EQ(PayloadSplitter::kTooLargePayload,
+  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());
 }
 
 // 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);
 
+  rtc::scoped_refptr<AudioDecoderFactory> factory =
+      CreateBuiltinAudioDecoderFactory();
   MockDecoderDatabase decoder_database;
   std::unique_ptr<DecoderDatabase::DecoderInfo> info(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, "",
+                                       factory));
   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