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

webrtc/modules/audio_coding/neteq/neteq_impl_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 221 matching lines @@
 // TODO(hlundin): Move to separate file?
 TEST(NetEq, CreateAndDestroy) {
   NetEq::Config config;
   NetEq* neteq = NetEq::Create(config);
   delete neteq;
 }
 
 TEST_F(NetEqImplTest, RegisterPayloadType) {
   CreateInstance();
   uint8_t rtp_payload_type = 0;
-  NetEqDecoder codec_type = kDecoderPCMu;
+  NetEqDecoder codec_type = NetEqDecoder::kDecoderPCMu;
   EXPECT_CALL(*mock_decoder_database_,
               RegisterPayload(rtp_payload_type, codec_type));
   neteq_->RegisterPayloadType(codec_type, rtp_payload_type);
 }
 
 TEST_F(NetEqImplTest, RemovePayloadType) {
   CreateInstance();
   uint8_t rtp_payload_type = 0;
   EXPECT_CALL(*mock_decoder_database_, Remove(rtp_payload_type))
       .WillOnce(Return(DecoderDatabase::kDecoderNotFound));
@@ skipping 40 matching lines @@
       .Times(2)
       .WillRepeatedly(Return(DecoderDatabase::kOK));  // Payload type is valid.
   EXPECT_CALL(*mock_decoder_database_, IsDtmf(kPayloadType))
       .WillRepeatedly(Return(false));  // This is not DTMF.
   EXPECT_CALL(*mock_decoder_database_, GetDecoder(kPayloadType))
       .Times(3)
       .WillRepeatedly(Return(&mock_decoder));
   EXPECT_CALL(*mock_decoder_database_, IsComfortNoise(kPayloadType))
       .WillRepeatedly(Return(false));  // This is not CNG.
   DecoderDatabase::DecoderInfo info;
-  info.codec_type = kDecoderPCMu;
+  info.codec_type = NetEqDecoder::kDecoderPCMu;
   EXPECT_CALL(*mock_decoder_database_, GetDecoderInfo(kPayloadType))
       .WillRepeatedly(Return(&info));
 
   // Expectations for packet buffer.
   EXPECT_CALL(*mock_packet_buffer_, NumPacketsInBuffer())
       .WillOnce(Return(0))   // First packet.
       .WillOnce(Return(1))   // Second packet.
       .WillOnce(Return(2));  // Second packet, checking after it was inserted.
   EXPECT_CALL(*mock_packet_buffer_, Empty())
       .WillOnce(Return(false));  // Called once after first packet is inserted.
@@ skipping 13 matching lines @@
 
   // Expectations for DTMF buffer.
   EXPECT_CALL(*mock_dtmf_buffer_, Flush())
       .Times(1);
 
   // Expectations for delay manager.
   {
     // All expectations within this block must be called in this specific order.
     InSequence sequence;  // Dummy variable.
     // Expectations when the first packet is inserted.
-    EXPECT_CALL(*mock_delay_manager_, LastDecoderType(kDecoderPCMu))
+    EXPECT_CALL(*mock_delay_manager_,
+                LastDecoderType(NetEqDecoder::kDecoderPCMu))
         .Times(1);
     EXPECT_CALL(*mock_delay_manager_, last_pack_cng_or_dtmf())
         .Times(2)
         .WillRepeatedly(Return(-1));
     EXPECT_CALL(*mock_delay_manager_, set_last_pack_cng_or_dtmf(0))
         .Times(1);
     EXPECT_CALL(*mock_delay_manager_, ResetPacketIatCount()).Times(1);
     // Expectations when the second packet is inserted. Slightly different.
-    EXPECT_CALL(*mock_delay_manager_, LastDecoderType(kDecoderPCMu))
+    EXPECT_CALL(*mock_delay_manager_,
+                LastDecoderType(NetEqDecoder::kDecoderPCMu))
         .Times(1);
     EXPECT_CALL(*mock_delay_manager_, last_pack_cng_or_dtmf())
         .WillOnce(Return(0));
     EXPECT_CALL(*mock_delay_manager_, SetPacketAudioLength(30))
         .WillOnce(Return(0));
   }
 
   // Expectations for payload splitter.
   EXPECT_CALL(*mock_payload_splitter_, SplitAudio(_, _))
       .Times(2)
@@ skipping 17 matching lines @@
   const size_t kPayloadLengthBytes = 2 * kPayloadLengthSamples;  // PCM 16-bit.
   const uint8_t kPayloadType = 17;  // Just an arbitrary number.
   const uint32_t kReceiveTime = 17;  // Value doesn't matter for this test.
   uint8_t payload[kPayloadLengthBytes] = {0};
   WebRtcRTPHeader rtp_header;
   rtp_header.header.payloadType = kPayloadType;
   rtp_header.header.sequenceNumber = 0x1234;
   rtp_header.header.timestamp = 0x12345678;
   rtp_header.header.ssrc = 0x87654321;
 
-  EXPECT_EQ(NetEq::kOK,
-            neteq_->RegisterPayloadType(kDecoderPCM16B, kPayloadType));
+  EXPECT_EQ(NetEq::kOK, neteq_->RegisterPayloadType(
+                            NetEqDecoder::kDecoderPCM16B, kPayloadType));
 
   // Insert packets. The buffer should not flush.
   for (size_t i = 1; i <= config_.max_packets_in_buffer; ++i) {
     EXPECT_EQ(NetEq::kOK,
               neteq_->InsertPacket(
                   rtp_header, payload, kPayloadLengthBytes, kReceiveTime));
     rtp_header.header.timestamp += kPayloadLengthSamples;
     rtp_header.header.sequenceNumber += 1;
     EXPECT_EQ(i, packet_buffer_->NumPacketsInBuffer());
   }
@@ skipping 52 matching lines @@
     void Reset() override { next_value_ = 1; }
 
     size_t Channels() const override { return 1; }
 
     uint16_t next_value() const { return next_value_; }
 
    private:
     int16_t next_value_;
   } decoder_;
 
