-
Notifications
You must be signed in to change notification settings - Fork 59
/
encoder_test.go
393 lines (356 loc) · 9.69 KB
/
encoder_test.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
// Copyright © Go Opus Authors (see AUTHORS file)
//
// License for use of this code is detailed in the LICENSE file
package opus
import "testing"
func TestEncoderNew(t *testing.T) {
enc, err := NewEncoder(48000, 1, AppVoIP)
if err != nil || enc == nil {
t.Errorf("Error creating new encoder: %v", err)
}
enc, err = NewEncoder(12345, 1, AppVoIP)
if err == nil || enc != nil {
t.Errorf("Expected error for illegal samplerate 12345")
}
}
func TestEncoderUnitialized(t *testing.T) {
var enc Encoder
_, err := enc.Encode(nil, nil)
if err != errEncUninitialized {
t.Errorf("Expected \"unitialized encoder\" error: %v", err)
}
_, err = enc.EncodeFloat32(nil, nil)
if err != errEncUninitialized {
t.Errorf("Expected \"unitialized encoder\" error: %v", err)
}
}
func TestEncoderDTX(t *testing.T) {
enc, err := NewEncoder(8000, 1, AppVoIP)
if err != nil || enc == nil {
t.Errorf("Error creating new encoder: %v", err)
}
vals := []bool{true, false}
for _, dtx := range vals {
err := enc.SetDTX(dtx)
if err != nil {
t.Fatalf("Error setting DTX to %t: %v", dtx, err)
}
gotv, err := enc.DTX()
if err != nil {
t.Fatalf("Error getting DTX (%t): %v", dtx, err)
}
if gotv != dtx {
t.Errorf("Error set dtx: expect dtx=%v, got dtx=%v", dtx, gotv)
}
}
}
func TestEncoderInDTX(t *testing.T) {
// Create bogus input sound
const G4 = 391.995
const SAMPLE_RATE = 48000
const FRAME_SIZE_MS = 60
const FRAME_SIZE = SAMPLE_RATE * FRAME_SIZE_MS / 1000
pcm := make([]int16, FRAME_SIZE)
silentPCM := make([]int16, FRAME_SIZE)
out := make([]byte, FRAME_SIZE*4)
addSine(pcm, SAMPLE_RATE, G4)
vals := []bool{true, false}
for _, dtx := range vals {
enc, err := NewEncoder(SAMPLE_RATE, 1, AppVoIP)
if err != nil || enc == nil {
t.Fatalf("Error creating new encoder: %v", err)
}
enc.SetDTX(dtx)
if _, err = enc.Encode(pcm, out); err != nil {
t.Fatalf("Error encoding non-silent frame: %v", err)
}
gotDTX, err := enc.InDTX()
if err != nil {
t.Fatalf("Error getting in DTX (%t): %v", dtx, err)
}
if gotDTX {
t.Fatalf("Error get in dtx: expect in dtx=false, got=true")
}
// Encode a few frames to let DTX kick in
for i := 0; i < 5; i++ {
if _, err = enc.Encode(silentPCM, out); err != nil {
t.Fatalf("Error encoding silent frame: %v", err)
}
}
gotDTX, err = enc.InDTX()
if err != nil {
t.Fatalf("Error getting in DTX (%t): %v", dtx, err)
}
if gotDTX != dtx {
t.Errorf("Error set dtx: expect in dtx=%v, got in dtx=%v", dtx, gotDTX)
}
}
}
func TestEncoderSampleRate(t *testing.T) {
sample_rates := []int{8000, 12000, 16000, 24000, 48000}
for _, f := range sample_rates {
enc, err := NewEncoder(f, 1, AppVoIP)
if err != nil || enc == nil {
t.Fatalf("Error creating new encoder with sample_rate %d Hz: %v", f, err)
}
f2, err := enc.SampleRate()
if err != nil {
t.Fatalf("Error getting sample rate (%d Hz): %v", f, err)
}
if f != f2 {
t.Errorf("Unexpected sample rate reported by %d Hz encoder: %d", f, f2)
}
}
}
func TestEncoder_SetGetBitrate(t *testing.T) {
enc, err := NewEncoder(8000, 1, AppVoIP)
if err != nil || enc == nil {
t.Errorf("Error creating new encoder: %v", err)
}
vals := []int{500, 100000, 300000}
for _, bitrate := range vals {
err := enc.SetBitrate(bitrate)
if err != nil {
t.Error("Error set bitrate:", err)
}
br, err := enc.Bitrate()
if err != nil {
t.Error("Error getting bitrate", err)
}
if br != bitrate {
t.Errorf("Unexpected bitrate. Got %d, but expected %d", br, bitrate)
}
}
}
func TestEncoder_SetBitrateToAuto(t *testing.T) {
enc, err := NewEncoder(8000, 1, AppVoIP)
if err != nil || enc == nil {
t.Errorf("Error creating new encoder: %v", err)
}
bitrate := 5000
if err := enc.SetBitrate(bitrate); err != nil {
t.Error("Error setting bitrate:", err)
}
br, err := enc.Bitrate()
if err != nil {
t.Error("Error getting bitrate", err)
}
if br != bitrate {
t.Errorf("Unexpected bitrate. Got %d, but expected %d", br, bitrate)
}
err = enc.SetBitrateToAuto()
if err != nil {
t.Error("Error setting Auto bitrate:", err)
}
br, err = enc.Bitrate()
if err != nil {
t.Error("Error getting bitrate", err)
}
brDefault := 32000 //default start value
if br != brDefault {
t.Errorf("Unexpected bitrate. Got %d, but expected %d", br, brDefault)
}
}
func TestEncoder_SetBitrateToMax(t *testing.T) {
enc, err := NewEncoder(8000, 1, AppVoIP)
if err != nil || enc == nil {
t.Errorf("Error creating new encoder: %v", err)
}
bitrate := 5000
if err := enc.SetBitrate(bitrate); err != nil {
t.Error("Error setting bitrate:", err)
}
br, err := enc.Bitrate()
if err != nil {
t.Error("Error getting bitrate", err)
}
if br != bitrate {
t.Errorf("Unexpected bitrate. Got %d, but expected %d", br, bitrate)
}
err = enc.SetBitrateToMax()
if err != nil {
t.Error("Error setting Max bitrate:", err)
}
br, err = enc.Bitrate()
if err != nil {
t.Error("Error getting bitrate", err)
}
brMax := 4083200
if br != brMax { //default start value
t.Errorf("Unexpected bitrate. Got %d, but expected %d", br, brMax)
}
}
func TestEncoder_SetGetInvalidBitrate(t *testing.T) {
enc, err := NewEncoder(8000, 1, AppVoIP)
if err != nil || enc == nil {
t.Errorf("Error creating new encoder: %v", err)
}
invalidVals := []int{-20, 0}
for _, bitrate := range invalidVals {
err := enc.SetBitrate(bitrate)
if err == nil {
t.Errorf("Expected Error invalid bitrate: %d", bitrate)
}
br, err := enc.Bitrate()
if err != nil {
t.Error("Error getting bitrate", err)
}
// default bitrate is 32 kbit/s
if br != 32000 {
t.Errorf("Unexpected bitrate. Got %d, but expected %d", br, bitrate)
}
}
}
func TestEncoder_SetGetComplexity(t *testing.T) {
enc, err := NewEncoder(8000, 1, AppVoIP)
if err != nil || enc == nil {
t.Errorf("Error creating new encoder: %v", err)
}
vals := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
for _, complexity := range vals {
err := enc.SetComplexity(complexity)
if err != nil {
t.Error("Error setting complexity value:", err)
}
cpx, err := enc.Complexity()
if err != nil {
t.Error("Error getting complexity value", err)
}
if cpx != complexity {
t.Errorf("Unexpected encoder complexity value. Got %d, but expected %d",
cpx, complexity)
}
}
}
func TestEncoder_SetGetInvalidComplexity(t *testing.T) {
enc, err := NewEncoder(8000, 1, AppVoIP)
if err != nil || enc == nil {
t.Errorf("Error creating new encoder: %v", err)
}
invalidVals := []int{-20, 11, 1000}
for _, complexity := range invalidVals {
err := enc.SetComplexity(complexity)
if err == nil {
t.Errorf("Expected Error invalid complexity value: %d", complexity)
}
if err.Error() != "opus: invalid argument" {
t.Error("Unexpected Error message")
}
cpx, err := enc.Complexity()
if err != nil {
t.Error("Error getting complexity value", err)
}
// default complexity value is 9
if cpx != 9 {
t.Errorf("Unexpected complexity value. Got %d, but expected %d",
cpx, complexity)
}
}
}
func TestEncoder_SetGetMaxBandwidth(t *testing.T) {
enc, err := NewEncoder(8000, 1, AppVoIP)
if err != nil || enc == nil {
t.Errorf("Error creating new encoder: %v", err)
}
vals := []Bandwidth{
Narrowband,
Mediumband,
Wideband,
SuperWideband,
Fullband,
}
for _, maxBw := range vals {
err := enc.SetMaxBandwidth(maxBw)
if err != nil {
t.Error("Error setting max Bandwidth:", err)
}
maxBwRead, err := enc.MaxBandwidth()
if err != nil {
t.Error("Error getting max Bandwidth", err)
}
if maxBwRead != maxBw {
t.Errorf("Unexpected max Bandwidth value. Got %d, but expected %d",
maxBwRead, maxBw)
}
}
}
func TestEncoder_SetGetInBandFEC(t *testing.T) {
enc, err := NewEncoder(8000, 1, AppVoIP)
if err != nil || enc == nil {
t.Errorf("Error creating new encoder: %v", err)
}
if err := enc.SetInBandFEC(true); err != nil {
t.Error("Error setting fec:", err)
}
fec, err := enc.InBandFEC()
if err != nil {
t.Error("Error getting fec", err)
}
if !fec {
t.Errorf("Wrong fec value. Expected %t", true)
}
if err := enc.SetInBandFEC(false); err != nil {
t.Error("Error setting fec:", err)
}
fec, err = enc.InBandFEC()
if err != nil {
t.Error("Error getting fec", err)
}
if fec {
t.Errorf("Wrong fec value. Expected %t", false)
}
}
func TestEncoder_SetGetPacketLossPerc(t *testing.T) {
enc, err := NewEncoder(8000, 1, AppVoIP)
if err != nil || enc == nil {
t.Errorf("Error creating new encoder: %v", err)
}
vals := []int{0, 5, 10, 20}
for _, lossPerc := range vals {
err := enc.SetPacketLossPerc(lossPerc)
if err != nil {
t.Error("Error setting loss percentage value:", err)
}
lp, err := enc.PacketLossPerc()
if err != nil {
t.Error("Error getting loss percentage value", err)
}
if lp != lossPerc {
t.Errorf("Unexpected encoder loss percentage value. Got %d, but expected %d",
lp, lossPerc)
}
}
}
func TestEncoder_SetGetInvalidPacketLossPerc(t *testing.T) {
enc, err := NewEncoder(8000, 1, AppVoIP)
if err != nil || enc == nil {
t.Errorf("Error creating new encoder: %v", err)
}
vals := []int{-1, 101}
for _, lossPerc := range vals {
err := enc.SetPacketLossPerc(lossPerc)
if err == nil {
t.Errorf("Expected Error invalid loss percentage: %d", lossPerc)
}
lp, err := enc.PacketLossPerc()
if err != nil {
t.Error("Error getting loss percentage value", err)
}
// default packet loss percentage is 0
if lp != 0 {
t.Errorf("Unexpected encoder loss percentage value. Got %d, but expected %d",
lp, lossPerc)
}
}
}
func TestEncoder_Reset(t *testing.T) {
enc, err := NewEncoder(48000, 1, AppVoIP)
if err != nil || enc == nil {
t.Errorf("Error creating new encoder: %v", err)
}
RunTestCodec(t, enc)
if err := enc.Reset(); err != nil {
t.Errorf("Error reset encoder: %v", err)
}
RunTestCodec(t, enc)
}