Add encode/decode time tracing to audio_coding.

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 413 matching lines @@
   rtp_header.header.ssrc = 0x87654321;
 
   // This is a dummy decoder that produces as many output samples as the input
   // has bytes. The output is an increasing series, starting at 1 for the first
   // sample, and then increasing by 1 for each sample.
   class CountingSamplesDecoder : public AudioDecoder {
    public:
     CountingSamplesDecoder() : next_value_(1) {}
 
     // Produce as many samples as input bytes (|encoded_len|).
-    int Decode(const uint8_t* encoded,
-               size_t encoded_len,
-               int /* sample_rate_hz */,
-               size_t /* max_decoded_bytes */,
-               int16_t* decoded,
-               SpeechType* speech_type) override {
+    int DecodeInternal(const uint8_t* encoded,
+                       size_t encoded_len,
+                       int /* sample_rate_hz */,
+                       int16_t* decoded,
+                       SpeechType* speech_type) override {
       for (size_t i = 0; i < encoded_len; ++i) {
         decoded[i] = next_value_++;
       }
       *speech_type = kSpeech;
       return encoded_len;
     }
 
     void Reset() override { next_value_ = 1; }
 
     size_t Channels() const override { return 1; }
@@ skipping 70 matching lines @@
 
   // Create a mock decoder object.
   MockAudioDecoder mock_decoder;
   EXPECT_CALL(mock_decoder, Reset()).WillRepeatedly(Return());
   EXPECT_CALL(mock_decoder, Channels()).WillRepeatedly(Return(1));
   EXPECT_CALL(mock_decoder, IncomingPacket(_, kPayloadLengthBytes, _, _, _))
       .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,
+  EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(0), kPayloadLengthBytes,
+                                           kSampleRateHz, _, _))
+      .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
                                           dummy_output + kPayloadLengthSamples),
-                      SetArgPointee<5>(AudioDecoder::kSpeech),
+                      SetArgPointee<4>(AudioDecoder::kSpeech),
                       Return(kPayloadLengthSamples)));
   EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
                             &mock_decoder, NetEqDecoder::kDecoderPCM16B,
                             kPayloadType, kSampleRateHz));
 
   // Insert one packet.
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
 
   // Pull audio once.
@@ skipping 18 matching lines @@
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
   rtp_header.header.sequenceNumber += 2;
   rtp_header.header.timestamp += 2 * kPayloadLengthSamples;
   payload[0] = 2;
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
 
   // Expect only the second packet to be decoded (the one with "2" as the first
   // payload byte).
-  EXPECT_CALL(mock_decoder,
-              Decode(Pointee(2), kPayloadLengthBytes, kSampleRateHz, _, _, _))
-      .WillOnce(DoAll(SetArrayArgument<4>(dummy_output,
+  EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(2), kPayloadLengthBytes,
+                                           kSampleRateHz, _, _))
+      .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
                                           dummy_output + kPayloadLengthSamples),
-                      SetArgPointee<5>(AudioDecoder::kSpeech),
+                      SetArgPointee<4>(AudioDecoder::kSpeech),
                       Return(kPayloadLengthSamples)));
 
   // Pull audio once.
   EXPECT_EQ(
       NetEq::kOK,
       neteq_->GetAudio(
           kMaxOutputSize, output, &samples_per_channel, &num_channels, &type));
   ASSERT_EQ(kMaxOutputSize, samples_per_channel);
   EXPECT_EQ(1, num_channels);
   EXPECT_EQ(kOutputNormal, type);
@@ skipping 93 matching lines @@
 
   // Create a mock decoder object.
   MockAudioDecoder mock_decoder;
   EXPECT_CALL(mock_decoder, Reset()).WillRepeatedly(Return());
   EXPECT_CALL(mock_decoder, Channels()).WillRepeatedly(Return(1));
   EXPECT_CALL(mock_decoder, IncomingPacket(_, kPayloadLengthBytes, _, _, _))
       .WillRepeatedly(Return(0));
 
   // Pointee(x) verifies that first byte of the payload equals x, this makes it
   // possible to verify that the correct payload is fed to Decode().
-  EXPECT_CALL(mock_decoder, Decode(Pointee(0), kPayloadLengthBytes,
-                                   kSampleRateKhz * 1000, _, _, _))
-      .WillOnce(DoAll(SetArrayArgument<4>(dummy_output,
+  EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(0), kPayloadLengthBytes,
+                                           kSampleRateKhz * 1000, _, _))
+      .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
                                           dummy_output + kPayloadLengthSamples),