-  EXPECT_EQ(NetEq::kOK,
-            neteq_->RegisterExternalDecoder(&decoder_, kDecoderPCM16B,
-                                            kPayloadType, kSampleRateHz));
+  EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
+                            &decoder_, NetEqDecoder::kDecoderPCM16B,
+                            kPayloadType, kSampleRateHz));
 
   // Insert one packet.
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(
                 rtp_header, payload, kPayloadLengthBytes, kReceiveTime));
 
   // Pull audio once.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   int16_t output[kMaxOutputSize];
   size_t samples_per_channel;
@@ skipping 57 matching lines @@
       .WillRepeatedly(Return(0));
   int16_t dummy_output[kPayloadLengthSamples] = {0};
   // The below expectation will make the mock decoder write
   // |kPayloadLengthSamples| zeros to the output array, and mark it as speech.
   EXPECT_CALL(mock_decoder,
               Decode(Pointee(0), kPayloadLengthBytes, kSampleRateHz, _, _, _))
       .WillOnce(DoAll(SetArrayArgument<4>(dummy_output,
                                           dummy_output + kPayloadLengthSamples),
                       SetArgPointee<5>(AudioDecoder::kSpeech),
                       Return(kPayloadLengthSamples)));
-  EXPECT_EQ(NetEq::kOK,
-            neteq_->RegisterExternalDecoder(&mock_decoder, kDecoderPCM16B,
-                                            kPayloadType, kSampleRateHz));
+  EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
+                            &mock_decoder, NetEqDecoder::kDecoderPCM16B,
+                            kPayloadType, kSampleRateHz));
 
   // Insert one packet.
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(
                 rtp_header, payload, kPayloadLengthBytes, kReceiveTime));
 
   // Pull audio once.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   int16_t output[kMaxOutputSize];
   size_t samples_per_channel;
@@ skipping 81 matching lines @@
   NetEqOutputType type;
   EXPECT_EQ(NetEq::kOK,
             neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
                              &num_channels, &type));
   ASSERT_LE(samples_per_channel, kMaxOutputSize);
   EXPECT_EQ(kMaxOutputSize, samples_per_channel);
   EXPECT_EQ(1, num_channels);
   EXPECT_EQ(kOutputPLC, type);
 
   // Register the payload type.
