This CL is to add Opus complexity knob and to test it.

As a by-product, a generic tool for testing and comparing the complexity of codecs is added, and new audio files are added to the resources.

Three complexity tests are included
1. Default Opus complexity
2. Opus complexity knob
3. Default iSAC complexity (to compare with Opus)

The complexity tests are only meant for development reasons
and not to be run at bots.

The .isolate file is only needed for the APK packaging and test execution on Android.

TEST=passes all trybots

BUG=
R=kjellander@webrtc.org, tina.legrand@webrtc.org, turaj@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/8969004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@5655 4adac7df-926f-26a2-2b94-8c16560cd09d

webrtc/modules/audio_coding/codecs/isac/fix/test/isac_speed_test.cc

@@ -0,0 +1,109 @@
+/*
+ *  Copyright (c) 2014 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.
+ */
+
+#include "webrtc/modules/audio_coding/codecs/isac/fix/interface/isacfix.h"
+#include "webrtc/modules/audio_coding/codecs/isac/fix/source/settings.h"
+#include "webrtc/modules/audio_coding/codecs/tools/audio_codec_speed_test.h"
+
+using ::std::tr1::make_tuple;
+using ::testing::ValuesIn;
+
+namespace webrtc {
+
+static const int kIsacBlockDurationMs = 30;
+static const int kIsacInputSamplingKhz = 16;
+static const int kIsacOutputSamplingKhz = 16;
+
+class IsacSpeedTest : public AudioCodecSpeedTest {
+ protected:
+  IsacSpeedTest();
+  virtual void SetUp() OVERRIDE;
+  virtual void TearDown() OVERRIDE;
+  virtual float EncodeABlock(int16_t* in_data, uint8_t* bit_stream,
+                             int max_bytes, int* encoded_bytes);
+  virtual float DecodeABlock(const uint8_t* bit_stream, int encoded_bytes,
+                             int16_t* out_data);
+  ISACFIX_MainStruct *ISACFIX_main_inst_;
+};
+
+IsacSpeedTest::IsacSpeedTest()
+    : AudioCodecSpeedTest(kIsacBlockDurationMs,
+                          kIsacInputSamplingKhz,
+                          kIsacOutputSamplingKhz),
+      ISACFIX_main_inst_(NULL) {
+}
+
+void IsacSpeedTest::SetUp() {
+  AudioCodecSpeedTest::SetUp();
+
+  // Check whether the allocated buffer for the bit stream is large enough.
+  EXPECT_GE(max_bytes_, STREAM_MAXW16_60MS);
+
+  // Create encoder memory.
+  EXPECT_EQ(0, WebRtcIsacfix_Create(&ISACFIX_main_inst_));
+  EXPECT_EQ(0, WebRtcIsacfix_EncoderInit(ISACFIX_main_inst_, 1));
+  EXPECT_EQ(0, WebRtcIsacfix_DecoderInit(ISACFIX_main_inst_));
+  // Set bitrate and block length.
+  EXPECT_EQ(0, WebRtcIsacfix_Control(ISACFIX_main_inst_, bit_rate_,
+                                     block_duration_ms_));
+}
+
+void IsacSpeedTest::TearDown() {
+  AudioCodecSpeedTest::TearDown();
+  // Free memory.
+  EXPECT_EQ(0, WebRtcIsacfix_Free(ISACFIX_main_inst_));
+}
+
+float IsacSpeedTest::EncodeABlock(int16_t* in_data, uint8_t* bit_stream,
+                                  int max_bytes, int* encoded_bytes) {
+  // ISAC takes 10 ms everycall
+  const int subblocks = block_duration_ms_ / 10;
+  const int subblock_length = 10 * input_sampling_khz_;
+  int value;
+
+  clock_t clocks = clock();
+  size_t pointer = 0;
+  for (int idx = 0; idx < subblocks; idx++, pointer += subblock_length) {
+    value = WebRtcIsacfix_Encode(ISACFIX_main_inst_, &in_data[pointer],
+                                 reinterpret_cast<int16_t*>(bit_stream));
+  }
+  clocks = clock() - clocks;
+  EXPECT_GT(value, 0);
+  assert(value <= max_bytes);
+  *encoded_bytes = value;
+  return 1000.0 * clocks / CLOCKS_PER_SEC;
+}
+
+float IsacSpeedTest::DecodeABlock(const uint8_t* bit_stream, int encoded_bytes,
+                                  int16_t* out_data) {
+  int value;
+  int16_t audio_type;
+  clock_t clocks = clock();
+  value = WebRtcIsacfix_Decode(ISACFIX_main_inst_,
+                               reinterpret_cast<const uint16_t*>(bit_stream),
+                               encoded_bytes, out_data, &audio_type);
+  clocks = clock() - clocks;
+  EXPECT_EQ(output_length_sample_, value);
+  return 1000.0 * clocks / CLOCKS_PER_SEC;
+}
+
+TEST_P(IsacSpeedTest, IsacEncodeDecodeTest) {
+  size_t kDurationSec = 400;  // Test audio length in second.
+  EncodeDecode(kDurationSec);
+}
+
+const coding_param param_set[] =
+    {make_tuple(1, 32000, string("audio_coding/speech_mono_16kHz"),
+                string("pcm"), true)};
+
+INSTANTIATE_TEST_CASE_P(AllTest, IsacSpeedTest,
+                        ValuesIn(param_set));
+
+}  // namespace webrtc