1/*
2 *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10
11#include "webrtc/common_audio/vad/vad_unittest.h"
12
13#include <stdlib.h>
14
15#include "testing/gtest/include/gtest/gtest.h"
16
17#include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
18#include "webrtc/common_audio/vad/include/webrtc_vad.h"
19#include "webrtc/typedefs.h"
20
21VadTest::VadTest() {}
22
23void VadTest::SetUp() {}
24
25void VadTest::TearDown() {}
26
27// Returns true if the rate and frame length combination is valid.
28bool VadTest::ValidRatesAndFrameLengths(int rate, int frame_length) {
29  if (rate == 8000) {
30    if (frame_length == 80 || frame_length == 160 || frame_length == 240) {
31      return true;
32    }
33    return false;
34  } else if (rate == 16000) {
35    if (frame_length == 160 || frame_length == 320 || frame_length == 480) {
36      return true;
37    }
38    return false;
39  } else if (rate == 32000) {
40    if (frame_length == 320 || frame_length == 640 || frame_length == 960) {
41      return true;
42    }
43    return false;
44  } else if (rate == 48000) {
45    if (frame_length == 480 || frame_length == 960 || frame_length == 1440) {
46      return true;
47    }
48    return false;
49  }
50
51  return false;
52}
53
54namespace {
55
56TEST_F(VadTest, ApiTest) {
57  // This API test runs through the APIs for all possible valid and invalid
58  // combinations.
59
60  VadInst* handle = NULL;
61  int16_t zeros[kMaxFrameLength] = { 0 };
62
63  // Construct a speech signal that will trigger the VAD in all modes. It is
64  // known that (i * i) will wrap around, but that doesn't matter in this case.
65  int16_t speech[kMaxFrameLength];
66  for (int16_t i = 0; i < kMaxFrameLength; i++) {
67    speech[i] = (i * i);
68  }
69
70  // NULL instance tests
71  EXPECT_EQ(-1, WebRtcVad_Create(NULL));
72  EXPECT_EQ(-1, WebRtcVad_Init(NULL));
73  EXPECT_EQ(-1, WebRtcVad_set_mode(NULL, kModes[0]));
74  EXPECT_EQ(-1, WebRtcVad_Process(NULL, kRates[0], speech, kFrameLengths[0]));
75
76  // WebRtcVad_Create()
77  ASSERT_EQ(0, WebRtcVad_Create(&handle));
78
79  // Not initialized tests
80  EXPECT_EQ(-1, WebRtcVad_Process(handle, kRates[0], speech, kFrameLengths[0]));
81  EXPECT_EQ(-1, WebRtcVad_set_mode(handle, kModes[0]));
82
83  // WebRtcVad_Init() test
84  ASSERT_EQ(0, WebRtcVad_Init(handle));
85
86  // WebRtcVad_set_mode() invalid modes tests. Tries smallest supported value
87  // minus one and largest supported value plus one.
88  EXPECT_EQ(-1, WebRtcVad_set_mode(handle,
89                                   WebRtcSpl_MinValueW32(kModes,
90                                                         kModesSize) - 1));
91  EXPECT_EQ(-1, WebRtcVad_set_mode(handle,
92                                   WebRtcSpl_MaxValueW32(kModes,
93                                                         kModesSize) + 1));
94
95  // WebRtcVad_Process() tests
96  // NULL speech pointer
97  EXPECT_EQ(-1, WebRtcVad_Process(handle, kRates[0], NULL, kFrameLengths[0]));
98  // Invalid sampling rate
99  EXPECT_EQ(-1, WebRtcVad_Process(handle, 9999, speech, kFrameLengths[0]));
100  // All zeros as input should work
101  EXPECT_EQ(0, WebRtcVad_Process(handle, kRates[0], zeros, kFrameLengths[0]));
102  for (size_t k = 0; k < kModesSize; k++) {
103    // Test valid modes
104    EXPECT_EQ(0, WebRtcVad_set_mode(handle, kModes[k]));
105    // Loop through sampling rate and frame length combinations
106    for (size_t i = 0; i < kRatesSize; i++) {
107      for (size_t j = 0; j < kFrameLengthsSize; j++) {
108        if (ValidRatesAndFrameLengths(kRates[i], kFrameLengths[j])) {
109          EXPECT_EQ(1, WebRtcVad_Process(handle,
110                                         kRates[i],
111                                         speech,
112                                         kFrameLengths[j]));
113        } else {
114          EXPECT_EQ(-1, WebRtcVad_Process(handle,
115                                          kRates[i],
116                                          speech,
117                                          kFrameLengths[j]));
118        }
119      }
120    }
121  }
122
123  WebRtcVad_Free(handle);
124}
125
126TEST_F(VadTest, ValidRatesFrameLengths) {
127  // This test verifies valid and invalid rate/frame_length combinations. We
128  // loop through some sampling rates and frame lengths from negative values to
129  // values larger than possible.
130  const int kNumRates = 12;
131  const int kRates[kNumRates] = {
132    -8000, -4000, 0, 4000, 8000, 8001, 15999, 16000, 32000, 48000, 48001, 96000
133  };
134
135  const int kNumFrameLengths = 13;
136  const int kFrameLengths[kNumFrameLengths] = {
137    -10, 0, 80, 81, 159, 160, 240, 320, 480, 640, 960, 1440, 2000
138  };
139
140  for (int i = 0; i < kNumRates; i++) {
141    for (int j = 0; j < kNumFrameLengths; j++) {
142      if (ValidRatesAndFrameLengths(kRates[i], kFrameLengths[j])) {
143        EXPECT_EQ(0, WebRtcVad_ValidRateAndFrameLength(kRates[i],
144                                                       kFrameLengths[j]));
145      } else {
146        EXPECT_EQ(-1, WebRtcVad_ValidRateAndFrameLength(kRates[i],
147                                                        kFrameLengths[j]));
148      }
149    }
150  }
151}
152
153// TODO(bjornv): Add a process test, run on file.
154
155}  // namespace
156