-  EXPECT_EQ(NetEq::kOK,
-            neteq_->RegisterPayloadType(kDecoderPCM16B, kPayloadType));
+  EXPECT_EQ(NetEq::kOK, neteq_->RegisterPayloadType(
+                            NetEqDecoder::kDecoderPCM16B, kPayloadType));
 
   // Insert 10 packets.
   for (size_t i = 0; i < 10; ++i) {
     rtp_header.header.sequenceNumber++;
     rtp_header.header.timestamp += kPayloadLengthSamples;
     EXPECT_EQ(NetEq::kOK,
               neteq_->InsertPacket(rtp_header, payload, kPayloadLengthBytes,
                                    kReceiveTime));
     EXPECT_EQ(i + 1, packet_buffer_->NumPacketsInBuffer());
   }
@@ skipping 62 matching lines @@
                       Return(kPayloadLengthSamples)));
 
   EXPECT_CALL(mock_decoder, Decode(Pointee(2), kPayloadLengthBytes,
                                    kSampleRateKhz * 1000, _, _, _))
       .WillOnce(DoAll(SetArrayArgument<4>(dummy_output,
                                           dummy_output + kPayloadLengthSamples),
                       SetArgPointee<5>(AudioDecoder::kSpeech),
                       Return(kPayloadLengthSamples)));
 
   EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
-                            &mock_decoder, kDecoderOpus, kPayloadType,
-                            kSampleRateKhz * 1000));
+                            &mock_decoder, NetEqDecoder::kDecoderOpus,
+                            kPayloadType, kSampleRateKhz * 1000));
 
   // Insert one packet (decoder will return speech).
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(
                 rtp_header, payload, kPayloadLengthBytes, kReceiveTime));
 
   // Insert second packet (decoder will return CNG).
   payload[0] = 1;
   rtp_header.header.sequenceNumber++;
   rtp_header.header.timestamp += kPayloadLengthSamples;
@@ skipping 117 matching lines @@
                                           kPayloadLengthSamples * kChannels),
                       SetArgPointee<4>(AudioDecoder::kSpeech),
                       Return(static_cast<int>(
                           kPayloadLengthSamples * kChannels))));
 
   EXPECT_CALL(decoder_, PacketDuration(Pointee(kSecondPayloadValue),
                                        kPayloadLengthBytes))
     .Times(AtLeast(1))
     .WillRepeatedly(Return(kNetEqMaxFrameSize));
 
-  EXPECT_EQ(NetEq::kOK,
-            neteq_->RegisterExternalDecoder(&decoder_, kDecoderPCM16B,
-                                            kPayloadType, kSampleRateHz));
+  EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
+                            &decoder_, NetEqDecoder::kDecoderPCM16B,
+                            kPayloadType, kSampleRateHz));
 
   // Insert one packet.
   payload[0] = kFirstPayloadValue;  // This will make Decode() fail.
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(
                 rtp_header, payload, kPayloadLengthBytes, kReceiveTime));
 
   // Insert another packet.
   payload[0] = kSecondPayloadValue;  // This will make Decode() successful.
   rtp_header.header.sequenceNumber++;
@@ skipping 38 matching lines @@
   const size_t kPayloadLengthBytes = 2 * kPayloadLengthSamples;  // PCM 16-bit.
   const uint8_t kPayloadType = 17;   // Just an arbitrary number.
   const uint32_t kReceiveTime = 17;  // Value doesn't matter for this test.
   uint8_t payload[kPayloadLengthBytes] = {0};
   WebRtcRTPHeader rtp_header;
   rtp_header.header.payloadType = kPayloadType;
   rtp_header.header.sequenceNumber = 0x1234;
   rtp_header.header.timestamp = 0x12345678;
   rtp_header.header.ssrc = 0x87654321;
 