-                      SetArgPointee<5>(AudioDecoder::kSpeech),
+                      SetArgPointee<4>(AudioDecoder::kSpeech),
                       Return(kPayloadLengthSamples)));
 
-  EXPECT_CALL(mock_decoder, Decode(Pointee(1), kPayloadLengthBytes,
-                                   kSampleRateKhz * 1000, _, _, _))
-      .WillOnce(DoAll(SetArrayArgument<4>(dummy_output,
+  EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(1), kPayloadLengthBytes,
+                                           kSampleRateKhz * 1000, _, _))
+      .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
                                           dummy_output + kPayloadLengthSamples),
-                      SetArgPointee<5>(AudioDecoder::kComfortNoise),
+                      SetArgPointee<4>(AudioDecoder::kComfortNoise),
                       Return(kPayloadLengthSamples)));
 
-  EXPECT_CALL(mock_decoder, Decode(IsNull(), 0, kSampleRateKhz * 1000, _, _, _))
-      .WillOnce(DoAll(SetArrayArgument<4>(dummy_output,
+  EXPECT_CALL(mock_decoder,
+              DecodeInternal(IsNull(), 0, kSampleRateKhz * 1000, _, _))
+      .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
                                           dummy_output + kPayloadLengthSamples),
-                      SetArgPointee<5>(AudioDecoder::kComfortNoise),
+                      SetArgPointee<4>(AudioDecoder::kComfortNoise),
                       Return(kPayloadLengthSamples)));
 
-  EXPECT_CALL(mock_decoder, Decode(Pointee(2), kPayloadLengthBytes,
-                                   kSampleRateKhz * 1000, _, _, _))
-      .WillOnce(DoAll(SetArrayArgument<4>(dummy_output,
+  EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(2), kPayloadLengthBytes,
+                                           kSampleRateKhz * 1000, _, _))
+      .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
                                           dummy_output + kPayloadLengthSamples),
-                      SetArgPointee<5>(AudioDecoder::kSpeech),
+                      SetArgPointee<4>(AudioDecoder::kSpeech),
                       Return(kPayloadLengthSamples)));
 
   EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
                             &mock_decoder, NetEqDecoder::kDecoderOpus,
                             kPayloadType, kSampleRateKhz * 1000));
 
   // Insert one packet (decoder will return speech).
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
 
@@ skipping 227 matching lines @@
   EXPECT_CALL(mock_decoder, Channels()).WillRepeatedly(Return(1));
   EXPECT_CALL(mock_decoder, IncomingPacket(_, kPayloadLengthBytes, _, _, _))
       .WillRepeatedly(Return(0));
   EXPECT_CALL(mock_decoder, PacketDuration(_, _))
       .WillRepeatedly(Return(kPayloadLengthSamples));
   int16_t dummy_output[kPayloadLengthSamples] = {0};
   // 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, _, _, _))
+              DecodeInternal(_, kPayloadLengthBytes, kSampleRateHz, _, _))
       .WillOnce(
-          DoAll(SetArrayArgument<4>(dummy_output,
+          DoAll(SetArrayArgument<3>(dummy_output,
                                     dummy_output + kPayloadLengthSamples - 5),
-                SetArgPointee<5>(AudioDecoder::kSpeech),
+                SetArgPointee<4>(AudioDecoder::kSpeech),
                 Return(kPayloadLengthSamples - 5)));
   EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
                             &mock_decoder, NetEqDecoder::kDecoderPCM16B,
                             kPayloadType, kSampleRateHz));
 
   // Insert one packet.
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
 
   EXPECT_EQ(5u, neteq_->sync_buffer_for_test()->FutureLength());
