Reenables several NetEq unittests on android.

webrtc/modules/audio_coding/neteq/neteq_unittest.cc

 /*
  *  Copyright (c) 2011 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 394 matching lines @@
 void NetEqDecodingTest::OpenInputFile(const std::string &rtp_file) {
   rtp_source_.reset(test::RtpFileSource::Create(rtp_file));
 }
 
 void NetEqDecodingTest::Process(size_t* out_len) {
   // Check if time to receive.
   while (packet_ && sim_clock_ >= packet_->time_ms()) {
     if (packet_->payload_length_bytes() > 0) {
       WebRtcRTPHeader rtp_header;
       packet_->ConvertHeader(&rtp_header);
+#ifndef WEBRTC_CODEC_ISAC
+      // Ignore payload type 104 (iSAC-swb) if ISAC is not supported.
+      if (rtp_header.header.payloadType != 104)
+#endif
       ASSERT_EQ(0, neteq_->InsertPacket(
                        rtp_header,
                        rtc::ArrayView<const uint8_t>(
                            packet_->payload(), packet_->payload_length_bytes()),
                        static_cast<uint32_t>(packet_->time_ms() *
                                              (output_sample_rate_ / 1000))));
     }
     // Get next packet.
     packet_.reset(rtp_source_->NextPacket());
   }
@@ skipping 83 matching lines @@
                                     size_t* payload_len) {
   rtp_info->header.sequenceNumber = frame_index;
   rtp_info->header.timestamp = timestamp;
   rtp_info->header.ssrc = 0x1234;  // Just an arbitrary SSRC.
   rtp_info->header.payloadType = 98;  // WB CNG.
   rtp_info->header.markerBit = 0;
   payload[0] = 64;  // Noise level -64 dBov, quite arbitrarily chosen.
   *payload_len = 1;  // Only noise level, no spectral parameters.
 }
 
-#if !defined(WEBRTC_IOS) && !defined(WEBRTC_ANDROID) &&             \
-    defined(WEBRTC_NETEQ_UNITTEST_BITEXACT) &&                      \
-    (defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)) && \
-    defined(WEBRTC_CODEC_ILBC) && defined(WEBRTC_CODEC_G722)
+#if !defined(WEBRTC_IOS) && defined(WEBRTC_NETEQ_UNITTEST_BITEXACT) && \
+    (defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)) &&    \
+    defined(WEBRTC_CODEC_ILBC) && defined(WEBRTC_CODEC_G722) &&        \
+    !defined(WEBRTC_ARCH_ARM64)
 #define MAYBE_TestBitExactness TestBitExactness
 #else
 #define MAYBE_TestBitExactness DISABLED_TestBitExactness
 #endif
 TEST_F(NetEqDecodingTest, MAYBE_TestBitExactness) {
   const std::string input_rtp_file =
       webrtc::test::ResourcePath("audio_coding/neteq_universal_new", "rtp");
   // Note that neteq4_universal_ref.pcm and neteq4_universal_ref_win_32.pcm
   // are identical. The latter could have been removed, but if clients still
   // have a copy of the file, the test will fail.
@@ skipping 390 matching lines @@
 TEST_F(NetEqDecodingTest, UnknownPayloadType) {
   const size_t kPayloadBytes = 100;
   uint8_t payload[kPayloadBytes] = {0};
   WebRtcRTPHeader rtp_info;
   PopulateRtpInfo(0, 0, &rtp_info);
   rtp_info.header.payloadType = 1;  // Not registered as a decoder.
   EXPECT_EQ(NetEq::kFail, neteq_->InsertPacket(rtp_info, payload, 0));
   EXPECT_EQ(NetEq::kUnknownRtpPayloadType, neteq_->LastError());
 }
 
-#if defined(WEBRTC_ANDROID)
+#if defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)
+#define MAYBE_DecoderError DecoderError
+#else
 #define MAYBE_DecoderError DISABLED_DecoderError
-#else
-#define MAYBE_DecoderError DecoderError
 #endif
-#if defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)
+
 TEST_F(NetEqDecodingTest, MAYBE_DecoderError) {
   const size_t kPayloadBytes = 100;
   uint8_t payload[kPayloadBytes] = {0};
   WebRtcRTPHeader rtp_info;
   PopulateRtpInfo(0, 0, &rtp_info);
   rtp_info.header.payloadType = 103;  // iSAC, but the payload is invalid.
   EXPECT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
   NetEqOutputType type;
   // Set all of |out_data_| to 1, and verify that it was set to 0 by the call
   // to GetAudio.
   for (size_t i = 0; i < kMaxBlockSize; ++i) {
     out_data_[i] = 1;
   }
   size_t num_channels;
   size_t samples_per_channel;
   EXPECT_EQ(NetEq::kFail,
             neteq_->GetAudio(kMaxBlockSize, out_data_,
                              &samples_per_channel, &num_channels, &type));
   // Verify that there is a decoder error to check.
   EXPECT_EQ(NetEq::kDecoderErrorCode, neteq_->LastError());
-  // Code 6730 is an iSAC error code.
-  EXPECT_EQ(6730, neteq_->LastDecoderError());
+
+  enum NetEqDecoderError {
+    ISAC_LENGTH_MISMATCH = 6730,
+    ISAC_RANGE_ERROR_DECODE_FRAME_LENGTH = 6640
+  };
+#if defined(WEBRTC_CODEC_ISAC)
+  EXPECT_EQ(ISAC_LENGTH_MISMATCH, neteq_->LastDecoderError());
+#elif defined(WEBRTC_CODEC_ISACFX)
+  EXPECT_EQ(ISAC_RANGE_ERROR_DECODE_FRAME_LENGTH, neteq_->LastDecoderError());
+#endif
   // Verify that the first 160 samples are set to 0, and that the remaining
   // samples are left unmodified.
   static const int kExpectedOutputLength = 160;  // 10 ms at 16 kHz sample rate.
   for (int i = 0; i < kExpectedOutputLength; ++i) {
     std::ostringstream ss;
     ss << "i = " << i;
     SCOPED_TRACE(ss.str());  // Print out the parameter values on failure.
     EXPECT_EQ(0, out_data_[i]);
   }
   for (size_t i = kExpectedOutputLength; i < kMaxBlockSize; ++i) {
     std::ostringstream ss;
     ss << "i = " << i;
     SCOPED_TRACE(ss.str());  // Print out the parameter values on failure.
     EXPECT_EQ(1, out_data_[i]);
   }
 }
-#endif
 
 TEST_F(NetEqDecodingTest, GetAudioBeforeInsertPacket) {
   NetEqOutputType type;
   // Set all of |out_data_| to 1, and verify that it was set to 0 by the call
   // to GetAudio.
   for (size_t i = 0; i < kMaxBlockSize; ++i) {
     out_data_[i] = 1;
   }
   size_t num_channels;
   size_t samples_per_channel;
@@ skipping 178 matching lines @@
   CheckBgn(32000);
 }
 
 TEST_F(NetEqBgnTestFade, RunTest) {
   CheckBgn(8000);
   CheckBgn(16000);
   CheckBgn(32000);
 }
 
 #if defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)
-TEST_F(NetEqDecodingTest, SyncPacketInsert) {
+#define MAYBE_SyncPacketInsert SyncPacketInsert
+#else
+#define MAYBE_SyncPacketInsert DISABLED_SyncPacketInsert
+#endif
+TEST_F(NetEqDecodingTest, MAYBE_SyncPacketInsert) {
   WebRtcRTPHeader rtp_info;
   uint32_t receive_timestamp = 0;
   // For the readability use the following payloads instead of the defaults of
   // this test.
   uint8_t kPcm16WbPayloadType = 1;
   uint8_t kCngNbPayloadType = 2;
   uint8_t kCngWbPayloadType = 3;
   uint8_t kCngSwb32PayloadType = 4;
   uint8_t kCngSwb48PayloadType = 5;
   uint8_t kAvtPayloadType = 6;
@@ skipping 58 matching lines @@
   EXPECT_EQ(-1, neteq_->InsertSyncPacket(rtp_info, receive_timestamp));
 
   // Change of SSRC is not allowed with a sync packet.
   rtp_info.header.payloadType = kPcm16WbPayloadType;
   ++rtp_info.header.ssrc;
   EXPECT_EQ(-1, neteq_->InsertSyncPacket(rtp_info, receive_timestamp));
 
   --rtp_info.header.ssrc;
   EXPECT_EQ(0, neteq_->InsertSyncPacket(rtp_info, receive_timestamp));
 }
-#endif
 
 // First insert several noise like packets, then sync-packets. Decoding all
 // packets should not produce error, statistics should not show any packet loss
 // and sync-packets should decode to zero.
 // TODO(turajs) we will have a better test if we have a referece NetEq, and
 // when Sync packets are inserted in "test" NetEq we insert all-zero payload
 // in reference NetEq and compare the output of those two.
 TEST_F(NetEqDecodingTest, SyncPacketDecode) {
   WebRtcRTPHeader rtp_info;
   PopulateRtpInfo(0, 0, &rtp_info);
@@ skipping 374 matching lines @@
     // Pull audio once.
     ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                   &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
   }
   // Verify speech output.
   EXPECT_EQ(kOutputNormal, type);
 }
 
 }  // namespace webrtc