-  EXPECT_EQ(NetEq::kOK,
-            neteq_->RegisterPayloadType(kDecoderPCM16B, kPayloadType));
+  EXPECT_EQ(NetEq::kOK, neteq_->RegisterPayloadType(
+                            NetEqDecoder::kDecoderPCM16B, kPayloadType));
 
   // Insert packets until the buffer flushes.
   for (size_t i = 0; i <= config_.max_packets_in_buffer; ++i) {
     EXPECT_EQ(i, packet_buffer_->NumPacketsInBuffer());
     EXPECT_EQ(NetEq::kOK,
               neteq_->InsertPacket(rtp_header, payload, kPayloadLengthBytes,
                                    kReceiveTime));
     rtp_header.header.timestamp +=
         rtc::checked_cast<uint32_t>(kPayloadLengthSamples);
     ++rtp_header.header.sequenceNumber;
@@ skipping 34 matching lines @@
   // The below expectation will make the mock decoder write
   // |kPayloadLengthSamples| - 5 zeros to the output array, and mark it as
   // speech. That is, the decoded length is 5 samples shorter than the expected.
   EXPECT_CALL(mock_decoder,
               Decode(_, kPayloadLengthBytes, kSampleRateHz, _, _, _))
       .WillOnce(
           DoAll(SetArrayArgument<4>(dummy_output,
                                     dummy_output + kPayloadLengthSamples - 5),
                 SetArgPointee<5>(AudioDecoder::kSpeech),
                 Return(kPayloadLengthSamples - 5)));
-  EXPECT_EQ(NetEq::kOK,
-            neteq_->RegisterExternalDecoder(&mock_decoder, kDecoderPCM16B,
-                                            kPayloadType, kSampleRateHz));
+  EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
+                            &mock_decoder, NetEqDecoder::kDecoderPCM16B,
+                            kPayloadType, kSampleRateHz));
 
   // Insert one packet.
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(rtp_header, payload, kPayloadLengthBytes,
                                  kReceiveTime));
 
   EXPECT_EQ(5u, neteq_->sync_buffer_for_test()->FutureLength());
 
   // Pull audio once.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
@@ skipping 73 matching lines @@
     EXPECT_CALL(mock_decoder,
                 Decode(_, kPayloadLengthBytes, kSampleRateHz, _, _, _))
         .Times(2)
         .WillRepeatedly(
             DoAll(SetArrayArgument<4>(dummy_output,
                                   dummy_output + kFrameLengthSamples),
                   SetArgPointee<5>(AudioDecoder::kSpeech),
                   Return(kFrameLengthSamples)));
   }
 
-  EXPECT_EQ(NetEq::kOK,
-            neteq_->RegisterExternalDecoder(&mock_decoder, kDecoderPCM16B,
-                                            kPayloadType, kSampleRateHz));
+  EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
+                            &mock_decoder, NetEqDecoder::kDecoderPCM16B,
+                            kPayloadType, kSampleRateHz));
 
   // Insert packets.
   for (int i = 0; i < 6; ++i) {
     rtp_header.header.sequenceNumber += 1;
     rtp_header.header.timestamp += kFrameLengthSamples;
     EXPECT_EQ(NetEq::kOK,
               neteq_->InsertPacket(rtp_header, payload, kPayloadLengthBytes,
                                    kReceiveTime));
   }
 
@@ skipping 99 matching lines @@
     // Mock decoder finally returns to normal.
     EXPECT_CALL(mock_decoder, Decode(nullptr, 0, kSampleRateHz, _, _, _))
         .Times(2)
         .WillRepeatedly(
             DoAll(SetArrayArgument<4>(dummy_output,
                                   dummy_output + kFrameLengthSamples),
                   SetArgPointee<5>(AudioDecoder::kComfortNoise),
                   Return(kFrameLengthSamples)));
   }
 
-  EXPECT_EQ(NetEq::kOK,
-            neteq_->RegisterExternalDecoder(&mock_decoder, kDecoderPCM16B,
-                                            kPayloadType, kSampleRateHz));
+  EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
+                            &mock_decoder, NetEqDecoder::kDecoderPCM16B,
+                            kPayloadType, kSampleRateHz));
 
   // Insert 2 packets. This will make netEq into codec internal CNG mode.
   for (int i = 0; i < 2; ++i) {
     rtp_header.header.sequenceNumber += 1;
     rtp_header.header.timestamp += kFrameLengthSamples;
     EXPECT_EQ(NetEq::kOK,
               neteq_->InsertPacket(rtp_header, payload, kPayloadLengthBytes,
                                    kReceiveTime));
   }
 
@@ skipping 27 matching lines @@
             neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
                              &num_channels, &type));
   EXPECT_EQ(kMaxOutputSize, samples_per_channel);
   EXPECT_EQ(1, num_channels);
   EXPECT_EQ(kOutputCNG, type);
 
   EXPECT_CALL(mock_decoder, Die());
 }
 
 }// namespace webrtc