@@ skipping 49 matching lines @@
   EXPECT_CALL(mock_decoder, ErrorCode())
       .WillOnce(Return(kDecoderErrorCode));
   EXPECT_CALL(mock_decoder, HasDecodePlc())
       .WillOnce(Return(false));
   int16_t dummy_output[kFrameLengthSamples] = {0};
 
   {
     InSequence sequence;  // Dummy variable.
     // Mock decoder works normally the first time.
     EXPECT_CALL(mock_decoder,
-                Decode(_, kPayloadLengthBytes, kSampleRateHz, _, _, _))
+                DecodeInternal(_, kPayloadLengthBytes, kSampleRateHz, _, _))
         .Times(3)
         .WillRepeatedly(
-            DoAll(SetArrayArgument<4>(dummy_output,
+            DoAll(SetArrayArgument<3>(dummy_output,
                                       dummy_output + kFrameLengthSamples),
-                  SetArgPointee<5>(AudioDecoder::kSpeech),
+                  SetArgPointee<4>(AudioDecoder::kSpeech),
                   Return(kFrameLengthSamples)))
         .RetiresOnSaturation();
 
     // Then mock decoder fails. A common reason for failure can be buffer being
     // too short
     EXPECT_CALL(mock_decoder,
-                Decode(_, kPayloadLengthBytes, kSampleRateHz, _, _, _))
+                DecodeInternal(_, kPayloadLengthBytes, kSampleRateHz, _, _))
         .WillOnce(Return(-1))
         .RetiresOnSaturation();
 
     // Mock decoder finally returns to normal.
     EXPECT_CALL(mock_decoder,
-                Decode(_, kPayloadLengthBytes, kSampleRateHz, _, _, _))
+                DecodeInternal(_, kPayloadLengthBytes, kSampleRateHz, _, _))
         .Times(2)
         .WillRepeatedly(
-            DoAll(SetArrayArgument<4>(dummy_output,
-                                  dummy_output + kFrameLengthSamples),
-                  SetArgPointee<5>(AudioDecoder::kSpeech),
+            DoAll(SetArrayArgument<3>(dummy_output,
+                                      dummy_output + kFrameLengthSamples),
+                  SetArgPointee<4>(AudioDecoder::kSpeech),
                   Return(kFrameLengthSamples)));
   }
 
   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;
@@ skipping 79 matching lines @@
   EXPECT_CALL(mock_decoder, PacketDuration(_, _))
       .WillRepeatedly(Return(kFrameLengthSamples));
   EXPECT_CALL(mock_decoder, ErrorCode())
       .WillOnce(Return(kDecoderErrorCode));
   int16_t dummy_output[kFrameLengthSamples] = {0};
 
   {
     InSequence sequence;  // Dummy variable.
     // Mock decoder works normally the first 2 times.
     EXPECT_CALL(mock_decoder,
-                Decode(_, kPayloadLengthBytes, kSampleRateHz, _, _, _))
+                DecodeInternal(_, kPayloadLengthBytes, kSampleRateHz, _, _))
         .Times(2)
         .WillRepeatedly(
-            DoAll(SetArrayArgument<4>(dummy_output,
+            DoAll(SetArrayArgument<3>(dummy_output,
                                       dummy_output + kFrameLengthSamples),
-                  SetArgPointee<5>(AudioDecoder::kComfortNoise),
+                  SetArgPointee<4>(AudioDecoder::kComfortNoise),
                   Return(kFrameLengthSamples)))
         .RetiresOnSaturation();
 
     // Then mock decoder fails. A common reason for failure can be buffer being
     // too short
-    EXPECT_CALL(mock_decoder, Decode(nullptr, 0, kSampleRateHz, _, _, _))
+    EXPECT_CALL(mock_decoder, DecodeInternal(nullptr, 0, kSampleRateHz, _, _))
         .WillOnce(Return(-1))
         .RetiresOnSaturation();
 
     // Mock decoder finally returns to normal.
-    EXPECT_CALL(mock_decoder, Decode(nullptr, 0, kSampleRateHz, _, _, _))
+    EXPECT_CALL(mock_decoder, DecodeInternal(nullptr, 0, kSampleRateHz, _, _))
         .Times(2)
         .WillRepeatedly(
-            DoAll(SetArrayArgument<4>(dummy_output,
-                                  dummy_output + kFrameLengthSamples),
-                  SetArgPointee<5>(AudioDecoder::kComfortNoise),
+            DoAll(SetArrayArgument<3>(dummy_output,
+                                      dummy_output + kFrameLengthSamples),
+                  SetArgPointee<4>(AudioDecoder::kComfortNoise),
                   Return(kFrameLengthSamples)));
   }
 
   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;
@@ skipping 41 matching lines @@
 // Tests that the return value from last_output_sample_rate_hz() is equal to the
 // configured inital sample rate.
 TEST_F(NetEqImplTest, InitialLastOutputSampleRate) {
   UseNoMocks();
   config_.sample_rate_hz = 48000;
   CreateInstance();
   EXPECT_EQ(48000, neteq_->last_output_sample_rate_hz());
 }
 
 }// namespace webrtc