1 /*
2  *  Copyright (c) 2011 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 "utility.h"
12 
13 #include <assert.h>
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <string.h>
17 
18 #include "common_types.h"  // NOLINT(build/include)
19 #include "modules/audio_coding/include/audio_coding_module.h"
20 #include "test/gtest.h"
21 
22 #define NUM_CODECS_WITH_FIXED_PAYLOAD_TYPE 13
23 
24 namespace webrtc {
25 
ACMTestTimer()26 ACMTestTimer::ACMTestTimer()
27     : _msec(0),
28       _sec(0),
29       _min(0),
30       _hour(0) {
31   return;
32 }
33 
~ACMTestTimer()34 ACMTestTimer::~ACMTestTimer() {
35   return;
36 }
37 
Reset()38 void ACMTestTimer::Reset() {
39   _msec = 0;
40   _sec = 0;
41   _min = 0;
42   _hour = 0;
43   return;
44 }
Tick10ms()45 void ACMTestTimer::Tick10ms() {
46   _msec += 10;
47   Adjust();
48   return;
49 }
50 
Tick1ms()51 void ACMTestTimer::Tick1ms() {
52   _msec++;
53   Adjust();
54   return;
55 }
56 
Tick100ms()57 void ACMTestTimer::Tick100ms() {
58   _msec += 100;
59   Adjust();
60   return;
61 }
62 
Tick1sec()63 void ACMTestTimer::Tick1sec() {
64   _sec++;
65   Adjust();
66   return;
67 }
68 
CurrentTimeHMS(char * currTime)69 void ACMTestTimer::CurrentTimeHMS(char* currTime) {
70   sprintf(currTime, "%4lu:%02u:%06.3f", _hour, _min,
71           (double) _sec + (double) _msec / 1000.);
72   return;
73 }
74 
CurrentTime(unsigned long & h,unsigned char & m,unsigned char & s,unsigned short & ms)75 void ACMTestTimer::CurrentTime(unsigned long& h, unsigned char& m,
76                                unsigned char& s, unsigned short& ms) {
77   h = _hour;
78   m = _min;
79   s = _sec;
80   ms = _msec;
81   return;
82 }
83 
Adjust()84 void ACMTestTimer::Adjust() {
85   unsigned int n;
86   if (_msec >= 1000) {
87     n = _msec / 1000;
88     _msec -= (1000 * n);
89     _sec += n;
90   }
91   if (_sec >= 60) {
92     n = _sec / 60;
93     _sec -= (n * 60);
94     _min += n;
95   }
96   if (_min >= 60) {
97     n = _min / 60;
98     _min -= (n * 60);
99     _hour += n;
100   }
101 }
102 
ChooseCodec(CodecInst & codecInst)103 int16_t ChooseCodec(CodecInst& codecInst) {
104 
105   PrintCodecs();
106   //AudioCodingModule* tmpACM = AudioCodingModule::Create(0);
107   uint8_t noCodec = AudioCodingModule::NumberOfCodecs();
108   int8_t codecID;
109   bool outOfRange = false;
110   char myStr[15] = "";
111   do {
112     printf("\nChoose a codec [0]: ");
113     EXPECT_TRUE(fgets(myStr, 10, stdin) != NULL);
114     codecID = atoi(myStr);
115     if ((codecID < 0) || (codecID >= noCodec)) {
116       printf("\nOut of range.\n");
117       outOfRange = true;
118     }
119   } while (outOfRange);
120 
121   CHECK_ERROR(AudioCodingModule::Codec((uint8_t )codecID, &codecInst));
122   return 0;
123 }
124 
PrintCodecs()125 void PrintCodecs() {
126   uint8_t noCodec = AudioCodingModule::NumberOfCodecs();
127 
128   CodecInst codecInst;
129   printf("No  Name                [Hz]    [bps]\n");
130   for (uint8_t codecCntr = 0; codecCntr < noCodec; codecCntr++) {
131     AudioCodingModule::Codec(codecCntr, &codecInst);
132     printf("%2d- %-18s %5d   %6d\n", codecCntr, codecInst.plname,
133            codecInst.plfreq, codecInst.rate);
134   }
135 
136 }
137 
138 namespace test {
139 
CircularBuffer(uint32_t len)140 CircularBuffer::CircularBuffer(uint32_t len)
141     : _buff(NULL),
142       _idx(0),
143       _buffIsFull(false),
144       _calcAvg(false),
145       _calcVar(false),
146       _sum(0),
147       _sumSqr(0) {
148   _buff = new double[len];
149   if (_buff == NULL) {
150     _buffLen = 0;
151   } else {
152     for (uint32_t n = 0; n < len; n++) {
153       _buff[n] = 0;
154     }
155     _buffLen = len;
156   }
157 }
158 
~CircularBuffer()159 CircularBuffer::~CircularBuffer() {
160   if (_buff != NULL) {
161     delete[] _buff;
162     _buff = NULL;
163   }
164 }
165 
Update(const double newVal)166 void CircularBuffer::Update(const double newVal) {
167   assert(_buffLen > 0);
168 
169   // store the value that is going to be overwritten
170   double oldVal = _buff[_idx];
171   // record the new value
172   _buff[_idx] = newVal;
173   // increment the index, to point to where we would
174   // write next
175   _idx++;
176   // it is a circular buffer, if we are at the end
177   // we have to cycle to the beginning
178   if (_idx >= _buffLen) {
179     // flag that the buffer is filled up.
180     _buffIsFull = true;
181     _idx = 0;
182   }
183 
184   // Update
185 
186   if (_calcAvg) {
187     // for the average we have to update
188     // the sum
189     _sum += (newVal - oldVal);
190   }
191 
192   if (_calcVar) {
193     // to calculate variance we have to update
194     // the sum of squares
195     _sumSqr += (double) (newVal - oldVal) * (double) (newVal + oldVal);
196   }
197 }
198 
SetArithMean(bool enable)199 void CircularBuffer::SetArithMean(bool enable) {
200   assert(_buffLen > 0);
201 
202   if (enable && !_calcAvg) {
203     uint32_t lim;
204     if (_buffIsFull) {
205       lim = _buffLen;
206     } else {
207       lim = _idx;
208     }
209     _sum = 0;
210     for (uint32_t n = 0; n < lim; n++) {
211       _sum += _buff[n];
212     }
213   }
214   _calcAvg = enable;
215 }
216 
SetVariance(bool enable)217 void CircularBuffer::SetVariance(bool enable) {
218   assert(_buffLen > 0);
219 
220   if (enable && !_calcVar) {
221     uint32_t lim;
222     if (_buffIsFull) {
223       lim = _buffLen;
224     } else {
225       lim = _idx;
226     }
227     _sumSqr = 0;
228     for (uint32_t n = 0; n < lim; n++) {
229       _sumSqr += _buff[n] * _buff[n];
230     }
231   }
232   _calcAvg = enable;
233 }
234 
ArithMean(double & mean)235 int16_t CircularBuffer::ArithMean(double& mean) {
236   assert(_buffLen > 0);
237 
238   if (_buffIsFull) {
239 
240     mean = _sum / (double) _buffLen;
241     return 0;
242   } else {
243     if (_idx > 0) {
244       mean = _sum / (double) _idx;
245       return 0;
246     } else {
247       return -1;
248     }
249 
250   }
251 }
252 
Variance(double & var)253 int16_t CircularBuffer::Variance(double& var) {
254   assert(_buffLen > 0);
255 
256   if (_buffIsFull) {
257     var = _sumSqr / (double) _buffLen;
258     return 0;
259   } else {
260     if (_idx > 0) {
261       var = _sumSqr / (double) _idx;
262       return 0;
263     } else {
264       return -1;
265     }
266   }
267 }
268 
269 }  // namespace test
270 
FixedPayloadTypeCodec(const char * payloadName)271 bool FixedPayloadTypeCodec(const char* payloadName) {
272   char fixPayloadTypeCodecs[NUM_CODECS_WITH_FIXED_PAYLOAD_TYPE][32] = { "PCMU",
273       "PCMA", "GSM", "G723", "DVI4", "LPC", "PCMA", "G722", "QCELP", "CN",
274       "MPA", "G728", "G729" };
275 
276   for (int n = 0; n < NUM_CODECS_WITH_FIXED_PAYLOAD_TYPE; n++) {
277     if (!STR_CASE_CMP(payloadName, fixPayloadTypeCodecs[n])) {
278       return true;
279     }
280   }
281   return false;
282 }
283 
Reset()284 void VADCallback::Reset() {
285   memset(_numFrameTypes, 0, sizeof(_numFrameTypes));
286 }
287 
VADCallback()288 VADCallback::VADCallback() {
289   memset(_numFrameTypes, 0, sizeof(_numFrameTypes));
290 }
291 
PrintFrameTypes()292 void VADCallback::PrintFrameTypes() {
293   printf("kEmptyFrame......... %d\n", _numFrameTypes[kEmptyFrame]);
294   printf("kAudioFrameSpeech... %d\n", _numFrameTypes[kAudioFrameSpeech]);
295   printf("kAudioFrameCN....... %d\n", _numFrameTypes[kAudioFrameCN]);
296   printf("kVideoFrameKey...... %d\n", _numFrameTypes[kVideoFrameKey]);
297   printf("kVideoFrameDelta.... %d\n", _numFrameTypes[kVideoFrameDelta]);
298 }
299 
InFrameType(FrameType frame_type)300 int32_t VADCallback::InFrameType(FrameType frame_type) {
301   _numFrameTypes[frame_type]++;
302   return 0;
303 }
304 
305 }  // namespace webrtc
306